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

@page
@c -----------------------------------------------------------------------------
@node Listen, Arrays, Funktionen und Variablen f@"ur Konstante, Datentypen und Strukturen
@section Listen
@c -----------------------------------------------------------------------------

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

@c -----------------------------------------------------------------------------
@node Einf@"uhrung in Listen, Funktionen und Variablen f@"ur Listen, Listen, Listen
@subsection Einf@"uhrung in Listen
@c -----------------------------------------------------------------------------

Listen werden in Maxima mit eckigen Klammern eingegeben und angezeigt:

@example
[a, b, c, ...]
@end example

Die Elemente einer Liste k@"onnen Zahlen, Symbole, Ausdr@"ucke und auch Listen
sein, wodurch verschachtelte Listen entstehen:

@example
(%i1) [1, 1/2, a, a+b, sin(x), [log(y)^2, y]];
                 1                        2
(%o1)        [1, -, a, b + a, sin(x), [log (y), y]]
                 2
@end example

Mit den Funktionen @mref{makelist} und @mref{create_list} k@"onnen Listen aus
Ausdr@"ucken generiert werden.  Die Funktion @mref{copylist} erzeugt eine Kopie
einer Liste.  Auf einzelne Elemente oder Teile von Listen kann mit den
Funktionen @mrefcomma{first} @mref{rest} oder @mref{last} zugegriffen werden.
Mit der Aussagefunktion @mref{listp} kann getestet werden, ob eine Liste
vorliegt.  F@"ur das Arbeiten mit Listen kennt Maxima die folgenden Funktionen:

@verbatim
   append        assoc     cons      copylist
   create_list   delete    eighth    endcons
   fifth         first     fourth    join
   last          length    listp     makelist
   member        ninth     pop       push
   rest          reverse   second    seventh
   sixth         sort      sublist   sublist_indices
   tenth         third
@end verbatim

Da Maxima intern alle Ausdr@"ucke als Listen darstellt, k@"onnen viele der oben
aufgef@"uhrten Funktionen nicht nur auf Maxima-Listen, sondern auch auf
allgemeine Ausdr@"ucke angewendet werden.  So wird zum Beispiel die Addition der
drei Symbole @code{a}, @code{b}, @code{c} von Maxima intern folgenderma@ss{}en
als eine Lisp-Liste dargestellt:

@example
   ((MPLUS) $A $B $C)
@end example

Der Operator der Addition ist @code{MPLUS} und die Symbole @code{$A}, @code{$B}
und @code{$C} sind die Argumente des Operators.  Alle Funktionen f@"ur Listen,
die nur auf die Argumente wirken, k@"onnen auch auf allgemeine Ausdr@"ucke
angewendet werden.  Im folgenden werden zum Beispiel die Funktionen
@mrefcomma{first} @mrefcomma{last} @mref{cons} und @mref{delete} auf eine
Addition angewendet:

@example
(%i1) expr: a + b + c;
(%o1)                       c + b + a
(%i2) first(expr);
(%o2)                           c
(%i3) last(expr);
(%o3)                           a
(%i4) cons(2*x, expr);
(%o4)                    2 x + c + b + a
(%i5) delete(b, expr);
(%o5)                         c + a
@end example

