| blob | 312f0eaed5e654dccca783dafa8df5be72170de7 |
1 @c -----------------------------------------------------------------------------
2 @c File : Evaluation.de.texi
3 @c License : GNU General Public License (GPL)
4 @c Language : German
5 @c Original : Evaluation.texi revision 01.08.2011
6 @c Translation : Dr. Dieter Kaiser
7 @c Date : 17.10.2010
8 @c Revision : 01.11.2011
9 @c
10 @c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA
11 @c -----------------------------------------------------------------------------
13 @menu
14 * Einf@"uhrung in die Auswertung::
15 * Funktionen und Variablen f@"ur die Auswertung::
16 @end menu
18 @c -----------------------------------------------------------------------------
19 @node Einf@"uhrung in die Auswertung, Funktionen und Variablen f@"ur die Auswertung, Auswertung, Auswertung
20 @section Einf@"uhrung in die Auswertung
21 @c -----------------------------------------------------------------------------
23 In @ref{Einf@"uhrung in die Kommandozeile} sind die vier Phasen der Eingabe,
24 Auswertung, Vereinfachung und Ausgabe erl@"autert, die jede Eingabe des Nutzers
25 bis zur Ausgabe auf der Konsole durchl@"auft.
27 Jede Eingabe eines Ausdrucks @var{expr} wird von Maxima ausgewertet. Symbole,
28 die keinen Wert haben, und Zahlen werden zu sich selbst ausgewertet. Symbole,
29 die einen Wert haben, werden durch ihren Wert ersetzt.
31 Beispiele:
33 Im ersten Beispiel werden Symbole und Zahlen zu sich selbst ausgewertet. Im
34 zweiten Beispiel erh@"alt die Variable @code{a} den Wert @code{2}. In den
35 folgenden Ausdr@"ucken wird die Variable @code{a} ausgewertet und durch ihren
36 Wert ersetzt.
38 @example
39 (%i1) [a, b, 2, 1/2, 1.0];
40 1
41 (%o1) [a, b, 2, -, 1.0]
42 2
43 (%i2) a:2$
45 (%i3) [a, sin(a), a^2];
46 (%o3) [2, sin(2), 4]
47 @end example
49 Maxima unterscheidet Funktionen in einer Verbform von Funktionen in einer
50 Substantivform. Funktionen in einer Verbform werden ausgewertet, indem die
51 Funktion auf die ausgewerteten Argumente angewendet wird. Im Gegensatz dazu
52 werden Funktionen in einer Substantivform nicht auf die Argumente angewendet,
53 jedoch werden die Argumente weiterhin ausgewertet. Funktionen k@"onnen in
54 beiden Formen auftreten. Typische Beispiele sind die Differentiation mit der
55 Funktion @mref{diff} oder die Integration mit der Funktion @mrefdot{integrate}
56 Siehe zum diesem Thema auch @ref{Substantive und Verben}.
58 Beispiele:
60 Die Variable @code{a} erh@"alt einen Wert. Im ersten Fall liegt die Funktion
61 @code{diff} in ihrer Verbform vor. Die Auswertung bewirkt, dass die Funktion
62 auf die Argumente @code{a*x^2} und @var{x} angewendet wird. Im zweiten Fall
63 liegt die Funktion @code{diff} in ihrer Substantivform vor. Dies wird hier
64 durch den @mxref{', Quote-Operator} @code{'} bewirkt. Jetzt wird die Funktion
65 nicht angewendet. Das Ergebnis ist ein symbolischer Ausdruck f@"ur die
66 Ableitung. Da auch in diesem Fall die Argumente ausgewertet werden, wird auch
67 hier der Wert @code{1/2} f@"ur die Variable @code{a} eingesetzt.
69 @example
70 (%i1) a:1/2;
71 1
72 (%o1) -
73 2
74 (%i2) diff(a*x^2, x);
75 (%o2) x
76 (%i3) 'diff(a*x^2, x);
77 @group
78 2
79 d x
80 (%o3) -- (--)
81 dx 2
82 @end group
83 @end example
85 Nicht alle Maxima-Funktionen werten die Argumente aus. Die Dokumentation der
86 Funktionen gibt h@"aufig einen Hinweis darauf, ob die Argumente ausgewertet
87 werden oder nicht.
89 Beispiel:
91 Die Funktion @mref{properties} wertet das Argument nicht aus. Dies ist f@"ur
92 den Nutzer praktisch, da ansonsten die Auswertung einer Variablen @code{a}, die
93 einen Wert hat, explizit mit dem Quote-Operator @code{'} unterdr@"uckt werden
94 m@"usste, um die Eigenschaften des Symbols @code{'a} anzuzeigen. Im ersten Fall
95 ist das Ergebnis eine leere Liste. Das Symbol @code{a} hat keine Eigenschaften.
96 Im zweiten Fall erh@"alt die Variable @code{a} einen Wert. Die Funktion
97 @code{properties} wertet ihr Argument nicht aus und @code{a} wird nicht durch
98 den Wert @code{2} ersetzt. Die Funktion @code{properties} zeigt weiterhin die
99 Eigenschaften des Symbols @code{'a} an.
101 @example
102 (%i1) properties(a);
103 (%o1) []
104 (%i2) a:2$
106 (%i3) properties(a);
107 (%o3) [value]
108 @end example
110 Die Auswertung von Symbolen, Funktionen und Ausdr@"ucken kann mit dem
111 @nxref{', Quote-Operator} @code{'} und dem @nxref{'', Quote-Quote-Operator}@w{}
112 @code{''} kontrolliert werden. Der Quote-Operator unterdr@"uckt die Auswertung.
113 Dagegen erzwingt der Quote-Quote-Operator die Auswertung.
115 Mit der Funktion @mref{ev} wird ein Ausdruck in einer definierten Umgebung
116 ausgewertet, in der Optionsvariablen f@"ur die Auswertung einen bestimmten Wert
117 erhalten oder Auswertungsschalter @mref{evflag} und Auswertungsfunktionen
118 @mref{evfun} angewendet werden.
120 @c -----------------------------------------------------------------------------
121 @node Funktionen und Variablen f@"ur die Auswertung, , Einf@"uhrung in die Auswertung, Auswertung
122 @section Funktionen und Variablen f@"ur die Auswertung
123 @c -----------------------------------------------------------------------------
125 @c --- 07.03.2011 DK -----------------------------------------------------------
126 @anchor{'}
127 @findex Quote-Operator
128 @deffn {Operator} '
130 Der Quote-Operator @code{'} unterdr@"uckt die Auswertung eines Symbols oder
131 Ausdrucks. Auf eine Funktion angewendet, unterdr@"uckt der Quote-Operator die
132 Auswertung der Funktion. Die Auswertung der Argumente der Funktion wird nicht
133 unterdr@"uckt. Das Ergebnis ist die Substantivform der Funktion.
135 Wird der Quote-Operator auf einen eingeklammerten Ausdruck angewendet, wird die
136 Auswertung aller Symbole und Funktionen innerhalb der Klammern unterdr@"uckt.
137 @code{'(f(x))} bedeutet, dass der Ausdruck @code{f(x)} nicht ausgewertet werden
138 soll. @code{'f(x)} bedeutet, dass die Substantivform von @code{f} auf das
139 ausgewertete Argument @var{x} angewendet wird.
141 Der Quote-Operator unterdr@"uckt die Auswertung, aber nicht die Vereinfachung
142 von Ausdr@"ucken.
144 Substantivformen werden mit einem Hochkomma angezeigt, wenn die Optionsvariable
145 @mref{noundisp} den Wert @code{true} hat.
147 Siehe auch den @nxref{'', Quote-Quote-Operator} @code{'@w{}'} und den
148 Auswertungsschalter @mrefdot{nouns}
150 Beispiele:
152 Auf ein Symbol angewendet, unterdr@"uckt der Quote-Operator die Auswertung des
153 Symbols.
155 @example
156 (%i1) aa: 1024;
157 (%o1) 1024
158 @group
159 (%i2) aa^2;
160 (%o2) 1048576
161 @end group
162 (%i3) 'aa^2;
163 2
164 (%o3) aa
165 (%i4) ''%;
166 (%o4) 1048576
167 @end example
169 Auf eine Funktion angewendet, unterdr@"uckt der Quote-Operator die Auswertung
170 der Funktion. Das Ergebnis ist die Substantivform der Funktion.
172 @example
173 (%i1) x0: 5;
174 (%o1) 5
175 (%i2) x1: 7;
176 (%o2) 7
177 @group
178 (%i3) integrate (x^2, x, x0, x1);
179 218
180 (%o3) ---
181 3
182 @end group
183 (%i4) 'integrate (x^2, x, x0, x1);
184 @group
185 7
186 /
187 [ 2
188 (%o4) I x dx
189 ]
190 /
191 5
192 @end group
193 (%i5) %, nouns;
194 218
195 (%o5) ---
196 3
197 @end example
199 Wird der Quote-Operator auf einen eingeklammerten Ausdruck angewendet, wird die
200 Auswertung aller Symbole und Funktionen innerhalb der Klammern unterdr@"uckt.
202 @example
203 (%i1) aa: 1024;
204 (%o1) 1024
205 (%i2) bb: 19;
206 (%o2) 19
207 (%i3) sqrt(aa) + bb;
208 (%o3) 51
209 (%i4) '(sqrt(aa) + bb);
210 (%o4) bb + sqrt(aa)
211 (%i5) ''%;
212 (%o5) 51
213 @end example
215 Der Quote-Operator unterdr@"uckt nicht die Vereinfachung von Ausdr@"ucken.
217 @example
218 (%i1) sin (17 * %pi) + cos (17 * %pi);
219 (%o1) - 1
220 (%i2) '(sin (17 * %pi) + cos (17 * %pi));
221 (%o2) - 1
222 @end example
224 Gleitkommarechnungen sind eine Vereinfachung und keine Auswertung. Daher kann
225 die Berechnung von @code{sin(1.0)} nicht mit dem Quote-Operator unterdr@"uckt
226 werden.
228 @example
229 (%i1) sin(1.0);
230 (%o1) .8414709848078965
231 (%i2) '(sin(1.0));
232 (%o2) .8414709848078965
233 @end example
234 @end deffn
236 @c --- 07.03.2011 DK -----------------------------------------------------------
237 @anchor{''}
238 @findex Quote-Quote-Operator
239 @deffn {Operator} ''
241 Der Quote-Quote-Operator @code{'@w{}'} (zwei Hochkommata) modifiziert die
242 Auswertung von Ausdr@"ucken, die von der Eingabe gelesen werden.
244 Wird der Quote-Quote-Operator auf einen allgemeinen Ausdruck @var{expr}
245 angewendet, wird der Ausdruck @var{expr} durch seinen Wert ersetzt.
247 Wird der Quote-Quote-Operator auf den Operator eines Ausdruckes angewendet,
248 @"andert sich der Operator, wenn er in seiner Substantivform vorliegt, in die
249 Verbform.
251 Der Quote-Quote-Operator wird vom Parser, der die Eingabe liest, sofort
252 angewendet und nicht im eingelesen Ausdruck gespeichert. Daher kann die
253 Auswertung des Quote-Quote-Operators nicht durch einen weiteren Quote-Operator
254 verhindert werden. Der Quote-Quote-Operator f@"uhrt zur Auswertung von
255 Ausdr@"ucken, deren Auswertung unterdr@"uckt ist. Das ist der Fall f@"ur
256 Funktionsdefinitionen, Lambda-Ausdr@"ucke und Ausdr@"ucke, deren Auswertung
257 durch den Quote-Operator verhindert wurde.
259 Der Quote-Quote-Operator wird von den Befehlen @mref{batch} und
260 @mref{load} erkannt.
262 Siehe auch den @nxref{', Quote-Operator} @code{'} und den Auswertungsschalter
263 @mrefdot{nouns}
265 Beispiele:
267 Wird der Quote-Quote-Operator auf einen Ausdruck @var{expr} angewendet, wird
268 der Wert von @var{expr} in den Ausdruck eingesetzt.
270 @example
271 (%i1) expand ((a + b)^3);
272 3 2 2 3
273 (%o1) b + 3 a b + 3 a b + a
274 (%i2) [_, ''_];
275 3 3 2 2 3
276 (%o2) [expand((b + a) ), b + 3 a b + 3 a b + a ]
277 (%i3) [%i1, ''%i1];
278 3 3 2 2 3
279 (%o3) [expand((b + a) ), b + 3 a b + 3 a b + a ]
280 (%i4) [aa : cc, bb : dd, cc : 17, dd : 29];
281 (%o4) [cc, dd, 17, 29]
282 (%i5) foo_1 (x) := aa - bb * x;
283 (%o5) foo_1(x) := aa - bb x
284 (%i6) foo_1 (10);
285 (%o6) cc - 10 dd
286 (%i7) ''%;
287 (%o7) - 273
288 (%i8) ''(foo_1 (10));
289 (%o8) - 273
290 @group
291 (%i9) foo_2 (x) := ''aa - ''bb * x;
292 (%o9) foo_2(x) := cc - dd x
293 @end group
294 (%i10) foo_2 (10);
295 (%o10) - 273
296 (%i11) [x0 : x1, x1 : x2, x2 : x3];
297 (%o11) [x1, x2, x3]
298 (%i12) x0;
299 (%o12) x1
300 (%i13) ''x0;
301 (%o13) x2
302 (%i14) '' ''x0;
303 (%o14) x3
304 @end example
306 Wird der Quote-Quote-Operator auf den Operator in einem Ausdruck angewendet,
307 @"andert sich der Operator von seiner Substantivform in die Verbform.
309 @example
310 (%i1) declare (foo, noun);
311 (%o1) done
312 (%i2) foo (x) := x - 1729;
313 (%o2) ''foo(x) := x - 1729
314 (%i3) foo (100);
315 (%o3) foo(100)
316 (%i4) ''foo (100);
317 (%o4) - 1629
318 @end example
320 Der Quote-Quote-Operator wird vom Parser sofort auf den eingelesenen Ausdruck
321 angewendet und ist nicht Teil eines Maxima-Ausdrucks.
323 @example
324 (%i1) [aa : bb, cc : dd, bb : 1234, dd : 5678];
325 (%o1) [bb, dd, 1234, 5678]
326 (%i2) aa + cc;
327 (%o2) dd + bb
328 (%i3) display (_, op (_), args (_));
329 _ = cc + aa
331 op(cc + aa) = +
333 args(cc + aa) = [cc, aa]
335 (%o3) done
336 (%i4) ''(aa + cc);
337 (%o4) 6912
338 (%i5) display (_, op (_), args (_));
339 @group
340 _ = dd + bb
342 op(dd + bb) = +
344 args(dd + bb) = [dd, bb]
345 @end group
346 (%o5) done
347 @end example
349 Der Quote-Quote-Operator bewirkt die Auswertung von Ausdr@"ucken, deren
350 Auswertung unterdr@"uckt ist wie in Funktionsdefinitionen, Lambda-Ausdr@"ucken
351 und Aus@-dr@"u@-cken, auf die der Quote-Operator angewendet wurde.
353 @example
354 (%i1) foo_1a (x) := ''(integrate (log (x), x));
355 (%o1) foo_1a(x) := x log(x) - x
356 (%i2) foo_1b (x) := integrate (log (x), x);
357 (%o2) foo_1b(x) := integrate(log(x), x)
358 (%i3) dispfun (foo_1a, foo_1b);
359 (%t3) foo_1a(x) := x log(x) - x
361 (%t4) foo_1b(x) := integrate(log(x), x)
363 (%o4) [%t3, %t4]
364 (%i5) integrate (log (x), x);
365 (%o5) x log(x) - x
366 (%i6) foo_2a (x) := ''%;
367 (%o6) foo_2a(x) := x log(x) - x
368 (%i7) foo_2b (x) := %;
369 (%o7) foo_2b(x) := %
370 (%i8) dispfun (foo_2a, foo_2b);
371 (%t8) foo_2a(x) := x log(x) - x
373 (%t9) foo_2b(x) := %
375 (%o9) [%t8, %t9]
376 (%i10) F : lambda ([u], diff (sin (u), u));
377 (%o10) lambda([u], diff(sin(u), u))
378 (%i11) G : lambda ([u], ''(diff (sin (u), u)));
379 (%o11) lambda([u], cos(u))
380 (%i12) '(sum (a[k], k, 1, 3) + sum (b[k], k, 1, 3));
381 (%o12) sum(b , k, 1, 3) + sum(a , k, 1, 3)
382 k k
383 (%i13) '(''(sum (a[k], k, 1, 3)) + ''(sum (b[k], k, 1, 3)));
384 (%o13) b + a + b + a + b + a
385 3 3 2 2 1 1
386 @end example
387 @end deffn
389 @c --- 07.03.2011 DK -----------------------------------------------------------
390 @anchor{ev}
391 @deffn {Funktion} ev (@var{expr}, @var{arg_1}, @dots{}, @var{arg_n})
393 Wertet den Ausdruck @var{expr} in einer Umgebung aus, die durch die Argumente
394 @var{arg_1}, @dots{}, @var{arg_n} spezifiziert wird. Die Argumente sind
395 Optionsvariablen (Boolesche Variablen), Zuweisungen, Gleichungen und Funktionen.
396 @code{ev} gibt das Ergebnis der Auswertung zur@"uck.
398 Die Auswertung wird in den folgenden Schritten durchgef@"uhrt:
400 @enumerate
401 @item
402 Zuerst wird die Umgebung gesetzt. Dazu werden die Argumente @var{arg_1},
403 @dots{}, @var{arg_n} ausgewertet. Folgende Argumente sind m@"oglich:
405 @itemize @bullet
406 @item
407 @code{simp} bewirkt, dass der Ausdruck @var{expr} vereinfacht wird. Der Wert
408 der Optionsvariablen @mref{simp} wird dabei ignoriert. Der Ausdruck wird also
409 auch dann vereinfacht, wenn die Optionsvariable @var{simp} den Wert @code{false}
410 hat.
412 @item
413 @code{noeval} unterdr@"uckt die Auswertungphase der Funktion @code{ev} (siehe
414 Schritt (4) unten). Dies ist n@"utzlich im Zusammenhang mit anderen Schaltern
415 und um einen Ausdruck @var{expr} erneuert zu vereinfachen, ohne dass dieser
416 ausgewertet wird.
418 @item
419 @code{nouns} bewirkt die Auswertung von Substantivformen. Solche
420 Substantivformen sind typischerweise nicht ausgewertete Funktionen wie
421 @code{'integrate} oder @code{'diff}, die im Ausdruck @var{expr} enthalten sind.
423 @item
424 @code{expand} bewirkt die Expansion des Ausdruckes @var{expr}. Siehe die
425 Funktion @mrefdot{expand}
427 @item
428 @code{expand}(@var{m}, @var{n}) bewirkt die Expansion des Ausdruckes @var{expr},
429 wobei den Optionsvariablen @mref{maxposex} und @mref{maxnegex} die Werte der
430 Argumente @var{m} und @var{n} zugewiesen werden. Siehe die Funktion
431 @mrefdot{expand}
433 @item
434 @code{detout} bewirkt, dass bei der Berechnung von Inversen von Matrizen, die im
435 Ausdruck @var{expr} enthalten sind, Determinanten den Matrizen vorangestellt
436 und nicht elementweise in die Matrize hereinmultipliziert werden.
438 @item
439 @code{diff} bewirkt, dass alle Ableitungen ausgef@"uhrt werden, die im Ausdruck
440 @var{expr} enthalten sind.
442 @item
443 @code{derivlist(@var{x}, @var{y}, @var{z}, ...)} bewirkt, dass die Ableitungen
444 bez@"uglich der angegebenen Variablen @var{x}, @var{y}, @var{z}, @dots{}
445 ausgef@"uhrt werden.
447 @item
448 @code{risch} bewirkt das Integrale im Ausdruck @var{expr} mit dem
449 Risch-Algorithmus berechnet werden. Siehe @code{risch}. Wird der Schalter
450 @mref{nouns} benutzt, wird der Standardalgorithmus f@"ur Integrale verwendet.
452 @item
453 @code{float} bewirkt, dass rationale Zahlen in Gleitkommazahlen konvertiert
454 werden.
456 @item
457 @code{numer} bewirkt, dass mathematische Funktionen mit numerischen Argumenten
458 ein Ergebnis in Gleitkommazahlen liefern. Variablen in @code{expr}, denen
459 numerische Werte zugewiesen wurden, werden durch diese ersetzt. Der Schalter
460 @mref{float} wird zus@"atzlich wirksam.
462 @item
463 @code{pred} bewirkt, dass Aussagen zu @code{true} oder @code{false} ausgewertet
464 werden.
466 @item
467 @code{eval} bewirkt eine zus@"atzliche Auswertung des Ausdrucks @var{expr}.
468 (Siehe Schritt (5) unten). @code{eval} kann mehrfach angewendet werden. Jedes
469 Auftreten von @code{eval} f@"uhrt zu einer weiteren Auswertung.
471 @item
472 @code{A}, wobei @code{A} ein Symbol ist, das als ein Auswertungsschalter
473 @mref{evflag} definiert ist. W@"ahrend der Auswertung des Ausdrucks @var{expr}
474 erh@"alt @code{A} den Wert @code{true}.
476 @item
477 @code{V: expression} (oder alternativ @code{V=expression}) bewirkt, dass
478 @code{V} w@"ahrend der Auswertung des Ausdrucks @var{expr} den Wert
479 @code{expression} erh@"alt. @code{V} kann auch eine Optionsvariable sein, die
480 f@"ur die Auswertung den Wert @code{expression} erh@"alt. Wenn mehr als ein
481 Argument der Funktion @code{ev} @"ubergeben wird, wird die Zuweisung der Werte
482 parallel ausgef@"uhrt. Wenn @code{V} kein Atom ist, wird anstatt einer
483 Zuweisung eine Substitution ausgef@"uhrt.
485 @item
486 @code{F}, wobei @code{F} der Name einer Funktion ist, die als eine
487 Auswertungsfunktion (siehe @mref{evfun}) definiert wurde. @code{F} bewirkt,
488 dass die Auswertungsfunktion auf den Ausdruck @var{expr} angewendet wird.
490 @item
491 Jeder andere Funktionsname (zum Beispiel @code{sum}) bewirkt, dass jedes
492 Auftreten dieser Funktion im Ausdruck @var{expr} ausgewertet wird.
494 @item
495 Zus@"atzlich kann f@"ur die Auswertung von @var{expr} eine lokale Funktion
496 @code{F(x) := expression} definiert werden.
498 @item
499 Wird ein Symbol, eine indizierte Variable oder ein indizierter Ausdruck, der
500 oben nicht genannt wurde, als Argument @"ubergeben, wird das Argument
501 ausgewertet. Wenn das Ergebnis eine Gleichung oder eine Zuweisung ist, werden
502 die entsprechenden Zuweisungen und Substitutionen ausgef@"uhrt. Wenn das
503 Ergebnis eine Liste ist, werden die Elemente der Liste als zus@"atzliche
504 Argumente von @code{ev} betrachtet. Dies erlaubt, das eine Liste mit
505 Gleichungen (zum Beispiel @code{[%t1, %t2]}, wobei @code{%t1} und @code{%t2}
506 Gleichungen sind) wie sie zum Beispiel von der Funktion @mref{solve} erzeugt
507 wird, als Argument verwendet werden kann.
508 @end itemize
510 Die Argumente der Funktion @code{ev} k@"onnen in einer beliebigen Reihenfolge
511 @"ubergeben werden. Ausgenommen sind Gleichungen mit Substitutionen, die
512 nacheinander von links nach rechts ausgewertet werden, sowie
513 Auswertungsfunktionen, die verkettet werden. So wird zum Beispiel
514 @code{ev(@var{expr}, ratsimp, realpart)} zu
515 @code{realpart(ratsimp(@var{expr}))}.
517 Die Schalter @mrefcomma{simp} @mrefcomma{numer} @mref{float} und
518 @mref{detout} sind auch Optionsvariablen, die lokal in einem Block oder global
519 gesetzt werden k@"onnen.
521 Ist @var{expr} ein kanonischer rationaler Ausdruck (CRE = canonical rational
522 expression), ist auch das Ergebnis der Funktion @code{ev} ein CRE-Ausdruck,
523 falls nicht die beiden Schalter @code{float} und @code{numer} den Wert
524 @code{true} haben.
526 @item
527 W@"ahrend des Schritts (1) wird eine Liste der nicht indizierten Variablen
528 erstellt, die auf der linken Seite von Gleichungen auftreten. Die Gleichungen
529 k@"onnen dabei entweder als Argument oder als Wert eines Argumentes vorliegen.
530 Variablen, die nicht in dieser Liste enthalten sind, werden durch ihre globalen
531 Werte ersetzt. Davon ausgenommen sind Variablen, die eine Array-Funktion
532 repr@"asentieren. Ist zum Beispiel @var{expr} eine Marke wie @code{%i2} im
533 Beispiel unten oder das letzte Ergebnis @code{%}, so wird in diesem Schritt der
534 globale Wert dieser Marke eingesetzt und die Bearbeitung durch @code{ev}
535 fortgesetzt.
537 @item
538 Wenn in den Argumenten Substitutionen aufgef@"uhrt sind, werden diese nun
539 ausgef@"uhrt.
541 @item
542 Der resultierende Ausdruck wird erneut ausgewertet, au@ss{}er wenn @code{noeval}
543 unter den Argumente ist, und vereinfacht. Die Funktionsaufrufe in @var{expr}
544 werden erst ausgef@"uhrt, wenn die enthaltenden Variablen ausgewertet sind.
545 Dadurch verh@"alt sich @code{ev(F(x))} wie @code{F(ev(x))}.
547 @item
548 F@"ur jedes Auftreten des Schalters @code{eval} in den Argumenten werden die
549 Schritte (3) und (4) wiederholt.
550 @end enumerate
552 Anstatt der Anwendung der Funktion @code{ev} k@"onnen alternativ der Ausdruck
553 und die Argumente durch Kommata getrennt eingegeben werden:
555 @example
556 @var{expr}, @var{arg_1}, ..., @var{arg_n}
557 @end example
559 Diese Kurzschreibweise ist jedoch als Teil eines anderen Ausdrucks, zum Beispiel
560 in Funktionen oder Bl@"ocken nicht gestattet.
562 Beispiele:
564 @example
565 @group
566 (%i1) sin(x) + cos(y) + (w+1)^2 + 'diff (sin(w), w);
567 d 2
568 (%o1) cos(y) + sin(x) + -- (sin(w)) + (w + 1)
569 dw
570 @end group
571 (%i2) ev (%, numer, expand, diff, x=2, y=1);
572 2
573 (%o2) cos(w) + w + 2 w + 2.449599732693821
574 @end example
576 Im folgenden Beispiel werden die Zuweisungen parallel durchgef@"uhrt. Es wird
577 die Kurzschreibweise der Funktion @code{ev} angewendet.
579 @example
580 (%i3) programmode: false;
581 (%o3) false
582 (%i4) x+y, x: a+y, y: 2;
583 (%o4) y + a + 2
584 (%i5) 2*x - 3*y = 3$
585 (%i6) -3*x + 2*y = -4$
586 (%i7) solve ([%o5, %o6]);
587 Solution
588 @group
590 1
591 (%t7) y = - -
592 5
593 @end group
595 6
596 (%t8) x = -
597 5
598 (%o8) [[%t7, %t8]]
599 (%i8) %o6, %o8;
600 (%o8) - 4 = - 4
601 (%i9) x + 1/x > gamma (1/2);
602 1
603 (%o9) x + - > sqrt(%pi)
604 x
605 (%i10) %, numer, x=1/2;
606 (%o10) 2.5 > 1.772453850905516
607 (%i11) %, pred;
608 (%o11) true
609 @end example
610 @end deffn
612 @c --- 07.03.2011 DK -----------------------------------------------------------
613 @anchor{eval}
614 @defvr {Auswertungsschalter} eval
616 Als Argument des Kommandos @code{ev(expr, eval)} bewirkt @code{eval} eine
617 zus@"atzliche Auswertung des Ausdrucks @code{expr}.
619 @code{eval} kann mehrfach auftreten. Jedes Auftreten f@"uhrt zu einer
620 zus@"atzlichen Auswertung.
622 Siehe auch die Funktion @mref{ev} sowie die Auswertungsschalter
623 @mref{noeval} und @mref{infeval}
625 Beispiele:
627 @example
628 (%i1) [a:b,b:c,c:d,d:e];
629 (%o1) [b, c, d, e]
630 (%i2) a;
631 (%o2) b
632 (%i3) ev(a);
633 (%o3) c
634 (%i4) ev(a),eval;
635 (%o4) e
636 (%i5) a,eval,eval;
637 (%o5) e
638 @end example
639 @end defvr
641 @c --- 07.03.2011 DK -----------------------------------------------------------
642 @anchor{evflag}
643 @defvr {Eigenschaft} evflag
645 Wenn ein Symbol @var{x} die Eigenschaft eines Auswertungsschalters besitzt, sind
646 die Ausdr@"ucke @code{ev(@var{expr}, @var{x})} und @code{@var{expr}, @var{x}}@
647 @"aquivalent zu @code{ev(@var{expr}, @var{x} = true)}. W@"ahrend der Auswertung
648 von @var{expr} erh@"alt also @var{x} den Wert @code{true}.
650 Mit @code{declare(@var{x}, evflag)} wird der Variablen @var{x} die
651 @code{evflag}-Eigenschaft gegeben. Siehe auch die Funktion
652 @mrefdot{declare} Mit @mref{kill} oder @mref{remove} kann diese Eigenschaft
653 wieder entfernt werden. Siehe auch @mref{properties} f@"ur die Anzeige von
654 Eigenschaften.
656 Folgende Optionsvariablen haben bereits die @code{evflag}-Eigenschaft:
658 @verbatim
659 algebraic cauchysum demoivre
660 dotscrules %emode %enumer
661 exponentialize exptisolate factorflag
662 float halfangles infeval
663 isolate_wrt_times keepfloat letrat
664 listarith logabs logarc
665 logexpand lognegint
666 m1pbranch numer_pbranch programmode
667 radexpand ratalgdenom ratfac
668 ratmx ratsimpexpons simp
669 simpproduct simpsum sumexpand
670 trigexpand
671 @end verbatim
673 Beispiele:
675 @example
676 (%i1) sin (1/2);
677 1
678 (%o1) sin(-)
679 2
680 (%i2) sin (1/2), float;
681 (%o2) 0.479425538604203
682 (%i3) sin (1/2), float=true;
683 (%o3) 0.479425538604203
684 (%i4) simp : false;
685 (%o4) false
686 (%i5) 1 + 1;
687 (%o5) 1 + 1
688 (%i6) 1 + 1, simp;
689 (%o6) 2
690 (%i7) simp : true;
691 (%o7) true
692 @group
693 (%i8) sum (1/k^2, k, 1, inf);
694 inf
695 ====
696 \ 1
697 (%o8) > --
698 / 2
699 ==== k
700 k = 1
701 @end group
702 (%i9) sum (1/k^2, k, 1, inf), simpsum;
703 2
704 %pi
705 (%o9) ----
706 6
707 (%i10) declare (aa, evflag);
708 (%o10) done
709 (%i11) if aa = true then YES else NO;
710 (%o11) NO
711 (%i12) if aa = true then YES else NO, aa;
712 (%o12) YES
713 @end example
714 @end defvr
716 @c --- 07.03.2011 DK -----------------------------------------------------------
717 @anchor{evfun}
718 @defvr {Eigenschaft} evfun
720 Wenn eine Funktion @var{F} die Eigenschaft @code{evfun} besitzt, sind die
721 Ausdr@"ucke @code{ev(@var{expr}, @var{F})} und @code{@var{expr}, @var{F}}@
722 @"aquivalent zu @code{@var{F}(ev(@var{expr}))}.
724 Zwei oder mehr @code{evfun}-Funktionen @var{F}, @var{G}, @dots{} werden in der
725 aufgef@"uhrten Reihenfolge auf den Ausdruck @var{expr} angewendet.
727 Mit @code{declare(@var{F}, evfun)} wird der Funktion @var{F} die
728 @code{evfun}-Eigenschaft gegeben. Siehe auch die Funktion @mrefdot{declare}@w{}
729 Mit @mref{kill} oder @mref{remove} kann diese Eigenschaft wieder entfernt
730 werden. Siehe auch @mref{properties} f@"ur die Anzeige von Eigenschaften.
732 Funktionen, die bereits die @code{evfun}-Eigenschaft besitzen, sind:
734 @verbatim
735 bfloat factor fullratsimp
736 logcontract polarform radcan
737 ratexpand ratsimp rectform
738 rootscontract trigexpand trigreduce
739 @end verbatim
741 Beispiele:
743 @example
744 (%i1) x^3 - 1;
745 3
746 (%o1) x - 1
747 (%i2) x^3 - 1, factor;
748 @group
749 2
750 (%o2) (x - 1) (x + x + 1)
751 @end group
752 (%i3) factor (x^3 - 1);
753 2
754 (%o3) (x - 1) (x + x + 1)
755 (%i4) cos(4 * x) / sin(x)^4;
756 cos(4 x)
757 (%o4) --------
758 4
759 sin (x)
760 (%i5) cos(4 * x) / sin(x)^4, trigexpand;
761 4 2 2 4
762 sin (x) - 6 cos (x) sin (x) + cos (x)
763 (%o5) -------------------------------------
764 4
765 sin (x)
766 (%i6) cos(4 * x) / sin(x)^4, trigexpand, ratexpand;
767 @group
768 2 4
769 6 cos (x) cos (x)
770 (%o6) - --------- + ------- + 1
771 2 4
772 sin (x) sin (x)
773 @end group
774 (%i7) ratexpand (trigexpand (cos(4 * x) / sin(x)^4));
775 2 4
776 6 cos (x) cos (x)
777 (%o7) - --------- + ------- + 1
778 2 4
779 sin (x) sin (x)
780 (%i8) declare ([F, G], evfun);
781 (%o8) done
782 (%i9) (aa : bb, bb : cc, cc : dd);
783 (%o9) dd
784 (%i10) aa;
785 (%o10) bb
786 (%i11) aa, F;
787 (%o11) F(cc)
788 (%i12) F (aa);
789 (%o12) F(bb)
790 (%i13) F (ev (aa));
791 (%o13) F(cc)
792 (%i14) aa, F, G;
793 (%o14) G(F(cc))
794 (%i15) G (F (ev (aa)));
795 (%o15) G(F(cc))
796 @end example
797 @end defvr
799 @c --- 07.03.2011 DK -----------------------------------------------------------
800 @anchor{infeval}
801 @need 800
802 @defvr {Optionsvariable} infeval
803 Standardwert: @code{false}
805 @code{infeval} bewirkt, dass die Funktion @mref{ev} die Auswertung eines
806 Ausdrucks solange wiederholt, bis dieser sich nicht mehr @"andert. Um zu
807 verhindern, dass eine Variable in diesem Modus durch die Auswertung
808 verschwindet, kann zum Beispiel f@"ur eine Variable @code{x} der Ausdruck
809 @code{x='x} als Argument von @code{ev} einf@"ugt werden. Ausdr@"ucke wie
810 @code{ev(x, x=x+1, infeval)} f@"uhren in diesem Modus zu Endlosschleifen.
812 Siehe auch die Auswertungsschalter @mref{noeval} und @mrefdot{eval}
813 @end defvr
815 @c --- 07.03.2011 DK -----------------------------------------------------------
816 @anchor{noeval}
817 @defvr {Auswertungsschalter} noeval
819 @code{noeval} unterdr@"uckt die Auswertungsphase der Funktion @mrefdot{ev}@w{}
820 Der Schalter kann im Zusammenhang mit anderen Auswertungsschaltern genutzt
821 werden, um einen Ausdruck erneut zu vereinfachen, ohne diesen auszuwerten.
823 Siehe auch die Optionsvariable @mref{infeval} und den Auswertungsschalter
824 @mrefdot{eval}
825 @end defvr
827 @c --- 07.03.2011 DK -----------------------------------------------------------
828 @anchor{nouns}
829 @defvr {Auswertungsschalter} nouns
831 @code{nouns} ist ein Auswertungsschalter. Wird dieser Schalter als eine Option
832 der Funktion @mref{ev} genutzt, werden alle Substantivformen, die in dem
833 Ausdruck enthalten sind, in Verbformen umgewandelt und ausgewertet.
835 Siehe auch die Eigenschaft @mref{noun} und die Funktionen @mref{nounify} und
836 @mrefdot{verbify}
837 @end defvr
839 @c --- 07.03.2011 DK -----------------------------------------------------------
840 @anchor{pred}
841 @defvr {Auswertungsschalter} pred
843 Wird @code{pred} als ein Argument der Funktion @code{ev} eingesetzt, werden
844 Aussagen zu @code{true} oder @code{false} ausgewertet. Siehe die Funktion
845 @mrefdot{ev}
847 Beispiel:
849 @example
850 (%i1) 1 < 2;
851 (%o1) 1 < 2
852 (%i2) 1 < 2,pred;
853 (%o2) true
854 @end example
855 @end defvr
857 @c --- End of file Evaluation.de.texi ------------------------------------------