kapitel-14maple.html

Mathematik

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

(zu Kapitel 14: Lineare Gleichungssysteme)

> restart;

Loesung linearer Gleichungssysteme

Um ein lineares Gleiichungssystem mit einem Computeralgebrasystem zu loesen, muss zunaechst die erweiterte Koeffizientenmatrix eingegeben werden. Dazu koennen wir in Maple den Datentypen matrix nutzen. Es ist etwa

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

Dabei bezeichnet das erste Argument die Anzahl der Zeilen, also die Anzahl der Gleichungen in unserem System. Die zweite Zahl gibt die Anzahl der Spalten und somit die Anzahl der Unbekannten des Systems an. Im dritten Argument werden alle Koeffizienten des Systems in Form einer Liste von Listen (den einzelnen Zeilen) gesammelt.

Auf einzelne Elemente in der Matrix koennen wir direkt zugreifen, etwa auf den dritten Eintrag in der zweiten Zeile durch

> A[2,3];

Nun wollen wir das lineare Gleichungssystem aus der Anwendung auf Seite 479 im Buch angehen. Dazu geben wir zunaechst die Koeffizientenmatrix ein. Wir legen die Spalten fest, indem wir die 6 Unbekannten in der Reihenfolge

zusammenstellen. Dann lautet die Koeffizientenmatrix

> A:=matrix(6,6,[[-2040,-2040,2020,0,1140,0],[2040,0,-2020,-2020,0,1140],[-2450,-2450,2570,0,1380,0],[2450,0,-2570,-2570,0,1380],[-4280,-4280,2960,0,1560,0],[4280,0,-2960,-2960,0,1560]]);

Fuer die erweiterte Koeffizientenmatrix benoetigen wir noch die rechte Seite, die auch als Matrix eingegeben werden kann.

> b:=matrix(6,1,[-300,-120,-340,-180,-810,-50]);

Eine Variante des Eleminationsverfahrens von Gauss steht nun zur Verfuegung. Das Programm zusammen mit vielen weiteren zur linearen Algebra ist im Paket linalg zu finden. Also laden wir dieses Paket:

> with(linalg):

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

(Bemerkung: Haetten wir den letzten Befehl mit einem Semikolon anstelle des Doppelpunkts abgeschlossen, so wuerde uns eine Liste aller Befehle angezeigt, die in diesem Paket zu finden sind. Schauen Sie sich die Begriffe ruhig schon an. Vielleicht entdecken Sie ja den einen oder anderen, der Ihnen bekannt vorkommt.)

Somit stehen nun eine ganze Reihe von Befehlen zum Umgang mit linearen Gleichungssystemen zur Verfuegung. Eine Loesung des LGS wird durch den Befehl linsolve bestimmt.

> l:=linsolve(A,b);

Gerne wuerden wir die Zahlen auch im Fliesskommaformat ansehen, also

> evalf(l);

... Das funktioniert leider so nicht!

Wollen wir die Matrix wieder betrachten, so muessen wir mit dem Befehl evalm zunaechst auswerten, d.h. Befehle von der Form

> evalm(l);
evalf(evalm(l));

matrix([[1333/12000], [211/1200], [5071/36000], [433/3600], [73/108000], [17137/108000]])

matrix([[.1110833333], [.1758333333], [.1408611111], [.1202777778], [0.6759259259e-3], [.1586759259]])

sind erforderlich. Nun laesst sich das Ergebnis bequem ablesen und mit dem im Buch angegebenen vergleichen.

Mit dem Befehl rank wird der Rang einer Matrix bestimmt, sodas wir auch die Loesbarkeit des Systems durch Vergleichen von

> rank(A);

mit dem Rang der erweiterten Koeffizientenmatrix pruefen koennen. Dazu fuegen wir die Koeffizientenmatrix und die rechte Seite mit dem Befehl concat (oder auch augment) horizontal zu einer Matrix zusammen und erhalten

> concat(A,b);
rank(concat(A,b));

