kapitel-16maple.mw

Mathematik

von T. Arens, F. Hettlich, Ch. Karpfinger, U. Kockelkorn, K. Lichtenegger,  H. Stachel

(zu Kapitel 16:  Matrizen und Determinanten)

> restart;

Matrizen

Addition und Multiplikation von Matrizen und Vektoren wurden im letzten Abschnitt vorgestellt. Nun fehlt uns noch das Matrixprodukt bei passenden Dimensionen. Dafuer ist das Verknuepfungssymbol   &*   vorgesehen. Wir erhalten  z.B.

> A:=matrix(2,3,[[3,2,1],[0,1,1]]);
b:=matrix(3,1,[1,1,3]);

c:=matrix(1,3,[1,0,2]);

B:=matrix(3,2,[[1,2], [1,1], [1,0]]);

BA=evalm(B&*A);

Ab=evalm(A&*b);

cB=evalm(c&*B);

A := matrix([[3, 2, 1], [0, 1, 1]])

b := matrix([[1], [1], [3]])

c := matrix([[1, 0, 2]])

B := matrix([[1, 2], [1, 1], [1, 0]])

BA = matrix([[3, 4, 3], [3, 3, 2], [3, 2, 1]])

Ab = matrix([[8], [4]])

cB = matrix([[3, 2]])

Auf diesem Weg ergeben sich  auch das  Skalarprodukt und das dyadische Produkt zweier Spaltenvektoren

> cb = evalm(c&*b);
bc = evalm(b&*c);

cb = matrix([[7]])

bc = matrix([[1, 0, 2], [1, 0, 2], [3, 0, 6]])

Weitere Befehle zum Umgang mit Matrizen finden sich indem Paket linalg. Wie wir im Programm des letzten Abschnitt schon gesehen haben, koennen wir mit coldim oder rowdim  die Spalten-  bzw.  Zeilendimension einer Matrix erfragen. Mit transpose laesst sich die transponierte Matrix angeben.

> with(linalg):
transpose(A);

Warning, the protected names norm and trace have been redefined and unprotected

matrix([[3, 0], [2, 1], [1, 1]])

oder komplexwertig

> A:=array([[1+I, 1+I], [1,1-I] ]);
transpose(A);

htranspose(A);

A := matrix([[1+I, 1+I], [1, 1-I]])

matrix([[1+I, 1], [1+I, 1-I]])

matrix([[1-I, 1], [1-I, 1+I]])

Mit dem Befehl htranspose erhalten Sie die transponierte konjugiert komplexe Matrix, die man  als hermitsch transponierte Matrix bezeichnet.

Mit einigen Befehlen lassen sich Matrizen mit einer speziellen Gestalt leichter eingeben. So erhalten wir etwa eine Diagonalmatrix durch

> diag(2,3,4,5);

matrix([[2, 0, 0, 0], [0, 3, 0, 0], [0, 0, 4, 0], [0, 0, 0, 5]])

Eine Einheitsmatrix bekommen wir somit durch

> diag(1,1,1);

matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]])

Eine Matrix, die auf den Diagonalen gleiche Eintraege hat, heisst Toeplitzmatrix . Eine symmetrische Toeplitzmatrix ergibt sich zum Beispiel  durch

> toeplitz([1,2,3,4]);

matrix([[1, 2, 3, 4], [2, 1, 2, 3], [3, 2, 1, 2], [4, 3, 2, 1]])

Die Vielzahl von Befehle etwa zu

symmetrische Matrizen oder Bandmatrizen.  Die Vielzahl von Befehlen zum Umgang mit Matrizen/Feldern wollen wir hier nicht alle aufzaehlen, aber es lohnt sich die Befehlsliste zum Paket linalg genauer durchzusehen.

>

Die inverse Matrix

Wenn eine inverse Matrix existiert, berechnet der Befehl  inverse  diese Inverse.

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



A := matrix([[1, 2, 3, 4], [1, 1, 0, 0], [0, 2, 1, 0], [2, 5, 1, 4]])