Weitere Beispiele f@"ur die Anwendung der Funktionen f@"ur Listen auf allgemeine
Ausdr@"ucke sind bei den einzelnen Funktionen angegeben.  Eine ausf@"uhrliche
Beschreibung der internen Darstellung von Maxima-Ausdr@"ucken ist in
@ref{Ausdr@"ucke} enthalten.

Auf die einzelnen Elemente einer Liste kann direkt @"uber einen Index
zugegriffen werden.  Bezeichnet der Index kein Element der Liste, gibt Maxima
eine Fehlermeldung aus.  Im Folgenden werden Beispiele gezeigt:

@example
(%i1) list : [a,b,c];
(%o1)                       [a, b, c]
(%i2) list[1];
(%o2)                           a
(%i3) list[2];
(%o3)                           b
(%i4) list[3];
(%o4)                           c
(%i5) list[1]: sin(x);
(%o5)                        sin(x)
(%i6) list[2]: cos(x);
(%o6)                        cos(x)
(%i7) list[3]: tan(x);
(%o7)                        tan(x)
(%i8) list;
(%o8)               [sin(x), cos(x), tan(x)]
@end example

Listen k@"onnen auch als Argument einer Funktion auftreten.  Hat die Funktion
die Eigenschaft @mrefcomma{distribute_over} dann wird die Funktion auf die
Elemente der Liste angewendet.  Dies funktioniert auch f@"ur Funktionen mit
mehreren Argumenten.

@example
(%i1) sin([x,y,z]);
(%o1)               [sin(x), sin(y), sin(z)]
(%i2) mod([x,y],3);
(%o2)                [mod(x, 3), mod(y, 3)]
(%i3) mod([x,y],[5,7]);
(%o3)   [[mod(x, 5), mod(x, 7)], [mod(y, 5), mod(y, 7)]]
@end example

@c -----------------------------------------------------------------------------
@node Funktionen und Variablen f@"ur Listen, , Einf@"uhrung in Listen, Listen
@subsection Funktionen und Variablen f@"ur Listen
@c -----------------------------------------------------------------------------

@c --- 14.03.2011 DK -----------------------------------------------------------
@anchor{[}
@anchor{]}
@defvr  {Operator} [
@defvrx {Operator} ]

Die Operatoren @code{[} und @code{]} markieren den Anfang und das Ende einer
Liste.

@code{[} und @code{]} schlie@ss{}en auch die Indizes von Symbolen, Arrays, 
Hash-Arrays oder Array-Funktionen ein.

Beispiele:

@example
(%i1) x: [a, b, c];
(%o1)                       [a, b, c]
(%i2) x[3];
(%o2)                           c
(%i3) array (y, fixnum, 3);
(%o3)                           y
(%i4) y[2]: %pi;
(%o4)                          %pi
(%i5) y[2];
(%o5)                          %pi
(%i6) z['foo]: 'bar;
(%o6)                          bar
(%i7) z['foo];
(%o7)                          bar
(%i8) g[k] := 1/(k^2+1);
                                  1
(%o8)                     g  := ------
                           k     2
                                k  + 1
(%i9) g[10];
                                1
(%o9)                          ---
                               101
@end example
@end defvr

@c --- 14.03.2011 DK -----------------------------------------------------------
@anchor{append}
@deffn {Funktion} append (@var{list_1}, @dots{}, @var{list_n})

Gibt eine Liste mit den Elementen der Listen @var{list_1}, @dots{}, @var{list_n}
zur@"uck.  Ist eines der Argumente @var{list_1}, @dots{}, @var{list_n} keine
Liste meldet Maxima einen Fehler.

@code{append} kann auch f@"ur allgemeine Ausdr@"ucke genutzt werden.
So hat zum Beispiel @code{append(f(a,b), f(c,d,e))} das Ergebnis
@code{f(a,b,c,d,e)}.  In diesem Fall muss der Operator, der hier @code{f} ist,
f@"ur beide Ausdr@"ucke identisch sein, ansonsten meldet Maxima einen Fehler.

Siehe auch die Funktionen @mref{cons} und @mrefcomma{endcons} um ein Element
einer Liste hin@-zu@-zu@-f@"u@-gen.

Beispiele:

In den ersten Beispielen werden jeweils Listen mit verschiedenen Elementen
zusammengef@"ugt.  Im letzten Beispiel wird @code{append} genutzt, um zwei
Additionen zusammenzusetzen.

@example
(%i1) append([a,b], [x,y,z], [1]);
(%o1)                  [a, b, x, y, z, 1]
(%i2) append([x+y, 0, -3.2], [2.5e+20, x]);
(%o2)             [y + x, 0, - 3.2, 2.5e+20, x]
(%i3) append([2*a+b], [x+y]);
(%o3)                   [b + 2 a, y + x]
(%i4) append(2*a+b, x+y);
(%o4)                    y + x + b + 2 a
@end example
@end deffn

@c --- 14.03.2011 DK -----------------------------------------------------------
@anchor{assoc}
@deffn  {Funktion} assoc (@var{key}, @var{list}, @var{default})
@deffnx {Funktion} assoc (@var{key}, @var{list})

Ist das Argument @code{list} eine Liste mit paarweisen Elementen der Form
@code{[[key_1, value_1], [key_2, value_2], ...]}, wobei @var{key_i} ein
Schl@"ussel und @var{value_i} der dazugeh@"orige Wert ist, dann gibt die
Funktion @code{assoc} den zum Schl@"ussel @var{key} geh@"orenden Wert
@code{value} zur@"uck.  Wird der Schl@"ussel nicht gefunden, wird das Argument
@code{default} zur@"uckgegeben, wenn es vorhanden ist, oder der Wert
@code{false}.

Anstatt Paare @code{[key_i, value_i]} k@"onnen auch allgemeine Ausdr@"ucke in 
der Liste enthalten sein, die zwei Argumente haben.  Zum Beispiel sind 
Eintr@"age der Form @code{x=1} oder @code{a^b} m@"oglich.  Im ersten Fall ist 
@code{x} der Schl@"ussel und im zweiten Fall @code{a}.  Die Werte sind jeweils 
@code{1} und @code{b}.

Beispiele:

@example
(%i1) l : [[info, 10], [warn, 20], [err, 30]];
(%o1)          [[info, 10], [warn, 20], [err, 30]]
(%i2) assoc(info, l);
(%o2)                          10
(%i3) assoc(warn, l);
(%o3)                          20
(%i4) assoc(err, l);
(%o4)                          30
(%i5) l : [x+y, a^(2*b), sin(x) = 0.5];
                            2 b
(%o5)              [y + x, a   , sin(x) = 0.5]
(%i6) assoc(x, l);
(%o6)                           y
(%i7) assoc(y, l);
(%o7)                         false
(%i8) assoc(a, l);
(%o8)                          2 b
(%i9) assoc(sin(x), l);
(%o9)                          0.5
@end example
@end deffn

@c --- 15.03.2011 DK -----------------------------------------------------------
@anchor{cons}
@deffn {Funktion} cons (@var{expr}, @var{list})

F@"ugt den Ausdruck @var{expr} als erstes Element der Liste @var{list} hinzu.

@code{cons} arbeitet auch mit allgemeinen Ausdr@"ucken als Argument @var{list}.
In diesem Fall wird dem Hauptoperator des Arguments @var{list} der Ausdruck
@var{expr} als erstes Argument hinzugef@"ugt.

Siehe auch die Funktion @mrefcomma{endcons} um ein Element an das Ende einer
Liste anzuh@"angen sowie die Funktion @mrefcomma{append} um zwei Listen
zusammenzuf@"ugen.

Beispiele:

@example
(%i1) cons(x, [a, b, c]);
(%o1)                     [x, a, b, c]
(%i2) cons(x^2+1, [a, b, c]);
                          2
(%o2)                   [x  + 1, a, b, c]
(%i3) cons(x^2+1, a+b+c);
                        2
(%o3)                  x  + c + b + a + 1
(%i4) cons(x^2+1, f(a,b,c));
                          2
(%o4)                  f(x  + 1, a, b, c)
@end example
@end deffn

@c --- 15.03.2011 DK -----------------------------------------------------------
@anchor{copylist}
@need 800
@deffn {Funktion} copylist (@var{list})

Gibt eine Kopie der Liste @var{list} zur@"uck.

Im Unterschied zur Funktion @code{copylist} wird mit dem Zuweisungsoperator
@mref{:} keine Kopie, sondern eine Referenz auf das Original zugewiesen.  Das
folgende Beispiel zeigt den Unterschied f@"ur den Fall, dass das Original
modifiziert wird.

@example
(%i1) list : [x,y,z];
(%o1)                       [x, y, z]
(%i2) a: list;
(%o2)                       [x, y, z]
(%i3) b: copylist(list);
(%o3)                       [x, y, z]
(%i4) list[2]:99;
(%o4)                          99
(%i5) list;
(%o5)                      [x, 99, z]
(%i6) a;
(%o6)                      [x, 99, z]
(%i7) b;
(%o7)                       [x, y, z]
@end example
@end deffn

@c --- 15.03.2011 DK -----------------------------------------------------------
@anchor{create_list}
@deffn {Funktion} create_list (@var{expr}, @var{x_1}, @var{list_1}, @dots{}, @var{x_n}, @var{list_n})

Erzeugt eine Liste, indem der Ausdruck @var{expr} zun@"achst f@"ur die Variable
@var{x_1} ausgewertet wird.  Der Variablen @var{x_1} werden f@"ur die Auswertung 
nacheinander die Werte der Liste @var{list_1} zugewiesen.  Dann wird der
Ausdruck @var{expr} f@"ur die Variable @var{x_2} mit den Werten der Liste
@var{list_2} ausgewertet u.s.w.  Die Anzahl der Elemente der Ergebnisliste ist
das Produkt der Anzahl der Elemente der einzelnen Listen @var{list_i}.  Die
Variablen @var{x_i} m@"ussen Symbole sein, die nicht ausgewertet werden.  Die 
Elemente der Listen @var{list_i} werden vor der Iteration ausgewertet.

Anstatt einer Liste @var{list_i} mit den Elementen f@"ur die Iteration kann auch
eine untere und obere Grenze angegeben werden.  Die Grenzen k@"onnen ganze
Zahlen oder Gleitkommazahlen sowie Ausdr@"ucke sein, die zu einer Zahl
auswerten.  Die Schrittweite ist immer 1.  Siehe auch das Beispiel weiter unten.

Beispiele:

@example
(%i1) create_list(x^i, i, [1, 3, 7]);
                 3   7
(%o1)       [x, x , x ]
@end example

In diesem Beispiel wird f@"ur zwei Listen iteriert.

@example
(%i1) create_list([i, j], i, [a, b], j, [e, f, h]);
(%o1) [[a, e], [a, f], [a, h], [b, e], [b, f], [b, h]]
@end example

Anstatt einer Liste @var{list_i} k@"onnen auch zwei Argumente @"ubergeben 
werden, die jedes zu einer Nummer auswerten.  Diese Werte sind die untere und
die obere Grenze f@"ur die Iteration.

@example
(%i1) create_list([i,j],i,[1,2,3],j,1,i);
(%o1) [[1, 1], [2, 1], [2, 2], [3, 1], [3, 2], [3, 3]]
@end example
@end deffn

@c --- 15.03.2011 DK -----------------------------------------------------------
@anchor{delete}
@deffn  {Funktion} delete (@var{expr}, @var{list})
@deffnx {Funktion} delete (@var{expr}, @var{list}, @var{n})

@code{delete(@var{expr}, @var{list})} entfernt aus der Liste @var{list} die
Elemente, die gleich dem Ausdruck @var{expr} sind.  Mit dem Argument @var{n}
kann die Anzahl der Elemente spezifiziert werden, die aus der Liste entfernt
werden sollen.  @code{delete} gibt eine neue Liste zur@"uck.  Das Argument
@var{list} wird nicht modifiziert.

Die Gleichheit wird mit dem Operator @mref{=} gepr@"uft.  Daher werden nur
Ausdr@"ucke als gleich erkannt, die syntaktisch @"ubereinstimmen.  @"Aquivalente
Ausdr@"ucke, die syntaktisch voneinander verschieden sind, werden nicht aus der
Liste entfernt.  Zum Beispiel sind die Ausdr@"ucke @code{x^2-1} und
@code{(x+1)*(x-1)} @"aquivalent, aber syntaktisch verschieden.

Das zweite Argument @var{list} kann auch ein allgemeiner Ausdruck sein.  In 
diesem Fall werden die Argumente des Hauptoperators als die Elemente einer Liste
angenommen.

Beispiele:

Entferne Elemente einer Liste.

@example
(%i1) delete (y, [w, x, y, z, z, y, x, w]);
(%o1)                  [w, x, z, z, x, w]
@end example

Entferne Terme einer Summe.

@example
(%i1) delete (sin(x), x + sin(x) + y);
(%o1)                         y + x
@end example

Entferne Faktoren eines Produkts.

@example
(%i1) delete (u - x, (u - w)*(u - x)*(u - y)*(u - z));
(%o1)                (u - w) (u - y) (u - z)
@end example

Entferne Argumente einer Funktion.

@example
(%i1) delete (a, f(a, b, c, d, a));
(%o1)                     f(b, c, d)
@end example

Das Element @code{a} tritt mehrfach auf.  Es werden zwei Elemente entfernt.

@example
(%i1) delete (a, f(a, b, a, c, d, a), 2);
(%o1)                    f(b, c, d, a)
@end example

Die Gleichheit wird mit dem Operator @code{=} gepr@"uft.

@example
(%i1) [is(equal (0, 0)), is(equal (0, 0.0)), is(equal (0, 0b0))];

`rat' replaced 0.0 by 0/1 = 0.0
`rat' replaced 0.0B0 by 0/1 = 0.0B0
(%o1)                  [true, true, true]
(%i2) [is (0 = 0), is (0 = 0.0), is (0 = 0b0)];
(%o2)                 [true, false, false]
(%i3) delete (0, [0, 0.0, 0b0]);
(%o3)                     [0.0, 0.0b0]
(%i4) is (equal ((x + y)*(x - y), x^2 - y^2));
(%o4)                         true
(%i5) is ((x + y)*(x - y) = x^2 - y^2);
(%o5)                         false
(%i6) delete ((x + y)*(x - y), [(x + y)*(x - y), x^2 - y^2]);
                              2    2
(%o6)                       [x  - y ]
@end example
@end deffn

@c --- 15.03.2011 DK -----------------------------------------------------------
@anchor{endcons}
@deffn {Funktion} endcons (@var{expr}, @var{list})

F@"ugt den Ausdruck @var{expr} als letztes Element der Liste @var{list} hinzu.

@code{endcons} arbeitet auch mit allgemeinen Ausdr@"ucken als Argument
@var{list}.  In diesem Fall wird dem Hauptoperator des Arguments @var{list} der
Ausdruck @var{expr} als letztes Argument hinzugef@"ugt.

Siehe auch die Funktion @mrefcomma{cons} um ein Element am Anfang einer
Liste einzuf@"ugen sowie die Funktion @mrefcomma{append} um zwei Listen
zusammenzuf@"ugen.

Beispiele:

@example
(%i1) endcons(x, [a, b, c]);
(%o1)                     [a, b, c, x]
(%i2) endcons(x^2+1, [a, b, c]);
                                   2
(%o2)                   [a, b, c, x  + 1]
(%i3) endcons(x^2+1, a+b+c);
                        2
(%o3)                  x  + c + b + a + 1
(%i4) endcons(x^2+1, f(a,b,c));
                                   2
(%o4)                  f(a, b, c, x  + 1)
@end example
@end deffn

@c --- 15.03.2011 DK -----------------------------------------------------------
@anchor{first}
@deffn {Funktion} first (@var{list})

Gibt das erste Element der Liste @var{list} zur@"uck.

Das Argument @var{list} kann auch ein allgemeiner Ausdruck wie zum Beispiel
der Term einer Summe, der Faktor eines Produktes oder die erste Spalte einer
Matrix sein.  Die Funktion @code{first} und verwandte Funktionen wie
@mref{last} oder @mref{rest} arbeiten mit der externen Darstellung eines
Ausdrucks, wie sie in der Anzeige erscheint.  Dies kann mit der Optionsvariablen
@mref{inflag} kontrolliert werden.  Hat die Optionsvariable @code{inflag} den
Wert @code{true}, wird von diesen Funktionen die interne Darstellung betrachtet.

Die Funktionen @mref{second} bis @mref{tenth} geben jeweils das 2. bis 10. 
Element zur@"uck.

Beispiele:

@example
(%i1) l: [a,b,c];
(%o1)                       [a, b, c]
(%i2) first(l);
(%o2)                           a
(%i3) first(x + y);
(%o3)                           y
(%i4) first(x * y);
(%o4)                           x
(%i5) first(f(x, y, z));
(%o5)                           x
@end example
@end deffn

@c --- 15.03.2011 DK -----------------------------------------------------------
@anchor{join}
@deffn {Funktion} join (@var{list_1}, @var{list_2})

Erzeugt eine neue Liste aus den Elementen der Listen @var{list_1} und
@var{list_2}, wobei die Elemente abwechselnd @"ubernommen werden.  Das Ergebnis
hat die Form @code{[@var{list_1}[1], @var{list_2}[1], @var{list_1}[2],
@var{list_2}[2], ...]}.

Haben die Listen verschiedene L@"angen, werden die zus@"atzlichen Elemente der
l@"angeren Liste ignoriert.

Sind @var{list_1} oder @var{list_2} keine Listen, gibt Maxima einen Fehler aus.

Beispiele:

@example
(%i1) L1: [a, sin(b), c!, d - 1];
(%o1)                [a, sin(b), c!, d - 1]
(%i2) join (L1, [1, 2, 3, 4]);
(%o2)          [a, 1, sin(b), 2, c!, 3, d - 1, 4]
(%i3) join (L1, [aa, bb, cc, dd, ee, ff]);
(%o3)        [a, aa, sin(b), bb, c!, cc, d - 1, dd]
@end example
@end deffn

@c --- 15.03.2011 DK -----------------------------------------------------------
@anchor{last}
@deffn {Funktion} last (@var{list})

Gibt das letzte Element der Liste @var{list} zur@"uck.

Das Argument @var{list} kann auch ein allgemeiner Ausdruck sein.  Siehe
@mref{first} f@"ur weitere Erl@"auterungen.

Beispiele:

@example
(%i1) l: [a,b,c];
(%o1)                       [a, b, c]
(%i2) last(x + y);
(%o2)                           x
(%i3) last(x * y);
(%o3)                           y
(%i4) last(f(x, y, z));
(%o4)                           z
@end example
@end deffn

@c --- 15.03.2011 DK -----------------------------------------------------------
@anchor{length}
@deffn {Funktion} length (@var{list})

Gibt die Anzahl der Elemente der Liste @var{list} zur@"uck.

Das Argument @var{list} kann auch ein allgemeiner Ausdruck sein.  Wie bei
anderen Funktionen f@"ur Listen wird auch von der Funktion @code{length} die
externe Darstellung eines Ausdrucks betrachtet, wie sie f@"ur die Ausgabe
vorliegt.  Die Optionsvariable @mref{inflag} hat daher Einfluss auf das Ergebnis
der Funktion @code{length}.

Beispiele:

@example
(%i1) length([a, x^2, sin(x), y+3]);
(%o1)                           4
(%i2) length(a/(b*x));
(%o2)                           2
(%i3) length(a/(b*x)),inflag:true;
(%o3)                           3
@end example
@end deffn

@c TODO: DIES GEHOERT IN DAS KAPITEL VEREINFACHUNGEN?!

@c --- 15.03.2011 DK -----------------------------------------------------------
@anchor{listarith}
@need 800
@defvr {Optionsvariable} listarith
Standardwert: @code{true}

Hat die Optionsvariable @code{listarith} den Wert @code{true}, werden 
Rechenoperationen mit Matrizen und Listen elementweise ausgef@"uhrt.  Das 
Ergebnis von Rechnungen mit Listen und Matrizen sind wieder Listen und Matrizen.
Hat die Optionsvariable @code{listarith} den Wert @code{false}, wird die
elementweise Ausf@"uhrung der Rechenoperationen unterdr@"uckt.

Beispiele:

@example
(%i1) listarith: true;
(%o1)                         true
(%i2) 2 + [a, b, c];
(%o2)                 [a + 2, b + 2, c + 2]
(%i3) 2^[a, b, c];
                            a   b   c
(%o3)                     [2 , 2 , 2 ]
(%i4) [1, 2, 3] + [a, b, c];
(%o4)                 [a + 1, b + 2, c + 3]
(%i5) listarith: false;
(%o5)                         false
(%i6) 2 + [a, b, c];
(%o6)                     [a, b, c] + 2
(%i7) 2^[a, b, c];
                            [a, b, c]
(%o7)                      2
(%i8) [1, 2, 3] + [a, b, c];
(%o8)                 [a, b, c] + [1, 2, 3]
@end example
@end defvr

@c --- 15.03.2011 DK -----------------------------------------------------------
@anchor{listp}
@deffn {Funktion} listp (@var{expr})

Gibt @code{true} zur@"uck, wenn @var{expr} eine Liste ist.  Ansonsten ist der 
R@"uckgabewert @code{false}.
@end deffn

@c --- 15.03.2011 DK -----------------------------------------------------------
@anchor{makelist}
@deffn  {Funktion} makelist (@var{expr}, @var{i}, @var{i_0}, @var{i_1})
@deffnx {Funktion} makelist (@var{expr}, @var{x}, @var{list})

Erzeugt eine Liste, indem der Ausdruck @var{expr} f@"ur die Variable @var{i}
ausgewertet wird.  Die Variable @var{i} nimmt nacheinander die Werte von
@var{i_0} bis @var{i_1} an, wobei die Schrittweite 1 ist.  Alternativ kann eine
Liste @var{list} als Argument @"ubergeben werden.  In diesem Fall nimmt die
Variable @var{i} nacheinander die Werte der Liste @var{list} an.

Siehe auch die Funktion @mrefcomma{create_list} um eine Liste zu generieren.

Beispiele:

@example
(%i1) makelist(concat(x, i), i, 1, 6);
(%o1)               [x1, x2, x3, x4, x5, x6]
(%i2) makelist(x = y, y, [a, b, c]);
(%o2)                 [x = a, x = b, x = c]
@end example
@end deffn

@c --- 15.03.2011 DK -----------------------------------------------------------
@anchor{member}
@deffn {Funktion} member (@var{expr}, @var{list})

Gibt @code{true} zur@"uck, wenn der Ausdruck @var{expr} gleich einem Element in
der Liste @var{list} ist.  Die Gleichheit wird dem Operator
@mref{=} festgestellt.

Die Gleichheit wird mit dem Operator @mref{=} gepr@"uft.  Daher werden nur
Ausdr@"ucke als gleich erkannt, die syntaktisch @"ubereinstimmen.  @"Aquivalente
Ausdr@"ucke, die syntaktisch voneinander verschieden sind, werden nicht aus der
Liste entfernt.  Zum Beispiel sind die Ausdr@"ucke @code{x^2-1} und
@code{(x+1)*(x-1)} @"aquivalent, aber syntaktisch verschieden.

Das Argument @var{list} kann auch ein allgemeiner Ausdruck sein.  Dabei werden
die Argumente des Hauptoperators betrachtet.

Siehe auch die Funktion @mrefdot{elementp}

Beispiele:

@example
(%i1) member (8, [8, 8.0, 8b0]);
(%o1)                         true
(%i2) member (8, [8.0, 8b0]);
(%o2)                         false
(%i3) member (b, [a, b, c]);
(%o3)                         true
(%i4) member (b, [[a, b], [b, c]]);
(%o4)                         false
(%i5) member ([b, c], [[a, b], [b, c]]);
(%o5)                         true
(%i6) F (1, 1/2, 1/4, 1/8);
                               1  1  1
(%o6)                     F(1, -, -, -)
                               2  4  8
(%i7) member (1/8, %);
(%o7)                         true
(%i8) member ("ab", ["aa", "ab", sin(1), a + b]);
(%o8)                         true
@end example
@end deffn

@c --- 16.03.2011 DK -----------------------------------------------------------
@anchor{pop}
@deffn {Funktion} pop (@var{list})

Die Funktion @code{pop} entfernt das erste Element der Liste @var{list} und
gibt dieses Element zur@"uck.  @var{list} muss ein Symbol sein, dem eine Liste
zugewiesen wurde, und kann nicht selbst eine Liste sein.

Ist dem Argument @var{list} keine Liste zugewiesen, gibt Maxima eine
Fehlermeldung aus.

Siehe auch die Funktion @mref{push} f@"ur Beispiele.

Mit dem Kommando @code{load("basic")} wird die Funktion geladen.
@end deffn

@c --- 16.03.2011 DK -----------------------------------------------------------
@anchor{push}
@deffn {Funktion} push (@var{item}, @var{list})

Die Funktion @code{push} f@"ugt das Argument @var{item} als erstes Element der
Liste @var{list} hinzu und gibt die neue Liste zur@"uck.  Das Argument
@var{list} muss ein Symbol sein, dem eine Liste zugewiesen wurde, und kann nicht
selbst eine Liste sein.  Das Argument @var{item} kann ein beliebiger Ausdruck
sein.

Ist dem Argument @var{list} keine Liste zugewiesen, gibt Maxima eine 
Fehlermeldung aus.

Siehe auch die Funktion @mrefcomma{pop} um das erste Element einer Liste zu
entfernen.

Mit dem Kommando @code{load("basic")} wird die Funktion geladen.

Beispiele:

@example
(%i1) ll:[];
(%o1)                          []
(%i2) push(x,ll);
(%o2)                          [x]
(%i3) push(x^2+y,ll);
                                 2
(%o3)                      [y + x , x]
(%i4) a:push("string",ll);
                                     2
(%o4)                  [string, y + x , x]
(%i5) pop(ll);
(%o5)                        string
(%i6) pop(ll);
                                  2
(%o6)                        y + x
(%i7) pop(ll);
(%o7)                           x
(%i8) ll;
(%o8)                          []
(%i9) a;
                                     2
(%o9)                  [string, y + x , x]
@end example
@end deffn

@c --- 16.03.2011 DK -----------------------------------------------------------
@anchor{rest}
@deffn  {Funktion} rest (@var{list}, @var{n})
@deffnx {Funktion} rest (@var{list})

Entfernt das erste Element oder, wenn @var{n} eine positive ganze Zahl ist, die
ersten @var{n} Elemente der Liste @var{list} und gibt den Rest der Liste als
Ergebnis zur@"uck.  Ist @var{n} eine negative Zahl, werden die letzten @var{n}
Elemente von der Liste entfernt und der Rest als Ergebnis zur@"uckgegeben.

Das Argument @var{list} kann auch ein allgemeiner Ausdruck sein.

Siehe auch die Funktionen @mref{first} und @mrefdot{last}

Beispiele:

@example
(%i1) rest([a,b,c]);
(%o1)                        [b, c]
(%i2) rest(a+b+c);
(%o2)                         b + a
@end example
@end deffn

@c --- 16.03.2011 DK -----------------------------------------------------------
@anchor{reverse}
@deffn {Funktion} reverse (@var{list})

Kehrt die Anordnung der Elemente einer Liste @var{list} um und gibt die
Ergebnisliste zur@"uck.  Das Argument @var{list} kann auch ein allgemeiner
Ausdruck sein.

Beispiele:

@example
(%i1) reverse([a, b, c]);
(%o1)                       [c, b, a]
(%i2) reverse(sin(x)=2*x^2+1);
                           2
(%o2)                   2 x  + 1 = sin(x)
@end example
@end deffn

@c --- 16.03.2011 DK -----------------------------------------------------------
@anchor{second}
@anchor{third}
@anchor{fourth}
@anchor{fifth}
@anchor{sixth}
@anchor{seventh}
@anchor{eighth}
@anchor{ninth}
@anchor{tenth}
@deffn  {Funktion} second (@var{list})
@deffnx {Funktion} third (@var{list})
@deffnx {Funktion} fourth (@var{list})
@deffnx {Funktion} fifth (@var{list})
@deffnx {Funktion} sixth (@var{list})
@deffnx {Funktion} seventh (@var{list})
@deffnx {Funktion} eighth (@var{list})
@deffnx {Funktion} ninth (@var{list})
@deffnx {Funktion} tenth (@var{list})

Die Funktionen @code{second} bis @code{tenth} geben das 2. bis 10. Element eines
Ausdrucks oder einer Liste @var{list} zur@"uck.  Siehe @mrefdot{first}
@end deffn

@c --- 20.03.2011 DK -----------------------------------------------------------
@anchor{sort}
@deffn  {Funktion} sort (@var{L}, @var{P})
@deffnx {Funktion} sort (@var{L})

Sortiert eine Liste @var{L} und gibt die sortierte Liste zur@"uck.  Das
optionale Argument @var{P} ist eine Aussagefunktion mit zwei Argumenten, die
eine Ordnung der Elemente definiert.  Die Aussagefunktion kann eine Funktion,
ein bin@"arer Operator oder ein Lambda-Ausdruck sein.  Wird kein Argument
@var{P} angegeben, werden die Elemente der Liste mit der Aussagefunktion
@mref{orderlessp} geordnet.

Die Aussagefunktion @mref{orderlessp} sortiert eine List aufsteigend.  Mit der
Aussagefunktion @mref{ordergreatp} kann die Liste absteigend sortiert werden.
Die Aussagefunktion @mref{ordermagnitudep} sortiert Maxima Zahlen, Konstante 
oder Ausdr@"ucke, die zu einer Zahl oder Konstanten ausgewertet werden k@"onnen,
nach der Gr@"o@ss{}e.  Mit dem Operator @mref{<} kann auch nach der Gr@"o@ss{}e
sortiert werden.  Im Unterschied zur Aussagefunktion @code{ordermagnitudep} ist
die Ordnung nicht vollst@"andig, wenn einzelne Elemente der Liste nicht
vergleichbar unter dem Operator @code{<} sind.

Beispiele:

@example
(%i1) sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9 * c,
      19 - 3 * x]);
               5
(%o1) [- 17, - -, 3, 7.55, 11, 2.9b1, b + a, 9 c, 19 - 3 x]
               2
(%i2) sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9*c, 19 - 3*x],
      ordergreatp);
                                                   5
