सी ++ में गॉस जॉर्डन विधि का उपयोग करके मैट्रिक्स का उलटा ढूँढना

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

अब, समस्या की मूल बातें समझते हैं,

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

उदाहरण

$\begin{bmatrix}2&5&4 \\1&6&7 \\9&3&8\end{bmatrix}$

मैट्रिक्स का उलटा [A-1] -

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

• प्रारंभिक मैट्रिक्स वर्ग मैट्रिक्स होना चाहिए।

• यह गैर-एकवचन मैट्रिक्स होना चाहिए।

• मैट्रिक्स ए के लिए एक पहचान मैट्रिक्स I मौजूद है, जैसे कि,

$$AA^{-1} =A^{-1}.A =I$$

उनका एक सूत्र है जिसका उपयोग चींटी दिए गए मैट्रिक्स के व्युत्क्रम को खोजने के लिए किया जा सकता है। यह है

$A^{-1}\:=\:\बाएं(\frac{adj(A)}{\det(A)}\right)$

adj(A) मैट्रिक्स A का जोड़ . है

det(A) मैट्रिक्स A का निर्धारक है।

उनके कई तरीके हैं जिनका उपयोग करके हम एक मैट्रिक्स का व्युत्क्रम पा सकते हैं। इस लेख में, हम गॉस जॉर्डन विधि . के बारे में जानेंगे जिसे प्राथमिक पंक्ति संचालन . के रूप में भी जाना जाता है ।

यह एक मैट्रिक्स के व्युत्क्रम को खोजने के लिए एक कदम दर कदम विधि है, यहां शामिल चरण हैं -

• पहचान मैट्रिक्स का उपयोग करके संवर्धित मैट्रिक्स ढूँढना।

• चरण 1 में पाए गए संवर्धित मैट्रिक्स पर पंक्ति में कमी ऑपरेशन निष्पादित करके मैट्रिक्स के सोपानक रूप का पता लगाएं।

• प्रक्रिया में संवर्धित मैट्रिक्स पर किए जा सकने वाले कुछ ऑपरेशन हैं

  • पंक्ति इंटरचेंज (आप किन्हीं दो पंक्तियों को आपस में बदल सकते हैं)

  • गुणा (पंक्ति के प्रत्येक तत्व को 0 के अलावा एक स्थिर मान से गुणा किया जा सकता है)।

  • पंक्ति इंटरचेंज (पंक्ति को पंक्ति के योग और मैट्रिक्स की दूसरी पंक्ति के निरंतर गुणक से बदलें)।

उदाहरण

हमारे समाधान की कार्यप्रणाली को दर्शाने के लिए कार्यक्रम

#include <iostream>
#include <vector>
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;
   }
   return;
}
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;
   }
   return;
}
void findInvMatGaussJordan(float** mat, int order){
   float temp;
   printf("The inverse of matrix : 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* temp = mat[i];
         mat[i] = mat[i - 1];
         mat[i - 1] = temp;
      }
   }
   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;
            }
         }
      }
   }
   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);
   return;
}
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;
}

आउटपुट

The inverse of matrix : 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