Nächste: Nutzerdefinierte Operatoren, Vorige: Operatoren für Gleichungen, Nach oben: Operatoren [Inhalt][Index]
Ist der Operator für die Zuweisung eines Wertes an eine Variable.
Ist die linke Seite eine Variable (ohne Index), wertet der Operator :
die
rechte Seite aus und weist den Wert der Variablen auf der linken Seite zu.
Ist die linke Seite ein Element einer Liste, Matrix oder ein deklariertes Maxima- oder Lisp-Array, wird die rechte Seite diesem Element zugewiesen. Der Index muss ein existierendes Element bezeichnen.
Ist die linke Seite ein Element eines nicht deklarierten Arrays, dann wird die rechte Seite diesem Element zugewiesen, falls dieses existiert. Existiert das Element noch nicht, wird ein neues Element erzeugt.
Ist die linke Seite eine Liste mit Variablen (ohne Index), muss die rechte Seite zu einer Liste auswerten. Die Elemente der Liste auf der rechten Seite werden den Elementen auf der linken Seite parallel zugewiesen.
Siehe auch kill
und remvalue
für die Aufhebung der Zuweisung
eines Wertes an ein Symbol.
Beispiele:
Zuweisung an eine einfache Variable.
(%i1) a; (%o1) a (%i2) a : 123; (%o2) 123 (%i3) a; (%o3) 123
Zuweisung an ein Element einer Liste.
(%i1) b : [1, 2, 3]; (%o1) [1, 2, 3] (%i2) b[3] : 456; (%o2) 456 (%i3) b; (%o3) [1, 2, 456]
Die Zuweisung erzeugt ein nicht deklariertes Array.
(%i1) c[99] : 789; (%o1) 789 (%i2) c[99]; (%o2) 789 (%i3) c; (%o3) c (%i4) arrayinfo (c); (%o4) [hashed, 1, [99]] (%i5) listarray (c); (%o5) [789]
Mehrfache Zuweisung.
(%i1) [a, b, c] : [45, 67, 89]; (%o1) [45, 67, 89] (%i2) a; (%o2) 45 (%i3) b; (%o3) 67 (%i4) c; (%o4) 89
Die mehrfache Zuweisung wird parallel ausgeführt. Die Werte von a
und
b
werden in diesem Beispiel ausgetauscht.
(%i1) [a, b] : [33, 55]; (%o1) [33, 55] (%i2) [a, b] : [b, a]; (%o2) [55, 33] (%i3) a; (%o3) 55 (%i4) b; (%o4) 33
Ist der Operator für die Zuweisung eines Wertes an eine Variable.
Der Operator ::
ist vergleichbar mit dem Operator :
mit dem
Unterschied, dass ::
sowohl die rechte als auch die linke Seite
auswertet.
Beispiele:
(%i1) x : 'foo; (%o1) foo (%i2) x :: 123; (%o2) 123 (%i3) foo; (%o3) 123 (%i4) x : '[a, b, c]; (%o4) [a, b, c] (%i5) x :: [11, 22, 33]; (%o5) [11, 22, 33] (%i6) a; (%o6) 11 (%i7) b; (%o7) 22 (%i8) c; (%o8) 33
Ist der Operator für die Definition von Makro-Funktionen.
Der Operator ::=
definiert eine Makro-Funktion, das ist eine Funktion,
die ihre Argumente nicht auswertet. Der Ausdruck, der die Makro-Funktion
definiert, wird in dem Kontext ausgewertet, in dem das Makro aufgerufen wird.
Ansonsten verhält sich eine Makro-Funktion wie eine gewöhnliche Funktion.
Die Funktion macroexpand
expandiert eine Makro-Funktion, ohne sie
auszuwerten. macroexpand(foo(x))
dem ''%
folgt, ist äquivalent
zu foo(x)
, wenn foo
eine Makro-Funktion ist.
Der Operator ::=
fügt den Namen der neuen Makro-Funktion der
Informationsliste macros
hinzu. Die Funktionen kill
,
remove
und remfunction
heben die Zuweisung der Makro-Funktion an
ein Symbol auf und entfernen die Makro-Funktion von der Informationsliste
macros
.
Die Funktionen fundef
oder dispfun
geben die Definition einer
Makro-Funktion zurück oder weisen die Makro-Funktion einer Marke zu.
Makro-Funktionen enthalten häufig Ausdrücke mit den Funktionen
buildq
und splice
. Mit diesen werden Ausdrücke konstruiert,
die dann ausgewertet werden.
Beispiele:
Eine Makro-Funktion wertet ihre Argumente nicht aus. Daher zeigt Beispiel (1)
y - z
und nicht den Wert von y - z
. Das Makro wird in
dem Kontext ausgewertet, in dem das Makro aufgerufen wird. Dies zeigt (2).
(%i1) x: %pi$ (%i2) y: 1234$ (%i3) z: 1729 * w$ (%i4) printq1 (x) ::= block (print ("(1) x is equal to", x), '(print ("(2) x is equal to", x)))$ (%i5) printq1 (y - z); (1) x is equal to y - z (2) x is equal to %pi (%o5) %pi
Eine gewöhnliche Funktion wertet ihre Argumente aus. Daher zeigt (1) den Wert
von y - z
. Der Rückgabewert wird nicht ausgewertet und gibt (2). Mit
''%
wird die Auswertung erzwungen.
(%i1) x: %pi$ (%i2) y: 1234$ (%i3) z: 1729 * w$ (%i4) printe1 (x) := block (print ("(1) x is equal to", x), '(print ("(2) x is equal to", x)))$ (%i5) printe1 (y - z); (1) x is equal to 1234 - 1729 w (%o5) print((2) x is equal to, x) (%i6) ''%; (2) x is equal to %pi (%o6) %pi
macroexpand
gibt die Expansion des Makros zurück.
macroexpand(foo(x))
dem ''%
folgt, ist äquivalent zu
foo(x)
, wenn foo
eine Makro-Funktion ist.
(%i1) x: %pi$ (%i2) y: 1234$ (%i3) z: 1729 * w$ (%i4) g (x) ::= buildq ([x], print ("x is equal to", x))$ (%i5) macroexpand (g (y - z)); (%o5) print(x is equal to, y - z) (%i6) ''%; x is equal to 1234 - 1729 w (%o6) 1234 - 1729 w (%i7) g (y - z); x is equal to 1234 - 1729 w (%o7) 1234 - 1729 w
Ist der Operator für Funktionsdefinitionen.
f(x_1, ..., x_n)
:= expr definiert eine Funktion
mit dem Namen f, den Argumenten x_1, …, x_n und der
Funktionsdefinition expr. Der Operator :=
wertet die
Funktionsdefinition nicht aus. Die Auswertung kann mit dem
Quote-Quote-Operator ''
erzwungen werden. Die definierte
Funktion kann eine gewöhnliche Maxima-Funktion f(x)
sein oder eine
Array-Funktion f[i](x)
.
Ist das letzte oder das einzige Argument der Funktion x_n eine Liste mit
einem Element, dann akzeptiert die mit :=
definierte Funktion eine
variable Anzahl an Argumenten. Die Argumente werden zunächst nacheinander den
Argumenten x_1, …, x_(n - 1) zugewiesen. Sind weitere
Argumente vorhanden, werden diese x_n als Liste zugewiesen.
Funktionsdefinitionen erscheinen im globalen Namensraum. Wird eine Funktion
f
innerhalb einer Funktion g
definiert, wird die Reichweite der
Funktion nicht automatisch auf g
beschränkt. Dagegen führt
local(f)
zu einer Definition, die nur innerhalb eines Blockes oder einem
anderen zusammengesetzten Ausdrück erscheint. Siehe auch local
.
Ist eines der Argumente ein Symbol auf das der Quote-Operator
'
angewendet wurde, wird dieses Argument nicht ausgewertet. Ansonsten
werden alle Argumente ausgewertet.
Beispiele:
:=
wertet die Funktionsdefinition nie aus, außer wenn der
Quote-Quote-Operator angewendet wird.
(%i1) expr : cos(y) - sin(x); (%o1) cos(y) - sin(x) (%i2) F1 (x, y) := expr; (%o2) F1(x, y) := expr (%i3) F1 (a, b); (%o3) cos(y) - sin(x) (%i4) F2 (x, y) := ''expr; (%o4) F2(x, y) := cos(y) - sin(x) (%i5) F2 (a, b); (%o5) cos(b) - sin(a)
Mit dem Operator :=
definierte Funktionen können eine gewöhnliche
Maxima-Funktion oder eine Array-Funktion sein.
(%i1) G1 (x, y) := x.y - y.x; (%o1) G1(x, y) := x . y - y . x (%i2) G2 [x, y] := x.y - y.x; (%o2) G2 := x . y - y . x x, y
Ist das letzte oder einzige Argument x_n eine Liste mit einem Element, dann akzeptiert die Funktion eine variable Anzahl an Argumenten.
(%i1) H ([L]) := apply ("+", L); (%o1) H([L]) := apply("+", L) (%i2) H (a, b, c); (%o2) c + b + a
local
erzeugt 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
Nächste: Nutzerdefinierte Operatoren, Vorige: Operatoren für Gleichungen, Nach oben: Operatoren [Inhalt][Index]