[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
11.1 Einführung in Maximas Datenbank | ||
11.2 Funktionen und Variablen für Eigenschaften | ||
11.3 Funktionen und Variablen für Fakten | ||
11.4 Funktionen und Variablen für Aussagen |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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.
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:
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
Weiterhin können mit den Funktion 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.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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:
(%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~]
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 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
declare(a, constant)
deklariert ein Symbol a als konstant.
Siehe declare
und constantp
.
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.
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)
Weist dem Symbol oder den Symbolen einer Liste a_i die Eigenschaft oder
die Eigenschaften der Liste p_i zu. Ist a_i oder p_i
eine Liste, erhält jedes Atom die aufgeführten Eigenschaften. Die Funktion
declare
wertet die Argumente nicht aus. declare
gibt stets
done
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"onnen alle Eigenschaften eines Symbols angzeigt werden.
Die Funktion declare
kennt die folgenden Eigenschaften:
additive
Hat eine Funktion f
die Eigenschaft additive
, wird ein Ausdruck
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. commutative
und symmtric
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 Eigenschaft erhalten. Siehe feature
.
increasing, decreasing
Erhält eine Funktion die Eigenschaft decreasing
oder increasing
,
wird die Funktion als eine steigende oder fallende Funktion interpretiert.
Siehe decreasing
und increasing
.
integer, noninteger
a_i wird als eine ganzzahlige oder nichtganzzahlige 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
Ausdrücke a_i(x * y * z * ...)
werden durch a_i(x) *
a_i(y) * a_i(z) * ...
ersetzt. Die Ersetzung wird nur für das
Argument der Funktion a_i 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
a_i wird nicht als ein Array interpretiert. 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. Überlicherweise
wird damit ein symbolischer 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 positive Funktion interpretiert. 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
.
Erhält eine Funktion mit der Funktion declare
die Eigenschaft
decreasing
oder increasing
wird die Funktion als eine steigende
oder fallende Funktion interpretiert.
Hat eine Variable mit der Funktion declare
die Eigenschaft even
oder odd
erhalten, wird sie von Maxima als gerade oder ungerade
interpretiert.
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 Symobl
x die neu 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
Stellt fest, ob das Symbol oder der Ausdruck a die Eigenschaft f hat. Maxima nutzt dafür die Fakten der Datenbank 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 f 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
Standardwert: []
Maxima erkennt 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 in die Datenbank eingetragen
werden:
integer
, noninteger
, even
, odd
, rational
,
irrational
, real
, imaginary
, complex
,
analytic
, increasing
, decreasing
, oddfun
,
evenfun
, posfun
, commutative
, lassociative
,
rassociative
, symmetric
, und antisymmetric
.
Hinzu kommen die vom Nutzer definierten Eigenschaften.
features
ist eine Liste der mathematischen Eigenschaften. Es gibt
weitere Eigenschaften. Siehe declare
und status
.
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]]
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.
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
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
Hat ein Symbol die Eigenschaft nonscalar
, verhält es sich wie eine
Matrix oder Liste bei nicht-kommutativen Rechenoperationen.
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.
declare(f, posfun)
deklariert die Funktion f
als positive
Funktion. is (f(x) > 0)
gibt dann true
zurück.
Zeigt die zum Kennzeichen i zugeordnete Eigenschaft des Atoms a an.
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. printprops
zeigt die Eigenschaften von Atomen, die auf
andere Weise nicht angezeigt werden können, zum Beispiel für atvalue
,
atomgrad
, gradef
und matchdeclare
.
Gibt eine Liste mit den Eigenschaften zurück, die das Atom a von Maxima oder dem Nutzer erhalten hat.
Standardwert: []
props
ist eine Liste der Symbole, die eine Eigenschaft mit den Funktionen
declare
, atvaule
oder matchdeclare
erhalten haben.
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.
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
Arbeit wie die 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
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.
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.
Entfernt die Eigenschaft indicator vom Atom atom.
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.
Hat ein Symbol die Eigenschaft scalar
, verhält es sich wie ein Skalar
bei nicht-kommutativen Rechenoperationen.
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.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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.
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.
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
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.
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
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]
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
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
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)]
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
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.
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]
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.
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
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.
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
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.
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.
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).
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.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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]
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) <
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 boolschen 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 boolschen Wert
auszuwerten. 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
boolschen 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
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
Gibt den Wert true
zurück, wenn der Ausdruck expr einen Operator
oder eine Funktion enthält, die nicht von Maximas Vereinfacher erkannt wird.
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:
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
.
[ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This document was generated by Robert Dodier on April, 4 2011 using texi2html 1.76.