ZuweisungsOperatoren

________________________________________________________________________________

Inhalt....: Zuweisungs Operatoren mit hold und print

Kategorie.: Handwerkskasten

Mathematik: Programmierung

MuPAD.....: 3.1.1

Datum.....: 2005-12-20

Autoren...: Raymond Ami <r.ami@bluewin.ch>

Funktionen: proc, print, _assign, operator, expr2text, text2expr

Funktionen: eval, val, level, hold

Funktionen: Datei/Eigenschaften, reset

________________________________________________________________________________

Zuweisungs Operatoren mit hold und print

Zusätzlich zum Zuweisungs-Operator ":=" verbessern zwei ergänzende

Benutzer-spezifizierte Operatoren die Dokumentation im Ausgabeteil.

Zuweisungs Operator mit print ":=:"

Die Zuweisungsoperation ":=" gibt den Rückgabewert im Ausgabebereich aus.

Dies sofern die Operation nicht mit ":" abgeschlossen wurde. Es ist übersichtlich,

wenn man solche Zuweisungen wie folgt codiert:

delete A, B, C:

A:= B+C:

` A`=%;

Der Operator ":=:" vereinfacht diese Form von Zuweisungen:

delete A, B, C:

A:=: B+C:

Anmerkung:

Die Zuweisung mittels ":=:" wird vorteilhaft mit ":" abgeschlossen, da sonst

2 Ausgabezeilen (print und Rückgabewert) im Ausgabeteil erscheinen.

Das folgende Beispiel demonstriert das Verhalten von ":=:", falls auf bereits

belegte Variabeln Bezug genommen wird.

delete A,B,C:

C:=: 2:

A:=: B+C:

` A`=A;

Der ursprüngliche Ausdruck (B+C) wird zusätzlich als "[[ex:=Ausdruck "ausgegeben.

Er ist aber für spätere Auswertungen (zB: val(objekt)) verloren da ":=:" ohne hold()

arbeitet. Die Anzeige des Zusatzteils "[[ex:=Ausdruck" macht auf mögliche Fehler

(nicht gelöschte Variabeln) aufmerksam.

Vorteile von ":=:":

Die Zuweisung wird mit rechtem und linkem Teil ausgegeben, was die Lesbarkeit des

Ausgabeteils erhöht. Der ursprüngliche Ausdruck wird ebenfalls angezeigt, was auf

mögliche Fehler hinweist.

Zuweisungs Operator mit hold und print ":=="

Der Operator ":==" ist eine Erweiterung von ":=:" um die hold-Funktion für den rechten

Teil der Zuweisung.

Das folgende Beispiel zeigt einerseits die konventionelle und andererseits die

mit ":==" codierte Version. Beide Versionen haben denselben Effekt.

Auch hier wird die Zuweisung von Vorteil mit ":" abgeschlossen.

delete A, B, C:

C:=1:

// manuelle Variante

A:= hold(B+C):` A`=(val(A)=A);

//Variante mit ":=="

A:==B+C:

Aus dem Beispiel geht auch ein Vorteil von hold() hervor: hold() verhindert das

Evaluieren des rechten Teils der Zuweisung. Dadurch wird die Variable C nicht

durch 1 ersetzt sodern es bleibt ein Verweis auf C bestehen.

Ohne hold() führt dies bei nachfolgender Aenderung der Variablen C zu ungewollten

Effekten, wie folgendes Beispiel zeigt:

delete A, B, C:

C:=:1:

A:=:B+C:

C:=:2:

` -------------`;

` val(A)`=val(A);

` A`=A, "falsch";

Anders mit hold, das im Operator ":==" integriert ist:

delete A, B, C:

C:=:1:

A:==B+C:

C:=:2:

` -------------`;

` val(A)`=val(A);

` A`=A, "richtig";

Natürlich kann auch ohne ":==" mit hold() gearbeitet werden.

Das folgende Beispiel arbeitet mit hold() aber ohne Verwendung von ":==".

delete A, B, C:

C:=1: ` C`=%;

A:=hold(B+C):` A`=(val(A)=A);

C:=2:` C`=%;

` -------------`;

` val(A)`=val(A);

` A`=A, "richtig";

Vorteil von ":==" resp. hold():

Die zusätzlichen Informationen im Ausgabeteil macht das Worksheet lesbarer.

Der Zugriff auf die ursprüngliche Definition ist auch dann noch möglich, wenn einer

oder mehreren Variablen des Objektes bereits vorangehend ein Wert zugewiesen

wurde. Ausserdem bleibt das Resultat korrekt, wenn nachträglich einer oder mehreren

Variablen ein neuer Wert zugewiesen wird.

Anmerkung:

Mögliche Nachteile von Benutzer-spezifierten Operatoren:

- Nicht ohne weiteres für andere Anwender transparent/verständlich

- Das kopieren von Code in andere Worksheets ist nur bedingt möglich

Mögliche Nachteile bei der Anwendung von hold():

- Laufzeit erhöht sich (meistens nicht merklich)

- in einigen Fällen muss eval() zur Auflösung des Hold-Zustandes

zwingend verwendet werden

