Funktionen und Variablen für Fakten (Maxima Manual)

Next: Funktionen und Variablen für Aussagen, Previous: Funktionen und Variablen für Eigenschaften, Up: Maximas Datenbank [Contents][Index]

### 11.3 Funktionen und Variablen für Fakten

Funktion: activate (context_1, …, context_n)

  Das Kommando `activate(context)` aktiviert den Kontext context. Der Funktion `activate` können mehrere Kontexte context_1, …, context_n übergeben werden. Nur die Aussagen und Fakten eines aktiven Kontextes stehen für die Auswertung von Aussagen zur Verfügung.

  Maxima gibt `done` zurück, wenn der Kontext erfolgreich aktiviert werden konnte oder wenn der Kontext bereits aktiv ist. Wird versucht einen nicht existierenden Kontext zu aktivieren, gibt Maxima eine Fehlermeldung aus.

  Das Kommando `facts()` gibt die Fakten und Aussagen des aktuellen Kontextes aus. Die Aussagen und Fakten anderer Kontexte können zwar aktiv sein, sind aber in der Rückgabe von `facts` nicht enthalten. Um die Aussagen und Fakten eines anderen als des aktuellen Kontexts auszugeben, kann das Kommando `facts(context)` ausgeführt werden.

  Die Systemvariable `activecontexts` enthält eine Liste der aktiven Kontexte. Siehe auch die Systemvariable `contexts` für eine Liste aller Kontexte, die Maxima kennt.

Systemvariable: activecontexts

  Standardwert: `[]`

  Die Systemvariable `activecontexts` enthält eine Liste der Kontexte, die mit der Funktion `activate` aktiviert wurden. Unterkontexte sind aktiv, ohne dass die Funktion `activate` aufgerufen werden muss und sind nicht in der Liste `activecontexts` enthalten. Siehe auch die Funktion `activate` für die Aktivierung eines Kontextes und die Systemvariable `contexts` für eine Liste aller vorhandenen Kontexte.

Funktion: askinteger (expr, integer)
Funktion: askinteger (expr)
Funktion: askinteger (expr, even)
Funktion: askinteger (expr, odd)

  Das Kommando `askinteger(expr, integer)` versucht anhand der Aussagen und Fakten der aktiven Kontexte zu entscheiden, ob expr eine ganze Zahl repräsentiert. Kann `askinteger` die Frage nicht entscheiden, fragt Maxima den Nutzer. Die Antwort wird dem aktuellen Kontext hinzugefügt. `askinteger(expr)` ist äquivalent zu `askinteger(expr, integer)`.

  `askinteger(expr, even)` und `askinteger(expr, odd)` versuchen zu entscheiden, ob expr eine gerade oder ungerade ganze Zahl repräsentiert. Kann Maxima dies nicht entscheiden, wird der Nutzer gefragt. Die Antwort wird dem aktuellen Kontext hinzugefügt.

  Beispiele:

      (%i1) askinteger(n,integer);
      Is n an integer?
      yes;
      (%o1)                          yes
      (%i2) askinteger(e,even);
      Is e an even number?
      yes;
      (%o2)                          yes
      (%i3) facts();
      (%o3)           [kind(n, integer), kind(e, even)]
      (%i4) declare(f,integervalued);
      (%o4)                         done
      (%i5) askinteger(f(x));
      (%o5)                          yes

Funktion: asksign (expr)

  Die Funktion `asksign` versucht zu entscheiden, ob der Ausdruck expr einen positiven, negativen oder den Wert Null repräsentiert. Kann Maxima dies nicht feststellen, wird der Nutzer nach weiteren Informationen gefragt, um die Frage zu entscheiden. Die Antworten des Nutzers werden für die laufende Auswertung dem aktuellen Kontext hinzugefügt. Der Rückgabewert der Funktion `asksign` ist `pos`, `neg` oder `zero` für einen positiven, negativen oder den Wert Null.

