Next: Arithmetische Operatoren, Previous: Operatoren, Nach oben: Operatoren [Inhalt][Index]
Maxima kennt die üblichen arithmetischen, relationalen und logischen
Operatoren der Mathematik.  Weiterhin kennt Maxima Operatoren für die
Zuweisung von Werten an Variablen und die Definition von Funktionen.  Die
folgende Tabelle zeigt die in diesem Kapitel beschriebenen Operatoren.
Angegeben sind der Name des Operators, der linksseitige Vorrang lbp und
der rechtsseitige Vorrang rbp, der Typ des Operators und ein Beispiel
einschließlich der internen Darstellung, wie sie vom Parser von der Eingabe
gelesen wird.
Operator  lbp rbp  Typ     Beispiel
                       
   +      100 134  nary     a+b      ((mplus) $A $B)
   -      100 134  prefix   -a       ((mminus) $A)
   *      120      nary     a*b      ((mtimes) $A $B)
   /      120 120  infix    a/b      ((mquotient) $A $B)
   ^      140 139  infix    a^b      ((mexpt) $A $B)
   **     140 139  infix    a**b     ((mexpt) $A $B)
   ^^     140 139  infix    a^^b     ((mncexpt) $A $B)
   .      130 129  infix    a.b      ((mnctimes) $A $B)
                                     
   <       80  80  infix    a<b      ((mlessp) $A $B)
   <=      80  80  infix    a<=b     ((mleqp) $A $B)
   >       80  80  infix    a>b      ((mqreaterp) $A $B)
   >=      80  80  infix    a>=b     ((mgeqp) $A $B)
                                     
   not         70  prefix   not a    ((mnot) $A)
   and     65      nary     a and b  ((mand) $A $B)
   or      60      nary     a or b   ((mor) $A $B)
                                     
   #       80  80  infix    a#b      ((mnotequal) $A $B)
   =       80  80  infix    a=b      ((mequal) $A $B)
                                     
   :      180  20  infix    a:b      ((msetq) $A $B)
   ::     180  20  infix    a::b     ((mset) $A $B)
   :=     180  20  infix    a:=b     ((mdefine) $A $B)
   ::=    180  20  infix    a::=b    ((mdefmacro) $A $B)
Mit dem Vorrang der Operatoren werden die bekannten Rechenregeln der einzelnen
Operatoren definiert.  So wird zum Beispiel  a + b * c  vom Parser
als  a + (b * c)  interpretiert, da der linksseitige Vorrang der
Multiplikation größer als der linksseitige Vorrang der Addition ist.
Maxima unterscheidet die folgenden Operatoren:
Prefix-Operatoren sind unäre Operatoren, die einen Operanden haben, der dem 
Operator nachfolgt.  Beispiele sind die Operatoren - und not.
Postfix-Operatoren sind unäre Operatoren, die einen Operanden haben, der dem 
Operator vorangestellt ist.  Ein Beispiel ist der Operator ! für die 
Fakultät.
Infix-Operatoren, sind binäre Operatoren, die zwei Operanden haben.  Der
Operator steht zwischen diesen Operanden.  Hierzu zählen zum Beispiel der
Operator für die Exponentiation ^ oder der Operator für die Zuweisung
:.
N-ary-Operatoren fassen eine beliebige Anzahl an Operanden zu einem Ausdruck
zusammen.  Hierzu zählen die Multiplikation * oder die Addition
+.
Matchfix-Operatoren sind Begrenzungszeichen, die eine beliebige Anzahl an
Operanden einschließen.  Ein Beispiel sind die Operatoren [ und
], die eine Liste [a, b, ...] definieren.
Ein Nofix-Operator ist ein Operator, der keinen Operanden hat.  Maxima kennt
keinen internen Nofix-Operator.  Zum Beispiel kann mit nofix(quit) ein
Nofix-Operator definiert werden.  Dann ist es möglich, Maxima allein mit
quit anstatt dem Funktionsaufruf quit() zu beenden.
Maxima unterscheidet das Symbol eines Operators, wie zum Beispiel +
für die Addition, von dem Namen eines Operators, der eine Zeichenkette ist.
Der Additionsoperator hat den Namen "+".  Mit dem Namen des Operators
kann der Operator als eine Funktion eingegeben werden.  Im folgenden wird ein
Beispiel für den binären Infix-Operator der Exponentiation gezeigt:
(%i1) a^b;
                                b
(%o1)                          a
(%i2) "^"(a,b);
                                b
(%o2)                          a
Der Name des Operators kann immer dann verwendet werden, wenn eine
Funktion als Argument benötigt wird.  Beispiele sind die Funktionen
map, apply oder auch die Substitution mit subst.
(%i3) apply("+", [a,b,c]);
(%o3)                       c + b + a
(%i4) map("^", [a,b,c],[1,2,3]);
                                2   3
(%o4)                      [a, b , c ]
(%i5) subst("*"="+", 10*a*b*c);
(%o5)                    c + b + a + 10
In Nutzerdefinierte Operatoren wird beschrieben, wie interne Maxima-Operatoren umdefiniert oder neue Operatoren definiert werden.
Die obige Tabelle enthält nicht alle von Maxima definierten Operatoren.
Weitere Operatoren sind zum Beispiel ! für die Fakultät, die
Operatoren for, do, while, um eine Programmschleife zu 
programmieren, oder if, then, else, um eine Bedingung zu 
definieren.
Next: Arithmetische Operatoren, Previous: Operatoren, Nach oben: Operatoren [Inhalt][Index]