Head , Tail , Length , Map , MapSingle , RandomIntegerVector , MakeVector , Select , Nth , DestructiveReverse , List , UnList , Listify , Concat , Delete , Insert , DestructiveDelete , DestructiveInsert , Replace , DestructiveReplace , FlatCopy , Contains , Find , Append , DestructiveAppend , RemoveDuplicates , Push , Pop , PopFront , PopBack , Swap , Count , Intersection , Union , Difference , FillList , Drop , Take , Partition , Assoc , AssocIndices , Flatten , UnFlatten , Type , NrArgs , BubbleSort , Table , TableForm .

Das Arbeiten mit Listen

Fast alle Objekte variabler Größer werden als Listen repräsentiert (intern als verkettete Listen implementiert).

Head erstes Element einer Liste
Tail Liste ohne das erste Element
Length Länge einer Liste oder einer Zeichenkette (String)
Map Anwenden einer Funktion auf alle Elemente der Liste
MapSingle Anwenden einer Funktion auf alle Elemente der Liste
RandomIntegerVector Zufallsvektor
MakeVector Vektor mit numerierten Variablen
Select Selektieren bestimmter Elemente einer Liste
Nth das n-te Element einer Liste
DestructiveReverse Vertauschen der Reihenfolge aller Elemente
List Erzeugen einer Liste
UnList Umwandlung einer Liste in einen Funktionsaufruf
Listify Umwandlung eines Funktionsaufrufs in eine Liste
Concat Aneinanderhängen von Listen
Delete Löschen eines Listenelements
Insert Einfügen eines Listenelements
DestructiveDelete Löschen eines Listenelements mit Änderung der ursprünglichen Liste
DestructiveInsert Einfügen eines Listenelements mit Änderung der ursprünglichen Liste
Replace Ersetzen eines Listenelements
DestructiveReplace Ersetzen eines Listenelements mit Änderung der ursprünglichen Liste
FlatCopy Kopieren einer Liste
Contains Testen, ob eine Liste ein best. Element enthält
Find Durchsuchen einer Liste
Append Hinzufügen eines Listenelements am Ende der Liste
DestructiveAppend Hinzufügen eines Listenelements am Ende der Liste mit Änderung der ursprünglichen Liste
RemoveDuplicates Entfernen von Duplikaten
Push Hinzufügen eines Elements zu einem Stack
Pop Entfernen eines Elements aus einem Stack
PopFront Entfernen des obersten Elements aus einem Stack
PopBack Entfernen des untersten Elements aus einem Stack
Swap Vertauschen zweier Listenelemente
Count Anzahl des Auftretens eines best. Ausdrucks in der Liste
Intersection Schnittmenge zweier Listen
Union Vereinigungsmenge zweier Listen
Difference Differenz zweier Listen
FillList Füllen einer Liste mit einem best. Ausdruck
Drop Entfernen eines Bereichs von Listenelementen
Take Abspalten eines Bereichs von Listenelementen
Partition Umformen einer Liste in Teillisten gleicher Länge
Assoc Suchen eines Listenelements anhand eines Schlüssels
AssocIndices Schlüssel einer Schlüsselliste
Flatten Zerlegen eines Terms in eine Liste
UnFlatten Erzeugen eines Terms aus den Elementen einer Liste
Type den Typ eines Ausdrucks bestimmen
NrArgs Anzahl der Argumente eines Ausdrucks bestimmen
BubbleSort Sortieren einer Liste
Table Erzeugen einer Liste über eine Schleife
TableForm gibt die Elemente einer Liste formatiert aus


Head -- erstes Element einer Liste

interne Funktion
Funktionsaufruf:
Head(list)
Parameter:
list - eine Liste
Beschreibung:
Das Ergebnis ist das erste Element der Liste. Angewendet auf einen Term wird der erste Operand zurückgegeben.
Beispiele:
In> Head({a,b,c})
Out> a;

In> Head(f(a,b,c));
Out> a;
siehe auch:
Tail , Length .


Tail -- Liste ohne das erste Element

interne Funktion
Funktionsaufruf:
Tail(list)
Parameter:
list - eine Liste
Beschreibung:
Das Ergebnis ist eine Liste ohne das erste Element.
Beispiele:
In> Tail({a,b,c})
Out> {b,c};
siehe auch:
Head , Length .


Length -- Länge einer Liste oder einer Zeichenkette (String)

interne Funktion
Funktionsaufruf:
Length(object)
Parameter:
object - eine Liste, ein Array oder ein String
Beschreibung:
Das Ergebnis ist die Länge der Liste. Die Funktion kann auch auf Arrays oder Strings angewendet werden.
Beispiele:
In> Length({a,b,c})
Out> 3;

In> Length("abcdef");
Out> 6;
siehe auch:
Head , Tail , Nth , Count .


