3.4 Erzeugung von Matrizen

Arrays bzw. Matrizen können auf vielfältige Weise erzeugt werden:

Explizite Eingabe (3.4.1).
Erzeugung mit Hilfe der Doppelpunkt Notation (3.4.2).
Erzeugung mit Hilfe eingebauter Funktionen (3.4.3).
Laden von einem externen File (3.4.4).
Selbst geschriebene Funktionen (M-files).

3.4.1 Explizite Eingabe

Die explizite Eingabe einer beliebigen Matrix (hier z.B. eines magisches Quadrats),

$\displaystyle \left[ \begin{array}{cccc} 16 & 3 & 2 & 13 5 & 10 & 11 & 8 9 & 6 & 7 & 12 4 & 15 & 14 & 1 \end{array} \right]$

kann auf folgende Weise durchgeführt werden:

 A = [16,3,2,13; 5,10,11,8; 9,6,7,12; 4,15,14,1]

wobei hier eine Zuweisung der Werte auf eine Variable mit dem Namen A erfolgt.

Man muss dabei folgende Regeln beachten:

Die einzelnen Einträge innerhalb einer Zeile (row) werden durch Leerzeichen (blanks) oder bevorzugt durch Beistriche (commas) getrennt.
Der Strichpunkt (semicolon) schließt eine Zeile ab.
Die gesamte Liste der Einträge wird in eckige Klammern [] gestellt.

3.4.2 Doppelpunkt Notation

Die Doppelpunktnotation ist eine der mächtigsten Bestandteile von MATLAB. Sie kann einerseits zur Konstruktion von Vektoren (Tab.3.2), aber auch zum Zugriff auf Teile von Matrizen (Index, 3.6) verwendet werden.

**Table 3.2:** Doppelpunkt Notation zur Erzeugung von Vektoren
Op.	Alt.	Befehl	Resultat	Bedingung
`J:K`	`J:1:K`	`colon(J,K)`	`[J, J+1, ..., K]`	`K>=J`
`J:K`	`J:1:K`	`colon(J,K)`	`[]`	`K<J`
`J:D:K`		`colon(J,D,K)`	`[J, J+D, ..., J+m*D]`	`K>=J & D>0`
`J:D:K`		`colon(J,D,K)`	`[J, J+D, ..., J+m*D]`	`K<=J & D<0`
`J:D:K`		`colon(J,D,K)`	`[]`	`K<J & D>0`
`J:D:K`		`colon(J,D,K)`	`[]`	`K>J & D<0`
`J:D:K`		`colon(J,D,K)`	`[]`	`D=0`

Definition:: m = fix((K-J)/D), Umwandlung in ganze Zahlen durch Abschneiden.
Leere Arrays:: Symbolisiert durch [].
Logisches UND:: Verwendetes Symbol &.

MATLAB EXAMPLE:

X = 1:5 1 2 3 4 5 X = 1:2:5 1 3 5 X = 1:-2:5 Empty matrix: [] X = 5:-2:1 5 3 1 X = 5:2:1 Empty matrix: []
Der Befehl colon bzw. der Operator :

Einige gültige und ungültige Beispiele für die Doppelpunkt Notation.

MATLAB EXAMPLE:

X = 1:5 1 2 3 4 5 X = 1:2:5 1 3 5 X = 1:-2:5 Empty matrix: [] X = 5:-2:1 5 3 1 X = 5:2:1 Empty matrix: []	Der Befehl colon bzw. der Operator `:` Einige gültige und ungültige Beispiele für die Doppelpunkt Notation.

3.4.3 Interne Befehle zur Erzeugen von Matrizen

Es gibt eine Reihe von Befehlen zur einfachen Erzeugung von Matrizen.

