Wie man die Inverse einer Matrix in C berechnet | Matrixinversion C Tutorial

Einführung

In diesem Labor lernen wir, wie man die Inverse einer quadratischen Matrix mit C-Programmierung berechnet. Die Inverse einer Matrix ist ein wichtiges Konzept in der linearen Algebra mit Anwendungen in der Lösung linearer Gleichungssysteme, der Computergrafik, der Datenanalyse und vielen Bereichen des wissenschaftlichen Rechnens.

Wir werden den Prozess der Matrixinversion in mehreren Schritten untersuchen: Einlesen einer quadratischen Matrix von der Benutzereingabe, Berechnung der Determinante und der Adjunkten der Matrix und schließlich Berechnung der Inversen unter Verwendung dieser Werte. Das Labor bietet praktische Erfahrung bei der Implementierung dieser mathematischen Operationen in C-Code und festigt Ihr Verständnis sowohl der Programmierkonzepte als auch der Prinzipien der linearen Algebra.

Am Ende dieses Labors werden Sie in der Lage sein, ein vollständiges Matrixinversionsprogramm zu implementieren und die zugrunde liegenden mathematischen Techniken zu verstehen, die in diesem Prozess involviert sind.

Einlesen einer quadratischen Matrix von der Benutzereingabe

In diesem Schritt erstellen wir ein Programm, um eine quadratische Matrix von der Benutzereingabe einzulesen. Eine quadratische Matrix hat eine gleiche Anzahl von Zeilen und Spalten, was eine Voraussetzung für die Berechnung einer Matrixinversen ist.

Zuerst wollen wir verstehen, was wir tun müssen:

Definieren Sie eine maximale Größe für unsere Matrix
Holen Sie sich die tatsächliche Matrixgröße vom Benutzer
Lesen Sie jedes Element der Matrix ein
Zeigen Sie die Matrix an, um unsere Eingabe zu überprüfen

Beginnen wir damit, eine neue C-Datei in unserem Projektverzeichnis zu erstellen:

Öffnen Sie die WebIDE und navigieren Sie zum Projektverzeichnis
Erstellen Sie eine neue Datei namens matrix_input.c im Verzeichnis ~/project

Kopieren Sie den folgenden Code in die Datei:

#include <stdio.h>
#define MAX_SIZE 10

// Function to read matrix elements from user
void readMatrix(int matrix[MAX_SIZE][MAX_SIZE], int size) {
    printf("Enter the elements of the %dx%d matrix:\n", size, size);
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            printf("Enter element [%d][%d]: ", i, j);
            scanf("%d", &matrix[i][j]);
        }
    }
}