Map -- Anwenden einer Funktion auf alle Elemente der Liste

mathematische Standardbibliothek
Funktionsaufruf:
Map(fn, list)
Parameter:
fn - eine Funktion
list - eine Liste mit Listen von Argumenten
Beschreibung:
Diese Funktion wendet die Funktion "fn" auf alle in "list" enthaltenen Argumentlisten an. Das erste Element von "list" ist eine Liste deren Elemente das 1., 2., 3., ... Argument von "fn" sind. Das gleiche gilt für die weiteren Elemente in "list".
Beispiele:
In> MapSingle("Sin",{a,b,c});
Out> {Sin(a),Sin(b),Sin(c)};

In> Map("+",{{a,b},{c,d}});
Out> {a+c,b+d};
siehe auch:
MapSingle , MapArgs .


MapSingle -- Anwenden einer Funktion auf alle Elemente der Liste

mathematische Standardbibliothek
Funktionsaufruf:
MapSingle(fn, list)
Parameter:
fn - eine Funktion
list - eine Liste von Argumenten
Beschreibung:
Die Funktion "fn" wird nacheinander auf alle Elemente der Liste "list" angewendet. Zurückgegeben wird eine Liste mit den entsprechenden Ergebnissen.

Der /@ Operator ist eine Abkürzung für MapSingle.
Beispiele:
In> MapSingle("Sin",{a,b,c});
Out> {Sin(a),Sin(b),Sin(c)};

In> MapSingle({{x},x^2}, {a,2,c});
Out> {a^2,4,c^2};
siehe auch:
Map , MapArgs , /@ .


RandomIntegerVector -- Zufallsvektor

mathematische Standardbibliothek
Funktionsaufruf:
RandomIntegerVector(nr, from, to)
Parameter:
nr - Anzahl der Komponenten
from - untere Grenze
to - obere Grenze
Beschreibung:
Das Ergebnis ist eine Liste mit "nr" ganzzahligen Zufallszahlen. Die Zufallszahlen sind gleichmäßig im Intervall [from ; to] verteilt.
Beispiele:
In> RandomIntegerVector(4,-3,3)
Out> {0,3,2,-2};
siehe auch:
Random , RandomPoly .


MakeVector -- Vektor mit numerierten Variablen

mathematische Standardbibliothek
Funktionsaufruf:
MakeVector(var, n)
Parameter:
var - freie Variable
n - Länge des Vektors
Beschreibung:
Das Ergebnis ist eine Liste der Länge "n". Die Elemente sind jeweils die Variable "var" mit hinzugefügtem Index.
Beispiele:
In> MakeVector(a,3)
Out> {a1,a2,a3};
siehe auch:
RandomIntegerVector , ZeroVector .


Select -- Selektieren bestimmter Elemente einer Liste

mathematische Standardbibliothek
Funktionsaufruf:
Select(pred, list)
Parameter:
pred - eine Eigenschaft
list - eine Liste
Beschreibung:
Das Ergebnis ist eine Teilliste von "list", die alle Elemente mit der angegebenen Eigenschaft "pred" enthält.
Beispiele:
In> Select("IsInteger",{a,b,2,c,3,d,4,e,f})
Out> {2,3,4};
siehe auch:
Length , Find , Count .


Nth -- das n-te Element einer Liste

interne Funktion
Funktionsaufruf:
Nth(list, n)
Parameter:
list - eine Liste
n - Index
Beschreibung:
Das Ergebnis ist das Element der Liste "list" mit dem Index "n". Das erste Element hat den Index 1. Ist "n" eine Liste von Indizees, ist das Ergebnis eine Liste mit den entsprechenden Elementen.

Auf einen Term angewendet ist das Ergebnis der n-te Operand.

Eine äquivalente Form von Nth(list, n) ist list[n].
Beispiele:
In> lst := {a,b,c,13,19};
Out> {a,b,c,13,19};

In> Nth(lst, 3);
Out> c;

In> lst[3];
Out> c;

In> Nth(lst, {3,4,1});
Out> {c,13,a};

In> Nth(b*(a+c), 2);
Out> a+c;
siehe auch:
Select , Nth .


DestructiveReverse -- Vertauschen der Reihenfolge aller Elemente

interne Funktion
Funktionsaufruf:
DestructiveReverse(list)
Parameter:
list - eine Liste
Beschreibung:
Die Funktion dreht die Reihenfolge der Elemente der Liste "list" um. Das Original bleibt nicht erhalten.
Die gedrehte Liste wird als Ergebnis zurückgegeben.

Es gibt keine Funktion, die eine Liste dreht ohne das Original zu zerstören. Soll das Original erhalten bleiben, muss die Liste zunächst mit FlatCopy kopiert werden.
Beispiele:
In> lst := {a,b,c,13,19};
Out> {a,b,c,13,19};