Funktion: assume (pred_1, …, pred_n)

  Fügt die Aussagen pred_1, …, pred_n dem aktuellen Kontext hinzu. Eine inkonsistente oder redundante Aussage wird dem Kontext nicht hinzugefügt. `assume` gibt eine Liste mit den Aussagen zurück, die dem Kontext hinzugefügt wurden, oder die Symbole `redunant` und `inconsistent`.

  Die Aussagen pred_1, …, pred_n können nur Ausdrücke mit den relationalen Operatoren `"<"`, `"<="`, `equal`, `notequal`, `">="` und `">"` sein. Aussagen können nicht die Operatoren `"="` für Gleichungen oder `"#"` für Ungleichungen enthalten. Auch können keine Aussagefunktionen wie `integerp` verwendet werden.

  Zusammengesetzte Aussagen mit dem Operator `and` der Form `pred_1 and ... and pred_n` sind möglich, nicht dagegen Aussagen mit dem Operator `or` der Form `pred_1 or ... or pred_n`. Ein Ausdruck mit dem Operator `not` der Form `not(pred_k)` ist dann möglich, wenn pred_k eine relationale Aussage ist. Aussagen der Form `not (pred_1 and pred_2)` und `not (pred_1 or pred_2)` sind dagegen nicht möglich.

  Der Folgerungsmechanismus von Maxima ist nicht sehr stark. Viele Schlußfolgerungen können von Maxima nicht abgeleitet werden. Dies ist eine bekannte Schwäche von Maxima.

  `assume` behandelt keine Aussagen mit komplexen Zahlen. Enthält eine Aussage eine komplexe Zahl, gibt `assume` den Wert `inconsistent` oder `redunant` zurück.

  `assume` wertet die Argumente aus.

  Siehe auch `is`, `facts`, `forget`, `context` und `declare`.

  Beispiele:

      (%i1) assume (xx > 0, yy < -1, zz >= 0);
      (%o1)              [xx > 0, yy < - 1, zz >= 0]
      (%i2) assume (aa < bb and bb < cc);
      (%o2)                  [bb > aa, cc > bb]
      (%i3) facts ();
      (%o3)     [xx > 0, - 1 > yy, zz >= 0, bb > aa, cc > bb]
      (%i4) is (xx > yy);
      (%o4)                         true
      (%i5) is (yy < -yy);
      (%o5)                         true
      (%i6) is (sinh (bb - aa) > 0);
      (%o6)                         true
      (%i7) forget (bb > aa);
      (%o7)                       [bb > aa]
      (%i8) prederror : false;
      (%o8)                         false
      (%i9) is (sinh (bb - aa) > 0);
      (%o9)                        unknown
      (%i10) is (bb^2 < cc^2);
      (%o10)                       unknown

Optionsvariable: assumescalar

  Standardwert: `true`

  Die Optionsvariable `assumescalar` kontrolliert, wie ein Ausdruck von den arithmetischen Operatoren `"+"`, `"*"`, `"^"`, `"."` und `"^^"` behandelt wird, wenn Maxima nicht ermitteln kann, ob der Ausdruck ein Skalar oder Nicht-Skalar ist. `assumescalar` hat drei mögliche Werte:

  `false`

    Unbekannte Ausdrücke werden als ein Nicht-Skalar behandelt.

  `true`

    Unbekannte Ausdrücke werden als ein Skalar für die kommutativen arithmetischen Operatoren `"+"`, `"*"` und `"^"` behandelt.

  `all`

    Unbekannte Ausdrücke werden für alle arithmetischen Operatoren als ein Skalar behandelt.

  Es ist besser Variablen als ein Skalar oder Nicht-Skalar mit der Funktion `declare` zu deklarieren, anstatt die Vereinfachung mit der Optionsvariablen `assumescalar` zu kontrollieren. Siehe auch die Eigenschaften `scalar` und `nonscalar` sowie die Funktionen `scalarp` und `nonscalarp`.

  Beispiele:

  Maxima kann nicht ermitteln, ob das Symbol `x` ein Skalar oder ein Nicht-Skalar ist.

      (%i1) scalarp(x);
      (%o1)                         false
      (%i2) nonscalarp(x);
      (%o2)                         false

  Hat `assumescalar` den Wert `true`, behandelt Maxima das Symbol `x` als einen Skalar für die kommutative Multiplikation.

      (%i3) x * [a,b,c], assumescalar:false;
      (%o3)                      x [a, b, c]
      (%i4) x * [a,b,c], assumescalar:true;
      (%o4)                    [a x, b x, c x]

  Für die nicht kommutative Multiplikation behandelt Maxima das Symbol `x` dann als einen Skalar, wenn `assumescalar` den Wert `all` hat.

      (%i5) x . [a,b,c], assumescalar:false;
      (%o5)                     x . [a, b, c]
      (%i6) x . [a,b,c], assumescalar:true;
      (%o6)                     x . [a, b, c]
      (%i7) x . [a,b,c], assumescalar:all;
      (%o7)                 [x . a, x . b, x . c]