// Function to display the matrix
void displayMatrix(int matrix[MAX_SIZE][MAX_SIZE], int size) {
    printf("\nMatrix Contents:\n");
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            printf("%d\t", matrix[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int matrix[MAX_SIZE][MAX_SIZE];
    int size;

    // Get matrix size from user
    printf("Matrix Input Program\n");
    printf("====================\n");
    printf("Enter the size of the square matrix (1-%d): ", MAX_SIZE);
    scanf("%d", &size);

    // Validate matrix size
    if (size <= 0 || size > MAX_SIZE) {
        printf("Invalid matrix size. Please enter a size between 1 and %d.\n", MAX_SIZE);
        return 1;
    }

    // Read matrix elements
    readMatrix(matrix, size);

    // Display the matrix
    displayMatrix(matrix, size);

    return 0;
}

Lassen Sie uns die Schlüsselkomponenten dieses Codes verstehen:

#define MAX_SIZE 10 - Dies definiert eine Konstante für die maximale Matrixgröße
readMatrix() - Eine Funktion, die verschachtelte Schleifen verwendet, um jedes Element der Matrix einzulesen
displayMatrix() - Eine Funktion, die die Matrix in einem tabellarischen Format ausgibt
In der Funktion main() erhalten wir die Größe vom Benutzer und validieren sie, bevor wir die Matrix einlesen

Nun wollen wir unser Programm kompilieren und ausführen:

Öffnen Sie ein Terminal in der WebIDE
Kompilieren Sie das Programm mit dem folgenden Befehl:
```
cd ~/project
gcc matrix_input.c -o matrix_input
```
Führen Sie das Programm aus:
```
./matrix_input
```

Sie sollten eine Ausgabe ähnlich dieser sehen:

Matrix Input Program
====================
Enter the size of the square matrix (1-10): 3
Enter the elements of the 3x3 matrix:
Enter element [0][0]: 1
Enter element [0][1]: 2
Enter element [0][2]: 3
Enter element [1][0]: 4
Enter element [1][1]: 5
Enter element [1][2]: 6
Enter element [2][0]: 7
Enter element [2][1]: 8
Enter element [2][2]: 9

Matrix Contents:
1	2	3
4	5	6
7	8	9

Sie haben nun erfolgreich ein Programm erstellt, das eine quadratische Matrix von der Benutzereingabe einliest und anzeigt. Dies ist der erste Schritt in unserem Matrixinversionsberechnungsprozess.

Berechnung der Matrixdeterminante und des Kofaktors

Bevor wir die Inverse einer Matrix berechnen können, müssen wir zwei wichtige mathematische Operationen verstehen und implementieren: das Finden der Determinante und des Kofaktors einer Matrix. Die Determinante ist ein Skalarwert, der von einer quadratischen Matrix abgeleitet wird und eine entscheidende Rolle bei der Bestimmung spielt, ob eine Matrix invertierbar ist.

In diesem Schritt werden wir:

Lernen, was Determinanten und Kofaktoren sind
Funktionen zu deren Berechnung implementieren
Unsere Implementierung mit einer einfachen Matrix testen

Erstellen wir eine neue Datei für diesen Schritt:

Erstellen Sie eine neue Datei namens matrix_determinant.c im Verzeichnis ~/project

Kopieren Sie den folgenden Code in die Datei:

#include <stdio.h>
#define MAX_SIZE 10

// Function to read matrix elements from user
void readMatrix(int matrix[MAX_SIZE][MAX_SIZE], int size) {
    printf("Enter the elements of the %dx%d matrix:\n", size, size);
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            printf("Enter element [%d][%d]: ", i, j);
            scanf("%d", &matrix[i][j]);
        }
    }
}

// Function to get cofactor of matrix[p][q] in temp[][]
void getCofactor(int matrix[MAX_SIZE][MAX_SIZE], int temp[MAX_SIZE][MAX_SIZE],
                 int p, int q, int n) {
    int i = 0, j = 0;

    // Looping for each element of the matrix
    for (int row = 0; row < n; row++) {
        for (int col = 0; col < n; col++) {
            // Copying into temporary matrix only those elements
            // which are not in given row and column
            if (row != p && col != q) {
                temp[i][j++] = matrix[row][col];

                // Row is filled, so increase row index and
                // reset column index
                if (j == n - 1) {
                    j = 0;
                    i++;
                }
            }
        }
    }
}

// Recursive function to find determinant of matrix
int determinant(int matrix[MAX_SIZE][MAX_SIZE], int n) {
    int det = 0; // Initialize result

    // Base case: if matrix contains single element
    if (n == 1)
        return matrix[0][0];

    int temp[MAX_SIZE][MAX_SIZE]; // To store cofactors
    int sign = 1; // To store sign multiplier

    // Iterate for each element of first row
    for (int f = 0; f < n; f++) {
        // Getting cofactor of matrix[0][f]
        getCofactor(matrix, temp, 0, f, n);

        // Adding to determinant with appropriate sign
        det += sign * matrix[0][f] * determinant(temp, n - 1);

        // Alternating sign factor
        sign = -sign;
    }

    return det;
}

