Prüfen, ob eine Matrix orthogonal ist (C)

Einführung

In diesem Labor lernen Sie, wie Sie überprüfen, ob eine quadratische Matrix in C orthogonal ist. Das Labor umfasst die folgenden Schritte: das Einlesen einer quadratischen Matrix, die Berechnung der Transponierten der Matrix und die Überprüfung der Bedingung AᵀA = I, um festzustellen, ob die Matrix orthogonal ist. Am Ende dieses Labors haben Sie ein umfassendes Verständnis der Matrizenoperationen und ihrer Anwendungen in der linearen Algebra mit C.

Das Labor bietet eine Schritt-für-Schritt-Anleitung, beginnend mit dem Einlesen einer quadratischen Matrix, gefolgt von der Berechnung der Transponierten der Matrix und schließlich der Überprüfung, ob die Matrix orthogonal ist, indem die Bedingung AᵀA = I verifiziert wird. Dieses Labor ist darauf ausgelegt, Ihre Fähigkeiten in der Matrizen- und linearen Algebra mit C-Programmierung zu entwickeln, eine wertvolle Fähigkeit in verschiedenen Bereichen wie Datenanalyse, wissenschaftlichem Rechnen und Ingenieurwesen.

Eine quadratische Matrix einlesen

In diesem Schritt lernen Sie, wie Sie eine quadratische Matrix in C einlesen. Eine quadratische Matrix ist eine Matrix mit einer gleichen Anzahl von Zeilen und Spalten. Wir erstellen ein Programm, das es Benutzern ermöglicht, eine quadratische Matrix dynamisch einzugeben.

Erstellen Sie zunächst eine C-Quelldatei für unsere Matrizenoperationen:

cd ~/project
nano matrix_orthogonal.c

Fügen Sie nun den folgenden Code hinzu, um eine quadratische Matrix einzulesen:

#include <stdio.h>
#define MAX_SIZE 100

void readMatrix(int matrix[MAX_SIZE][MAX_SIZE], int size) {
    printf("Geben Sie die Matrixelemente zeilenweise ein:\n");
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            scanf("%d", &matrix[i][j]);
        }
    }
}

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

    printf("Geben Sie die Größe der quadratischen Matrix ein: ");
    scanf("%d", &size);

    readMatrix(matrix, size);

    // Ausgabe der Matrix zur Überprüfung der Eingabe
    printf("\nEingabematrix:\n");
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }

    return 0;
}

Kompilieren und ausführen Sie das Programm:

gcc matrix_orthogonal.c -o matrix_orthogonal
./matrix_orthogonal

Beispielausgabe:

Geben Sie die Größe der quadratischen Matrix ein: 3
Geben Sie die Matrixelemente zeilenweise ein:
1 0 0
0 1 0
0 0 1

Eingabematrix:
1 0 0
0 1 0
0 0 1

Erklärung

• MAX_SIZE definiert die maximal mögliche Größe der Matrix.
• Die Funktion readMatrix() nimmt ein zweidimensionales Array und seine Größe als Parameter entgegen.
• Der Benutzer gibt die Matrixgröße und die Elemente zeilenweise ein.
• Das Programm gibt die Eingabematrix aus, um die korrekte Eingabe zu verifizieren.

Aᵀ berechnen und prüfen, ob AᵀA = I

In diesem Schritt erweitern Sie das vorherige Programm, um die Transponierte der Matrix zu berechnen und zu überprüfen, ob die Matrix orthogonal ist, indem Sie die Bedingung AᵀA = I verifizieren.

Aktualisieren Sie die Datei matrix_orthogonal.c mit folgendem Code:

nano ~/project/matrix_orthogonal.c

Fügen Sie die folgende Implementierung hinzu:

#include <stdio.h>
#include <stdbool.h>
#define MAX_SIZE 100

void readMatrix(int matrix[MAX_SIZE][MAX_SIZE], int size) {
    printf("Geben Sie die Matrixelemente zeilenweise ein:\n");
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            scanf("%d", &matrix[i][j]);
        }
    }
}

void transposeMatrix(int original[MAX_SIZE][MAX_SIZE],
                     int transpose[MAX_SIZE][MAX_SIZE],
                     int size) {
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            transpose[j][i] = original[i][j];
        }
    }
}

bool checkOrthogonality(int matrix[MAX_SIZE][MAX_SIZE],
                        int transpose[MAX_SIZE][MAX_SIZE],
                        int size) {
    int result[MAX_SIZE][MAX_SIZE] = {0};

    // Multiplikation der transponierten und ursprünglichen Matrix
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            for (int k = 0; k < size; k++) {
                result[i][j] += transpose[i][k] * matrix[k][j];
            }
        }
    }

    // Überprüfung, ob das Ergebnis die Einheitsmatrix ist
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            if (i == j && result[i][j] != 1) return false;
            if (i != j && result[i][j] != 0) return false;
        }
    }

    return true;
}

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

    printf("Geben Sie die Größe der quadratischen Matrix ein: ");
    scanf("%d", &size);

    readMatrix(matrix, size);

    // Transponierte berechnen
    transposeMatrix(matrix, transpose, size);

    // Orthogonalität prüfen
    bool isOrthogonal = checkOrthogonality(matrix, transpose, size);

    printf("\nTransponierte Matrix:\n");
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            printf("%d ", transpose[i][j]);
        }
        printf("\n");
    }

    printf("\nIst die Matrix orthogonal? %s\n",
           isOrthogonal ? "Ja" : "Nein");

    return 0;
}

