SymPy - Matrici

In matematica, una matrice è una matrice bidimensionale di numeri, simboli o espressioni. La teoria della manipolazione della matrice si occupa di eseguire operazioni aritmetiche su oggetti matrice, soggetti a determinate regole.

La trasformazione lineare è una delle applicazioni importanti delle matrici. Molti campi scientifici, in particolare legati alla fisica, utilizzano applicazioni relative alle matrici.

Il pacchetto SymPy ha un modulo matrici che si occupa della gestione delle matrici. Include la classe Matrix il cui oggetto rappresenta una matrice.

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]$

Eseguendo il comando precedente nella shell python, verrà generato il seguente output:

[1 2 3 2 3 1]

La matrice viene creata da oggetti List di dimensioni appropriate. È inoltre possibile ottenere una matrice distribuendo gli elementi dell'elenco nel numero specificato di righe e colonne.

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

Eseguendo il comando precedente nella shell python, verrà generato il seguente output:

[10 40 30 2 6 9]

Matrix è un oggetto mutevole. Il modulo matrici fornisce anche la classe ImmutableMatrix per ottenere una matrice immutabile.

Manipolazione di base

Il shape proprietà dell'oggetto Matrix restituisce la sua dimensione.

>>> M.shape

L'output per il codice precedente è il seguente:

(2,3)

Il metodo row () e col () restituisce rispettivamente la riga o la colonna del numero specificato.

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

L'output per il codice precedente è il seguente:

[10 40 30]

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

L'output per il codice precedente è il seguente:

[40 6]

Usa l'operatore slice di Python per recuperare uno o più elementi che appartengono alla riga o alla colonna.

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

La classe Matrix ha metodi row_del () e col_del () che elimina la riga / colonna specificata dalla matrice data -

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

Eseguendo il comando precedente nella shell python, verrà generato il seguente output:

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

È possibile applicare lo stile all'output utilizzando il seguente comando:

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

Si ottiene il seguente output dopo aver eseguito lo snippet di codice sopra:

[10 30 2 9]

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

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

Si ottiene il seguente output dopo aver eseguito lo snippet di codice sopra:

[2 9]

Allo stesso modo, i metodi row_insert () e col_insert () aggiungono righe o colonne all'indice di riga o colonna specificato

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

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

Si ottiene il seguente output dopo aver eseguito lo snippet di codice sopra:

[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]$

Si ottiene il seguente output dopo aver eseguito lo snippet di codice sopra:

[10 40 30 6 9]

Operazioni aritmetiche

Gli operatori usuali +, - e * sono definiti per eseguire addizioni, sottrazioni e moltiplicazioni.

>>> 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]$

Si ottiene il seguente output dopo aver eseguito lo snippet di codice sopra:

[5 7 9 9 7 5]

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

Si ottiene il seguente output dopo aver eseguito lo snippet di codice sopra:

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

La moltiplicazione di matrici è possibile solo se - Il numero di colonne della 1a matrice deve essere uguale al numero di righe della 2a matrice. - E il risultato avrà lo stesso numero di righe della prima matrice e lo stesso numero di colonne della seconda matrice.

>>> 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]$

L'output per il codice precedente è il seguente:

[31 29 29 31]

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

Il seguente output si ottiene dopo aver eseguito il codice:

[1 3 2 2 3 1]

Per calcolare un determinante di matrice, utilizzare il metodo det (). Un determinante è un valore scalare che può essere calcolato dagli elementi di una matrice quadrata. 0

>>> 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]$

L'output per il codice precedente è il seguente:

[10 20 30 5 8 12 9 6 15]

>>> M.det()

L'output per il codice precedente è il seguente:

-120

Costruttori di matrici

SymPy fornisce molti tipi speciali di classi di matrici. Ad esempio, Matrice identità, matrice di tutti gli zeri e uno, ecc. Queste classi sono denominate rispettivamente come occhio, zero e uno. La matrice di identità è una matrice quadrata con gli elementi che cadono sulla diagonale sono impostati su 1, il resto degli elementi è 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]$

L'output per il codice precedente è il seguente:

[1 0 0 0 1 0 0 0 1]

Nella matrice diag, gli elementi sulla diagonale vengono inizializzati secondo gli argomenti forniti.

>>> 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]$

L'output per il codice precedente è il seguente:

[1 0 0 0 2 0 0 0 3]

Tutti gli elementi nella matrice degli zeri vengono inizializzati su 0.

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

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

L'output per il codice precedente è il seguente:

[0 0 0 0 0 0]

Allo stesso modo, uno è una matrice con tutti gli elementi impostati su 1.

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

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

L'output per il codice precedente è il seguente:

[1 1 1 1 1 1]