Maxima Manual: 8. Auswertung

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

# 8. Auswertung

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

## 8.1 Einführung in die Auswertung

In Einführung in die Kommandozeile sind die vier Phasen der Eingabe, Auswertung, Vereinfachung und Ausgabe erläutert, die jede Eingabe des Nutzers bis zur Ausgabe auf der Konsole durchläuft.

Jede Eingabe eines Ausdrucks expr wird von Maxima ausgewertet. Symbole, die keinen Wert haben, und Zahlen werden zu sich selbst ausgewertet. Symbole, die einen Wert haben, werden durch ihren Wert ersetzt.

Beispiele:

Im ersten Beispiel werden Symbole und Zahlen zu sich selbst ausgewertet. Im zweiten Beispiel erhält die Variable `a` den Wert `2`. In den folgenden Ausdrücken wird die Variable `a` ausgewertet und durch ihren Wert ersetzt.

    (%i1) [a, b, 2, 1/2, 1.0];
                                      1
    (%o1)                   [a, b, 2, -, 1.0]
                                      2
    (%i2) a:2$

    (%i3) [a, sin(a), a^2];
    (%o3)                    [2, sin(2), 4]

Maxima unterscheidet Funktionen in einer Verbform von Funktionen in einer Substantivform. Funktionen in einer Verbform werden ausgewertet, indem die Funktion auf die ausgewerteten Argumente angewendet wird. Im Gegensatz dazu werden Funktionen in einer Substantivform nicht auf die Argumente angewendet, jedoch werden die Argumente weiterhin ausgewertet. Funktionen können in beiden Formen auftreten. Typische Beispiele sind die Differentiation mit der Funktion `diff` oder die Integration mit der Funktion `integrate`. Siehe zum diesem Thema auch Substantive und Verben.

Beispiele:

Die Variable `a` erhält einen Wert. Im ersten Fall liegt die Funktion `diff` in ihrer Verbform vor. Die Auswertung bewirkt, dass die Funktion auf die Argumente `a*x^2` und x angewendet wird. Im zweiten Fall liegt die Funktion `diff` in ihrer Substantivform vor. Dies wird hier durch den `Quote-Operator` `'` bewirkt. Jetzt wird die Funktion nicht angewendet. Das Ergebnis ist ein symbolischer Ausdruck für die Ableitung. Da auch in diesem Fall die Argumente ausgewertet werden, wird auch hier der Wert `1/2` für die Variable `a` eingesetzt.

    (%i1) a:1/2;
                                    1
    (%o1)                           -
                                    2
    (%i2) diff(a*x^2, x);
    (%o2)                           x
    (%i3) 'diff(a*x^2, x);
                                      2
                                 d   x
    (%o3)                        -- (--)
                                 dx  2

Nicht alle Maxima-Funktionen werten die Argumente aus. Die Dokumentation der Funktionen gibt häufig einen Hinweis darauf, ob die Argumente ausgewertet werden oder nicht.

Beispiel:

Die Funktion `properties` wertet das Argument nicht aus. Dies ist für den Nutzer praktisch, da ansonsten die Auswertung einer Variablen `a`, die einen Wert hat, explizit mit dem Quote-Operator `'` unterdrückt werden müsste, um die Eigenschaften des Symbols `'a` anzuzeigen. Im ersten Fall ist das Ergebnis eine leere Liste. Das Symbol `a` hat keine Eigenschaften. Im zweiten Fall erhält die Variable `a` einen Wert. Die Funktion `properties` wertet ihr Argument nicht aus und `a` wird nicht durch den Wert `2` ersetzt. Die Funktion `properties` zeigt weiterhin die Eigenschaften des Symbols `'a` an.

    (%i1) properties(a);
    (%o1)                          []
    (%i2) a:2$

    (%i3) properties(a);
    (%o3)                        [value]

Die Auswertung von Symbolen, Funktionen und Ausdrücken kann mit dem Quote-Operator `'` und dem Quote-Quote-Operator `''` kontrolliert werden. Der Quote-Operator unterdrückt die Auswertung. Dagegen erzwingt der Quote-Quote-Operator die Auswertung.

Mit der Funktion `ev` wird ein Ausdruck in einer definierten Umgebung ausgewertet, in der Optionsvariablen für die Auswertung einen bestimmten Wert erhalten oder Auswertungsschalter `evflag` und Auswertungsfunktionen `evfun` angewendet werden.

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