Definition der Prozeduren und der Operator-Zeichen

Sofern ":=:" und ":==" genutzt werden sollen, müssen die folgenden zwei

Prozeduren in Datei/Eigenschaften abgelegt werden. (Ist in diesem

Worksheet bereits der Fall).

Mit jedem reset() resp. beim Start des Worksheets werden die

Operator-Zeichen neu aktiviert.

//===== Hold-Zuweisungs-Operator =======================

HDO:= proc()

begin

HDP:= proc (HD_left,HD_right)

option hold;

local Zuweisung;

begin

if expr2text(HD_right)

expr2text(context(HD_right)) then:

print(Typeset, HD_left = HD_right):

else:

print(Typeset, HD_left =

(HD_right = context(HD_right))):

end_if:

Zuweisung:="_assign(".expr2text(HD_left)

.",hold(".expr2text(HD_right)."))":

// lokale Variablen als Global behandeln:

eval(text2expr(Zuweisung)):

HD_right;

end_proc:

operator(":==", Delete, Global):

operator(":==", HDP, Binary, 15, Global):

end_proc:

HDO():

//======================================================

//===== NOHold-Zuweisungs-Operator =====================

NHO:= proc()

begin

NHP:= proc (NH_left,NH_right)

option hold;

local Zuweisung;

begin

if expr2text(NH_right)

expr2text(context(NH_right)) then:

print(Typeset, NH_left = context(NH_right)):

else:

print(Typeset, NH_left =

context(NH_right), ` [[ex:`=NH_right):

end_if:

Zuweisung:="_assign(".expr2text(NH_left)

.",".expr2text(NH_right).")":

// lokale Variablen als Global behandeln:

eval(text2expr(Zuweisung)):

NH_right;

end_proc:

operator(":=:", Delete, Global):

operator(":=:", NHP, Binary, 15, Global):

end_proc:

NHO():

//======================================================

Der folgenden Teil demonstriert das Verhalten der Zuweisungs-

Operatoren in verschiedenen Situationen.

Verhalten nach reset()

Wenn die Prozedur- und Operation-Zuweisung in Datei/Eigenschaften abgelegt wurde,

funktioniert das neue Operator-Zeichen auch nach einem reset().

reset():

// reset() MUSS ein eigener Eingabe-Bereich sein.

delete A, B, C:

A:=:B:

C:=:2:

B:==C:

Verhalten bei rekursiver Zuweisung

Generell darf hold() bei rekursiver Verwendung einer Variable nicht eingesetzt werden.

Somit ist auch ":==" in diesen Fällen nicht einsetzbar.

(die folgenden zwei Teile sind Text, sodass "Notebook/Evaluiere/Alle"

ohne Stop nach einer Errormeldung durchläuft)

delete A:

A:=1;

A:=hold(A+1);

` -------------`;

` A`=A;

Error: Recursive definition [See ?MAXLEVEL]

delete A:

A:== 1:

A:== A+1:

` -------------`;

` A`=A;

Error: Recursive definition [See ?MAXLEVEL]

Ohne hold ergibt sich keine Fehlermeldung

delete A:

A:=: 1:

A:=: A+1:

` -------------`;

` A`=A;

Verhalten innerhalb Ausdruck-Sequenz

Im Gegensatz zu ":=" kann ":==" und ":=:" auch innerhalb einer Ausdrucksequenz

verwendet werden, da mit der Funktion _assign anstelle von ":=" gearbeitet wird.

delete A, B, AB:

AB:= ( A:==1, B:==A+1):

` -------------`;

` A`=A, ` B`=B, ` AB`=AB;

` val(B)`=val(B);

` val(AB)`=val(AB);

` eval(AB)`=eval(AB);

delete A, B, AB:

AB:= ( A:=:1, B:=:A+1):

` -------------`;

` A`=A, ` B`=B, ` AB`=AB;

` val(B)`=val(B);

` val(AB)`=val(AB);

` eval(AB)`=eval(AB);

Anmerkung:

Die Befehlsseqenz "AB:== A:==1, B:==2:" ist nicht möglich. Hingegen führt

"AB:= A:==1, B:==2:" zum erwarteten Resultat.

Dasselbe gilt für ":=:".

Verhalten im Zusammenhang mit solve

hold() im Zusammenhang mit solve() kann zu unendlichen Rekursionen führen.

Entsprechend ist auch ":==" in Verbindung mit solve() ungeeignet.

(der folgende Teil ist Text, sodass "Notebook/Evaluiere/Alle"

ohne Stop nach einer Errormeldung durchläuft)

delete x:

x:==(solve(x^2 + (2*x) +1/3 = 0,x)):

Error: Recursive definition [See ?MAXLEVEL]

Hingegen ist ":=:" wie folgt einsetzbar:

delete x:

x:=:(solve(x^2 + (2*x) + 1/3 = 0,x)):

________________________________________________________________________________

Weitere Anregungen zum Einsatz von MuPAD in der Lehre finden Sie auf unserem WebPortal

MuPAD in Schule und Studium unter: http://schule.mupad.de bzw. http://studium.mupad.de.

________________________________________________________________________________