@c -----------------------------------------------------------------------------
@c File        : Evaluation.de.texi
@c License     : GNU General Public License (GPL)
@c Language    : German
@c Original    : Evaluation.texi revision 01.08.2011
@c Translation : Dr. Dieter Kaiser
@c Date        : 17.10.2010
@c Revision    : 01.11.2011
@c 
@c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA
@c -----------------------------------------------------------------------------

@menu
* Einf@"uhrung in die Auswertung::
* Funktionen und Variablen f@"ur die Auswertung::
@end menu

@c -----------------------------------------------------------------------------
@node Einf@"uhrung in die Auswertung, Funktionen und Variablen f@"ur die Auswertung, Auswertung, Auswertung
@section Einf@"uhrung in die Auswertung
@c -----------------------------------------------------------------------------

In @ref{Einf@"uhrung in die Kommandozeile} sind die vier Phasen der Eingabe, 
Auswertung, Vereinfachung und Ausgabe erl@"autert, die jede Eingabe des Nutzers
bis zur Ausgabe auf der Konsole durchl@"auft.

Jede Eingabe eines Ausdrucks @var{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@"alt die Variable @code{a} den Wert @code{2}.  In den
folgenden Ausdr@"ucken wird die Variable @code{a} ausgewertet und durch ihren
Wert ersetzt.

@example
(%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]
@end example

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@"onnen in
beiden Formen auftreten.  Typische Beispiele sind die Differentiation mit der
Funktion @mref{diff} oder die Integration mit der Funktion @mrefdot{integrate}
Siehe zum diesem Thema auch @ref{Substantive und Verben}.

Beispiele:

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

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

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

Beispiel:

Die Funktion @mref{properties} wertet das Argument nicht aus.  Dies ist f@"ur
den Nutzer praktisch, da ansonsten die Auswertung einer Variablen @code{a}, die
einen Wert hat, explizit mit dem Quote-Operator @code{'} unterdr@"uckt werden
m@"usste, um die Eigenschaften des Symbols @code{'a} anzuzeigen.  Im ersten Fall
ist das Ergebnis eine leere Liste.  Das Symbol @code{a} hat keine Eigenschaften.
Im zweiten Fall erh@"alt die Variable @code{a} einen Wert.  Die Funktion
@code{properties} wertet ihr Argument nicht aus und @code{a} wird nicht durch
den Wert @code{2} ersetzt.  Die Funktion @code{properties} zeigt weiterhin die
Eigenschaften des Symbols @code{'a} an.

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

(%i3) properties(a);
(%o3)                        [value]
@end example

Die Auswertung von Symbolen, Funktionen und Ausdr@"ucken kann mit dem
@nxref{', Quote-Operator} @code{'} und dem @nxref{'', Quote-Quote-Operator}@w{}
@code{''} kontrolliert werden.  Der Quote-Operator unterdr@"uckt die Auswertung.
Dagegen erzwingt der Quote-Quote-Operator die Auswertung.

Mit der Funktion @mref{ev} wird ein Ausdruck in einer definierten Umgebung
ausgewertet, in der Optionsvariablen f@"ur die Auswertung einen bestimmten Wert
erhalten oder Auswertungsschalter @mref{evflag} und Auswertungsfunktionen
@mref{evfun} angewendet werden.

@c -----------------------------------------------------------------------------
@node Funktionen und Variablen f@"ur die Auswertung, , Einf@"uhrung in die Auswertung, Auswertung
@section Funktionen und Variablen f@"ur die Auswertung
@c -----------------------------------------------------------------------------

@c --- 07.03.2011 DK -----------------------------------------------------------
@anchor{'}
@findex Quote-Operator
@deffn {Operator} '

Der Quote-Operator @code{'} unterdr@"uckt die Auswertung eines Symbols oder
Ausdrucks.  Auf eine Funktion angewendet, unterdr@"uckt der Quote-Operator die
Auswertung der Funktion.  Die Auswertung der Argumente der Funktion wird nicht
unterdr@"uckt.  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@"uckt.
@code{'(f(x))} bedeutet, dass der Ausdruck @code{f(x)} nicht ausgewertet werden 
soll.  @code{'f(x)} bedeutet, dass die Substantivform von @code{f} auf das 
ausgewertete Argument @var{x} angewendet wird.

Der Quote-Operator unterdr@"uckt die Auswertung, aber nicht die Vereinfachung
von Ausdr@"ucken.

Substantivformen werden mit einem Hochkomma angezeigt, wenn die Optionsvariable 
@mref{noundisp} den Wert @code{true} hat.

Siehe auch den @nxref{'', Quote-Quote-Operator} @code{'@w{}'} und den
Auswertungsschalter @mrefdot{nouns}

Beispiele:

Auf ein Symbol angewendet, unterdr@"uckt der Quote-Operator die Auswertung des
Symbols.

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

Auf eine Funktion angewendet, unterdr@"uckt der Quote-Operator die Auswertung
der Funktion.  Das Ergebnis ist die Substantivform der Funktion.

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

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

@example
(%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
@end example

Der Quote-Operator unterdr@"uckt nicht die Vereinfachung von Ausdr@"ucken.

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

Gleitkommarechnungen sind eine Vereinfachung und keine Auswertung.  Daher kann
die Berechnung von @code{sin(1.0)} nicht mit dem Quote-Operator unterdr@"uckt
werden.

@example
(%i1) sin(1.0);
(%o1)                          .8414709848078965
(%i2) '(sin(1.0));
(%o2)                          .8414709848078965
@end example
@end deffn

@c --- 07.03.2011 DK -----------------------------------------------------------
@anchor{''}
@findex Quote-Quote-Operator
@deffn {Operator} ''

Der Quote-Quote-Operator @code{'@w{}'} (zwei Hochkommata) modifiziert die 
Auswertung von Ausdr@"ucken, die von der Eingabe gelesen werden.

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

Wird der Quote-Quote-Operator auf den Operator eines Ausdruckes angewendet,
@"andert 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@"uhrt zur Auswertung von
Ausdr@"ucken, deren Auswertung unterdr@"uckt ist.  Das ist der Fall f@"ur 
Funktionsdefinitionen, Lambda-Ausdr@"ucke und Ausdr@"ucke, deren Auswertung
durch den Quote-Operator verhindert wurde.

Der Quote-Quote-Operator wird von den Befehlen @mref{batch} und
@mref{load} erkannt.

Siehe auch den @nxref{', Quote-Operator} @code{'} und den Auswertungsschalter
@mrefdot{nouns}

Beispiele:

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

@example
(%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
@group
(%i9) foo_2 (x) := ''aa - ''bb * x;
(%o9)                 foo_2(x) := cc - dd x
@end group
(%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
@end example

Wird der Quote-Quote-Operator auf den Operator in einem Ausdruck angewendet,
@"andert sich der Operator von seiner Substantivform in die Verbform.

@example
(%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
@end example

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

@example
(%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 (_));
@group
                           _ = dd + bb

                         op(dd + bb) = +

                    args(dd + bb) = [dd, bb]
@end group
(%o5)                         done
@end example

Der Quote-Quote-Operator bewirkt die Auswertung von Ausdr@"ucken, deren
Auswertung unterdr@"uckt ist wie in Funktionsdefinitionen, Lambda-Ausdr@"ucken 
und Aus@-dr@"u@-cken, auf die der Quote-Operator angewendet wurde.

@example
(%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
@end example
@end deffn

@c --- 07.03.2011 DK -----------------------------------------------------------
@anchor{ev}
@deffn {Funktion} ev (@var{expr}, @var{arg_1}, @dots{}, @var{arg_n})

Wertet den Ausdruck @var{expr} in einer Umgebung aus, die durch die Argumente
@var{arg_1}, @dots{}, @var{arg_n} spezifiziert wird.  Die Argumente sind
Optionsvariablen (Boolesche Variablen), Zuweisungen, Gleichungen und Funktionen.
@code{ev} gibt das Ergebnis der Auswertung zur@"uck.

Die Auswertung wird in den folgenden Schritten durchgef@"uhrt:

@enumerate
@item
Zuerst wird die Umgebung gesetzt.  Dazu werden die Argumente @var{arg_1},
@dots{}, @var{arg_n} ausgewertet.  Folgende Argumente sind m@"oglich:

@itemize @bullet
@item
@code{simp} bewirkt, dass der Ausdruck @var{expr} vereinfacht wird.  Der Wert
der Optionsvariablen @mref{simp} wird dabei ignoriert.  Der Ausdruck wird also
auch dann vereinfacht, wenn die Optionsvariable @var{simp} den Wert @code{false}
hat.

@item
@code{noeval} unterdr@"uckt die Auswertungphase der Funktion @code{ev} (siehe 
Schritt (4) unten).  Dies ist n@"utzlich im Zusammenhang mit anderen Schaltern
und um einen Ausdruck @var{expr} erneuert zu vereinfachen, ohne dass dieser
ausgewertet wird.

@item
@code{nouns} bewirkt die Auswertung von Substantivformen.  Solche 
Substantivformen sind typischerweise nicht ausgewertete Funktionen wie 
@code{'integrate} oder @code{'diff}, die im Ausdruck @var{expr} enthalten sind.

@item
@code{expand} bewirkt die Expansion des Ausdruckes @var{expr}.  Siehe die 
Funktion @mrefdot{expand}

@item
@code{expand}(@var{m}, @var{n}) bewirkt die Expansion des Ausdruckes @var{expr}, 
wobei den Optionsvariablen @mref{maxposex} und @mref{maxnegex} die Werte der
Argumente @var{m} und @var{n} zugewiesen werden.  Siehe die Funktion
@mrefdot{expand}

@item
@code{detout} bewirkt, dass bei der Berechnung von Inversen von Matrizen, die im
Ausdruck @var{expr} enthalten sind, Determinanten den Matrizen vorangestellt
und nicht elementweise in die Matrize hereinmultipliziert werden.

@item
@code{diff} bewirkt, dass alle Ableitungen ausgef@"uhrt werden, die im Ausdruck
@var{expr} enthalten sind.

@item
@code{derivlist(@var{x}, @var{y}, @var{z}, ...)} bewirkt, dass die Ableitungen
bez@"uglich der angegebenen Variablen @var{x}, @var{y}, @var{z}, @dots{}
ausgef@"uhrt werden.

@item
@code{risch} bewirkt das Integrale im Ausdruck @var{expr} mit dem
Risch-Algorithmus berechnet werden.  Siehe @code{risch}.  Wird der Schalter
@mref{nouns} benutzt, wird der Standardalgorithmus f@"ur Integrale verwendet.

@item
@code{float} bewirkt, dass rationale Zahlen in Gleitkommazahlen konvertiert 
werden.

@item
@code{numer} bewirkt, dass mathematische Funktionen mit numerischen Argumenten 
ein Ergebnis in Gleitkommazahlen liefern.  Variablen in @code{expr}, denen
numerische Werte zugewiesen wurden, werden durch diese ersetzt.  Der Schalter
@mref{float} wird zus@"atzlich wirksam.

@item
@code{pred} bewirkt, dass Aussagen zu @code{true} oder @code{false} ausgewertet 
werden.

@item
@code{eval} bewirkt eine zus@"atzliche Auswertung des Ausdrucks @var{expr}.
(Siehe Schritt (5) unten).  @code{eval} kann mehrfach angewendet werden.  Jedes 
Auftreten von @code{eval} f@"uhrt zu einer weiteren Auswertung.

@item
@code{A}, wobei @code{A} ein Symbol ist, das als ein Auswertungsschalter
@mref{evflag} definiert ist.  W@"ahrend der Auswertung des Ausdrucks @var{expr} 
erh@"alt @code{A} den Wert @code{true}.

@item
@code{V: expression} (oder alternativ @code{V=expression}) bewirkt, dass 
@code{V} w@"ahrend der Auswertung des Ausdrucks @var{expr} den Wert
@code{expression} erh@"alt.  @code{V} kann auch eine Optionsvariable sein, die
f@"ur die Auswertung den Wert @code{expression} erh@"alt.  Wenn mehr als ein 
Argument der Funktion @code{ev} @"ubergeben wird, wird die Zuweisung der Werte
parallel ausgef@"uhrt.  Wenn @code{V} kein Atom ist, wird anstatt einer
Zuweisung eine Substitution ausgef@"uhrt.

@item
@code{F}, wobei @code{F} der Name einer Funktion ist, die als eine
Auswertungsfunktion (siehe @mref{evfun}) definiert wurde.  @code{F} bewirkt,
dass die Auswertungsfunktion auf den Ausdruck @var{expr} angewendet wird.

@item
Jeder andere Funktionsname (zum Beispiel @code{sum}) bewirkt, dass jedes
Auftreten dieser Funktion im Ausdruck @var{expr} ausgewertet wird.

@item
Zus@"atzlich kann f@"ur die Auswertung von @var{expr} eine lokale Funktion
@code{F(x) := expression} definiert werden.

@item
Wird ein Symbol, eine indizierte Variable oder ein indizierter Ausdruck, der
oben nicht genannt wurde, als Argument @"ubergeben, wird das Argument
ausgewertet.  Wenn das Ergebnis eine Gleichung oder eine Zuweisung ist, werden
die entsprechenden Zuweisungen und Substitutionen ausgef@"uhrt.  Wenn das
Ergebnis eine Liste ist, werden die Elemente der Liste als zus@"atzliche
Argumente von @code{ev} betrachtet.  Dies erlaubt, das eine Liste mit
Gleichungen (zum Beispiel @code{[%t1, %t2]}, wobei @code{%t1} und @code{%t2} 
Gleichungen sind) wie sie zum Beispiel von der Funktion @mref{solve} erzeugt
wird, als Argument verwendet werden kann.
@end itemize

Die Argumente der Funktion @code{ev} k@"onnen in einer beliebigen Reihenfolge
@"ubergeben werden.  Ausgenommen sind Gleichungen mit Substitutionen, die
nacheinander von links nach rechts ausgewertet werden, sowie
Auswertungsfunktionen, die verkettet werden.  So wird zum Beispiel
@code{ev(@var{expr}, ratsimp, realpart)} zu
@code{realpart(ratsimp(@var{expr}))}.

Die Schalter @mrefcomma{simp} @mrefcomma{numer} @mref{float} und 
@mref{detout} sind auch Optionsvariablen, die lokal in einem Block oder global
gesetzt werden k@"onnen.

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

@item
W@"ahrend des Schritts (1) wird eine Liste der nicht indizierten Variablen
erstellt, die auf der linken Seite von Gleichungen auftreten.  Die Gleichungen
k@"onnen 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@"asentieren.  Ist zum Beispiel @var{expr} eine Marke wie @code{%i2} im
Beispiel unten oder das letzte Ergebnis @code{%}, so wird in diesem Schritt der
globale Wert dieser Marke eingesetzt und die Bearbeitung durch @code{ev}
fortgesetzt.

@item
Wenn in den Argumenten Substitutionen aufgef@"uhrt sind, werden diese nun 
ausgef@"uhrt.

@item
Der resultierende Ausdruck wird erneut ausgewertet, au@ss{}er wenn @code{noeval} 
unter den Argumente ist, und vereinfacht.  Die Funktionsaufrufe in @var{expr} 
werden erst ausgef@"uhrt, wenn die enthaltenden Variablen ausgewertet sind.
Dadurch verh@"alt sich @code{ev(F(x))} wie @code{F(ev(x))}.

@item
F@"ur jedes Auftreten des Schalters @code{eval} in den Argumenten werden die 
Schritte (3) und (4) wiederholt.
@end enumerate

Anstatt der Anwendung der Funktion @code{ev} k@"onnen alternativ der Ausdruck
und die Argumente durch Kommata getrennt eingegeben werden:

@example
@var{expr}, @var{arg_1}, ..., @var{arg_n}
@end example

Diese Kurzschreibweise ist jedoch als Teil eines anderen Ausdrucks, zum Beispiel
in Funktionen oder Bl@"ocken nicht gestattet.

Beispiele:

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

Im folgenden Beispiel werden die Zuweisungen parallel durchgef@"uhrt.  Es wird
die Kurzschreibweise der Funktion @code{ev} angewendet.

@example
(%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
@group

                                          1
(%t7)                               y = - -
                                          5
@end group

                                         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
@end example
@end deffn

@c --- 07.03.2011 DK -----------------------------------------------------------
@anchor{eval}
@defvr {Auswertungsschalter} eval

Als Argument des Kommandos @code{ev(expr, eval)} bewirkt @code{eval} eine
zus@"atzliche Auswertung des Ausdrucks @code{expr}.

@code{eval} kann mehrfach auftreten.  Jedes Auftreten f@"uhrt zu einer
zus@"atzlichen Auswertung.

Siehe auch die Funktion @mref{ev} sowie die Auswertungsschalter
@mref{noeval} und @mref{infeval}

Beispiele:

@example
(%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
@end example
@end defvr

@c --- 07.03.2011 DK -----------------------------------------------------------
@anchor{evflag}
@defvr {Eigenschaft} evflag

Wenn ein Symbol @var{x} die Eigenschaft eines Auswertungsschalters besitzt, sind
die Ausdr@"ucke @code{ev(@var{expr}, @var{x})} und @code{@var{expr}, @var{x}}@ 
@"aquivalent zu @code{ev(@var{expr}, @var{x} = true)}.  W@"ahrend der Auswertung
von @var{expr} erh@"alt also @var{x} den Wert @code{true}.

Mit @code{declare(@var{x}, evflag)} wird der Variablen @var{x} die
@code{evflag}-Eigenschaft gegeben.  Siehe auch die Funktion
@mrefdot{declare}  Mit @mref{kill} oder @mref{remove} kann diese Eigenschaft
wieder entfernt werden.  Siehe auch @mref{properties} f@"ur die Anzeige von
Eigenschaften.

Folgende Optionsvariablen haben bereits die @code{evflag}-Eigenschaft:

@verbatim
   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
@end verbatim

Beispiele:

@example
(%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
@group
(%i8) sum (1/k^2, k, 1, inf);
                            inf
                            ====
                            \     1
(%o8)                        >    --
                            /      2
                            ====  k
                            k = 1
@end group
(%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
@end example
@end defvr

@c --- 07.03.2011 DK -----------------------------------------------------------
@anchor{evfun}
@defvr {Eigenschaft} evfun

Wenn eine Funktion @var{F} die Eigenschaft @code{evfun} besitzt, sind die 
Ausdr@"ucke @code{ev(@var{expr}, @var{F})} und @code{@var{expr}, @var{F}}@ 
@"aquivalent zu @code{@var{F}(ev(@var{expr}))}.

Zwei oder mehr @code{evfun}-Funktionen @var{F}, @var{G}, @dots{} werden in der 
aufgef@"uhrten Reihenfolge auf den Ausdruck @var{expr} angewendet.

Mit @code{declare(@var{F}, evfun)} wird der Funktion @var{F} die
@code{evfun}-Eigenschaft gegeben.  Siehe auch die Funktion @mrefdot{declare}@w{}
Mit @mref{kill} oder @mref{remove} kann diese Eigenschaft wieder entfernt
werden.  Siehe auch @mref{properties} f@"ur die Anzeige von Eigenschaften.

Funktionen, die bereits die @code{evfun}-Eigenschaft besitzen, sind:

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

Beispiele:

@example
(%i1) x^3 - 1;
                              3
(%o1)                        x  - 1
(%i2) x^3 - 1, factor;
@group
                                2
(%o2)                 (x - 1) (x  + x + 1)
@end group
(%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;
@group
                           2         4
                      6 cos (x)   cos (x)
(%o6)               - --------- + ------- + 1
                          2          4
                       sin (x)    sin (x)
@end group
(%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))
@end example
@end defvr

@c --- 07.03.2011 DK -----------------------------------------------------------
@anchor{infeval}
@need 800
@defvr {Optionsvariable} infeval
Standardwert: @code{false}

@code{infeval} bewirkt, dass die Funktion @mref{ev} die Auswertung eines
Ausdrucks solange wiederholt, bis dieser sich nicht mehr @"andert.  Um zu
verhindern, dass eine Variable in diesem Modus durch die Auswertung
verschwindet, kann zum Beispiel f@"ur eine Variable @code{x} der Ausdruck
@code{x='x} als Argument von @code{ev} einf@"ugt werden.  Ausdr@"ucke wie
@code{ev(x, x=x+1, infeval)} f@"uhren in diesem Modus zu Endlosschleifen.

Siehe auch die Auswertungsschalter @mref{noeval} und @mrefdot{eval}
@end defvr

@c --- 07.03.2011 DK -----------------------------------------------------------
@anchor{noeval}
@defvr {Auswertungsschalter} noeval

@code{noeval} unterdr@"uckt die Auswertungsphase der Funktion @mrefdot{ev}@w{}
Der Schalter kann im Zusammenhang mit anderen Auswertungsschaltern genutzt
werden, um einen Ausdruck erneut zu vereinfachen, ohne diesen auszuwerten.

Siehe auch die Optionsvariable @mref{infeval} und den Auswertungsschalter
@mrefdot{eval}
@end defvr

@c --- 07.03.2011 DK -----------------------------------------------------------
@anchor{nouns}
@defvr {Auswertungsschalter} nouns

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

Siehe auch die Eigenschaft @mref{noun} und die Funktionen @mref{nounify} und
@mrefdot{verbify}
@end defvr

@c --- 07.03.2011 DK -----------------------------------------------------------
@anchor{pred}
@defvr {Auswertungsschalter} pred

Wird @code{pred} als ein Argument der Funktion @code{ev} eingesetzt, werden
Aussagen zu @code{true} oder @code{false} ausgewertet.  Siehe die Funktion
@mrefdot{ev}

Beispiel:

@example
(%i1) 1 < 2;
(%o1)                                1 < 2
(%i2) 1 < 2,pred;
(%o2)                                true
@end example
@end defvr

@c --- End of file Evaluation.de.texi ------------------------------------------