In> revlst := DestructiveReverse(lst);
Out> {19,13,c,b,a};

In> lst;
Out> {a};
siehe auch:
FlatCopy .


List -- Erzeugen einer Liste

interne Funktion
Funktionsaufruf:
List(expr1, expr2, ...)
Parameter:
expr1, expr2 - Listenelemente
Beschreibung:
Es wird eine Liste erzeugt, deren erstes Element "expr1" ist, das zweite "expr2" usw. Das Ergebnis ist äquivalent zum Ausdruck "{expr1, expr2, ...}".
Beispiele:
In> List();
Out> {};

In> List(a,b);
Out> {a,b};

In> List(a,{1,2},d);
Out> {a,{1,2},d};
siehe auch:
UnList , Listify .


UnList -- Umwandlung einer Liste in einen Funktionsaufruf

interne Funktion
Funktionsaufruf:
UnList(list)
Parameter:
list - eine Liste
Beschreibung:
Diese Funktion wandelt die Liste in einen Funktionsaufruf um. Das erste Listenelement wird als Funktionsterm interpretiert, die folgenden Elemente als Argumente der Funktion.

Die Liste "list" wird vor dem Erstellen des Funktionsaufrufs berechnet, der resultierende Funktionsaufruf jedoch nicht.
Beispiele:
In> UnList({Cos, x});
Out> Cos(x);

In> UnList({f});
Out> f();

In> UnList({Taylor,x,0,5,Cos(x)});
Out> Taylor(x,0,5)Cos(x);

In> Eval(%);
Out> 1-x^2/2+x^4/24;
siehe auch:
List , Listify .


Listify -- Umwandlung eines Funktionsaufrufs in eine Liste

interne Funktion
Funktionsaufruf:
Listify(expr)
Parameter:
expr - ein Funktionsterm
Beschreibung:
Das Ergebnis ist eine Liste. Das erste Element ist der Operator, die übrigen Elemente sind die Operanden.
Beispiele:
In> Listify(Cos(x));
Out> {Cos,x};

In> Listify(3*a);
Out> {*,3,a};
siehe auch:
List , UnList , IsAtom .


Concat -- Aneinanderhängen von Listen

interne Funktion
Funktionsaufruf:
Concat(list1, list2, ...)
Parameter:
list1, list2 - Listen
Beschreibung:
Die Listen "list1", "list2", ... werden berechnet und aneinandergehängt. Das Ergebnis ist die neue Liste.
Beispiele:
In> Concat({a,b}, {c,d});
Out> {a,b,c,d};

In> Concat({5}, {a,b,c}, {{f(x)}});
Out> {5,a,b,c,{f(x)}};
siehe auch:
ConcatStrings , : , Insert .


Delete -- Löschen eines Listenelements

interne Funktion
Funktionsaufruf:
Delete(list, n)
Parameter:
list - eine Liste
n - Index des zu löschenden Elements
Beschreibung:
Die Funktion löscht das n-te Element der Liste "list". Das Ergebnis ist die resultierende Liste.
Beispiele:
In> Delete({a,b,c,d,e,f}, 4);
Out> {a,b,c,e,f};
siehe auch:
DestructiveDelete , Insert , Replace .


Insert -- Einfügen eines Listenelements

interne Funktion
Funktionsaufruf:
Insert(list, n, expr)
Parameter:
list - eine Liste
n - ein Index
expr - ein Term
Beschreibung:
Der Term "expr" wird unmittelbar vor dem n-ten Listenelement in die Liste "list" eingefügt. Ist n=1, wird "expr" an den Anfang der Liste gesetzt (entspricht dem : Operator); ist n um 1 größer als die Listenlänge, wird "expr" an das Ende der Liste gesetzt (entspricht Append). Das Ergebnis ist die resultierende Liste.
Beispiele:
In> Insert({a,b,c,d}, 4, x);
Out> {a,b,c,x,d};

In> Insert({a,b,c,d}, 5, x);
Out> {a,b,c,d,x};

In> Insert({a,b,c,d}, 1, x);
Out> {x,a,b,c,d};
siehe auch:
DestructiveInsert , : , Append , Delete , Remove .


DestructiveDelete -- Löschen eines Listenelements mit Änderung der ursprünglichen Liste

interne Funktion
Funktionsaufruf:
DestructiveDelete(list, n)
Parameter:
list - eine Liste
n - Index des zu löschenden Elements
Beschreibung:
Im Gegensatz zur Funktion Delete wird das Original hier verändert.
Beispiele:
In> lst := {a,b,c,d,e,f};
Out> {a,b,c,d,e,f};

In> Delete(lst, 4);
Out> {a,b,c,e,f};

In> lst;
Out> {a,b,c,d,e,f};

In> DestructiveDelete(lst, 4);
Out> {a,b,c,e,f};