## 8.2 Funktionen und Variablen für die Auswertung

Operator: '

  Der Quote-Operator `'` unterdrückt die Auswertung eines Symbols oder Ausdrucks. Auf eine Funktion angewendet, unterdrückt der Quote-Operator die Auswertung der Funktion. Die Auswertung der Argumente der Funktion wird nicht unterdrückt. Das Ergebnis ist die Substantivform der Funktion.

  Wird der Quote-Operator auf einen eingeklammerten Ausdruck angewendet, wird die Auswertung aller Symbole und Funktionen innerhalb der Klammern unterdrückt. `'(f(x))` bedeutet, dass der Ausdruck `f(x)` nicht ausgewertet werden soll. `'f(x)` bedeutet, dass die Substantivform von `f` auf das ausgewertete Argument x angewendet wird.

  Der Quote-Operator unterdrückt die Auswertung, aber nicht die Vereinfachung von Ausdrücken.

  Substantivformen werden mit einem Hochkomma angezeigt, wenn die Optionsvariable `noundisp` den Wert `true` hat.

  Siehe auch den Quote-Quote-Operator `''` und den Auswertungsschalter `nouns`.

  Beispiele:

  Auf ein Symbol angewendet, unterdrückt der Quote-Operator die Auswertung des Symbols.

      (%i1) aa: 1024;
      (%o1)                         1024
      (%i2) aa^2;
      (%o2)                        1048576
      (%i3) 'aa^2;
                                       2
      (%o3)                          aa
      (%i4) ''%;
      (%o4)                        1048576

  Auf eine Funktion angewendet, unterdrückt der Quote-Operator die Auswertung der Funktion. Das Ergebnis ist die Substantivform der Funktion.

      (%i1) x0: 5;
      (%o1)                           5
      (%i2) x1: 7;
      (%o2)                           7
      (%i3) integrate (x^2, x, x0, x1);
                                     218
      (%o3)                          ---
                                      3
      (%i4) 'integrate (x^2, x, x0, x1);
                                   7
                                  /
                                  [   2
      (%o4)                       I  x  dx
                                  ]
                                  /
                                   5
      (%i5) %, nouns;
                                     218
      (%o5)                          ---
                                      3

  Wird der Quote-Operator auf einen eingeklammerten Ausdruck angewendet, wird die Auswertung aller Symbole und Funktionen innerhalb der Klammern unterdrückt.

      (%i1) aa: 1024;
      (%o1)                         1024
      (%i2) bb: 19;
      (%o2)                          19
      (%i3) sqrt(aa) + bb;
      (%o3)                          51
      (%i4) '(sqrt(aa) + bb);
      (%o4)                     bb + sqrt(aa)
      (%i5) ''%;
      (%o5)                          51

  Der Quote-Operator unterdrückt nicht die Vereinfachung von Ausdrücken.

      (%i1) sin (17 * %pi) + cos (17 * %pi);
      (%o1)                          - 1
      (%i2) '(sin (17 * %pi) + cos (17 * %pi));
      (%o2)                          - 1

  Gleitkommarechnungen sind eine Vereinfachung und keine Auswertung. Daher kann die Berechnung von `sin(1.0)` nicht mit dem Quote-Operator unterdrückt werden.

      (%i1) sin(1.0);
      (%o1)                          .8414709848078965
      (%i2) '(sin(1.0));
      (%o2)                          .8414709848078965

