[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
7.1 Arithmetische Operatoren | ||
7.2 Relationale Operatoren | ||
7.3 Logische Operatoren | ||
7.4 Operatoren für Gleichungen | ||
7.5 Zuweisungsoperatoren | ||
7.6 Einführung in nutzerdefinierte Operatoren |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Sind die Operatoren der Addition, Multiplikation, Division und Exponentiation.
Wird der Name eines Operators in einem Ausdruck benötigt, können die
Bezeichnungen "+"
, "*"
, "/"
und "^"
verwendet
werden.
Die Symbole +
und -
repräsentieren die unäre Addition and
Negation. Die Namen der Operatoren sind "+"
und "-"
.
Die Subtraktion a - b
wird von Maxima intern als Addition
a + (- b)
dargestellt. In der Ausgabe werden die Ausdrücke
a + (- b)
als Subtraktion a - b
angezeigt. Maxima erkennt
"-"
nur als den Namen der unären Negation, nicht jedoch als den
binären Operator der Subtraktion.
Die Division a / b
wird von Maxima intern als Multiplikation
a * b^(- 1)
dargestellt. In der Ausgabe werden die Ausdrücke
a * b^(- 1)
als Division a / b
angezeigt. Der Name des Operators
für die Division ist "/"
.
Die Addition und Multiplikation sind kommutative N-ary-Operatoren. Die Division und Exponentiation sind nicht-kommutative binäre Operatoren.
Maxima sortiert die Argumente eines kommutativen Operators und konstruiert eine
kanonische Darstellung. Für die interne Darstellung wird die Ordnung durch
orderlessp
bestimmt. Für die externe Darstellung der Anzeige wird die
Ordnung mit ordergreatp
festgelegt. Ausnahme ist die Multiplikaton.
Für diese sind die interne und die externe Darstellung identisch.
Arithmetische Rechnungen werden mit Zahlen (ganzen Zahlen, rationale Zahlen,
Gleitkommazahlen und großen Gleitkommazahlen) durchgeführt. Mit Ausnahme
der Exponentiation werden alle arithmetischen Operationen mit Zahlen zu Zahlen
vereinfacht. Die Exponentiation vereinfacht zu einer Zahl, wenn eines der
Argumente eine Gleikommazahl ist, oder wenn das Ergebnis eine ganze
oder rationale Zahl ist. In anderen Fällen kann die Exponentiation zum
Beispiel zu einer Wurzelfunktion sqrt
oder wiederum zu einer
Exponentiation vereinfachen.
Bei einer arithmetische Rechnung kann es zur Umwandlung in Gleitkommazahlen kommen. Ist eines der Argumente eine große Gleitkommazahl, so ist auch das Ergebnis eine große Gleitkommazahl. Entsprechend ist das Ergebnis eine einfache Gleitkommazahl, sofern mindestens eines der Argumente eine einfache Gleitkommazahl ist. Treten nur ganze oder rationale Zahlen auf, ist das Ergebnis wieder eine ganze oder rationale Zahl.
Arithmetische Rechnungen sind Vereinfachungen und keine Auswertungen. Daher
werden arithmetische Rechnungen auch dann ausgeführt, wenn die Auswertung des
Ausdrucks mit den Quote-Operator '
unterdrückt wird.
Arithmetische Operatoren werden elementweise auf Listen angewendet, wenn die
Optionsvariable listarith
den Wert true
hat. Auf Matrizen werden
die arithmetischen Operatoren immer elementweise angewendet. Ist eines der
Argumente eine Liste oder Matrix und das andere Argument hat einen anderen
Typ, dann wird dieses Argument mit jedem Element der Liste oder Matrix
kombiniert.
Beispiele:
Addition und Multiplikation sind kommutative N-ary-Operatoren. Maxima sortiert
die Operanden und konstruiert eine kanonische Darstellung. Die Namen der
Operatoren sind "+"
und "*"
.
(%i1) c + g + d + a + b + e + f; (%o1) g + f + e + d + c + b + a (%i2) [op (%), args (%)]; (%o2) [+, [g, f, e, d, c, b, a]] (%i3) c * g * d * a * b * e * f; (%o3) a b c d e f g (%i4) [op (%), args (%)]; (%o4) [*, [a, b, c, d, e, f, g]] (%i5) apply ("+", [a, 8, x, 2, 9, x, x, a]); (%o5) 3 x + 2 a + 19 (%i6) apply ("*", [a, 8, x, 2, 9, x, x, a]); 2 3 (%o6) 144 a x
Die Division und Exponentiation sind nicht-kommutative binäre Operatoren. Die
Namen der Operatoren sind "/"
und "^"
.
(%i1) [a / b, a ^ b]; a b (%o1) [-, a ] b (%i2) [map (op, %), map (args, %)]; (%o2) [[/, ^], [[a, b], [a, b]]] (%i3) [apply ("/", [a, b]), apply ("^", [a, b])]; a b (%o3) [-, a ] b
Subtraktion and Divison werden intern als Addition und Multiplikation dargestellt.
(%i1) [inpart (a - b, 0), inpart (a - b, 1), inpart (a - b, 2)]; (%o1) [+, a, - b] (%i2) [inpart (a / b, 0), inpart (a / b, 1), inpart (a / b, 2)]; 1 (%o2) [*, a, -] b
Rechnungen werden für Zahlen ausgeführt. Die Umwandlung in Gleitkommazahlen wird angewendet.
(%i1) 17 + b - (1/2)*29 + 11^(2/4); 5 (%o1) b + sqrt(11) + - 2 (%i2) [17 + 29, 17 + 29.0, 17 + 29b0]; (%o2) [46, 46.0, 4.6b1]
Arithmetische Rechnungen sind Vereinfachungen und keine Auswertung.
(%i1) simp : false; (%o1) false (%i2) '(17 + 29*11/7 - 5^3); 29 11 3 (%o2) 17 + ----- - 5 7 (%i3) simp : true; (%o3) true (%i4) '(17 + 29*11/7 - 5^3); 437 (%o4) - --- 7
Arithmetische Rechnungen werden elementweise für Listen und Matrizen
ausgeführt. Bei Listen wird dies mit der Optionsvariablen
listarith
kontrolliert.
(%i1) matrix ([a, x], [h, u]) - matrix ([1, 2], [3, 4]); [ a - 1 x - 2 ] (%o1) [ ] [ h - 3 u - 4 ] (%i2) 5 * matrix ([a, x], [h, u]); [ 5 a 5 x ] (%o2) [ ] [ 5 h 5 u ] (%i3) listarith : false; (%o3) false (%i4) [a, c, m, t] / [1, 7, 2, 9]; [a, c, m, t] (%o4) ------------ [1, 7, 2, 9] (%i5) [a, c, m, t] ^ x; x (%o5) [a, c, m, t] (%i6) listarith : true; (%o6) true (%i7) [a, c, m, t] / [1, 7, 2, 9]; c m t (%o7) [a, -, -, -] 7 2 9 (%i8) [a, c, m, t] ^ x; x x x x (%o8) [a , c , m , t ]
Ist eine alternative Schreibweise für den Operator ^
der
Exponentiation. In der Ausgabe wird entweder ^
angezeigt oder der
Exponent hochgestellt. Siehe ^
.
Die Funktion fortran
zeigt den Operator der Exponentiation immer als
**
an, unabhängig davon ob **
oder ^
eingegeben wird.
Beispiele:
(%i1) is (a**b = a^b); (%o1) true (%i2) x**y + x^z; z y (%o2) x + x (%i3) string (x**y + x^z); (%o3) x^z+x^y (%i4) fortran (x**y + x^z); x**z+x**y (%o4) done
Ist der Operator der nicht-kommutativen Exponentiation von Matrizen. In der
linearen Ausgabe wird der nicht-kommutative Operator als ^^
angezeigt.
In der zweidimensionalen Ausgabe wird der hochgestellte Exponent von spitzen
Klammern < >
eingeschlossen.
Beispiele:
(%i1) a . a . b . b . b + a * a * a * b * b; 3 2 <2> <3> (%o1) a b + a . b (%i2) string (a . a . b . b . b + a * a * a * b * b); (%o2) a^3*b^2+a^^2 . b^^3
Ist der Operator für die nicht-kommutative Multiplikation von Matrizen.
Siehe auch
dot
,
dot0nscsimp
,
dot0simp
,
dot1simp
,
dotassoc
,
dotconstrules
,
dotdistrib
,
dotexptsimp
,
dotident
und dotscrules
.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Die Symbole <
, <=
, >=
und >
repräsentieren die
Operatoren "kleiner als", "kleiner als oder gleich", "größer als oder
gleich" und "größer als". Die Namen dieser Operatoren sind jeweils:
"<"
, "<="
, ">="
und ">"
. Diese können dort
eingesetzt werden, wo der Name des Operators benötigt wird.
Die relationalen Operatoren sind binäre Operatoren. Ausdrücke wie
a < b < c
werden von Maxima nicht erkannt.
Relationale Ausdrücke werden von den Funktionen is
und
maybe
sowie den Funktionen if
,
while
und
unless
zu boolschen Werten ausgewertet. Relationale Ausdrücke werden
ansonsten nicht zu boolschen Werten ausgewertet oder vereinfacht. Jedoch
werden die Argumente eines boolschen Ausdruckes ausgewertet, wenn die
Auswertung nicht auf andere Weise unterdrückt ist.
Wenn ein relationaler Ausdruck nicht zu true
oder false
ausgewertet werden kann, wird das Verhalten von is
und if
von der
Optionsvariable prederror
kontrolliert. Hat prederror
den Wert
true
, wird von is
and if
ein Fehler erzeugt. Hat
prederror
den Wert false
, hat is
den Rückgabewert
unknown
und if
gibt einen konditionalen Ausdruck zurück, der
teilweise ausgewertet ist.
Die Funktion maybe
verhält sich immer so, als ob prederror
den
Wert false
hat, und while
sowie unless
verhalten sich
immer so, als ob prederror
den Wert true
hat.
Relationale Operatoren werden nicht auf die Elemente von Listen oder Matrizen sowie auf die beiden Seiten einer Gleichung angewendet.
Siehe auch =
,
#
,
equal
und notequal
.
Beispiele:
Relationale Ausdrücke werden von einigen Funktionen zu boolschen Werten ausgewertet.
(%i1) [x, y, z] : [123, 456, 789]; (%o1) [123, 456, 789] (%i2) is (x < y); (%o2) true (%i3) maybe (y > z); (%o3) false (%i4) if x >= z then 1 else 0; (%o4) 0 (%i5) block ([S], S : 0, for i:1 while i <= 100 do S : S + i, return (S)); (%o5) 5050
Relationale Ausdrücke werden ansonsten nicht zu boolschen Werten ausgewertet oder vereinfacht, auch wenn die Argumente eines relationalen Ausdruckes ausgewertet werden.
(%o1) [123, 456, 789] (%i2) [x < y, y <= z, z >= y, y > z]; (%o2) [123 < 456, 456 <= 789, 789 >= 456, 456 > 789] (%i3) map (is, %); (%o3) [true, true, true, false]
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Ist der logische Operator der Konjunktion. and
ist ein N-ary Infix
Operator. Seine Argumente sind boolsche Ausdrücke und sein Ergebnis ist ein
boolscher Wert.
Wie is
erzwingt and
die Auswertung aller oder einen Teil seiner
Argumente.
Die Argumente werden in der Reihenfolge ausgewertet, in der sie auftreten.
and
wertet nur soviele Argumente aus, wie nötig sind, um das Ergebnis
des Ausdrucks zu bestimmen. Hat irgendein Argument den Wert false
, ist
das Ergebnis false
und die weiteren Argumente werden nicht ausgewertet.
Die Optionsvariable prederror
kontrolliert das Verhalten von and
für den Fall, dass ein Argument nicht zu true
oder false
ausgewertet werden kann. and
gibt eine Fehlermeldung, wenn
prederror
den Wert true
hat. Andernfalls werden Argumente, die
nicht zu true
oder false
ausgewertet werden können, akzeptiert
und das Ergebnis ist ein boolscher Ausdruck.
and
ist nicht kommutativ, da aufgrund von nicht ausgewerteten Argumenten
die Ausdrücke a and b
und b and a
ein unterschiedliches Ergebnis
haben können.
Ist der logische Operator der Disjunktion. or
ist ein N-ary Infix
Operator. Seine Argumente sind boolsche Ausdrücke und sein Ergebnis ist ein
boolscher Wert.
Wie is
erzwingt der Operator or
die Auswertung aller oder einen
Teil seiner Argumente.
Die Argumente werden in der Reihenfolge ausgewertet, in der sie auftreten.
or
wertet nur soviele Argumente aus, wie nötig sind, um das Ergebnis
des Ausdrucks zu bestimmen. Hat irgendein Argument den Wert true
, ist
das Ergebnis true
und die weiteren Argumente werden nicht ausgewertet.
Die Optionsvariable prederror
kontrolliert das Verhalten von or
,
für den Fall, das ein Argument nicht zu true
oder false
ausgewertet werden kann. and
gibt eine Fehlermeldung, wenn
prederror
den Wert true
hat. Andernfalls, werden Argumente, die
nicht zu true
oder false
ausgewertet werden können, akzeptiert
und das Ergebnis ist ein boolscher Ausdruck.
or
ist nicht kommutativ, da aufgrund von nicht ausgewerteten Argumenten
die Ausdrücke a or b
und b or a
ein unterschiedliches Ergebnis
haben können.
Ist die logische Negation. not
ist ein Prefix-Operator. Sein Argument
ist ein boolscher Ausdruck und sein Ergebnis ein boolscher Wert.
Wie is
erzwingt not
die Auswertung seiner Argumente.
Die Optionsvariable prederror
kontrolliert das Verhalten von not
,
für den Fall, dass das Argument nicht zu true
oder false
ausgewertet werden kann. not
gibt eine Fehlermeldung, wenn
prederror
den Wert true
hat. Andernfalls wird ein Argument, das
nicht zu true
oder false
ausgewertet werden kann, akzeptiert und
das Ergebnis ist ein boolscher Ausdruck.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Ist der Operator für eine Ungleichung.
Wegen der Regeln für die Auswertung von Aussagen und weil
not expr
die Auswertung des Argumentes expr bewirkt, ist der
Ausdruck not a = b
äquivalent zu
is(a # b)
und nicht zu a # b
.
Beispiele:
(%i1) a = b; (%o1) a = b (%i2) is (a = b); (%o2) false (%i3) a # b; (%o3) a # b (%i4) not a = b; (%o4) true (%i5) is (a # b); (%o5) true (%i6) is (not a = b); (%o6) true
Ist der Operator für eine Gleichung.
Ein Ausdruck a = b
repräsentiert eine nicht ausgewertete
Gleichung, welche zutreffen kann oder auch nicht. Nicht ausgewertete
Gleichungen können zum Beispiel als Argument der Funktionen solve
und
algsys
auftreten.
Die Funktion is
wertet =
zu einem boolschen Wert aus.
is(a = b)
wertet die Gleichung a = b
zum
Wert true
aus, wenn a and b identische Ausdrücke sind. Das
trifft zu, wenn a und b identische Atome sind, oder wenn ihre
Operatoren sowie die Argumente identisch sind. In jedem anderen Fall ist das
Ergebnis false
. Das Ergebnis der Auswertung ist nie unkown
. Hat
is(a = b)
das Ergebnis true
, werden a
und
b
als syntaktisch gleich bezeichnet. Im Unterschied dazu gilt für
äquivalente Ausdrücke, das is(equal(a, b))
den Wert
true
hat. Ausdrücke können äquivalent, aber syntaktisch
verschieden sein.
Die Negation von =
wird durch #
repräsentiert. Wie bei =
wird ein Ausdruck a # b
nicht ausgewertet. Eine Auswertung
erfolgt mit is(a # b)
, welche die Werte true
oder
false
liefert.
Neben is
werten auch die Operatoren
if
,
and
,
or
und not
die Operatoren
=
und #
zu den Werten true
oder false
aus.
Wegen der Regeln für die Auswertung von Aussagen und weil im Ausdruck
not expr
das Argument expr ausgewertet wird, ist
not a = b
äquivalent zu is(a # b)
und
nicht zu a # b
.
Die Funktionen rhs
und lhs
geben die rechte und die linke einer
Gleichung oder Ungleichung zurück.
Siehe auch equal
und notequal
.
Beispiele:
Ein Ausdruck a = b
repräsentiert eine nicht ausgewertete
Gleichung. Diese kann zutreffen oder nicht.
(%i1) eq_1 : a * x - 5 * y = 17; (%o1) a x - 5 y = 17 (%i2) eq_2 : b * x + 3 * y = 29; (%o2) 3 y + b x = 29 (%i3) solve ([eq_1, eq_2], [x, y]); 196 29 a - 17 b (%o3) [[x = ---------, y = -----------]] 5 b + 3 a 5 b + 3 a (%i4) subst (%, [eq_1, eq_2]); 196 a 5 (29 a - 17 b) (%o4) [--------- - --------------- = 17, 5 b + 3 a 5 b + 3 a 196 b 3 (29 a - 17 b) --------- + --------------- = 29] 5 b + 3 a 5 b + 3 a (%i5) ratsimp (%); (%o5) [17 = 17, 29 = 29]
is(a = b)
wertet a = b
zu true
aus,
wenn a und b syntaktisch gleich sind. Ausdrücke können
äquivalent sein, ohne syntaktisch gleich zu sein.
(%i1) a : (x + 1) * (x - 1); (%o1) (x - 1) (x + 1) (%i2) b : x^2 - 1; 2 (%o2) x - 1 (%i3) [is (a = b), is (a # b)]; (%o3) [false, true] (%i4) [is (equal (a, b)), is (notequal (a, b))]; (%o4) [true, false]
Einige Operatoren werten =
und #
zu true
oder false
aus.
(%i1) if expand ((x + y)^2) = x^2 + 2 * x * y + y^2 then FOO else BAR; (%o1) FOO (%i2) eq_3 : 2 * x = 3 * x; (%o2) 2 x = 3 x (%i3) eq_4 : exp (2) = %e^2; 2 2 (%o3) %e = %e (%i4) [eq_3 and eq_4, eq_3 or eq_4, not eq_3]; (%o4) [false, true, true]
Da not expr
die Auswertung des Ausdrucks expr bewirkt, ist
not a = b
äquivalent zu is(a # b)
.
(%i1) [2 * x # 3 * x, not (2 * x = 3 * x)]; (%o1) [2 x # 3 x, true] (%i2) is (2 * x # 3 * x); (%o2) true
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [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 Maxima-Array, 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 die linke Seite.
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.
::
ist wie :
mit der Ausnahme, 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. ::=
definiert eine Funktion (aus historischen Gründen Makro genannt), welche ihre
Argumenente nicht auswertet. Der Ausdruck, welcher zurückgegeben wird, wird
in dem Kontext ausgewertet, in dem das Makro aufgerufen wurde. Ansonsten
verhält sich eine Makro-Funktion wie eine gewöhnliche Funktion.
macroexpand
expandiert ein Makro ohne es auszuwerten.
macroexpand(foo(x)
dem ''%
folgt, ist äquivalent zu
foo (x)
, wenn foo
eine Makro-Funktion ist.
::=
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
.
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. :=
wertet die Funktionsdefinition nicht
aus. Die Auswertung kann mit dem Quote-Quote-Operator "
erzwungen
werden. Die definierte Funktion kann eine gewöhnliche Maxima-Funktion sein,
deren Argumente in runden Klammern eingeschlossen sind, oder eine Array-Funktion
mit Argumenten, die in eckigen Klammern eingeschlossen sind.
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 in demselben 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 Funktions-Definition 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, akzepiert 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
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Es ist möglich neue Operatoren zu definieren, vorhandene Operatoren zu entfernen oder deren Eigenschaften zu ändern. Es können Operatoren mit den folgenden Eigenschaften definiert werden:
Negation - a
Fakultät a!
Exponentiation a^b
Addition a + b
Liste [a,b]
Maxima hat keinen implementierten Nofix-Operator.
Jede Funktion kann als ein Operator definiert werden, die Funktion kann, muss aber nicht definiert sein.
Im Folgenden werden die Operatoren dd
und "<-"
definiert. Nach
der Definition als Operatoren ist dd a
gleichbedeutend mit "dd"(a)
und a <- b
entspricht dem Funktionsaufruf "<-"(a,b)
. In diesem
Beispiel sind die Funktionen "dd"
und "<-"
nicht definiert.
(%i1) prefix ("dd"); (%o1) dd (%i2) dd a; (%o2) dd a (%i3) "dd" (a); (%o3) dd a (%i4) infix ("<-"); (%o4) <- (%i5) a <- dd b; (%o5) a <- dd b (%i6) "<-" (a, "dd" (b)); (%o6) a <- dd b
Die Maxima-Funktionen, um Operatoren zu definieren, sind in der folgenden Tabelle zusammengefasst. Weiterhin sind die Standardvorgaben für die links- und rechtsseitige Bindungskraft der Operatoren (lbp und rbp) angegeben. Die Bindungskräfte bestimmen den Vorrang der Operatoren.
Prefix
rbp=180
Postfix
lbp=180
Infix
lbp=180, rbp=180
N-ary
lbp=180, rbp=180
Matchfix
(Bindungskraft nicht anwendbar)
Nofix
(Bindungskraft nicht anwendbar)
Die folgende Tabelle enthält die Maxima-Operatoren und deren links- und rechtsseitigen Bindungskräfte.
Operator lbp rbp lpos rpos pos : 180 20 :: 180 20 := 180 20 ::= 180 20 ! 160 !! 160 ^ 140 139 . 130 129 * 120 expr expr / 120 120 expr expr expr + 100 134 expr expr - 100 134 expr expr = 80 80 # 80 80 > 80 80 >= 80 80 < 80 80 <= 80 80 not 70 clause clause clause and 65 or 60 , 10 $ -1 ; -1
Mit den Befehlen remove
und kill
können Operatoreigenschaften
von einem Symbol entfernt werden. remove("a", op)
entfernt
die Operator-Eigenschaften des Symbols a. kill("a")
entfernt
alle Eigenschaften einschließich der Operator-Eigenschaften des Symbols
a. In diesem Fall steht der Name des Symbols in Anführungszeichen.
(%i1) infix ("##"); (%o1) ## (%i2) "##" (a, b) := a^b; b (%o2) a ## b := a (%i3) 5 ## 3; (%o3) 125 (%i4) remove ("##", op); (%o4) done (%i5) 5 ## 3; Incorrect syntax: # is not a prefix operator 5 ## ^ (%i5) "##" (5, 3); (%o5) 125 (%i6) infix ("##"); (%o6) ## (%i7) 5 ## 3; (%o7) 125 (%i8) kill ("##"); (%o8) done (%i9) 5 ## 3; Incorrect syntax: # is not a prefix operator 5 ## ^ (%i9) "##" (5, 3); (%o9) ##(5, 3)
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Deklariert op als einen Infix-Operator. Ein Infix-Operator hat eine
Funktionsdefinition mit zwei Argumenten. Der Infix-Operator steht zwischen den
Argumenten. Zum Beispiel ist die Subtraktion -
ein Infix-Operator.
infix(op)
deklariert op als einen Infix-Operator mit einer
links- und rechtsseitigen Bindungskraft von jeweils 180.
infix (op, lbp, rbp)
deklariert op als einen
Infix-Operator mit den angegebenen Werten für die links- und rechtsseitige
Bindungskraft.
infix(op, lbp, rbp, lpos, rpos, pos)
deklariert op als einen Infix-Operator mit den angegebenen
Bindungskräften sowie den Wortarten lpos, rpos und pos für
den linken und den rechten Operanden sowie das Ergebnis des Operators.
Wortart bedeutet hier, den Type eines Operanden. Maxima kennt die drei Typen
expr
, clause
und any
. Diese stehen für einen
algebraischen Ausdruck, einen logischen Ausdruck und einen beliebigen Ausdruck.
Mit Hilfe der für einen Operator definierten Wortart kann der Parser beim
Einlesen eines Ausdrucks Syntaxfehler feststellen.
Der Vorrang eines Operators op vor anderen Operatoren leitet sich aus den links- und rechtsseitigen Bindungskräften ab. Sind die links- und rechtsseitigen Bindungskräfte von op beide größer als die links- und rechtsseitige Bindungskraft eines anderen Operators, dann hat op Vorrang vor dem anderen Operator. Sind die Bindungskräfte nicht beide größer oder kleiner, werden weitere Regeln zur Bestimmung des Vorrangs herangezogen.
Die Assoziativität eines Operators op hängt ab von seiner Bindungskraft. Eine größere linksseitige Bindungskraft hat zur Folge, dass der Operator op vor einem anderen Operator auf seiner linken Seite ausgewertet wird. Während eine größere rechtsseitige Bindungskraft zur Folge hat, dass der Operator vor anderen Operaroten auf der rechten Seite ausgewertet wird. Daraus folgt, dass eine größere linksseitige Bindungskraft lbp einen Operator op rechts-assoziativ und eine größere rechtsseitige Bindungskraft rbp den Operator links-assoziativ macht. Sind die links- und rechtsseitigen Bindungskräfte gleich groß, ist der Operator op links-assoziativ.
Beispiele:
Sind die rechtsseitigen und linksseitigen Bindungskräfte eines Operators op größer als die entsprechenden Bindungskräfte eines anderen Operatores, dann hat der Operator op Vorrang.
(%i1) :lisp (get '$+ 'lbp) 100 (%i1) :lisp (get '$+ 'rbp) 100 (%i1) infix ("##", 101, 101); (%o1) ## (%i2) "##"(a, b) := sconcat("(", a, ",", b, ")"); (%o2) (a ## b) := sconcat("(", a, ",", b, ")") (%i3) 1 + a ## b + 2; (%o3) (a,b) + 3 (%i4) infix ("##", 99, 99); (%o4) ## (%i5) 1 + a ## b + 2; (%o5) (a+1,b+2)
Eine größere linksseitige Bindungskraft lbp bewirkt, dass der Operator op rechts-assoziativ ist. Eine größere rechtsseitige Bindungskraft macht dagegen den Operator op links-assoziativ.
(%i1) infix ("##", 100, 99); (%o1) ## (%i2) "##"(a, b) := sconcat("(", a, ",", b, ")")$ (%i3) foo ## bar ## baz; (%o3) (foo,(bar,baz)) (%i4) infix ("##", 100, 101); (%o4) ## (%i5) foo ## bar ## baz; (%o5) ((foo,bar),baz)
Maxima kann Syntaxfehler beim Einlesen eines Ausdrucks feststellen, wenn der eingelesene Operand nicht die für den Operator definierte Wortart hat.
(%i1) infix ("##", 100, 99, expr, expr, expr); (%o1) ## (%i2) if x ## y then 1 else 0; Incorrect syntax: Found algebraic expression where logical expression expected if x ## y then ^ (%i2) infix ("##", 100, 99, expr, expr, clause); (%o2) ## (%i3) if x ## y then 1 else 0; (%o3) if x ## y then 1 else 0
Deklariert einen Matchfix-Operator mit dem linksseitigen Begrenzungszeichen ldelimiter und dem rechtsseitigen Begrenzungszeichen rdelimiter.
Ein Matchfix-Operator hat eine beliebige Anzahl an Argumenten, die zwischen
dem linksseitigen und dem rechtsseitigen Begrenzungszeichen stehen. Das
Begrenzungszeichen kann eine beliebige Zeichenkette sein. Einige Zeichen wie
%
, ,
, $
und ;
können nicht als Begrenzungszeichen
definiert werden.
Ein linksseitiges Begrenzungszeichen kann nicht verschiedene rechtsseitige Begrenzungszeichen haben.
Maxima-Operatoren können als Matchfix-Operatoren definiert werden, ohne
dass sich die sonstigen Operatoreigenschaften ändern. So kann zum Beispiel
der Operator +
als Matchfix-Operator definiert werden.
matchfix(ldelimiter, rdelimiter, arg_pos, pos)
definiert die Wortarten für die Argumente arg_pos und das Ergebnis
pos sowie das linksseitige ldelimiter und rechtsseitige
rdelimiter Begrenzungszeichen.
Wortart bedeutet hier, den Type eines Operanden. Maxima kennt die drei Typen
expr
, clause
und any
. Diese stehen für einen
algebraischen Ausdruck, einen logischen Ausdruck und einen beliebigen Ausdruck.
Mit Hilfe der für einen Operator definierten Wortart kann der Parser beim
Einlesen eines Ausdrucks Syntaxfehler feststellen.
Die zu einem Matchfix-Operator zugehörige Funktion kann jede
nutzerdefinierte Funktion sein, die mit :=
oder define
definiert
wird. Die Definition der Funktion kann mit dispfun(ldelimiter)
ausgegeben werden.
Maxima kennt nur den Operator für Listen [ ]
als Matchfix-Operator.
Klammern ( )
und Anführungszeichen " "
arbeiten wie
Matchfix-Operatoren, werden aber vom Parser nicht als Matchfix-Operatoren
behandelt.
matchfix
wertet seine Argumente aus. matchfix
gibt das erste
Argument ldelimiter als Ergebnis zurück.
Beispiele:
Begrenzungszeichen können eine beliebige Zeichenkette sein.
(%i1) matchfix ("@@", "~"); (%o1) @@ (%i2) @@ a, b, c ~; (%o2) @@a, b, c~ (%i3) matchfix (">>", "<<"); (%o3) >> (%i4) >> a, b, c <<; (%o4) >>a, b, c<< (%i5) matchfix ("foo", "oof"); (%o5) foo (%i6) foo a, b, c oof; (%o6) fooa, b, coof (%i7) >> w + foo x, y oof + z << / @@ p, q ~; >>z + foox, yoof + w<< (%o7) ---------------------- @@p, q~
Matchfix-Operatoren können für nutzerdefinierte Funktionen definiert werden.
(%i1) matchfix ("!-", "-!"); (%o1) "!-" (%i2) !- x, y -! := x/y - y/x; x y (%o2) !-x, y-! := - - - y x (%i3) define (!-x, y-!, x/y - y/x); x y (%o3) !-x, y-! := - - - y x (%i4) define ("!-" (x, y), x/y - y/x); x y (%o4) !-x, y-! := - - - y x (%i5) dispfun ("!-"); x y (%t5) !-x, y-! := - - - y x (%o5) done (%i6) !-3, 5-!; 16 (%o6) - -- 15 (%i7) "!-" (3, 5); 16 (%o7) - -- 15
Ein N-ary
-Operator ist ein Operator, der eine beliebige Anzahl an
Argumenten haben kann. Die Argumente werden durch den Operator voneinander
getrennt, so ist zum Beispiel +
ein N-ary
-Operator und
A+B+C
. Die Funktion nary("x")
ermöglicht die Erweiterung der
Maxima-Syntax um einen N-ary-Operator x
. Funktionen können als
N-ary-Operator deklariert werden. declare(j,nary)
deklariert den
Operator j
zu einem N-ary-Operator. Ein Ausdruck j(j(a,b),j(c,d)
wird in diesem Fall zu j(a,b,c,d)
vereinfacht.
Nofix-Operatoren sind Operatoren, die kein Argument haben. Tritt ein solcher
Operator allein auf, wird die dazugehörige Funktion ausgewertet. Zum Beispiel
beendet die Funktion quit()
eine Maxima-Sitzung. Wird diese Funktion
mit nofix("quit")
zu einen Nofix-Operator deklariert, genügt die
Eingabe von quit;
, um eine Maxima-Sitzung zu beenden. Die Funktion
nofix("x")
erweitert die Maxima-Syntax um den Nofix-Operator x
.
Postfix-Operatoren und Prefix-Operatoren bezeichnen Operatoren mit einem
Argument, wobei für Postfix-Operatoren der Operator dem Argument direkt
nachfolgt. Ein Beispiel ist der !
-Operator mit 3!
. Die Funktion
postfix("x")
erweitert die Maxima-Syntax um den Postfix-Operator
x
.
Ein Prefix-Operator ist ein Operator mit einem Argument, das dem Operator
nachfolgt. Mit prefix("x")
wird die Maxima-Syntax um einen
Prefix-Operator x
erweitert.
[ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This document was generated by Robert Dodier on April, 4 2011 using texi2html 1.76.