SymPy - Matrizen

In der Mathematik ist eine Matrix ein zweidimensionales Array von Zahlen, Symbolen oder Ausdrücken. Die Theorie der Matrixmanipulation befasst sich mit der Durchführung arithmetischer Operationen an Matrixobjekten unter bestimmten Regeln.

Die lineare Transformation ist eine der wichtigsten Anwendungen von Matrizen. Viele wissenschaftliche Bereiche, insbesondere in Bezug auf die Physik, verwenden matrixbezogene Anwendungen.

Das SymPy-Paket verfügt über ein Matrizenmodul, das sich mit der Matrixbehandlung befasst. Es enthält eine Matrixklasse, deren Objekt eine Matrix darstellt.

Note: If you want to execute all the snippets in this chapter individually, you need to import the matrix module as shown below −

>>> from sympy.matrices import Matrix

Example

>>> from sympy.matrices import Matrix 
>>> m=Matrix([[1,2,3],[2,3,1]]) 
>>> m
$\displaystyle \left[\begin{matrix}1 & 2 & 3\\2 & 3 & 1\end{matrix}\right]$

Bei Ausführung des obigen Befehls in der Python-Shell wird die folgende Ausgabe generiert:

[1 2 3 2 3 1]

Die Matrix wird aus Listenobjekten geeigneter Größe erstellt. Sie können eine Matrix auch erhalten, indem Sie Listenelemente in einer bestimmten Anzahl von Zeilen und Spalten verteilen.

>>> M=Matrix(2,3,[10,40,30,2,6,9]) 
>>> M
$\displaystyle \left[\begin{matrix}10 & 40 & 30\\2 & 6 & 9\end{matrix}\right]$

Bei Ausführung des obigen Befehls in der Python-Shell wird die folgende Ausgabe generiert:

[10 40 30 2 6 9]

Matrix ist ein veränderliches Objekt. Das Matrizenmodul bietet auch die ImmutableMatrix-Klasse zum Erhalten einer unveränderlichen Matrix.

Grundlegende Manipulation

Das shape Die Eigenschaft des Matrix-Objekts gibt seine Größe zurück.

>>> M.shape

Die Ausgabe für den obigen Code lautet wie folgt:

(2,3)

Die Methode row () und col () gibt jeweils eine Zeile oder Spalte mit der angegebenen Nummer zurück.

>>> M.row(0)
$\displaystyle \left[\begin{matrix}10 & 40 & 30\end{matrix}\right]$

Die Ausgabe für den obigen Code lautet wie folgt:

[10 40 30]

>>> M.col(1)
$\displaystyle \left[\begin{matrix}40\\6\end{matrix}\right]$

Die Ausgabe für den obigen Code lautet wie folgt:

[40 6]

Verwenden Sie den Slice-Operator von Python, um ein oder mehrere Elemente abzurufen, die zu einer Zeile oder Spalte gehören.

>>> M.row(1)[1:3]
[6, 9]

Die Matrixklasse verfügt über die Methoden row_del () und col_del (), mit denen die angegebene Zeile / Spalte aus der angegebenen Matrix gelöscht wird.

>>> M=Matrix(2,3,[10,40,30,2,6,9]) 
>>> M.col_del(1) 
>>> M

Bei Ausführung des obigen Befehls in der Python-Shell wird die folgende Ausgabe generiert:

Matrix([[10, 30],[ 2, 9]])

Sie können den Stil mit dem folgenden Befehl mit Stil versehen:

$\displaystyle \left[\begin{matrix}10 & 30\\2 & 9\end{matrix}\right]$

Sie erhalten die folgende Ausgabe, nachdem Sie das obige Code-Snippet ausgeführt haben:

[10 30 2 9]

>>> M.row_del(0) 
>>> M

$\displaystyle \left[\begin{matrix}2 & 9\end{matrix}\right]$

Sie erhalten die folgende Ausgabe, nachdem Sie das obige Code-Snippet ausgeführt haben:

[2 9]

In ähnlicher Weise fügen die Methoden row_insert () und col_insert () Zeilen oder Spalten am angegebenen Zeilen- oder Spaltenindex hinzu

>>> M1=Matrix([[10,30]]) 
>>> M=M.row_insert(0,M1)
>>> M

$\displaystyle \left[\begin{matrix}10 & 30\\2 & 9\end{matrix}\right]$

Sie erhalten die folgende Ausgabe, nachdem Sie das obige Code-Snippet ausgeführt haben:

[10 40 30 2 9]

>>> M2=Matrix([40,6]) 
>>> M=M.col_insert(1,M2) 
>>> M

$\displaystyle \left[\begin{matrix}10 & 40 & 30\\2 & 6 & 9\end{matrix}\right]$

