Vektoren und Matrizen - Cinderella Dokumentation
Description: The user's guide to the Interactive Geometry Software Cinderella

Zum Inhalt

# Vektoren und Matrizen

Listen können als Darstellung von Vektoren und Matrizen dienen. Insbesondere Listen, die numerische Werte enthalten, ermöglichen viele verschiedene arithmetische Operationen. Darüber hinaus werden die Koordinatenwerte geometrischer Elemente üblicherweise als Listen numerischer Werte abgerufen. Zum Beispiel: Wenn `A` das Label eines geometrischen Punkts ist, gibt `A.xy` eine Liste von zwei Zahlen zurück – die `x`- und `y`-Koordinaten des Punkts. Ähnlich gibt `A.homog` eine Liste von drei Zahlen zurück: die homogenen Koordinaten des Punkts. Mehrere arithmetische Operationen dienen dem speziellen Zweck, direkt mit diesen Koordinatenvektoren zu rechnen.

### Definition von Vektoren und Matrizen

Jede Liste kann als „Vektor von Objekten" betrachtet werden. Von besonderem Interesse sind jedoch Vektoren von Zahlen. Ein solcher Vektor wird „Zahlenvektor" genannt. Ob eine bestimmte Liste ein Zahlenvektor ist, kann mit dem Operator `isnumbervector(<expr>)` getestet werden.

Wenn die Elemente einer Liste wiederum Listen sind und alle diese Listen dieselbe Länge haben, wird eine solche Liste Matrix genannt. Ob eine Liste eine Matrix ist, kann mit dem Operator `ismatrix(<expr>)` getestet werden. Wenn darüber hinaus alle (zweiten) Elemente in der Matrix Zahlen sind, wird diese Matrix eine Zahlenmatrix genannt. Ob eine Liste eine Zahlenmatrix ist, kann mit dem Operator `isnumbermatrix(<expr>)` getestet werden. Die Einträge einer Matrix sind Vektoren derselben Länge. Diese Vektoren werden als die Zeilen der Matrix betrachtet. Wenn eine Matrix also n Vektoren der Länge m enthält, ist sie eine n × m Matrix.

### Addition und Multiplikation

Im Abschnitt Arithmetische Operatoren erklären wir, wie die grundlegenden Operationen Addition, Subtraktion, Multiplikation und Division auf Listen von Zahlen angewendet werden können. Als Faustregel kann man sagen, dass auf dieser Ebene alles, was mathematisch sinnvoll ist, in CindyScript durchgeführt werden kann. Wenn `A` und `B` zum Beispiel Listen von Zahlen sind, berechnet der Ausdruck `(A+B)/2` den Mittelpunkt dieser beiden Vektoren.

Addition und Subtraktion von Listen sind zulässig, wenn die Listen die gleiche Form haben. Das bedeutet, dass die Listen dieselbe Länge haben und wenn einige der Einträge selbst Listen sind, dann haben die entsprechenden Einträge der beiden Summanden rekursiv wieder die gleiche Form.

Multiplikation mit Listen ist zulässig, wenn diese eine mathematisch sinnvolle Operation durchführt. Die folgende Tabelle fasst die verschiedenen zulässigen Verwendungen des Multiplikationsoperators zusammen.

Faktor 1 | Faktor 2 | Ergebnis | Bedeutung
--- | --- | --- | ---
Zahl | Zahl | Zahl | übliche Multiplikation
Zahl | Vektor der Länge r | Vektor der Länge r | Skalare Vektor-Multiplikation
Vektor der Länge r | Zahl | Vektor der Länge r | Skalare Vektor-Multiplikation
Vektor der Länge r | Vektor der Länge r | Zahl | Skalarprodukt zweier Vektoren
n × r Matrix | Vektor der Länge r | Vektor der Länge n | Matrix × Vektor
Vektor der Länge n | n × r Matrix | Vektor der Länge r | Vektor × Matrix
n × r Matrix | r × m Matrix | n × m Matrix | Matrizenmultiplikation

### Produkte, Summen, Maximum und Minimum

#### Der Summationsoperator: `sum(<list>)`

