Algorithmensammlung: Numerik: Inverse Matrix

Algorithmensammlung: Numerik

• Dividierte Differenzen
• Hermiteinterpolation
• Horner-Schema
• Quadratur
• Gauß-Jordan-Algorithmus
• Inverse Matrix
• Determinante

Inverse Matrix

Pseudocode

function inverseMatrix (m)
  n ← Zeilen- bzw. Spaltenzahl von m
  a ← Kopie von m
  b ← Einheitsmatrix mit n Zeilen und n Spalten
  for j ← 1 to n do
    begin
    p ← j
    while p ≤ n and a[p][j] = 0 do p ← p + 1
    if p = n + 1 then return undefiniert
    if p ≠ j then
      begin
      Vertausche in Matrix a die Zeilen j und p
      Vertausche in Matrix b die Zeilen j und p
      end
    f ← a[j][j]
    Dividiere in Matrix a die Zeile j durch f
    Dividiere in Matrix b die Zeile j durch f
    for i ← 1 to n do
      begin
      if i ≠ j then
        begin
        f ← a[i][j]
        Subtrahiere in Matrix a von Zeile i das f-fache von Zeile j
        Subtrahiere in Matrix b von Zeile i das f-fache von Zeile j
        end
      end
    end
  return b

Java

// Inverse Matrix:
// m ... Gegebene Matrix
  
public static double[][] inverseMatrix (double[][] m) {
  	
  int n = m.length;                                         // Anzahl der Zeilen
  	
  // Überprüfung, ob die gegebene Matrix quadratisch ist:
  	
  for (int i=0; i<n; i++) {                                 // Für alle Zeilenindizes ...
    if (m[i].length != n) {                                 // Falls abweichende Zeilenlänge ...
      System.out.println("Matrix nicht quadratisch!");      // Fehlermeldung
      return null;                                          // Rückgabewert
      }
    }
  	  
  // Kopie der gegebenen Matrix (zur Weiterverarbeitung):
  	
  double[][] a = new double[n][n];                          // Zweifach indiziertes Array
  for (int i=0; i<n; i++)                                   // Für alle Zeilenindizes ...
    for (int j=0; j<n; j++)                                 // Für alle Spaltenindizes ...
      a[i][j] = m[i][j];                                    // Matrixelement
  	  	
  // Einheitsmatrix (zur Weiterverarbeitung):
  	
  double[][] b = new double[n][n];                          // Zweifach indiziertes Array
  for (int i=0; i<n; i++)                                   // Für alle Zeilenindizes ...
    for (int j=0; j<n; j++)                                 // Für alle Spaltenindizes ...
      b[i][j] = (i==j ? 1 : 0);                             // Matrixelement 1 oder 0
  	
  // Berechnung: 
  	
  for (int j=0; j<n; j++) {                                 // Für alle Spaltenindizes ...
    int p = j;                                              // Variable für Zeilenindex
    while (p < n && a[p][j] == 0) p++;                      // Index erhöhen, bis Spaltenelement ungleich 0
    if (p == n) {                                           // Falls Suche erfolglos ...
      System.out.println("Matrix nicht invertierbar!");     // Fehlermeldung
      return null;                                          // Rückgabewert
      } 
    if (p != j) {                                           // Falls Zeilentausch nötig ...
      double[] temp = a[j];                                 // Zeile von Matrix a mit Index j
      a[j] = a[p];                                          // Zeile mit Index j neu
      a[p] = temp;                                          // Zeile mit Index p neu
      temp = b[j];                                          // Zeile von Matrix b mit Index j
      b[j] = b[p];                                          // Zeile mit Index j neu
      b[p] = temp;                                          // Zeile mit Index p neu
      }
    double f = a[j][j];                                     // Element der Hauptdiagonale
    for (int k=0; k<n; k++) {                               // Für alle Spaltenindizes ...
      a[j][k] /= f;                                         // In Matrix a durch f dividieren
      b[j][k] /= f;                                         // In Matrix b durch f dividieren
      } 
    for (int i=0; i<n; i++) {                               // Für alle Zeilenindizes ...
      if (i == j) continue;                                 // Element der Hauptdiagonale überspringen
      f = a[i][j];                                          // Faktor für Multiplikation
      for (int k=0; k<n; k++) {                             // Für alle Spaltenindizes ..
        a[i][k] -= f*a[j][k];                               // Zeilenumformung in Matrix a
        b[i][k] -= f*b[j][k];                               // Zeilenumformung in Matrix b
        }
      }
    }
  	
    return b; 
  }