Maximas Datenbank (Maxima Manual)

11 Maximas Datenbank

Einführung in Maximas Datenbank
Funktionen und Variablen für Eigenschaften
Funktionen und Variablen für Fakten
Funktionen und Variablen für Aussagen

11.1 Einführung in Maximas Datenbank

Eigenschaften

Variablen und Funktionen können mit der Funktion declare Eigenschaften zugewiesen werden. Diese Eigenschaften werden in eine Datenbank abgelegt oder in eine von Lisp bereitgestellte Eigenschaftsliste eingetragen. Mit der Funktion featurep kann geprüft werden, ob ein Symbol eine bestimmte Eigenschaft hat und mit der Funktion properties können alle Eigenschaften eines Symbols angezeigt werden. Die Funktion remove löscht Eigenschaften aus der Datenbank oder von der Eigenschaftsliste. Wird mit der Funktion kill ein Symbol entfernt, werden auch die zugewiesenen Eigenschaften gelöscht.

Weiterhin können mit den Funktionen put und qput beliebige vom Nutzer vorgesehene Eigenschaften in die Eigenschaftsliste zu einem Symbol abgelegt werden. Mit der Funktion get werden die Eigenschaften von der Eigenschaftsliste gelesen und mit der Funktion rem gelöscht.

Variablen können die folgenden Eigenschaften erhalten, die in die Datenbank eingetragen werden.

   constant
   integer        noninteger
   even           odd
   rational       irrational
   real           imaginary      complex

Funktionen können die folgenden Eigenschaften erhalten, die in die Datenbank eingetragen werden.

   increasing     decreasing
   posfun         integervalued

Die folgenden Eigenschaften können für Funktionen definiert werden und wirken sich auf die Vereinfachung dieser Funktionen aus. Diese Eigenschaften werden in Vereinfachung beschrieben.

   linear         additive       multiplicative
   outative       commutative    symmetric      
   antisymmetric  nary           lassociativ
   rassociative   evenfun        oddfun

Weitere Eigenschaften, die Variablen und Funktionen erhalten können, und die in die Lisp-Eigenschaftsliste des Symbols abgelegt werden, sind.

   bindtest       feature        alphabetic
   scalar         nonscalar      nonarray

Kontexte

Maxima verwaltet Kontexte, um Eigenschaften von Variablen und Funktionen sowie Fakten abzulegen. Fakten werden mit der Funktion assume definiert und in dem aktuellen Kontext abgelegt. Mit assume(a>10) erhält Maxima zum Beispiel die Information, dass die Variable a größer als 10 ist. Mit der Funktion forget werden Fakten aus der Datenbank entfernt. Fragt Maxima den Nutzer nach Eigenschaften von Variablen, werden die Antworten in einem Kontext abgelegt.

Ein Kontext hat einen Namen, mit dem auf diesen Bezug genommen werden kann. Nach dem Starten von Maxima hat der aktuelle Kontext den Namen initial. Es kann eine beliebige Anzahl weiterer Kontexte definiert werden. Diese können hierarchisch voneinander abhängen. So ist der Kontext initial ein Unterkontext zum Kontext global. Die Fakten in einem übergeordneten Kontext sind in dem Unterkontext immer präsent. Der Kontext global enthält zum Beispiel Fakten, die von Maxima initialisiert werden, und zusätzlich zu den Fakten des Kontextes initial aktiv sind.

Kontexte können eine beliege Anzahl an Fakten aufnehmen. Sie können mit der Funktion deactivate deaktiviert werden, ohne dass die Fakten verloren gehen und später mit der Funktion activate aktiviert werden, wodurch die Fakten für Aussagefunktionen wieder zur Verfügung stehen.

11.2 Funktionen und Variablen für Eigenschaften

Eigenschaft: alphabetic ¶