(%o2) [19 - 3 x, 9 c, b + a, 2.9b1, 11, 7.55, 3, - -, - 17]
                                                   2
(%i3) sort ([%pi, 3, 4, %e, %gamma]);
(%o3)                [3, 4, %e, %gamma, %pi]
(%i4) sort ([%pi, 3, 4, %e, %gamma], "<");
(%o4)                [%gamma, %e, 3, %pi, 4]
(%i5) my_list: [[aa,hh,uu], [ee,cc], [zz,xx,mm,cc], [%pi,%e]];
(%o5) [[aa, hh, uu], [ee, cc], [zz, xx, mm, cc], [%pi, %e]]
(%i6) sort (my_list);
(%o6) [[%pi, %e], [aa, hh, uu], [ee, cc], [zz, xx, mm, cc]]
(%i7) sort (my_list, lambda ([a, b], orderlessp (reverse (a),
      reverse (b))));
(%o7) [[%pi, %e], [ee, cc], [zz, xx, mm, cc], [aa, hh, uu]]
@end example

Ordne Maxima Zahlen, Konstante und konstante Ausdr@"ucke nach der Gr@"o@ss{}e.
Alle anderen Elemente werden aufsteigend sortiert.

@example
@group
(%i8) sort([%i,1+%i,2*x,minf,inf,%e,sin(1),0,1,2,3,1.0,1.0b0],
           ordermagnitudep);