Operator: "

  Der Quote-Quote-Operator `''` (zwei Hochkommata) modifiziert die Auswertung von Ausdrücken, die von der Eingabe gelesen werden.

  Wird der Quote-Quote-Operator auf einen allgemeinen Ausdruck expr angewendet, wird der Ausdruck expr durch seinen Wert ersetzt.

  Wird der Quote-Quote-Operator auf den Operator eines Ausdruckes angewendet, ändert sich der Operator, wenn er in seiner Substantivform vorliegt, in die Verbform.

  Der Quote-Quote-Operator wird vom Parser, der die Eingabe liest, sofort angewendet und nicht im eingelesen Ausdruck gespeichert. Daher kann die Auswertung des Quote-Quote-Operators nicht durch einen weiteren Quote-Operator verhindert werden. Der Quote-Quote-Operator führt zur Auswertung von Ausdrücken, deren Auswertung unterdrückt ist. Das ist der Fall für Funktionsdefinitionen, Lambda-Ausdrücke und Ausdrücke, deren Auswertung durch den Quote-Operator verhindert wurde.

  Der Quote-Quote-Operator wird von den Befehlen `batch` und `load` erkannt.

  Siehe auch den Quote-Operator `'` und den Auswertungsschalter `nouns`.

  Beispiele:

  Wird der Quote-Quote-Operator auf einen Ausdruck expr angewendet, wird der Wert von expr in den Ausdruck eingesetzt.

      (%i1) expand ((a + b)^3);
                           3        2      2      3
      (%o1)               b  + 3 a b  + 3 a  b + a
      (%i2) [_, ''_];
                               3    3        2      2      3
      (%o2)     [expand((b + a) ), b  + 3 a b  + 3 a  b + a ]
      (%i3) [%i1, ''%i1];
                               3    3        2      2      3
      (%o3)     [expand((b + a) ), b  + 3 a b  + 3 a  b + a ]
      (%i4) [aa : cc, bb : dd, cc : 17, dd : 29];
      (%o4)                   [cc, dd, 17, 29]
      (%i5) foo_1 (x) := aa - bb * x;
      (%o5)                 foo_1(x) := aa - bb x
      (%i6) foo_1 (10);
      (%o6)                      cc - 10 dd
      (%i7) ''%;
      (%o7)                         - 273
      (%i8) ''(foo_1 (10));
      (%o8)                         - 273
      (%i9) foo_2 (x) := ''aa - ''bb * x;
      (%o9)                 foo_2(x) := cc - dd x
      (%i10) foo_2 (10);
      (%o10)                        - 273
      (%i11) [x0 : x1, x1 : x2, x2 : x3];
      (%o11)                    [x1, x2, x3]
      (%i12) x0;
      (%o12)                         x1
      (%i13) ''x0;
      (%o13)                         x2
      (%i14) '' ''x0;
      (%o14)                         x3

  Wird der Quote-Quote-Operator auf den Operator in einem Ausdruck angewendet, ändert sich der Operator von seiner Substantivform in die Verbform.

      (%i1) declare (foo, noun);
      (%o1)                         done
      (%i2) foo (x) := x - 1729;
      (%o2)                 ''foo(x) := x - 1729
      (%i3) foo (100);
      (%o3)                       foo(100)
      (%i4) ''foo (100);
      (%o4)                        - 1629

  Der Quote-Quote-Operator wird vom Parser sofort auf den eingelesenen Ausdruck angewendet und ist nicht Teil eines Maxima-Ausdrucks.

      (%i1) [aa : bb, cc : dd, bb : 1234, dd : 5678];
      (%o1)                 [bb, dd, 1234, 5678]
      (%i2) aa + cc;
      (%o2)                        dd + bb
      (%i3) display (_, op (_), args (_));
                                 _ = cc + aa

                               op(cc + aa) = +

                          args(cc + aa) = [cc, aa]

      (%o3)                         done
      (%i4) ''(aa + cc);
      (%o4)                         6912
      (%i5) display (_, op (_), args (_));
                                 _ = dd + bb

                               op(dd + bb) = +

                          args(dd + bb) = [dd, bb]
      (%o5)                         done

  Der Quote-Quote-Operator bewirkt die Auswertung von Ausdrücken, deren Auswertung unterdrückt ist wie in Funktionsdefinitionen, Lambda-Ausdrücken und Ausdrücken, auf die der Quote-Operator angewendet wurde.

      (%i1) foo_1a (x) := ''(integrate (log (x), x));
      (%o1)               foo_1a(x) := x log(x) - x
      (%i2) foo_1b (x) := integrate (log (x), x);
      (%o2)           foo_1b(x) := integrate(log(x), x)
      (%i3) dispfun (foo_1a, foo_1b);
      (%t3)               foo_1a(x) := x log(x) - x

      (%t4)           foo_1b(x) := integrate(log(x), x)

      (%o4)                      [%t3, %t4]
      (%i5) integrate (log (x), x);
      (%o5)                     x log(x) - x
      (%i6) foo_2a (x) := ''%;
      (%o6)               foo_2a(x) := x log(x) - x
      (%i7) foo_2b (x) := %;
      (%o7)                    foo_2b(x) := %
      (%i8) dispfun (foo_2a, foo_2b);
      (%t8)               foo_2a(x) := x log(x) - x

      (%t9)                    foo_2b(x) := %

      (%o9)                      [%t8, %t9]
      (%i10) F : lambda ([u], diff (sin (u), u));
      (%o10)            lambda([u], diff(sin(u), u))
      (%i11) G : lambda ([u], ''(diff (sin (u), u)));
      (%o11)                 lambda([u], cos(u))
      (%i12) '(sum (a[k], k, 1, 3) + sum (b[k], k, 1, 3));
      (%o12)         sum(b , k, 1, 3) + sum(a , k, 1, 3)
                          k                  k
      (%i13) '(''(sum (a[k], k, 1, 3)) + ''(sum (b[k], k, 1, 3)));
      (%o13)             b  + a  + b  + a  + b  + a
                          3    3    2    2    1    1