Optionsvariable: assume_pos

  Standardwert: `false`

  Die Optionsvariable `assume_pos` kontrolliert das Ergebnis der Funktionen `sign` und `asksign`, für den Fall, dass Maxima das Vorzeichen einer Variablen oder indizierten Variablen nicht aus den aktiven Kontexten ermitteln kann. Hat `assume_pos` den Wert `true`, dann wird für Variable oder indizierte Variable, immer das Ergebnis `pos` ermittelt, wenn die Optionsvariable `assume_pos_pred` den Standardwert `false` hat und das Vorzeichen nicht aus den aktiven Kontexten ermittelt werden kann.

  Die Optionsvariable `assume_pos_pred` hat den Standardwert `false`. In diesem Fall werden von Maxima Variablen und indizierte Variablen als positiv angenommen, wenn `assume_pos` den Wert `true` hat. Der Optionsvariablen `assume_pos_pred` kann eine Aussagefunktion mit einem Argument zugewiesen werden. Hat die Aussagefunktion für ein Argument expr das Ergebnis `true`, wird das Argument als positiv angenommen, wenn die Optionsvariable `assume_pos` den Wert `true` hat und Maxima das Vorzeichen nicht aus den aktiven Kontexten ermitteln kann.

  Die Funktionen `sign` und `asksign` versuchen das Vorzeichen eines Ausdrucks anhand der Vorzeichen der Argumente zu ermitteln. Sind zum Beispiel `a` und `b` beide positiv, dann wird für den Ausdruck `a+b` ein positives Vorzeichen ermittelt. Auch wenn die Vorzeichen der Variablen `a` und `b` nicht bekannt sind, hat daher `asksign(a+b)` das Ergebnis `pos`, wenn `assume_pos` den Wert `true` hat, da in diesem Fall die Variablen als positiv angenommen werden.

  Es gibt jedoch keine Möglichkeit, alle Ausdrücke grundsätzlich als positiv zu erklären. Selbst wenn der Optionsvariablen `assume_pos_pred` eine Aussagefunktion zugewiesen wird, die alle Ausdrücke als positiv erklärt, werden Differenzen `a-b` oder das Vorzeichen der Logarithmusfunktion `log(a)` nicht als positiv ermittelt. Die Fragen der Funktion `asksign` an den Nutzer können daher nie vollständig mit dem Mechanismus der Optionsvariablen `assume_pos` unterdrückt werden.

  Siehe für weitere Beispiele die Optionsvariable `assume_pos_pred`.

  Beispiele:

  Das Vorzeichen der Variablen `x` ist nicht bekannt. Erhält die Optionsvariable `assume_pos` den Wert `true`, wird für die Variable `x` und die indizierte Variable `x[1]` ein positives Vorzeichen ermittelt.

      (%i1) sign(x);
      (%o1)                          pnz
      (%i2) assume_pos:true;
      (%o2)                         true
      (%i3) sign(x);
      (%o3)                          pos
      (%i4) sign(x[1]);
      (%o4)                          pos

  Die Vorzeichen der Variablen `a` und `b` sind nicht bekannt. Maxima ermittelt ein positives Vorzeichen für die Summe der Variablen. Das Vorzeichen der Differenz ist dagegen weiterhin nicht bekannt.

      (%i5) sign(a+b);
      (%o5)                          pos
      (%i6) sign(a-b);
      (%o6)                          pnz

