[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

6. Ausdrücke


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

6.1 Einführung in Ausdrücke

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


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

6.2 Substantive und Verben

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)

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

6.3 Bezeichner

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

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

6.4 Funktionen und Variablen für Ausdrücke

Funktion: alias (new_name_1, old_name_1, …, new_name_n, old_name_n)

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)                          []

Systemvariable: aliases

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.

Schlüsselwort: allbut

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]

Funktion: args (expr)

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]

Funktion: atom (expr)

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

Funktion: box (expr)
Funktion: box (expr, a)

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"
                                 """"""

Optionsvariable: boxchar

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.

Funktion: collapse (expr)
Funktion: collapse ([expr_1, expr_2, …])

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.

Funktion: dispform (expr)
Funktion: dispform (expr, all)

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

Funktion: disolate (expr, x_1, …, x_n)

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)

Funktion: dpart (expr, n_1, …, n_k)

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"
                            """

Optionsvariable: exptisolate

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.

Optionsvariable: exptsubst

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

Funktion: freeof (x, expr)
Funktion: freeof (x_1, …, x_n, expr)

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

Optionsvariable: inflag

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 forin, map, fullmap, maplist, reveal, pickapart, args und op.

Funktion: inpart (expr, n_1, …, n_k)

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)

Funktion: isolate (expr, x)

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

Optionsvariable: isolate_wrt_times

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

Optionsvariable: listconstvars

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.

Optionsvariable: listdummyvars

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]

Funktion: listofvars (expr)

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

Funktion: lfreeof (list, expr)

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.

Funktion: lpart (label, expr, n_1, …, n_k)

Die Funktion lpart ist ähnlich zu dpart, verwendet aber einen Rahmen, der mit einer Marke gekennzeichnet ist.

Siehe auch part, inpart und dpart.

Eigenschaft: mainvar

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]

Eigenschaft: noun

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

Optionsvariable: noundisp

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.

Funktion: nounify (f)

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.

Funktion: nterms (expr)

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.

Funktion: op (expr)

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

Funktion: operatorp (expr, op)
Funktion: operatorp (expr, [op_1, …, op_n])

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.

Optionsvariable: opsubst

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].

Funktion: optimize (expr)

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.

Optionsvariable: optimprefix

Standardwert: %

Die Optionsvariable optimprefix enthält den Präfix, der von der Funktion optimize benutzt wird, um einen Teilausdruck zu benennen.

Funktion: ordergreat (v_1, …, v_n)
Funktion: orderless (v_1, …, v_n)

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.

Funktion: ordergreatp (expr_1, expr_2)
Funktion: orderlessp (expr_1, expr_2)

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

Funktion: ordermagnitudep (expr_1, expr_2)

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]

Funktion: part (expr, n_1, …, n_k)

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.

Funktion: partition (expr, var)

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)]]

Optionsvariable: partswitch

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.

Funktion: pickapart (expr, n)

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

Systemvariable: piece

Die Systemvariable piece enthält den letzten Ausdruck, der bei der Verwendung einer part-Funktion ausgewählt wurde.

Siehe auch part und inpart.

Funktion: psubst (list, expr)
Funktion: psubst (a, b, expr)

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)

Funktion: rembox (expr, unlabelled)
Funktion: rembox (expr, label)
Funktion: rembox (expr)

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

Funktion: reveal (expr, depth)

Ersetzt Teile des Ausdrucks expr in der ganzzahligen Tiefe depth durch eine beschreibende Zusammenfassung:

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

Funktion: sublis (list, expr)

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)

Optionsvariable: sublis_apply_lambda

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.

Option variable: subnumsimp

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

Funktion: subst (a, b, c)

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.

Funktion: substinpart (x, expr, n_1, …, n_k)

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)

Funktion: substpart (x, expr, n_1, …, n_k)

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

Funktion: symbolp (expr)

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.

Funktion: unorder ()

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

Funktion: verbify (f)

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

[ << ] [ >> ]           [Top] [Contents] [Index] [ ? ]

This document was generated by Robert on Juli, 9 2012 using texi2html 1.76.