@end group
(%o8) [minf, 0, sin(1), 1, 1.0, 1.0b0, 2, %e, 3, inf, %i, 
                                                     %i + 1, 2 x]
@end example
@end deffn

@c --- 16.03.2011 DK -----------------------------------------------------------
@anchor{sublist}
@deffn {Funktion} sublist (@var{L}, @var{P})

Gibt die Elemente der Liste @var{L} als eine Liste zur@"uck, f@"ur die die
Aussagefunktion @code{P} das Ergebnis @code{true} hat.  @code{P} ist eine
Funktion mit einem Argument wie zum Beispiel die Funktion
@mrefdot{integerp}  Siehe auch die Funktion @mrefdot{sublist_indices}

Beispiele:

@example
(%i1) L: [1, 2, 3, 4, 5, 6];
(%o1)                  [1, 2, 3, 4, 5, 6]
(%i2) sublist (L, evenp);
(%o2)                       [2, 4, 6]
@end example
@end deffn

@c --- 16.11.2010 DK -----------------------------------------------------------
@anchor{sublist_indices}
@deffn {Funktion} sublist_indices (@var{L}, @var{P})

Gibt die Indizes der Elemente der Liste @var{L} zur@"uck, f@"ur die die
Aussagefunktion @code{P} das Ergebnis @code{true} hat.  @code{P} ist eine
Funktion mit einem Argument wie zum Beispiel die Funktion
@mrefdot{integerp}  Siehe auch die Funktion @mrefdot{sublist}