Funktion: ev (expr, arg_1, …, arg_n)

  Wertet den Ausdruck expr in einer Umgebung aus, die durch die Argumente arg_1, …, arg_n spezifiziert wird. Die Argumente sind Optionsvariablen (Boolesche Variablen), Zuweisungen, Gleichungen und Funktionen. `ev` gibt das Ergebnis der Auswertung zurück.

  Die Auswertung wird in den folgenden Schritten durchgeführt:

  1. Zuerst wird die Umgebung gesetzt. Dazu werden die Argumente arg_1, …, arg_n ausgewertet. Folgende Argumente sind möglich:
     - `simp` bewirkt, dass der Ausdruck expr vereinfacht wird. Der Wert der Optionsvariablen `simp` wird dabei ignoriert. Der Ausdruck wird also auch dann vereinfacht, wenn die Optionsvariable simp den Wert `false` hat.
     - `noeval` unterdrückt die Auswertungphase der Funktion `ev` (siehe Schritt (4) unten). Dies ist nützlich im Zusammenhang mit anderen Schaltern und um einen Ausdruck expr erneuert zu vereinfachen, ohne dass dieser ausgewertet wird.
     - `nouns` bewirkt die Auswertung von Substantivformen. Solche Substantivformen sind typischerweise nicht ausgewertete Funktionen wie `'integrate` oder `'diff`, die im Ausdruck expr enthalten sind.
     - `expand` bewirkt die Expansion des Ausdruckes expr. Siehe die Funktion `expand`.
     - `expand`(m, n) bewirkt die Expansion des Ausdruckes expr, wobei den Optionsvariablen `maxposex` und `maxnegex` die Werte der Argumente m und n zugewiesen werden. Siehe die Funktion `expand`.
     - `detout` bewirkt, dass bei der Berechnung von Inversen von Matrizen, die im Ausdruck expr enthalten sind, Determinanten den Matrizen vorangestellt und nicht elementweise in die Matrize hereinmultipliziert werden.
     - `diff` bewirkt, dass alle Ableitungen ausgeführt werden, die im Ausdruck expr enthalten sind.
     - `derivlist(x, y, z, ...)` bewirkt, dass die Ableitungen bezüglich der angegebenen Variablen x, y, z, … ausgeführt werden.
     - `risch` bewirkt das Integrale im Ausdruck expr mit dem Risch-Algorithmus berechnet werden. Siehe `risch`. Wird der Schalter `nouns` benutzt, wird der Standardalgorithmus für Integrale verwendet.
     - `float` bewirkt, dass rationale Zahlen in Gleitkommazahlen konvertiert werden.
     - `numer` bewirkt, dass mathematische Funktionen mit numerischen Argumenten ein Ergebnis in Gleitkommazahlen liefern. Variablen in `expr`, denen numerische Werte zugewiesen wurden, werden durch diese ersetzt. Der Schalter `float` wird zusätzlich wirksam.
     - `pred` bewirkt, dass Aussagen zu `true` oder `false` ausgewertet werden.
     - `eval` bewirkt eine zusätzliche Auswertung des Ausdrucks expr. (Siehe Schritt (5) unten). `eval` kann mehrfach angewendet werden. Jedes Auftreten von `eval` führt zu einer weiteren Auswertung.
     - `A`, wobei `A` ein Symbol ist, das als ein Auswertungsschalter `evflag` definiert ist. Während der Auswertung des Ausdrucks expr erhält `A` den Wert `true`.
     - `V: expression` (oder alternativ `V=expression`) bewirkt, dass `V` während der Auswertung des Ausdrucks expr den Wert `expression` erhält. `V` kann auch eine Optionsvariable sein, die für die Auswertung den Wert `expression` erhält. Wenn mehr als ein Argument der Funktion `ev` übergeben wird, wird die Zuweisung der Werte parallel ausgeführt. Wenn `V` kein Atom ist, wird anstatt einer Zuweisung eine Substitution ausgeführt.
     - `F`, wobei `F` der Name einer Funktion ist, die als eine Auswertungsfunktion (siehe `evfun`) definiert wurde. `F` bewirkt, dass die Auswertungsfunktion auf den Ausdruck expr angewendet wird.
     - Jeder andere Funktionsname (zum Beispiel `sum`) bewirkt, dass jedes Auftreten dieser Funktion im Ausdruck expr ausgewertet wird.
     - Zusätzlich kann für die Auswertung von expr eine lokale Funktion `F(x) := expression` definiert werden.
     - Wird ein Symbol, eine indizierte Variable oder ein indizierter Ausdruck, der oben nicht genannt wurde, als Argument übergeben, wird das Argument ausgewertet. Wenn das Ergebnis eine Gleichung oder eine Zuweisung ist, werden die entsprechenden Zuweisungen und Substitutionen ausgeführt. Wenn das Ergebnis eine Liste ist, werden die Elemente der Liste als zusätzliche Argumente von `ev` betrachtet. Dies erlaubt, das eine Liste mit Gleichungen (zum Beispiel `[%t1, %t2]`, wobei `%t1` und `%t2` Gleichungen sind) wie sie zum Beispiel von der Funktion `solve` erzeugt wird, als Argument verwendet werden kann.

     Die Argumente der Funktion `ev` können in einer beliebigen Reihenfolge übergeben werden. Ausgenommen sind Gleichungen mit Substitutionen, die nacheinander von links nach rechts ausgewertet werden, sowie Auswertungsfunktionen, die verkettet werden. So wird zum Beispiel `ev(expr, ratsimp, realpart)` zu `realpart(ratsimp(expr))`.

     Die Schalter `simp`, `numer`, `float` und `detout` sind auch Optionsvariablen, die lokal in einem Block oder global gesetzt werden können.

     Ist expr ein kanonischer rationaler Ausdruck (CRE = canonical rational expression), ist auch das Ergebnis der Funktion `ev` ein CRE-Ausdruck, falls nicht die beiden Schalter `float` und `numer` den Wert `true` haben.

  2. Während des Schritts (1) wird eine Liste der nicht indizierten Variablen erstellt, die auf der linken Seite von Gleichungen auftreten. Die Gleichungen können dabei entweder als Argument oder als Wert eines Argumentes vorliegen. Variablen, die nicht in dieser Liste enthalten sind, werden durch ihre globalen Werte ersetzt. Davon ausgenommen sind Variablen, die eine Array-Funktion repräsentieren. Ist zum Beispiel expr eine Marke wie `%i2` im Beispiel unten oder das letzte Ergebnis `%`, so wird in diesem Schritt der globale Wert dieser Marke eingesetzt und die Bearbeitung durch `ev` fortgesetzt.
  3. Wenn in den Argumenten Substitutionen aufgeführt sind, werden diese nun ausgeführt.
  4. Der resultierende Ausdruck wird erneut ausgewertet, außer wenn `noeval` unter den Argumente ist, und vereinfacht. Die Funktionsaufrufe in expr werden erst ausgeführt, wenn die enthaltenden Variablen ausgewertet sind. Dadurch verhält sich `ev(F(x))` wie `F(ev(x))`.
  5. Für jedes Auftreten des Schalters `eval` in den Argumenten werden die Schritte (3) und (4) wiederholt.

  Anstatt der Anwendung der Funktion `ev` können alternativ der Ausdruck und die Argumente durch Kommata getrennt eingegeben werden:

      expr, arg_1, ..., arg_n

  Diese Kurzschreibweise ist jedoch als Teil eines anderen Ausdrucks, zum Beispiel in Funktionen oder Blöcken nicht gestattet.

  Beispiele:

      (%i1) sin(x) + cos(y) + (w+1)^2 + 'diff (sin(w), w);
                                           d                    2
      (%o1)              cos(y) + sin(x) + -- (sin(w)) + (w + 1)
                                           dw
      (%i2) ev (%, numer, expand, diff, x=2, y=1);
                                     2
      (%o2)                cos(w) + w  + 2 w + 2.449599732693821

  Im folgenden Beispiel werden die Zuweisungen parallel durchgeführt. Es wird die Kurzschreibweise der Funktion `ev` angewendet.

      (%i3) programmode: false;
      (%o3)                                false
      (%i4) x+y, x: a+y, y: 2;
      (%o4)                              y + a + 2
      (%i5) 2*x - 3*y = 3$
      (%i6) -3*x + 2*y = -4$
      (%i7) solve ([%o5, %o6]);
      Solution

                                                1
      (%t7)                               y = - -
                                                5

                                               6
      (%t8)                                x = -
                                               5
      (%o8)                            [[%t7, %t8]]
      (%i8) %o6, %o8;
      (%o8)                              - 4 = - 4
      (%i9) x + 1/x > gamma (1/2);
                                         1
      (%o9)                          x + - > sqrt(%pi)
                                         x
      (%i10) %, numer, x=1/2;
      (%o10)                      2.5 > 1.772453850905516
      (%i11) %, pred;
      (%o11)                               true

