| blob | 15a67bce8b653b1cd351fd31a9fa47c3011c30a8 |
1 @c -----------------------------------------------------------------------------
2 @c File : Lists.de.texi
3 @c License : GNU General Public License (GPL)
4 @c Language : German
5 @c Original : Lists.texi revision 12.06.2011
6 @c Translation : Dr. Dieter Kaiser
7 @c Date : 14.11.2010
8 @c Revision : 17.07.2011
9 @c
10 @c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA
11 @c -----------------------------------------------------------------------------
13 @page
14 @c -----------------------------------------------------------------------------
15 @node Listen, Arrays, Funktionen und Variablen f@"ur Konstante, Datentypen und Strukturen
16 @section Listen
17 @c -----------------------------------------------------------------------------
19 @menu
20 * Einf@"uhrung in Listen::
21 * Funktionen und Variablen f@"ur Listen::
22 @end menu
24 @c -----------------------------------------------------------------------------
25 @node Einf@"uhrung in Listen, Funktionen und Variablen f@"ur Listen, Listen, Listen
26 @subsection Einf@"uhrung in Listen
27 @c -----------------------------------------------------------------------------
29 Listen werden in Maxima mit eckigen Klammern eingegeben und angezeigt:
31 @example
32 [a, b, c, ...]
33 @end example
35 Die Elemente einer Liste k@"onnen Zahlen, Symbole, Ausdr@"ucke und auch Listen
36 sein, wodurch verschachtelte Listen entstehen:
38 @example
39 (%i1) [1, 1/2, a, a+b, sin(x), [log(y)^2, y]];
40 1 2
41 (%o1) [1, -, a, b + a, sin(x), [log (y), y]]
42 2
43 @end example
45 Mit den Funktionen @mref{makelist} und @mref{create_list} k@"onnen Listen aus
46 Ausdr@"ucken generiert werden. Die Funktion @mref{copylist} erzeugt eine Kopie
47 einer Liste. Auf einzelne Elemente oder Teile von Listen kann mit den
48 Funktionen @mrefcomma{first} @mref{rest} oder @mref{last} zugegriffen werden.
49 Mit der Aussagefunktion @mref{listp} kann getestet werden, ob eine Liste
50 vorliegt. F@"ur das Arbeiten mit Listen kennt Maxima die folgenden Funktionen:
52 @verbatim
53 append assoc cons copylist
54 create_list delete eighth endcons
55 fifth first fourth join
56 last length listp makelist
57 member ninth pop push
58 rest reverse second seventh
59 sixth sort sublist sublist_indices
60 tenth third
61 @end verbatim
63 Da Maxima intern alle Ausdr@"ucke als Listen darstellt, k@"onnen viele der oben
64 aufgef@"uhrten Funktionen nicht nur auf Maxima-Listen, sondern auch auf
65 allgemeine Ausdr@"ucke angewendet werden. So wird zum Beispiel die Addition der
66 drei Symbole @code{a}, @code{b}, @code{c} von Maxima intern folgenderma@ss{}en
67 als eine Lisp-Liste dargestellt:
69 @example
70 ((MPLUS) $A $B $C)
71 @end example
73 Der Operator der Addition ist @code{MPLUS} und die Symbole @code{$A}, @code{$B}
74 und @code{$C} sind die Argumente des Operators. Alle Funktionen f@"ur Listen,
75 die nur auf die Argumente wirken, k@"onnen auch auf allgemeine Ausdr@"ucke
76 angewendet werden. Im folgenden werden zum Beispiel die Funktionen
77 @mrefcomma{first} @mrefcomma{last} @mref{cons} und @mref{delete} auf eine
78 Addition angewendet:
80 @example
81 (%i1) expr: a + b + c;
82 (%o1) c + b + a
83 (%i2) first(expr);
84 (%o2) c
85 (%i3) last(expr);
86 (%o3) a
87 (%i4) cons(2*x, expr);
88 (%o4) 2 x + c + b + a
89 (%i5) delete(b, expr);
90 (%o5) c + a
91 @end example
93 Weitere Beispiele f@"ur die Anwendung der Funktionen f@"ur Listen auf allgemeine
94 Ausdr@"ucke sind bei den einzelnen Funktionen angegeben. Eine ausf@"uhrliche
95 Beschreibung der internen Darstellung von Maxima-Ausdr@"ucken ist in
96 @ref{Ausdr@"ucke} enthalten.
98 Auf die einzelnen Elemente einer Liste kann direkt @"uber einen Index
99 zugegriffen werden. Bezeichnet der Index kein Element der Liste, gibt Maxima
100 eine Fehlermeldung aus. Im Folgenden werden Beispiele gezeigt:
102 @example
103 (%i1) list : [a,b,c];
104 (%o1) [a, b, c]
105 (%i2) list[1];
106 (%o2) a
107 (%i3) list[2];
108 (%o3) b
109 (%i4) list[3];
110 (%o4) c
111 (%i5) list[1]: sin(x);
112 (%o5) sin(x)
113 (%i6) list[2]: cos(x);
114 (%o6) cos(x)
115 (%i7) list[3]: tan(x);
116 (%o7) tan(x)
117 (%i8) list;
118 (%o8) [sin(x), cos(x), tan(x)]
119 @end example
121 Listen k@"onnen auch als Argument einer Funktion auftreten. Hat die Funktion
122 die Eigenschaft @mrefcomma{distribute_over} dann wird die Funktion auf die
123 Elemente der Liste angewendet. Dies funktioniert auch f@"ur Funktionen mit
124 mehreren Argumenten.
126 @example
127 (%i1) sin([x,y,z]);
128 (%o1) [sin(x), sin(y), sin(z)]
129 (%i2) mod([x,y],3);
130 (%o2) [mod(x, 3), mod(y, 3)]
131 (%i3) mod([x,y],[5,7]);
132 (%o3) [[mod(x, 5), mod(x, 7)], [mod(y, 5), mod(y, 7)]]
133 @end example
135 @c -----------------------------------------------------------------------------
136 @node Funktionen und Variablen f@"ur Listen, , Einf@"uhrung in Listen, Listen
137 @subsection Funktionen und Variablen f@"ur Listen
138 @c -----------------------------------------------------------------------------
140 @c --- 14.03.2011 DK -----------------------------------------------------------
141 @anchor{[}
142 @anchor{]}
143 @defvr {Operator} [
144 @defvrx {Operator} ]
146 Die Operatoren @code{[} und @code{]} markieren den Anfang und das Ende einer
147 Liste.
149 @code{[} und @code{]} schlie@ss{}en auch die Indizes von Symbolen, Arrays,
150 Hash-Arrays oder Array-Funktionen ein.
152 Beispiele:
154 @example
155 (%i1) x: [a, b, c];
156 (%o1) [a, b, c]
157 (%i2) x[3];
158 (%o2) c
159 (%i3) array (y, fixnum, 3);
160 (%o3) y
161 (%i4) y[2]: %pi;
162 (%o4) %pi
163 (%i5) y[2];
164 (%o5) %pi
165 (%i6) z['foo]: 'bar;
166 (%o6) bar
167 (%i7) z['foo];
168 (%o7) bar
169 (%i8) g[k] := 1/(k^2+1);
170 1
171 (%o8) g := ------
172 k 2
173 k + 1
174 (%i9) g[10];
175 1
176 (%o9) ---
177 101
178 @end example
179 @end defvr
181 @c --- 14.03.2011 DK -----------------------------------------------------------
182 @anchor{append}
183 @deffn {Funktion} append (@var{list_1}, @dots{}, @var{list_n})
185 Gibt eine Liste mit den Elementen der Listen @var{list_1}, @dots{}, @var{list_n}
186 zur@"uck. Ist eines der Argumente @var{list_1}, @dots{}, @var{list_n} keine
187 Liste meldet Maxima einen Fehler.
189 @code{append} kann auch f@"ur allgemeine Ausdr@"ucke genutzt werden.
190 So hat zum Beispiel @code{append(f(a,b), f(c,d,e))} das Ergebnis
191 @code{f(a,b,c,d,e)}. In diesem Fall muss der Operator, der hier @code{f} ist,
192 f@"ur beide Ausdr@"ucke identisch sein, ansonsten meldet Maxima einen Fehler.
194 Siehe auch die Funktionen @mref{cons} und @mrefcomma{endcons} um ein Element
195 einer Liste hin@-zu@-zu@-f@"u@-gen.
197 Beispiele:
199 In den ersten Beispielen werden jeweils Listen mit verschiedenen Elementen
200 zusammengef@"ugt. Im letzten Beispiel wird @code{append} genutzt, um zwei
201 Additionen zusammenzusetzen.
203 @example
204 (%i1) append([a,b], [x,y,z], [1]);
205 (%o1) [a, b, x, y, z, 1]
206 (%i2) append([x+y, 0, -3.2], [2.5e+20, x]);
207 (%o2) [y + x, 0, - 3.2, 2.5e+20, x]
208 (%i3) append([2*a+b], [x+y]);
209 (%o3) [b + 2 a, y + x]
210 (%i4) append(2*a+b, x+y);
211 (%o4) y + x + b + 2 a
212 @end example
213 @end deffn
215 @c --- 14.03.2011 DK -----------------------------------------------------------
216 @anchor{assoc}
217 @deffn {Funktion} assoc (@var{key}, @var{list}, @var{default})
218 @deffnx {Funktion} assoc (@var{key}, @var{list})
220 Ist das Argument @code{list} eine Liste mit paarweisen Elementen der Form
221 @code{[[key_1, value_1], [key_2, value_2], ...]}, wobei @var{key_i} ein
222 Schl@"ussel und @var{value_i} der dazugeh@"orige Wert ist, dann gibt die
223 Funktion @code{assoc} den zum Schl@"ussel @var{key} geh@"orenden Wert
224 @code{value} zur@"uck. Wird der Schl@"ussel nicht gefunden, wird das Argument
225 @code{default} zur@"uckgegeben, wenn es vorhanden ist, oder der Wert
226 @code{false}.
228 Anstatt Paare @code{[key_i, value_i]} k@"onnen auch allgemeine Ausdr@"ucke in
229 der Liste enthalten sein, die zwei Argumente haben. Zum Beispiel sind
230 Eintr@"age der Form @code{x=1} oder @code{a^b} m@"oglich. Im ersten Fall ist
231 @code{x} der Schl@"ussel und im zweiten Fall @code{a}. Die Werte sind jeweils
232 @code{1} und @code{b}.
234 Beispiele:
236 @example
237 (%i1) l : [[info, 10], [warn, 20], [err, 30]];
238 (%o1) [[info, 10], [warn, 20], [err, 30]]
239 (%i2) assoc(info, l);
240 (%o2) 10
241 (%i3) assoc(warn, l);
242 (%o3) 20
243 (%i4) assoc(err, l);
244 (%o4) 30
245 (%i5) l : [x+y, a^(2*b), sin(x) = 0.5];
246 2 b
247 (%o5) [y + x, a , sin(x) = 0.5]
248 (%i6) assoc(x, l);
249 (%o6) y
250 (%i7) assoc(y, l);
251 (%o7) false
252 (%i8) assoc(a, l);
253 (%o8) 2 b
254 (%i9) assoc(sin(x), l);
255 (%o9) 0.5
256 @end example
257 @end deffn
259 @c --- 15.03.2011 DK -----------------------------------------------------------
260 @anchor{cons}
261 @deffn {Funktion} cons (@var{expr}, @var{list})
263 F@"ugt den Ausdruck @var{expr} als erstes Element der Liste @var{list} hinzu.
265 @code{cons} arbeitet auch mit allgemeinen Ausdr@"ucken als Argument @var{list}.
266 In diesem Fall wird dem Hauptoperator des Arguments @var{list} der Ausdruck
267 @var{expr} als erstes Argument hinzugef@"ugt.
269 Siehe auch die Funktion @mrefcomma{endcons} um ein Element an das Ende einer
270 Liste anzuh@"angen sowie die Funktion @mrefcomma{append} um zwei Listen
271 zusammenzuf@"ugen.
273 Beispiele:
275 @example
276 (%i1) cons(x, [a, b, c]);
277 (%o1) [x, a, b, c]
278 (%i2) cons(x^2+1, [a, b, c]);
279 2
280 (%o2) [x + 1, a, b, c]
281 (%i3) cons(x^2+1, a+b+c);
282 2
283 (%o3) x + c + b + a + 1
284 (%i4) cons(x^2+1, f(a,b,c));
285 2
286 (%o4) f(x + 1, a, b, c)
287 @end example
288 @end deffn
290 @c --- 15.03.2011 DK -----------------------------------------------------------
291 @anchor{copylist}
292 @need 800
293 @deffn {Funktion} copylist (@var{list})
295 Gibt eine Kopie der Liste @var{list} zur@"uck.
297 Im Unterschied zur Funktion @code{copylist} wird mit dem Zuweisungsoperator
298 @mref{:} keine Kopie, sondern eine Referenz auf das Original zugewiesen. Das
299 folgende Beispiel zeigt den Unterschied f@"ur den Fall, dass das Original
300 modifiziert wird.
302 @example
303 (%i1) list : [x,y,z];
304 (%o1) [x, y, z]
305 (%i2) a: list;
306 (%o2) [x, y, z]
307 (%i3) b: copylist(list);
308 (%o3) [x, y, z]
309 (%i4) list[2]:99;
310 (%o4) 99
311 (%i5) list;
312 (%o5) [x, 99, z]
313 (%i6) a;
314 (%o6) [x, 99, z]
315 (%i7) b;
316 (%o7) [x, y, z]
317 @end example
318 @end deffn
320 @c --- 15.03.2011 DK -----------------------------------------------------------
321 @anchor{create_list}
322 @deffn {Funktion} create_list (@var{expr}, @var{x_1}, @var{list_1}, @dots{}, @var{x_n}, @var{list_n})
324 Erzeugt eine Liste, indem der Ausdruck @var{expr} zun@"achst f@"ur die Variable
325 @var{x_1} ausgewertet wird. Der Variablen @var{x_1} werden f@"ur die Auswertung
326 nacheinander die Werte der Liste @var{list_1} zugewiesen. Dann wird der
327 Ausdruck @var{expr} f@"ur die Variable @var{x_2} mit den Werten der Liste
328 @var{list_2} ausgewertet u.s.w. Die Anzahl der Elemente der Ergebnisliste ist
329 das Produkt der Anzahl der Elemente der einzelnen Listen @var{list_i}. Die
330 Variablen @var{x_i} m@"ussen Symbole sein, die nicht ausgewertet werden. Die
331 Elemente der Listen @var{list_i} werden vor der Iteration ausgewertet.
333 Anstatt einer Liste @var{list_i} mit den Elementen f@"ur die Iteration kann auch
334 eine untere und obere Grenze angegeben werden. Die Grenzen k@"onnen ganze
335 Zahlen oder Gleitkommazahlen sowie Ausdr@"ucke sein, die zu einer Zahl
336 auswerten. Die Schrittweite ist immer 1. Siehe auch das Beispiel weiter unten.
338 Beispiele:
340 @example
341 (%i1) create_list(x^i, i, [1, 3, 7]);
342 3 7
343 (%o1) [x, x , x ]
344 @end example
346 In diesem Beispiel wird f@"ur zwei Listen iteriert.
348 @example
349 (%i1) create_list([i, j], i, [a, b], j, [e, f, h]);
350 (%o1) [[a, e], [a, f], [a, h], [b, e], [b, f], [b, h]]
351 @end example
353 Anstatt einer Liste @var{list_i} k@"onnen auch zwei Argumente @"ubergeben
354 werden, die jedes zu einer Nummer auswerten. Diese Werte sind die untere und
355 die obere Grenze f@"ur die Iteration.
357 @example
358 (%i1) create_list([i,j],i,[1,2,3],j,1,i);
359 (%o1) [[1, 1], [2, 1], [2, 2], [3, 1], [3, 2], [3, 3]]
360 @end example
361 @end deffn
363 @c --- 15.03.2011 DK -----------------------------------------------------------
364 @anchor{delete}
365 @deffn {Funktion} delete (@var{expr}, @var{list})
366 @deffnx {Funktion} delete (@var{expr}, @var{list}, @var{n})
368 @code{delete(@var{expr}, @var{list})} entfernt aus der Liste @var{list} die
369 Elemente, die gleich dem Ausdruck @var{expr} sind. Mit dem Argument @var{n}
370 kann die Anzahl der Elemente spezifiziert werden, die aus der Liste entfernt
371 werden sollen. @code{delete} gibt eine neue Liste zur@"uck. Das Argument
372 @var{list} wird nicht modifiziert.
374 Die Gleichheit wird mit dem Operator @mref{=} gepr@"uft. Daher werden nur
375 Ausdr@"ucke als gleich erkannt, die syntaktisch @"ubereinstimmen. @"Aquivalente
376 Ausdr@"ucke, die syntaktisch voneinander verschieden sind, werden nicht aus der
377 Liste entfernt. Zum Beispiel sind die Ausdr@"ucke @code{x^2-1} und
378 @code{(x+1)*(x-1)} @"aquivalent, aber syntaktisch verschieden.
380 Das zweite Argument @var{list} kann auch ein allgemeiner Ausdruck sein. In
381 diesem Fall werden die Argumente des Hauptoperators als die Elemente einer Liste
382 angenommen.
384 Beispiele:
386 Entferne Elemente einer Liste.
388 @example
389 (%i1) delete (y, [w, x, y, z, z, y, x, w]);
390 (%o1) [w, x, z, z, x, w]
391 @end example
393 Entferne Terme einer Summe.
395 @example
396 (%i1) delete (sin(x), x + sin(x) + y);
397 (%o1) y + x
398 @end example
400 Entferne Faktoren eines Produkts.
402 @example
403 (%i1) delete (u - x, (u - w)*(u - x)*(u - y)*(u - z));
404 (%o1) (u - w) (u - y) (u - z)
405 @end example
407 Entferne Argumente einer Funktion.
409 @example
410 (%i1) delete (a, f(a, b, c, d, a));
411 (%o1) f(b, c, d)
412 @end example
414 Das Element @code{a} tritt mehrfach auf. Es werden zwei Elemente entfernt.
416 @example
417 (%i1) delete (a, f(a, b, a, c, d, a), 2);
418 (%o1) f(b, c, d, a)
419 @end example
421 Die Gleichheit wird mit dem Operator @code{=} gepr@"uft.
423 @example
424 (%i1) [is(equal (0, 0)), is(equal (0, 0.0)), is(equal (0, 0b0))];
426 `rat' replaced 0.0 by 0/1 = 0.0
427 `rat' replaced 0.0B0 by 0/1 = 0.0B0
428 (%o1) [true, true, true]
429 (%i2) [is (0 = 0), is (0 = 0.0), is (0 = 0b0)];
430 (%o2) [true, false, false]
431 (%i3) delete (0, [0, 0.0, 0b0]);
432 (%o3) [0.0, 0.0b0]
433 (%i4) is (equal ((x + y)*(x - y), x^2 - y^2));
434 (%o4) true
435 (%i5) is ((x + y)*(x - y) = x^2 - y^2);
436 (%o5) false
437 (%i6) delete ((x + y)*(x - y), [(x + y)*(x - y), x^2 - y^2]);
438 2 2
439 (%o6) [x - y ]
440 @end example
441 @end deffn
443 @c --- 15.03.2011 DK -----------------------------------------------------------
444 @anchor{endcons}
445 @deffn {Funktion} endcons (@var{expr}, @var{list})
447 F@"ugt den Ausdruck @var{expr} als letztes Element der Liste @var{list} hinzu.
449 @code{endcons} arbeitet auch mit allgemeinen Ausdr@"ucken als Argument
450 @var{list}. In diesem Fall wird dem Hauptoperator des Arguments @var{list} der
451 Ausdruck @var{expr} als letztes Argument hinzugef@"ugt.
453 Siehe auch die Funktion @mrefcomma{cons} um ein Element am Anfang einer
454 Liste einzuf@"ugen sowie die Funktion @mrefcomma{append} um zwei Listen
455 zusammenzuf@"ugen.
457 Beispiele:
459 @example
460 (%i1) endcons(x, [a, b, c]);
461 (%o1) [a, b, c, x]
462 (%i2) endcons(x^2+1, [a, b, c]);
463 2
464 (%o2) [a, b, c, x + 1]
465 (%i3) endcons(x^2+1, a+b+c);
466 2
467 (%o3) x + c + b + a + 1
468 (%i4) endcons(x^2+1, f(a,b,c));
469 2
470 (%o4) f(a, b, c, x + 1)
471 @end example
472 @end deffn
474 @c --- 15.03.2011 DK -----------------------------------------------------------
475 @anchor{first}
476 @deffn {Funktion} first (@var{list})
478 Gibt das erste Element der Liste @var{list} zur@"uck.
480 Das Argument @var{list} kann auch ein allgemeiner Ausdruck wie zum Beispiel
481 der Term einer Summe, der Faktor eines Produktes oder die erste Spalte einer
482 Matrix sein. Die Funktion @code{first} und verwandte Funktionen wie
483 @mref{last} oder @mref{rest} arbeiten mit der externen Darstellung eines
484 Ausdrucks, wie sie in der Anzeige erscheint. Dies kann mit der Optionsvariablen
485 @mref{inflag} kontrolliert werden. Hat die Optionsvariable @code{inflag} den
486 Wert @code{true}, wird von diesen Funktionen die interne Darstellung betrachtet.
488 Die Funktionen @mref{second} bis @mref{tenth} geben jeweils das 2. bis 10.
489 Element zur@"uck.
491 Beispiele:
493 @example
494 (%i1) l: [a,b,c];
495 (%o1) [a, b, c]
496 (%i2) first(l);
497 (%o2) a
498 (%i3) first(x + y);
499 (%o3) y
500 (%i4) first(x * y);
501 (%o4) x
502 (%i5) first(f(x, y, z));
503 (%o5) x
504 @end example
505 @end deffn
507 @c --- 15.03.2011 DK -----------------------------------------------------------
508 @anchor{join}
509 @deffn {Funktion} join (@var{list_1}, @var{list_2})
511 Erzeugt eine neue Liste aus den Elementen der Listen @var{list_1} und
512 @var{list_2}, wobei die Elemente abwechselnd @"ubernommen werden. Das Ergebnis
513 hat die Form @code{[@var{list_1}[1], @var{list_2}[1], @var{list_1}[2],
514 @var{list_2}[2], ...]}.
516 Haben die Listen verschiedene L@"angen, werden die zus@"atzlichen Elemente der
517 l@"angeren Liste ignoriert.
519 Sind @var{list_1} oder @var{list_2} keine Listen, gibt Maxima einen Fehler aus.
521 Beispiele:
523 @example
524 (%i1) L1: [a, sin(b), c!, d - 1];
525 (%o1) [a, sin(b), c!, d - 1]
526 (%i2) join (L1, [1, 2, 3, 4]);
527 (%o2) [a, 1, sin(b), 2, c!, 3, d - 1, 4]
528 (%i3) join (L1, [aa, bb, cc, dd, ee, ff]);
529 (%o3) [a, aa, sin(b), bb, c!, cc, d - 1, dd]
530 @end example
531 @end deffn
533 @c --- 15.03.2011 DK -----------------------------------------------------------
534 @anchor{last}
535 @deffn {Funktion} last (@var{list})
537 Gibt das letzte Element der Liste @var{list} zur@"uck.
539 Das Argument @var{list} kann auch ein allgemeiner Ausdruck sein. Siehe
540 @mref{first} f@"ur weitere Erl@"auterungen.
542 Beispiele:
544 @example
545 (%i1) l: [a,b,c];
546 (%o1) [a, b, c]
547 (%i2) last(x + y);
548 (%o2) x
549 (%i3) last(x * y);
550 (%o3) y
551 (%i4) last(f(x, y, z));
552 (%o4) z
553 @end example
554 @end deffn
556 @c --- 15.03.2011 DK -----------------------------------------------------------
557 @anchor{length}
558 @deffn {Funktion} length (@var{list})
560 Gibt die Anzahl der Elemente der Liste @var{list} zur@"uck.
562 Das Argument @var{list} kann auch ein allgemeiner Ausdruck sein. Wie bei
563 anderen Funktionen f@"ur Listen wird auch von der Funktion @code{length} die
564 externe Darstellung eines Ausdrucks betrachtet, wie sie f@"ur die Ausgabe
565 vorliegt. Die Optionsvariable @mref{inflag} hat daher Einfluss auf das Ergebnis
566 der Funktion @code{length}.
568 Beispiele:
570 @example
571 (%i1) length([a, x^2, sin(x), y+3]);
572 (%o1) 4
573 (%i2) length(a/(b*x));
574 (%o2) 2
575 (%i3) length(a/(b*x)),inflag:true;
576 (%o3) 3
577 @end example
578 @end deffn
580 @c TODO: DIES GEHOERT IN DAS KAPITEL VEREINFACHUNGEN?!
582 @c --- 15.03.2011 DK -----------------------------------------------------------
583 @anchor{listarith}
584 @need 800
585 @defvr {Optionsvariable} listarith
586 Standardwert: @code{true}
588 Hat die Optionsvariable @code{listarith} den Wert @code{true}, werden
589 Rechenoperationen mit Matrizen und Listen elementweise ausgef@"uhrt. Das
590 Ergebnis von Rechnungen mit Listen und Matrizen sind wieder Listen und Matrizen.
591 Hat die Optionsvariable @code{listarith} den Wert @code{false}, wird die
592 elementweise Ausf@"uhrung der Rechenoperationen unterdr@"uckt.
594 Beispiele:
596 @example
597 (%i1) listarith: true;
598 (%o1) true
599 (%i2) 2 + [a, b, c];
600 (%o2) [a + 2, b + 2, c + 2]
601 (%i3) 2^[a, b, c];
602 a b c
603 (%o3) [2 , 2 , 2 ]
604 (%i4) [1, 2, 3] + [a, b, c];
605 (%o4) [a + 1, b + 2, c + 3]
606 (%i5) listarith: false;
607 (%o5) false
608 (%i6) 2 + [a, b, c];
609 (%o6) [a, b, c] + 2
610 (%i7) 2^[a, b, c];
611 [a, b, c]
612 (%o7) 2
613 (%i8) [1, 2, 3] + [a, b, c];
614 (%o8) [a, b, c] + [1, 2, 3]
615 @end example
616 @end defvr
618 @c --- 15.03.2011 DK -----------------------------------------------------------
619 @anchor{listp}
620 @deffn {Funktion} listp (@var{expr})
622 Gibt @code{true} zur@"uck, wenn @var{expr} eine Liste ist. Ansonsten ist der
623 R@"uckgabewert @code{false}.
624 @end deffn
626 @c --- 15.03.2011 DK -----------------------------------------------------------
627 @anchor{makelist}
628 @deffn {Funktion} makelist (@var{expr}, @var{i}, @var{i_0}, @var{i_1})
629 @deffnx {Funktion} makelist (@var{expr}, @var{x}, @var{list})
631 Erzeugt eine Liste, indem der Ausdruck @var{expr} f@"ur die Variable @var{i}
632 ausgewertet wird. Die Variable @var{i} nimmt nacheinander die Werte von
633 @var{i_0} bis @var{i_1} an, wobei die Schrittweite 1 ist. Alternativ kann eine
634 Liste @var{list} als Argument @"ubergeben werden. In diesem Fall nimmt die
635 Variable @var{i} nacheinander die Werte der Liste @var{list} an.
637 Siehe auch die Funktion @mrefcomma{create_list} um eine Liste zu generieren.
639 Beispiele:
641 @example
642 (%i1) makelist(concat(x, i), i, 1, 6);
643 (%o1) [x1, x2, x3, x4, x5, x6]
644 (%i2) makelist(x = y, y, [a, b, c]);
645 (%o2) [x = a, x = b, x = c]
646 @end example
647 @end deffn
649 @c --- 15.03.2011 DK -----------------------------------------------------------
650 @anchor{member}
651 @deffn {Funktion} member (@var{expr}, @var{list})
653 Gibt @code{true} zur@"uck, wenn der Ausdruck @var{expr} gleich einem Element in
654 der Liste @var{list} ist. Die Gleichheit wird dem Operator
655 @mref{=} festgestellt.
657 Die Gleichheit wird mit dem Operator @mref{=} gepr@"uft. Daher werden nur
658 Ausdr@"ucke als gleich erkannt, die syntaktisch @"ubereinstimmen. @"Aquivalente
659 Ausdr@"ucke, die syntaktisch voneinander verschieden sind, werden nicht aus der
660 Liste entfernt. Zum Beispiel sind die Ausdr@"ucke @code{x^2-1} und
661 @code{(x+1)*(x-1)} @"aquivalent, aber syntaktisch verschieden.
663 Das Argument @var{list} kann auch ein allgemeiner Ausdruck sein. Dabei werden
664 die Argumente des Hauptoperators betrachtet.
666 Siehe auch die Funktion @mrefdot{elementp}
668 Beispiele:
670 @example
671 (%i1) member (8, [8, 8.0, 8b0]);
672 (%o1) true
673 (%i2) member (8, [8.0, 8b0]);
674 (%o2) false
675 (%i3) member (b, [a, b, c]);
676 (%o3) true
677 (%i4) member (b, [[a, b], [b, c]]);
678 (%o4) false
679 (%i5) member ([b, c], [[a, b], [b, c]]);
680 (%o5) true
681 (%i6) F (1, 1/2, 1/4, 1/8);
682 1 1 1
683 (%o6) F(1, -, -, -)
684 2 4 8
685 (%i7) member (1/8, %);
686 (%o7) true
687 (%i8) member ("ab", ["aa", "ab", sin(1), a + b]);
688 (%o8) true
689 @end example
690 @end deffn
692 @c --- 16.03.2011 DK -----------------------------------------------------------
693 @anchor{pop}
694 @deffn {Funktion} pop (@var{list})
696 Die Funktion @code{pop} entfernt das erste Element der Liste @var{list} und
697 gibt dieses Element zur@"uck. @var{list} muss ein Symbol sein, dem eine Liste
698 zugewiesen wurde, und kann nicht selbst eine Liste sein.
700 Ist dem Argument @var{list} keine Liste zugewiesen, gibt Maxima eine
701 Fehlermeldung aus.
703 Siehe auch die Funktion @mref{push} f@"ur Beispiele.
705 Mit dem Kommando @code{load("basic")} wird die Funktion geladen.
706 @end deffn
708 @c --- 16.03.2011 DK -----------------------------------------------------------
709 @anchor{push}
710 @deffn {Funktion} push (@var{item}, @var{list})
712 Die Funktion @code{push} f@"ugt das Argument @var{item} als erstes Element der
713 Liste @var{list} hinzu und gibt die neue Liste zur@"uck. Das Argument
714 @var{list} muss ein Symbol sein, dem eine Liste zugewiesen wurde, und kann nicht
715 selbst eine Liste sein. Das Argument @var{item} kann ein beliebiger Ausdruck
716 sein.
718 Ist dem Argument @var{list} keine Liste zugewiesen, gibt Maxima eine
719 Fehlermeldung aus.
721 Siehe auch die Funktion @mrefcomma{pop} um das erste Element einer Liste zu
722 entfernen.
724 Mit dem Kommando @code{load("basic")} wird die Funktion geladen.
726 Beispiele:
728 @example
729 (%i1) ll:[];
730 (%o1) []
731 (%i2) push(x,ll);
732 (%o2) [x]
733 (%i3) push(x^2+y,ll);
734 2
735 (%o3) [y + x , x]
736 (%i4) a:push("string",ll);
737 2
738 (%o4) [string, y + x , x]
739 (%i5) pop(ll);
740 (%o5) string
741 (%i6) pop(ll);
742 2
743 (%o6) y + x
744 (%i7) pop(ll);
745 (%o7) x
746 (%i8) ll;
747 (%o8) []
748 (%i9) a;
749 2
750 (%o9) [string, y + x , x]
751 @end example
752 @end deffn
754 @c --- 16.03.2011 DK -----------------------------------------------------------
755 @anchor{rest}
756 @deffn {Funktion} rest (@var{list}, @var{n})
757 @deffnx {Funktion} rest (@var{list})
759 Entfernt das erste Element oder, wenn @var{n} eine positive ganze Zahl ist, die
760 ersten @var{n} Elemente der Liste @var{list} und gibt den Rest der Liste als
761 Ergebnis zur@"uck. Ist @var{n} eine negative Zahl, werden die letzten @var{n}
762 Elemente von der Liste entfernt und der Rest als Ergebnis zur@"uckgegeben.
764 Das Argument @var{list} kann auch ein allgemeiner Ausdruck sein.
766 Siehe auch die Funktionen @mref{first} und @mrefdot{last}
768 Beispiele:
770 @example
771 (%i1) rest([a,b,c]);
772 (%o1) [b, c]
773 (%i2) rest(a+b+c);
774 (%o2) b + a
775 @end example
776 @end deffn
778 @c --- 16.03.2011 DK -----------------------------------------------------------
779 @anchor{reverse}
780 @deffn {Funktion} reverse (@var{list})
782 Kehrt die Anordnung der Elemente einer Liste @var{list} um und gibt die
783 Ergebnisliste zur@"uck. Das Argument @var{list} kann auch ein allgemeiner
784 Ausdruck sein.
786 Beispiele:
788 @example
789 (%i1) reverse([a, b, c]);
790 (%o1) [c, b, a]
791 (%i2) reverse(sin(x)=2*x^2+1);
792 2
793 (%o2) 2 x + 1 = sin(x)
794 @end example
795 @end deffn
797 @c --- 16.03.2011 DK -----------------------------------------------------------
798 @anchor{second}
799 @anchor{third}
800 @anchor{fourth}
801 @anchor{fifth}
802 @anchor{sixth}
803 @anchor{seventh}
804 @anchor{eighth}
805 @anchor{ninth}
806 @anchor{tenth}
807 @deffn {Funktion} second (@var{list})
808 @deffnx {Funktion} third (@var{list})
809 @deffnx {Funktion} fourth (@var{list})
810 @deffnx {Funktion} fifth (@var{list})
811 @deffnx {Funktion} sixth (@var{list})
812 @deffnx {Funktion} seventh (@var{list})
813 @deffnx {Funktion} eighth (@var{list})
814 @deffnx {Funktion} ninth (@var{list})
815 @deffnx {Funktion} tenth (@var{list})
817 Die Funktionen @code{second} bis @code{tenth} geben das 2. bis 10. Element eines
818 Ausdrucks oder einer Liste @var{list} zur@"uck. Siehe @mrefdot{first}
819 @end deffn
821 @c --- 20.03.2011 DK -----------------------------------------------------------
822 @anchor{sort}
823 @deffn {Funktion} sort (@var{L}, @var{P})
824 @deffnx {Funktion} sort (@var{L})
826 Sortiert eine Liste @var{L} und gibt die sortierte Liste zur@"uck. Das
827 optionale Argument @var{P} ist eine Aussagefunktion mit zwei Argumenten, die
828 eine Ordnung der Elemente definiert. Die Aussagefunktion kann eine Funktion,
829 ein bin@"arer Operator oder ein Lambda-Ausdruck sein. Wird kein Argument
830 @var{P} angegeben, werden die Elemente der Liste mit der Aussagefunktion
831 @mref{orderlessp} geordnet.
833 Die Aussagefunktion @mref{orderlessp} sortiert eine List aufsteigend. Mit der
834 Aussagefunktion @mref{ordergreatp} kann die Liste absteigend sortiert werden.
835 Die Aussagefunktion @mref{ordermagnitudep} sortiert Maxima Zahlen, Konstante
836 oder Ausdr@"ucke, die zu einer Zahl oder Konstanten ausgewertet werden k@"onnen,
837 nach der Gr@"o@ss{}e. Mit dem Operator @mref{<} kann auch nach der Gr@"o@ss{}e
838 sortiert werden. Im Unterschied zur Aussagefunktion @code{ordermagnitudep} ist
839 die Ordnung nicht vollst@"andig, wenn einzelne Elemente der Liste nicht
840 vergleichbar unter dem Operator @code{<} sind.
842 Beispiele:
844 @example
845 (%i1) sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9 * c,
846 19 - 3 * x]);
847 5
848 (%o1) [- 17, - -, 3, 7.55, 11, 2.9b1, b + a, 9 c, 19 - 3 x]
849 2
850 (%i2) sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9*c, 19 - 3*x],
851 ordergreatp);
852 5
853 (%o2) [19 - 3 x, 9 c, b + a, 2.9b1, 11, 7.55, 3, - -, - 17]
854 2
855 (%i3) sort ([%pi, 3, 4, %e, %gamma]);
856 (%o3) [3, 4, %e, %gamma, %pi]
857 (%i4) sort ([%pi, 3, 4, %e, %gamma], "<");
858 (%o4) [%gamma, %e, 3, %pi, 4]
859 (%i5) my_list: [[aa,hh,uu], [ee,cc], [zz,xx,mm,cc], [%pi,%e]];
860 (%o5) [[aa, hh, uu], [ee, cc], [zz, xx, mm, cc], [%pi, %e]]
861 (%i6) sort (my_list);
862 (%o6) [[%pi, %e], [aa, hh, uu], [ee, cc], [zz, xx, mm, cc]]
863 (%i7) sort (my_list, lambda ([a, b], orderlessp (reverse (a),
864 reverse (b))));
865 (%o7) [[%pi, %e], [ee, cc], [zz, xx, mm, cc], [aa, hh, uu]]
866 @end example
868 Ordne Maxima Zahlen, Konstante und konstante Ausdr@"ucke nach der Gr@"o@ss{}e.
869 Alle anderen Elemente werden aufsteigend sortiert.
871 @example
872 @group
873 (%i8) sort([%i,1+%i,2*x,minf,inf,%e,sin(1),0,1,2,3,1.0,1.0b0],
874 ordermagnitudep);
875 @end group
876 (%o8) [minf, 0, sin(1), 1, 1.0, 1.0b0, 2, %e, 3, inf, %i,
877 %i + 1, 2 x]
878 @end example
879 @end deffn
881 @c --- 16.03.2011 DK -----------------------------------------------------------
882 @anchor{sublist}
883 @deffn {Funktion} sublist (@var{L}, @var{P})
885 Gibt die Elemente der Liste @var{L} als eine Liste zur@"uck, f@"ur die die
886 Aussagefunktion @code{P} das Ergebnis @code{true} hat. @code{P} ist eine
887 Funktion mit einem Argument wie zum Beispiel die Funktion
888 @mrefdot{integerp} Siehe auch die Funktion @mrefdot{sublist_indices}
890 Beispiele:
892 @example
893 (%i1) L: [1, 2, 3, 4, 5, 6];
894 (%o1) [1, 2, 3, 4, 5, 6]
895 (%i2) sublist (L, evenp);
896 (%o2) [2, 4, 6]
897 @end example
898 @end deffn
900 @c --- 16.11.2010 DK -----------------------------------------------------------
901 @anchor{sublist_indices}
902 @deffn {Funktion} sublist_indices (@var{L}, @var{P})
904 Gibt die Indizes der Elemente der Liste @var{L} zur@"uck, f@"ur die die
905 Aussagefunktion @code{P} das Ergebnis @code{true} hat. @code{P} ist eine
906 Funktion mit einem Argument wie zum Beispiel die Funktion
907 @mrefdot{integerp} Siehe auch die Funktion @mrefdot{sublist}
909 Beispiele:
911 @example
912 (%i1) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b],
913 lambda ([x], x='b));
914 (%o1) [2, 3, 7, 9]
915 (%i2) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], symbolp);
916 (%o2) [1, 2, 3, 4, 7, 9]
917 (%i3) sublist_indices ([1 > 0, 1 < 0, 2 < 1, 2 > 1, 2 > 0],
918 identity);
919 (%o3) [1, 4, 5]
920 (%i4) assume (x < -1);
921 (%o4) [x < - 1]
922 (%i5) map (maybe, [x > 0, x < 0, x < -2]);
923 (%o5) [false, true, unknown]
924 (%i6) sublist_indices ([x > 0, x < 0, x < -2], identity);
925 (%o6) [2]
926 @end example
927 @end deffn
929 @c --- 16.03.2011 DK -----------------------------------------------------------
930 @anchor{unique}
931 @deffn {Funktion} unique (@var{L})
933 Gibt eine Liste mit den Elementen der Liste @var{L} zur@"uck, die sich
934 voneinander unterscheiden. Sind alle Elemente der Liste @var{L} verschieden,
935 gibt @code{unique} eine Kopie der Liste @var{L} und nicht die Liste selbst
936 zur@"uck. Ist @var{L} keine Liste, gibt @code{unique} den Ausdruck @var{L}
937 zur@"uck.
939 Beispiel:
941 @example
942 (%i1) unique ([1, %pi, a + b, 2, 1, %e, %pi, a + b, [1]]);
943 (%o1) [1, 2, %e, %pi, [1], b + a]
944 @end example
945 @end deffn
947 @c --- End of file Lists.de.texi -----------------------------------------------