matrix([[-2040, -2040, 2020, 0, 1140, 0, -300], [2040, 0, -2020, -2020, 0, 1140, -120], [-2450, -2450, 2570, 0, 1380, 0, -340], [2450, 0, -2570, -2570, 0, 1380, -180], [-4280, -4280, 2960, 0, 1560, 0,...

(Bemerkung: Wenn die Eintraege der Matrix "floating point" Zahlen sind, wird zur Berechnung des Rangs eine Singulaerwertzerlegung von Maple durchgefuehrt. Worum es sich dabei handelt, wird spaeter im Buch erlaeutert.)

Da wir es mit einem Computeralgebrasystem zu tun haben, koennen wir auch Parameter abhaengige Systeme, wie im Beispiel auf Seite 474 loesen. Betrachten wir etwa das System

und

Wir geben die Koeffizientenmatrix und die rechte Seite ein:

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

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

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

und erhalten als Loesung

> linsolve(A,b);

matrix([[(3*d-4+c)/(-4+c)], [-3*d/(-4+c)], [d*(-1+c)/(-4+c)]])

Dies ist eine formale Loesung, da der offensichtlich kritische Fall bei , nicht getrennt untersucht wird. Ersetzen wir durch

> A:=subs(c=4,evalm(A));

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

und betrachten erneut das Ergebnis von

> linsolve(A,b);

Da es zumindest, wenn d nicht 0 ist, keine Loesung zu diesem System gibt, bekommen wir kein Resultat. Mit erhalten wir aber

> b:=subs(d=0,evalm(b));
linsolve(A,b);

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

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

Maple hat eine Hilfsvariable eingefuehrt, da es unendlich viele Loesungen zum Gleichungssystem gibt. Alle diese Loesungen sind von der angegebenen Gestalt (liegen auf einer Geraden), wobei die Hilfsvariable jede beliebige Zahl sein kann.

Mit Hilfsvariablen werden gegebenenfalls auch die Loesungsmengen angezeigt, wenn weniger Gleichungen als Unbekannte betrachtet werden. Zum Beispiel zwei Hilfsvariablen bei

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

matrix([[_t[1][1]], [_t[1][2]], [3-2*_t[1][2]+_t[1][1]], [-2-_t[1][1]+_t[1][2]]])

Einzelne Gauss'sche Eleminationsschritte

Da man sich beim Loesen von linearen Gleichungssystemnen gerne verrechnet, ist es angenehm, einzelne Gaussschritte mit dem Rechner zu pruefen. Dazu bietet sich der Befehl addrow (A,r1,r2,p) an, der die Zeile r2 durch r2+p*r1 ersetzt. Zum Beispiel ergibt sich fuer

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

wenn wir 3 mal die zweite Zeile zur ersten addieren

> addrow(A,2,1,3);

Um eigenen Rechnungen auf dem Weg zu einer reduzierten Zeilenstufenform leicht ueberpruefen zu koennen, bietet sich ein eigenes Programm an. Dazu dient in Maple der Befehl proc . Versuchen Sie die Schritte im Programm nachzuvollziehen. Das Programm ist so geschrieben, dass Sie interaktiv jeweils ein Pivotelemente angeben koennen.

Kopieren Sie das Programm in ein neues Worksheet und verwenden Sie es, um Ihre Hausaufgaben zu pruefen.

> gjcheck:=proc(a,b)
local al, bl, piv, seperat, tmp, j:

#Eingabe testen
al:= a: bl:=b:
if type(al,array) then
   seperat:=array([seq([`|`],j=1..rowdim(al))]):              #Trennstriche zur Darstellung
   if (type(bl,array) and rowdim(al)=rowdim(bl)) then
     tmp := concat(al,bl);
     print(evalm(concat(al,seperat,bl)));
     piv:=readstat("Pivotelement ?"):

     #Gauss Schritte
     while (piv <> 0) do
       tmp:=pivot(tmp,piv[1],piv[2]):

       #Ausgabe und Eingabe des neuen Pivotelements
       al:=submatrix(tmp,1..rowdim(al),1..coldim(al)):
       bl:=submatrix(tmp,1..rowdim(bl),(coldim(al)+1)..coldim(tmp)):                                                                                                                                                                         print(evalm(concat(al,seperat,bl)));
       piv:=readstat("Pivotelement ?"):
     od:
     "Tschuess";
   else
     "falsche Eingabe";
   fi:
else
  "falsche Eingabe";
fi:
end:

(Es wird hier insbesondere der Befehl pivot genutzt, der durch elementare Zeilenumformungen zu einem angegebenen Pivotelement die entsprechende Stufe berechnet )

Definieren wir noch eine rechte Seite

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

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

Jetzt koennen wir das Programm nutzen. Dazu geben Sie das gewuenschte Pivotelement in der Form " (3,1); " direkt nach der Aufforderung hinter dem Fragezeichen ein. Wenn Sie anstelle eines Paars von Indizes " 0; " angeben, so bricht das Programm ab.

> gjcheck(A,b);

matrix([[1, 0, 1, `|`, 1], [1, 2, 0, `|`, 1], [1, 1, 1, `|`, 0]])

Pivotelement ? 0;

(Bemerkung: Sie koennen Prozeduren auch mit einem beliebigen Editor in einer Datei eingeben, und diese dann mit
read(Dateiname) in eine Maplesitzung einlesen. Dabei ist zu beachten, dass nach dem end: noch ein return eingegeben wird, also der Cursor im Editor unter dieser Zeile steht, da der Programmtext sonst nicht ausgefuehrt wird.
Um formatierte Daten, wie zum Beispiel eine Matrix, aus einer Datei einzulesen, gibt es den Befehl fscanf , wie er aus c-Bibliotheken eventuell bekannt ist.)

Im Programm haben wir eine Moeglichkeit genutzt, Matrizen durch die Angabe von Operatoren einzugeben.

> matrix(3,5,(i,j)->1/(i^2+j^2));

matrix([[1/2, 1/5, 1/10, 1/17, 1/26], [1/5, 1/8, 1/13, 1/20, 1/29], [1/10, 1/13, 1/18, 1/25, 1/34]])

Anstelle einer Liste wird bei dieser Version einfach die Zuordnung angegeben, wie der (i,j)te Eintrag der Matrix zu bilden ist.

Aufgaben

1. Loesen Sie das linearen Gleichungssysteme

das System

sowie das komplexe LGS (s. Aufg. 14.9)

Loesung

2. Pruefen Sie indem Sie den Rang der Koeffizientenmatrix und der erweiterten Koeffizientenmatrix bestimmen, dass das folgende Gleichungssystem loesbar ist,

Loesung

3. Loesen Sie Aufgabe 14.8 im Buch, d.h. es ist nach den Loesungen des linearen Gleichungssystems

in Anbhaengigkeit eines Parameters a gefragt.

Loesung