Beschreibung: Dieser Operator addiert alle Elemente einer Liste. Die Elemente können Zahlen sein, oder selbst Listen (oder Vektoren oder Matrizen), oder sogar Strings.

Code | Ergebnis |  |
`sum(1..10)` | `55` |  |
`sum([4,6,2,6])` | `18` |  |
`sum([ [3, 5], [2, 5], [5, 6] ])` | `[10, 16]` |  |
`sum(["h","e","ll","o"])` | `"hello"` |  |

Man kann den Summationsoperator zum Beispiel verwenden, um eine Funktion für das arithmetische Mittel mit folgendem Code zu definieren:

    average(x) := sum(x)/length(x)

Diese Funktion funktioniert sowohl für eine Liste von Zahlen als auch für den Durchschnitt einer Liste von Vektoren oder Matrizen.

#### Der Summationsoperator: `sum(<list>,<expr>)`

Beschreibung: Dieser Operator ähnelt dem Summationsoperator, addiert aber die Ergebnisse von `<expr>`, während eine Schleife alle Elemente von `<list>` durchläuft. Die Laufvariable ist wie üblich `#`.

Wir können die Summe aller Quadrate der ersten hundert ganzen Zahlen mit folgendem Ausdruck berechnen:

Code | Ergebnis |  |
`sum(1..100,#^2)` | `338350` |  |

Es ist Zeit für ein kleines mathematisches Rätsel:

Code | Ergebnis |  |
`sum(1..10,#^2)` | `385` |  |
`sum(1..100,#^2)` | `338350` |  |
`sum(1..1000,#^2)` | `333833500` |  |
`sum(1..10000,#^2)` | `333383335000` |  |

#### Der Summationsoperator: `sum(<list>,<var>,<expr>)`

Beschreibung: Dieser Operator ähnelt dem vorherigen, nur dass die Laufvariable lokal `<var>` genannt wird.

#### Der Produktoperator: `product(<list>)`

Beschreibung: Dieser Operator multipliziert alle Elemente einer Liste miteinander. Von den Elementen wird erwartet, dass sie Zahlen sind.

Code | Ergebnis |  |
`product(1..5)` | `120` |  |

Man kann den Produktoperator zum Beispiel verwenden, um die Fakultätsfunktion mit folgendem Code zu definieren:

    fac(x) := product(1..x)

#### Der Produktoperator: `product(<list>,<expr>)`

Beschreibung: Dieser Operator ähnelt dem Produktoperator, berechnet aber das Produkt der Ergebnisse von `<expr>`, während eine Schleife alle Elemente von `<list>` durchläuft. Die Laufvariable ist wie üblich `#`.

#### Der Produktoperator: `product(<list>,<var>,<expr>)`

Beschreibung: Dieser Operator ähnelt dem vorherigen, nur dass die Laufvariable lokal `<var>` genannt wird.

#### Der Maximumoperator: `max(<list>)`

Beschreibung: Dieser Operator findet den Maximalwert in einer Liste von Einträgen.

Code | Ergebnis |  |
`max([4,2,6,3,5])` | `6` |  |

#### Der Maximumoperator: `max(<list>,<expr>)`

Beschreibung: Dieser Operator ähnelt dem Maximumoperator `max(<list>)`, berechnet aber das Maximum der Ergebnisse von `<expr>`, während eine Schleife alle Elemente von `<list>` durchläuft. Die Laufvariable ist wie üblich `#`.

#### Der Maximumoperator: `max(<list>,<var>,<expr>)`

Beschreibung: Dieser Operator ähnelt dem vorherigen, nur dass die Laufvariable lokal `<var>` genannt wird.

#### Der Minimumoperator: `min(<list>)`

Beschreibung: Dieser Operator findet das Minimum einer Liste von Einträgen.

Code | Ergebnis |  |
`min([4,2,6,3,5])` | `2` |  |

#### Der Minimumoperator: `min(<list>,<expr>)`

Dieser Operator ähnelt dem Minimumoperator `min(<list>)`, berechnet aber das Minimum der Ergebnisse von `<expr>`, während eine Schleife alle Elemente von `<list>` durchläuft. Die Laufvariable ist wie üblich `#`.

#### Der Minimumoperator: `min(<list>,<var>,<expr>)`