// Function to display the matrix
void displayMatrix(int matrix[MAX_SIZE][MAX_SIZE], int size) {
    printf("\nMatrix Contents:\n");
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            printf("%d\t", matrix[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int matrix[MAX_SIZE][MAX_SIZE];
    int size;

    // Get matrix size from user
    printf("Matrix Determinant Calculator\n");
    printf("=============================\n");
    printf("Enter the size of the square matrix (1-%d): ", MAX_SIZE);
    scanf("%d", &size);

    // Validate matrix size
    if (size <= 0 || size > MAX_SIZE) {
        printf("Invalid matrix size. Please enter a size between 1 and %d.\n", MAX_SIZE);
        return 1;
    }

    // Read matrix elements
    readMatrix(matrix, size);

    // Display the matrix
    displayMatrix(matrix, size);

    // Calculate and display the determinant
    int det = determinant(matrix, size);
    printf("\nDeterminant of the matrix is: %d\n", det);

    // Check if matrix is invertible
    if (det == 0) {
        printf("The matrix is not invertible (determinant is zero).\n");
    } else {
        printf("The matrix is invertible (determinant is non-zero).\n");
    }

    return 0;
}

Lassen Sie uns die Schlüsselkomponenten dieses Codes verstehen:

getCofactor() - Diese Funktion extrahiert eine Submatrix, indem sie eine bestimmte Zeile und Spalte entfernt. Dies ist für die Berechnung von Determinanten und adjungierten Matrizen unerlässlich.
determinant() - Eine rekursive Funktion, die die Determinante einer Matrix unter Verwendung der Kofaktor-Entwicklungsmethode berechnet.
Wir überprüfen auch, ob die Matrix invertierbar ist, indem wir testen, ob die Determinante ungleich Null ist.

Verständnis der mathematischen Konzepte:

Kofaktor (Cofactor): Für jedes Element in einer Matrix ist der Kofaktor die Determinante der Submatrix, die durch Entfernen der Zeile und Spalte dieses Elements gebildet wird, multipliziert mit (-1)^(i+j), wobei i,j die Zeilen- und Spaltenindizes sind.
Determinante (Determinant): Die Determinante ist eine spezielle Zahl, die aus einer quadratischen Matrix berechnet wird. Für eine 2×2-Matrix [[a,b],[c,d]] ist die Determinante (a×d - b×c). Für größere Matrizen verwenden wir die Kofaktor-Entwicklung.
Invertierbarkeit (Invertibility): Eine Matrix ist nur dann invertierbar, wenn ihre Determinante nicht Null ist.

Nun wollen wir unser Programm kompilieren und ausführen:

Kompilieren Sie das Programm mit dem folgenden Befehl:

cd ~/project
gcc matrix_determinant.c -o matrix_determinant

Führen Sie das Programm aus:
```
./matrix_determinant
```

Sie sollten eine Ausgabe ähnlich dieser sehen:

Matrix Determinant Calculator
=============================
Enter the size of the square matrix (1-10): 3
Enter the elements of the 3x3 matrix:
Enter element [0][0]: 1
Enter element [0][1]: 2
Enter element [0][2]: 3
Enter element [1][0]: 0
Enter element [1][1]: 1
Enter element [1][2]: 4
Enter element [2][0]: 5
Enter element [2][1]: 6
Enter element [2][2]: 0

Matrix Contents:
1	2	3
0	1	4
5	6	0

Determinant of the matrix is: 49
The matrix is invertible (determinant is non-zero).

Versuchen Sie, verschiedene Matrizen einzugeben, einschließlich einiger mit Determinante Null, um zu sehen, wie sich das Programm verhält. Wenn Sie beispielsweise eine Matrix eingeben, bei der eine Zeile ein Vielfaches einer anderen Zeile ist, sollte die Determinante Null sein.

Sie haben nun erfolgreich die Determinantenberechnung implementiert, die eine kritische Komponente für das Finden der Inversen einer Matrix ist.

Berechnung der Adjungierten einer Matrix

Der nächste Schritt bei der Berechnung der Inversen einer Matrix ist die Berechnung der Adjungierten (auch Adjugierte genannt) der Matrix. Die Adjungierte einer Matrix ist die Transponierte der Kofaktormatrix. Sobald wir die Adjungierte und die Determinante einer Matrix haben, können wir die Inverse mit der Formel berechnen:

Inverse(A) = Adjungierte(A) / Determinante(A)

In diesem Schritt werden wir:

Die Funktion zur Berechnung der Adjungierten implementieren
Auf unserem vorherigen Code aufbauen, um uns auf die endgültige Matrixinversion vorzubereiten

Erstellen wir eine neue Datei für diesen Schritt:

Erstellen Sie eine neue Datei namens matrix_adjoint.c im Verzeichnis ~/project

Kopieren Sie den folgenden Code in die Datei:

#include <stdio.h>
#define MAX_SIZE 10

// Function to read matrix elements from user
void readMatrix(int matrix[MAX_SIZE][MAX_SIZE], int size) {
    printf("Enter the elements of the %dx%d matrix:\n", size, size);
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            printf("Enter element [%d][%d]: ", i, j);
            scanf("%d", &matrix[i][j]);
        }
    }
}

