C++ प्रोग्राम: दोहरा समाकलन (Double Integration) की गणना

हमें चर x की निचली सीमा, चर x की ऊपरी सीमा, चर y की निचली सीमा, चर y की ऊपरी सीमा, x के लिए संबंधित चरण और y के लिए संबंधित चरण दिए गए हैं। कार्य दोहरा समाकलन उत्पन्न करना और परिणाम प्रदर्शित करना है।

उदाहरण

Input: steps for x = 1.2, steps for y = 0.54
       lower limit of x = 1.3, upper limit of x = 2.1
       lower limit of y = 1.0, upper limit for y = 2.1
Output: double integration is : 2.1

नीचे दिए गए प्रोग्राम में प्रयुक्त दृष्टिकोण:

• x और y की ऊपरी और निचली सीमा के मान इनपुट करें, साथ ही x और y के लिए चरण इनपुट करें
• x और y दोनों के लिए दोहरे समाकलन की गणना के लिए जिस विधि का उपयोग कर रहे हैं वह सिम्पसन 1/3 विधि है
• आगे बढ़ने से पहले निम्नलिखित तालिका उत्पन्न करें

• प्रत्येक पंक्ति पर सिम्पसन 1/3 नियम लागू करें पहले समाकलन के लिए और दोहरे समाकलन के लिए इसे दोहराएं
• परिणाम प्रिंट करें

एल्गोरिदम

Start
Step 1 → समाकलन के लिए घात की गणना के लिए फंक्शन घोषित करें
    float fun(float x, float y)
    return pow(pow(x, 4) + pow(y, 5), 0.5)

Step 2 → दोहरे समाकलन मान ज्ञात करने के लिए फंक्शन घोषित करें
    float doubleIntegral(float step_x, float step_y, float lower_x, float upper_x, float lower_y, float upper_y)
    int n1, n2 घोषित करें
    float arr[50][50], arr_2[50], result घोषित करें
    n1 = (upper_x - lower_x) / step_x + 1 सेट करें
    n2 = (upper_y - lower_y) / step_y + 1 सेट करें
    लूप For int i = 0 से i < n1 तक ++i
        लूप For int j = 0 से j < n2 तक ++j
            arr[i][j] = fun(lower_x + i * step_x, lower_y + j * step_y) सेट करें
        End
    End
    लूप For int i = 0 से i < n1 तक ++i
        arr_2[i] = 0 सेट करें
        लूप For int j = 0 से j < n2 तक ++j
            IF (j == 0 || j == n2 - 1)
                arr_2[i] += arr[i][j] सेट करें
            End
            Else IF (j % 2 == 0)
                arr_2[i] += 2 * arr[i][j] सेट करें
            End
            Else
                arr_2[i] += 4 * arr[i][j] सेट करें
            End
        arr_2[i] *= (step_y / 3) सेट करें
    End
    result = 0 सेट करें
    लूप For int i = 0 से i < n1 तक ++i
        IF (i == 0 || i == n1 - 1)
            result += arr_2[i] सेट करें
        End
        Else IF (i % 2 == 0)
            result += 2 * arr_2[i] सेट करें
        End
        Else
            result += 4 * arr_2[i] सेट करें
        End
        result *= (step_x / 3) सेट करें
    End
    result लौटाएं

Step 2 → main() में
    float step_x = 1.2 घोषित करें  // x के लिए चरण
    float step_y = 0.54 घोषित करें  // y के लिए चरण
    float lower_x = 1.3 घोषित करें  // x की निचली सीमा
    float upper_x = 2.1 घोषित करें  // x की ऊपरी सीमा
    float lower_y = 1.0 घोषित करें  // y की निचली सीमा
    float upper_y = 2.1 घोषित करें  // y की ऊपरी सीमा
    (step_x, step_y, lower_x, upper_x, lower_y, upper_y) कॉल करें
Stop

उदाहरण

#include <bits/stdc++.h>
using namespace std;

float fun(float x, float y) {
    return pow(pow(x, 4) + pow(y, 5), 0.5);
}

// दोहरे समाकलन मान ज्ञात करने के लिए फंक्शन
float doubleIntegral(float step_x, float step_y, float lower_x, float upper_x, float lower_y, float upper_y) {
    int n1, n2;
    float arr[50][50], arr_2[50], result;
    n1 = (upper_x - lower_x) / step_x + 1;
    n2 = (upper_y - lower_y) / step_y + 1;
    for (int i = 0; i < n1; ++i) {
        for (int j = 0; j < n2; ++j) {
            arr[i][j] = fun(lower_x + i * step_x, lower_y + j * step_y);
        }
    }
    for (int i = 0; i < n1; ++i) {
        arr_2[i] = 0;
        for (int j = 0; j < n2; ++j) {
            if (j == 0 || j == n2 - 1)
                arr_2[i] += arr[i][j];
            else if (j % 2 == 0)
                arr_2[i] += 2 * arr[i][j];
            else
                arr_2[i] += 4 * arr[i][j];
        }
        arr_2[i] *= (step_y / 3);
    }
    result = 0;
    for (int i = 0; i < n1; ++i) {
        if (i == 0 || i == n1 - 1)
            result += arr_2[i];
        else if (i % 2 == 0)
            result += 2 * arr_2[i];
        else
            result += 4 * arr_2[i];
    }
    result *= (step_x / 3);
    return result;
}

int main() {
    float step_x = 1.2; // x के लिए चरण
    float step_y = 0.54; // y के लिए चरण
    float lower_x = 1.3; // x की निचली सीमा
    float upper_x = 2.1; // x की ऊपरी सीमा
    float lower_y = 1.0; // y की निचली सीमा
    float upper_y = 2.1; // y की ऊपरी सीमा
    cout << "double integration is : " << doubleIntegral(step_x, step_y, lower_x, upper_x, lower_y, upper_y);
    return 0;
}

आउटपुट

double integration is : 2.1