In> lst;
Out> {a,b,c,e,f};
siehe auch:
Delete , DestructiveInsert , DestructiveReplace .


DestructiveInsert -- Einfügen eines Listenelements mit Änderung der ursprünglichen Liste

interne Funktion
Funktionsaufruf:
DestructiveInsert(list, n, expr)
Parameter:
list - eine Liste
n - ein Index
expr - ein Term
Beschreibung:
Im Gegensatz zur Funktion Insert wird das Original hier verändert.
Beispiele:
In> lst := {a,b,c,d};
Out> {a,b,c,d};

In> Insert(lst, 2, x);
Out> {a,x,b,c,d};

In> lst;
Out> {a,b,c,d};

In> DestructiveInsert(lst, 2, x);
Out> {a,x,b,c,d};

In> lst;
Out> {a,x,b,c,d};
siehe auch:
Insert , DestructiveDelete , DestructiveReplace .


Replace -- Ersetzen eines Listenelements

interne Funktion
Funktionsaufruf:
Replace(list, n, expr)
Parameter:
list - eine Liste
n - ein Index
expr - ein Term
Beschreibung:
Die Funktion ersetzt das n-te Listenelement der Liste "list" durch den Term "expr". Die Funktion ist äquivalent zu
Insert(Delete(list, n), n, expr).
Beispiele:
In> Replace({a,b,c,d,e,f}, 4, x);
Out> {a,b,c,x,e,f};
siehe auch:
Delete , Insert , DestructiveReplace .


DestructiveReplace -- Ersetzen eines Listenelements mit Änderung der ursprünglichen Liste

interne Funktion
Funktionsaufruf:
DestructiveReplace(list, n, expr)
Parameter:
list - eine Liste
n - ein Index
expr - ein Term
Beschreibung:
Im Gegensatz zur Funktion Replace wird hier das Original verändert.
Beispiele:
In> lst := {a,b,c,d,e,f};
Out> {a,b,c,d,e,f};

In> Replace(lst, 4, x);
Out> {a,b,c,x,e,f};

In> lst;
Out> {a,b,c,d,e,f};

In> DestructiveReplace(lst, 4, x);
Out> {a,b,c,x,e,f};

In> lst;
Out> {a,b,c,x,e,f};
siehe auch:
Replace , DestructiveDelete , DestructiveInsert .


FlatCopy -- Kopieren einer Liste

interne Funktion
Funktionsaufruf:
FlatCopy(list)
Parameter:
list - eine Liste
Beschreibung:
Das Ergebnis ist eine Kopie der Liste "list". Es wird keine Rekursion durchgeführt, nur die oberste Ebene wird kopiert.
Beispiel:
Das folgende Beispiel dreht die Reihenfolge der Listenelemente ohne das Original zuverändern.
In> reverse(l_IsList) <-- DestructiveReverse(FlatCopy(l));
Out> True;

In> lst := {a,b,c,d,e};
Out> {a,b,c,d,e};

In> reverse(lst);
Out> {e,d,c,b,a};

In> lst;
Out> {a,b,c,d,e};


Contains -- Testen, ob eine Liste ein best. Element enthält

mathematische Standardbibliothek
Funktionsaufruf:
Contains(list, expr)
Parameter:
list - eine Liste
expr - ein Term
Beschreibung:
Diese Funktion testet, ob die Liste "list" den Term "expr" als Listenelement enthält. Wenn ja ist das Ergebnis True, sonst False.
Ist der Parameter "list" ein Term, werden die Operanden nach "expr" abgesucht.
Beispiele:
In> Contains({a,b,c,d}, b);
Out> True;

In> Contains({a,b,c,d}, x);
Out> False;

In> Contains({a,{1,2,3},z}, 1);
Out> False;

In> Contains(a*b, b);
Out> True;
siehe auch:
Find , Count .


Find -- Durchsuchen einer Liste

mathematische Standardbibliothek
Funktionsaufruf:
Find(list, expr)
Parameter:
list - eine Liste
expr - ein Term
Beschreibung:
Die Funktion durchsucht die Liste "list" nach dem Term "expr". Wird "expr" als Listenelement gefunden, ist das Ergebnis der Index des Elements. Ist die Suche erfolglos, ist das Ergebnis -1.
Beispiele:
In> Find({a,b,c,d,e,f}, d);
Out> 4;

In> Find({1,2,3,2,1}, 2);
Out> 2;

In> Find({1,2,3,2,1}, 4);
Out> -1;
siehe auch:
Contains .


Append -- Hinzufügen eines Listenelements am Ende der Liste

mathematische Standardbibliothek
Funktionsaufruf:
Append(list, expr)
Parameter:
list - eine Liste
expr - ein Term
Beschreibung:
Der Term "expr" wird am Listenende hinzugefügt. Das Ergebnis ist die resultierende Liste.