Auswertungsschalter: eval

  Als Argument des Kommandos `ev(expr, eval)` bewirkt `eval` eine zusätzliche Auswertung des Ausdrucks `expr`.

  `eval` kann mehrfach auftreten. Jedes Auftreten führt zu einer zusätzlichen Auswertung.

  Siehe auch die Funktion `ev` sowie die Auswertungsschalter `noeval` und `infeval`

  Beispiele:

      (%i1) [a:b,b:c,c:d,d:e];
      (%o1)                            [b, c, d, e]
      (%i2) a;
      (%o2)                                  b
      (%i3) ev(a);
      (%o3)                                  c
      (%i4) ev(a),eval;
      (%o4)                                  e
      (%i5) a,eval,eval;
      (%o5)                                  e

Eigenschaft: evflag

  Wenn ein Symbol x die Eigenschaft eines Auswertungsschalters besitzt, sind die Ausdrücke `ev(expr, x)` und `expr, x` äquivalent zu `ev(expr, x = true)`. Während der Auswertung von expr erhält also x den Wert `true`.

  Mit `declare(x, evflag)` wird der Variablen x die `evflag`-Eigenschaft gegeben. Siehe auch die Funktion `declare`. Mit `kill` oder `remove` kann diese Eigenschaft wieder entfernt werden. Siehe auch `properties` für die Anzeige von Eigenschaften.

  Folgende Optionsvariablen haben bereits die `evflag`-Eigenschaft:

         algebraic           cauchysum       demoivre
         dotscrules          %emode          %enumer
         exponentialize      exptisolate     factorflag
         float               halfangles      infeval
         isolate_wrt_times   keepfloat       letrat
         listarith           logabs          logarc
         logexpand           lognegint
         m1pbranch           numer_pbranch   programmode
         radexpand           ratalgdenom     ratfac
         ratmx               ratsimpexpons   simp
         simpproduct         simpsum         sumexpand
         trigexpand

  Beispiele:

      (%i1) sin (1/2);
                                       1
      (%o1)                        sin(-)
                                       2
      (%i2) sin (1/2), float;
      (%o2)                   0.479425538604203
      (%i3) sin (1/2), float=true;
      (%o3)                   0.479425538604203
      (%i4) simp : false;
      (%o4)                         false
      (%i5) 1 + 1;
      (%o5)                         1 + 1
      (%i6) 1 + 1, simp;
      (%o6)                           2
      (%i7) simp : true;
      (%o7)                         true
      (%i8) sum (1/k^2, k, 1, inf);
                                  inf
                                  ====
                                  \     1
      (%o8)                        >    --
                                  /      2
                                  ====  k
                                  k = 1
      (%i9) sum (1/k^2, k, 1, inf), simpsum;
                                       2
                                    %pi
      (%o9)                         ----
                                     6
      (%i10) declare (aa, evflag);
      (%o10)                        done
      (%i11) if aa = true then YES else NO;
      (%o11)                         NO
      (%i12) if aa = true then YES else NO, aa;
      (%o12)                         YES

