Sie können JavaScript verwenden, um die inverse Matrix zu finden

Matrixinversion ist eine wichtige Berechnung in der linearen Algebra. Sie wird häufig in mathematischen Berechnungen und technischen Praktiken verwendet, beispielsweise zum Lösen von Gleichungssystemen, zum Berechnen von Transformationsmatrizen usw. In diesem Artikel wird erläutert, wie Sie mithilfe der JavaScript-Sprache die Funktion zum Invertieren einer Matrix implementieren.

1. Grundkenntnisse der linearen Algebra

Bevor wir vorstellen, wie man eine Matrix in JavaScript umkehrt, müssen wir zunächst einige Grundkenntnisse der linearen Algebra verstehen.

1. Matrix und Vektor

Die Matrix ist eine rechteckige Zahlentabelle, die aus m Zeilen und n Spalten besteht. Sie kann ausgedrückt werden als:

A = [a1,1 a1,2 ... a1, n

 a2,1 a2,2 ... a2,n
 ...  ...  ...  ...
 am,1 am,2 ... am,n]

Ein Vektor ist eine Spaltenmatrix, die ausgedrückt werden kann als:

v = [v1

 v2
 ...
 vn]

2. Matrixaddition und -multiplikation

Matrixaddition und -multiplikation sind Operationen zwischen entsprechenden Elementen. Das Ergebnis der Matrixaddition ist die Addition entsprechender Elemente zweier Matrizen. Das Ergebnis der Matrixmultiplikation sind die Zeilen der ersten Matrix, multipliziert mit den Spalten der zweiten Matrix und dann summiert.

3. Matrixtransponierung

Matrixtransponierung (Matrixtransponierung) ist eine neue Matrix, die durch Austauschen der Zeilen und Spalten der Matrix erhalten wird. Zum Beispiel:

A = [1 2 3

 4 5 6]

A' = [1 4

  2 5
  3 6]

4. Inverse der Matrix

Die Umkehrung der Matrix ist eine Matrix und das Ergebnis der Multiplikation mit der Die ursprüngliche Matrix ist die Identitätsmatrix. Die Identitätsmatrix ist eine Matrix mit Einsen auf der Hauptdiagonale und Nullen an anderen Stellen.

Wenn die Umkehrung der Matrix A A^-1 ist, dann ist A A^-1 = A^-1 A = I.

Beachten Sie, dass nur die quadratische Matrix invertiert werden kann.

2. Verwenden Sie JavaScript, um die inverse Matrix zu implementieren.

Die Implementierung der inversen Matrix in JavaScript erfordert einige grundlegende mathematische Kenntnisse und Algorithmen. Im Folgenden stellen wir die spezifische Implementierungsmethode Schritt für Schritt vor.

1. Finden Sie die Determinante einer Matrix

Das Finden der Determinante einer Matrix ist der erste Schritt beim Lösen der Umkehrung einer Matrix. Die Determinante ist ein numerischer Wert, der das Produkt der diagonalen Elemente einer Matrix minus dem Produkt der nichtdiagonalen Elemente darstellt. Zum Beispiel:

A = [1 2 3

 4 5 6
 7 8 9]

|A| = 1 5 9 + 2 6 7 + 3 4 8 - 3 5 7 - 2 4 9 -. 1 6 8 = 0

Wir können die Determinante mithilfe der Rekursion lösen. Wenn die Größe der Matrix 1x1 beträgt, ist die Determinante gleich dem Wert des Elements; wenn die Größe der Matrix 2x2 beträgt, ist die Determinante gleich dem Produkt der oberen linken und unteren rechten Elemente minus Produkt der oberen rechten und unteren linken Elemente; wenn die Größe der Matrix größer als 2x2 ist, ist die Determinante gleich der Summe der Determinante der Submatrix, bestehend aus dem ersten Element jeder Zeile und den verbleibenden Elementen, multipliziert mit dem entsprechenden Koeffizienten.

Das Folgende ist der JavaScript-Code zum Lösen der Determinante:

