Funktionen und Variablen für Aussagen (Maxima Manual)

Vorige: Funktionen und Variablen für Fakten, Nach oben: Maximas Datenbank [Inhalt][Index]

### 11.4 Funktionen und Variablen für Aussagen

Funktion: charfun (p) ¶

  Gibt den Wert 0 zurück, wenn die Aussage p zu `false` ausgewertet werden kann und den Wert 1, wenn die Auswertung `true` liefert. Kann die Aussage weder zu `false` oder `true` ausgewertet werden, wird eine Substantiv-Form zurück gegeben.

  Beispiele:

      (%i1) charfun (x < 1);
      (%o1)                    charfun(x < 1)
      (%i2) subst (x = -1, %);
      (%o2)                           1
      (%i3) e : charfun ('"and" (-1 < x, x < 1))$
      (%i4) [subst (x = -1, e), subst (x = 0, e), subst (x = 1, e)];
      (%o4)                       [0, 1, 0]

Funktion: compare (x, y) ¶

  Liefert den Vergleichsoperator op (`<`, `<=`, `>`, `>=`, `=` oder `#`), so dass der Ausdruck `is(x op y)` zu `true` ausgewertet werden kann. Ist eines der Argumente eine komplexe Zahl, dann wird `notcomparable` zurückgegeben. Kann Maxima keinen Vergleichsoperator bestimmen, wird `unknown` zurückgegeben.

  Beispiele:

      (%i1) compare (1, 2);
      (%o1)                           <
      (%i2) compare (1, x);
      (%o2)                        unknown
      (%i3) compare (%i, %i);
      (%o3)                           =
      (%i4) compare (%i, %i + 1);
      (%o4)                     notcomparable
      (%i5) compare (1/x, 0);
      (%o5)                           #
      (%i6) compare (x, abs(x));
      (%o6)                          <=

  Die Funktion `compare` versucht nicht festzustellen, ob der Wertebereich einer Funktion reelle Zahlen enthält. Obwohl der Wertebereich von `acos(x^2+1)` bis auf Null keine reellen Zahlen enthält, gibt `compare` das folgende Ergebnis zurück:

      (%i1) compare (acos (x^2 + 1), acos (x^2 + 1) + 1);
      (%o1)                           <

Funktion: equal (a, b) ¶

  Repräsentiert die Äquivalenz, das heißt den gleichen Wert.

  `equal` wird nicht ausgewertet oder vereinfacht. Die Funktion `is` versucht einen Ausdruck mit `equal` zu einem booleschen Wert auszuwerten. `is(equal(a, b))` gibt `true` oder `false` zurück, wenn und nur wenn a und b gleich oder ungleich sind für alle Werte ihrer Variablen, was mit `ratsimp(a - b)` bestimmt wird. Gibt `ratsimp` das Ergebnis 0 zurück, werden die beiden Ausdrücke als äquivalent betracht. Zwei Ausdrücke können äquivalent sein, obwohl sie nicht syntaktisch gleich (im allgemeinen identisch) sind.

  Kann `is` einen Ausdruck mit `equal` nicht zu `true` oder `false` auswerten, hängt das Ergebnis vom Wert des globalen Flags `prederror` ab. Hat `prederror` den Wert `true`, gibt `is` eine Fehlermeldung zurück. Ansonsten wird `unknown` zurückgegeben.

  Es gibt weitere Operatoren, die einen Ausdruck mit `equal` zu `true` oder `false` auswerten können. Dazu gehören `if`, `and`, `or` und `not`.

  Die Umkehrung von `equal` ist `notequal`.

  Beispiele:

  `equal` wird von allein weder ausgewertet noch vereinfacht:

      (%i1) equal (x^2 - 1, (x + 1) * (x - 1));
                              2
      (%o1)            equal(x  - 1, (x - 1) (x + 1))
      (%i2) equal (x, x + 1);
      (%o2)                    equal(x, x + 1)
      (%i3) equal (x, y);
      (%o3)                      equal(x, y)

  Die Funktion `is` versucht, `equal` zu einem booleschen Wert auszuwerten. Der Ausdruck `is(equal(a, b))` gibt den Wert `true` zurück, when `ratsimp(a - b)` den Wert 0 hat. Zwei Ausdrücke können äquivalent sein, obwohl sie nicht syntaktisch gleich sind.

      (%i1) ratsimp (x^2 - 1 - (x + 1) * (x - 1));
      (%o1)                           0
      (%i2) is (equal (x^2 - 1, (x + 1) * (x - 1)));
      (%o2)                         true
      (%i3) is (x^2 - 1 = (x + 1) * (x - 1));
      (%o3)                         false
      (%i4) ratsimp (x - (x + 1));
      (%o4)                          - 1
      (%i5) is (equal (x, x + 1));
      (%o5)                         false
      (%i6) is (x = x + 1);
      (%o6)                         false
      (%i7) ratsimp (x - y);
      (%o7)                         x - y
      (%i8) is (equal (x, y));
      (%o8)                        unknown
      (%i9) is (x = y);
      (%o9)                         false

  Kann `is` einen Ausdruck mit `equal` nicht zu `true` oder `false` vereinfachen, hängt das Ergebnis vom Wert des globalen Flags `prederror` ab.

      (%i1) [aa : x^2 + 2*x + 1, bb : x^2 - 2*x - 1];
                          2             2
      (%o1)             [x  + 2 x + 1, x  - 2 x - 1]
      (%i2) ratsimp (aa - bb);
      (%o2)                        4 x + 2
      (%i3) prederror : true;
      (%o3)                         true
      (%i4) is (equal (aa, bb));
      Maxima was unable to evaluate the predicate:
             2             2
      equal(x  + 2 x + 1, x  - 2 x - 1)
       -- an error.  Quitting.  To debug this try debugmode(true);
      (%i5) prederror : false;
      (%o5)                         false
      (%i6) is (equal (aa, bb));
      (%o6)                        unknown

  Einige weitere Operatoren werten `equal` und `notequal` zu einem booleschen Wert aus.

      (%i1) if equal (y, y - 1) then FOO else BAR;
      (%o1)                          BAR
      (%i2) eq_1 : equal (x, x + 1);
      (%o2)                    equal(x, x + 1)
      (%i3) eq_2 : equal (y^2 + 2*y + 1, (y + 1)^2);
                               2                   2
      (%o3)             equal(y  + 2 y + 1, (y + 1) )
      (%i4) [eq_1 and eq_2, eq_1 or eq_2, not eq_1];
      (%o4)                  [false, true, true]

  Da `not expr` den Ausdruck expr auswertet, ist `not equal(a, b)` äquivalent zu `is(notequal(a, b))`

      (%i1) [notequal (2*z, 2*z - 1), not equal (2*z, 2*z - 1)];
      (%o1)            [notequal(2 z, 2 z - 1), true]
      (%i2) is (notequal (2*z, 2*z - 1));
      (%o2)                         true

Funktion: notequal (a, b) ¶

  Repräsentiert die Verneinung von `equal(a, b)`.

  Beispiele:

      (%i1) equal (a, b);
      (%o1)                      equal(a, b)
      (%i2) maybe (equal (a, b));
      (%o2)                        unknown
      (%i3) notequal (a, b);
      (%o3)                    notequal(a, b)
      (%i4) not equal (a, b);
      (%o4)                    notequal(a, b)
      (%i5) maybe (notequal (a, b));
      (%o5)                        unknown
      (%i6) assume (a > b);
      (%o6)                        [a > b]
      (%i7) equal (a, b);
      (%o7)                      equal(a, b)
      (%i8) maybe (equal (a, b));
      (%o8)                         false
      (%i9) notequal (a, b);
      (%o9)                    notequal(a, b)
      (%i10) maybe (notequal (a, b));
      (%o10)                        true

Funktion: unknown (expr) ¶

  Gibt den Wert `true` zurück, wenn der Ausdruck expr einen Operator oder eine Funktion enthält, die nicht von Maximas Vereinfacher erkannt wird.

Funktion: zeroequiv (expr, v) ¶

  Testet, ob ein Ausdruck expr mit der Variablen v äquivalent zu Null ist. Die Funktion gibt `true`, `false` oder `dontknow` zurück.

  `zeroequiv` hat Einschränkungen:

  1. Funktionen im Ausdruck expr müssen von Maxima differenzierbar und auswertbar sein.
  2. Hat der Ausdruck Pole auf der reellen Achse, können Fehler auftreten.
  3. Enthält der Ausdruck Funktionen, die nicht Lösung einer Differentialgleichung erster Ordnung sind (zum Beispiel Bessel Funktionen), können die Ergebnisse fehlerhaft sein.
  4. Der Algorithmus wertet die Funktion an zufällig Punkten für ausgewählte Teilausdrücke aus. Dies ist ein riskantes Verfahren und kann zu Fehlern führen.

  `zeroequiv(sin(2*x) - 2*sin(x)*cos(x), x)` hat zum Beispiel das Ergebnis `true` und `zeroequiv (%e^x + x, x)` hat das Ergebnis `false`. Andererseits hat `zeroequiv (log(a*b) - log(a) - log(b), a)` das Ergebnis `dontknow`, wegen dem zusätzlichem Parameter `b`.

Vorige: Funktionen und Variablen für Fakten, Nach oben: Maximas Datenbank [Inhalt][Index]