Eigenschaft: evfun

  Wenn eine Funktion F die Eigenschaft `evfun` besitzt, sind die Ausdrücke `ev(expr, F)` und `expr, F` äquivalent zu `F(ev(expr))`.

  Zwei oder mehr `evfun`-Funktionen F, G, … werden in der aufgeführten Reihenfolge auf den Ausdruck expr angewendet.

  Mit `declare(F, evfun)` wird der Funktion F die `evfun`-Eigenschaft gegeben. Siehe auch die Funktion `declare`. Mit `kill` oder `remove` kann diese Eigenschaft wieder entfernt werden. Siehe auch `properties` für die Anzeige von Eigenschaften.

  Funktionen, die bereits die `evfun`-Eigenschaft besitzen, sind:

         bfloat          factor       fullratsimp
         logcontract     polarform    radcan
         ratexpand       ratsimp      rectform
         rootscontract   trigexpand   trigreduce

  Beispiele:

      (%i1) x^3 - 1;
                                    3
      (%o1)                        x  - 1
      (%i2) x^3 - 1, factor;
                                      2
      (%o2)                 (x - 1) (x  + x + 1)
      (%i3) factor (x^3 - 1);
                                      2
      (%o3)                 (x - 1) (x  + x + 1)
      (%i4) cos(4 * x) / sin(x)^4;
                                  cos(4 x)
      (%o4)                       --------
                                     4
                                  sin (x)
      (%i5) cos(4 * x) / sin(x)^4, trigexpand;
                       4           2       2         4
                    sin (x) - 6 cos (x) sin (x) + cos (x)
      (%o5)         -------------------------------------
                                      4
                                   sin (x)
      (%i6) cos(4 * x) / sin(x)^4, trigexpand, ratexpand;
                                 2         4
                            6 cos (x)   cos (x)
      (%o6)               - --------- + ------- + 1
                                2          4
                             sin (x)    sin (x)
      (%i7) ratexpand (trigexpand (cos(4 * x) / sin(x)^4));
                                 2         4
                            6 cos (x)   cos (x)
      (%o7)               - --------- + ------- + 1
                                2          4
                             sin (x)    sin (x)
      (%i8) declare ([F, G], evfun);
      (%o8)                         done
      (%i9) (aa : bb, bb : cc, cc : dd);
      (%o9)                          dd
      (%i10) aa;
      (%o10)                         bb
      (%i11) aa, F;
      (%o11)                        F(cc)
      (%i12) F (aa);
      (%o12)                        F(bb)
      (%i13) F (ev (aa));
      (%o13)                        F(cc)
      (%i14) aa, F, G;
      (%o14)                      G(F(cc))
      (%i15) G (F (ev (aa)));
      (%o15)                      G(F(cc))