Funktion det(A) {

var n = A.length;
if (n === 1) {
    return A[0][0];
} else if (n === 2) {
    return A[0][0] * A[1][1] - A[0][1] * A[1][0];
} else {
    var sum = 0;
    for (var i = 0; i < n; i++) {
        var submatrix = [];
        for (var j = 1; j < n; j++) {
            submatrix.push(A[j].slice(0, i).concat(A[j].slice(i + 1)));
        }
        var sign = Math.pow(-1, i);
        var cofactor = sign * det(submatrix);
        sum += A[0][i] * cofactor;
    }
    return sum;
}

}

2. Finden Sie die adjungierte Matrix der Matrix

Die adjungierte Matrix der Matrix (Adjugatmatrix) ist die Umkehrung der Matrix und des Determinantenprodukts. Jedes Element der adjungierten Matrix ist der algebraische Cofaktor der Matrix.

Zum Beispiel für die folgende 3x3-Matrix:

A = [1 2 3

 4 5 6
 7 8 9]

Ihre adjungierte Matrix ist:

adj(A) = [ -3 6 -3

        6 -12  6
       -3  6 -3 ]

Um die adjungierte Matrix zu lösen, müssen Sie kann den folgenden JavaScript-Code verwenden:

function adj(A) {

var n = A.length;
var adjA = [];
for (var i = 0; i < n; i++) {
    adjA[i] = [];
    for (var j = 0; j < n; j++) {
        var submatrix = [];
        for (var k = 0; k < n; k++) {
            if (k !== i) {
                submatrix.push(A[k].slice(0, j).concat(A[k].slice(j + 1)));
            }
        }
        var sign = Math.pow(-1, i + j);
        adjA[i][j] = sign * det(submatrix);
    }
}
return adjA;

}

3. Um die Umkehrung einer Matrix zu finden

Um die Umkehrung einer Matrix zu finden, müssen Sie zuerst die adjungierte Matrix und die Determinante finden der Matrix und dann gemäß der Formel A^-1 = adj( A) / |A|, d. h. die inverse Matrix kann durch Division der adjungierten Matrix der Matrix durch ihre Determinante erhalten werden.

Das Folgende ist der JavaScript-Code zum Lösen der inversen Matrix:

Funktion inverse(A) {

var n = A.length;
var detA = det(A);
if (detA === 0) {
    console.log("Matrix is not invertible.");
    return null;
}
var adjA = adj(A);
var Ainv = [];
for (var i = 0; i < n; i++) {
    Ainv[i] = [];
    for (var j = 0; j < n; j++) {
        Ainv[i][j] = adjA[j][i] / detA;
    }
}
return Ainv;

}

4. Testcode

Wir können den obigen JavaScript-Code zum Lösen der inversen Matrix durch einen einfachen Test überprüfen Code-Korrektheit:

var A = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
console.log("A = ");
console.log( A);

var Ainv = inverse(A);
console.log("Ainv = ");
console.log(Ainv);

var I = numeric.dot(A, Ainv);
console.log ("A * Ainv = ");
console.log(I);

Das Ausgabeergebnis sollte wie folgt sein:

A =
[ [ 1, 2, 3 ],
[ 4, 5, 6 ],
[ 7, 8, 9 ] ]
Ainv =
[ [ -0,5000000000000001, 1, -0,5 ],
[ 1, -2, 1 ],
[ -0,5000000000000001, 1, -0,5 ] ]
A * Ainv =
[ [ 1, 0, 0 ],
[ 0, 0.9999999999999997, 0 ],
[ 3.3306690738754696e-16, 0, 1 ] ]

Wie Sie sehen können, liegt das Ergebnis sehr nahe an der Identitätsmatrix.

3. Zusammenfassung

Das Lösen der inversen Matrix ist eine sehr wichtige mathematische Berechnung. Als beliebte Programmiersprache kann die JavaScript-Sprache die Funktion zum Lösen inverser Matrizen problemlos implementieren. In diesem Artikel wird die spezifische Methode zum Lösen der inversen Matrix mithilfe der JavaScript-Sprache vorgestellt, einschließlich der Ermittlung der Determinante, der adjungierten Matrix und der inversen Matrix der Matrix. Hoffentlich ist dieser Artikel für JavaScript-Entwickler hilfreich, die mathematische Berechnungen durchführen müssen.

Das obige ist der detaillierte Inhalt vonSie können JavaScript verwenden, um die inverse Matrix zu finden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!