Beschreibung: Dieser Operator ähnelt dem vorherigen, nur dass die Laufvariable lokal `<var>` genannt wird.

### Vektor- und Matrizrenrechnung

Neben Addition und Multiplikation, wie sie früher in diesem Abschnitt beschrieben wurden, gibt es mehrere Operatoren für die Vektor- und Matrixverwaltung.

#### Dimensionen einer Matrix: `matrixrowcolum(<matrix>)`

Beschreibung: Wenn das Argument eine Matrix ist, gibt dieser Operator die Anzahl der Zeilen und die Anzahl der Spalten der Matrix zurück, codiert als eine Liste mit zwei Elementen.

Code | Ergebnis |  |
`matrixrowcolumn([[1,2],[3,2],[1,3],[5,4]])` | `[4,2]` |  |

#### Transponieren einer Matrix: `transpose(<matrix>)`

Beschreibung: Wenn das Argument eine Matrix ist, gibt dieser Operator die Transponierte der Matrix zurück. In der Transponierten werden Zeilen und Spalten vertauscht.

Code | Ergebnis |  |
`transpose([[1,2],[3,2],[1,3], [5,4]])` | `[[1,3,1,5],[2,2,3,4]]` |  |
`transpose([[1],[3],[1],[5]])` | `[[1,3,1,5]]` |  |
`transpose([[1,3,1,5]])` | `[[1],[3],[1],[5]]` |  |

#### Zeilen einer Matrix: `row(<matrix>,<int>)`

Beschreibung: Wenn das erste Argument eine Matrix ist, gibt dieser Operator die Zeile mit Index `<int>` als Vektor zurück.

Code | Ergebnis |  |
`row([[1,2],[3,2],[1,3], [5,4]],2)` | `[3,2]` |  |

#### Spalten einer Matrix: `column(<matrix>,<int>)`

Beschreibung: Wenn das erste Argument eine Matrix ist, gibt dieser Operator die Spalte mit Index `<int>` als Vektor zurück.

Code | Ergebnis |  |
`column([[1,2],[3,2],[1,3], [5,4]],2)` | `[2,2,3,4]` |  |

#### Extrahieren einer Submatrix: `submatrix(<matrix>,<int1>,<int2>)`

Beschreibung: Wenn das erste Argument eine Matrix ist, gibt dieser Operator die Submatrix zurück, die durch Löschen der Spalte mit Index `<int1>` und der Zeile mit Index `<int2>` erhalten wird.

Code | Ergebnis |  |
`submatrix([[1,2,4],[3,2,3], [1,3,6],[5,4,7]],2,3)` | `[[1,4],[3,3],[5,7]]` |  |

#### Umwandlung eines Vektors in eine Zeilenmatrix: `rowmatrix(<vector>)`

Beschreibung: Wenn das erste Argument ein Vektor ist, gibt dieser Operator die Matrix mit einer einzelnen Zeile zurück, die aus diesem Vektor besteht.

Code | Ergebnis |  |
`rowmatrix([1,2,3,4])` | `[[1,2,3,4]]` |  |

#### Umwandlung eines Vektors in eine Spaltenmatrix: `columnmatrix(<vector>)`

Beschreibung: Wenn das erste Argument ein Vektor ist, gibt dieser Operator die Matrix mit einer einzelnen Spalte zurück, die aus diesem Vektor besteht.

Code | Ergebnis |  |
`columnmatrix([1,2,3,4])` | `[[1],[2],[3],[4]]` |  |

#### Erstellen eines Nullvektors: `zerovector(<int>)`

Beschreibung: Erstellt einen Nullvektor der Länge `<int>`.

#### Erstellen einer Nullmatrix: `zeromatrix(<int1>,<int2>)`

Beschreibung: Erstellt eine Matrix mit `<int1>` Zeilen und `<int2>` Spalten, die nur Nullen enthält.

### Lineare Algebra

Da Listen als Vektoren oder Matrizen verwendet werden können, gibt es auch mehrere arithmetische Operationen aus der linearen Algebra, die auf Listen anwendbar sind.

#### Determinante einer quadratischen Matrix: `det(<matrix>)`