Optionsvariable: assume_pos_pred

  Standardwert: `false`

  Der Optionsvariablen `assume_pos_pred` kann eine Aussagefunktion wie zum Beispiel `symbolp` oder ein Lambda-Ausdruck mit einem Argument `x` zugewiesen werden. Hat die Optionsvariable `assume_pos` den Wert `true`, werden Variablen, indizierte Variablen oder die Werte von Funktionen dann als positiv angenommen, wenn die Aussagefunktion das Ergebnis `true` hat.

  Die Aussagefunktion wird intern von den Funktionen `sign` und `asksign` aufgerufen, wenn die Optionsvariable `assume_pos` den Wert `true` hat und das Vorzeichen einer Variablen, indizierten Variablen oder für den Wert einer Funktion nicht ermittelt werden konnte. Gibt die Aussagefunktion das Ergebnis `true` zurück, wird das Argument als positiv angenommen.

  Hat die Optionsvariable `assume_pos_pred` den Standardwert `false` werden Variablen und indizierte Variablen von Maxima als positiv angenommen, wenn die Optionsvariable `assume_pos` den Wert `true` hat. Das entspricht einer Aussagefunktion, die als `lambda([x], symbolp(x) or subvarp(x))` definiert wird.

  Siehe auch `assume` und `assume_pos`.

  Beispiele:

  Der Optionsvariablen `assume_pos_pred` wird der Name der Aussagefunktion `symbolp` zugewiesen. Indizierte Variablen werden nun nicht mehr als positiv angenommen, wie es für den Standartwert `false` gilt.

      (%i1) assume_pos: true$
      (%i2) assume_pos_pred: symbolp$
      (%i3) sign (a);
      (%o3)                          pos
      (%i4) sign (a[1]);
      (%o4)                          pnz

  Der Optionsvariablen `assume_pos_pred` wird ein Lambda-Ausdruck zugewiesen, der für alle Argumente das Ergebnis `true` hat. Die Funktion `sign` ermittelt nun für Variablen, indizierte Variablen und den Werten von Funktionen ein positives Vorzeichen. Dies trifft jedoch nicht für die Logarithmusfunktion oder eine Differenz zu.

      (%i1) assume_pos: true$
      (%i2) assume_pos_pred: lambda([x], true);
      (%o2)                   lambda([x], true)
      (%i3) sign(a);
      (%o3)                          pos
      (%i4) sign(a[1]);
      (%o4)                          pos
      (%i5) sign(foo(x));
      (%o5)                          pos
      (%i6) sign(foo(x)+foo(y));
      (%o6)                          pos
      (%i7) sign(log(x));
      (%o7)                          pnz
      (%i8) sign(x-y);
      (%o8)                          pnz

Optionsvariable: context

  Standardwert: `initial`

  Die Optionsvariable `context` enthält den Namen des aktuellen Kontextes. Das ist der Kontext, der die Aussagen der Funktion `assume` oder die mit der Funktion `declare` definierten Eigenschaften aufnimmt und aus dem die Aussagen mit der Funktion `forget` oder die Eigenschaften mit der Funktion `remove` gelöscht werden.

  Wird der Optionsvariablen `context` der Name eines existierenden Kontextes zugewiesen, wird dieser zum aktuellen Kontext. Existiert der Kontext noch nicht, wird er durch Aufruf der Funktion `newcontext` erzeugt.

  Siehe auch `contexts` für eine allgemeinere Beschreibung von Kontexten.

  Beispiele:

  Der Standardkontext ist `initial`. Es wird ein neuer Kontext `mycontext` generiert, der die Aussagen und Eigenschaften aufnimmt.

      (%i1) context;
      (%o1)                        initial
      (%i2) context:mycontext;
      (%o2)                       mycontext
      (%i3) contexts;
      (%o3)             [mycontext, initial, global]
      (%i4) assume(a>0);
      (%o4)                        [a > 0]
      (%i5) declare(b,integer);
      (%o5)                         done
      (%i6) facts(mycontext);
      (%o6)               [a > 0, kind(b, integer)]

