Vorige: Einführung in die Programmierung, Nach oben: Programmierung [Inhalt][Index]
Gibt den Aufruf-Stack der Funktion zurück, die ausgeführt wird.
Das Kommando backtrace()
zeigt den gesamten Stack.
backtrace(n)
zeigt die letzten n Funktionen
einschließlich der Funktion, die ausgeführt wird.
backtrace
kann in einer Batch-Datei, die zum Beispiel mit der Funktion
batch
geladen wird, in einer Funktion oder von einer Kommandozeile
aufgerufen werden.
Beispiele:
backtrace()
gibt den gesamten Stack aus.
(%i1) h(x) := g(x/7)$ (%i2) g(x) := f(x-11)$ (%i3) f(x) := e(x^2)$ (%i4) e(x) := (backtrace(), 2*x + 13)$ (%i5) h(10); #0: e(x=4489/49) #1: f(x=-67/7) #2: g(x=10/7) #3: h(x=10) 9615 (%o5) ---- 49
backtrace(n)
gibt die letzten n Funktionen aus.
(%i1) h(x) := (backtrace(1), g(x/7))$ (%i2) g(x) := (backtrace(1), f(x-11))$ (%i3) f(x) := (backtrace(1), e(x^2))$ (%i4) e(x) := (backtrace(1), 2*x + 13)$ (%i5) h(10); #0: h(x=10) #0: g(x=10/7) #0: f(x=-67/7) #0: e(x=4489/49)
9615 (%o5) ---- 49
Mit der Anweisung block
werden Ausdrücke in einer lokalen Umgebung
zusammengefasst. block
wertet die Argument expr_1, expr_2,
…, expr_n nacheinander aus und gibt das Ergebnis des letzten
ausgewerteten Ausdrucks zurück. Die Liste [v_1, ..., v_m]
am Anfang
der block
-Anweisung bezeichnet Variablen, die innerhalb der
block
-Anweisung lokal sind. Alle anderen Variablen, die in einem Block
verwendet werden, beziehen sich auf globale Variablen, die außerhalb des Block
definiert sind. Dies kann ein weiterer Block oder die globale Maxima-Umgebung
sein. block
sichert die aktuellen Werte der Variablen v_1,
…, v_m. Wird block
verlassen, werden diese Werte
wiederhergestellt.
Die Deklaration local(v_1, ..., v_m)
innerhalb der
block
-Anweisung sichert nicht nur die Werte, sondern auch die
Eigenschaften der Variablen wie sie zum Beispiel mit den Funktionen
declare
oder depends
definiert werden. Erhalten die mit
local
deklarierten Variablen innerhalb der block
-Anweisung
Eigenschaften, wirken sich diese nur lokal aus. Beim Verlassen der
block
-Anweisung werden die globalen Eigenschaften wiederhergestellt.
Siehe auch local
.
Die block
-Anweisung kann verschachtelt werden. Jeder Block kann
eigene lokale Variablen definieren. Diese sind global zu jedem anderen Block
der sich innerhalb des Blockes befindet. Ein Variable die nicht als lokal
definiert ist, hat den globalen Wert eines umgebenden Blocks oder den Wert der
globalen Maxima-Umgebung.
Der Rückgabewert eines Blocks ist der Wert des letzten Ausdrucks oder der
Wert, der mit den return
-Anweisung zurückgegeben wird. Mit der
go
-Anweisung kann innerhalb eines Blocks zu einer Marke gesprungen
werden. Weiterhin kann mit der throw
-Anweisung ein nicht-lokaler
Rücksprung zu einer entsprechenden catch
-Anweisung erfolgen.
Blöcke erscheinen typischerweise auf der rechten Seite einer Funktionsdefinitionen. Sie können aber auch an anderen Stellen verwendet werden.
Beispiel:
Das Beispiel zeigt eine einfache Implementation des Newton-Algorithmus. Der
Block definiert die lokalen Variablen xn
, s
und numer.
numer
ist eine Optionsvariable, die im Block einen lokalen Wert erhält.
Im Block ist das Tag loop
definiert. Zu diesem Tag wird mit der
Anweisung go(loop)
gesprungen. Der Block und damit die Funktion wird
mit der Anweisung return(xn)
verlassen. Der Wert der Variablen xn
ist das Ergebnis der Funktion newton
.
newton(exp,var,x0,eps):= block([xn,s,numer], numer:true, s:diff(exp,var), xn:x0, loop, if abs(subst(xn,var,exp))<eps then return(xn), xn:xn-subst(xn,var,exp)/subst(xn,var,s), go(loop) )$
Wertet die Ausdrücke expr_1, …, expr_n aus, zeigt die
Ergebnisse an und führt dann eine Unterbrechung aus. Mit dem Kommando
exit;
wird Maxima fortgesetzt. Siehe das Kapitel
Beispiel:
Der Variablen a
wird der Wert 2 zugewiesen. Dann wird die Unterbrechung
ausgeführt. Mit dem Kommando exit;
wird Maxima fortgesetzt.
(%i1) break(a:2); 2 Entering a Maxima break point. Type 'exit;' to resume. _a; 2 _exit; (%o1) 2
Wertet die Ausdrücke expr_1, …, expr_n nacheinander aus.
Wertet irgendeiner der Ausdrücke zu throw(arg)
aus, dann ist das
Ergebnis der Wert von throw(arg)
und es werden keine weiteren Ausdrücke
ausgewertet. Diese nicht-lokale Rückgabe kehrt zu dem nächsten catch
in einer beliebigen Verschachtelungstiefe zurück. Wird kein catch
gefunden gibt Maxima eine Fehlermeldung aus.
Führt die Auswertung der Argumente nicht zu einem throw
, dann ist
die Rückgabe das Ergebnis des letzten Ausdrucks expr_n
.
Beispiel:
Die Funktion g
gibt eine Liste mit den Werten des Lambda-Ausdrucks
zurück. Tritt ein negativer Wert auf, bricht die Funktion ab, in diesem
Beispiel mit throw(-3)
.
(%i1) lambda ([x], if x < 0 then throw(x) else f(x))$ (%i2) g(l) := catch (map (''%, l))$ (%i3) g ([1, 2, 3, 7]); (%o3) [f(1), f(2), f(3), f(7)] (%i4) g ([1, 2, -3, 7]); (%o4) - 3
Die do
-Anweisung erlaubt die Definition von Iterationen. Aufgrund der
großen Allgemeinheit der do
-Anweisung folgt die Beschreibung in zwei
Teilen. Zunächst werden die bekannteren Formen beschrieben, wie sie auch in
anderen Programmiersprachen vorhanden sind. Dann folgen die weiteren
Möglichkeiten.
Es gibt drei Varianten der do
-Anweisung, die sich nur durch die
Abbruchbedingung voneinander unterscheiden. Diese sind:
for variable: initial_value step increment thru limit do body
for variable: initial_value step increment while condition do body
for variable: initial_value step increment unless condition do body
initial_value, increment, limit und body können
beliebige Ausdrücke sein. Ist das Inkrement 1, kann step
entfallen.
Die Ausführung der do
-Anweisung beginnt mit der Zuweisung von
initial_value
an die Kontrollvariable variable. Dann folgen die
Schritte: (1) Hat die Kontrollvariable den Wert einer thru
-Anweisung
überschritten oder hat die Bedingung einer unless
-Anweisung den Wert
true
oder hat die Bedingung einer while
-Anweisung den Wert
false
, dann endet die Ausführung der do
-Anweisung. (2) Die
Ausdrücke in body werden ausgewertet. (3) Das Inkrement wird zu der
Kontrollvariablen hinzuaddiert. Die Schritte (1) bis (3) werden solange
ausgeführt, bis eine der Bedingungen für die Beendigung der
do
-Anweisung zutrifft.
Im Allgemeinen ist der thru
-Test erfüllt, wenn die Kontrollvariable
größer als limit ist, falls increment nicht negativ ist. Oder
wenn die Kontrollvariable kleiner als limit
ist, für den Fall, dass das
Inkrement negativ ist. increment und limit können Ausdrücke
sein, sofern die Bedingung zum Abbruch der do
-Anweisung ausgewertet
werden kann. Soll increment
zu einem negativen Wert auswerten und kann
dies jedoch bei Eintritt in die Schleife von Maxima nicht festgestellt werden,
so wird das Inkrement als positiv angenommen. Dies kann dazu führen, dass die
Schleife nicht korrekt ausgeführt wird.
limit, increment und die Bedingung für den Abbruch der Schleife werden für jeden Durchgang durch die Schleife ausgewertet. Ändern diese ihren Wert nicht, kann es daher effizienter sein, die Werte diese Ausdrücke vor Eintritt in die Schleife zu berechnen und in Variablen abzulegen, die anstatt der Ausdrücke in der Schleife verwendet werden.
Die do
-Anweisung hat den Rückgabewert done
. Um einen anderen
Wert zurückzugeben, kann die return
-Anweisung innerhalb von
body
genutzt werden. Befindet sich die do
-Anweisung innerhalb
eines Blockes, so wird dieser nicht mit einer return
-Anweisung verlassen,
die sich innerhalb der do
-Anweisung befindet. Auch kann nicht mit der
go
-Anweisung in einen umgebenen Block gesprungen werden.
Die Kontrollvariable ist immer lokal zur do
-Anweisung. Nach dem
Verlassen der do
-Anweisung kann auf die Kontrollvariable nicht mehr
zugegriffen werden.
(%i1) for a:-3 thru 26 step 7 do display(a)$ a = - 3 a = 4 a = 11 a = 18 a = 25
Die Bedingung while i <= 10
ist äquivalent zu den Bedingungen
unless i > 10
und thru 10
ist.
(%i1) s: 0$ (%i2) for i: 1 while i <= 10 do s: s+i; (%o2) done (%i3) s; (%o3) 55
Berechne die ersten acht Terme einer Taylorreihe in einer do
-Schleife.
(%i1) series: 1$ (%i2) term: exp (sin (x))$ (%i3) for p: 1 unless p > 7 do (term: diff (term, x)/p, series: series + subst (x=0, term)*x^p)$ (%i4) series; 7 6 5 4 2 x x x x x (%o4) -- - --- - -- - -- + -- + x + 1 90 240 15 8 2
In diesem Beispiel wird die negative Wurzel von 10 mit einem Newton-Raphson-Algorithmus berechnet.
(%i1) poly: 0$ (%i2) for i: 1 thru 5 do for j: i step -1 thru 1 do poly: poly + i*x^j$ (%i3) poly; 5 4 3 2 (%o3) 5 x + 9 x + 12 x + 14 x + 15 x (%i4) guess: -3.0$ (%i5) for i: 1 thru 10 do (guess: subst (guess, x, 0.5*(x + 10/x)), if abs (guess^2 - 10) < 0.00005 then return (guess)); (%o5) - 3.162280701754386
Anstatt eines festes Inkrements mit step
kann die Kontrollvariable auch
mit next
für jeden Schleifendurchgang berechnet werden.
(%i6) for count: 2 next 3*count thru 20 do display (count)$ count = 2 count = 6 count = 18
Anstatt mit der Syntax for variable: value ...
kann die
Kontrollvariable auch mit for variable from value ...do...
initialisiert werden. Wird auch from value
fortgelassen, wird
die Kontrollvariable mit dem Wert 1 initialisiert.
Manchmal kann es von Interesse sein, in einer Schleife keine Kontrollvariable zu nutzen. In diesem Fall genügt es allein die Bedingung für den Abbruch der Schleife anzugeben. Im folgenden wird die Wurzel aus 5 mit dem Heron-Verfahren bestimmt.
(%i1) x: 1000$ (%i2) thru 20 do x: 0.5*(x + 5.0/x)$ (%i3) x; (%o3) 2.23606797749979 (%i4) sqrt(5), numer; (%o4) 2.23606797749979
Auch die Abbruchbedingung kann fortgelassen werden. Wird allein
do body
angegeben, wird die Schleife unendlich oft ausgeführt.
Die Schleife kann mit der return
-Anweisung verlassen werden. Das
folgende Beispiel zeigt eine Implementierung des Newton-Algorithmus.
(%i1) newton (f, x):= ([y, df, dfx], df: diff (f ('x), 'x), do (y: ev(df), x: x - f(x)/y, if abs (f (x)) < 5e-6 then return (x)))$
(%i2) sqr (x) := x^2 - 5.0$ (%i3) newton (sqr, 1000); (%o3) 2.236068027062195
Eine weitere Syntax ist die folgende:
for variable in list end_tests do body
Die Elemente der Liste list können beliebige Ausdrücke sein, die
nacheinander der Kontrollvariablen zugewiesen werden. Die Schleife bricht ab,
wenn die optionale Abbruchbedingung end_test
zutrifft, wenn die Liste
list keine weiteren Elemente enthält oder wenn die Schleife zum Beispiel
mit der Funktion return
verlassen wird.
(%i1) for f in [log, rho, atan] do ldisp(f(1))$ (%t1) 0 (%t2) rho(1) %pi (%t3) --- 4 (%i4) ev(%t3,numer); (%o4) 0.78539816
Ein Ausdruck mit der Funktion eval_when
wird an oberster Stelle in einer
Datei definiert und erlaubt die bedingte Auswertung von Ausdrücken beim Laden,
Übersetzen oder Kompilieren einer Datei. Das Argument keyword ist eines
der Schlüsselworte batch
, translate
, compile
oder
loadfile
. Das erste Argument kann ein einzelnes Schlüsselwort oder
ein Liste mit mehreren Schlüsselworten sein. Trifft die mit dem
Schlüsselwort angegebene Bedingung zu, wird eine oder mehrere der folgenden
Aktionen ausgeführt:
batch
Wird die Datei mit einer der Funktionen load
, batch
,
batchload
oder demo
geladen und ist batch
in der Liste der
Schlüsselworte enthalten, dann werden die Ausdrücke expr1, …,
expr_n genau einmal beim Laden der Datei ausgewertet. Die Rückgabe der
Funktion eval_when
ist ein Ausdruck evaluated_when(result)
,
wobei result das Ergebnis der Auswertung ist. Ist das Schlüsselwort
batch
nicht vorhanden, ist die Rückgabe das Symbol
not_evaluated_when
.
translate
Wird die Datei mit dem Kommando translate_file
oder
compile_file
geladen und ist translate
unter den
Schlüsselworten, dann werden die Ausdrücke expr_1, …,
expr_n sofort ausgewertet. Seiteneffekte wie Zuweisungen von Werten
an Optionsvariablen oder Deklarationen sind für die folgende Übersetzung
der Datei nach Lisp wirksam. Die Ausdrücke sind jedoch nicht Teil des
übersetzten Programms.
loadfile
Wird die Datei mit dem Kommando translate_file
oder dem Kommando
compile_file
geladen und ist loadfile
unter den
Schlüsselworten, dann werden die Ausdrücke expr_1, …,
expr_n nach Lisp übersetzt und als Block der Form
(PROGN EXPR_1 ... EXPR_N)
in das Lisp Programm eingesetzt. Hier sind
die Anweisungen EXPR_I die nach Lisp übersetzten Maxima-Ausdrücke
expr_i.
compile
Wird die Datei mit dem Kommando translate_file
oder
compile_file
geladen und ist compile
unter den
Schlüsselworten, dann werden die Ausdrücke expr_1, …,
expr_n nach Lisp übersetzt und als eine Lisp-Anweisung in das
Lisp-Programm eingesetzt, die die Form (EVAL-WHEN (:COMPILE-TOPLEVEL)
(EXPR_1 ... EXPR_N))
hat. Das Schlüsselwort compile
kann nicht mit
dem Schlüsselwort loadfile
in einem eval_when
-Ausdruck
kombiniert werden. In diesem Fall wird das Schlüsselwort compile
ignoriert.
Beispiele:
Für die folgende Beispiele ist eine Datei mit den Namen
eval_when.mac
definiert, die verschiedene eval_when
-Anweisungen
enthält.
(%i1) file: file_search("eval_when.mac"); (%o1) /home/dieter/.maxima/eval_when.mac (%i2) printfile(file); eval_when(batch, print("called in mode BATCH")); eval_when(loadfile, print("called in mode LOADFILE")); eval_when(compile, print("called in mode COMPILE")); eval_when(translate, print("called in mode TRANSLATE")); (%o2) /home/dieter/.maxima/eval_when.mac
Die Datei wird mit dem Kommando load
geladen. Die Anweisung mit
dem Schlüsselwort batch
wird beim Laden einmal ausgeführt.
(%i1) file: file_search("eval_when.mac"); (%o1) /home/dieter/.maxima/eval_when.mac (%i2) load("file"); called in mode BATCH (%o2) /home/dieter/.maxima/eval_when.mac
In diesem Fall wird die Datei mit dem Befehl batch
geladen. Die
Anweisung mit dem Schlüsselwort batch
wird einmal ausgeführt.
Die anderen eval_when
-Anweisungen werten jeweils zum Ergebnis
not_evaluated_when
aus.
(%i3) batch(file); read and interpret file: /home/dieter/.maxima/eval_when.mac (%i4) eval_when(batch, print(called in mode BATCH)) called in mode BATCH (%o4) evaluated_when(called in mode BATCH) (%i5) eval_when(loadfile, print(called in mode LOADFILE)) (%o5) not_evaluated_when (%i6) eval_when(compile, print(called in mode COMPILE)) (%o6) not_evaluated_when (%i7) eval_when(translate, print(called in mode TRANSLATE)) (%o7) not_evaluated_when (%o7) /home/dieter/.maxima/eval_when.mac
Jetzt wird die Datei mit dem Kommando translate_file
geladen und nach
Lisp übersetzt. Der Ausdruck mit dem Schlüsselwort translate
wird
sofort ausgewertet. Das übersetzte Programm wird in die Ausgabedatei
eval_when.LISP
geschrieben. Die eval_when
-Anweisung zum
Schlüsselwort wird nicht ausgewertet.
(%i1) file: file_search("eval_when.mac"); (%o1) /home/dieter/.maxima/eval_when.mac (%i2) translate_file(file); translator: begin translating /home/dieter/.maxima/eval_when.mac. called in mode TRANSLATE (%o2) [/home/dieter/.maxima/eval_when.mac, /home/dieter/.maxima/eval_when.LISP, /home/dieter/.maxima/eval_when.UNLISP]
Dies ist der Inhalt der Ausgabedatei eval_when.LISP
. Die Ausgabedatei
enthält eine PROGN
-Anweisung mit dem Ausdruck
($print '"called in mode LOADFILE")
für den eval_when
-Ausdruck
zum Schlüsselwort loadfile
sowie eine EVAL-WHEN
-Anweisung mit
dem Ausdruck ($print '"called in mode COMPILE")
für den
eval_when
-Ausdruck mit dem Schlüsselwort compile
.
;;; -*- Mode: Lisp; package:maxima; syntax:common-lisp ;Base: 10 -*- ;;; ;;; Translated on: 2011-10-02 13:35:37+02:00 ;;; Maxima version: 5.25post ;;; Lisp implementation: SBCL ;;; Lisp version: 1.0.45 (in-package :maxima) [...] nil (progn ($print '"called in mode LOADFILE")) (eval-when (:compile-toplevel) ($print '"called in mode COMPILE")) nil
Wertet die Ausdrücke expr_1, …, expr_n nacheinander aus und
gibt das Ergebnis des letzten Ausdrucks als eine Liste [expr_n]
zurück, wenn kein Fehler bei der Auswertung auftritt. Tritt ein Fehler
bei der Auswertung eines der Ausdrücke auf, ist die Rückgabe eine leere
Liste []
.
errcatch
ist nützlich in Batch-Dateien. Mit errcatch
kann ein
möglicher Fehler abgefangen werden, ohne das die Verarbeitung der Batch-Datei
abbricht.
Beispiele:
(%i1) errcatch(x:2,1/x); 1 (%o1) [-] 2 (%i2) errcatch(x:0,1/x); Division by 0 (%o2) []
Wertet die Ausdrücke expr_1, …, expr_n aus, gibt diese auf
der Konsole aus und generiert einen Fehler, der zur obersten Ebene von Maxima
führt oder zu dem nächsten errcatch
.
Der Systemvariablen error
wird eine Liste zugewiesen, die eine
Beschreibung des Fehlers enthält. Das erste Element der Liste ist eine
Zeichenkette und die weiteren Elemente enthalten die Argumente die keine
Zeichenkette sind.
errormsg()
formatiert und gibt die Fehlermeldung in error
aus.
Damit wird die letzte Fehlermeldung erneut ausgegeben.
Beispiel:
(%i1) f(x):= if x=0 then error("Division durch", x, "ist nicht gestattet.") else 1/x$ (%i2) f(0); Division durch 0 ist nicht gestattet. #0: f(x=0) -- an error. To debug this try: debugmode(true); (%i3) errormsg(); Division durch 0 ist nicht gestattet. (%o3) done (%i4) error; (%o4) [Division durch ~M ist nicht gestattet., 0]
Standardwert: 10
error_size
kontrolliert die Ausgabe eines Ausdrucks der zu einem Fehler
geführt hat. Ist der Ausdruck größer als error_size
wird der
Ausdruck bei der Ausgabe einer Fehlermeldung durch ein Symbol ersetzt und dem
Symbol wird der Ausdruck zugewiesen. Die Symbole werden aus der Liste
error_syms
ausgewählt.
Ist der Ausdruck kleiner als error_size
wird dieser mit der Fehlermeldung
ausgegeben.
Siehe auch error
und error_syms
.
Beispiel:
Die Größe des Ausdrucks U
ist 24.
(%i1) U: (C^D^E + B + A)/(cos(X-1) + 1)$ (%i2) error_size: 20$ (%i3) error ("Example expression is", U); Example expression is errexp1 -- an error. Quitting. To debug this try debugmode(true); (%i4) errexp1; E D C + B + A (%o4) -------------- cos(X - 1) + 1 (%i5) error_size: 30$ (%i6) error ("Example expression is", U); E D C + B + A Example expression is -------------- cos(X - 1) + 1 -- an error. Quitting. To debug this try debugmode(true);
Standardwert: [errexp1, errexp2, errexp3]
In Fehlermeldungen werden Ausdrücke, die größer als error_size
sind, durch Symbole ersetzt, denen der Ausdruck zugewiesen wird. Die Symbole
werden nacheinander der Liste error_syms
entnommen.
Sind keine Symbole mehr vorhanden, werden automatisch neue Symbole mit
concat('errexp, n)
gebildet.
Siehe auch error
und error_size
.
Gibt die letzte Fehlermeldung erneut aus. Die Fehlermeldung ist in der
Systemvariablen errormsg
enthalten. Die Funktion errormsg
formatiert diese und gibt sie aus.
Standardwert: true
Hat die Optionsvariable errormsg
den false
wird die Ausgabe
von Fehlermeldungen unterdrückt.
Der Optionsvariablen errormsg
kann in einem Block kein lokaler Wert
zugewiesen werden. Der globale Wert von errormsg
ist stets präsent.
Beispiele:
(%i1) errormsg; (%o1) true (%i2) sin(a,b); Wrong number of arguments to sin -- an error. To debug this try: debugmode(true); (%i3) errormsg:false; (%o3) false (%i4) sin(a,b); -- an error. To debug this try: debugmode(true);
Der Optionsvariablen errormsg
kann in einem Block kein lokaler Wert
zugewiesen werden.
(%i1) f(bool):=block([errormsg:bool], print ("value of errormsg is",errormsg))$ (%i2) errormsg:true; (%o2) true
(%i3) f(false); value of errormsg is true
(%o3) true (%i4) errormsg:false; (%o4) false (%i5) f(true); value of errormsg is false (%o5) false
Anweisung für Interationen. Siehe die do
-Anweisung für eine
Beschreibung der Iterationsmöglichkeiten von Maxima.
Erlaubt einen Sprung innerhalb eines Blocks zu einer Marke mit dem Namen
tag
. Um eine Anweisung mit einer Sprungmarke zu versehen, wird der
Anweisung die Marke vorangestellt. Ein Beispiel ist:
block ([x], x:1, loop, x+1, ..., go(loop), ...)
Das Argument der Funktion go
muss der Name einer Marke sein, die in
demselben Block erscheint. Es ist nicht möglich in einen anderen Block zu
springen.
Ist die bedingte Anweisung. Verschiedene Formen einer bedingten Anweisung sind möglich.
if cond_1 then expr_1 else expr_0
wertet zu
expr_1 aus, wenn die Bedingung cond_1 den Wert true
hat.
Ansonsten wertet der Ausdruck zu expr_0 aus.
Die zusammengesetzte bedingte Anweisung if cond_1 then expr_1
elseif cond_2 then expr_2 elseif ... else expr_0
wertet
zu expr_k aus, wenn die Bedingung cond_k den Wert true
hat
und alle vorhergehenden Bedingungen den Wert false
haben. Trifft keine
der Bedingungen zu, wertet der Ausdruck zu expr_0 aus.
Fehlt die Anweisung else
, wird diese zu else false
angenommen.
if cond_1 then expr_1
ist daher äquivalent zu
if cond_1 then expr_1 else false
und if cond_1
then expr_1 elseif ... elseif cond_n then expr_n
ist
äquivalent zu if cond_1 then expr_1 elseif ... elseif
cond_n then expr_n else false
.
Die Anweisungen expr_0, …, expr_n können beliebige
Maxima-Ausdrücke einschließlich weiterer if
-Anweisungen sein.
Die Anweisungen werden nicht vereinfacht oder ausgewertet, solange die
dazugehörende Bedingung nicht das Ergebnis true
hat.
Die Bedingungen cond_1, …, cond_n sind Ausdrücke, die zu
true
oder false
ausgewertet werden können. Kann eine Bedingung
nicht zu true
oder false
ausgewertet werden, hängt die Reaktion
von der Optionsvariablen prederror
ab. Hat prederror
den Wert
true
, dann meldet Maxima einen Fehler, wenn eine Bedingung nicht zu
true
oder false
ausgewertet werden kann. Ansonsten werden
Bedingungen akzeptiert, die nicht zu true
oder false
ausgewertet
werden können und das Ergebnis ist ein bedingter Ausdruck.
Die Bedingungen können die folgenden Operatoren enthalten:
Operation Symbol Typ less than < relational infix less than <= or equal to relational infix equality (syntactic) = relational infix negation of = # relational infix equality (value) equal relational function negation of equal notequal relational function greater than >= or equal to relational infix greater than > relational infix and and logical infix or or logical infix not not logical prefix
Speichert alle Eigenschaften der Symbole v_1, …, v_n, entfernt
die Eigenschaften und stellt die abgespeicherten Eigenschaften nach dem Austritt
aus einem Block oder einem zusammengesetzten Ausdruck in dem local
auftritt wieder her.
Einige Deklarationen sind als Eigenschaft eines Symbols implementiert. Dazu
gehören Deklarationen mit :=
, array
, dependencies
,
atvalue
, matchdeclare
, atomgrad
, constant
,
nonscalar
oder assume
. Der Effekt von local
ist, dass
solche Deklarationen nur lokal in dem Block wirksam sind.
local
kann nur in block
-Anweisungen oder in einer
Funktionsdefinition oder in einem Lambda-Ausdruck verwendet werden. Weiterhin
darf local
jeweils nur einmal auftreten.
local
wertet die Argumente aus. local
hat die Rückgabe
done
.
Beispiel:
Eine lokale Funktionsdefinition.
(%i1) foo (x) := 1 - x; (%o1) foo(x) := 1 - x (%i2) foo (100); (%o2) - 99 (%i3) block (local (foo), foo (x) := 2 * x, foo (100)); (%o3) 200 (%i4) foo (100); (%o4) - 99
Die return
-Anweisung wird in einem Block verwendet, um den Block mit dem
Ergebnis value zu verlassen. Siehe block
für mehr Informationen.
Wertet den Ausdruck expr aus und generiert eine Ausnahme mit dem Ergebnis
der Auswertung, die von der letzten catch
-Anweisung behandelt wird.
Vorige: Einführung in die Programmierung, Nach oben: Programmierung [Inhalt][Index]