matrix([[1/6, 7/6, (-1)/3, (-1)/6], [(-1)/6, (-1)/6, 1/3, 1/6], [1/3, 1/3, 1/3, (-1)/3], [1/24, (-11)/24, (-1)/3, 5/24]])

Leicht laesst sich pruefen, ob eine Matrix orthogonal ist. Betrachten wir etwa eine der Matrizen aus der Selbstfrage auf Seite 534  

> B:=matrix(3,3,[[0,-1,0],[0,0,-1],[-1,0,0]]);
evalm(transpose(B)&*B);

B := matrix([[0, -1, 0], [0, 0, -1], [-1, 0, 0]])

matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]])

Also ist die Matrix orthogonal, die transponierte Matrix ist gerade die Inverse zu A.

> inverse(B);
transpose(B);

matrix([[0, 0, -1], [-1, 0, 0], [0, -1, 0]])

matrix([[0, 0, -1], [-1, 0, 0], [0, -1, 0]])

Die LR-Zerlegung einer Matrix ist durch den Befehl, LUdecomp, im Paket linalg vertreten. Der Befehl liefert als Ergebnis die Matrix U, die  obere  Dreiecksmatrix. (Im Englischen werden die beiden Matrizen mit  U fuer  upper und  L fuer  lower bezeichnet anstelle von L fuer linke unterer Dreiecksmatrix und R fuer rechte obere Dreiecksmatrix bezeichnet)  

> LUdecomp(A,L='l',U='u',P='p');

matrix([[1, 2, 3, 4], [0, -1, -3, -4], [0, 0, -5, -8], [0, 0, 0, 24/5]])

Mit den zusaetzlichen Argumenten hat der Befehl die Variablen l,u,p mit den entsprechenden Matrizen belegt, sodass die Identitaet A = `&*`(`&*`(p, l), u) gilt, wie wir schnell nachpruefen.

> evalm(l);
evalm(u);

evalm(p);

evalm(A) = evalm(p&*l&*u);

matrix([[1, 0, 0, 0], [1, 1, 0, 0], [0, -2, 1, 0], [2, -1, 8/5, 1]])

matrix([[1, 2, 3, 4], [0, -1, -3, -4], [0, 0, -5, -8], [0, 0, 0, 24/5]])

matrix([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]])

matrix([[1, 2, 3, 4], [1, 1, 0, 0], [0, 2, 1, 0], [2, 5, 1, 4]]) = matrix([[1, 2, 3, 4], [1, 1, 0, 0], [0, 2, 1, 0], [2, 5, 1, 4]])

Beachten Sie, dass die von Maple gelieferte Vertauschungsmatrix p gerade die Inverse der im Buch angegebenen Matrix P  (s. Seite 537) ist.

Ob eine Matrix ueberhaupt invertierbar ist, koennen wir  leicht anhand der Determinate pruefen, die mit dem Befehl det berechnet wird.

> det(A);

24

Die Adjunkte einer Matrix A bekommt man  direkt  durch

> adjoint(A);

matrix([[4, 28, -8, -4], [-4, -4, 8, 4], [8, 8, 8, -8], [1, -11, -8, 5]])

Wir koennen diese Matrix natuerlich auch durch multiplizieren der Inverse von A mit det(A) berechnen.

> evalm(det(A)*inverse(A));

matrix([[4, 28, -8, -4], [-4, -4, 8, 4], [8, 8, 8, -8], [1, -11, -8, 5]])

>

Aufgaben

1. Fuer welche reellen Werte a ist die Matrix

            [ 2   1   0   0 ]
            [ a   0   2   1 ]

            [ 1   a   1   1 ]

            [ 1   2   a   a ]

invertierbar ?

>

Loesung

2. Verifizieren sie fuer u=(1,2,3)^T  und v=(1,0,1)^T die Identitaeten:

     (I+u*v^T)*B =I = B*(I+u*v^T)      mit     B = I-uv^T/(1+v^T*u) .

>

Loesung

3. Losen Sie Aufgabe 6.14 im Buch mit Hilfe von Maple

>

Loesung

>