// Function to get cofactor of matrix[p][q] in temp[][]
void getCofactor(int matrix[MAX_SIZE][MAX_SIZE], int temp[MAX_SIZE][MAX_SIZE],
                 int p, int q, int n) {
    int i = 0, j = 0;

    for (int row = 0; row < n; row++) {
        for (int col = 0; col < n; col++) {
            if (row != p && col != q) {
                temp[i][j++] = matrix[row][col];

                if (j == n - 1) {
                    j = 0;
                    i++;
                }
            }
        }
    }
}

// Recursive function to find determinant of matrix
int determinant(int matrix[MAX_SIZE][MAX_SIZE], int n) {
    int det = 0;

    if (n == 1)
        return matrix[0][0];

    int temp[MAX_SIZE][MAX_SIZE];
    int sign = 1;

    for (int f = 0; f < n; f++) {
        getCofactor(matrix, temp, 0, f, n);
        det += sign * matrix[0][f] * determinant(temp, n - 1);
        sign = -sign;
    }

    return det;
}

// Function to calculate the adjoint of a matrix
void adjoint(int matrix[MAX_SIZE][MAX_SIZE], int adj[MAX_SIZE][MAX_SIZE], int n) {
    if (n == 1) {
        adj[0][0] = 1;
        return;
    }

    int sign = 1;
    int temp[MAX_SIZE][MAX_SIZE];

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            // Get cofactor of matrix[i][j]
            getCofactor(matrix, temp, i, j, n);

            // Sign of adj[j][i] positive if sum of row and column indices is even
            sign = ((i + j) % 2 == 0) ? 1 : -1;

            // Interchanging rows and columns to get the transpose of the cofactor matrix
            adj[j][i] = sign * determinant(temp, n - 1);
        }
    }
}

