Manipulation von Listen

Copyright

Copyright 1994,  Claudia Funke und Markus Herold
TU-Berlin, FB 13, Fachgebiet Ökonometrie und Statistik
Dieses Notebook darf ausschließlich als Unterrichtsmaterial und für private Zwecke verwendet und nicht ohne Zustimmung der Autoren verändert werden.

Listen

Die Darstellung von Arrays, Vektoren und Matrizen sowie die Zusammenfassung von Daten, Variablen und mathematischen Ausdrücken erfolgt in Mathematica durch Listen.

Eine Liste ist vereinfacht die Zusammenfassung von Objekten, deren Symbole in geschweiften Klammern stehen und durch Kommata getrennt werden:

{item1, item2, item3, ... ,itemn}

Dabei müssen nicht alle Elemente einer Liste vom gleichen Typ sein. Die folgende  Liste besteht z.B. aus mehreren Integerzahlen, einer Realzahl, einigen Symbolen, einigen Funktionen, einem Polynom und einer Regel.

{4, 6, 7.8 , a, 7 x + 8, Sin[x], D, I, Integer, x -> E}

Der Zugang zu Mathematica wird erleichtert, wenn man sich Folgendes merkt: Alles, was in Mathematica nicht als Element darstellbar ist, ist 
eine Liste.

Im folgenden Beispiel wird ein simultanes Gleichungssystem gelöst. Die 
Gleichungen werden durch eine Liste spezifiziert und die von Mathematica berechnete Lösung ist wiederum eine Liste.

Solve[{2x + 5y == 19, 3x + 7y == 27}]

Die Lösung dieses Gleichungssystems wird in geschweiften Klammern ausgegeben, da die Funktion   Solve[ ]  als Ergebnis eine Liste der Lösungen liefert. Das Paar {{x  ->  2, y  ->  3}}  ist eine Lösung und in diesem Fall die einzige Lösung.

Anlegen von Listen

Range

Die Funktion   Range[ ]  erzeugt eine Liste mit aufeinanderfolgenden 
Zahlen.

Range[ m, n, d]

wobei	m = Untergrenze der Zahlenfolge
	n = Obergrenze der Zahlenfolge
	d = Differenz zwischen zwei aufeinanderfolgenden 
	      Listenelementen

Range[4]

Range[3,8]

Ohne Angabe der Differenz ist die Schrittweise 1.

Range[2.2, 6.6]

Range[2.2, 6.6, 0.4]

Table

Die Funktion  Table[ ]   ist wesentlich flexibler als Range[ ], da sie 
mehrdimensionale Listen erzeugen kann.

Table[ Ausdruck, iterator ]

wobei	Ausdruck = eine Funktion oder ein sonstiger Ausdruck
	iterator = steuert die Anzahl der Elemente, die generiert 
		werden sollen.

Der einfachste Iterator, eine Zahl in geschweiften Klammern, veranlaßt 
Mathematica, eine Liste mit  n  Listenelementen anzulegen.

Table[i, {5}]

Mit einem Iterator der Form   {i, imax}   erzeugt die Funktion Table[ ] 
eine Liste, wobei die Variable  i   im  Ausdruck  von  i  bis  imax   mit 
einer Schrittweite von 1 läuft.

Table[i^2, {i, 5}]

Mit dem Iterator   {i, imin, imax}  kann ein Startwert für die Iteration vor-
gegeben werden.

Table[5i, {i, 5, 10}]

Der Iterator   {i, imin, imax, d} gibt zusätzlich die Schrittweite der 
Iteration vor.

Table[5i, {i, 5, 10, 0.5}]

Ist das erste Argument der Table-Funktion eine Liste, arbeitet der 
Iterator auf dieser Liste. Zum Erzeugen einer neuen Liste wird also jedes Element im Ausdruck von Table[ ] angesprochen.

Table[{i, 1/i}, {i, 3}]

Table[] kann auch mit mehreren Indexvariablen und Iteratoren 
arbeiten. Im folgenden Beispiel wird mit zwei Indexvariablen und zwei 
Iteratoren eine zweidimensionale Liste (Matrix) erzeugt.

Table[1/(i+j), {i, 4}, {j, 4}]

MatrixForm[%]

Table[a[i] + b[j], {i, 1, 3}, {j, 4, 6}]; 
MatrixForm[%]

Das folgende Beispiel zeigt, daß der Wert des einen Iterators vom anderen 
Iterator abhängen kann.