Systemvariable: contexts

  Standardwert: `[initial, global]`

  Die Systemvariable `contexts` enthält eine Liste der Kontexte, die Maxima bekannt sind. Die Liste enthält auch die nicht aktiven Kontexte.

  Die Kontexte `global` und `initial` sind immer vorhanden. Diese werden von Maxima initialisiert und können nicht entfernt werden. Der Kontext `global` enthält Aussagen und Fakten für Systemvariablen und Systemfunktionen. Mit den Funktionen `newcontext` oder `supcontext` kann der Nutzer weitere Kontexte anlegen.

  Die Kontexte haben eine Hierarchie. Die Wurzel ist immer der Kontext `global`, der damit ein Unterkontext aller anderen Kontexte und immer aktiv ist. Der Kontext `initial` ist anfangs leer und nimmt, sofern kein weiterer Kontext angelegt wurde, die Aussagen und Fakten des Nutzers auf, die mit den Funktionen `assume` und `declare` definiert werden. Mit der Funktion `facts` können die Aussagen und Fakten von Kontexten angezeigt werden.

  Die Verwaltung verschiedener Kontexte ermöglicht es, Aussagen und Fakten in einem Kontext zusammenzustellen. Durch das Aktivieren mit der Funktion `activate` oder Deaktivieren mit der Funktion `deactivate` können diese Aussagen und Fakten für Maxima verfügbar gemacht oder wieder ausgeschaltet werden.

  Die Aussagen und Fakten in einem Kontext bleiben so lange verfügbar, bis sie mit den Funktionen `forget` oder `remove` gelöscht werden. Weiterhin kann der gesamte Kontext mit der Funktion `killcontext` entfernt werden.

  Beispiel:

  Das folgende Beispiel zeigt wie ein Kontext `mycontext` angelegt wird. Der Kontext enthält die Aussage `[a>0]`. Der Kontext kann mit der Funktion `activate` aktiviert werden, um die Aussage verfügbar zu machen.

      (%i1) newcontext(mycontext);
      (%o1)                       mycontext
      (%i2) context;
      (%o2)                       mycontext
      (%i3) assume(a>0);
      (%o3)                        [a > 0]
      (%i4) context:initial;
      (%o4)                        initial
      (%i5) is(a>0);
      (%o5)                        unknown
      (%i6) activate(mycontext);
      (%o6)                         done
      (%i7) is(a>0);
      (%o7)                         true

Funktion: deactivate (context_1, …, context_n)

  Die Kontexte context_1, …, context_n werden deaktiviert. Die Aussagen und Fakten dieser Kontexte stehen für die Auswertung von Aussagen nicht mehr zur Verfügung. Die Kontexte werden nicht gelöscht und können mit der Funktion `activate` wieder aktiviert werden.

  Die deaktivierten Kontexte werden aus der Liste `activecontexts` entfernt.

Funktion: facts (item)
Funktion: facts ()

  Ist item der Name eines Kontextes, gibt `facts(item)` eine Liste der Aussagen und Fakten des Kontextes `item` zurück.

  Ist item nicht der Name eines Kontextes, gibt `facts(item)` eine Liste mit den Aussagen und Fakten zurück, die zu item im aktuellen Kontext bekannt sind. Aussagen und Fakten die zu einem anderen aktiven Kontext gehören einschließlich der Unterkontexte, sind nicht in der Liste enthalten.

  `facts()` gibt eine Liste der Fakten des aktuellen Kontextes zurück.

  Beispiel:

      (%i1) context:mycontext;
      (%o1)                       mycontext
      (%i2) assume(a>0, a+b>0, x<0);
      (%o2)               [a > 0, b + a > 0, x < 0]
      (%i3) facts();
      (%o3)               [a > 0, b + a > 0, 0 > x]
      (%i4) facts(a);
      (%o4)                  [a > 0, b + a > 0]
      (%i5) facts(x);
      (%o5)                        [0 > x]
      (%i6) context:initial;
      (%o6)                        initial
      (%i7) activate(mycontext);
      (%o7)                         done
      (%i8) facts();
      (%o8)                          []
      (%i9) facts(mycontext);
      (%o9)               [a > 0, b + a > 0, 0 > x]

Funktion: forget (pred_1, …, pred_n)
Funktion: forget (L)

  Entfernt Aussagen, die mit `assume` einem Kontext hinzugefügt wurden. Die Aussagen können Ausdrücke sein, die äquivalent aber nicht unbedingt identisch zu vorherigen Fakten sind.

  `forget(L)` entfernt alle Aussagen, die in der Liste L enthalten sind.

