Funktionen und Variablen für Listen (Maxima Manual)

Previous: Einführung in Listen, Up: Listen [Contents][Index]

#### 5.4.2 Funktionen und Variablen für Listen

Operator: [
Operator: ]

  Die Operatoren `[` und `]` markieren den Anfang und das Ende einer Liste.

  `[` und `]` schließen auch die Indizes von Symbolen, Arrays, Hash-Arrays oder Array-Funktionen ein.

  Beispiele:

      (%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

Funktion: append (list_1, …, list_n)

  Gibt eine Liste mit den Elementen der Listen list_1, …, list_n zurück. Ist eines der Argumente list_1, …, list_n keine Liste meldet Maxima einen Fehler.

  `append` kann auch für allgemeine Ausdrücke genutzt werden. So hat zum Beispiel `append(f(a,b), f(c,d,e))` das Ergebnis `f(a,b,c,d,e)`. In diesem Fall muss der Operator, der hier `f` ist, für beide Ausdrücke identisch sein, ansonsten meldet Maxima einen Fehler.

  Siehe auch die Funktionen `cons` und `endcons`, um ein Element einer Liste hinzuzufügen.

  Beispiele:

  In den ersten Beispielen werden jeweils Listen mit verschiedenen Elementen zusammengefügt. Im letzten Beispiel wird `append` genutzt, um zwei Additionen zusammenzusetzen.

      (%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

Funktion: assoc (key, list, default)
Funktion: assoc (key, list)

  Ist das Argument `list` eine Liste mit paarweisen Elementen der Form `[[key_1, value_1], [key_2, value_2], ...]`, wobei key_i ein Schlüssel und value_i der dazugehörige Wert ist, dann gibt die Funktion `assoc` den zum Schlüssel key gehörenden Wert `value` zurück. Wird der Schlüssel nicht gefunden, wird das Argument `default` zurückgegeben, wenn es vorhanden ist, oder der Wert `false`.

  Anstatt Paare `[key_i, value_i]` können auch allgemeine Ausdrücke in der Liste enthalten sein, die zwei Argumente haben. Zum Beispiel sind Einträge der Form `x=1` oder `a^b` möglich. Im ersten Fall ist `x` der Schlüssel und im zweiten Fall `a`. Die Werte sind jeweils `1` und `b`.

  Beispiele:

      (%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

Funktion: cons (expr, list)

  Fügt den Ausdruck expr als erstes Element der Liste list hinzu.

  `cons` arbeitet auch mit allgemeinen Ausdrücken als Argument list. In diesem Fall wird dem Hauptoperator des Arguments list der Ausdruck expr als erstes Argument hinzugefügt.

  Siehe auch die Funktion `endcons`, um ein Element an das Ende einer Liste anzuhängen sowie die Funktion `append`, um zwei Listen zusammenzufügen.

  Beispiele:

      (%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)

Funktion: copylist (list)

  Gibt eine Kopie der Liste list zurück.

  Im Unterschied zur Funktion `copylist` wird mit dem Zuweisungsoperator `:` keine Kopie, sondern eine Referenz auf das Original zugewiesen. Das folgende Beispiel zeigt den Unterschied für den Fall, dass das Original modifiziert wird.

      (%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]

Funktion: create_list (expr, x_1, list_1, …, x_n, list_n)

  Erzeugt eine Liste, indem der Ausdruck expr zunächst für die Variable x_1 ausgewertet wird. Der Variablen x_1 werden für die Auswertung nacheinander die Werte der Liste list_1 zugewiesen. Dann wird der Ausdruck expr für die Variable x_2 mit den Werten der Liste list_2 ausgewertet u.s.w. Die Anzahl der Elemente der Ergebnisliste ist das Produkt der Anzahl der Elemente der einzelnen Listen list_i. Die Variablen x_i müssen Symbole sein, die nicht ausgewertet werden. Die Elemente der Listen list_i werden vor der Iteration ausgewertet.

  Anstatt einer Liste list_i mit den Elementen für die Iteration kann auch eine untere und obere Grenze angegeben werden. Die Grenzen können ganze Zahlen oder Gleitkommazahlen sowie Ausdrücke sein, die zu einer Zahl auswerten. Die Schrittweite ist immer 1. Siehe auch das Beispiel weiter unten.

  Beispiele:

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

  In diesem Beispiel wird für zwei Listen iteriert.

      (%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]]

  Anstatt einer Liste list_i können auch zwei Argumente übergeben werden, die jedes zu einer Nummer auswerten. Diese Werte sind die untere und die obere Grenze für die Iteration.

      (%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]]

Funktion: delete (expr, list)
Funktion: delete (expr, list, n)

  `delete(expr, list)` entfernt aus der Liste list die Elemente, die gleich dem Ausdruck expr sind. Mit dem Argument n kann die Anzahl der Elemente spezifiziert werden, die aus der Liste entfernt werden sollen. `delete` gibt eine neue Liste zurück. Das Argument list wird nicht modifiziert.

  Die Gleichheit wird mit dem Operator `=` geprüft. Daher werden nur Ausdrücke als gleich erkannt, die syntaktisch übereinstimmen. Äquivalente Ausdrücke, die syntaktisch voneinander verschieden sind, werden nicht aus der Liste entfernt. Zum Beispiel sind die Ausdrücke `x^2-1` und `(x+1)*(x-1)` äquivalent, aber syntaktisch verschieden.

  Das zweite Argument 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.

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

  Entferne Terme einer Summe.

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

  Entferne Faktoren eines Produkts.

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

  Entferne Argumente einer Funktion.

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

  Das Element `a` tritt mehrfach auf. Es werden zwei Elemente entfernt.

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

  Die Gleichheit wird mit dem Operator `=` geprüft.

      (%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 ]

Funktion: endcons (expr, list)

  Fügt den Ausdruck expr als letztes Element der Liste list hinzu.

  `endcons` arbeitet auch mit allgemeinen Ausdrücken als Argument list. In diesem Fall wird dem Hauptoperator des Arguments list der Ausdruck expr als letztes Argument hinzugefügt.

  Siehe auch die Funktion `cons`, um ein Element am Anfang einer Liste einzufügen sowie die Funktion `append`, um zwei Listen zusammenzufügen.

  Beispiele:

      (%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)

Funktion: first (list)

  Gibt das erste Element der Liste list zurück.

  Das Argument 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 `first` und verwandte Funktionen wie `last` oder `rest` arbeiten mit der externen Darstellung eines Ausdrucks, wie sie in der Anzeige erscheint. Dies kann mit der Optionsvariablen `inflag` kontrolliert werden. Hat die Optionsvariable `inflag` den Wert `true`, wird von diesen Funktionen die interne Darstellung betrachtet.

  Die Funktionen `second` bis `tenth` geben jeweils das 2. bis 10. Element zurück.

  Beispiele:

      (%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

Funktion: join (list_1, list_2)

  Erzeugt eine neue Liste aus den Elementen der Listen list_1 und list_2, wobei die Elemente abwechselnd übernommen werden. Das Ergebnis hat die Form `[list_1[1], list_2[1], list_1[2], list_2[2], ...]`.

  Haben die Listen verschiedene Längen, werden die zusätzlichen Elemente der längeren Liste ignoriert.

  Sind list_1 oder list_2 keine Listen, gibt Maxima einen Fehler aus.

  Beispiele:

      (%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]

Funktion: last (list)

  Gibt das letzte Element der Liste list zurück.

  Das Argument list kann auch ein allgemeiner Ausdruck sein. Siehe `first` für weitere Erläuterungen.

  Beispiele:

      (%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

Funktion: length (list)

  Gibt die Anzahl der Elemente der Liste list zurück.

  Das Argument list kann auch ein allgemeiner Ausdruck sein. Wie bei anderen Funktionen für Listen wird auch von der Funktion `length` die externe Darstellung eines Ausdrucks betrachtet, wie sie für die Ausgabe vorliegt. Die Optionsvariable `inflag` hat daher Einfluss auf das Ergebnis der Funktion `length`.

  Beispiele:

      (%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

Optionsvariable: listarith

  Standardwert: `true`

  Hat die Optionsvariable `listarith` den Wert `true`, werden Rechenoperationen mit Matrizen und Listen elementweise ausgeführt. Das Ergebnis von Rechnungen mit Listen und Matrizen sind wieder Listen und Matrizen. Hat die Optionsvariable `listarith` den Wert `false`, wird die elementweise Ausführung der Rechenoperationen unterdrückt.

  Beispiele:

      (%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]

Funktion: listp (expr)

  Gibt `true` zurück, wenn expr eine Liste ist. Ansonsten ist der Rückgabewert `false`.

Funktion: makelist (expr, i, i_0, i_1)
Funktion: makelist (expr, x, list)

  Erzeugt eine Liste, indem der Ausdruck expr für die Variable i ausgewertet wird. Die Variable i nimmt nacheinander die Werte von i_0 bis i_1 an, wobei die Schrittweite 1 ist. Alternativ kann eine Liste list als Argument übergeben werden. In diesem Fall nimmt die Variable i nacheinander die Werte der Liste list an.

  Siehe auch die Funktion `create_list`, um eine Liste zu generieren.

  Beispiele:

      (%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]

Funktion: member (expr, list)

  Gibt `true` zurück, wenn der Ausdruck expr gleich einem Element in der Liste list ist. Die Gleichheit wird dem Operator `=` festgestellt.

  Die Gleichheit wird mit dem Operator `=` geprüft. Daher werden nur Ausdrücke als gleich erkannt, die syntaktisch übereinstimmen. Äquivalente Ausdrücke, die syntaktisch voneinander verschieden sind, werden nicht aus der Liste entfernt. Zum Beispiel sind die Ausdrücke `x^2-1` und `(x+1)*(x-1)` äquivalent, aber syntaktisch verschieden.

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

  Siehe auch die Funktion `elementp`.

  Beispiele:

      (%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

Funktion: pop (list)

  Die Funktion `pop` entfernt das erste Element der Liste list und gibt dieses Element zurück. list muss ein Symbol sein, dem eine Liste zugewiesen wurde, und kann nicht selbst eine Liste sein.

  Ist dem Argument list keine Liste zugewiesen, gibt Maxima eine Fehlermeldung aus.

  Siehe auch die Funktion `push` für Beispiele.

  Mit dem Kommando `load(basic)` wird die Funktion geladen.

Funktion: push (item, list)

  Die Funktion `push` fügt das Argument item als erstes Element der Liste list hinzu und gibt die neue Liste zurück. Das Argument list muss ein Symbol sein, dem eine Liste zugewiesen wurde, und kann nicht selbst eine Liste sein. Das Argument item kann ein beliebiger Ausdruck sein.

  Ist dem Argument list keine Liste zugewiesen, gibt Maxima eine Fehlermeldung aus.

  Siehe auch die Funktion `pop`, um das erste Element einer Liste zu entfernen.

  Mit dem Kommando `load(basic)` wird die Funktion geladen.

  Beispiele:

      (%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]

Funktion: rest (list, n)
Funktion: rest (list)

  Entfernt das erste Element oder, wenn n eine positive ganze Zahl ist, die ersten n Elemente der Liste list und gibt den Rest der Liste als Ergebnis zurück. Ist n eine negative Zahl, werden die letzten n Elemente von der Liste entfernt und der Rest als Ergebnis zurückgegeben.

  Das Argument list kann auch ein allgemeiner Ausdruck sein.

  Siehe auch die Funktionen `first` und `last`.

  Beispiele:

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

Funktion: reverse (list)

  Kehrt die Anordnung der Elemente einer Liste list um und gibt die Ergebnisliste zurück. Das Argument list kann auch ein allgemeiner Ausdruck sein.

  Beispiele:

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

Funktion: second (list)
Funktion: third (list)
Funktion: fourth (list)
Funktion: fifth (list)
Funktion: sixth (list)
Funktion: seventh (list)
Funktion: eighth (list)
Funktion: ninth (list)
Funktion: tenth (list)

  Die Funktionen `second` bis `tenth` geben das 2. bis 10. Element eines Ausdrucks oder einer Liste list zurück. Siehe `first`.

Funktion: sort (L, P)
Funktion: sort (L)

  Sortiert eine Liste L und gibt die sortierte Liste zurück. Das optionale Argument P ist eine Aussagefunktion mit zwei Argumenten, die eine Ordnung der Elemente definiert. Die Aussagefunktion kann eine Funktion, ein binärer Operator oder ein Lambda-Ausdruck sein. Wird kein Argument P angegeben, werden die Elemente der Liste mit der Aussagefunktion `orderlessp` geordnet.

  Die Aussagefunktion `orderlessp` sortiert eine List aufsteigend. Mit der Aussagefunktion `ordergreatp` kann die Liste absteigend sortiert werden. Die Aussagefunktion `ordermagnitudep` sortiert Maxima Zahlen, Konstante oder Ausdrücke, die zu einer Zahl oder Konstanten ausgewertet werden können, nach der Größe. Mit dem Operator `<` kann auch nach der Größe sortiert werden. Im Unterschied zur Aussagefunktion `ordermagnitudep` ist die Ordnung nicht vollständig, wenn einzelne Elemente der Liste nicht vergleichbar unter dem Operator `<` sind.

  Beispiele:

      (%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]]

  Ordne Maxima Zahlen, Konstante und konstante Ausdrücke nach der Größe. Alle anderen Elemente werden aufsteigend sortiert.

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

      (%o8) [minf, 0, sin(1), 1, 1.0, 1.0b0, 2, %e, 3, inf, %i,
                                                           %i + 1, 2 x]

Funktion: sublist (L, P)

  Gibt die Elemente der Liste L als eine Liste zurück, für die die Aussagefunktion `P` das Ergebnis `true` hat. `P` ist eine Funktion mit einem Argument wie zum Beispiel die Funktion `integerp`. Siehe auch die Funktion `sublist_indices`.

  Beispiele:

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

Funktion: sublist_indices (L, P)

  Gibt die Indizes der Elemente der Liste L zurück, für die die Aussagefunktion `P` das Ergebnis `true` hat. `P` ist eine Funktion mit einem Argument wie zum Beispiel die Funktion `integerp`. Siehe auch die Funktion `sublist`.

  Beispiele:

      (%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]

Funktion: unique (L)

  Gibt eine Liste mit den Elementen der Liste L zurück, die sich voneinander unterscheiden. Sind alle Elemente der Liste L verschieden, gibt `unique` eine Kopie der Liste L und nicht die Liste selbst zurück. Ist L keine Liste, gibt `unique` den Ausdruck L zurück.

  Beispiel:

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

Previous: Einführung in Listen, Up: Listen [Contents][Index]