Sie erhalten die folgende Ausgabe, nachdem Sie das obige Code-Snippet ausgeführt haben:

[10 40 30 6 9]

Rechenoperationen

Übliche Operatoren +, - und * sind für die Addition, Subtraktion und Multiplikation definiert.

>>> M1=Matrix([[1,2,3],[3,2,1]]) 
>>> M2=Matrix([[4,5,6],[6,5,4]]) 
>>> M1+M2

$\displaystyle \left[\begin{matrix}5 & 7 & 9\\9 & 7 & 5\end{matrix}\right]$

Sie erhalten die folgende Ausgabe, nachdem Sie das obige Code-Snippet ausgeführt haben:

[5 7 9 9 7 5]

>>> M1-M2
$\displaystyle \left[\begin{matrix}-3 & -3 & -3\\-3 & -3 & -3\end{matrix}\right]$

Sie erhalten die folgende Ausgabe, nachdem Sie das obige Code-Snippet ausgeführt haben:

[- 3 -3 -3 -3 -3 -3]

Eine Matrixmultiplikation ist nur möglich, wenn - Die Anzahl der Spalten der 1. Matrix der Anzahl der Zeilen der 2. Matrix entsprechen muss. - Und das Ergebnis hat die gleiche Anzahl von Zeilen wie die 1. Matrix und die gleiche Anzahl von Spalten wie die 2. Matrix.

>>> M1=Matrix([[1,2,3],[3,2,1]]) 
>>> M2=Matrix([[4,5],[6,6],[5,4]]) 
>>> M1*M2
$\displaystyle \left[\begin{matrix}31 & 29\\29 & 31\end{matrix}\right]$

Die Ausgabe für den obigen Code lautet wie folgt:

[31 29 29 31]

>>> M1.T
$\displaystyle \left[\begin{matrix}1 & 3\\2 & 2\\3 & 1\end{matrix}\right]$

Die folgende Ausgabe wird nach Ausführung des Codes erhalten -

[1 3 2 2 3 1]

Verwenden Sie die Methode det (), um eine Determinante der Matrix zu berechnen. Eine Determinante ist ein Skalarwert, der aus den Elementen einer quadratischen Matrix berechnet werden kann

>>> M=Matrix(3,3,[10,20,30,5,8,12,9,6,15])
>>> M
$\displaystyle \left[\begin{matrix}10 & 20 & 30\\5 & 8 & 12\\9 & 6 & 15\end{matrix}\right]$

Die Ausgabe für den obigen Code lautet wie folgt:

[10 20 30 5 8 12 9 6 15]

>>> M.det()

Die Ausgabe für den obigen Code lautet wie folgt:

-120

Matrixkonstruktoren

SymPy bietet viele spezielle Arten von Matrixklassen. Zum Beispiel Identitätsmatrix, Matrix aller Nullen und Einsen usw. Diese Klassen werden als Auge, Nullen bzw. Einsen bezeichnet. Die Identitätsmatrix ist eine quadratische Matrix, bei der Elemente, die auf die Diagonale fallen, auf 1 gesetzt werden, der Rest der Elemente ist 0.

Example

from sympy.matrices import eye eye(3)

Output

Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]])

$\displaystyle \left[\begin{matrix}1 & 0 & 0\\0 & 1 & 0\\0 & 0 & 1\end{matrix}\right]$

Die Ausgabe für den obigen Code lautet wie folgt:

[1 0 0 0 1 0 0 0 1]

In der Diag-Matrix werden Elemente auf der Diagonale gemäß den angegebenen Argumenten initialisiert.

>>> from sympy.matrices import diag 
>>> diag(1,2,3)

$\displaystyle \left[\begin{matrix}1 & 0 & 0\\0 & 2 & 0\\0 & 0 & 3\end{matrix}\right]$

Die Ausgabe für den obigen Code lautet wie folgt:

[1 0 0 0 2 0 0 0 3]

Alle Elemente in der Nullmatrix werden auf 0 initialisiert.

>>> from sympy.matrices import zeros 
>>> zeros(2,3)

$\displaystyle \left[\begin{matrix}0 & 0 & 0\\0 & 0 & 0\end{matrix}\right]$

Die Ausgabe für den obigen Code lautet wie folgt:

[0 0 0 0 0 0]

In ähnlicher Weise ist one eine Matrix, bei der alle Elemente auf 1 gesetzt sind.

>>> from sympy.matrices import ones
>>> ones(2,3)

$\displaystyle \left[\begin{matrix}1 & 1 & 1\\1 & 1 & 1\end{matrix}\right]$

Die Ausgabe für den obigen Code lautet wie folgt:

[1 1 1 1 1 1]