Funktion: is (expr)

  Versucht festzustellen, ob die Aussage expr mit Hilfe der Aussagen und Fakten der aktiven Kontexte entschieden werden kann.

  Kann die Aussage expr zu `true` oder `false` entschieden werden, wird das entsprechende Ergebnis zurückgegeben. Andernfalls wird der Rückgabewert durch den Schalter `prederror` bestimmt. Hat `prederror` den Wert `true`, wird eine Fehlermeldung ausgegeben. Ansonsten wird `unknown` zurückgegeben.

  Siehe auch `assume`, `facts` und `maybe`.

  Beispiele:

  `is` wertet Aussagen aus.

      (%i1) %pi > %e;
      (%o1)                       %pi > %e
      (%i2) is (%pi > %e);
      (%o2)                         true

  `is` versucht Aussagen anhand der Aussagen und Fakten der aktiven Kontexte zu entscheiden.

      (%i1) assume (a > b);
      (%o1)                        [a > b]
      (%i2) assume (b > c);
      (%o2)                        [b > c]
      (%i3) is (a < b);
      (%o3)                         false
      (%i4) is (a > c);
      (%o4)                         true
      (%i5) is (equal (a, c));
      (%o5)                         false

  Wenn `is` eine Aussage anhand der Aussagen und Fakten der aktiven Kontexte nicht entscheiden kann, wird der Rückgabewert vom Wert des Schalters `prederror` bestimmt.

      (%i1) assume (a > b);
      (%o1)                        [a > b]
      (%i2) prederror: true$
      (%i3) is (a > 0);
      Maxima was unable to evaluate the predicate:
      a > 0
       -- an error.  Quitting.  To debug this try debugmode(true);
      (%i4) prederror: false$
      (%i5) is (a > 0);
      (%o5)                        unknown

Funktion: killcontext (context_1, …, context_n)

  Das Kommando `killcontext(context)` löscht den Kontext context.

  Ist einer der Kontexte der aktuelle Kontext, wird der erste vorhandene Unterkontext zum aktuellen Kontext. Ist der erste verfügbare Kontext der Kontext `global`, dann wird der Kontext `initial` zum aktuellen Kontext. Wird der Kontext `initial` gelöscht, dann wird eine neuer leerer Kontext `initial` erzeugt.

  `killcontext` löscht einen Kontext nicht, wenn dieser ein Unterkontext des aktuellen Kontextes ist oder wenn der Kontext mit der Funktion `activate` aktiviert wurde.

  `killcontext` wertet die Argumente aus. `killcontext` gibt `done` zurück.

Funktion: maybe (expr)

  Versucht festzustellen, ob die Aussage expr anhand der Aussagen und Fakten der aktive Kontexte entschieden werden kann.

  Kann die Aussage als `true` oder `false` entschieden werden, gibt `maybe` entsprechend `true` oder `false` zurück. Andernfalls gibt `maybe` den Wert `unknown` zurück.

  `maybe` entspricht der Funktion `is` mit `prederror: false`. Dabei wird `maybe` ausgeführt, ohne dass `prederror` einen Wert erhält.

  Siehe auch `assume`, `facts` und `is`.

  Beispiele:

      (%i1) maybe (x > 0);
      (%o1)                        unknown
      (%i2) assume (x > 1);
      (%o2)                        [x > 1]
      (%i3) maybe (x > 0);
      (%o3)                         true

Funktion: newcontext (name)

  `newcontext(name)` erzeugt einen neuen, leeren Kontext mit dem Namen name. Der neue Kontext hat den Kontext `global` als Subkontext und wird zum aktuellen Kontext.

  `newcontext` wertet seine Argumente aus. `newcontext` gibt `name` zurück.

Optionsvariable: prederror

  Standardwert: `false`

  Hat `prederror` den Wert `true`, wird eine Fehlermeldung ausgegeben, wenn eine Aussage mit einer `if`-Anweisung oder der Funktion `is` nicht zu `true` oder `false` ausgewertet werden kann.

  Hat `prederror` den Wert `false`, wird für diese Fälle `unknown` zurückgegeben.

  Siehe auch `is` und `maybe`.

Funktion: sign (expr)

  Versucht das Vorzeichen des Ausdrucks expr auf Grundlage der Fakten der aktuellen Datenbank zu finden. `sign` gibt eine der folgende Antworten zurück: `pos` (positiv), `neg` (negative), `zero` (null), `pz` (positive oder null), `nz` (negative oder null), `pn` (positiv oder negative) oder `pnz` (positiv, negative oder null, für den Fall das Vorzeichen nicht bekannt ist).

Funktion: supcontext (name, context)
FunKtion: supcontext (name)

  Erzeugt einen neuen Kontext, mit dem Namen `name`, der den Kontext `context` als einen Unterkontext enthält. Der Kontext context muss existieren.

  Wird context nicht angegeben, wird der aktuelle Kontext angenommen.

Next: Funktionen und Variablen für Aussagen, Previous: Funktionen und Variablen für Eigenschaften, Up: Maximas Datenbank [Contents][Index]