// Function to display the matrix
void displayMatrix(int matrix[MAX_SIZE][MAX_SIZE], int size) {
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            printf("%d\t", matrix[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int matrix[MAX_SIZE][MAX_SIZE];
    int adj[MAX_SIZE][MAX_SIZE];
    int size;

    // Get matrix size from user
    printf("Matrix Adjoint Calculator\n");
    printf("=========================\n");
    printf("Enter the size of the square matrix (1-%d): ", MAX_SIZE);
    scanf("%d", &size);

    // Validate matrix size
    if (size <= 0 || size > MAX_SIZE) {
        printf("Invalid matrix size. Please enter a size between 1 and %d.\n", MAX_SIZE);
        return 1;
    }

    // Read matrix elements
    readMatrix(matrix, size);

    // Display the original matrix
    printf("\nOriginal Matrix:\n");
    displayMatrix(matrix, size);

    // Calculate the adjoint
    adjoint(matrix, adj, size);

    // Display the adjoint matrix
    printf("\nAdjoint Matrix:\n");
    displayMatrix(adj, size);

    // Calculate and display the determinant
    int det = determinant(matrix, size);
    printf("\nDeterminant of the matrix is: %d\n", det);

    return 0;
}

Lassen Sie uns die neue Schlüsselkomponente dieses Codes verstehen:

adjoint() - Diese Funktion berechnet die Adjungierte einer Matrix, die die Transponierte der Kofaktormatrix ist. Für jedes Element (i,j) in der Matrix tun wir Folgendes:
1. Finden Sie die Kofaktormatrix, indem Sie Zeile i und Spalte j entfernen
2. Berechnen Sie die Determinante dieser Kofaktormatrix
3. Wenden Sie das entsprechende Vorzeichen ((−1)^(i+j)) an
4. Platzieren Sie diesen Wert an Position (j,i) in der adjungierten Matrix (Transponierte)

Verständnis der Adjungierten-Berechnung:

Die Adjungierte (oder Adjugierte) einer Matrix A wird mit adj(A) bezeichnet. Für eine 2×2-Matrix:

A = [a b]
    [c d]

Die Adjungierte ist:

adj(A) = [ d  -b]
         [-c   a]

Für größere Matrizen berechnen wir den Kofaktor jedes Elements und transponieren dann die resultierende Matrix.

Nun wollen wir unser Programm kompilieren und ausführen:

Kompilieren Sie das Programm mit dem folgenden Befehl:
```
cd ~/project
gcc matrix_adjoint.c -o matrix_adjoint
```
Führen Sie das Programm aus:
```
./matrix_adjoint
```

Sie sollten eine Ausgabe ähnlich dieser sehen:

Matrix Adjoint Calculator
=========================
Enter the size of the square matrix (1-10): 3
Enter the elements of the 3x3 matrix:
Enter element [0][0]: 1
Enter element [0][1]: 0
Enter element [0][2]: 2
Enter element [1][0]: 3
Enter element [1][1]: 0
Enter element [1][2]: 4
Enter element [2][0]: 5
Enter element [2][1]: 0
Enter element [2][2]: 6

Original Matrix:
1	0	2
3	0	4
5	0	6

Adjoint Matrix:
0	0	0
-8	-4	4
0	0	0

Determinant of the matrix is: 0

Beachten Sie, dass in diesem Beispiel die Determinante 0 ist, was bedeutet, dass die Matrix nicht invertierbar ist. Versuchen wir ein anderes Beispiel mit einer invertierbaren Matrix:

Matrix Adjoint Calculator
=========================
Enter the size of the square matrix (1-10): 3
Enter the elements of the 3x3 matrix:
Enter element [0][0]: 5
Enter element [0][1]: -2
Enter element [0][2]: 2
Enter element [1][0]: 1
Enter element [1][1]: 0
Enter element [1][2]: 3
Enter element [2][0]: 3
Enter element [2][1]: 1
Enter element [2][2]: 4

Original Matrix:
5	-2	2
1	0	3
3	1	4

Adjoint Matrix:
-3	11	-5
13	14	-11
-1	-7	2

Determinant of the matrix is: 15

In diesem Fall ist die Determinante 15 (ungleich Null), was bedeutet, dass wir die Inverse dieser Matrix berechnen können. Sie haben nun erfolgreich die Adjungierten-Berechnung implementiert, die der vorletzte Schritt bei der Matrixinversion ist.

Berechnung der Matrixinversen

Nachdem wir nun Funktionen zur Berechnung sowohl der Determinante als auch der Adjungierten einer Matrix implementiert haben, können wir endlich die Inverse einer Matrix berechnen. Wie bereits erwähnt, lautet die Formel zum Finden der Inversen:

Inverse(A) = Adjungierte(A) / Determinante(A)

In diesem letzten Schritt werden wir:

Die Matrixinversionsfunktion implementieren
Ein vollständiges Programm erstellen, das eine Matrix einliest und ihre Inverse berechnet
Eine erweiterte Ausgabefunktionalität für eine bessere Lesbarkeit hinzufügen

Erstellen wir eine neue Datei für diesen letzten Schritt:

Erstellen Sie eine neue Datei namens matrix_inverse.c im Verzeichnis ~/project

Kopieren Sie den folgenden Code in die Datei:

#include <stdio.h>
#define MAX_SIZE 10

// Function to read matrix elements from user
void readMatrix(int matrix[MAX_SIZE][MAX_SIZE], int size) {
    printf("Enter the elements of the %dx%d matrix:\n", size, size);
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            printf("Enter element [%d][%d]: ", i, j);
            scanf("%d", &matrix[i][j]);
        }
    }
}

// Function to get cofactor of matrix[p][q] in temp[][]
void getCofactor(int matrix[MAX_SIZE][MAX_SIZE], int temp[MAX_SIZE][MAX_SIZE],
                 int p, int q, int n) {
    int i = 0, j = 0;

    for (int row = 0; row < n; row++) {
        for (int col = 0; col < n; col++) {
            if (row != p && col != q) {
                temp[i][j++] = matrix[row][col];

                if (j == n - 1) {
                    j = 0;
                    i++;
                }
            }
        }
    }
}

// Recursive function to find determinant of matrix
int determinant(int matrix[MAX_SIZE][MAX_SIZE], int n) {
    int det = 0;

    if (n == 1)
        return matrix[0][0];

    int temp[MAX_SIZE][MAX_SIZE];
    int sign = 1;

    for (int f = 0; f < n; f++) {
        getCofactor(matrix, temp, 0, f, n);
        det += sign * matrix[0][f] * determinant(temp, n - 1);
        sign = -sign;
    }

    return det;
}