Das Kommando declare(string, alphabetic) deklariert die Zeichen der Zeichenkette string als alphabetisch. Das Argument string muss eine Zeichenkette sein. Zeichen, die als alphabetisch deklariert sind, können in Maxima-Bezeichnern verwendet werden. Siehe auch Bezeichner.

Beispiele:

Die Zeichen "~", "@" und ` als alphabetisch erklärt.

(%i1) xx\~yy\`\@ : 1729;
(%o1)                         1729
(%i2) declare ("~`@", alphabetic);
(%o2)                         done
(%i3) xx~yy`@ + @yy`xx + `xx@@yy~;
(%o3)               `xx@@yy~ + @yy`xx + 1729
(%i4) listofvars (%);
(%o4)                  [@yy`xx, `xx@@yy~]

Eigenschaft: bindtest ¶

Hat ein Symbol x die Eigenschaft bindtest und wird es ausgewertet, ohne das dem Symbol bisher ein Wert zugewiesen wurde, signalisiert Maxima einen Fehler. Siehe auch die Funktion declare.

Beispiel:

(%i1) aa + bb;
(%o1)                        bb + aa
(%i2) declare (aa, bindtest);
(%o2)                         done
(%i3) aa + bb;
aa unbound variable
 -- an error.  Quitting.  To debug this try debugmode(true);
(%i4) aa : 1234;
(%o4)                         1234
(%i5) aa + bb;
(%o5)                       bb + 1234

Eigenschaft: constant ¶

Das Kommando declare(a, constant) deklariert ein Symbol a als konstant. Die Funktion constantp hat für dieses Symbol dann das Ergebnis true. Die Deklaration als eine Konstante verhindert nicht, dass dem Symbol ein Wert zugewiesen werden kann. Siehe declare und constantp.

Beispiel:

(%i1) declare(c, constant);
(%o1)                         done
(%i2) constantp(c);
(%o2)                         true
(%i3) c : x;
(%o3)                           x
(%i4) constantp(c);
(%o4)                         false

Funktion: constantp (expr) ¶

Gibt für einen konstanten Ausdruck expr den Wert true zurück, andernfalls false.

Ein Ausdruck wird von Maxima als ein konstanter Ausdruck erkannt, wenn seine Argumente Zahlen sind (einschließlich von Zahlen in einer CRE-Darstellung), symbolische Konstanten wie %pi, %e und %i, Variablen, die einen konstanten Wert haben, Variablen, die mit declare als konstant deklariert sind, oder Funktionen, deren Argumente konstant sind.

Die Funktion constantp wertet das Argument aus.

Siehe auch die Eigenschaft constant.

Beispiele:

(%i1) constantp (7 * sin(2));
(%o1)                                true
(%i2) constantp (rat (17/29));
(%o2)                                true
(%i3) constantp (%pi * sin(%e));
(%o3)                                true
(%i4) constantp (exp (x));
(%o4)                                false
(%i5) declare (x, constant);
(%o5)                                done
(%i6) constantp (exp (x));
(%o6)                                true
(%i7) constantp (foo (x) + bar (%e) + baz (2));
(%o7)                                false
(%i8)

Funktion: declare (a_1, p_1, a_2, p_2, …) ¶

Weist dem Symbol a_i die Eigenschaft p_i zu. Die Argumente a_i und p_i können Listen sein. Ist a_i eine Liste, dann erhält jedes Symbol der Liste die Eigenschaft p_i. Ist umgekehrt p_i eine Liste mit Eigenschaften, dann erhält das Symbol a_i diese Eigenschaften. Entsprechend erhalten alle Symbole einer Liste a_i die Eigenschaften einer Liste p_i.

Die Funktion declare wertet die Argumente nicht aus. declare gibt stets done als Ergebnis zurück.

Hat ein Symbol sym die Eigenschaft prop mit der Funktion declare erhalten, dann hat das Kommando featurep(sym, prop) das Ergebnis true. Mit der Funktion properties können alle Eigenschaften eines Symbols angezeigt werden.

Mit der Funktion declare können Symbole die folgenden Eigenschaften erhalten:

additive: Hat eine Funktion f die Eigenschaft additive, wird ein Ausdruck der Form f(x + y + z + ...) zu f(x) + f(y) + f(z) + ... vereinfacht. Siehe additive.
alphabetic: a_i ist eine Zeichenkette, deren Zeichen als alphabetische Zeichen deklariert werden. Die Zeichen können dann in Maxima-Bezeichnern verwendet werden. Siehe alphabetic für Beispiele.
antisymmetric, commutative, symmetric: a_i wird als eine symmetrische, antisymmetrische oder kommutative Funktion interpretiert. Die Eigenschaften commutative und symmetric sind äquivalent. Siehe antisymmetric, commutative und symmetric.
bindtest: Hat ein Symbol die Eigenschaft bindtest und wird es ausgewertet, ohne das dem Symbol bisher ein Wert zugewiesen wurde, signalisiert Maxima einen Fehler. Siehe bindtest für Beispiele.
constant: Hat ein Symbol die Eigenschaft constant, wird es von Maxima als eine Konstante interpretiert. Siehe auch constant.
even, odd: Erhält eine Variable die Eigenschaft even oder odd, wird sie als gerade oder ungerade interpretiert.
evenfun, oddfun: Erhält eine Funktion oder ein Operator die Eigenschaft evenfun oder oddfun wird die Funktion oder der Operator von Maxima als gerade und ungerade interpretiert. Diese Eigenschaft wird bei der Vereinfachung von Ausdrücken von Maxima angewendet. Siehe evenfun und oddfun.
evflag: Deklariert die Variable a_i als einen Auswertungsschalter. Während der Auswertung eines Ausdrucks mit der Funktion ev, erhält der Auswertungsschalter a_i den Wert true. Siehe evflag für Beispiele.
evfun: Deklariert eine Funktion a_i als eine Auswertungsfunktion. Tritt die Funktion a_i als Argument der Funktion ev auf, so wird die Funktion auf den Ausdruck angewendet. Siehe evfun für Beispiele.
feature: a_i wird als eine Eigenschaft feature interpretiert. Andere Symbole können dann diese vom Nutzer definierte Eigenschaft erhalten. Siehe feature.
increasing, decreasing: Erhält eine Funktion die Eigenschaft decreasing oder increasing, wird die Funktion als eine monoton steigende oder fallende Funktion interpretiert. Siehe decreasing und increasing.
integer, noninteger: a_i wird als eine ganzzahlige oder nicht-ganzzahlige Variable interpretiert. Siehe integer und noninteger.
integervalued: Erhält eine Funktion die Eigenschaft integervalued, nimmt Maxima für Vereinfachungen an, dass die Funktionen einen ganzzahligen Wertebereich hat. Für ein Beispiel siehe integervalued.
lassociative, rassociative: a_i wird als eine rechts- oder links-assoziative Funktion interpretiert. Siehe lassociative und rassociative.
linear: Entspricht der Deklaration einer Funktion als outative und additive. Siehe auch linear.
mainvar: Wird eine Variable als mainvar deklariert, wird sie als eine "Hauptvariable" interpretiert. Eine Hauptvariable wird vor allen Konstanten und Variablen in einer kanonischen Ordnung eines Maxima-Ausdrückes angeordnet. Die Anordnung wird durch die Funktion ordergreatp bestimmt. Siehe auch mainvar.
multiplicative: Hat eine Funktion f die Eigenschaft multiplicative, werden Ausdrücke der Form a_i(x * y * z * ...) zu a_i(x) * a_i(y) * a_i(z) * ... vereinfacht. Die Vereinfachung wird nur für das erste Argument der Funktion f ausgeführt. Siehe multiplicative.
nary: Erhält eine Funktion oder ein Operator die Eigenschaft nary, wird die Funktion oder der Operator bei der Vereinfachung als Nary-Funktion oder Nary-Operator interpretiert. Verschachtelte Ausdrücke wie foo(x, foo(y, z)) werden zum Beispiel zu foo(x, y, z) vereinfacht. Die Deklaration nary unterscheidet sich von der Funktion nary. Während der Funktionsaufruf einen neuen Operator definiert, wirkt sich die Deklaration nur auf die Vereinfachung aus. Siehe auch nary.
nonarray: Hat ein Symbol a_i die Eigenschaft nonarray, wird es nicht als ein Array interpretiert, wenn das Symbol einen Index erhält. Diese Deklaration verhindert die mehrfache Auswertung, wenn a_i als indizierte Variable genutzt wird. Siehe nonarray.
nonscalar: a_i wird als eine nicht-skalare Variable interpretiert. Ein Symbol wird also als ein Vektor oder eine Matrix deklariert. Siehe nonscalar.
noun: a_i wird als Substantivform interpretiert. Abhängig vom Kontext wird a_i durch 'a_i oder nounify(a_i) ersetzt. Siehe auch noun. für ein Beispiel.
outative: Ausdrücke mit der Funktion a_i werden so vereinfacht, dass konstante Faktoren aus dem Argument herausgezogen werden. Hat die Funktion a_i ein Argument, wird ein Faktor dann als konstant angesehen, wenn er ein Symbol oder eine deklarierte Konstante ist. Hat die Funktion a_i zwei oder mehr Argumente, wird ein Faktor dann als konstant angesehen, wenn das zweite Argument ein Symbol und der Faktor unabhängig vom zweiten Argument ist. Siehe auch outative.
posfun: a_i wird als eine Funktion interpretiert, die nur positive Werte hat. Siehe posfun.
rational, irrational: a_i wird als eine rationale oder irrationale Zahl interpretiert. Siehe rational und irrational.
real, imaginary, complex: a_i wird als eine reelle, imaginäre oder komplexe Zahl interpretiert. Siehe real, imaginary und complex.
scalar: a_i wird als skalare Variable interpretiert. Siehe scalar.

Eigenschaft: decreasing ¶

Eigenschaft: increasing ¶

Erhält eine Funktion mit der Funktion declare die Eigenschaft decreasing oder increasing wird die Funktion als eine steigende oder fallende Funktion interpretiert.

Beispiel:

(%i1) assume(a > b);
(%o1)                        [a > b]
(%i2) is(f(a) > f(b));
(%o2)                        unknown
(%i3) declare(f, increasing);
(%o3)                         done
(%i4) is(f(a) > f(b));
(%o4)                         true

Eigenschaften: even ¶

Eigenschaften: odd ¶

Hat eine Variable mit der Funktion declare die Eigenschaft even oder odd erhalten, wird sie von Maxima als gerade oder ungerade ganze Zahl interpretiert. Diese Eigenschaften werden jedoch nicht von den Funktionen evenp, oddp oder integerp erkannt.

Siehe auch die Funktion askinteger.

Beispiele:

(%i1) declare(n, even);
(%o1)                         done
(%i2) askinteger(n, even);
(%o2)                          yes
(%i3) askinteger(n);
(%o3)                          yes
(%i4) evenp(n);
(%o4)                         false

Eigenschaft: feature ¶

feature ist eine Eigenschaft, die ein Symbol sym mit der Funktion declare erhalten kann. In diesem Fall ist das Symbol sym selbst eine Eigenschaft, so dass das Kommando declare(x, sym) einem Symbol x die vom Nutzer definierte Eigenschaft sym gibt.

Maxima unterscheidet Systemeigenschaften und mathematische Eigenschaften, die Symbole und Ausdrücke haben können. Für Systemeigenschaften siehe die Funktion status. Für mathematische Eigenschaften siehe die Funktionen declare und featurep.

Beispiel:

(%i1) declare (FOO, feature);
(%o1)                         done
(%i2) declare (x, FOO);
(%o2)                         done
(%i3) featurep (x, FOO);
(%o3)                         true

Funktion: featurep (a, p) ¶

Stellt fest, ob das Symbol oder der Ausdruck a die Eigenschaft p hat. Maxima nutzt die Fakten der aktiven Kontexte und die definierten Eigenschaften für Symbole und Funktionen.

featurep gibt sowohl für den Fall false zurück, dass das Argument a nicht die Eigenschaft p hat, als auch für den Fall, dass Maxima dies nicht anhand der bekannten Fakten und Eigenschaften entscheiden kann.

featurep wertet die Argumente aus.

Siehe auch declare und featurep..

Beispiele:

(%i1) declare (j, even)$
(%i2) featurep (j, integer);
(%o2)                           true

Systemvariable: features ¶

Maxima kennt spezielle mathematische Eigenschaften von Funktionen und Variablen.

declare(x), foo gibt der Funktion oder Variablen x die Eigenschaft foo.

declare(foo, feature) deklariert die neue Eigenschaft foo. Zum Beispiel deklariert declare([red, green, blue], feature) die drei neuen Eigenschaften red, green und blue.

featurep(x, foo) hat die Rückgabe true, wenn x die Eigenschaft foo hat. Ansonsten wird false zurückgegeben.

Die Informationsliste features enthält eine Liste der Eigenschaften, die Funktionen und Variablen erhalten können und die in die Datenbank eingetragen werden:

   integer         noninteger       even 
   odd             rational         irrational
   real            imaginary        complex
   analytic        increasing       decreasing
   oddfun          evenfun          posfun
   commutative     lassociative     rassociative
   symmetric       antisymmetric

Hinzu kommen die vom Nutzer definierten Eigenschaften.

features ist eine Liste der mathematischen Eigenschaften. Es gibt weitere Eigenschaften. Siehe declare und status.

Funktion: get (a, i) ¶

Gibt die Eigenschaft i des Symbols a zurück. Hat das Symbol a nicht die Eigenschaft i, wird false zurückgegeben.

get wertet die Argumente aus.

Beispiele:

(%i1) put (%e, 'transcendental, 'type);
(%o1)                    transcendental
(%i2) put (%pi, 'transcendental, 'type)$
(%i3) put (%i, 'algebraic, 'type)$
(%i4) typeof (expr) := block ([q],
        if numberp (expr)
        then return ('algebraic),
        if not atom (expr)
        then return (maplist ('typeof, expr)),
        q: get (expr, 'type),
        if q=false
        then errcatch (error(expr,"is not numeric.")) else q)$
(%i5) typeof (2*%e + x*%pi);
x is not numeric.
(%o5)  [[transcendental, []], [algebraic, transcendental]]
(%i6) typeof (2*%e + %pi);
(%o6)     [transcendental, [algebraic, transcendental]]

Eigenschaften: integer ¶

Eigenschaften: noninteger ¶

Hat eine Variable mit der Funktion declare die Eigenschaft integer oder noninteger erhalten, wird sie von Maxima als eine ganze Zahl oder als nicht-ganze Zahl interpretiert. Siehe auch askinteger.

Beispiele:

(%i1) declare(n, integer, x, noninteger);
(%o1)                         done
(%i2) askinteger(n);
(%o2)                          yes
(%i3) askinteger(x);
(%o3)                          no

Eigenschaft: integervalued ¶

Erhält eine Funktion mit declare die Eigenschaft integervalued, nimmt Maxima für Vereinfachungen an, dass der Wertebereich der Funktion ganzzahlig ist.

Beispiel:

(%i1) exp(%i)^f(x);
                              %i f(x)
(%o1)                      (%e  )
(%i2) declare(f, integervalued);
(%o2)                         done
(%i3) exp(%i)^f(x);
                              %i f(x)
(%o3)                       %e

Eigenschaft: nonarray ¶

declare(a, nonarray) gibt dem Symbol a die Eigenschaft nicht ein Array zu sein. Dies verhindert die mehrfache Auswertung, wenn das Symbol a als indizierte Variable genutzt wird.

Beispiel:

(%i1) a:'b$ b:'c$ c:'d$

(%i4) a[x];
(%o4)                          d
                                x
(%i5) declare(a, nonarray);
(%o5)                         done
(%i6) a[x];
(%o6)                          a
                                x

Eigenschaft: nonscalar ¶: Hat ein Symbol die Eigenschaft nonscalar, verhält es sich wie eine Matrix oder Liste bei nicht-kommutativen Rechenoperationen.

Funktion: nonscalarp (expr) ¶: Gibt true zurück, wenn der Ausdruck expr kein Skalar ist. Der Ausdruck enthält dann Matrizen, Listen oder Symbole, die als nonscalar deklariert wurden.

Eigenschaft: posfun ¶: declare(f, posfun) deklariert die Funktion f als eine Funktion, die nur positive Werte annimmt. is(f(x) > 0) gibt dann true zurück.

Funktion: printprops (a, i) ¶

Funktion: printprops ([a_1, …, a_n], i) ¶

Funktion: printprops (all, i) ¶

Zeigt die zum Kennzeichen i zugeordnete Eigenschaft des Atoms a an. i kann einer der Werte gradef, atvalue, atomgrad oder matchdeclare sein. a kann sowohl eine Liste von Atomen, als auch das Atom all sein. In diesem Fall werden alle Atome angezeigt, die eine Eigenschaft zum Kennzeichen i haben.

Beispiel:

(%i1) gradef(f(x), 2*g(x));
(%o1)                         f(x)
(%i2) printprops(f,gradef);
                       d
                       -- (f(x)) = 2 g(x)
                       dx

(%o2)                         done

Funktion: properties (a) ¶

Gibt eine Liste mit den Eigenschaften zurück, die das Symbol a von Maxima oder dem Nutzer erhalten hat. Die Rückgabe kann jede Eigenschaft enthalten, die mit der Funktion declare einem Symbol zugewiesen ist. Diese Eigenschaften sind:

   linear         additive       multiplicative
   outative       commutative    symmetric      
   antisymmetric  nary           lassociativ
   rassociative   evenfun        oddfun
   bindtest       feature        alphabetic
   scalar         nonscalar      nonarray
   constant       integer        noninteger
   even           odd            rational
   irrational     real           imaginary
   complex        increasing     decreasing
   posfun         integervalued

Die folgenden Einträge beschreiben Eigenschaften, die Variablen haben können:

value: Der Variable ist mit dem Operatoren : oder :: ein Wert zugewiesen.
system value: Die Variable ist eine Optionsvariable oder Systemvariable, die von Maxima definiert ist.
numer: Die Variable hat einen numerischen Wert auf der Eigenschaftsliste, der mit der Funktion numerval zugewiesen ist.
assign property: Die Variable hat eine eine Funktion auf der Eigenschaftsliste, die die Zuweisung eines Wertes kontrolliert.

Einträge, die die Eigenschaften von Funktionen beschreiben:

function: Eine mit dem Operator := oder der Funktion define definierte Nutzerfunktion.
macro: Eine mit dem Operator ::= definierte Makrofunktion.
system function: Ein interne Maxima-Funktion.
special evaluation form: Eine Maxima-Spezialform, die die Argumente nicht auswertet.
transfun: Wird eine Nutzerfunktion mit translate übersetzt oder mit der Funktion compile kompiliert, erhält sie die Eigenschaft transfun. Interne Maxima-Funktionen, die mit dem Lisp-Makro defmfun definiert werden, haben ebenfalls diese Eigenschaft.
deftaylor: Für die Funktion ist eine Taylorreihenentwicklung definiert.
gradef: Die Funktion hat eine Ableitung.
integral: Die Funktion hat eine Stammfunktion.
distribute over bags: Ist das Argument der Funktion eine Liste, Matrix oder Gleichung so wird die Funktion auf die Elemente oder beide Seiten der Gleichung angewendet.
limit function: Es existiert eine Funktion für die Behandlung spezieller Grenzwerte.
conjugate function: Es existiert eine Funktion, um die konjugiert komplexe Funktion für spezielle Wertebereiche zu ermitteln.
mirror symmetry: Die Funktion hat die Eigenschaft der Spiegelsymmetrie.
complex characteristic: Es existiert eine Funktion, um den Realteil und den Imaginärteil der Funktion für spezielle Wertebereiche zu ermitteln.
user autoload function: Die Funktion wird automatisch beim ersten Aufruf aus einer Datei geladen. Der Nutzer kann mit dem Funktion setup_autoload eine solche Funktion definieren.

Weitere Eigenschaften, die Symbole erhalten können:

operator: Das Symbol ist ein Maxima-Operator oder ein nutzerdefinierte Operator.
rule: Die Funktion oder der Operator haben eine Regel für die Vereinfachung.
alias
database info: Das Symbol hat Einträge in Maximas Datenbank.
hashed array, declared array, complete array: Ein Hashed-Array, ein deklariertes Array oder ein Array dessen Elemente einen bestimmten Typ haben.
array function: Eine Array-Funktion die mit dem Operator := definiert ist.
atvalue: Dem Symbol ist mit der Funktion atvalue ein Wert an einer Stelle zugewiesen.
atomgrad: Für das Symbol ist mit der Funktion gradef eine Ableitung definiert.
dependency: Für das Symbol ist eine Abhängigkeit mit der Funktion depends definiert.
matchdeclare: Das Symbol ist eine mit matchdeclare definierte Mustervariable, der eine Aussagefunktion zugeordnet ist.
modedeclare: Für das Symbol ist mit der Funktion mode_declare ein Typ definiert.
user properties
context: Das Symbol bezeichnet einen Kontext.
activecontext: Das Symbol bezeichnet einen aktiven Kontextes.

Systemvariable: props ¶

Standardwert: []

props ist eine Liste der Symbole, die vom Nutzer eine Eigenschaft erhalten haben, die in die Lisp-Eigenschaftsliste des Symbols eingetragen wird. Neben den Funktionen put und qput, mit denen der Nutzer direkt eine Eigenschaft zu einem Symbol in die Lisp-Eigenschaftsliste eintragen kann, legen auch Maxima-Funktionen Eigenschaften zu Symbolen in der Eigenschaftsliste ab und tragen diese Symbole in die Systemvariable props ein. Zu diesen Funktionen gehören zum Beispiel declare, numerval, matchdeclare, mode_declare, gradef oder setup_autoload.

Nach dem Start von Maxima sollte die Systemvariable props keine Symbole enthalten. Das ist jedoch nicht der Fall und kann als ein Fehler betrachtet werden, der in Zukunft zu beheben ist.

Funktion: propvars (prop) ¶: Gibt eine Liste mit den Atomen zurück, die in der Informationsliste props eingetragen sind und die die Eigenschaft prop haben. Zum Beispiel gibt propvars(atvalue) eine Liste der Atome zurück, die die Eigenschaft atvalue haben.

Funktion: put (atom, value, indicator) ¶

Weist den Wert value der Eigenschaft indicator des Atoms atom zu. indicator kann eine beliebige Eigenschaft sein und beschränkt sich nicht auf die vom System definierten Eigenschaften. put wertet die Argumente aus. put gibt value zurück.

Beispiele:

(%i1) put (foo, (a+b)^5, expr);
                                   5
(%o1)                       (b + a)
(%i2) put (foo, "Hello", str);
(%o2)                         Hello
(%i3) properties (foo);
(%o3)            [[user properties, str, expr]]
(%i4) get (foo, expr);

                                   5
(%o4)                       (b + a)

(%i5) get (foo, str);
(%o5)                         Hello

Funktion: qput (atom, value, indicator) ¶

Entspricht der Funktion put mit dem Unterschied, dass qput die Argumente nicht auswertet.

Beispiele:

(%i1) foo: aa$ 
(%i2) bar: bb$
(%i3) baz: cc$
(%i4) put (foo, bar, baz);
(%o4)                          bb
(%i5) properties (aa);
(%o5)                [[user properties, cc]]
(%i6) get (aa, cc);
(%o6)                          bb
(%i7) qput (foo, bar, baz);
(%o7)                          bar
(%i8) properties (foo);
(%o8)            [value, [user properties, baz]]
(%i9) get ('foo, 'baz);
(%o9)                          bar

Eigenschaft: rational ¶
Eigenschaft: irrational ¶: Hat eine Variable mit der Funktion declare die Eigenschaft rational oder irrational erhalten, wird sie von Maxima als eine rationale Zahl oder als eine nicht rationale Zahl interpretiert.

Eigenschaft: real ¶
Eigenschaft: imaginary ¶
Eigenschaft: complex ¶: Hat eine Variable mit der Funktion declare die Eigenschaft real, imaginary oder complex erhalten, wird sie von Maxima als eine reelle Zahl, imaginäre Zahl oder als eine komplexe Zahl interpretiert.

Funktion: rem (atom, indicator) ¶: Entfernt die Eigenschaft indicator vom Atom atom.

Funktion: remove (a_1, p_1, …, a_n, p_n) ¶

Funktion: remove ([a_1, …, a_m], [p_1, …, p_n], …) ¶

Funktion: remove ("a", operator) ¶

Funktion: remove (a, transfun) ¶

Funktion: remove (all, p) ¶

Entfernt Eigenschaften von Atomen.

remove(a_1, p_1, ..., a_n, p_n) entfernt die Eigenschaft p_k von dem Atom a_k.

remove([a_1, ..., a_m], [p_1, ..., p_n], ...) entfernt die Eigenschaften p_1, …, p_n von den Atomen a_1, …, a_m. Es können mehrere Paare an Listen angegeben werden.

remove(all, p) entfernt die Eigenschaft p von allen Atomen, die diese Eigenschaft aufweisen.

Die zu entfernenden Eigenschaften können vom System definierte Eigenschaften wie function, macro, mode_declare oder nutzerdefinierte Eigenschaften sein.

remove("a", operator) oder remove("a", op) entfernen vom Atom a die Operatoreigenschaften, die mit den Funktionen prefix, infix, nary, postfix, matchfix oder nofix definiert wurden. Die Namen von Operatoren müssen als eine Zeichenkette angegeben werden.

remove gibt immer done zurück.

Eigenschaft: scalar ¶: Hat ein Symbol die Eigenschaft scalar, verhält es sich wie ein Skalar bei nicht-kommutativen Rechenoperationen.

Funktion: scalarp (expr) ¶: Gibt true zurück, wenn der Ausdruck expr eine Zahl, Konstante, ein als Skalar definiertes Symbol oder ein aus diesen Objekten zusammengesetzter Ausdruck ist. Der Ausdruck darf jedoch keine Liste oder eine Matrix sein.

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.

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:

Funktionen im Ausdruck expr müssen von Maxima differenzierbar und auswertbar sein.
Hat der Ausdruck Pole auf der reellen Achse, können Fehler auftreten.
Enthält der Ausdruck Funktionen, die nicht Lösung einer Differentialgleichung erster Ordnung sind (zum Beispiel Bessel Funktionen), können die Ergebnisse fehlerhaft sein.
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.