Poprzedni artykułpreviousnextNastępny artykuł

Macierz odwrotna

Macierz odwrotna A-1-1=A-1⋅A = I
Macierz odwrotna do macierzy A:
Odwracanie macierzy
gdzie D jest transponowaną macierzą dopełnień algebraicznych odpowiadających elementów macierzy A.
Kroki przy odwracaniu macierzy:

  1. Pobieramy wszystkie podmacierze macierzy odwracanej
  2. Dla każdej podmacierzy obliczamy minor
  3. Obliczamy dopełnienie algebraiczne każdego minora
  4. Dopełnienia umieszczamy w macierzy
  5. Transformujemy macierz dopełnień
  6. Obliczamy wyznacznik macierzy odwracanej
  7. Mnożymy transformowaną macierz dopełnień przez odwrotność wyznacznika

Odwracanie macierzy

Załóżmy, że mamy do odwrócenia macierz:
Macierz Odwracanie macierzy
Pobieramy podmacierz Odwracanie macierzy
Obliczamy minor odwracanie macierzy
Obliczamy dopełnienie algebraiczne minora = -3
Wstawiamy dopełnienie do macierzy dopełnień
Odwracanie macierzy
Powtarzamy operację dla wszystkich podmacierzy i otrzymujemy macierz dopełnień:
Odwracanie macierzy
Transponujemy macierz dopełnień. Otrzymujemy macierz transponowaną:
Odwracanie macierzy
Obliczamy wyznacznik macierzy odwracanej.
Wyznacznik macierzy wyjściowej wynosi -3.
Mnożymy macierz transponowaną przez skalar (odwrotność wyznacznika macierzy wyjściowej)
Odwracanie macierzy
Sprawdzenie
A=Odwracanie macierzy
A-1=Odwracanie macierzy
Odwracanie macierzy
Ponieważ wynik mnożenia jest macierzą jednostkową, tzn. że macierz A-1 jest macierzą odwrotną do macierzy A.
Obliczenie w klasie Matrix034.

 double[][] array = {{2, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        Matrix matrix = new Matrix(array);
        matrix.printToConsole();
        Util.print("");
        Matrix matrixac = new Matrix(matrix.getRowCount(),
               matrix.getColCount());
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                double ac = MatrixUtil.algComplement(matrix, i, j);
                try {
                    matrixac.setCell(i, j, ac);
                } catch (MatrixException e) {
                    e.printStackTrace();
                }
            }
        }
        Matrix matrix1 = MatrixUtil.transpose(matrixac);
        double det = 0.0;
        try {
            det = matrix.det();
        } catch (MatrixException e) {
            e.printStackTrace();
        }
        Matrix matrixt = matrix1.mult2(1 / det);
        matrixt.printToConsole();
        Util.print("");
        Matrix finalm = matrix.multiply2(matrixt);
        finalm.printToConsole();

Po uruchomieniu klasy na konsoli zobaczymy:

2.0 2.0 3.0 
4.0 5.0 6.0 
7.0 8.0 9.0 

0.5 -1.0 0.5 
-1.0 0.5 0.0 
0.5 0.3333333333333333 -0.3333333333333333 

0.5 0.0 0.0 
0.0 0.5 0.0 
0.0 0.0 0.5 

w klasie Matrix035 pokazano użycie metody inverse do odwracania macierzy

Eliminacja Gaussa - Jordana

Jeżeli będziemy wykonywali operacje elementarne tylko na wierszach, to każdą macierz nieosobliwą można sprowadzić do macierzy jednostkowej.
Jeżeli dla danej macierzy przyjmiemy macierz jednostkową o tym samym rozmiarze, to jeśli wykonamy operacje elementarne zarówno na macierzy wyjściowej, jak i na macierzy elementarnej, to macierz wyjściowa przekształci się w macierz jednostkową, a macierz jednostkowa - w macierz odwrotną.
Mamy macierz:
Eliminacja Gaussa - Jordana
Wyznacznik macierzy Eliminacja Jordana - Gaussa, czyli macierz jest nieosobliwa, a jako taka ma macierz odwrotną.
Tworzymy macierz blokową [A|I] zawierającą macierz A oraz macierz jednostkową I.
Używając operacji elementarnych wyłącznie na wierszach sprowadzamy macierz blokową do postaci [I|B], gdzie macierz B jest macierzą odwrotną a-1.

1.0 -1.0 2.0 	1.0 0.0 0.0 
-1.0 2.0 0.0 	0.0 1.0 0.0 
2.0 -3.0 1.0 	0.0 0.0 1.0 

1.0 -1.0 2.0 	1.0 0.0 0.0 
0.0 1.0 2.0 	1.0 1.0 0.0 
2.0 -3.0 1.0 	0.0 0.0 1.0 

1.0 -1.0 2.0 	1.0 0.0 0.0 
0.0 1.0 2.0 	1.0 1.0 0.0 
0.0 -1.0 -3.0 	-2.0 0.0 1.0 

1.0 -1.0 2.0 	1.0 0.0 0.0 
0.0 1.0 2.0 	1.0 1.0 0.0 
0.0 0.0 -1.0 	-1.0 1.0 1.0 

1.0 -1.0 2.0 	1.0 0.0 0.0 
0.0 1.0 2.0 	1.0 1.0 0.0 
0.0 0.0 1.0 	1.0 -1.0 -1.0 

1.0 -1.0 2.0 	1.0 0.0 0.0 
0.0 1.0 0.0 	-1.0 3.0 2.0 
0.0 0.0 1.0 	1.0 -1.0 -1.0 

1.0 -1.0 0.0 	-1.0 2.0 2.0 
0.0 1.0 0.0 	-1.0 3.0 2.0 
0.0 0.0 1.0 	1.0 -1.0 -1.0 

1.0 0.0 0.0 	-2.0 5.0 4.0 
0.0 1.0 0.0 	-1.0 3.0 2.0 
0.0 0.0 1.0 	1.0 -1.0 -1.0 

Jeżeli pomnożymy macierz wejściową przez wyjściową otrzymamy macierz elementarną.
Eliminacja Jordana - Gaussa
Operacja sprowadzania macierzy do postaci jednostkowej składa się z dwóch etapów:

  • przekształcenie macierzy nieosobliwej w macierz górnotrójkątną - ten sposób opisano w podrozdziale poświęconym wyznacznikowi macierzy oraz przy omawianiu eliminacji Gaussa
  • sprowadzenie macierzy górnotrójkątnej do macierzy jednostkowej

Zauważmy, że w tej metodzie nie martwimy się ani o znak wyznacznika w przypadku zamiany wierszy, ani o podzielenie wyznacznika przez skalar, którego użyliśmy do pomnożenia elementów wiersza.
Przykład w klasie Matrix077:

        double[][] A = {{1, -1, 2}, {-1, 2, 0}, {2, -3, 1}};
        Matrix m = new Matrix(A);
        m.printToConsole();
        Util.print("");
        Matrix m1 = MatrixUtil.inverseGauss(m);
        m1.printToConsole(2);
        Util.print("");
        Matrix m2 = MatrixUtil.multiply3(m, m1);
        m2.printToConsole(1);
        Util.print("");

Po uruchomieniu klasy na konsoli zobaczymy:

1.0 -1.0 2.0 
-1.0 2.0 0.0 
2.0 -3.0 1.0 

-2.0 5.0 4.0 
-1.0 3.0 2.0 
1.0 -1.0 -1.0 

1.0 0.0 0.0 
0.0 1.0 0.0 
0.0 0.0 1.0 

Pliki do ściągnięcia

matrices023.zip
Moduł matrices - aktualny stan projektu = 023;