**Table 3.3:** MATLAB Befehle zum Erzeugen von Matrizen
zeros(m)	Erzeugt eine m $\times$ m Nullmatrix
zeros(m,n)	Erzeugt eine m $\times$ n Nullmatrix
ones(m)	Erzeugt eine m $\times$ m Matrix mit lauter Einsen
ones(m,n)	Erzeugt eine m $\times$ n Matrix mit lauter Einsen
eye(m)	Erzeugt eine m $\times$ m Einheitsmatrix
eye(m,n)	Erzeugt eine m $\times$ n Einheitsmatrix
linspace(a,b,n)	Erzeugt Zeilenvektor mit n äquidistanten Werten von a bis b.
logspace(a,b,n)	Erzeugt Zeilenvektor mit n Werten von 10 bis 10 mit logarithmisch äquidistantem Abstand.
rand(m)	Erzeugt eine m $\times$ m Zufallsmatrix (gleichverteilt aus [0,1])
rand(m,n)	Erzeugt eine m $\times$ n Zufallsmatrix (gleichverteilt aus [0,1])
randn(m)	Erzeugt eine m $\times$ m Zufallsmatrix (normalverteilt)
randn(m,n)	Erzeugt eine m $\times$ n Zufallsmatrix (normalverteilt)

**Table 3.4:** Ergänzende MATLAB Befehle zum Erzeugen von Matrizen
diag(v,k)	v $\dots$ Vektor, k $\dots$ Skalar. Erzeugt eine Matrix mit lauter Nullen, außer auf der k-ten Nebendiagonale, die mit den Werten von v gefüllt wird. k = 0 ist die Hauptdiagonale, k0 darüber, k0 darunter. Für k=0 kann man auch diag(v) schreiben.
diag(m,k)	m $\dots$ Matrix. Extrahiert die k-te Nebendiagonale. (k siehe oben).
triu(m)	Extrahiert oberes Dreieck aus der Matrix m.
triu(m,k)	Extrahiert Dreieck oberhalb der Nebendiagonale k aus der Matrix m. (k siehe oben).
tril(m)	Extrahiert unteres Dreieck aus der Matrix m.
tril(m,k)	Extrahiert Dreieck unterhalb der Nebendiagonale k aus der Matrix m. (k siehe oben).
blkdiag(a,b, $\dots$ )	Erzeugt eine blockdiagonale Matrix. a,b, $\dots$ sind Matrizen.
repmat(a,m,n)	Erzeugt aus einer Matrix a eine neue Matrix durch Replikation in Zeilenrichtung (m-mal) und Spaltenrichtung (n-mal).

Mit Hilfe des Befehls [z,s]=meshgrid(v1,v2) ist es sehr leicht zwei gleich große Matrizen zu erzeugen. Sind die beiden Vektoren v1 und v2 z.B. die Vektoren 1:n und 1:m, dann ergeben sich folgende Matrizen:

$\displaystyle z = \left[ \begin{array}{ccccc} 1 & 2 & 3 & \dots & n 1 & 2 & ... ...& \vdots & \ddots & \vdots m & m & m & \dots & m \end{array} \right] \; .$

(3.1)

Die Variablen m und n müssen dabei vorher definiert werden. Analog kann das natürlich mit allen anderen Vektoren ausgeführt werden. Die so erhaltenen Matrizen eignen sich bestens zum Kombinieren.

Mit dem Befehl v = z + 100*s erhält man sofort folgende Matrix:

$\displaystyle v = \left[ \begin{array}{cccccc} 101 & 102 & 103 & 104 & 105 & \d... ...\vdots & \vdots & \vdots & \vdots & \vdots & \ddots \end{array} \right] \; .$

(3.2)

3.4.4 Lesen und Schreiben von Daten

Neben komplexen Befehlen zum Schreiben und Lesen von Daten und dem Umgang mit externen Datenfiles, gibt es zum Lesen geordneter Strukturen den einfachen Befehl load. Er funktioniert nur, wenn die Daten in Tabellenform ohne fehlende Einträge oder Kommentarzeilen gespeichert sind.

Die Form des Aufrufs ist D = load('d.dat'), wobei hier 'd.dat' für eine Zeichenkette mit dem Filenamen steht. Das Gegenstück zum Speichern von lesbaren Daten ist save. Dieser Befehl wird in folgender Form verwendet: save('d.dat','D','-ascii')

Eine detailierte Beschreibung von Schreibe- und Leseroutinen folgt in einem späteren Kapitel.

Winfried Kernbichler 2005-04-26