Beschreibung: Dieser Operator berechnet die Determinante einer quadratischen Matrix, d. h. einer mit gleicher Anzahl von Zeilen und Spalten. Beachten Sie, dass die Determinante eine äußerst nützliche Funktion für viele geometrische Zwecke ist. Zum Beispiel ist die Determinante der 3 × 3 Matrix, die von den homogenen Koordinaten von drei Punkten gebildet wird, genau dann Null, wenn die drei Punkte kollinear sind. Das Vorzeichen der Determinante trägt Informationen über die relative Orientierung der drei Punkte. Im Abschnitt Geometrische Operatoren finden Sie Beschreibungen der Funktionen `area(<vec1>,<vec2>,<vec3>)` und `det(<vec1>,<vec2>,<vec3>)`. Beide sind Varianten der Determinantenfunktion, die in geometrischen Kontexten besonders nützlich sind und eine etwas bessere Leistung als die allgemeine Determinantenformel aufweisen.

#### Berechnung der Länge eines Vektors: `|<vec>|`

Beschreibung: Das Einschließen eines Vektors zwischen zwei senkrechten Strichen `|<vec>|` kann verwendet werden, um die Länge eines Vektors zu berechnen. Dieser Operator kann auch auf eine reelle oder komplexe Zahl angewendet werden und gibt ihren Absolutwert zurück.

#### Berechnung des Abstands zwischen zwei Vektoren: `|<vec1>,<vec2>|`

Beschreibung: Das Einschließen von zwei Vektoren gleicher Länge zwischen zwei senkrechten Strichen `|<vec1>,<vec2>|` kann verwendet werden, um den Abstand zwischen den Vektoren zu berechnen.

#### Berechnung von Abständen: `dist(<vec1>,<vec2>)`

Beschreibung: Dieser Operator berechnet den Abstand zwischen zwei Vektoren und gibt ihn als Zahl zurück. Dieser Operator ist auch sehr nützlich für geometrische Berechnungen.

#### Das hermitesche Skalarprodukt: `hermiteanproduct(<vec1>,<vec2>)`

Beschreibung: Dieser Operator gibt das hermitesche Skalarprodukt zweier Vektoren zurück. Er ähnelt dem Skalarprodukt `<vec1>*<vec2>`. Der zweite Vektor wird jedoch komplex konjugiert, bevor die Multiplikation durchgeführt wird. Insbesondere ist `hermiteanproduct(a,a)` immer nicht negativ.

Beispiel:

Das folgende Code-Fragment zeigt den Unterschied zwischen dem Skalarprodukt und dem Skalarprodukt.

    a=[2+3*i,1-i];
    println(hermiteanproduct(a,a));
    println(a*a);

erzeugt die Ausgabe:

    15
    -5 + i*10

#### Inverse einer quadratischen Matrix: `inverse(<matrix>)`

Beschreibung: Dieser Operator berechnet die Inverse einer quadratischen Matrix, d. h. einer mit gleicher Anzahl von Zeilen und Spalten. Wenn die Matrix nicht quadratisch oder nicht invertierbar ist, gibt der Operator ein nicht definiertes Objekt zurück. Inversen sind manchmal sehr nützlich, wenn das gleiche Typ lineares Gleichungssystem Ax=b für verschiedene rechte Seiten b gelöst werden muss. Wenn sich die Matrix A häufig ändert, ist es besser, den `linearsolve`-Operator zu verwenden.

#### Adjunkte einer quadratischen Matrix: `adj(<matrix>)`

Beschreibung: Dieser Operator berechnet die Adjunkte einer quadratischen Matrix. Für invertierbare Matrizen ist die Adjunkte die Inverse multipliziert mit der Determinante. Im Gegensatz zur Inversen existiert die Adjunkte einer Matrix immer.

#### Eigenwerte einer quadratischen Matrix: `eigenvalues(<matrix>)`

Beschreibung: Dieser Operator berechnet die Eigenwerte einer quadratischen Matrix. Das Ergebnis wird als Liste von Werten zurückgegeben. Wenn ein Eigenwert mit algebraischer Vielfachheit „r" auftritt, listet der Operator diesen Eigenwert „r" Mal auf. Der Operator gibt also immer n Werte für eine n × n Matrix zurück. Insbesondere geht der Operator davon aus, dass die Matrix über den komplexen Zahlen eingebettet ist. Daher werden auch komplexe Eigenwerte aufgelistet.