Beispiele:

@example
(%i1) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b],
                       lambda ([x], x='b));
(%o1)                     [2, 3, 7, 9]
(%i2) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], symbolp);
(%o2)                  [1, 2, 3, 4, 7, 9]
(%i3) sublist_indices ([1 > 0, 1 < 0, 2 < 1, 2 > 1, 2 > 0],
                       identity);
(%o3)                       [1, 4, 5]
(%i4) assume (x < -1);
(%o4)                       [x < - 1]
(%i5) map (maybe, [x > 0, x < 0, x < -2]);
(%o5)                [false, true, unknown]
(%i6) sublist_indices ([x > 0, x < 0, x < -2], identity);
(%o6)                          [2]
@end example
@end deffn

@c --- 16.03.2011 DK -----------------------------------------------------------
@anchor{unique}
@deffn {Funktion} unique (@var{L})

Gibt eine Liste mit den Elementen der Liste @var{L} zur@"uck, die sich
voneinander unterscheiden.  Sind alle Elemente der Liste @var{L} verschieden,
gibt @code{unique} eine Kopie der Liste @var{L} und nicht die Liste selbst
zur@"uck.  Ist @var{L} keine Liste, gibt @code{unique} den Ausdruck @var{L}
zur@"uck.

Beispiel:

@example
(%i1) unique ([1, %pi, a + b, 2, 1, %e, %pi, a + b, [1]]);
(%o1)              [1, 2, %e, %pi, [1], b + a]
@end example
@end deffn

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

