Nächste: Operatoren, Vorige: Datentypen und Strukturen [Inhalt][Index]
Nächste: Substantive und Verben, Vorige: Ausdrücke, Nach oben: Ausdrücke [Inhalt][Index]
Alles in Maxima, bis auf wenige Ausnahmen, sind Ausdrücke. Dazu gehören
mathematische Ausdrücke wie sqrt(2*a+b) oder Kommandos wie
subst(a^2,b,sin(b+1). Auch Maxima-Programme sind Ausdrücke.
Ausdrücke bestehen aus einem Atom oder einem Operator mit seinen Argumenten.
Ein Atom kann ein Symbol, eine Zeichenkette, eine ganze Zahl oder
eine Gleitkommazahl sein. Jeder Ausdruck, der nicht ein Atom ist, hat die
Darstellung op(a_1, a_2, ..., a_n). op ist der Operator und
a_1, …, a_n sind die Argumente des Operators. Die Argumente
des Operators können Atome oder wiederum Operatoren mit Argumenten sein.
Da Maxima in Lisp programmiert ist, wird ein Ausdruck intern als eine Liste
dargestellt, die die Gestalt ((op) a_1 a_2 ... a_n) hat. Die
arithmetischen Operatoren "+" und "*" haben zum Beispiel die interne
Darstellung:
x+y+10 -> ((mplus) 10 $x $y) 2*x*x -> ((mtimes) 2 $x $y) 2*(x+y) -> ((mtimes) 2 ((mplus) $x $y)
Mathematische Funktionen wie die trigonometrischen Funktionen oder die Logarithmusfunktion werden von Maxima intern analog dargestellt:
sin(x) -> ((%sin) $x) log(y) -> ((%log) $y) 2*sin(x)+log(y) -> ((mplus) ((mtimes) 2 ((%sin) $x)) ((%log) $y))
Mehrere Ausdrücke können zusammengefaßt werden, indem die Ausdrücke durch Kommata getrennt und mit runden Klammern umgeben werden.
(%i1) x: 3$ (%i2) (x: x+1, x: x^2); (%o2) 16 (%i3) (if (x > 17) then 2 else 4); (%o3) 4 (%i4) (if (x > 17) then x: 2 else y: 4, y+x); (%o4) 20
Auch Programmschleifen sind in Maxima Ausdrücke. Der Rückgabewert einer
Programmschleife ist done.
(%i1) y: (x: 1, for i from 1 thru 10 do (x: x*i))$ (%i2) y; (%o2) done
Um einen anderen Rückgabewert als done zu erhalten, kann zum Beispiel
der Wert der Variablen x nach dem Ende der Programmschleife ausgegeben
werden.
(%i3) y: (x: 1, for i from 1 thru 10 do (x: x*i), x)$ (%i4) y; (%o4) 3628800
Es gibt eine Anzahl an reservierten Namen, die nicht als Variablennamen verwendet werden sollten. Ihre Verwendung kann möglicherweise kryptische Fehlermeldungen erzeugen. Dazu gehören zum Beispiel die folgenden Namen:
integrate next from diff in at limit sum for and elseif then else do or if unless product while thru step
Funktionen und Variablen um einen Teilausdruck zu isolieren:
isolate disolate isolate_wrt_times expisolate part inpart substpart substinpart inflag piece partswitch pickapart
Funktionen und Variablen für Substantive und Verben:
nounify verbify alias aliases
Funktionen und Variablen, um zu prüfen, ob ein Teilausdruck enthalten ist und um eine Liste der Variablen eines Ausdrucks zu erstellen:
freeof lfreeof listofvars listconstvars listdummyvars
Funktionen und Variablen für Operatoren und Argumente:
args op operatorp
Funktionen und Variablen für Substitutionen in Ausdrücke:
subst psubst sublis exptsubst opsubst
Funktionen und Variablen für die kanonische Ordnung der Argumente eines Ausdrucks:
ordergreat orderless unorder ordergreatp orderlessp ordermagnitudep
Weitere Funktionen und Variablen:
nterms optimize optimprefix partition
Nächste: Bezeichner, Vorige: Einführung in Ausdrücke, Nach oben: Ausdrücke [Inhalt][Index]
Operatoren und Funktionen können als Substantiv oder Verb vorliegen. Verben
werden von Maxima ausgewertet. Substantive, die in einem Ausdruck auftreten,
werden dagegen nicht ausgewertet, sondern vereinfacht. Die meisten
mathematischen Funktionen sind Substantive. Funktionen wie
limit, diff oder integrate sind standardmäßig
Verben, die jedoch in ein Substantiv umgewandelt werden können. Ein Verb kann
durch den Quote-Operator ' oder mit der Funktion
nounify in ein Substantiv umgewandelt werden. Der Auswertungsschalter
nouns bewirkt, dass Substantive von der Funktion ev ausgewertet
werden.
In der internen Darstellung von Maxima erhalten Lisp-Symbole, die ein Verb
darstellen, ein führendes Dollarzeichen $. Lisp-Symbole, die ein
Substantiv darstellen, erhalten ein führendes Prozentzeichen %. Einige
Substantive wie 'integrate oder 'derivative haben eine spezielle
Darstellung für die Ausgabe. Standardmäßig werden jedoch Substantive
und Verben identisch dargestellt. Hat die Optionsvariable noundisp den
Wert true, werden Substantive mit einem führenden Hochkommata
angezeigt.
Siehe auch noun, nouns, nounify und
verbify.
Beispiele:
(%i1) foo (x) := x^2;
2
(%o1) foo(x) := x
(%i2) foo (42);
(%o2) 1764
(%i3) 'foo (42);
(%o3) foo(42)
(%i4) 'foo (42), nouns;
(%o4) 1764
(%i5) declare (bar, noun);
(%o5) done
(%i6) bar (x) := x/17;
x
(%o6) ''bar(x) := --
17
(%i7) bar (52);
(%o7) bar(52)
(%i8) bar (52), nouns;
52
(%o8) --
17
(%i9) integrate (1/x, x, 1, 42);
(%o9) log(42)
(%i10) 'integrate (1/x, x, 1, 42);
42
/
[ 1
(%o10) I - dx
] x
/
1
(%i11) ev (%, nouns);
(%o11) log(42)
Nächste: Funktionen und Variablen für Ausdrücke, Vorige: Substantive und Verben, Nach oben: Ausdrücke [Inhalt][Index]
Maxima Bezeichner bestehen aus den Buchstaben des Alphabets und den
Zahlzeichen 0 bis 9. Sonderzeichen können in einem Bezeichner mit einem
vorangestellten Backslash \ verwendet werden, zum Beispiel a\&b.
Ein Zahlzeichen kann der erste Buchstabe eines Bezeichners sein, wenn ihm ein
Backslash vorangestellt ist, zum Beispiel \2and3. Zahlzeichen, die an
anderen Stellen auftreten, muss kein Backslash vorangestellt werden, zum
Beispiel is5.
Sonderzeichen können mit der Funktion declare als alphabetisch
erklärt werden. In diesem Fall muss dem Sonderzeichen kein Backslash
vorangestellt werden, wenn es in einem Bezeichner genutzt wird. Die Zeichen
A bis Z, a bis z und 0 bis 9 sowie
die Zeichen % und _ haben bereits die Eigenschaft alphabetisch.
Maxima unterscheidet Groß- und Kleinschreibung. So werden von Maxima
foo, FOO oder Foo unterschieden. Ein Maxima-Bezeichner
ist ein Lisp-Symbol, dem ein Dollarzeichen $ vorangestellt ist.
Lisp-Symbolen, die in Maxima verwendet werden sollen, ist ein Fragezeichen
? vorangestellt. Siehe das Kapitel Lisp und Maxima für eine
ausführlichere Beschreibung.
Beispiele:
(%i1) %an_ordinary_identifier42;
(%o1) %an_ordinary_identifier42
(%i2) embedded\ spaces\ in\ an\ identifier;
(%o2) embedded spaces in an identifier
(%i3) symbolp (%);
(%o3) true
(%i4) [foo+bar, foo\+bar];
(%o4) [foo + bar, foo+bar]
(%i5) [1729, \1729];
(%o5) [1729, 1729]
(%i6) [symbolp (foo\+bar), symbolp (\1729)];
(%o6) [true, true]
(%i7) [is (foo\+bar = foo+bar), is (\1729 = 1729)];
(%o7) [false, false]
(%i8) baz\~quux;
(%o8) baz~quux
(%i9) declare ("~", alphabetic);
(%o9) done
(%i10) baz~quux;
(%o10) baz~quux
(%i11) [is (foo = FOO), is (FOO = Foo), is (Foo = foo)];
(%o11) [false, false, false]
(%i12) :lisp (defvar *my-lisp-variable* '$foo)
*MY-LISP-VARIABLE*
(%i12) ?\*my\-lisp\-variable\*;
(%o12) foo
Vorige: Bezeichner, Nach oben: Ausdrücke [Inhalt][Index]
Die Funktion alias ermöglicht einen alternativen Alias-Namen für eine
Maxima-Funktion, einer Variablen oder einem Array. Der Funktion alias
kann eine beliebige Anzahl von paarweisen Namen und Alias-Namen übergeben
werden.
alias gibt eine Liste mit den Symbolen zurück, denen ein Alias-Name
zugewiesen werden konnte. Wurde einem Symbol bereits derselbe Alias-Name
gegeben, enthält die Liste den Wert false. Wird versucht einem Symbol,
das bereits einen Alias-Namen hat, einen neuen Alias-Namen zu geben, bricht
alias mit einer Fehlermeldung ab.
Symbole, die einen Alias-Namen erhalten haben, werden in die Systemvariable
aliases eingetragen. Siehe die Systemvariable aliases.
Die Funktionen ordergreat und orderless sowie die Deklaration
eines Symbols als ein noun mit der Funktion declare erzeugen
automatisch Alias-Namen, die in die Liste aliases eingetragen werden.
Der Alias-Name kann mit der Funktion kill entfernt werden.
Beispiel:
(%i1) alias(mysqrt,sqrt); (%o1) [sqrt] (%i2) aliases; (%o2) [sqrt] (%i3) mysqrt(4); (%o3) 2 (%i4) kill(mysqrt); (%o4) done (%i5) mysqrt(4); (%o5) mysqrt(4) (%i6) aliases; (%o6) []
Anfangswert: []
Die Systemvariable aliases ist eine Informationsliste der Symbole, die
einen vom Nutzer definierten Alias-Namen mit dem Kommando alias
erhalten haben. Weiterhin werden von den Funktionen ordergreat und
orderless sowie bei der Deklaration eines Symbols als ein
noun mit der Funktion declare Alias-Namen generiert, die in die
Liste aliases eingetragen werden.
Siehe auch die Funktion alias für ein Beispiel.
Das Schlüsselwort allbut wird bei part-Befehlen wie
part, inpart, substpart,
substinpart, dpart und lpart genutzt, um Indizes bei
der Auswahl von Teilausdrücken auszuschließen.
Das Schlüsselwort allbut kann auch zusammen mit dem Kommando
kill verwendet werden. kill(allbut(a_1, a_2, ...))
hat denselben Effekt wie kill(all) mit der Ausnahme, dass die Symbole
a_1, a_2, … von kill ausgenommen werden. Siehe die
Funktion kill.
Beispiele:
(%i1) expr : e + d + c + b + a; (%o1) e + d + c + b + a (%i2) part (expr, [2, 5]); (%o2) d + a (%i3) expr : e + d + c + b + a; (%o3) e + d + c + b + a (%i4) part (expr, allbut (2, 5)); (%o4) e + c + b
Das Schlüsselwort allbut kann zusammen mit dem Kommando kill
verwendet werden.
(%i1) [aa : 11, bb : 22, cc : 33, dd : 44, ee : 55]; (%o1) [11, 22, 33, 44, 55] (%i2) kill (allbut (cc, dd)); (%o0) done (%i1) [aa, bb, cc, dd]; (%o1) [aa, bb, 33, 44]
Die Funktion args gibt eine Liste mit den Argumenten des Hauptoperators
des Ausdrucks expr zurück.
Die Anordnung der Argumente der Ergebnisliste wird von der Optionsvariablen
inflag beeinflußt. Hat inflag den Wert true, ist die
Anordnung entsprechend der internen Darstellung des Ausdrucks expr.
Ansonsten ist die Anordnung wie in der externen Darstellung für die Anzeige.
Siehe die Optionsvariable inflag.
args(expr) ist äquivalent zu
substpart("[", expr, 0). Siehe auch substpart und
op.
Beispiele:
(%i1) args(gamma_incomplete(a,x)); (%o1) [a, x] (%i2) args(x+y+z); (%o2) [z, y, x] (%i3) args(x+y+z),inflag:true; (%o3) [x, y, z] (%i4) args(x+2*a); (%o4) [x, 2 a]
Gibt den Wert true zurück, wenn das Argument expr ein Atom ist.
Atome sind ganze Zahlen, Gleitkommazahlen, Zeichenketten und Symbole. Siehe
auch die Funktionen symbolp und listp.
Beispiele:
(%i1) atom(5);
(%o1) true
(%i2) atom(5.0);
(%o2) true
(%i3) atom(5.0b0);
(%o3) true
(%i4) atom(1/2);
(%o4) false
(%i5) atom('a);
(%o5) true
(%i6) atom(2*x);
(%o6) false
(%i7) atom("string");
(%o7) true
Die Funktion box(expr) umschließt den Ausdruck expr in
der Ausgabe mit einem Rahmen, wenn display2d den Wert true hat.
Ansonsten ist der Rückgabewert ein Ausdruck mit box als Operator und
expr als Argument.
box(expr, a) umschließt expr mit einem Rahmen, der
mit einer Marke a bezeichnet ist. Ist die Marke länger als der Rahmen,
werden Zeichen abgeschnitten.
Die Funktion box wertet ihre Argumente aus. Die eingerahmten Ausdrücke
werden dagegen nicht mehr ausgewertet.
Die Optionsvariable boxchar enthält das Zeichen, das von den Funktionen
box sowie dpart und lpart verwendet wird, um den Rahmen
auszugeben.
Beispiele:
(%i1) box (a^2 + b^2);
"""""""""
" 2 2"
(%o1) "b + a "
"""""""""
(%i2) a : 1234;
(%o2) 1234
(%i3) b : c - d;
(%o3) c - d
(%i4) box (a^2 + b^2);
""""""""""""""""""""
" 2 "
(%o4) "(c - d) + 1522756"
""""""""""""""""""""
(%i5) box (a^2 + b^2, term_1);
term_1""""""""""""""
" 2 "
(%o5) "(c - d) + 1522756"
""""""""""""""""""""
(%i6) 1729 - box (1729);
""""""
(%o6) 1729 - "1729"
""""""
Standardwert: "
Die Optionsvariable boxchar enthält das Zeichen, welches von den
Funktionen box sowie dpart und lpart genutzt wird, um
einen Rahmen auszugeben.
Die Rahmen werden immer mit dem aktuellen Wert von boxchar ausgegeben.
Das Zeichen boxchar wird nicht zusammen mit dem eingerahmten Ausdruck
gespeichert.
Komprimiert einen Ausdruck expr, indem gemeinsame Teilausdrücke
denselben Speicher nutzen. collapse wird von der Funktion
optimize aufgerufen. collapse kann auch mit einer Liste
aufgerufen werden, die mehrere Argumente enthält.
Siehe auch die Funktion optimize.
dispform formatiert den Ausdruck expr von der internen Darstellung
in eine externe Darstellung, wie sie für die Anzeige des Ausdrucks benötigt
wird. Bei der Formatierung sind Optionsvariablen wie dispflag und
powerdisp wirksam.
Beispiele für die interne und externe Darstellung von Ausdrücken sind:
Interne Darstellung Externe Darstellung ------------------------------------------------------------ -x : ((MTIMES) -1 $x) ((MMINUS) $x) sqrt(x) : ((MEXPT) $x ((RAT) 1 2)) ((%SQRT) $X) a/b : ((MTIMES) $A ((MEXPT) $B -1)) ((MQUOTIENT) $A $B)
dispform(expr) gibt die externe Darstellung nur für den ersten
Operator im Ausdruck zurück. dispform(expr, all) gibt die
externe Darstellung aller Operatoren im Ausdruck expr zurück.
Siehe auch part, inpart und inflag.
Beispiel:
Die Funktion dispform kann genutzt werden, um die Wurzelfunktion in
einem Ausdruck zu substituieren. Die Wurzelfunktion ist nur in der externen
Darstellung eines Ausdruckes vorhanden:
(%i1) expr: sqrt(5)/(5+sqrt(2));
sqrt(5)
(%o1) -----------
sqrt(2) + 5
(%i2) subst(f,sqrt,expr);
sqrt(5)
(%o2) -----------
sqrt(2) + 5
(%i3) subst(f,sqrt,dispform(expr));
f(5)
(%o3) -----------
sqrt(2) + 5
(%i4) subst(f,sqrt,dispform(expr,all));
f(5)
(%o4) --------
f(2) + 5
Die Funktion disolate arbeitet ähnlich wie die Funktion isolate.
Teilausdrücke im Ausdruck expr, die die Variablen x_1, …,
x_n nicht enthalten, werden durch Zwischenmarken %t1, %t2,
… ersetzt. Im Unterschied zu der Funktion isolate kann die
Funktion disolate Teilausdrücke zu mehr als einer Variablen aus einem
Ausdruck isolieren.
Die Ersetzung von Teilausdrücken durch Zwischenmarken kann mit der
Optionsvariable isolate_wrt_times kontrolliert werden. Hat die
Optionsvariable isolate_wrt_times den Wert true, werden
Ersetzungen in Produkten ausgeführt. Der Standardwert ist false.
Siehe isolate_wrt_times für Beispiele.
Die Optionsvariable exptisolate hat im Unterschied zur Funktion
isolate keinen Einfluss auf die Ersetzung von Teilausdrücken durch
Zwischenmarken.
disolate wird automatisch aus der Datei
share/simplification/disol.mac geladen. Das Kommando
demo(disol)$ zeigt Beispiele.
Siehe auch die Funktion isolate.
Beispiel:
(%i1) expr:a*(e*(g+f)+b*(d+c)); (%o1) a (e (g + f) + b (d + c)) (%i2) disolate(expr,a,b,e); (%t2) d + c (%t3) g + f (%o3) a (%t3 e + %t2 b)
Wählt wie die Funktion part einen Teilausdruck aus, gibt aber den
vollständigen Ausdruck zurück, wobei der ausgewählte Teilausdruck
eingerahmt ist. Der Rahmen ist Teil des zurückgegebenen Ausdrucks.
Siehe auch part, inpart und lpart sowie box.
Beispiel:
(%i1) dpart (x+y/z^2, 1, 2, 1);
y
(%o1) ---- + x
2
"""
"z"
"""
Standardwert: false
Hat exptisolate den Wert true, dann sucht die Funktion
isolate auch in den Exponenten von Zahlen oder Symbolen nach
Teilausdrücken zu einer Variablen.
Siehe die Funktion isolate für Beispiele.
Standardwert: false
Die Optionsvariable exptsubst kontrolliert die Substitution von
Ausdrücken mit der Exponentialfunktion durch die Funktionen subst und
psubst.
Beispiele:
(%i1) subst(y,%e^x,%e^(a*x)),exptsubst:false;
a x
(%o1) %e
(%i2) subst(y,%e^x,%e^(a*x)),exptsubst:true;
a
(%o2) y
freeof(x, expr) gibt das Ergebnis true zurück, wenn
das Argument x nicht im Ausdruck expr enthalten ist. Ansonsten ist
der Rückgabewert false.
freeof(x_1, ..., x_n, expr) gibt das Ergebnis
true zurück, wenn keines der Argumente x_1, x_2, …
im Ausdruck expr enthalten ist.
Die Argumente x_1, …, x_n können die Namen von Funktionen
und Variablen sein, indizierte Namen, die Namen von Operatoren oder allgemeine
Ausdrücke. Die Funktion freeof wertet die Argumente aus.
Bei der Prüfung, ob ein Teilausdruck x im Ausdruck expr enthalten
ist, untersucht die Funktion freeof den Ausdruck expr in der
vorliegenden Form (nach Auswertung und Vereinfachung) und versucht nicht
herauszufinden, ob der Teilausdruck in einem äquivalenten Ausdruck enthälten
wäre.
freeof ignoriert Dummy-Variablen. Dummy-Variablen sind Variablen, die
außerhalb eines Ausdrucks nicht in Erscheinung treten. Folgende
Dummy-Variablen werden von freeof ignoriert: der Index einer Summe oder
eines Produktes, die unabhängige Variable in einem Grenzwert, die
Integrationsvariable eines bestimmten Integrals oder einer
Laplacetransformation, formale Variablen in at- oder
lambda-Ausdrücke, lokale Variablen eines Blocks oder einer
do-Schleife.
Das unbestimmte Integral ist nicht frei von der Integrationsvariablen.
Beispiele:
Argumente sind Namen von Funktionen, Variablen, indizierten Variablen,
Operatoren und Ausdrücke. freeof(a, b, expr) ist äquivalent zu
freeof(a, expr) and freeof(b, expr).
(%i1) expr: z^3 * cos (a[1]) * b^(c+d);
d + c 3
(%o1) cos(a ) b z
1
(%i2) freeof(z, expr);
(%o2) false
(%i3) freeof(cos, expr);
(%o3) false
(%i4) freeof(a[1], expr);
(%o4) false
(%i5) freeof(cos (a[1]), expr);
(%o5) false
(%i6) freeof(b^(c+d), expr);
(%o6) false
(%i7) freeof("^", expr);
(%o7) false
(%i8) freeof(w, sin, a[2], sin (a[2]), b*(c+d), expr);
(%o8) true
Die Funktion freeof wertet die Argumente aus.
(%i1) expr: (a+b)^5$ (%i2) c: a$ (%i3) freeof(c, expr); (%o3) false
freeof betrachtet keine äquivalenten Ausdrücke. Vereinfachungen
können einen äquivalenten Ausdruck liefern, der jedoch den Teilausdruck
nicht mehr enthält.
(%i1) expr: (a+b)^5$
(%i2) expand(expr);
5 4 2 3 3 2 4 5
(%o2) b + 5 a b + 10 a b + 10 a b + 5 a b + a
(%i3) freeof(a+b, %);
(%o3) true
(%i4) freeof(a+b, expr);
(%o4) false
Die Exponentialfunktion exp(x) wird von Maxima sofort zu %e^x
vereinfacht. Der Name exp der Exponentialfunktion ist daher nicht in
einem Ausdruck enthalten.
(%i5) exp(x);
x
(%o5) %e
(%i6) freeof(exp, exp (x));
(%o6) true
Eine Summe ist frei von dem Index und ein bestimmtes Integral ist frei von der Integrationsvariablen. Ein unbestimmtes Integral ist nicht frei von der Integrationsvariablen.
(%i1) freeof(i, 'sum (f(i), i, 0, n)); (%o1) true (%i2) freeof(x, 'integrate (x^2, x, 0, 1)); (%o2) true (%i3) freeof(x, 'integrate (x^2, x)); (%o3) false
Standardwert: false
Hat die Optionsvariable inflag den Wert true, wird von Funktionen,
die Teile eines Ausdrucks expr extrahieren, die interne Form des
Ausdrucks expr betrachtet.
Die Anordnung der Argumente der internen Darstellung unterscheidet sich zum
Beispiel für die Addition von der externen Darstellung für die Anzeige.
Daher hat first(x+y) das Ergebnis x, wenn inflag den Wert
true hat, und y, wenn inflag den Wert false hat.
Der Ausdruck first(y+x) gibt in beiden Fällen dasselbe Ergebnis.
Hat inflag den Wert true, entsprechen die Funktionen part
und substpart den Funktionen inpart und substinpart.
Folgende Funktionen werden von der Optionsvariablen inflag beeinflusst:
part, substpart, first, rest,
last, length, die Konstruktion for …
in, map, fullmap, maplist,
reveal, pickapart, args und op.
Die Funktion inpart ist ähnlich wie part, arbeitet aber mit der
internen Darstellung eines Ausdruckes und nicht mit der externen Darstellung
für die Anzeige. Da keine Formatierung vorgenommen wird, ist die Funktion
inpart schneller als part.
Immer dann, wenn sich die interne und die externe Darstellung eines Ausdrucks
voneinander unterscheiden, haben die Funktionen inpart und part
verschiedene Ergebnisse. Dies trifft zu für die Anordnung der Argumente einer
Addition, der Subtraktion und Division sowie zum Beispiel für die
Wurzelfunktion.
Ist das letzte Argument einer part-Funktion eine Liste mit Indizes,
werden mehrere Teilausdrücke heraus gepickt. So hat
inpart(x + y + z, [1, 3]) das Ergebnis z+x.
Siehe auch part, dpart und lpart.
Beispiele:
(%i1) x + y + w*z;
(%o1) w z + y + x
(%i2) inpart (%, 3, 2);
(%o2) z
(%i3) part (%th (2), 1, 2);
(%o3) z
(%i4) 'limit (f(x)^g(x+1), x, 0, minus);
g(x + 1)
(%o4) limit f(x)
x -> 0-
(%i5) inpart (%, 1, 2);
(%o5) g(x + 1)
Teilausdrücke im Ausdruck expr, die die Variable x nicht
enthalten, werden durch Zwischenmarken %t1, %t2, … ersetzt.
Dies kann genutzt werden, um die weitere Auswertung und Vereinfachung dieser
Teilausdrücke zu verhindern. Die Ersetzung der Teilausdrücke kann durch
eine Auswertung des Ausdrucks rückgängig gemacht werden.
Die Ersetzung von Teilausdrücken kann mit den Optionsvariablen
exptisolate und isolate_wrt_times kontrolliert werden. Hat die
Optionsvariable exptisolate den Wert true, werden Ersetzungen auch
für die Exponentiation ausgeführt. Die Basis muss dabei eine Zahl oder ein
Symbol wie %e sein. Hat die Optionsvariable isolate_wrt_times den
Wert true, werden Ersetzungen in Produkten ausgeführt. Siehe
isolate_wrt_times für Beispiele.
Die Ersetzung von Teilausdrücken für mehrere Variable kann mit der Funktion
disolate ausgeführt werden. Siehe disolate.
Beispiele:
(%i1) (b+a)^4*(x*((d+c)^2+2*x)+1);
4 2
(%o1) (b + a) (x (2 x + (d + c) ) + 1)
(%i2) isolate(%,x);
2
(%t2) (d + c)
4
(%t3) (b + a)
(%o3) %t3 (x (2 x + %t2) + 1)
(%i4) ratexpand(%);
2
(%o4) 2 %t3 x + %t2 %t3 x + %t3
(%i5) ev(%);
4 2 4 2 4
(%o5) 2 (b + a) x + (b + a) (d + c) x + (b + a)
(%i6) (b+a)*(b+a+x)^2*%e^(b+a*x+x^2);
2
2 x + a x + b
(%o6) (b + a) (x + b + a) %e
(%i7) ev(isolate(%,x),exptisolate:true);
(%t7) b + a
b
(%t8) %e
2
2 x + a x
(%o8) %t7 %t8 (x + %t7) %e
Standardwert: false
Hat die Optionsvariable isolate_wrt_times den Wert true, führen
die Funktionen isolate und disolate auch Ersetzungen in Produkten
aus.
Siehe auch die Funktionen isolate und disolate.
Beispiele:
(%i1) isolate_wrt_times: true$
(%i2) isolate (expand ((a+b+c)^2), c);
(%t2) 2 a
(%t3) 2 b
2 2
(%t4) b + 2 a b + a
2
(%o4) c + %t3 c + %t2 c + %t4
(%i4) isolate_wrt_times: false$
(%i5) isolate (expand ((a+b+c)^2), c);
2
(%o5) c + 2 b c + 2 a c + %t4
Standardwert: false
Hat die Optionsvariable listconstvars den Wert true, werden
Konstante wie %e, %pi und Variablen, die als konstant
deklariert sind, von der Funktion listofvars in die Ergebnisliste
aufgenommen. Der Standardwert von listconstvars ist false und
Konstante werden ignoriert.
Standardwert: true
Hat listdummyvars den Wert false, werden die Dummy-Variablen eines
Ausdrucks von der Funktion listofvars ignoriert. Dummy-Variablen sind
zum Beispiel der Index einer Summe, die Grenzwertvariable oder die
Integrationsvariable eines bestimmten Integrals.
Beispiele:
(%i1) listdummyvars: true$
(%i2) listofvars ('sum(f(i), i, 0, n));
(%o2) [i, n]
(%i3) listdummyvars: false$
(%i4) listofvars ('sum(f(i), i, 0, n));
(%o4) [n]
Die Funktion listofvars gibt eine Liste der Variablen zurück, die im
Ausdruck expr enthalten sind.
Hat die Optionsvariable listconstvars den Wert true, werden auch
Konstante wie %e, %pi und %i sowie als konstant
deklarierte Variable in die Liste aufgenommen. Der Standardwert von
listconstvars ist false.
Siehe entsprechend die Optionsvariable listdummyvars für
Dummy-Variablen.
Beispiel:
(%i1) listofvars (f (x[1]+y) / g^(2+a));
(%o1) [g, a, x , y]
1
Für jedes Element m der Liste list wird die Funktion
freeof aufgerufen. lfreeof hat den Rückgabewert true,
wenn keines der Elemente der Liste list im Ausdruck expr enthalten
ist. Ansonsten ist der Rückgabewert false.
Siehe auch die Funktion freeof.
Die Funktion lpart ist ähnlich zu dpart, verwendet aber einen
Rahmen, der mit einer Marke gekennzeichnet ist.
Die Deklaration einer Variablen als eine Hauptvariable mit der Funktion
declare ändert deren Anordnung in einem Ausdruck der kanonisch geordnet
ist. Hauptvariable sind bezüglich der Funktionen ordergreatp und
orderlessp stets größer als alle anderen Symbole, Konstanten und
Zahlen.
Beispiel:
(%i1) sort([9, 1, %pi, g, t, a]); (%o1) [1, 9, %pi, a, g, t] (%i2) declare(a, mainvar)$ (%i3) sort([9, 1, %pi, g, t, a]); (%o3) [1, 9, %pi, g, t, a]
noun ist eine der Optionen des Kommandos declare. Wird eine
Funktion als noun deklariert, wird diese als Substantivform behandelt
und nicht ausgewertet.
Ein Symbol f, dass als noun deklariert wird, wird in die
Informationsliste aliases eingetragen und die Rückgabe der Funktion
properties enthält den Eintrag noun.
Beispiel:
(%i1) factor (12345678);
2
(%o1) 2 3 47 14593
(%i2) declare (factor, noun);
(%o2) done
(%i3) factor (12345678);
(%o3) factor(12345678)
(%i4) ''%, nouns;
2
(%o4) 2 3 47 14593
Standardwert: false
Hat noundisp den Wert true, werden Substantivformen mit einem
vorangestelltem Hochkomma angezeigt. Diese Optionsvariable hat immer den Wert
true, wenn die Definition von Funktionen angezeigt wird.
Die Funktion nounify gibt den Namen einer Funktion f in einer
Substantivform zurück. Der Name f ist ein Symbol oder eine
Zeichenkette.
Einige Funktionen geben eine Substantivform zurück, wenn die Funktion nicht
ausgewertet werden kann. Wird einem Funktionsaufruf wie zum Beispiel
'f(x) oder '(f(x)) ein Hochkomma vorangestellt, wird ebenfalls
eine Substantivform zurückgegeben.
Siehe auch die Funktion verbify.
Die Funktion nterms gibt die Anzahl der Terme des Ausdrucks expr
zurück, wobei der Ausdruck als vollständig expandiert angenommen wird, ohne
dass Terme gekürzt oder zusammengefasst werden.
Ausdrücke wie sin(expr), sqrt(expr) oder
exp(expr) werden dabei als ein Term gezählt.
Die Funktion op gibt den Hauptoperator des Ausdrucks expr zurück.
op(expr) ist äquivalent zu part(expr, 0).
Ist der Hauptoperator des Ausdrucks expr ein Operator wie "+", "*" oder "/" wird der Name des Operators als Zeichenkette zurückgegeben. Andernfalls wird ein Symbol zurückgegeben.
op beachtet den Wert der Optionsvariablen inflag. op
wertet die Argumente aus. Siehe auch args.
Beispiele:
(%i1) stringdisp: true$
(%i2) op (a * b * c);
(%o2) "*"
(%i3) op (a * b + c);
(%o3) "+"
(%i4) op ('sin (a + b));
(%o4) sin
(%i5) op (a!);
(%o5) "!"
(%i6) op (-a);
(%o6) "-"
(%i7) op ([a, b, c]);
(%o7) "["
(%i8) op ('(if a > b then c else d));
(%o8) "if"
(%i9) op ('foo (a));
(%o9) foo
(%i10) prefix (foo);
(%o10) "foo"
(%i11) op (foo a);
(%o11) "foo"
(%i12) op (F [x, y] (a, b, c));
(%o12) F
x, y
(%i13) op (G [u, v, w]);
(%o13) G
Das Kommando operatorp(expr, op) gibt true zurück,
wenn op der Hauptoperator des Ausdrucks expr ist.
operatorp(expr, [op_1, ..., op_n]) gibt true
zurück, wenn einer der Operatoren op_1, …, op_n der
Hauptoperator des Ausdrucks expr ist.
Hat die Optionsvariable opsubst den Wert false, führt die
Funktion subst keine Substitution in einen Operator eines Ausdrucks aus.
Zum Beispiel hat (opsubst: false, subst(x^2, r, r+r[0])) das Ergebnis
x^2+r[0].
Die Funktion optimize gibt einen Ausdruck zurück, der dasselbe Ergebnis
und dieselben Seiteneffekte wie expr hat, der jedoch effizienter
ausgewertet werden kann. Im neuen Ausdruck wird die mehrfache Berechnung
gleicher Teilausdrücke vermieden und gleiche Teilausdrücke werden
zusammengefasst.
Siehe auch die Funktion collapse.
example(optimize) zeigt ein Beispiel.
Standardwert: %
Die Optionsvariable optimprefix enthält den Präfix, der von der
Funktion optimize benutzt wird, um einen Teilausdruck zu benennen.
Die Funktion ordergreat ändert die kanonische Anordnung der Symbole so,
dass v_1 > v_2 > … > v_n. Weiterhin ist v_n
kleiner als jedes andere Symbol, das nicht in der Liste enthalten ist.
orderless ändert die kanonische Anordnung der Symbole so, dass
v_1 < v_2 < … < v_n. Weiterhin ist v_n
größer als jedes andere Symbol, das nicht in der Liste enthalten ist.
Die durch ordergreat und orderless definierte Ordnung wird durch
unorder wieder aufgehoben. ordergreat und orderless
können jeweils nur einmal aufgerufen werden, solange nicht mit unorder
zuvor die definierte Ordnung aufgehoben wird.
Siehe auch ordergreatp, orderlessp und mainvar.
Die Funktion ordergreatp gibt true zurück, wenn in der
kanonischen Ordnung von Maxima expr_1 größer als expr_2 ist.
Ansonsten ist das Ergebnis false.
Die Funktion orderlessp gibt true zurück, wenn in der
kanonischen Ordnung von Maxima expr_1 kleiner als expr_2 ist.
Ansonsten ist das Ergebnis false.
Alle Maxima-Atome und Ausdrücke sind vergleichbar unter ordergreatp und
orderlessp. Die kanonische Ordnung von Atomen ist folgendermaßen:
Numerische Konstanten <
deklarierte Konstanten <
deklarierte Skalare <
erstes Argument von orderless <
weitere Argumente von orderless <
letztes Argument von orderless <
Variablen beginnend mit a, ... <
Variablen beginnend mit Z <
letzte Argument von ordergreat <
weitere Argumente von ordergreat <
erste Argument von ordergreat <
deklarierte Hauptvariablen.
Die Ordnung für Ausdrücke, die keine Atome sind, wird von der für Atome
abgeleitet. Für die Operatoren "+", "*" und "^" kann die
Ordnung nicht einfach beschrieben werden. Andere Operatoren, Funktionen und
Ausdrücke werden angeordnet nach den Argumenten, dann nach den Namen.
Bei Ausdrücken mit Indizes wird der Name des Symbols als Operator und der
Index als Argument betrachtet.
Die kanonische Ordnung der Ausdrücke wird modifiziert durch die Funktionen
ordergreat und orderless sowie der Deklarationen
mainvar, constant und scalar.
Siehe auch sort.
Beispiele:
Ordne Symbole und Konstanten. %pi wird nicht nach dem numerischen Wert
sortiert, sondern wie eine Konstante.
(%i1) stringdisp : true; (%o1) true (%i2) sort ([%pi, 3b0, 3.0, x, X, "foo", 3, a, "bar", 4.0, 4b0]); (%o2) [3, 3.0, 4.0, 3.0b0, 4.0b0, %pi, "bar", "foo", a, x, X]
Anwendung der Funktionen ordergreat und orderless.
(%i1) sort ([M, H, K, T, E, W, G, A, P, J, S]); (%o1) [A, E, G, H, J, K, M, P, S, T, W] (%i2) ordergreat (S, J); (%o2) done (%i3) orderless (M, H); (%o3) done (%i4) sort ([M, H, K, T, E, W, G, A, P, J, S]); (%o4) [M, H, A, E, G, K, P, T, W, J, S]
Anwendung der Deklarationen mainvar, constant und scalar.
(%i1) sort ([aa, foo, bar, bb, baz, quux, cc, dd, A1, B1, C1]); (%o1) [aa, bar, baz, bb, cc, dd, foo, quux, A1, B1, C1] (%i2) declare (aa, mainvar); (%o2) done (%i3) declare ([baz, quux], constant); (%o3) done (%i4) declare ([A1, B1], scalar); (%o4) done (%i5) sort ([aa, foo, bar, bb, baz, quux, cc, dd, A1, B1, C1]); (%o5) [baz, quux, A1, B1, bar, bb, cc, dd, foo, C1, aa]
Ordne nicht atomare Ausdrücke.
(%i1) sort ([f(1), f(2), f(2, 1), g(1), g(1, 2), g(n), f(n, 1)]);
(%o1) [f(1), g(1), g(1, 2), f(2), f(2, 1), g(n), f(n, 1)]
(%i2) sort ([foo(1), X[1], X[k], foo(k), 1, k]);
(%o2) [1, foo(1), X , k, foo(k), X ]
1 k
Ist eine Aussagefunktion, die das Ergebnis true hat, wenn die Argumente
expr_1 und expr_2 Zahlen, Konstante oder konstante Ausdrücke
repräsentieren und expr_1 kleiner als expr_2 ist. Sind die
Argumente nicht der Größe nach vergleichbar, wird die Ordnung durch die
Aussagefunktion orderlessp bestimmt.
Wird die Aussagefunktion ordermagnitudep als Argument der Funktion
sort verwendet, werden die Elemente einer Liste nach der Größe
sortiert.
Beispiele:
(%i1) ordermagnitudep(1, 2); (%o1) true (%i2) ordermagnitudep(%e, %pi); (%o2) true (%i3) sort([%e, %pi, sin(1), 0, 1, 2, 3, 4]); (%o3) [0, 1, 2, 3, 4, %e, %pi, sin(1)] (%i4) sort([%e, %pi, sin(1), 0, 1, 2, 3, 4], ordermagnitudep); (%o4) [0, sin(1), 1, 2, %e, 3, %pi, 4]
Die Funktion part gibt einen Teilausdruck des Ausdrucks expr
zurück. Der Ausdruck expr wird zuvor in das Format für die Anzeige
umgewandelt.
Der Teilausdruck wird durch die Indizes n_1, …, n_k ausgewählt. Zuerst wird der Teilausdruck n_1 ermittelt, von diesem der Teilausdruck n_2, u.s.w. Der zum Index n_k zuletzt gewonnene Teilausdruck ist dann das Ergebnis.
part kann auch verwendet werden, um ein Element einer Liste oder die
Zeile einer Matrix zu erhalten.
Das letzte Argument einer part-Funktion kann eine Liste mit Indizes sein.
In diesem Fall werden alle angegebenen Teilausdrücke als Ergebnis
zurückgegeben. Zum Beispiel hat das Kommando part(x + y + z, [1, 3])
das Ergebnis z+x.
Die Systemvariable piece enthält den letzten Ausdruck, der bei der
Verwendung einer part-Funktion ausgewählt wurde.
Hat die Optionsvariable partswitch den Wert true, wird end
zurückgegeben, wenn versucht wurde, einen Teilausdruck zu bilden, der nicht
existiert, andernfalls wird eine Fehlermeldung ausgegeben.
Siehe auch inpart, substpart, substinpart,
dpart und lpart.
Beispiele:
(%i1) part(z+2*y+a,2); (%o1) 2 y (%i2) part(z+2*y+a,[1,3]); (%o2) z + a (%i3) part(z+2*y+a,2,1); (%o3) 2
example(part) zeigt weitere Beispiele.
Die Funktion partition gibt eine Liste mit zwei Ausdrücken zurück.
Ist das Argument expr ein Produkt enthält das erste Element die
Faktoren, die die Variable var enthalten, und das zweite Element
enthält die übrigen Faktoren. Entsprechend enthält das erste Element die
Terme einer Summe oder die Elemente einer Liste, die die Variable var
enthalten, und das zweite Elemente die verbleibende Terme der Summe oder
Elemente der Liste.
(%i1) partition (2*a*x*f(x), x); (%o1) [2 a, x f(x)] (%i2) partition (a+b, x); (%o2) [b + a, 0] (%i3) partition ([a, b, f(a), c], a); (%o3) [[b, c], [a, f(a)]]
Standardwert: false
Hat die Optionsvariable partswitch den Wert true, wird end
zurückgegeben, wenn versucht wird, einen Teilausdruck zu bilden, der nicht
existiert, andernfalls wird eine Fehlermeldung ausgegeben.
Den Teilausdrücken in einer Tiefe n eines verschachtelten Ausdrucks
werden Zwischenmarken zugewiesen. n ist eine ganze positive Zahl. Die
Rückgabe von pickapart ist ein äquivalenter Ausdruck, der die
Zwischenmarken enthält.
Siehe auch part, dpart, lpart,
inpart und reveal.
Beispiele:
(%i1) expr: (a+b)/2 + sin (x^2)/3 - log (1 + sqrt(x+1));
2
sin(x ) b + a
(%o1) - log(sqrt(x + 1) + 1) + ------- + -----
3 2
(%i2) pickapart (expr, 0);
2
sin(x ) b + a
(%t2) - log(sqrt(x + 1) + 1) + ------- + -----
3 2
(%o2) %t2
(%i3) pickapart (expr, 1);
(%t3) - log(sqrt(x + 1) + 1)
2
sin(x )
(%t4) -------
3
b + a
(%t5) -----
2
(%o5) %t5 + %t4 + %t3
(%i5) pickapart (expr, 2);
(%t6) log(sqrt(x + 1) + 1)
2
(%t7) sin(x )
(%t8) b + a
%t8 %t7
(%o8) --- + --- - %t6
2 3
(%i8) pickapart (expr, 3);
(%t9) sqrt(x + 1) + 1
2
(%t10) x
b + a sin(%t10)
(%o10) ----- - log(%t9) + ---------
2 3
(%i10) pickapart (expr, 4);
(%t11) sqrt(x + 1)
2
sin(x ) b + a
(%o11) ------- + ----- - log(%t11 + 1)
3 2
(%i11) pickapart (expr, 5);
(%t12) x + 1
2
sin(x ) b + a
(%o12) ------- + ----- - log(sqrt(%t12) + 1)
3 2
(%i12) pickapart (expr, 6);
2
sin(x ) b + a
(%o12) ------- + ----- - log(sqrt(x + 1) + 1)
3 2
Die Systemvariable piece enthält den letzten Ausdruck, der bei der
Verwendung einer part-Funktion ausgewählt wurde.
psubst(a, b, expr) ist identisch mit subst.
Siehe subst.
Im Unterschied zu subst führt die Funktion psubst Substitutionen
parallel aus, wenn das erste Argument list eine Liste mit Gleichungen ist.
Siehe auch die Funktion sublis, um Substitutionen parallel
auszuführen.
Beispiel:
Das erste Beispiel zeigt die parallele Substitution mit psubst. Das
zweite Beispiel zeigt das Ergebnis für die Funktion subst. In diesem
Fall werden die Substitutionen nacheinander ausgeführt.
(%i4) psubst ([a^2=b, b=a], sin(a^2) + sin(b)); (%o4) sin(b) + sin(a) (%i5) subst ([a^2=b, b=a], sin(a^2) + sin(b)); (%o5) 2 sin(a)
Die Funktion rembox entfernt Rahmen aus dem Ausdruck expr.
rembox(expr, unlabelled) entfernt alle Rahmen, die keine Marke
haben. rembox(expr, label) entfernt nur Rahmen, die mit der
Marke label gekennzeichnet sind. rembox(expr) entfernt alle
Rahmen.
Rahmen werden mit den Funktionen box, dpart und
lpart einem Ausdruck hinzugefügt.
Beispiele:
(%i1) expr: (a*d - b*c)/h^2 + sin(%pi*x);
a d - b c
(%o1) sin(%pi x) + ---------
2
h
(%i2) dpart (dpart (expr, 1, 1), 2, 2);
""""""" a d - b c
(%o2) sin("%pi x") + ---------
""""""" """"
" 2"
"h "
""""
(%i3) expr2: lpart (BAR, lpart (FOO, %, 1), 2);
FOO""""""""""" BAR""""""""
" """"""" " "a d - b c"
(%o3) "sin("%pi x")" + "---------"
" """"""" " " """" "
"""""""""""""" " " 2" "
" "h " "
" """" "
"""""""""""
(%i4) rembox (expr2, unlabelled);
BAR""""""""
FOO""""""""" "a d - b c"
(%o4) "sin(%pi x)" + "---------"
"""""""""""" " 2 "
" h "
"""""""""""
(%i5) rembox (expr2, FOO);
BAR""""""""
""""""" "a d - b c"
(%o5) sin("%pi x") + "---------"
""""""" " """" "
" " 2" "
" "h " "
" """" "
"""""""""""
(%i6) rembox (expr2, BAR);
FOO"""""""""""
" """"""" " a d - b c
(%o6) "sin("%pi x")" + ---------
" """"""" " """"
"""""""""""""" " 2"
"h "
""""
(%i7) rembox (expr2);
a d - b c
(%o7) sin(%pi x) + ---------
2
h
Ersetzt Teile des Ausdrucks expr in der ganzzahligen Tiefe depth durch eine beschreibende Zusammenfassung:
Sum(n) ersetzt, wobei n
die Anzahl der Terme der Summe oder Differenz ist.
Product(n) ersetzt, wobei n die Anzahl
der Faktoren des Produktes ist.
Expt ersetzt.
Quotient ersetzt.
Negterm ersetzt.
List(n) ersetzt, wobei n die Anzahl der
Elemente der Liste ist.
Ist depth größer oder gleich der maximalen Tiefe des Ausdrucks
expr, gibt reveal den Ausdruck expr unverändert zurück.
reveal wertet die Argumente aus. reveal gibt die
Zusammenfassung zurück.
Beispiele:
(%i1) e: expand ((a - b)^2)/expand ((exp(a) + exp(b))^2);
2 2
b - 2 a b + a
(%o1) -------------------------
b + a 2 b 2 a
2 %e + %e + %e
(%i2) reveal (e, 1);
(%o2) Quotient
(%i3) reveal (e, 2);
Sum(3)
(%o3) ------
Sum(3)
(%i4) reveal (e, 3);
Expt + Negterm + Expt
(%o4) ------------------------
Product(2) + Expt + Expt
(%i5) reveal (e, 4);
2 2
b - Product(3) + a
(%o5) ------------------------------------
Product(2) Product(2)
2 Expt + %e + %e
(%i6) reveal (e, 5);
2 2
b - 2 a b + a
(%o6) --------------------------
Sum(2) 2 b 2 a
2 %e + %e + %e
(%i7) reveal (e, 6);
2 2
b - 2 a b + a
(%o7) -------------------------
b + a 2 b 2 a
2 %e + %e + %e
Führt im Unterschied zu der Funktion subst die Substitutionen der
Liste list parallel und nicht nacheinander aus.
Mit der Optionsvariablen sublis_apply_lambda wird die Vereinfachung
von Lamda-Ausdrücken kontrolliert, nachdem die Substitution ausgeführt
wurde.
Siehe auch die Funktion psubst, um parallele Substitutionen
auszuführen.
Beispiele:
(%i1) sublis ([a=b, b=a], sin(a) + cos(b)); (%o1) sin(b) + cos(a)
Standardwert: true
Kontrolliert, ob Lambda-Ausdrücke nach einer Substitution ausgewertet werden.
Hat sublis_apply_lambda den Wert true werden Lambda-Ausdrücke
ausgewertet. Ansonsten verbleiben diese nach der Substitution im Ausdruck.
Default value: false
If true then the functions subst and psubst can substitute
a subscripted variable f[x] with a number, when only the symbol f
is given.
See also subst.
(%i1) subst(100,g,g[x]+2);
subst: cannot substitute 100 for operator g in expression g
x
-- an error. To debug this try: debugmode(true);
(%i2) subst(100,g,g[x]+2),subnumsimp:true;
(%o2) 102
Substituiert a für b in den Ausdruck c. Das Argument
b muss ein Atom oder ein vollständiger Teilausdruck von c sein.
Zum Beispiel ist x+y+z ein vollständiger Teilausdruck von
2*(x+y+z)/w, nicht aber x+y. Hat b nicht diese Eigenschaft,
dann können möglicherweise die Funktionen substpart oder
ratsubst angewendet werden.
Hat b die Form e/f, kann subst(a*f, e, c) verwendet werden.
Ist b von der Form e^(1/f), dann kann subst(a^f, e, c)
verwendet werden. Die Funktion subst erkennt auch den Ausdruck
x^y in x^-y, so dass subst(a, sqrt(x), 1/sqrt(x)) das
Ergebnis 1/a hat. a und b können auch die Namen von
Operatoren oder Funktionen sein. Soll die unabhängige Variable in
Ausdrücken mit Ableitungen substituiert werden, sollte die Funktion
at verwendet werden.
subst ist der Alias-Name für substitute.
subst(eq_1, expr) und subst([eq_1, ...,
eq_k], expr) sind weitere mögliche Formen. eq_i sind
Gleichungen, die angeben, welche Substitutionen auszuführen sind. Für
jede Gleichung wird die rechte Seite der Gleichung für die linke Seite in den
Ausdruck expr substituiert.
Hat die Optionsvariable exptsubst den Wert true, wird eine
Substitution wie y für %e^x in einem Ausdruck der Form
%e^(a*x) nicht ausgeführt.
Hat die Optionsvariable opsubst den Wert false,
führt die Funktion subst keine Substitution in einen Operator eines
Ausdrucks aus. Zum Beispiel hat (opsubst: false, subst(x^2, r, r+r[0]))
das Ergebnis x^2+r[0].
Beispiele:
(%i1) subst (a, x+y, x + (x+y)^2 + y);
2
(%o1) y + x + a
(%i2) subst (-%i, %i, a + b*%i);
(%o2) a - %i b
Weitere Beispiele werden mit example(subst) angezeigt.
Die Funktion substinpart ist vergleichbar mit substpart.
substinpart wirkt jedoch auf die interne Darstellung des Ausdrucks
expr.
Beispiele:
(%i1) x . 'diff (f(x), x, 2);
2
d
(%o1) x . (--- (f(x)))
2
dx
(%i2) substinpart (d^2, %, 2);
2
(%o2) x . d
(%i3) substinpart (f1, f[1](x + 1), 0);
(%o3) f1(x + 1)
Substituiert x für den Teilausdruck, der mit den restlichen Argumenten
der Funktion substpart ausgewählt wird. Es wird der neue Ausdruck
expr zurückgegeben. x kann auch der Name eines Operators sein,
der für einen Operator im Ausdruck expr substituiert wird. Zum Beispiel
hat substpart("+", a*b, 0) das Ergebnis b + a).
Mit dem Wert true für die Optionsvariable inflag, verhält
sich die Funktion substpart wie substinpart.
Beispiele:
(%i1) 1/(x^2 + 2);
1
(%o1) ------
2
x + 2
(%i2) substpart (3/2, %, 2, 1, 2);
1
(%o2) --------
3/2
x + 2
(%i3) a*x + f(b, y);
(%o3) a x + f(b, y)
(%i4) substpart ("+", %, 1, 0);
(%o4) x + f(b, y) + a
Gibt true zurück, wenn expr ein Symbol ist, ansonsten
false. Das Kommando symbolp(x) ist äquivalent zu
atom(x) and not numberp(x).
Siehe auch Bezeichner.
Löscht die Ordnung, die mit dem letzten Aufruf der Funktionen
ordergreat oder orderless erzeugt wurde.
Siehe auch ordergreat und orderless.
Beispiele:
(%i1) unorder();
(%o1) []
(%i2) b*x + a^2;
2
(%o2) b x + a
(%i3) ordergreat (a);
(%o3) done
(%i4) b*x + a^2;
%th(1) - %th(3);
2
(%o4) a + b x
(%i5) unorder();
2 2
(%o5) a - a
Gibt das Verb des Symbols f zurück. Siehe auch das Kapitel
Substantive und Verben, sowie noun und nounify.
Beispiele:
(%i1) verbify ('foo);
(%o1) foo
(%i2) :lisp $%
$FOO
(%i2) nounify (foo);
(%o2) foo
(%i3) :lisp $%
%FOO
Nächste: Operatoren, Vorige: Datentypen und Strukturen [Inhalt][Index]