// Function to calculate the adjoint of a matrix
void adjoint(int matrix[MAX_SIZE][MAX_SIZE], int adj[MAX_SIZE][MAX_SIZE], int n) {
    if (n == 1) {
        adj[0][0] = 1;
        return;
    }

    int sign = 1;
    int temp[MAX_SIZE][MAX_SIZE];

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            // Get cofactor of matrix[i][j]
            getCofactor(matrix, temp, i, j, n);

            // Sign of adj[j][i] positive if sum of row and column indices is even
            sign = ((i + j) % 2 == 0) ? 1 : -1;

            // Interchanging rows and columns to get the transpose of the cofactor matrix
            adj[j][i] = sign * determinant(temp, n - 1);
        }
    }
}

// Function to calculate the inverse of a matrix
int inverse(int matrix[MAX_SIZE][MAX_SIZE], float inverse[MAX_SIZE][MAX_SIZE], int n) {
    // Find determinant of matrix
    int det = determinant(matrix, n);

    // If determinant is zero, matrix is not invertible
    if (det == 0) {
        printf("Matrix is not invertible as determinant is zero.\n");
        return 0;
    }

    // Find adjoint of matrix
    int adj[MAX_SIZE][MAX_SIZE];
    adjoint(matrix, adj, n);

    // Find inverse by dividing adjoint by determinant
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            inverse[i][j] = adj[i][j] / (float)det;
        }
    }

    return 1;
}

// Function to display an integer matrix
void displayMatrix(int matrix[MAX_SIZE][MAX_SIZE], int size) {
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            printf("%d\t", matrix[i][j]);
        }
        printf("\n");
    }
}