Table[a[i] + b[j], {i, 1, 3}, {j, i, 4}]; 
MatrixForm[%]

Die Dimension der erzeugten Liste wird mit Dimensions[ ] abgefragt.

Dimensions[ Ausdruck ]

Table[a[i] + b[j], {i, 1, 3}, {j, 1, 4}]; 
Dimensions[%]

Array

Mit der Funktion   Array[ ]   können sehr einfach ein- und mehrdimensionale symbolische Listen erzeugt werden.

Array[ Ausdruck, {n1, n2, ... } ]

wobei	Ausdruck = eine Funktion oder ein sonstiger Ausdruck
	n1, n2, ... = n1 x  n2  x  ....  verknüpfte Liste

Die Funktion Array[ ] wendet den Ausdruck auf jeden Index der 
angegebenen Liste an.

Array[a, {3}]

Array[a, {2, 3}]

MatrixForm[%]

Anhand einer solchen symbolische Matrix läßt sich zum Beispiel
die Determinantenberechnung demonstrieren.

m = Array[a, {2,2}]; MatrixForm[m]

Det[m]

Manipulation von Listen als Ganzes

Als Beispiele für die Manipulation von Listen seien die Funktionen 
Sort[ ], RotateLeft[ ], RotateRight[ ] und Permutation[ ] aufgeführt. Dazu wird eine Beispielsliste erzeugt:

listeA = Table[i, {i, 10, 1, -1}]

Sort[ Liste ]

sortiert eine Liste in aufsteigender Reihenfolge.

Sort[listeA]

??Sort

RotateLeft[ Liste, n ]

rotiert die Elemente im Ausdruck n-Positionen nach links.

RotateLeft[listeA, 2]

RotateRight[ Liste, n ]

rotiert die Elemente im Ausdruck n-Positionen nach rechts.

RotateRight[listeA, 2]

Permutations[ Liste ]

erzeugt eine Liste aller möglichen Permutationen der Elemente in Liste.

Permutations[{a, b, c}]

Zugriff auf Listenelemente

Teile von Listen oder einzelne Listenelemente erhält man über die Indexierung der Liste oder über die Funktionen Part[ ], Take[ ] und Drop[ ].

list[[ i,j ]]  oder   Part[[ Liste, i, j ]]

ergeben das i,j - te Element der Matrix Liste.

v = Table[x^2, {x, 1, 4}]

v[[3]]

m = Array[a, {3,3}]

m[[2,2]]

Den Zugriff auf mehrere Elemente einer Liste läßt sich am besten anhand von (einfachen) Matrizen als zweidimensionale Listen 
erläutern:

list[[ Ausdruck, x ]]   oder   Part[ Liste, i ]

ergeben die i - te Zeile in der Matrix Liste.

m[[3]]

Die Spalte einer Matrix erhält man unter Verwendung der Funktion 
Transpose[ ].

z = Transpose[m]; MatrixForm[z]

Transpose[m] [[3]]

Aus bestehenden Listen können neue Listen auch durch Indexierung der 
betrachteten Liste entstehen:

Take[ Liste, {m, n} ]

ergibt eine neue Liste, die aus den Elementen mit dem Index m bis 
einschließlich n besteht.

listeB = Sort[listeA]

Take[listeB, {2, 7}]

Take[listeB, 4]

Take[listeB, -4]

Die neue Liste kann auch aus einem "Rest" aufgebaut sein:

Drop[ Liste, {m, n} ]

ergibt eine neue Liste, in der die Elemente mit dem Index m bis 
einschließlich n entfernt wurden.

Drop[listeB, {8, 10}]

Drop[listeB, -3]

Drop[listeB, 3]

Anwendung von Funktionen auf Listen

In Mathematica gibt es zwei Wege, eine Funktion auf jedes Element einer 
Liste anzuwenden.

1. Die Funktion bekommt das Attribut    Listable (zu Attributen später).
2. Durch Benutzung des Befehls  Map[ ].

Dazu wird eine Beispielsfunktion definiert, definiert, die im Folgenden durch  den Namen f  angesprochen werden kann:

f[x_] := 1/x

??f

Mit

Map[ f, {item1, item2, ... } ]

wird die funktion  f  auf jedes Listenelement angewandt.

Map[f, {a, b, c}]

f /@ {item1, item2, ... }

ist die Kurzform des Map[] - Befehls.

f /@ {a, b, c}

Sqrt /@  {a, b, c}