Hinweis: Die Zeit für das Anhängen am Listenende wächst proportional mit der Listenlänge; die Zeit für das Hinzufügen am Listenanfang ist konstant.
Beispiele:
In> Append({a,b,c,d}, 1);
Out> {a,b,c,d,1};
siehe auch:
Concat , : , DestructiveAppend .


DestructiveAppend -- Hinzufügen eines Listenelements am Ende der Liste mit Änderung der ursprünglichen Liste

interne Funktion
Funktionsaufruf:
DestructiveAppend(list, expr)
Parameter:
list - eine Liste
expr - ein Term
Beschreibung:
Im Gegensatz zur Funktion Append wird hier das Original verändert.
Beispiele:
In> lst := {a,b,c,d};
Out> {a,b,c,d};

In> Append(lst, 1);
Out> {a,b,c,d,1};

In> lst
Out> {a,b,c,d};

In> DestructiveAppend(lst, 1);
Out> {a,b,c,d,1};

In> lst;
Out> {a,b,c,d,1};
siehe auch:
Concat , : , Append .


RemoveDuplicates -- Entfernen von Duplikaten

mathematische Standardbibliothek
Funktionsaufruf:
RemoveDuplicates(list)
Parameter:
list - eine Liste
Beschreibung:
Diese Funktion entfernt alle Duplikate in der Liste "list". Das Ergebnis ist die resultierende Liste.
Beispiele:
In> RemoveDuplicates({1,2,3,2,1});
Out> {1,2,3};

In> RemoveDuplicates({a,1,b,1,c,1});
Out> {a,1,b,c};


Push -- Hinzufügen eines Elements zu einem Stack

mathematische Standardbibliothek
Funktionsaufruf:
Push(stack, expr)
Parameter:
stack - ein Stack (repräsentiert durch eine Liste)
expr - ein Term
Beschreibung:
Diese Funktion ist Teil einer einfachen Implementation eines Stacks. Der Stack wird durch eine Liste repräsentiert.
Der Term "expr" wird dem Stack hinzugefügt. Das Ergebnis ist der resultierende Stack.
Beispiele:
In> stack := {};
Out> {};

In> Push(stack, x);
Out> {x};

In> Push(stack, x2);
Out> {x2,x};

In> PopFront(stack);
Out> x2;
siehe auch:
Pop , PopFront , PopBack .


Pop -- Entfernen eines Elements aus einem Stack

mathematische Standardbibliothek
Funktionsaufruf:
Pop(stack, n)
Parameter:
stack - ein Stack (repräsentiert durch eine Liste)
n - ein Index
Beschreibung:
Das Stackelement mit Index "n" wird vom Stack entfernt und als Ergebnis zurückgegeben. Das oberste Stackelement hat den Index 1. Ungültige Indizees führen zu einem Fehler.
Beispiele:
In> stack := {};
Out> {};

In> Push(stack, x);
Out> {x};

In> Push(stack, x2);
Out> {x2,x};

In> Push(stack, x3);
Out> {x3,x2,x};

In> Pop(stack, 2);
Out> x2;

In> stack;
Out> {x3,x};
siehe auch:
Push , PopFront , PopBack .


PopFront -- Entfernen des obersten Elements aus einem Stack

mathematische Standardbibliothek
Funktionsaufruf:
PopFront(stack)
Parameter:
stack - ein Stack (repräsentiert durch eine Liste)
Beschreibung:
Das oberste Stackelement wird vom Stack entfernt und als Ergebnis zurückgegeben. Das ist das Element, das mit dem letzten Push -Befehl dem Stack hinzugefügt wurde.
Beispiele:
In> stack := {};
Out> {};

In> Push(stack, x);
Out> {x};

In> Push(stack, x2);
Out> {x2,x};

In> Push(stack, x3);
Out> {x3,x2,x};
In> PopFront(stack);
Out> x3;

In> stack;
Out> {x2,x};
siehe auch:
Push , Pop , PopBack .


PopBack -- Entfernen des untersten Elements aus einem Stack

mathematische Standardbibliothek
Funktionsaufruf:
PopBack(stack)
Parameter:
stack - ein Stack (repräsentiert durch eine Liste)
Beschreibung:
Das unterste Stackelement wird vom Stack entfernt und als Ergebnis zurückgegeben.
Beispiele:
In> stack := {};
Out> {};

In> Push(stack, x);
Out> {x};

In> Push(stack, x2);
Out> {x2,x};

In> Push(stack, x3);
Out> {x3,x2,x};

In> PopBack(stack);
Out> x;

In> stack;
Out> {x3,x2};
siehe auch:
Push , Pop , PopFront .


Swap -- Vertauschen zweier Listenelemente