Kompilieren und ausführen Sie das Programm:

gcc matrix_orthogonal.c -o matrix_orthogonal
./matrix_orthogonal

Beispielausgabe:

Geben Sie die Größe der quadratischen Matrix ein: 3
Geben Sie die Matrixelemente zeilenweise ein:
1 0 0
0 1 0
0 0 1

Transponierte Matrix:
1 0 0
0 1 0
0 0 1

Ist die Matrix orthogonal? Ja

Erklärung

• Die Funktion transposeMatrix() berechnet die Matrixtransponierte.
• checkOrthogonality() überprüft die Bedingung AᵀA = I.
• Das Programm prüft, ob die Matrix orthogonal ist, indem es die transponierte und die ursprüngliche Matrix multipliziert.

Ausgabe, ob orthogonal oder nicht

In diesem letzten Schritt erweitern Sie das vorherige Programm, um detailliertere Informationen über die Orthogonalität der Matrix bereitzustellen und verschiedene Matrixszenarien zu demonstrieren.

Aktualisieren Sie die Datei matrix_orthogonal.c mit der folgenden verbesserten Implementierung:

nano ~/project/matrix_orthogonal.c

Ersetzen Sie die vorherige Implementierung durch:

#include <stdio.h>
#include <stdbool.h>
#define MAX_SIZE 100

void readMatrix(int matrix[MAX_SIZE][MAX_SIZE], int size) {
    printf("Geben Sie die Matrixelemente zeilenweise ein:\n");
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            scanf("%d", &matrix[i][j]);
        }
    }
}

void transposeMatrix(int original[MAX_SIZE][MAX_SIZE],
                     int transpose[MAX_SIZE][MAX_SIZE],
                     int size) {
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            transpose[j][i] = original[i][j];
        }
    }
}

bool checkOrthogonality(int matrix[MAX_SIZE][MAX_SIZE],
                        int transpose[MAX_SIZE][MAX_SIZE],
                        int size) {
    int result[MAX_SIZE][MAX_SIZE] = {0};

    // Multiplikation der transponierten und ursprünglichen Matrix
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            for (int k = 0; k < size; k++) {
                result[i][j] += transpose[i][k] * matrix[k][j];
            }
        }
    }

    // Überprüfung, ob das Ergebnis die Einheitsmatrix ist
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            if (i == j && result[i][j] != 1) return false;
            if (i != j && result[i][j] != 0) return false;
        }
    }

    return true;
}

void printDetailedOrthogonalityInfo(int matrix[MAX_SIZE][MAX_SIZE],
                                    int transpose[MAX_SIZE][MAX_SIZE],
                                    int size) {
    bool isOrthogonal = checkOrthogonality(matrix, transpose, size);

    printf("\n--- Analyse der Matrixorthogonalität ---\n");
    printf("Ursprüngliche Matrix:\n");
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }

    printf("\nTransponierte Matrix:\n");
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            printf("%d ", transpose[i][j]);
        }
        printf("\n");
    }

    printf("\nOrthogonalitätsstatus: %s\n",
           isOrthogonal ? "✓ Orthogonale Matrix" : "✗ Keine orthogonale Matrix");

    if (isOrthogonal) {
        printf("Erklärung: A * Aᵀ = I (Einheitsmatrix)\n");
    } else {
        printf("Erklärung: A * Aᵀ ≠ I (Keine Einheitsmatrix)\n");
    }
}

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

    printf("Geben Sie die Größe der quadratischen Matrix ein: ");
    scanf("%d", &size);

    readMatrix(matrix, size);
    transposeMatrix(matrix, transpose, size);
    printDetailedOrthogonalityInfo(matrix, transpose, size);

    return 0;
}

Kompilieren und ausführen Sie das Programm:

gcc matrix_orthogonal.c -o matrix_orthogonal
./matrix_orthogonal

Beispielausgabe für eine orthogonale Matrix:

...

Beispielausgabe für eine nicht orthogonale Matrix:

...

Erklärung

• Funktion printDetailedOrthogonalityInfo() hinzugefügt für umfassende Ausgabe
• Zeigt die Originalmatrix, die transponierte Matrix und den Orthogonalitätsstatus an
• Bietet eine klare Erklärung der Orthogonalitätsbedingung

Zusammenfassung

In diesem Labor haben Sie zunächst gelernt, wie man eine quadratische Matrix in der C-Programmierung einliest. Sie haben ein Programm erstellt, das es Benutzern ermöglicht, eine quadratische Matrix dynamisch einzugeben und anschließend die eingegebene Matrix auszugeben, um die korrekte Eingabe zu verifizieren. Anschließend haben Sie das Programm erweitert, um die Transponierte der eingegebenen Matrix zu berechnen und zu überprüfen, ob die Matrix orthogonal ist, indem Sie die Bedingung AᵀA = I verifizieren. Das Programm berechnet das Produkt aus der Transponierten und der ursprünglichen Matrix und prüft, ob das Ergebnis die Einheitsmatrix ist, was darauf hinweist, dass die eingegebene Matrix orthogonal ist.