Beispiel:

    m1=[[1,1,0],[0,1,0],[0,0,.5]];
    println(eigenvalues(m1));
    m2=[[1,1,0],[-1,1,0],[0,0,.5]];
    println(eigenvalues(m2));

erzeugt die Ausgabe:

    [1,1,0.5]
    [1 + i*1,1 - i*1,0.5]

#### Eigenvektoren einer quadratischen Matrix: `eigenvectors(<matrix>)`

Beschreibung: Dieser Operator berechnet eine Basis von Eigenvektoren einer quadratischen Matrix. Das Ergebnis wird als Liste von Vektoren zurückgegeben. Die Reihenfolge dieser Liste entspricht der Reihenfolge der Eigenwerte im `eigenvalues`-Operator.

Warnung: Wenn die Matrix nicht diagonalisierbar ist, ist die Ausgabe dieser Funktion bedeutungslos.

#### Lösen einer linearen Gleichung: `linearsolve(<matrix>,<vector>)`

#### Lösen einer linearen Gleichung: `linearsolve(<matrix>,<matrix>)`

Beschreibung: Der Operator `linearsolve(A,b)` berechnet eine Lösung x des Gleichungssystems Ax=b. Die Matrix A muss quadratisch (n × n) und invertierbar sein. b kann entweder ein n-dimensionaler Vektor sein oder eine Matrix mit n Zeilen. Wenn entweder A nicht invertierbar ist oder die Dimensionsbeschränkungen nicht erfüllt sind, wird ein nicht definierter Wert zurückgegeben.

Beispiel:

    m=[[1,1,0],[0,1,0],[0,1,1]];
    x=linearsolve(m,[2,3,4]);
    println(x);
    println(m*x);

erzeugt die Ausgabe:

    [-1,3,1]
    [2,3,4]

### Erweiterte geometrische Operationen

#### Berechnung einer konvexen Hülle in 3D: `convexhull3d(<list of vectors>)`

Beschreibung: Dieser Operator nimmt eine Liste von dreidimensionalen Vektoren als Eingabe und berechnet ihre konvexe Hülle. Er gibt ein Paar von zwei Listen zurück. Die erste dieser Listen enthält die Eckpunkte der konvexen Hülle. Die zweite Liste enthält die Liste der Facetten der konvexen Hülle. Jede Facette wird durch die Indizes der Eckpunkte der ersten Liste angegeben.

Beispiel: Die folgende Liste von Punkten beschreibt einen dreidimensionalen Würfel mit einem zusätzlichen Punkt in seinem Zentrum.

     [[1,1,1],[1,1,-1],[1,-1,1],[1,-1,-1],
      [-1,1,1],[-1,1,-1],[-1,-1,1],[-1,-1,-1],[0,0,0]]

Das Anwenden des Operators der konvexen Hülle auf diese Liste erzeugt die folgende Ausgabe:

    [
     [[1,1,1],[1,1,-1],[1,-1,1],[1,-1,-1],
      [-1,1,1],[-1,1,-1],[-1,-1,1],[-1,-1,-1]],
     [[6,5,1,2],[3,1,5,7],[3,4,2,1],[8,7,5,6],[8,6,2,4],[8,4,3,7]]
    ]

Beachten Sie, dass der innere Punkt ordnungsgemäß entfernt wurde und der Operator der konvexen Hülle Koplanarität elegant handhaben kann.

Der Operator der konvexen Hülle ist bemerkenswert robust gegen degenerierte Situationen. Das folgende Bild wurde unter Verwendung des Operators `convexhull3d(...)` berechnet. Es zeigt den Querschnitt eines 4-dimensionalen Polytops (einer 600-Zelle) mit einem 3-dimensionalen Raum.

Ein mit CindyScript gerenderter Querschnitt einer 600-Zelle.

Diese Seite wurde automatisch mit KI (Claude) übersetzt und wartet noch auf Überprüfung. → Alle KI-übersetzten Seiten