Podstawy programu MAPLE

22. Macierze

Najpierw załadujemy moduł linalg do obliczeń algebraicznych z zakresu algebry liniowej.

> with(linalg);

Warning, the protected names norm and trace have been redefined and unprotected
[BlockDiagonal, GramSchmidt, JordanBlock, LUdecomp, QRdecomp, Wronskian,

    addcol, addrow, adj, adjoint, angle, augment, backsub, band, basis, bezout,

    blockmatrix, charmat, charpoly, cholesky, col, coldim, colspace, colspan,

    companion, concat, cond, copyinto, crossprod, curl, definite, delcols,

    delrows, det, diag, diverge, dotprod, eigenvals, eigenvalues, eigenvectors,

    eigenvects, entermatrix, equal, exponential, extend, ffgausselim,

    fibonacci, forwardsub, frobenius, gausselim, gaussjord, geneqns, genmatrix,

    grad, hadamard, hermite, hessian, hilbert, htranspose, ihermite, indexfunc,

    innerprod, intbasis, inverse, ismith, issimilar, iszero, jacobian, jordan,

    kernel, laplacian, leastsqrs, linsolve, matadd, matrix, minor, minpoly,

    mulcol, mulrow, multiply, norm, normalize, nullspace, orthog, permanent,

    pivot, potential, randmatrix, randvector, rank, ratform, row, rowdim,

    rowspace, rowspan, rref, scalarmul, singularvals, smith, stackmatrix,

    submatrix, subvector, sumbasis, swapcol, swaprow, sylvester, toeplitz,

    trace, transpose, vandermonde, vecpotent, vectdim, vector, wronskian]

22.1. Definicja macierzy

Macierz definiuje się przy pomocy polecenia matrix(...) w jednej z dwóch wersji:

22.1.1. Definicja macierzy o zadanych rozmiarach

Polecenie matrix(m, n, [lista]) tworzy macierz o wymiarach m×n o elementach pobranych z listy. Elementy z listy umieszczane są macierzy wierszami, od prawej do lewej i od góry do dołu:

> M := matrix(3,4,[4,-3,1,0,3,7,0,-5,6,0,-1,2]);

                               [4    -3     1     0]
                               [                   ]
                          M := [3     7     0    -5]
                               [                   ]
                               [6     0    -1     2]

22.1.2. Definicja macierzy poprzez podanie wierszy.

Polecenie matrix([lista]) gdzie lista jest listą list, tworzy macierz, której wierszami są listy wymienione na liście podanej jako argument.

> N := matrix([[2,-1,0,6],[-5,0,7,3],[0,1,-3,4]]);

                               [ 2    -1     0    6]
                               [                   ]
                          N := [-5     0     7    3]
                               [                   ]
                               [ 0     1    -3    4]

22.2. Wydzielanie fragmentów macierzy

22.2.1. Wycinanie kolumny

> col(M,1);

                                   [4, 3, 6]

> [seq(col(M,k),k=1..4)];

                [[4, 3, 6], [-3, 7, 0], [1, 0, -1], [0, -5, 2]]

22.2.2. Wycinanie wiersza

> row(M,2);

                                 [3, 7, 0, -5]

> [seq(row(M,k),k=1..3)];

                 [[4, -3, 1, 0], [3, 7, 0, -5], [6, 0, -1, 2]]

22.2.3. Wycinanie "podmacierzy"

> evalm(M);

Dla przypomnienia - postać macierzy M:

                             [4    -3     1     0]
                             [                   ]
                             [3     7     0    -5]
                             [                   ]
                             [6     0    -1     2]

Aby z macierzy m wyciąć fragment zaweirający komówrki z wierszy w i jednocześnie kolumn k (gdzie w i k może być przedziałem, na przykład 2..4, lub listą [2,1,3] - patrz przykłady), należy użyć polecenia submatrix(m,w,k):

> submatrix(M,2..3,1..2);

                                   [3    7]
                                   [      ]
                                   [6    0]

> submatrix(M,[3,1,2],[4,1]);

                                   [ 2    6]
                                   [       ]
                                   [ 0    4]
                                   [       ]
                                   [-5    3]

22.3. Właściwości macierzy

22.3.1. Określanie rozmiaru macierzy

22.3.1.1. Ilość kolumn - szerokość

> coldim(M);

                                       4

22.3.1.2. Ilość wierszy - wysokość

> rowdim(M);

                                       3

22.3.2. Wyznacznik macierzy

Wyznacznik macierzy M wyznaczamy poleceniem det(M), gdzie macierz M musi być kwadratowa.

> det(M);

Error, (in linalg:-det) expecting a square matrix

> M2 := matrix(2,2,[2,-1,3,-1]);

                                      [2    -1]
                                M2 := [       ]
                                      [3    -1]

