MuPAD in Vorlesung und Übungen (12. Woche)

Transkript

1 MuPAD in Vorlesung und Übungen (12. Woche Zur Behandlung der laufenden Übungsaufgaben (Blatt 12, 13 ff. sind zur Lösung gewisse Buchführungsaufgaben wahrzunehmen, die wir sinnvoll dem MuPAD-System übertragen. Wir schlagen dabei zwei Fliegen mit einer Klappe: Zusätzlich werden wir nämlich Systemnamen, die ziemlich lang ausfallen können, wie <linalg::addrow(...> durch private Abkürzungen ersetzen und dadurch den Umgang mit dem System handlicher machen. Wir definieren eine Liste mit dem Namen <protokoll>, welche die verwendeten elementaren Zeilenoperationen protokolliert. Bei einer Liste kommt es - im Unterschied zu einer Menge auf die Reihenfolge an. Bezeichung [1, a, X] statt {1, a, X} reset(: bool({1,a,x}={a,x,1} true bool([1,a,x]=[a,x,1] false false Protokollieren von elementaren Zeilentransformationen Wir definieren ausgehend von <linalg::addrow> eine neue Operation <ar>, welche zusätzlich zur ersten der Liste <protokoll> einen neuen (letzten Eintrag a(i,j,a hinzufügt. Entsprechendes machen wir mit den beiden anderen Typen von elementaren Zeilenumformungen,

2 dem Vertauschen v(i, j und der Multiplikation m(i, a der i-ten Zeile mit dem Faktor a. Die privaten Kommandos wie <ar> erklären wir in Form einer Prozedur. Erläuterungen gibt Ihnen das System - wie üblich - durch den Aufruf:?proc ar:=proc(a,i,j,b protokoll:=[op(protokoll,a(i,j,b]: linalg::addrow(a,i,j,b end_proc; mr:=proc(a,i,b protokoll:=[op(protokoll,m(i,b]: linalg::multrow(a,i,b end_proc; vr:=proc(a,i,j protokoll:=[op(protokoll,v(i,j]: linalg::swaprow(a,i,j end_proc proc ar!a, i, j, b"... end proc mr!a, i, b"... end proc vr!a, i, j"... end Die Aufgabe sei, die folgende Matrix zu invertieren: A:=matrix([ [2,3,6], [3,4,5], [1,2,3]] # $ Wir erweitern dazu A mit der 3x3-Einheitsmatrix, bilden also B:=[A E_3]. E_3:=matrix(3,3,0:

3 for i from 1 to 3 do E_3[i,i]:=1 end_for: B:=A.E_3 # $ Die Matrix B bringen wir auf Zeilenstufenform und protokollieren die verwendeten Zeilentransformationen. Vor der ersten Zeilenoperation ist die Buchführung leer: protokoll:=[]: ar(b,3,1,-2: ar(,3,2,-3: vr(,1,3 # $ ar(,3,1,2: ar(,3,2,-2: vr(,3,2: mr(,2,-1 # $ mr(,3,-1/4: ar(,3,1, ( 1 ( ( 9 4 ' ( ( 1 ( protokoll, - a!3, 1, 2", a!3, 2, 3", v!1, 3", a!3, 1, 2", a!3, 2, 2", v!3, 2", m!2, 1", m 3, 1 4 (., a

4 In unserem Protokoll haben wir alle verwendeten Zeilentransformationen in der verwendeten Reihenfolge festgehalten. Determinantenberechnung Normalerweise ist es - für Anfänger - eine gute Praxis, eine neue Sitzung mit dem <reset(> -Kommando zu starten, welches alle vorherigen Zuweisungen löscht. Für die folgenden Rechnungen wollen wir jedoch auf die privaten Prozeduren <ar>, <mr> und <vr> zurückgreifen, die wir nicht löschen wollen. Hinweis: Einzelne Zuweisungen lassen sich durch das Kommando <delete> löschen. B # $ delete(b B B Wir starten jetzt mit der 5x5-Matrix A:=matrix([ [1, 1, 0, 1, 1], [2, 3, 3, 4, 3], [3, 4, 4, 6, 6], [4, 5, 6, 7, 7], [5, 6, 6, 7, 8]] ' Wir wollen die Determinante von A mittels elementarer Spaltenumformungen

5 berechnen, haben bisher aber nur ein Protokollsystem für Zeilenumformungen. Wir haben 2 Möglichkeiten: (1 das entsprechende Protokollsystem für Spaltenumformungen zu entwickeln, (2 die Matrix A zu transponieren (Befehl linalg::transpose(a und dadurch Spalten von A zu Zeilen der transponierten Matrix B zu machen. Wir schlagen den zweiten Weg ein: B:=linalg::transpose(A ' Wir protokollieren die elementaren Zeilenumformungen, und leeren dazu zunächst die Liste < protokoll >. protokoll:=[]: ar(b,1,2,-1: ar(,1,4,-1: B1:=aR(,1,5, ' ar(b1,2,1,-2: ar(,2,3,-3: ar(,2,4,-2: B2:=aR(,2,5, ' ar(b2,3,1,-1: ar(,3,2,-1:

6 ar(,3,4,-1: B3:=aR(,3,5, ' mr(b3,4,-1/2: ar(,4,1,1: ar(,4,2,2: ar(,4,3,-3: B4:=aR(,4,5, ( ( 3 2 ' ( mr(b4,5,1/2: ar(,5,1,-3/2: ar(,5,2,-1: ar(,5,3,3/2: ar(,5,4,-3/ ' protokoll, a!1, 2, 1", a!1, 4, 1", a!1, 5, 1", a!2, 1, 2", a!2, 3, 3", a!2, 4, 2", a!2, 5, 1", Dieses Protokoll ist etwas lang geraten. Wir können es - in optisch weniger ansprechender Form - mittels des <print>-befehls vollständig auf die Seite bringen. Die Ausgabe ist dann durch Copy-Paste abgreifbar.

7 print(protokoll [a(1, 2, -1, a(1, 4, -1, a(1, 5, -1, a(2, 1, -2, a(2, 3, -3, a(2, 4, -2, a(2, 5, -1, a(3, 1, -1, a(3, 2, -1, a(3, 4, -1, a(3, 5, -2, m(4, -1/2, a(4, 1, 1, a(4, 2, 2, a(4, 3, -3, a(4, 5, 4, m(5, 1/2, a(5, 1, -3/2, a(5, 2, -1, a(5, 3, 3/2, a(5, 4, -3/2] Wir lesen ab: Zeilenvertauschungen hatten wir keine. Zeilenmultiplikationen haben wir 2 mit den Faktoren -1/2 und 1/2. Die Determinante von A ist daher -4. Zur Kontrolle verwenden wir die eingebaute Determinantenfunktion <linalg::det>: Das Auslesen der Werte können wir natürlich dem System übertragen. linalg::det(a 4 Professionelles Auslesen Was wir zum Schluß gemacht haben ist wenig professionell. Das Auslesen der Vertauschungsbzw. Multiplikationsvorgänge sollten wir dem System übertragen! Allerdings ist hierzu eine gewisse Systemkenntnis notwendig. Wie kommen wir an die Prokolldaten heran? Das nächste Kommando wählt den 4- ten Eintrag: x:=protokoll[4] a!2, 1, 2" Wir würden durch nachfolgende Eingabe <x[1]> die Ausgabe a erwarten,

8 werden jedoch unangenehm überrascht. x[1] x 1 Der Grund für diese Schwierigkeit ist, dass MuPAD x als Funktion interpretiert: type(x "function" Um auf die Bezeichung a zugreifen zu können beseitigen wir daher zunächst die Funktionscharakteristik des Ausdrucks und wandeln ihn in Text um. Dies geschieht durch <expr2text>: y:=expr2text(x "a!2, 1, 2"" Jetzt können wir endlich durch <y[0]> auf a zugreifen: y[0] "a" Nach diesen Mühen können wir den m-anteil bzw. den v-anteil der Liste <protokoll> auslesen. Wir definieren zwei Vorschriften <f_m> und <f_v>, die Übereinstimmung mit "m" bzw. "v" feststellen und verwenden das <select>-kommando zum Auslesen. f_m:=proc(x expr2text(x[0]="m" end_proc; f_v:=proc(x expr2text(x[0]="v" end_proc; proc f_m!x"... end proc f_v!x"... end protokoll_m:=select(protokoll,f_m;

9 protokoll_v:=select(protokoll,f_v, - m 4, 1 2 (., m -5, 1 2 (./ 01 Hier können wir durch weiteres Extrahieren das System die Determinante berechnen lassen, oder dies jetzt per Hand tun. Alternative: Statt uns in die Datenstrukturen des Systems zu vertiefen, hätten wir zur Berechnung von Determinanten alternativ separate Listen für die drei Typen von Zeilenumformungen anlegen können.