// Function to display a float matrix (for inverse)
void displayFloatMatrix(float matrix[MAX_SIZE][MAX_SIZE], int size) {
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            printf("%.4f\t", matrix[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int matrix[MAX_SIZE][MAX_SIZE];
    float inv[MAX_SIZE][MAX_SIZE];
    int size;

    // Get matrix size from user
    printf("Matrix Inverse Calculator\n");
    printf("=========================\n");
    printf("Enter the size of the square matrix (1-%d): ", MAX_SIZE);
    scanf("%d", &size);

    // Validate matrix size
    if (size <= 0 || size > MAX_SIZE) {
        printf("Invalid matrix size. Please enter a size between 1 and %d.\n", MAX_SIZE);
        return 1;
    }

    // Read matrix elements
    readMatrix(matrix, size);

    // Display the original matrix
    printf("\nOriginal Matrix:\n");
    displayMatrix(matrix, size);

    // Calculate and display the determinant
    int det = determinant(matrix, size);
    printf("\nDeterminant of the matrix is: %d\n", det);

    // Calculate and display the inverse
    if (inverse(matrix, inv, size)) {
        printf("\nInverse Matrix:\n");
        displayFloatMatrix(inv, size);
    }

    return 0;
}

Lassen Sie uns die neuen Schlüsselkomponenten dieses Codes verstehen:

inverse() - Diese Funktion berechnet die Inverse einer Matrix, indem sie:
1. Die Determinante findet
2. Überprüft, ob die Determinante ungleich Null ist (invertierbar)
3. Die Adjungierte berechnet
4. Jedes Element der Adjungierten durch die Determinante dividiert
displayFloatMatrix() - Eine neue Funktion zur Anzeige der inversen Matrix mit Gleitkomma-Präzision, da die inversen Elemente nicht unbedingt ganze Zahlen sind.

Verständnis der Matrixinversion:

Für eine Matrix A erfüllt die Inverse A^(-1) die Gleichung: A × A^(-1) = A^(-1) × A = I, wobei I die Einheitsmatrix ist.

Die Formel, die wir verwenden, lautet: A^(-1) = adj(A) / det(A)

Nun wollen wir unser Programm kompilieren und ausführen:

Kompilieren Sie das Programm mit dem folgenden Befehl:
```
cd ~/project
gcc matrix_inverse.c -o matrix_inverse
```
Führen Sie das Programm aus:
```
./matrix_inverse
```

Sie sollten eine Ausgabe ähnlich dieser sehen:

Matrix Inverse Calculator
=========================
Enter the size of the square matrix (1-10): 3
Enter the elements of the 3x3 matrix:
Enter element [0][0]: 4
Enter element [0][1]: 3
Enter element [0][2]: 1
Enter element [1][0]: 0
Enter element [1][1]: -1
Enter element [1][2]: 2
Enter element [2][0]: -3
Enter element [2][1]: 3
Enter element [2][2]: 1

Original Matrix:
4	3	1
0	-1	2
-3	3	1

Determinant of the matrix is: 37

Inverse Matrix:
0.0270	0.1351	-0.1351
0.2432	-0.0541	-0.2432
-0.1081	0.4865	0.1081

Lassen Sie uns das Ergebnis überprüfen: Das Produkt der ursprünglichen Matrix und ihrer Inversen sollte der Einheitsmatrix sehr nahe kommen. Sie können dies manuell für kleine Matrizen überprüfen.

Für ein 2×2-Beispiel versuchen wir Folgendes:

Matrix Inverse Calculator
=========================
Enter the size of the square matrix (1-10): 2
Enter the elements of the 2x2 matrix:
Enter element [0][0]: 4
Enter element [0][1]: 7
Enter element [1][0]: 2
Enter element [1][1]: 6

Original Matrix:
4	7
2	6

Determinant of the matrix is: 10

Inverse Matrix:
0.6000	-0.7000
-0.2000	0.4000

Für eine 2×2-Matrix können Sie die Inverse leicht mit der Formel überprüfen: Für Matrix A = [[a, b], [c, d]] ist die Inverse: A^(-1) = (1/det(A)) × [[d, -b], [-c, a]]

wobei det(A) = a×d - b×c

In unserem Beispiel: det(A) = 4×6 - 7×2 = 24 - 14 = 10 A^(-1) = (1/10) × [[6, -7], [-2, 4]] = [[0.6, -0.7], [-0.2, 0.4]]

Herzlichen Glückwunsch! Sie haben nun erfolgreich einen vollständigen Matrixinversen-Rechner in C implementiert.

Zusammenfassung

In diesem Lab haben wir einen vollständigen Matrixinversen-Rechner in der C-Programmierung implementiert. Während des gesamten Labs haben wir mehrere Schlüsselkonzepte untersucht und diese Schritt für Schritt implementiert:

Wir begannen mit der Erstellung eines Programms, um eine quadratische Matrix von der Benutzereingabe zu lesen und anzuzeigen, und lernten, wie man mit 2D-Arrays in C umgeht.
Anschließend implementierten wir die Determinantenberechnung unter Verwendung der Kofaktorenentwicklungsmethode, einem rekursiven Ansatz, der die Grundlage der Matrixinversion bildet.
Als Nächstes bauten wir auf unserem Code auf, um die Adjungierte einer Matrix zu berechnen, die die Transponierte der Kofaktormatrix ist.
Schließlich kombinierten wir all diese Komponenten, um die Inverse einer Matrix mit der Formel zu berechnen: Inverse = Adjungierte / Determinante.

Diese mathematischen Operationen sind grundlegend in der linearen Algebra und haben weitreichende Anwendungen in verschiedenen Bereichen, darunter Computergrafik, maschinelles Lernen, das Lösen linearer Gleichungssysteme und mehr.

Die Implementierung zeigte mehrere Programmierkonzepte wie:

Mehrdimensionale Arrays
Rekursive Funktionen
Typkonvertierung zwischen Ganzzahlen und Gleitkommazahlen
Funktionsmodularität und Codeorganisation
Benutzereingabevalidierung

Durch die Durchführung dieses Labs haben Sie praktische Erfahrung sowohl mit der mathematischen Theorie als auch mit der Programmierimplementierung von Matrixoperationen, insbesondere der Matrixinversion, gesammelt.

Berechnung der Inversen einer Matrix in C

Einführung

Einlesen einer quadratischen Matrix von der Benutzereingabe

Berechnung der Matrixdeterminante und des Kofaktors

Berechnung der Adjungierten einer Matrix

Berechnung der Matrixinversen

Zusammenfassung