> det(M2);

                                       1

22.4. Przekształcenia macierzy

22.4.1. Macierz odwrotna

> evalm(M2^(-1));

                                   [-1    1]
                                   [       ]
                                   [-3    2]

Można też tak:

> inverse(M2);

                                   [-1    1]
                                   [       ]
                                   [-3    2]

22.4.2. Macierz transponowana

> transpose(M2);

                                  [ 2     3]
                                  [        ]
                                  [-1    -1]

22.4.3. Usuwanie wierszy lub kolumn

22.4.3.1. Usuwanie kolumn

W celu usunięcia z macierzy M kolumny od m-tej do n-taj należy użyć polecenia delcols(M,m..n):

> delcols(M,2..3);

                                   [4     0]
                                   [       ]
                                   [3    -5]
                                   [       ]
                                   [6     2]

22.4.3.2. Usuwanie wierszy

W celu usunięcia z macierzy M wierszy od m-tej do n-taj należy użyć polecenia delrows(M,m..n):

> delrows(M,1..2);

                              [6    0    -1    2]

22.5. Działania na macierzach

22.5.1. Łączenie macierzy

> concat(M,N);

                 [4    -3     1     0     2    -1     0    6]
                 [                                          ]
                 [3     7     0    -5    -5     0     7    3]
                 [                                          ]
                 [6     0    -1     2     0     1    -3    4]

22.5.2. Dodawanie macierzy

> evalm(M+N);

                            [ 6    -4     1     6]
                            [                    ]
                            [-2     7     7    -2]
                            [                    ]
                            [ 6     1    -4     6]

22.5.3. Mnożenie macierzy

Wykonajmy działanie: M₂^TM₂^-1

> evalm(transpose(M2)*M2^(-1));

                                  [-11     8]
                                  [         ]
                                  [  4    -3]

Można też i tak:

> multiply(transpose(M2),M2^(-1));

                                  [-11     8]
                                  [         ]
                                  [  4    -3]

22.6. Operacje elementarne

22.6.1. Dodanie krotności kolumny do innej kolumny

W celu zastąpienia j-tej kolumny macierzy M kolumną i-tą przemnożoną przez m (j ← j + m*i) należy użyć polcenia: addcol(M,i,j,m) jak następuje:

> addcol(M,3,1,-2);

                             [2    -3     1     0]
                             [                   ]
                             [3     7     0    -5]
                             [                   ]
                             [8     0    -1     2]

22.6.2. Dodanie krotności wiersza do innego wiersza

W celu zastąpienia j-tego wiersza macierzy M wierszem i-tą przemnożonym przez m (j ← j + m*i) należy użyć polcenia: addrow(M,i,j,m) jak następuje:

> addrow(M,2,3,-2);

                            [4     -3     1     0]
                            [                    ]
                            [3      7     0    -5]
                            [                    ]
                            [0    -14    -1    12]

22.6.3. Przemnożenie kolumny przez liczbę

> mulcol(M,3,5);

                             [4    -3     5     0]
                             [                   ]
                             [3     7     0    -5]
                             [                   ]
                             [6     0    -5     2]

22.6.4. Przemnożenie wiersza przez liczbę

> mulrow(M,1,0.5);

                          [2.0    -1.5    0.5    0.]
                          [                        ]
                          [ 3      7       0     -5]
                          [                        ]
                          [ 6      0      -1     2 ]

22.6.5. Przestawienie kolumn

> swapcol(M,3,1);

                             [ 1    -3    4     0]
                             [                   ]
                             [ 0     7    3    -5]
                             [                   ]
                             [-1     0    6     2]

22.6.6. Przestawienie wierszy

> swaprow(M,3,1);

                             [6     0    -1     2]
                             [                   ]
                             [3     7     0    -5]
                             [                   ]
                             [4    -3     1     0]

22.7. Wartości i wektory własne

> A := matrix([[2,-3,1],[3,1,3],[-5,2,-4]]);

                                  [ 2    -3     1]
                                  [              ]
                             A := [ 3     1     3]
                                  [              ]
                                  [-5     2    -4]

> eigenvalues(A);

                                   0, 1, -2

> eigenvectors(A);

                                      [         -11]
   [-2, 1, {[1, 3/4, -7/4]}], [0, 1, {[1, 3/10, ---]}], [1, 1, {[-1, 0, 1]}]
                                      [         10 ]

Funkcja eigenvectors zwraca w każdej liście następujące wartości:

• wartość własną;
• krotność;
• wektor własny

czyli w przykładzie otrzymaliśmy trzy wektory własne, wszystkie jednokrotne. Wartości własnej -2 odpowiada wektor [1, ³/₄, -⁷/₄], wartości własnej 0: [1, ³/₁₀, -¹¹/₁₀], a wartości własne -1: [-1, 0, 1]