Maxima Manual: Operatoren für Gleichungen

Next: Zuweisungsoperatoren, Previous: Logische Operatoren, Nach oben: Operatoren [Inhalt][Index]

### 7.5 Operatoren für Gleichungen

Operator: #

  Ist der Operator für eine Ungleichung. `#` ist ein Infix-Operator mit zwei Operanden.

  Mit dem Operator `#` wird eine Ungleichung `a # b` formuliert, wobei die Operanden `a` und `b` jeweils die linke und die rechte Seite der Ungleichung sind und beliebige Ausdrücke sein können. Die Operanden werden ausgewertet, nicht jedoch die Ungleichung selbst.

  Die Funktionen `is`, `maybe`, die logischen Operatoren `and`, `or` und `not` sowie die Funktionen für die Definition von Programmanweisungen wie `if`, `while` oder `unless` erzwingen die Auswertung einer 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`.

  Die Funktionen `rhs` und `lhs` geben die rechte und die linke Seite einer Gleichung oder Ungleichung zurück.

  Siehe auch den Operator `=`, um eine Gleichung zu formulieren, sowie die Funktionen `equal` und `notequal`.

  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. `=` ist ein Infix-Operator mit zwei Operanden.

  Mit dem Operator `=` wird eine Gleichung `a = b` formuliert, wobei die Operanden `a` und `b` jeweils die linke und die rechte Seite der Gleichung sind und beliebige Ausdrücke sein können. Die Operanden werden ausgewertet, nicht jedoch die Gleichung selbst. Nicht ausgewertete Gleichungen können als Argument von Funktionen wie zum Beispiel den Funktionen `solve`, `algsys` oder `ev` auftreten.

  Die Funktion `is` wertet eine Gleichung `=` zu einem booleschen Wert aus. `is(a = b)` wertet die Gleichung `a = b` zum Wert `true` aus, wenn `a` und `b` identische Ausdrücke sind. Das trifft zu, wenn `a` und `b` identische Atome sind oder wenn ihre Operatoren sowie die Operanden 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, dass `is(equal(a, b))` den Wert `true` hat. Ausdrücke können äquivalent aber syntaktisch verschieden sein.

  Eine Ungleichung wird mit dem Operator `#` formuliert. Wie für den Operator `=` für eine Gleichung wird eine Ungleichung `a # b` nicht ausgewertet. Eine Auswertung erfolgt mit `is(a # b)`, welche die Werte `true` oder `false` als Ergebnis hat.

  Neben `is` werten auch die Operatoren `if`, `and`, `or` und `not` Gleichungen mit dem Operator `=` oder Ungleichungen mit dem Operator `#` zu den Werten `true` oder `false` aus.

  Wegen der Regeln für die Auswertung von Aussagen und weil im Ausdruck `not expr` der Operand `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 Seite einer Gleichung oder Ungleichung zurück.

  Siehe auch den Operator `#` für Ungleichungen sowie die Funktionen `equal` und `notequal`.

  Beispiele:

  Ein Ausdruck `a = b` repräsentiert eine nicht ausgewertete Gleichung.

      (%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 die Gleichung `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

Next: Zuweisungsoperatoren, Previous: Logische Operatoren, Nach oben: Operatoren [Inhalt][Index]