mathematische Standardbibliothek
Funktionsaufruf:
Swap(list, i1, i2)
Parameter:
list - eine Liste
i1, i2 - Indizees
Beschreibung:
Die Listenelemente mit den Indizees "i1" und "i2" werden vertauscht. Das Ergebnis ist die resultierende Liste.
Beispiele:
In> lst := {a,b,c,d,e,f};
Out> {a,b,c,d,e,f};

In> Swap(lst, 2, 4);
Out> {a,d,c,b,e,f};
siehe auch:
Replace , DestructiveReplace .


Count -- Anzahl des Auftretens eines best. Ausdrucks in der Liste

mathematische Standardbibliothek
Funktionsaufruf:
Count(list, expr)
Parameter:
list - eine Liste
expr - ein Term
Beschreibung:
Die Anzahl des Auftretens des Terms "expr" in der Liste "list"wird bestimmt und als Ergebnis zurückgegeben.
Beispiele:
In> lst := {a,b,c,b,a};
Out> {a,b,c,b,a};

In> Count(lst, a);
Out> 2;

In> Count(lst, c);
Out> 1;

In> Count(lst, x);
Out> 0;
siehe auch:
Length , Select , Contains .


Intersection -- Schnittmenge zweier Listen

mathematische Standardbibliothek
Funktionsaufruf:
Intersection(l1, l2)
Parameter:
l1, l2 - zwei Listen
Beschreibung:
Die Schnittmenge der Listen "l1" and "l2" wird bestimmt und als Ergebnis zurückgegeben. Die Schnittmenge enthält alle Elemente, die in beiden Listen vorkommen. Die Elemente der Schnittmenge sind in der gleichen Reihenfolge wie in der Liste "l1" angeordnet.
Beispiele:
In> Intersection({a,b,c}, {b,c,d});
Out> {b,c};

In> Intersection({a,e,i,o,u}, {f,o,u,r,t,e,e,n});
Out> {e,o,u};

In> Intersection({1,2,2,3,3,3}, {1,1,2,2,3,3});
Out> {1,2,2,3,3};
siehe auch:
Union , Difference .


Union -- Vereinigungsmenge zweier Listen

mathematische Standardbibliothek
Funktionsaufruf:
Intersection(l1, l2)
Parameter:
l1, l2 - zwei Listen
Beschreibung:
Die Vereinigungsmenge der Listen "l1" and "l2" wird bestimmt und als Ergebnis zurückgegeben. Die Vereinigungsmenge enthält alle Elemente, die in "l1" oder "l2" enthalten sind. In der resultierenden Liste kommt jedes Element nur einmal vor.
Beispiele:
In> Union({a,b,c}, {b,c,d});
Out> {a,b,c,d};

In> Union({a,e,i,o,u}, {f,o,u,r,t,e,e,n});
Out> {a,e,i,o,u,f,r,t,n};

In> Union({1,2,2,3,3,3}, {2,2,3,3,4,4});
Out> {1,2,3,4};
siehe auch:
Intersection , Difference .


Difference -- Differenz zweier Listen

mathematische Standardbibliothek
Funktionsaufruf:
Intersection(l1, l2)
Parameter:
l1, l2 - zwei Listen
Beschreibung:
Die Differenz der Listen "l1" and "l2" wird bestimmt und als Ergebnis zurückgegeben. Die Differenz enthält alle Elemente, die in "l1" vorkommen aber nicht in "l2". Die Reihenfolge der Elemente in "l1" bleibt erhalten. Ist ein Element n1-mal in "l1" und n2-mal in "l2" enthalten, erscheint es (n1-n2)-mal im Ergebnis.
Beispiele:
In> Difference({a,b,c}, {b,c,d});
Out> {a};

In> Difference({a,e,i,o,u}, {f,o,u,r,t,e,e,n});
Out> {a,i};

In> Difference({1,2,2,3,3,3}, {2,2,3,4,4});
Out> {1,3,3};
siehe auch:
Intersection , Union .


FillList -- Füllen einer Liste mit einem best. Ausdruck

mathematische Standardbibliothek
Funktionsaufruf:
FillList(expr, n)
Parameter:
expr - ein Term
n - die Länge der Liste
Beschreibung:
Die Funktion erzeugt eine Liste mit "n" gleichen Elementen "expr". Das Ergebnis ist die resultierende Liste.
Beispiele:
In> FillList(x, 5);
Out> {x,x,x,x,x};
siehe auch:
MakeVector , ZeroVector , RandomIntegerVector .


Drop -- Entfernen eines Bereichs von Listenelementen

