C++ में गॉस-जॉर्डन विधि का उपयोग करके मैट्रिक्स का व्युत्क्रम खोजना

समस्या विवरण

इस समस्या में, हमें एक 2D मैट्रिक्स mat[][] दिया गया है। हमारा कार्य गॉस-जॉर्डन विधि का उपयोग करके मैट्रिक्स का व्युत्क्रम खोजना है।

आधारभूत अवधारणाएं

मैट्रिक्स संख्याओं की दो-आयामी सरणी है।

उदाहरण

[ 2  5  4 ]
[ 1  6  7 ]
[ 9  3  8 ]

मैट्रिक्स का व्युत्क्रम [A⁻¹] - यह वर्ग मैट्रिक्स पर किया जाने वाला एक ऑपरेशन है। मैट्रिक्स के व्युत्क्रम के लिए निम्नलिखित गुण आवश्यक हैं:

• प्रारंभिक मैट्रिक्स वर्ग मैट्रिक्स होना चाहिए
• यह गैर-विलक्षण (non-singular) मैट्रिक्स होना चाहिए
• मैट्रिक्स A के लिए एक पहचान मैट्रिक्स I मौजूद होना चाहिए जैसे कि: AA⁻¹ = A⁻¹A = I

किसी भी दिए गए मैट्रिक्स का व्युत्क्रम खोजने के लिए एक सूत्र है:

A⁻¹ = adj(A) / det(A)

जहां adj(A) मैट्रिक्स A का सहखंडज (adjoint) है और det(A) मैट्रिक्स A का सारणिक (determinant) है।

मैट्रिक्स का व्युत्क्रम खोजने के कई तरीके हैं। इस लेख में, हम गॉस-जॉर्डन विधि के बारे में सीखेंगे जिसे प्राथमिक पंक्ति संक्रिया (Elementary Row Operation) के रूप में भी जाना जाता है।

गॉस-जॉर्डन विधि के चरण

1. वर्धित मैट्रिक्स बनाएं पहचान मैट्रिक्स का उपयोग करके
2. पंक्ति न्यूनीकरण ऑपरेशन करके वर्धित मैट्रिक्स का एशेलॉन रूप खोजें
3. ऑपरेशन जो किए जा सकते हैं:
   • पंक्ति अदला-बदली (किसी भी दो पंक्तियों को आपस में बदल सकते हैं)
   • गुणा (पंक्ति के प्रत्येक तत्व को 0 के अलावा किसी स्थिर मान से गुणा कर सकते हैं)
   • पंक्ति प्रतिस्थापन (पंक्ति को उस पंक्ति और मैट्रिक्स की किसी अन्य पंक्ति के स्थिर गुणक के योग से बदल सकते हैं)

C++ कार्यान्वयन

#include <iostream> 
#include <vector> 
#include <cstdio> 
using namespace std; 

void printMatrixValues(float** arr, int n, int m) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cout << arr[i][j] << "\t";
        }
        cout << endl;
    }
}

void printInverseMatrix(float** arr, int n, int m) {
    for (int i = 0; i < n; i++) {
        for (int j = n; j < m; j++) {
            printf("%.3f\t", arr[i][j]);
        }
        cout << endl;
    }
}

void findInvMatGaussJordan(float** mat, int order) {
    float temp;
    printf("मैट्रिक्स का व्युत्क्रम: A = \n");
    printMatrixValues(mat, order, order);
    
    // पहचान मैट्रिक्स के साथ वर्धित करें
    for (int i = 0; i < order; i++) {
        for (int j = 0; j < 2 * order; j++) {
            if (j == (i + order))
                mat[i][j] = 1;
        }
    }
    
    // पिवट के लिए पंक्तियों को सॉर्ट करें (वैकल्पिक)
    for (int i = order - 1; i > 0; i--) {
        if (mat[i - 1][0] < mat[i][0]) {
            float* tempRow = mat[i];
            mat[i] = mat[i - 1];
            mat[i - 1] = tempRow;
        }
    }
    
    // गॉस-जॉर्डन एलिमिनेशन
    for (int i = 0; i < order; i++) {
        for (int j = 0; j < order; j++) {
            if (j != i) {
                temp = mat[j][i] / mat[i][i];
                for (int k = 0; k < 2 * order; k++) {
                    mat[j][k] -= mat[i][k] * temp;
                }
            }
        }
    }
    
    // विकर्ण को 1 बनाएं
    for (int i = 0; i < order; i++) {
        temp = mat[i][i];
        for (int j = 0; j < 2 * order; j++) {
            mat[i][j] = mat[i][j] / temp;
        }
    }
    
    cout << "A⁻¹ =\n";
    printInverseMatrix(mat, order, 2 * order);
}

int main() {
    int order = 3;
    float** mat = new float*[20];
    for (int i = 0; i < 20; i++)
        mat[i] = new float[20];
    
    mat[0][0] = 6; mat[0][1] = 9; mat[0][2] = 5;
    mat[1][0] = 8; mat[1][1] = 3; mat[1][2] = 2;
    mat[2][0] = 1; mat[2][1] = 4; mat[2][2] = 7;
    
    findInvMatGaussJordan(mat, order);
    return 0;
}

आउटपुट

मैट्रिक्स का व्युत्क्रम: A = 
6   9   5
8   3   2
1   4   7
A⁻¹ =
-0.049   0.163   -0.011
0.205   -0.141   -0.106
-0.110   0.057   0.205

जटिलता विश्लेषण

• समय जटिलता: O(N³)
• स्पेस जटिलता: O(N²)

महत्वपूर्ण नोट्स

• केवल वर्ग और गैर-विलक्षण (सारणिक ≠ 0) मैट्रिक्स के लिए काम करता है
• संख्यात्मक स्थिरता के लिए आंशिक पिवटिंग की सिफारिश की जाती है
• उत्पादन कोड के लिए, लैपैक जैसे पुस्तकालयों का उपयोग करें