[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

7. Operatoren


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

7.1 Arithmetische Operatoren

Operator: +
Operator: -
Operator: *
Operator: /
Operator: ^

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 ]

Operator: **

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

Operator: ^^

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

Operator: .

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] [ ? ]

7.2 Relationale Operatoren

Operator: <
Operator: <=
Operator: >=
Operator: >

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] [ ? ]

7.3 Logische Operatoren

Operator: and

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.

Operator: or

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.

Operator: not

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] [ ? ]

7.4 Operatoren für Gleichungen

Operator: #

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

Operator: =

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] [ ? ]

7.5 Zuweisungsoperatoren

Operator: :

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

Operator: ::

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

Operator: ::=

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

Operator: :=

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.

Siehe auch define und ::=.

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] [ ? ]

7.6 Einführung in nutzerdefinierte Operatoren

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:

unär Prefix

Negation - a

unär Postfix

Fakultät a!

binär Infix

Exponentiation a^b

N-ary Infix

Addition a + b

Matchfix

Liste [a,b]

Nofix

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] [ ? ]

7.7 Funktionen und Variable für nutzerdefinierte Operatoren

Funktion: infix (op)
Funktion: infix (op, lbp, rbp)
Funktion: infix (op, lbp, rbp, lpos, rpos, pos)

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

Funktion: matchfix (ldelimiter, rdelimiter)
Funktion: matchfix (ldelimiter, rdelimiter, arg_pos, pos)

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

Funktion: nary (x)

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.

Funktion: nofix (x)

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.

Funktion: postfix (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.

Funktion: prefix (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.