mathematische Standardbibliothek
Funktionsaufruf:
Drop(list, n)
Drop(list, -n)
Drop(list, {m,n})
Parameter:
list - eine Liste
n, m - positive ganze Zahlen
Beschreibung:
Diese Funktion entfernt eine Teilliste der Liste "list". Das Ergebnis ist eine Liste mit den übrigen Elementen.
Der erste Funktionsaufruf entfernt die ersten "n" Elemente. Der zweite Funktionsaufruf entfernt die letzten "n" Elemente. Der dritte Funktionsaufruf entfernt die Elemente mit Indizees von "m" bis "n".
Beispiele:
In> lst := {a,b,c,d,e,f,g};
Out> {a,b,c,d,e,f,g};

In> Drop(lst, 2);
Out> {c,d,e,f,g};

In> Drop(lst, -3);
Out> {a,b,c,d};

In> Drop(lst, {2,4});
Out> {a,e,f,g};
siehe auch:
Take , Select , Remove .


Take -- Abspalten eines Bereichs von Listenelementen

mathematische Standardbibliothek
Funktionsaufruf:
Take(list, n)
Take(list, -n)
Take(list, {m,n})
Parameter:
list - eine Liste
n, m - positive ganze Zahlen
Beschreibung:
Diese Funktion spaltet eine Teilliste der Liste "list" ab und entfernt alle restlichen Elemente. Das Ergebnis ist die Teilliste.
Der erste Funktionsaufruf spaltet die ersten "n" Elemente ab. Der zweite Funktionsaufruf spaltet die letzten "n" Elemente ab. Der dritte Funktionsaufruf spaltet die Elemente mit Indizees von "m" bis "n" ab.
Beispiele:
In> lst := {a,b,c,d,e,f,g};
Out> {a,b,c,d,e,f,g};

In> Take(lst, 2);
Out> {a,b};

In> Take(lst, -3);
Out> {e,f,g};

In> Take(lst, {2,4});
Out> {b,c,d};
siehe auch:
Drop , Select , Remove .


Partition -- Umformen einer Liste in Teillisten gleicher Länge

mathematische Standardbibliothek
Funktionsaufruf:
Partition(list, n)
Parameter:
list - eine Liste
n - Länge der Teillisten
Beschreibung:
Diese Funktion zerlegt die Liste "list" in nicht überlappende Teillisten der Länge "n". Das Ergebnis ist eine Liste dieser Teillisten. Ist "n" kein Teiler der Listenlänge, werden die überzähligen Elemente nicht berücksichtigt.
Beispiele:
In> Partition({a,b,c,d,e,f,}, 2);
Out> {{a,b},{c,d},{e,f}};

In> Partition(1 .. 11, 3);
Out> {{1,2,3},{4,5,6},{7,8,9}};
siehe auch:
Take , Permutations .


Assoc -- Suchen eines Listenelements anhand eines Schlüssels

mathematische Standardbibliothek
Funktionsaufruf:
Assoc(key, alist)
Parameter:
key - ein Schlüssel
alist - eine Schlüsselliste
Beschreibung:
Die Schlüsselliste "alist" wird nach einem Element mit dem Schlüssel "key" durchsucht. Das Ergebnis ist das gesuchte Element oder Empty, falls das Element nicht gefunden wurde.

Schlüssellisten werden durch Listen von zweielementigen Listen repräsentiert. Das erste Element der zweielementigen Liste ist der Schlüssel, das zweite Element ist der dem Schlüssel zugeordnete Wert.

Ein zu Assoc(key, alist) äquivalenter Funktionsaufruf ist alist[key].
Beispiele:
In> writer := {};
Out> {};

In> writer["Iliad"] := "Homer";
Out> True;

In> writer["Henry IV"] := "Shakespeare";
Out> True;

In> writer["Ulysses"] := "James Joyce";
Out> True;

In> Assoc("Henry IV", writer);
Out> {"Henry IV","Shakespeare"};

In> Assoc("War and Peace", writer);
Out> Empty;
siehe auch:
AssocIndices , [] , := .


AssocIndices -- Schlüssel einer Schlüsselliste

mathematische Standardbibliothek
Funktionsaufruf:
AssocIndices(alist)
Parameter:
alist - eine Schlüsselliste
Beschreibung:
Das Ergebnis dieser Funktion ist eine Liste aller Schlüssel der Schlüsselliste "alist".
Beispiele:
In> writer := {};
Out> {};

In> writer["Iliad"] := "Homer";
Out> True;

In> writer["Henry IV"] := "Shakespeare";
Out> True;

In> writer["Ulysses"] := "James Joyce";
Out> True;

In> AssocIndices(writer);
Out> {"Iliad","Henry IV","Ulysses"};
siehe auch:
Assoc .


Flatten -- Zerlegen eines Terms in eine Liste

