| blob | 9c6fe84548c0d93ef1cc0196d2136497084fb2ad |
1 @c -----------------------------------------------------------------------------
2 @c File : Function.de.texi
3 @c License : GNU General Public License (GPL)
4 @c Language : German
5 @c Original : Function.texi revision 14.03.2011
6 @c Translation : Dr. Dieter Kaiser
7 @c Date : 14.11.2010
8 @c Revision : 04.12.2011
9 @c
10 @c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA
11 @c -----------------------------------------------------------------------------
13 @menu
14 * Funktionen::
15 * Makros::
16 * Funktionen und Variablen f@"ur Funktionsdefinitionen::
17 @end menu
19 @c -----------------------------------------------------------------------------
20 @node Funktionen, Makros, Funktionsdefinitionen, Funktionsdefinitionen
21 @section Funktionen
22 @c -----------------------------------------------------------------------------
24 @c -----------------------------------------------------------------------------
25 @subsection Gew@"ohnliche Funktionen
27 Eine Maxima-Funktion wird mit dem Operator @mref{:=} oder der Funktion
28 @mref{define} definiert. Im folgenden wird die Funktion @code{f} mit
29 dem Operator @code{:=} definiert:
31 @example
32 f(x) := sin(x)
33 @end example
35 Funktionen, die mit der Funktion @mref{lambda} definiert werden, sind anonyme
36 Funktionen, die keinen Namen haben. Diese werden auch @code{lambda}-Ausdr@"ucke
37 genannt:
39 @example
40 lambda ([i, j], ...)
41 @end example
43 Anonyme Funktionen k@"onnen @"uberall dort verwendet werden, wo eine Funktion
44 als Argument erwartet wird. Das folgende Beispiel gibt eine Liste zur@"uck,
45 bei der jedes Element der Liste @code{L} mit 1 addiert wird:
47 @example
48 map (lambda ([i], i+1), L)
49 @end example
51 Ist das letzte oder einzige Argument einer Funktion eine Liste mit einem
52 Element, kann eine variable Anzahl an Argumenten an die Funktion @"ubergeben
53 werden:
55 @example
56 (%i1) f ([u]) := u;
57 (%o1) f([u]) := u
58 (%i2) f (1, 2, 3, 4);
59 (%o2) [1, 2, 3, 4]
60 (%i3) f (a, b, [u]) := [a, b, u];
61 (%o3) f(a, b, [u]) := [a, b, u]
62 (%i4) f (1, 2, 3, 4, 5, 6);
63 (%o4) [1, 2, [3, 4, 5, 6]]
64 @end example
66 Die rechte Seite einer Funktionsdefinition ist ein Ausdruck. Mehrere
67 Ausdr@"ucke werden durch Kommata getrennt und mit Klammern umgeben. Das
68 Ergebnis der Funktion ist der Wert des letzten Ausdrucks @code{exprn}:
70 @example
71 f(x) := (expr1, expr2, ...., exprn);
72 @end example
74 Ein R@"ucksprung mit der Anweisung @mref{return} aus einer Funktion ist
75 m@"oglich, wenn die Definition der Funktion in einen Block eingef@"ugt wird.
76 Ein Block wird mit der @mref{block}-Anweisung definiert. Das folgende Beispiel
77 hat entweder den Wert @code{a} oder den Wert des Ausdrucks @var{exprn} als
78 Ergebnis:
80 @example
81 block ([], expr1, ..., if (a > 10) then return(a), ..., exprn)
82 @end example
84 Das erste paar Klammern @code{[]} in einem Block enth@"alt die Definition von
85 lokalen Variablen wie zum Beispiel @code{[a: 3, b, c: []]}. Die Variablen sind
86 au@ss{}erhalb des Blocks nicht sichtbar. Die Werte von globalen Variablen
87 werden von den lokalen Werten @"uberschrieben. Au@ss{}erhalb des Blocks haben
88 die Variablen, wenn vorhanden, wieder ihre alten Werte. Die Zuweisung der Werte
89 an die lokalen Variablen wird parallel ausgef@"uhrt.
91 Im folgenden Beispiel wird der Wert der globalen Variablen @var{a} der lokalen
92 Variablen @var{a} zugewiesen. @"Anderungen von @var{a} im Block wirken sich
93 nicht auf den globalen Wert der Variablen aus.
95 @example
96 block ([a: a], expr1, ... a: a+3, ..., exprn)
97 @end example
99 Die Anweisung @code{block ([x], ...)} bewirkt, dass @code{x} als lokale Variable
100 ohne einen Wert verwendet werden kann.
102 Die Argumente einer Funktion werden in gleicher Weise wie lokal definierte
103 Variable behandelt. Die folgende Definition
105 @example
106 f(x) := (expr1, ..., exprn);
107 @end example
109 mit
111 @example
112 f(1);
113 @end example
115 hat denselben Effekt wie der folgende Block:
117 @example
118 block ([x: 1], expr1, ..., exprn)
119 @end example
121 Soll die rechte Seite einer Funktionsdefinition ausgewertet werden,
122 kann die Funktionen @mref{define} f@"ur die Definition der Funktion verwendet
123 werden. Mit der Funktion @mref{buildq} kann die Definition einer Funktion
124 konstruiert werden, wobei die Auswertung gezielt kontrolliert werden kann.
126 @c -----------------------------------------------------------------------------
127 @anchor{Array-Funktionen}
128 @subsection Array-Funktionen
130 Eine Array-Funktion speichert bei dem ersten Aufruf den Funktionswert zu dem
131 Argument. Wird die Array-Funktion mit demselben Argument aufgerufen, wird der
132 gespeicherte Wert zur@"uckgeben, ohne diesen neu zu berechnen. Dies wird auch
133 Memoisation genannt.
135 Beispiel:
137 Das folgende Beispiel zeigt die Definition einer Array-Funktion @code{f}, die
138 die Fakult@"at einer Zahl faktorisiert. Im ersten Aufruf der Funktion mit dem
139 Argument @code{25000} wird eine Rechenzeit von etwa 24 Sekunden ben@"otigt.
140 Der zweite Aufruf mit demselben Argument gibt sofort den abgespeicherten Wert
141 zur@"uck.
143 @example
144 (%i1) f[x]:=factor(x!);
145 (%o1) f := factor(x!)
146 x
147 (%i2) showtime:true;
148 Evaluation took 0.0000 seconds (0.0000 elapsed) using 0 bytes.
149 (%o2) true
150 (%i3) f[25000]$
151 Evaluation took 23.9250 seconds (26.0790 elapsed) using 3829.778 MB.
152 (%i4) f[25000]$
153 Evaluation took 0.0000 seconds (0.0000 elapsed) using 0 bytes.
154 @end example
156 Die Namen der Array-Funktionen werden in die Informationsliste @mref{arrays}@w{}
157 und nicht in die Liste @mref{functions} eingetragen. @mref{arrayinfo} gibt eine
158 Liste der Argumente zur@"uck, f@"ur die Werte gespeichert sind und
159 @mref{listarray} gibt die Werte zur@"uck. Die Funktionen @mref{dispfun} und
160 @mref{fundef} geben die Definition der Array-Funktion zur@"uck.
162 Beispiele:
164 Mit dem obigen Beispiel werden die folgenden Ergebnisse ausgegeben.
166 @example
167 (%i5) arrays;
168 (%o5) [f]
169 (%i6) arrayinfo(f);
170 (%o6) [hashed, 1, [25000]]
171 (%i7) dispfun(f);
172 (%t7) f := factor(x!)
173 x
174 (%o7) [%t7]
175 @end example
177 @mref{arraymake} erzeugt den Aufruf einer Array-Funktion. Dies ist analog zu
178 der Funktion @mref{funmake} f@"ur gew@"ohnliche Funktionen.
179 @mref{arrayapply} wendet eine Array-Funktion auf die Argumente an. Dies
180 entspricht der Funktion @mref{apply} f@"ur gew@"ohnliche Funktionen. Die
181 Funktion @mref{map} hat keine Entsprechung f@"ur Array-Funktionen.
182 Vergleichbare Konstruktionen sind
183 @code{map(lambda([@var{x}], @var{a}[@var{x}]), @var{L})} oder
184 @code{makelist(@var{a}[@var{x}], @var{x}, @var{L})}, wobei @var{L} eine Liste
185 ist.
187 @mref{remarray} entfernt die Definition einer Array-Funktion einschlie@ss{}lich
188 der gespeicherten Werte. Dies entspricht @mref{remfunction} f@"ur gew@"ohnliche
189 Funktionen.
191 @code{kill(@var{a}[@var{x}])} entfernt den f@"ur das Argument @var{x}
192 gespeicherten Wert einer Array-Funktion @var{a}. Beim n@"achsten Aufruf von
193 @var{a} mit dem Argument @var{x} wird der Funktionswert neu berechnet. Es gibt
194 keine M@"oglichkeit, alle gespeicherten Werte zu l@"oschen, ohne dass die
195 Definition der Funktion entfernt wird. Die Kommandos @code{kill(@var{a})} und
196 @code{remarray(@var{a})} l@"oschen alle Werte einschlie@ss{}lich der Definition
197 der Funktion.
199 @c -----------------------------------------------------------------------------
200 @node Makros, Funktionen und Variablen f@"ur Funktionsdefinitionen, Funktionen, Funktionsdefinitionen
201 @section Makros
202 @c -----------------------------------------------------------------------------
204 @c --- 02.12.2010 DK -----------------------------------------------------------
205 @anchor{buildq}
206 @deffn {Funktion} buildq (@var{L}, @var{expr})
208 Die Variablen der Liste @var{L} werden in den Ausdruck @var{expr} substituiert.
209 Die Substitution wird parallel ausgef@"uhrt. Das Ergebnis der Substitution wird
210 vereinfacht, aber nicht ausgewertet.
212 Die Elemente der Liste @var{L} sind Symbole oder Zuweisungen der Form
213 @code{@var{symbol}: @var{value}}. Die Zuweisungen werden parallel ausgewertet.
214 Der Wert einer Variablen auf der rechten Seite einer Zuweisung ist der globale
215 Wert in dem Kontext in dem @code{buildq} aufgerufen wird und nicht der lokale
216 Wert einer vorhergehenden Zuweisung. Erh@"alt eine Variable keinen Wert, dann
217 beh@"alt die Variable den globalen Wert.
219 Dann werden die in der Liste @var{L} enthaltenen Variablen parallel in den
220 Ausdruck @var{expr} substituiert.
222 Enth@"alt @var{expr} Ausdr@"ucke der Form @code{splice(@var{x})}, muss die
223 Variable @var{x} eine Liste sein. Die Liste wird in den Ausdruck eingef@"ugt.
224 Siehe auch @mrefdot{splice}
226 Variablen in in dem Ausdruck @var{expr}, die nicht in @var{L} enthalten sind,
227 werden nicht durch einen Wert ersetzt, auch wenn es eine globale Variable mit
228 demselben Namen gibt, da der Ausdruck nicht ausgewertet wird.
230 Beispiele:
232 Der Variablen @code{a} wird der Wert zugewiesen. Die Variable @code{b} erh@"alt
233 den globalen Wert. Die Variable @code{c} hat keinen Wert. Das Ergebnis ist
234 ein nicht ausgewerteter Ausdruck. Die Auswertung wird mit dem
235 @nxref{'', Quote-Quote-Operator} @code{''} erzwungen.
237 @example
238 (%i1) (a: 17, b: 29, c: 1729)$
239 (%i2) buildq ([a: x, b], a + b + c);
240 (%o2) x + c + 29
241 (%i3) ''%;
242 (%o3) x + 1758
243 @end example
245 @code{e} ist eine Liste, die einmal als Argument der Funktion @code{foo}
246 vorliegt und zum anderen in die Argumentliste der Funktion @code{bar}
247 eingef@"ugt wird.
249 @example
250 (%i1) buildq ([e: [a, b, c]], foo (x, e, y));
251 (%o1) foo(x, [a, b, c], y)
252 (%i2) buildq ([e: [a, b, c]], bar (x, splice (e), y));
253 (%o2) bar(x, a, b, c, y)
254 @end example
256 Das Ergebnis wird nach der Substitution vereinfacht, ansonsten h@"atten die
257 beiden folgenden Beispiele dasselbe Ergebnis.
259 @example
260 (%i1) buildq ([e: [a, b, c]], splice (e) + splice (e));
261 (%o1) 2 c + 2 b + 2 a
262 (%i2) buildq ([e: [a, b, c]], 2 * splice (e));
263 (%o2) 2 a b c
264 @end example
266 Die Variablen der Liste @var{L} erhalten ihren Wert parallel, ansonsten w@"are
267 das erste Ergebnis @code{foo(b,b)}. Substitutionen werden parallel
268 ausgef@"uhrt. Im Gegensatz dazu werden die Substitutionen mit der Funktion
269 @mref{subst} nacheinander ausgef@"uhrt.
271 @example
272 (%i1) buildq ([a: b, b: a], foo (a, b));
273 (%o1) foo(b, a)
274 (%i2) buildq ([u: v, v: w, w: x, x: y, y: z, z: u],
275 bar (u, v, w, x, y, z));
276 (%o2) bar(v, w, x, y, z, u)
277 (%i3) subst ([u=v, v=w, w=x, x=y, y=z, z=u],
278 bar (u, v, w, x, y, z));
279 (%o3) bar(u, u, u, u, u, u)
280 @end example
282 Konstruktion einer Liste mit Gleichungen mit Variablen oder Ausdr@"ucken auf
283 der linken Seite und deren Werten auf der rechten Seite. Die Funktion
284 @mref{macroexpand} expandiert das Makro @code{show_values}.
286 @example
287 (%i1) show_values ([L]) ::= buildq ([L], map ("=", 'L, L))$
288 (%i2) (a: 17, b: 29, c: 1729)$
289 (%i3) show_values (a, b, c - a - b);
290 (%o3) [a = 17, b = 29, c - b - a = 1683]
291 (%i4) macroexpand (show_values (a, b, c - a - b));
292 (%o4) map(=, '([a, b, c - b - a]), [a, b, c - b - a])
293 @end example
295 Konstruktion einer Funktion.
297 @example
298 (%i1) curry (f, [a]) :=
299 buildq ([f, a], lambda ([[x]], apply (f, append (a, x))))$
300 (%i2) by3 : curry ("*", 3);
301 (%o2) lambda([[x]], apply(*, append([3], x)))
302 (%i3) by3 (a + b);
303 (%o3) 3 (b + a)
304 @end example
305 @end deffn
307 @c --- 04.12 2011 DK -----------------------------------------------------------
308 @anchor{macroexpand}
309 @deffn {Funktion} macroexpand (@var{expr})
311 Ist das Argument @var{expr} ein Makro, wird das Makro expandiert, ohne dass es
312 ausgewertet wird. Ansonsten wird @var{expr} zur@"uckgegeben.
314 Ist die Expansion des Makros selbst ein Makro, wird dieses Makro wiederholt
315 expandiert.
317 @code{macroexpand} wertet das Argument @var{expr} nicht aus. Hat die Expansion
318 des Makros Seiteneffekte, dann werden diese ausgef@"uhrt.
320 Siehe auch @mref{::=} und @mrefdot{macroexpand1}
322 Beispiele:
324 @example
325 (%i1) g (x) ::= x / 99;
326 x
327 (%o1) g(x) ::= --
328 99
329 (%i2) h (x) ::= buildq ([x], g (x - a));
330 (%o2) h(x) ::= buildq([x], g(x - a))
331 (%i3) a: 1234;
332 (%o3) 1234
333 (%i4) macroexpand (h (y));
334 y - a
335 (%o4) -----
336 99
337 (%i5) h (y);
338 y - 1234
339 (%o5) --------
340 99
341 @end example
342 @end deffn
344 @c --- 04.12.2010 DK -----------------------------------------------------------
345 @anchor{macroexpand1}
346 @deffn {Funktion} macroexpand1 (@var{expr})
348 Gibt die Makro-Expansion von @var{expr} zur@"uck, ohne das Ergebnis auszuwerten.
349 Ist @var{expr} keine Makro-Funktion gibt @code{macroexpand1} das Argument
350 @var{expr} zur@"uck.
352 @code{macroexpand1} wertet das Argument nicht aus. Hat die Expansion des Makros
353 Seiteneffekte, dann werden diese ausgef@"uhrt.
355 Enth@"alt die Expansion @var{expr} wiederum Makros, werden diese im Unterschied
356 zur Funktion @code{macroexpand} nicht expandiert.
358 Siehe auch @mref{::=} und @mrefdot{macroexpand}
360 Beispiele:
362 @example
363 (%i1) g (x) ::= x / 99;
364 x
365 (%o1) g(x) ::= --
366 99
367 (%i2) h (x) ::= buildq ([x], g (x - a))$
368 (%i3) a: 1234;
369 (%o3) 1234
370 (%i4) macroexpand1 (h (y));
371 (%o4) g(y - a)
372 (%i5) h (y);
373 y - 1234
374 (%o5) --------
375 99
376 @end example
377 @end deffn
379 @c --- 03.01.2011 DK -----------------------------------------------------------
380 @defvr {Optionsvariable} macroexpansion
381 Standardwert: @code{false}
383 @code{macroexpansion} kontrolliert die Expansion von Makros.
385 @table @code
386 @item false
387 Die Expansion des Makros wird nicht f@"ur die aufrufende Funktion ersetzt.
389 @item expand
390 Wird die Makro-Funktion das erste Mal ausgewertet, wird die Expansion des Makros
391 gespeichert. Weitere Aufrufe werten das Makro nicht erneut aus. Seiteneffekte,
392 wie Zuweisungen an globale Variablen, werden nur bei der ersten Auswertung
393 wirksam. Die Expansion des Makros beeinflusst nicht andere Ausdr@"ucke, die das
394 Makro ebenfalls aufrufen.
396 @item displace
397 Wird die Makro-Funktion das erste mal ausgewertet, wird die Expansion des Makros
398 in den aufrufenden Ausdruck eingesetzt. Weitere Aufrufe werten das Makro nicht
399 erneut aus. Seiteneffekte, wie Zuweisungen an globale Variablen, werden nur bei
400 der ersten Auswertung wirksam. Die Expansion des Makros beeinflusst nicht
401 andere Ausdr@"ucke, die das Makro ebenfalls aufrufen.
402 @end table
404 Beispiele:
406 Hat @code{macroexpansion} den Wert @code{false}, wird eine Makro-Funktion
407 jedes mal aufgerufen, wenn der aufrufende Ausdruck ausgewertet wird. Der
408 aufrufende Ausdruck wird nicht modifiziert.
410 @example
411 (%i1) f (x) := h (x) / g (x);
412 h(x)
413 (%o1) f(x) := ----
414 g(x)
415 @group
416 (%i2) g (x) ::= block (print ("x + 99 is equal to", x),
417 return (x + 99));
418 @end group
419 (%o2) g(x) ::= block(print("x + 99 is equal to", x),
420 return(x + 99))
421 (%i3) h (x) ::= block (print ("x - 99 is equal to", x),
422 return (x - 99));
423 (%o3) h(x) ::= block(print("x - 99 is equal to", x),
424 return(x - 99))
425 (%i4) macroexpansion: false;
426 (%o4) false
427 (%i5) f (a * b);
428 x - 99 is equal to x
429 x + 99 is equal to x
430 a b - 99
431 (%o5) --------
432 a b + 99
433 (%i6) dispfun (f);
434 h(x)
435 (%t6) f(x) := ----
436 g(x)
438 (%o6) done
439 (%i7) f (a * b);
440 x - 99 is equal to x
441 x + 99 is equal to x
442 a b - 99
443 (%o7) --------
444 a b + 99
445 @end example
447 Hat @code{macroexpansion} den Wert @code{expand}, wird eine Makro-Funktion nur
448 einmal aufgerufen. Der aufrufende Ausdruck wird nicht modifiziert.
450 @example
451 (%i1) f (x) := h (x) / g (x);
452 h(x)
453 (%o1) f(x) := ----
454 g(x)
455 (%i2) g (x) ::= block (print ("x + 99 is equal to", x),
456 return (x + 99));
457 (%o2) g(x) ::= block(print("x + 99 is equal to", x),
458 return(x + 99))
459 (%i3) h (x) ::= block (print ("x - 99 is equal to", x),
460 return (x - 99));
461 (%o3) h(x) ::= block(print("x - 99 is equal to", x),
462 return(x - 99))
463 (%i4) macroexpansion: expand;
464 (%o4) expand
465 (%i5) f (a * b);
466 x - 99 is equal to x
467 x + 99 is equal to x
468 @group
469 a b - 99
470 (%o5) --------
471 a b + 99
472 @end group
473 (%i6) dispfun (f);
474 h(x)
475 (%t6) f(x) := ----
476 g(x)
478 (%o6) done
479 (%i7) f (a * b);
480 a b - 99
481 (%o7) --------
482 a b + 99
483 @end example
485 Hat @code{macroexpansion} den Wert @code{displace}, wird eine Makro-Funktion
486 nur einmal aufgerufen. Der aufrufende Ausdruck wird modifiziert.
488 @example
489 (%i1) f (x) := h (x) / g (x);
490 h(x)
491 (%o1) f(x) := ----
492 g(x)
493 (%i2) g (x) ::= block (print ("x + 99 is equal to", x),
494 return (x + 99));
495 (%o2) g(x) ::= block(print("x + 99 is equal to", x),
496 return(x + 99))
497 (%i3) h (x) ::= block (print ("x - 99 is equal to", x),
498 return (x - 99));
499 (%o3) h(x) ::= block(print("x - 99 is equal to", x),
500 return(x - 99))
501 (%i4) macroexpansion: displace;
502 (%o4) displace
503 (%i5) f (a * b);
504 x - 99 is equal to x
505 x + 99 is equal to x
506 a b - 99
507 (%o5) --------
508 a b + 99
509 (%i6) dispfun (f);
510 x - 99
511 (%t6) f(x) := ------
512 x + 99
514 (%o6) done
515 (%i7) f (a * b);
516 a b - 99
517 (%o7) --------
518 a b + 99
519 @end example
520 @end defvr
522 @c --- 04.12.2011 DK -----------------------------------------------------------
523 @anchor{macros}
524 @defvr {Systemvariable} macros
525 Standardwert: @code{[]}
527 Die Systemvariable @code{macros} ist eine Informationsliste, die die vom Nutzer
528 mit dem Operator @mref{::=} definierten Makros enth@"alt. Wird das Makro mit
529 einer der Funktionen @mrefcomma{kill} @mref{remove} oder @mref{remfunction}
530 gel@"oscht, wird der Eintrag aus der Informationsliste entfernt. Siehe auch die
531 Systemvariable @mrefdot{infolists}
532 @end defvr
534 @c --- 04.12.2010 DK -----------------------------------------------------------
535 @anchor{splice}
536 @deffn {Funktion} splice (@var{a})
538 Die Funktion @code{splice} kann nur im Zusammenhang mit der Funktion
539 @mref{buildq} verwendet werden. Das Argument @var{a} bezeichnet eine Liste, die
540 an Stelle von @code{splice(a)} in einen Ausdruck eingef@"ugt wird. @var{a} kann
541 nicht selbst eine Liste oder ein Ausdruck sein, der zu einer Liste auswertet.
543 Beispiele:
545 @example
546 (%i1) buildq ([x: [1, %pi, z - y]], foo (splice (x)) / length (x));
547 foo(1, %pi, z - y)
548 (%o1) -----------------------
549 length([1, %pi, z - y])
550 (%i2) buildq ([x: [1, %pi]], "/" (splice (x)));
551 1
552 (%o2) ---
553 %pi
554 (%i3) matchfix ("<>", "<>");
555 (%o3) <>
556 (%i4) buildq ([x: [1, %pi, z - y]], "<>" (splice (x)));
557 (%o4) <>1, %pi, z - y<>
558 @end example
559 @end deffn
561 @c -----------------------------------------------------------------------------
562 @node Funktionen und Variablen f@"ur Funktionsdefinitionen, , Makros, Funktionsdefinitionen
563 @section Funktionen und Variablen f@"ur Funktionsdefinitionen
564 @c -----------------------------------------------------------------------------
566 @c --- 04.12.2010 DK -----------------------------------------------------------
567 @anchor{apply}
568 @deffn {Funktion} apply (@var{F}, [@var{x_1}, @dots{}, @var{x_n}])
570 Konstruiert den Ausdruck @code{@var{F}(@var{arg_1}, ..., @var{arg_n})} und
571 wertet diesen aus.
573 @code{apply} versucht nicht Array-Funktionen von gew@"ohnlichen Funktionen zu
574 unterscheiden. Ist @var{F} der Name eine Array-Funktion, wertet @code{apply}
575 den Ausdruck @code{@var{F}(...)} aus. @mref{arrayapply} entspricht der
576 Funktion @code{apply}, wenn @var{F} eine Array-Funktion ist.
578 Beispiele:
580 @code{apply} wertet die Argumente aus. In diesem Beispiel wird die Funktion
581 @mref{min} auf die Liste @code{L} angewendet.
583 @example
584 (%i1) L : [1, 5, -10.2, 4, 3];
585 (%o1) [1, 5, - 10.2, 4, 3]
586 (%i2) apply (min, L);
587 (%o2) - 10.2
588 @end example
590 @code{apply} wertet die Argumente auch dann aus, wenn die Funktion @code{F}
591 die Auswertung ihrer Argumente unterdr@"uckt.
593 @example
594 (%i1) F (x) := x / 1729;
595 @group
596 x
597 (%o1) F(x) := ----
598 1729
599 @end group
600 (%i2) fname : F;
601 (%o2) F
602 (%i3) dispfun (F);
603 x
604 (%t3) F(x) := ----
605 1729
607 (%o3) [%t3]
608 (%i4) dispfun (fname);
609 fname is not the name of a user function.
610 -- an error. Quitting. To debug this try debugmode(true);
611 (%i5) apply (dispfun, [fname]);
612 x
613 (%t5) F(x) := ----
614 1729
616 (%o5) [%t5]
617 @end example
619 @code{apply} wertet den Namen der Funktion @var{F} aus. Mit dem
620 @nxref{', Quote-Operator} @code{'} wird die Auswertung unterdr@"uckt.
621 @mref{demoivre} ist der Name einer globalen Optionsvariable und einer Funktion.
623 @example
624 (%i1) demoivre;
625 (%o1) false
626 (%i2) demoivre (exp (%i * x));
627 (%o2) %i sin(x) + cos(x)
628 (%i3) apply (demoivre, [exp (%i * x)]);
629 demoivre evaluates to false
630 Improper name or value in functional position.
631 -- an error. Quitting. To debug this try debugmode(true);
632 (%i4) apply ('demoivre, [exp (%i * x)]);
633 (%o4) %i sin(x) + cos(x)
634 @end example
635 @end deffn
637 @c --- 03.01.2011 DK -----------------------------------------------------------
638 @anchor{define}
639 @deffn {Funktion} define (@var{f}(@var{x_1}, @dots{}, @var{x_n}), @var{expr})
640 @deffnx {Funktion} define (@var{f}[@var{x_1}, @dots{}, @var{x_n}], @var{expr})
641 @deffnx {Funktion} define (funmake (@var{f}, [@var{x_1}, @dots{}, @var{x_n}]), @var{expr})
642 @deffnx {Funktion} define (arraymake (@var{f}, [@var{x_1}, @dots{}, @var{x_n}]), @var{expr})
643 @deffnx {Funktion} define (ev (@var{expr_1}), @var{expr_2})
645 Definiert eine Funktion mit dem Namen @var{f} und den Argumenten @var{x1},
646 @dots{}, @var{x_n} und der Funktionsdefinition @var{expr}. @code{define}
647 wertet das zweite Argument immer aus.
649 Ist das letzte oder einzige Argument @var{x_n} eine Liste mit einem Element,
650 dann akzeptiert die Funktion eine variable Anzahl an Argumenten. Die Argumente
651 der Funktion werden nacheinander den Variablen @var{x_1}, @dots{}, @var{x_(n-1)}
652 zugewiesen. Sind weitere Argumente vorhanden, werden diese als Liste der
653 Variablen @var{x_n} zugewiesen.
655 Ist das erste Argument der Funktion @code{define} ein Ausdruck der Form
656 @code{@var{f}(@var{x_1}, ..., @var{x_n})} oder @code{@var{f}[@var{x_1}, ...,
657 @var{x_n}]} werden die Argumente der Funktion ausgewertet, aber nicht die
658 Funktion @var{f} selbst. @var{f} wird auch dann nicht ausgewertet, wenn es
659 bereits eine Funktion mit dem Namen @var{f} gibt.
661 Das erste Argument wird dann ausgewertet, wenn es ein Ausdruck mit den
662 Funktionen @mrefcomma{funmake} @mref{arraymake} oder @mref{ev} ist.
664 Alle Funktionsdefinitionen treten in demselben Namensraum auf. Die Definition
665 einer Funktion @code{g} innerhalb einer Funktion @code{f} f@"uhrt nicht
666 automatisch zu einer lokalen Definition. Um eine lokale Funktion zu erhalten,
667 kann @code{lokal(g)} innerhalb der Funktion @code{f} ausgef@"uhrt werden.
668 Siehe auch @mrefdot{local}
670 Ist eines der Argumente @var{x_k} nach der Auswertung ein quotiertes Symbol,
671 wertet die mit @code{define} definierte Funktion das Argument nicht aus.
672 Alle weiteren Argumente der Funktion werden ausgewertet.
674 Siehe auch @mref{:=} und @mrefdot{::=}
676 Beispiele:
678 @code{define} wertet das zweite Argument aus.
680 @example
681 (%i1) expr : cos(y) - sin(x);
682 (%o1) cos(y) - sin(x)
683 (%i2) define (F1 (x, y), expr);
684 (%o2) F1(x, y) := cos(y) - sin(x)
685 (%i3) F1 (a, b);
686 (%o3) cos(b) - sin(a)
687 (%i4) F2 (x, y) := expr;
688 (%o4) F2(x, y) := expr
689 (%i5) F2 (a, b);
690 (%o5) cos(y) - sin(x)
691 @end example
694 Mit @code{define} k@"onnen gew@"ohnliche Maxima-Funktionen und Array-Funktionen
695 definiert werden.
697 @example
698 (%i1) define (G1 (x, y), x.y - y.x);
699 (%o1) G1(x, y) := x . y - y . x
700 (%i2) define (G2 [x, y], x.y - y.x);
701 (%o2) G2 := x . y - y . x
702 x, y
703 @end example
705 Ist das letzte oder einzige Argument @var{x_n} eine Liste mit einem Element,
706 akzeptiert die mit @code{define} definierte Funktion eine variable Anzahl an
707 Argumenten.
709 @example
710 (%i1) define (H ([L]), '(apply ("+", L)));
711 (%o1) H([L]) := apply("+", L)
712 (%i2) H (a, b, c);
713 (%o2) c + b + a
714 @end example
716 Ist das erste Argument ein Ausdruck mit den Funktionen @code{funmake},
717 @code{arraymake} oder @code{ev} wird das Argument ausgewertet.
719 @example
720 (%i1) [F : I, u : x];
721 (%o1) [I, x]
722 (%i2) funmake (F, [u]);
723 (%o2) I(x)
724 (%i3) define (funmake (F, [u]), cos(u) + 1);
725 (%o3) I(x) := cos(x) + 1
726 (%i4) define (arraymake (F, [u]), cos(u) + 1);
727 (%o4) I := cos(x) + 1
728 x
729 (%i5) define (foo (x, y), bar (y, x));
730 (%o5) foo(x, y) := bar(y, x)
731 (%i6) define (ev (foo (x, y)), sin(x) - cos(y));
732 (%o6) bar(y, x) := sin(x) - cos(y)
733 @end example
734 @end deffn
736 @c --- 03.01.2011 DK -----------------------------------------------------------
737 @anchor{define_variable}
738 @deffn {Funktion} define_variable (@var{name}, @var{default_value}, @var{mode})
740 Definiert eine globale Variable in der Maxima-Umgebung. @code{define_variable}
741 ist n@"utzlich f@"ur das Schreiben von Paketen, die h@"aufig @"ubersetzt oder
742 kompiliert werden. @code{define_variable} f@"uhrt die folgenden Schritte aus:
744 @enumerate
745 @item
746 @code{mode_declare(@var{name}, @var{mode})} deklariert den Typ der Variablen
747 @var{name} f@"ur den @"Ubersetzer. Siehe @mref{mode_declare} f@"ur eine Liste
748 der m@"oglichen Typen.
750 @item
751 Hat die Variable keinen Wert, wird der Variablen der Wert @var{default_value}
752 zugewiesen.
754 @item
755 @code{declare(@var{name}, special)} deklariert die Variable als Special.
757 @item
758 Ordnet der Variablen @var{name} eine Testfunktion zu, um sicherzustellen, dass
759 der Variablen nur Werte zugewiesen werden k@"onnen.
760 @end enumerate
762 Einer mit @code{define_variable} definierten Variablen, die einen anderen Typ
763 als @code{any} erhalten hat, kann die Eigenschaft @code{value_check} zugewiesen
764 werden. Die @code{value_check}-Eigenschaft ist eine Aussagefunktion mit einer
765 Variablen oder ein Lambda-Ausdruck, die aufgerufen werden, wenn der Variablen
766 ein Wert zugewiesen werden soll. Das Argument der @code{value_check}-Funktion
767 ist der Wert, den die Variable erhalten soll.
769 @code{define_variable} wertet @code{default_value} aus. Die Argumente
770 @code{name} und @code{mode} werden nicht ausgewertet. @code{define_variable}
771 gibt den aktuellen Wert der Variable @code{name} zur@"uck. Dieser ist
772 @code{default_value}, wenn der Variablen bisher kein Wert zugewiesen wurde.
774 Beispiele:
776 @code{foo} ist eine boolesche Variable mit dem Wert @code{true}.
778 @example
779 (%i1) define_variable (foo, true, boolean);
780 (%o1) true
781 (%i2) foo;
782 (%o2) true
783 (%i3) foo: false;
784 (%o3) false
785 (%i4) foo: %pi;
786 Error: foo was declared mode boolean, has value: %pi
787 -- an error. Quitting. To debug this try debugmode(true);
788 (%i5) foo;
789 (%o5) false
790 @end example
792 @code{bar} ist eine Variable mit dem Typ einer ganzen Zahl, die eine Primzahl
793 sein muss.
795 @example
796 (%i1) define_variable (bar, 2, integer);
797 (%o1) 2
798 (%i2) qput (bar, prime_test, value_check);
799 (%o2) prime_test
800 (%i3) prime_test (y) := if not primep(y) then
801 error (y, "is not prime.");
802 (%o3) prime_test(y) := if not primep(y)
804 then error(y, "is not prime.")
805 (%i4) bar: 1439;
806 (%o4) 1439
807 (%i5) bar: 1440;
808 1440 is not prime.
809 #0: prime_test(y=1440)
810 -- an error. Quitting. To debug this try debugmode(true);
811 (%i6) bar;
812 (%o6) 1439
813 @end example
815 @code{baz_quux} ist eine Variable, der kein Wert zugewiesen werden kann. Der
816 Typ @code{any_check} ist vergleichbar mit @code{any}. Aber @code{any_check}
817 ruft im Gegensatz zu @code{any} den @code{value_check}-Mechanismus auf.
819 @example
820 (%i1) define_variable (baz_quux, 'baz_quux, any_check);
821 (%o1) baz_quux
822 (%i2) F: lambda ([y], if y # 'baz_quux then
823 error ("Cannot assign to `baz_quux'."));
824 (%o2) lambda([y], if y # 'baz_quux
826 then error(Cannot assign to `baz_quux'.))
827 (%i3) qput (baz_quux, ''F, value_check);
828 (%o3) lambda([y], if y # 'baz_quux
830 then error(Cannot assign to `baz_quux'.))
831 (%i4) baz_quux: 'baz_quux;
832 (%o4) baz_quux
833 (%i5) baz_quux: sqrt(2);
834 Cannot assign to `baz_quux'.
835 #0: lambda([y],if y # 'baz_quux then
836 error("Cannot assign to `baz_quux'."))(y=sqrt(2))
837 -- an error. Quitting. To debug this try debugmode(true);
838 (%i6) baz_quux;
839 (%o6) baz_quux
840 @end example
841 @end deffn
843 @c --- 03.01.2011 DK -----------------------------------------------------------
844 @anchor{dispfun}
845 @deffn {Funktion} dispfun (@var{f_1}, @dots{}, @var{f_n})
846 @deffnx {Funktion} dispfun (all)
848 Zeigt die Definitionen der nutzerdefinierten Funktionen @var{f_1}, @dots{},
849 @var{f_n} an. Die Argumente k@"onnen gew@"ohnliche Funktionen, Makros,
850 Array-Funktionen oder indizierte Funktionen sein.
852 @code{dispfun(all)} zeigt die Definitionen aller nutzerdefinierten Funktionen
853 an, die in den Informationslisten @mrefcomma{functions} @mref{arrays} oder
854 @mref{macros} enthalten sind.
856 @code{dispfun} erzeugt Zwischenmarken @code{%t} f@"ur jede einzelne anzuzeigende
857 Funktion und weist die Funktionsdefinitionen den Zwischenmarken zu. Im
858 Gegensatz dazu, zeigt die Funktion @mref{fundef} die Funktionsdefinition ohne
859 Zwischenmarken an.
861 @code{dispfun} wertet die Argumente nicht aus. @code{dispfun} gibt eine Liste
862 mit den Zwischenmarken zur@"uck, die zu den angezeigten Funktionen geh@"oren.
864 Beispiele:
866 @example
867 (%i1) m(x, y) ::= x^(-y);
868 - y
869 (%o1) m(x, y) ::= x
870 (%i2) f(x, y) := x^(-y);
871 - y
872 (%o2) f(x, y) := x
873 (%i3) g[x, y] := x^(-y);
874 - y
875 (%o3) g := x
876 x, y
877 (%i4) h[x](y) := x^(-y);
878 - y
879 (%o4) h (y) := x
880 x
881 (%i5) i[8](y) := 8^(-y);
882 - y
883 (%o5) i (y) := 8
884 8
885 (%i6) dispfun (m, f, g, h, h[5], h[10], i[8]);
886 - y
887 (%t6) m(x, y) ::= x
889 - y
890 (%t7) f(x, y) := x
892 - y
893 (%t8) g := x
894 x, y
896 - y
897 (%t9) h (y) := x
898 x
900 1
901 (%t10) h (y) := --
902 5 y
903 5
905 @group
906 1
907 (%t11) h (y) := ---
908 10 y
909 10
910 @end group
912 - y
913 (%t12) i (y) := 8
914 8
916 (%o12) [%t6, %t7, %t8, %t9, %t10, %t11, %t12]
917 (%i12) ''%;
918 @group
919 - y - y - y
920 (%o12) [m(x, y) ::= x , f(x, y) := x , g := x ,
921 x, y
922 - y 1 1 - y
923 h (y) := x , h (y) := --, h (y) := ---, i (y) := 8 ]
924 x 5 y 10 y 8
925 5 10
926 @end group
927 @end example
928 @end deffn
930 @c --- 15.10.2010 DK -----------------------------------------------------------
931 @anchor{fullmap}
932 @deffn {Funktion} fullmap (@var{f}, @var{expr_1}, @dots{})
934 Die Funktion @code{fullmap} ist vergleichbar mit der Funktion @mrefdot{map}@w{}
935 Im Unterschied zu der Funktion @code{map} kann @code{fullmap} auf
936 verschachtelte Ausdr@"ucke angewendet werden.
938 Intern wird @code{fullmap} von Maxima f@"ur die Vereinfachung von Matrizen
939 aufgerufen. Daher k@"onnen bei der Vereinfachung von Matrizen Fehlermeldungen
940 im Zusammenhang mit @code{fullmap} auftreten, ohne dass die Funktion direkt
941 aufgerufen wurde.
943 Beispiele:
945 @example
946 (%i1) a + b * c;
947 (%o1) b c + a
948 (%i2) fullmap (g, %);
949 (%o2) g(b) g(c) + g(a)
950 (%i3) map (g, %th(2));
951 (%o3) g(b c) + g(a)
952 @end example
953 @end deffn
955 @c --- 15.10.2010 DK -----------------------------------------------------------
956 @anchor{fullmapl}
957 @deffn {Funktion} fullmapl (@var{f}, @var{list_1}, @dots{})
959 Die Funktion @code{fullmapl} ist vergleichbar mit @mrefdot{fullmap}@w{}
960 @code{fullmapl} kann jedoch nur auf Matrizen und Listen angewendet werden kann.
962 Beispiele:
964 @example
965 (%i1) fullmapl ("+", [3, [4, 5]], [[a, 1], [0, -1.5]]);
966 (%o1) [[a + 3, 4], [4, 3.5]]
967 @end example
968 @end deffn
970 @c --- 19.11.2010 DK -----------------------------------------------------------
971 @anchor{functions}
972 @defvr {Systemvariable} functions
973 Standardwert: @code{[]}
975 @code{functions} ist eine Informationsliste, die die vom Nutzer mit dem
976 Operator @mref{:=} oder der Funktion @mref{define} definierten Funktionen
977 enth@"alt. Siehe auch die Systemvariable @mrefdot{infolists}
979 Array-Funktionen und indizierte Funktionen werden nicht in die Informationsliste
980 @mrefcomma{functions} sondern in die Informationsliste @mref{arrays}@w{}
981 eingetragen.
983 Beispiele:
985 @example
986 (%i1) F_1 (x) := x - 100;
987 (%o1) F_1(x) := x - 100
988 (%i2) F_2 (x, y) := x / y;
989 x
990 (%o2) F_2(x, y) := -
991 y
992 (%i3) define (F_3 (x), sqrt (x));
993 (%o3) F_3(x) := sqrt(x)
994 (%i4) G_1 [x] := x - 100;
995 (%o4) G_1 := x - 100
996 x
997 (%i5) G_2 [x, y] := x / y;
998 x
999 (%o5) G_2 := -
1000 x, y y
1001 (%i6) define (G_3 [x], sqrt (x));
1002 (%o6) G_3 := sqrt(x)
1003 x
1004 (%i7) H_1 [x] (y) := x^y;
1005 y
1006 (%o7) H_1 (y) := x
1007 x
1008 (%i8) functions;
1009 (%o8) [F_1(x), F_2(x, y), F_3(x)]
1010 (%i9) arrays;
1011 (%o9) [G_1, G_2, G_3, H_1]
1012 @end example
1013 @end defvr
1015 @c --- 03.01.2011 DK -----------------------------------------------------------
1016 @anchor{fundef}
1017 @deffn {Funktion} fundef (@var{f})
1019 Gibt die Definition der Funktion @var{f} zur@"uck.
1021 Das Argument @var{f} kann eine gew@"ohnliche Funktion, eine Makro-Funktion, eine
1022 Array-Funktion oder eine indizierte Funktion sein.
1024 @code{fundef} wertet das Argument aus. Siehe auch @mrefdot{dispfun}
1025 @end deffn
1027 @c --- 03.01.2011 DK -----------------------------------------------------------
1028 @anchor{funmake}
1029 @deffn {Funktion} funmake (@var{F}, [@var{arg_1}, @dots{}, @var{arg_n}])
1031 Gibt den Ausdruck @code{@var{F}(@var{arg_1}, ..., @var{arg_n})} zur@"uck. Die
1032 R@"uckgabe wird vereinfacht, aber nicht ausgewertet. Die Funktion @var{F} wird
1033 also nicht aufgerufen, auch wenn diese existiert.
1035 @code{funmake} versucht nicht, Array-Funktionen von gew@"ohnlichen Funktionen zu
1036 unterscheiden. Ist @var{F} der Name einer Array-Funktion, dann gibt
1037 @code{funmake} einen Ausdruck der Form @code{@var{F}(...)} zur@"uck.
1038 F@"ur Array-Funktionen kann die Funktion @mref{arraymake} verwendet werden.
1040 @code{funmake} wertet die Argumente aus.
1042 Beispiele:
1044 @code{funmake} angewendet auf eine gew@"ohnliche Funktion.
1046 @example
1047 (%i1) F (x, y) := y^2 - x^2;
1048 2 2
1049 (%o1) F(x, y) := y - x
1050 (%i2) funmake (F, [a + 1, b + 1]);
1051 (%o2) F(a + 1, b + 1)
1052 (%i3) ''%;
1053 2 2
1054 (%o3) (b + 1) - (a + 1)
1055 @end example
1057 @code{funmake} angewendet auf ein Makro.
1059 @example
1060 (%i1) G (x) ::= (x - 1)/2;
1061 x - 1
1062 (%o1) G(x) ::= -----
1063 2
1064 (%i2) funmake (G, [u]);
1065 (%o2) G(u)
1066 (%i3) ''%;
1067 u - 1
1068 (%o3) -----
1069 2
1070 @end example
1072 @code{funmake} angewendet auf eine indizierte Funktion.
1074 @example
1075 (%i1) H [a] (x) := (x - 1)^a;
1076 a
1077 (%o1) H (x) := (x - 1)
1078 a
1079 (%i2) funmake (H [n], [%e]);
1080 n
1081 (%o2) lambda([x], (x - 1) )(%e)
1082 (%i3) ''%;
1083 n
1084 (%o3) (%e - 1)
1085 (%i4) funmake ('(H [n]), [%e]);
1086 (%o4) H (%e)
1087 n
1088 (%i5) ''%;
1089 n
1090 (%o5) (%e - 1)
1091 @end example
1093 @code{funmake} angewendet auf ein Symbol, welches keine Funktion
1094 repr@"asentiert.
1096 @example
1097 (%i1) funmake (A, [u]);
1098 (%o1) A(u)
1099 (%i2) ''%;
1100 (%o2) A(u)
1101 @end example
1103 @code{funmake} wertet die Argumente, aber nicht die R@"uckgabe aus.
1105 @example
1106 (%i1) det(a,b,c) := b^2 -4*a*c;
1107 2
1108 (%o1) det(a, b, c) := b - 4 a c
1109 (%i2) (x : 8, y : 10, z : 12);
1110 (%o2) 12
1111 (%i3) f : det;
1112 (%o3) det
1113 (%i4) funmake (f, [x, y, z]);
1114 (%o4) det(8, 10, 12)
1115 (%i5) ''%;
1116 (%o5) - 284
1117 @end example
1119 Maxima vereinfacht den R@"uckgabewert der Funktion @code{funmake}.
1121 @example
1122 (%i1) funmake (sin, [%pi / 2]);
1123 (%o1) 1
1124 @end example
1125 @end deffn
1127 @c --- 04.01.2011 DK -----------------------------------------------------------
1128 @anchor{lambda}
1129 @deffn {Funktion} lambda ([@var{x_1}, @dots{}, @var{x_m}], @var{expr_1}, @dots{}, @var{expr_n})
1130 @deffnx {Funktion} lambda ([[@var{L}]], @var{expr_1}, @dots{}, @var{expr_n})
1131 @deffnx {Funktion} lambda ([@var{x_1}, @dots{}, @var{x_m}, [@var{L}]], @var{expr_1}, @dots{}, @var{expr_n})
1133 Definiert einen Lambda-Ausdruck, der auch als anonyme Funktion bezeichnet wird,
1134 und gibt diesen zur@"uck. Die Funktion kann Argumente @var{x_1}, @dots{},
1135 @var{x_m} und optionale Argumente @var{L} haben. Die R@"uckgabe der Funktion
1136 ist das Ergebnis des Ausdrucks @var{exprn}. Ein Lambda-Ausdruck kann einer
1137 Variablen zugewiesen werden und wertet wie eine gew@"ohnliche Funktion aus. Ein
1138 Lambda-Ausdruck kann an solchen Stellen verwendet werden, wo der Name einer
1139 Funktion erwartet wird.
1141 Wird der Lambda-Ausdruck ausgewertet, werden lokale Variablen @var{x_1},
1142 @dots{}, @var{x_m} erzeugt. @code{lambda} kann innerhalb von Bl@"ocken oder
1143 anderen Lambda-Ausdr@"ucken verwendet werden. Mit jeder @code{block}-Anweisung
1144 oder jedem Lambda-Ausdruck werden erneut lokale Variablen erzeugt. Die lokalen
1145 Variablen sind jeweils global zu jeder eingeschlossenen @code{block}-Anweisung
1146 oder zu jedem eingeschlossenen Lambda-Ausdruck. Ist eine Variable innerhalb von
1147 @code{block} oder @code{lambda} nicht lokal, hat sie den Wert der
1148 n@"achst h@"oheren Anweisung, die ihr einen Wert gibt oder den globalen Wert der
1149 Maxima-Umgebung.
1151 Nachdem die lokalen Variablen erzeugt sind, werden die Ausdr@"ucke @var{expr_1},
1152 @dots{}, @var{expr_n} nacheinander ausgewertet. Die Systemvariable @code{%%},
1153 welche das Ergebnis eines vorhergehendes Ausdrucks enth@"alt, kann verwendet
1154 werden. In einem Lambda-Ausdruck k@"onnen die Anweisungen @mref{catch} und
1155 @mref{throw} verwendet werden.
1157 Die @mref{return}-Anweisung kann in einem Lambda-Ausdruck nur verwendet werden,
1158 wenn sie von einer @code{block}-Anweisung eingeschlossen wird. Die
1159 @code{return}-Anweisung definiert jedoch den R@"uckgabewert des Blocks und nicht
1160 des Lambda-Ausdrucks. Auch die @mref{go}-Anweisung kann in einem
1161 Lambda-Ausdrucks nur in einem Block verwendet werden.
1163 @code{lambda} wertet die Argumente nicht aus.
1165 Beispiele:
1167 Ein Lambda-Ausdruck kann einer Variablen zugewiesen werden und wie eine
1168 gew@"ohnliche Funktion ausgewertet werden.
1170 @example
1171 (%i1) f: lambda ([x], x^2);
1172 2
1173 (%o1) lambda([x], x )
1174 (%i2) f(a);
1175 2
1176 (%o2) a
1177 @end example
1179 Ein Lamda-Ausdruck kann an Stellen verwendet werden, wo der Name einer Funktion
1180 erwartet wird.
1182 @example
1183 (%i3) lambda ([x], x^2) (a);
1184 2
1185 (%o3) a
1186 (%i4) apply (lambda ([x], x^2), [a]);
1187 2
1188 (%o4) a
1189 (%i5) map (lambda ([x], x^2), [a, b, c, d, e]);
1190 2 2 2 2 2
1191 (%o5) [a , b , c , d , e ]
1192 @end example
1194 Die Argumente sind lokale Variablen. Andere Variablen sind globale Variablen.
1195 Globale Variablen werden zu dem Zeitpunkt ausgewertet, wenn der Lambda-Ausdruck
1196 ausgewertet wird.
1198 @example
1199 (%i6) a: %pi$
1200 (%i7) b: %e$
1201 (%i8) g: lambda ([a], a*b);
1202 (%o8) lambda([a], a b)
1203 (%i9) b: %gamma$
1204 (%i10) g(1/2);
1205 %gamma
1206 (%o10) ------
1207 2
1208 (%i11) g2: lambda ([a], a*''b);
1209 (%o11) lambda([a], a %gamma)
1210 (%i12) b: %e$
1211 (%i13) g2(1/2);
1212 %gamma
1213 (%o13) ------
1214 2
1215 @end example
1217 Lambda-Ausdr@"ucke k@"onnen verschachtelt werden. Lokale Variablen eines
1218 @"au@ss{}eren Lambda-Ausdrucks sind global zu den enthaltenen
1219 Lambda-Ausdr@"ucken, au@ss{}er diese werden wieder als lokal erkl@"art.
1221 @example
1222 (%i14) h: lambda ([a, b], h2: lambda ([a], a*b), h2(1/2));
1223 1
1224 (%o14) lambda([a, b], h2 : lambda([a], a b), h2(-))
1225 2
1226 (%i15) h(%pi, %gamma);
1227 %gamma
1228 (%o15) ------
1229 2
1230 @end example
1232 Da @code{lambda} die Argumente nicht auswertet, definiert der unten angegebene
1233 Ausdruck @code{i} keine Funktion "multipliziere mit @code{a}". Solch eine
1234 Funktion kann mit Hilfe der Funktion @mref{buildq} definiert werden.
1236 @example
1237 (%i16) i: lambda ([a], lambda ([x], a*x));
1238 (%o16) lambda([a], lambda([x], a x))
1239 (%i17) i(1/2);
1240 (%o17) lambda([x], a x)
1241 (%i18) i2: lambda([a], buildq([a: a], lambda([x], a*x)));
1242 (%o18) lambda([a], buildq([a : a], lambda([x], a x)))
1243 (%i19) i2(1/2);
1244 x
1245 (%o19) lambda([x], -)
1246 2
1247 (%i20) i2(1/2)(%pi);
1248 %pi
1249 (%o20) ---
1250 2
1251 @end example
1253 Ein Lambda-Ausdruck kann eine variable Anzahl an Argumenten haben, wenn das
1254 letzte Argument eine Liste mit einem Element ist.
1256 @example
1257 (%i1) f : lambda ([aa, bb, [cc]], aa * cc + bb);
1258 (%o1) lambda([aa, bb, [cc]], aa cc + bb)
1259 (%i2) f (foo, %i, 17, 29, 256);
1260 (%o2) [17 foo + %i, 29 foo + %i, 256 foo + %i]
1261 (%i3) g : lambda ([[aa]], apply ("+", aa));
1262 (%o3) lambda([[aa]], apply(+, aa))
1263 (%i4) g (17, 29, x, y, z, %e);
1264 (%o4) z + y + x + %e + 46
1265 @end example
1266 @end deffn
1268 @c --- 03.01.2011 DK -----------------------------------------------------------
1269 @anchor{map}
1270 @deffn {Funktion} map (@var{f}, @var{expr_1}, @dots{}, @var{expr_n})
1272 Gibt einen Ausdruck zur@"uck, dessen Hauptoperator derselbe ist, wie der der
1273 Argumente @var{expr_1}, @dots{}, @var{expr_n} aber dessen Operanden das Ergebnis
1274 der Anwendung des Operators @var{f} auf die Teilausdr@"ucke des Ausdrucks sind.
1275 @var{f} ist entweder der Name einer Funktion mit @math{n} Argumenten oder
1276 ein Lambda-Ausdruck mit @math{n} Argumenten.
1278 Hat @mref{maperror} den Wert @code{false}, wird die Anwendung der Funktion
1279 @var{f} gestoppt, (1) wenn die Anwendung auf den k@"urzesten Ausdruck
1280 @var{expr_i} beendet ist und die Ausdr@"ucke nicht alle dieselbe L@"ange haben
1281 oder (2) wenn die Ausdr@"ucke @var{expr_i} einen verschiedenen Typ haben. Hat
1282 @code{maperror} den Wert @code{true} wird in den obigen F@"allen eine
1283 Fehlermeldung ausgegeben.
1285 @c TODO: NICHT UEBERSETZT
1286 @c One of the uses of this function is to @code{map} a function (e.g.
1287 @c @code{partfrac}) onto each term of a very large expression where it
1288 @c ordinarily wouldn't be possible to use the function on the entire expression
1289 @c due to an exhaustion of list storage space in the course of the computation.
1291 @c IN THESE EXAMPLES, SPELL OUT WHAT IS THE MAIN OPERATOR AND SHOW HOW THE
1292 @c RESULT FOLLOWS FROM THE DESCRIPTION STATED IN THE FIRST PARAGRAPH
1294 Beispiele:
1296 @example
1297 (%i1) map(f,x+a*y+b*z);
1298 (%o1) f(b z) + f(a y) + f(x)
1299 (%i2) map(lambda([u],partfrac(u,x)),x+1/(x^3+4*x^2+5*x+2));
1300 1 1 1
1301 (%o2) ----- - ----- + -------- + x
1302 x + 2 x + 1 2
1303 (x + 1)
1304 (%i3) map(ratsimp, x/(x^2+x)+(y^2+y)/y);
1305 1
1306 (%o3) y + ----- + 1
1307 x + 1
1308 (%i4) map("=",[a,b],[-0.5,3]);
1309 (%o4) [a = - 0.5, b = 3]
1312 @end example
1313 @end deffn
1315 @c --- 03.01.2011 DK -----------------------------------------------------------
1316 @anchor{mapatom}
1317 @deffn {Funktion} mapatom (@var{expr})
1319 Gibt den Wert @code{true} zur@"uck, wenn der Ausdruck @var{expr} von Funktionen
1320 die auf Argumente angewendete werden, als ein Atom betrachtet wird. Als Atome
1321 werden Zahlen, einschlie@ss{}lich rationaler Zahlen und gro@ss{}er
1322 Gleitkommazahlen, Symbole und indizierte Symbole betrachtet.
1323 @end deffn
1325 @c --- 03.01.2011 DK -----------------------------------------------------------
1326 @anchor{maperror}
1327 @defvr {Optionsvariable} maperror
1328 Standardwert: @code{true}
1330 Hat @code{maperror} den Wert @code{false}, wird die Anwendung der Funktion
1331 @var{f} gestoppt, (1) wenn die Anwendung auf den k@"urzesten Ausdruck
1332 @var{expr_i} beendet ist und die Ausdr@"ucke nicht alle dieselbe L@"ange haben
1333 oder (2) wenn die Ausdr@"ucke @var{expr_i} einen verschiedenen Typ haben. Hat
1334 @code{maperror} den Wert @code{true} wird in den obigen F@"allen eine
1335 Fehlermeldung ausgegeben.
1336 @end defvr
1338 @c --- 03.01.2011 DK -----------------------------------------------------------
1339 @anchor{mapprint}
1340 @defvr {Optionsvariable} mapprint
1341 Standardwert: @code{true}
1343 Hat @code{mapprint} den Wert @code{true}, werden verschiedene Informationen von
1344 den Funktionen @mrefcomma{map} @mref{maplist} und @mref{fullmap} ausgegeben.
1345 Dies ist der Fall, wenn die Funktion @code{map} die Funktion @code{apply}
1346 aufruft oder wenn f@"ur die Funktion @code{map} die Argumente eine verschiedene
1347 L@"ange haben.
1349 Hat @code{mapprint} den Wert @code{false}, werden diese Meldungen unterdr@"uckt.
1350 @end defvr
1352 @c --- 03.01.2011 DK -----------------------------------------------------------
1353 @anchor{maplist}
1354 @deffn {Funktion} maplist (@var{f}, @var{expr_1}, @dots{}, @var{expr_n})
1356 Wendet die Funktion @var{f} auf die Ausdr@"ucke @var{expr_1}, @dots{},
1357 @var{expr_n} an und gibt das Ergebnis als eine Liste zur@"uck. @var{f} ist der
1358 Name einer Funktion oder ein lambda-Ausdruck.
1360 Im Unterschied zu @code{maplist} gibt die Funktion @mref{map} einen Ausdruck
1361 zur@"uck, der denselben Hauptoperator wie die Ausdr@"ucke @var{expr_i} hat.
1362 @end deffn
1364 @c --- 03.01.2011 DK -----------------------------------------------------------
1365 @anchor{outermap}
1366 @deffn {Funktion} outermap (@var{f}, @var{a_1}, @dots{}, @var{a_n})
1368 Wendet die Funktion @var{f} auf jedes Element des @"au@ss{}eren Produktes der
1369 Argumente @var{a_1} @code{x} @var{a_2} @code{x} @dots{} @code{x} @var{a_n} an.
1371 @var{f} ist der Name einer Funktion mit @math{n} Argumenten oder ein
1372 Lambda-Ausdruck mit @math{n} Argumenten. Jedes Argument @var{a_k} kann eine
1373 Liste oder verschachtelte Liste, eine Matrix oder irgendein anderer Ausdruck
1374 sein.
1376 @c TODO: OBIGE UEBERSETZUNG FEHLEN
1377 @c Note that the effect of @code{outermap} is different from that of applying
1378 @c @var{f} to each one of the elements of the outer product returned by
1379 @c @code{cartesian_product}. @code{outermap} preserves the structure of the
1380 @c arguments in the return value, while @code{cartesian_product} does not.
1382 @code{outermap} wertet die Argumente aus.
1384 Siehe auch @mrefcomma{map} @mref{maplist} und @mrefdot{apply}
1386 Beispiele:
1388 Einfaches Beispiel f@"ur @code{outermap}. Die Funktion @code{F} ist
1389 undefiniert.
1391 @example
1392 (%i1) outermap(F, [a, b, c], [1, 2, 3]);
1393 (%o1) [[F(a, 1), F(a, 2), F(a, 3)], [F(b, 1), F(b, 2), F(b, 3)],
1394 [F(c, 1), F(c, 2), F(c, 3)]]
1395 (%i2) outermap(F, matrix([a, b],[c, d]), matrix([1, 2],[3, 4]));
1396 [ [ F(a, 1) F(a, 2) ] [ F(b, 1) F(b, 2) ] ]
1397 [ [ ] [ ] ]
1398 [ [ F(a, 3) F(a, 4) ] [ F(b, 3) F(b, 4) ] ]
1399 (%o2) [ ]
1400 [ [ F(c, 1) F(c, 2) ] [ F(d, 1) F(d, 2) ] ]
1401 [ [ ] [ ] ]
1402 [ [ F(c, 3) F(c, 4) ] [ F(d, 3) F(d, 4) ] ]
1403 (%i3) outermap (F, [a, b], x, matrix ([1, 2], [3, 4]));
1404 [ F(a, x, 1) F(a, x, 2) ] [ F(b, x, 1) F(b, x, 2) ]
1405 (%o3) [[ ], [ ]]
1406 [ F(a, x, 3) F(a, x, 4) ] [ F(b, x, 3) F(b, x, 4) ]
1407 (%i4) outermap (F, [a, b], matrix ([1, 2]), matrix ([x], [y]));
1408 [ [ F(a, 1, x) ] [ F(a, 2, x) ] ]
1409 (%o4) [[ [ ] [ ] ],
1410 [ [ F(a, 1, y) ] [ F(a, 2, y) ] ]
1411 [ [ F(b, 1, x) ] [ F(b, 2, x) ] ]
1412 [ [ ] [ ] ]]
1413 [ [ F(b, 1, y) ] [ F(b, 2, y) ] ]
1414 (%i5) outermap ("+", [a, b, c], [1, 2, 3]);
1415 (%o5) [[a + 1, a + 2, a + 3], [b + 1, b + 2, b + 3],
1416 [c + 1, c + 2, c + 3]]
1417 @end example
1419 Das Beispiel zeigt die R@"uckgabe der Funktion @code{outermap} detaillierter.
1420 Das erste, zweite und dritte Argument sind eine Matrix, eine Liste und eine
1421 Matrix. Der R@"uckgabewert ist eine Matrix. Jedes Element der Matrix ist eine
1422 Liste und jedes Element der Liste ist eine Matrix.
1424 @example
1425 (%i1) arg_1 : matrix ([a, b], [c, d]);
1426 [ a b ]
1427 (%o1) [ ]
1428 [ c d ]
1429 (%i2) arg_2 : [11, 22];
1430 (%o2) [11, 22]
1431 (%i3) arg_3 : matrix ([xx, yy]);
1432 (%o3) [ xx yy ]
1433 (%i4) xx_0 : outermap(lambda([x, y, z], x / y + z), arg_1,
1434 arg_2, arg_3);
1435 [ [ a a ] [ a a ] ]
1436 [ [[ xx + -- yy + -- ], [ xx + -- yy + -- ]] ]
1437 [ [ 11 11 ] [ 22 22 ] ]
1438 (%o4) Col 1 = [ ]
1439 [ [ c c ] [ c c ] ]
1440 [ [[ xx + -- yy + -- ], [ xx + -- yy + -- ]] ]
1441 [ [ 11 11 ] [ 22 22 ] ]
1442 [ [ b b ] [ b b ] ]
1443 [ [[ xx + -- yy + -- ], [ xx + -- yy + -- ]] ]
1444 [ [ 11 11 ] [ 22 22 ] ]
1445 Col 2 = [ ]
1446 [ [ d d ] [ d d ] ]
1447 [ [[ xx + -- yy + -- ], [ xx + -- yy + -- ]] ]
1448 [ [ 11 11 ] [ 22 22 ] ]
1449 (%i5) xx_1 : xx_0 [1][1];
1450 [ a a ] [ a a ]
1451 (%o5) [[ xx + -- yy + -- ], [ xx + -- yy + -- ]]
1452 [ 11 11 ] [ 22 22 ]
1453 (%i6) xx_2 : xx_0 [1][1] [1];
1454 [ a a ]
1455 (%o6) [ xx + -- yy + -- ]
1456 [ 11 11 ]
1457 (%i7) xx_3 : xx_0 [1][1] [1] [1][1];
1458 a
1459 (%o7) xx + --
1460 11
1461 (%i8) [op (arg_1), op (arg_2), op (arg_3)];
1462 (%o8) [matrix, [, matrix]
1463 (%i9) [op (xx_0), op (xx_1), op (xx_2)];
1464 (%o9) [matrix, [, matrix]
1465 @end example
1467 @code{outermap} erh@"alt die Struktur der Argumente im Ergebnis. Die Funktion
1468 @code{cartesian_product} erh@"alt die Struktur der Argumente nicht.
1470 @example
1471 (%i1) outermap (F, [a, b, c], [1, 2, 3]);
1472 (%o1) [[F(a, 1), F(a, 2), F(a, 3)], [F(b, 1), F(b, 2), F(b, 3)],
1473 [F(c, 1), F(c, 2), F(c, 3)]]
1474 (%i2) setify (flatten (%));
1475 (%o2) @{F(a, 1), F(a, 2), F(a, 3), F(b, 1), F(b, 2), F(b, 3),
1476 F(c, 1), F(c, 2), F(c, 3)@}
1477 (%i3) map(lambda([L], apply(F, L)),
1478 cartesian_product(@{a, b, c@}, @{1, 2, 3@}));
1479 (%o3) @{F(a, 1), F(a, 2), F(a, 3), F(b, 1), F(b, 2), F(b, 3),
1480 F(c, 1), F(c, 2), F(c, 3)@}
1481 (%i4) is (equal (%, %th (2)));
1482 (%o4) true
1483 @end example
1484 @end deffn
1486 @c --- 19.04.2011 DK -----------------------------------------------------------
1487 @anchor{remfunction}
1488 @deffn {Funktion} remfunction (@var{f_1}, @dots{}, @var{f_n})
1489 @deffnx {Funktion} remfunction (all)
1491 Hebt die Bindung der Symbole @var{f_1}, @dots{}, @var{f_n} an ihre
1492 Funktionsdefinitionen auf. Die Argumente k@"onnen die Namen von Funktionen
1493 sein, die mit dem Operator @mref{:=} oder der Funktion @mref{define} definiert
1494 wurden sowie Makro-Funktionen, die mit dem Operator @mref{::=} definiert wurden.
1496 @code{remfunction(all)} entfernt alle Bindungen von Funktionsdefinitionen.
1498 @code{remfunction} gibt eine Liste mit den Symbolen zur@"uck, die von ihren
1499 Funktionsdefinitionen entbunden wurden. @code{false} wird f@"ur die Symbole
1500 zur@"uckgegeben, f@"ur die es keine Funktionsdefinition gibt.
1502 @code{remfunction} wertet die Argumente nicht aus.
1504 @code{remfunction} kann nicht auf Array-Funktionen und indizierte Funktionen
1505 angewendet werden. F@"ur diese Funktionen kann @mref{remarray} verwendet
1506 werden.
1507 @end deffn
1509 @c --- 03.01.2011 DK -----------------------------------------------------------
1510 @anchor{scanmap}
1511 @deffn {Funktion} scanmap (@var{f}, @var{expr})
1512 @deffnx {Funktion} scanmap (@var{f}, @var{expr}, bottomup)
1514 Wendet die Funktion @var{f} rekursiv auf alle Teilausdr@"ucke in @var{expr} an.
1515 Dies kann zum Beispiel verwendet werden, um einen Ausdruck vollst@"andig zu
1516 faktorisieren.
1518 Beispiele:
1520 @example
1521 (%i1) exp:(a^2+2*a+1)*y + x^2$
1522 (%i2) scanmap(factor,exp);
1523 2 2
1524 (%o2) (a + 1) y + x
1525 @end example
1527 @example
1528 (%i3) scanmap(factor,expand(exp));
1529 2 2
1530 (%o3) a y + 2 a y + y + x
1531 @end example
1533 Ein weiteres Beispiel f@"ur die Anwendung einer Funktion auf alle
1534 Teilausdr@"ucke.
1536 @example
1537 (%i4) expr : u*v^(a*x+b) + c$
1538 (%i5) scanmap('f, expr);
1539 f(f(f(a) f(x)) + f(b))
1540 (%o5) f(f(f(u) f(f(v) )) + f(c))
1541 @end example
1543 @code{scanmap (@var{f}, @var{expr}, bottomup)} wendet die Funktion @var{f}
1544 Bottom-up auf den Ausdruck @var{expr} an.
1546 @c TODO: BESSERES BEISPIEL UM DEN UNTERSCHIED ZU ZEIGEN.
1548 @example
1549 scanmap(f,a*x+b) ->
1550 f(a*x+b) -> f(f(a*x)+f(b)) -> f(f(f(a)*f(x))+f(b))
1551 scanmap(f,a*x+b,bottomup) -> f(a)*f(x)+f(b)
1552 -> f(f(a)*f(x))+f(b) ->
1553 f(f(f(a)*f(x))+f(b))
1554 @end example
1555 @end deffn
1557 @c --- End of file Function.de.texi --------------------------------------------