Optionsvariable: infeval

  Standardwert: `false`

  `infeval` bewirkt, dass die Funktion `ev` die Auswertung eines Ausdrucks solange wiederholt, bis dieser sich nicht mehr ändert. Um zu verhindern, dass eine Variable in diesem Modus durch die Auswertung verschwindet, kann zum Beispiel für eine Variable `x` der Ausdruck `x='x` als Argument von `ev` einfügt werden. Ausdrücke wie `ev(x, x=x+1, infeval)` führen in diesem Modus zu Endlosschleifen.

  Siehe auch die Auswertungsschalter `noeval` und `eval`.

Auswertungsschalter: noeval

  `noeval` unterdrückt die Auswertungsphase der Funktion `ev`. Der Schalter kann im Zusammenhang mit anderen Auswertungsschaltern genutzt werden, um einen Ausdruck erneut zu vereinfachen, ohne diesen auszuwerten.

  Siehe auch die Optionsvariable `infeval` und den Auswertungsschalter `eval`.

Auswertungsschalter: nouns

  `nouns` ist ein Auswertungsschalter. Wird dieser Schalter als eine Option der Funktion `ev` genutzt, werden alle Substantivformen, die in dem Ausdruck enthalten sind, in Verbformen umgewandelt und ausgewertet.

  Siehe auch die Eigenschaft `noun` und die Funktionen `nounify` und `verbify`.

Auswertungsschalter: pred

  Wird `pred` als ein Argument der Funktion `ev` eingesetzt, werden Aussagen zu `true` oder `false` ausgewertet. Siehe die Funktion `ev`.

  Beispiel:

      (%i1) 1 < 2;
      (%o1)                                1 < 2
      (%i2) 1 < 2,pred;
      (%o2)                                true

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

This document was generated by U-CYGWINX\ASSI on diciembre, 18 2015 using texi2html 1.76.