mathematische Standardbibliothek
Funktionsaufruf:
Flatten(expression,operator)
Parameter:
expression - ein Term
operator - ein String, der einen Operator enthält
Beschreibung:
Diese Funktion zerlegt einen Term in die Operanden bezgl. des angegebenen Operators. Das Ergebnis ist eine Liste mit den Operanden.
Diese Funktion wird eingesetzt, um verschachtelte Term aufzuspalten. Sie wird in den Vereinfachungsregeln verwendet.
Beispiele:
In> Flatten(a+b*c+d,"+");
Out> {a,b*c,d};

In> Flatten({a,{b,c},d},"List");
Out> {a,b,c,d};
siehe auch:
UnFlatten .


UnFlatten -- Erzeugen eines Terms aus den Elementen einer Liste

mathematische Standardbibliothek
Funktionsaufruf:
UnFlatten(list, operator, identity)
Parameter:
list - eine Liste
operator - ein Operator
identity - neutrales Element bzgl. des Operators
Beschreibung:
UnFlatten ist die umgekehrte Funktion zu Flatten. Die Elemente der Liste "list" werden mit dem Operator "operator" verknüpft.
Beispiele:
In> UnFlatten({a,b,c},"+",0)
Out> a+b+c;

In> UnFlatten({a,b,c},"*",1)
Out> a*b*c;
siehe auch:
Flatten .


Type -- den Typ eines Ausdrucks bestimmen

interne Funktion
Funktionsaufruf:
Type(expr)
Parameter:
expr - ein Term
Beschreibung:
Der Typ des Terms "expr" wird als String zurückgegeben. Ist z.B. "expr" eine Liste, dann wird als Ergebnis der String "List" zurückgegeben.
Beispiele:
In> Type({a,b,c});
Out> "List";

In> Type(a*(b+c));
Out> "*";

In> Type(123);
Out> "";
siehe auch:
IsAtom , NrArgs .


NrArgs -- Anzahl der Argumente eines Ausdrucks bestimmen

mathematische Standardbibliothek
Funktionsaufruf:
NrArgs(expr)
Parameter:
expr - ein Term
Beschreibung:
Das Ergebnis ist die Anzahl der Argumente des Terms "expr".
Beispiele:
In> NrArgs(f(a,b,c))
Out> 3;

In> NrArgs(Sin(x));
Out> 1;

In> NrArgs(a*(b+c));
Out> 2;
siehe auch:
Type , Length .


BubbleSort -- Sortieren eine Liste

mathematische Standardbibliothek
Funktionsaufruf:
BubbleSort(list, fn)
Parameter:
list - eine Liste
fn - eine Funktionen
Beschreibung:
Diese Funktion sortiert die Elemente der Liste "list" und gibt die sortierte Liste als Ergebnis zurück. Die Listenelemente werden mit Hilfe der Funktion "fn" verglichen. Die Funktion "fn" hat als Argumente zwei Listenelemente, die zu vergleichen sind. Ist das Ergebnis von "fn" True, wird in der sortierten Liste das zweite Argument hinter dem ersten angeordnet, sonst umgekehrt.

Die Funktion verwendet den BubbleSort-Algorithmus.
Beispiele:
In> BubbleSort({4,7,23,53,-2,1}, "<");
Out> {-2,1,4,7,23,53};

In> BubbleSort({4,7,23,53,-2,1}, ">");
Out> {53,23,7,4,1,-2};


Table -- Erzeugen einer Liste über eine Schleife

mathematische Standardbibliothek
Funktionsaufruf:
Table(body, var, from, to, step)
Parameter:
body - ein Term, der mehrfach ausgewertet wird
var - eine Schleifenvariable
from - der Startwert für "var"
to - der Endwert für "var"
step - die Schrittweite in der "var" erhöht wird
Beschreibung:
Diese Funktion erzeugt eine Liste von Werten. Der Term "body" wird dazu in Abhängigkeit von "var" ausgewertet. "var" durchläuft alle Werte von "from" bis "to" mit der Schrittweite "step". Das Ergebnis ist eine Liste aller berechneten Werte.
Beispiele:
In> Table(i!, i, 1, 10, 1);
Out> {1,2,6,24,120,720,5040,40320,362880,3628800};

In> Table(i, i, 3, 16, 4);
Out> {3,7,11,15};

In> Table(i^2, i, 10, 1, -1);
Out> {100,81,64,49,36,25,16,9,4,1};
siehe auch:
For , MapSingle , .. , TableForm .


TableForm -- gibt die Elemente einer Liste formatiert aus

mathematische Standardbibliothek
Funktionsaufruf:
TableForm(list)
Parameter:
list - eine Liste
Beschreibung:
Diese Funktion gibt die Liste "list" formatiert aus. Pro Zeile wird genau ein Listenelement ausgegeben.
Beispiele:
In> TableForm(Table(i!, i, 1, 10, 1));
 1
 2
 6
 24
 120
 720
 5040
 40320
 362880
 3628800
Out> True;
siehe auch:
PrettyForm , Echo , Table .