Maxima Manual: Einführung in Operatoren

Next: Arithmetische Operatoren, Previous: Operatoren, Nach oben: Operatoren [Inhalt][Index]

### 7.1 Einführung in Operatoren

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

  Prefix-Operatoren sind unäre Operatoren, die einen Operanden haben, der dem Operator nachfolgt. Beispiele sind die Operatoren `-` und `not`.

Postfix

  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

  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

  N-ary-Operatoren fassen eine beliebige Anzahl an Operanden zu einem Ausdruck zusammen. Hierzu zählen die Multiplikation `*` oder die Addition `+`.

Matchfix

  Matchfix-Operatoren sind Begrenzungszeichen, die eine beliebige Anzahl an Operanden einschließen. Ein Beispiel sind die Operatoren `[` und `]`, die eine Liste `[a, b, ...]` definieren.

Nofix

  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]