Next: Relationale Operatoren, Previous: Einführung in Operatoren, Up: Operatoren [Contents][Index]

### 7.2 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.

  In Ausdrücken wie `(+a)*(-a)` oder `exp(-a)` repräsentieren die Operatoren `+` und `-` die unäre Addition und Negation. Die Namen der Operatoren sind `"+"` und `"-"`.

  Die Subtraktion `a - b` wird von Maxima intern als Addition `a + (- b)` dargestellt. In der Ausgabe wird der Ausdruck `a + (- b)` als Subtraktion `a - b` angezeigt.

  Die Division `a / b` wird von Maxima intern als Multiplikation `a * b^(- 1)` dargestellt. In der Ausgabe wird der Ausdruck `a * b^(- 1)` als Division `a / b` angezeigt. Der Name des Operators für die Division ist `"/"`.

  Die Operatoren der Addition und Multiplikation sind kommutative N-ary-Operatoren. Die Operatoren der Division und Exponentiation sind nicht-kommutative binäre Operatoren.

  Maxima sortiert die Operanden eines kommutativen Operators und konstruiert eine kanonische Darstellung. Maxima unterscheidet die interne Sortierung von der externen Sortierung für die Anzeige. Die interne Sortierung wird von der Aussagefunktion `orderlessp` bestimmt. Die externe Sortierung für die Anzeige wird von der Aussagefunktion `ordergreatp` festgelegt. Ausnahme ist die Multiplikation. Für diese sind die interne und die externe Sortierung identisch.

  Arithmetische Rechnungen mit Zahlen (ganzen Zahlen, rationale Zahlen, Gleitkommazahlen und großen Gleitkommazahlen) werden als eine Vereinfachung und nicht als Auswertung ausgeführt. Mit Ausnahme der Exponentiation werden alle arithmetischen Operationen mit Zahlen zu Zahlen vereinfacht. Exponentiationen von Zahlen wie zum Beispiel `(1/3)^(1/2)` werden nicht notwendigerweise zu Zahlen vereinfacht. In diesem Beispiel ist das Ergebnis der Vereinfachung `1/sqrt(3)`.

  Bei einer arithmetischen 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 einer der Operanden eine einfache Gleitkommazahl ist. Treten nur ganze oder rationale Zahlen auf, ist das Ergebnis wieder eine ganze oder rationale Zahl.

  Da arithmetische Rechnungen Vereinfachungen und keine Auswertungen sind, werden arithmetische Rechnungen auch dann ausgeführt, wenn die Auswertung des Ausdrucks zum Beispiel mit dem `Quote-Operator` `'` unterdrückt ist.

  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 einer der Operanden eine Liste oder Matrix und der andere Operand 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

  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 und Division 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

  Sind die Operanden Zahlen, werden die Rechnungen ausgeführt. Ist einer der Operanden eine Gleitkommazahl, ist das Ergebnis ebenfalls eine Gleitkommazahl.

      (%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 den Operator der Exponentiation `^`.

  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 der nicht-kommutativen Multiplikation von Matrizen. Siehe für Erläuterungen Nicht-kommutative Multiplikation.

Next: Relationale Operatoren, Previous: Einführung in Operatoren, Up: Operatoren [Contents][Index]