Algèbre linéaire de NumPy

　 　 exemple de NumPy en algèbre linéaire

numpy.dot()

numpy.dot() pour deux tableaux unidimensionnels calcule la somme des produits des éléments correspondants (mathématiquement appelé produit scalaire) ; pour les tableaux bidimensionnels, il calcule le produit matriciel des deux tableaux ; pour les tableaux multidimensionnels, sa formule de calcul générale est la suivante, à savoir que chaque élément du tableau de résultat est : la somme des produits des éléments de la dernière dimension du tableau a avec les éléments de la deuxième dernière dimension du tableau b : dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m]).

　　　numpy.dot(a, b, out=None)

Description des paramètres :

a : ndarray tableau b : ndarray tableau out : ndarray, optionnel, utilisé pour sauvegarder le résultat du calcul de dot()

　import numpy.matlib
　import numpy as np
　a = np.array([[1,2],[3,4]]
　b = np.array([[11,12],[13,14]]
　print(np.dot(a,b))

Le résultat de la sortie est :

　[[37　40]　
　[85　92]]

L'expression est :

[[1*11+2*13,　1*12+2*14],[3*11+4*13,　3*12+4*14]]

numpy.vdot()

La fonction numpy.vdot() calcule le produit scalaire de deux vecteurs. Si le premier paramètre est un nombre complexe, son conjugué complexe est utilisé pour le calcul. Si les paramètres sont des tableaux multidimensionnels, ils sont étendus.

　import numpy.matlib
　import numpy as np
　a = np.array([[1,2],[3,4]]　
　b = np.array([[11,12],[13,14]]　
　　
　# vdot étend les tableaux pour calculer le produit scalaire
　print(np.vdot(a,b))

Le résultat de la sortie est :

　130

L'expression est :

1*11　+　2*12　+　3*13　+　4*14　=　130

numpy.inner()

La fonction numpy.inner() retourne le produit scalaire des vecteurs d'un tableau unidimensionnel. Pour des dimensions plus élevées, elle retourne le produit des sommes sur l'axe final.

　import numpy.matlib
　print(np.inner(np.array([1,2,3))1,0]])
　# Équivalent à　1*0+2*1+3*0

Le résultat de la sortie est :

　　　2

　import numpy as np　
　a = np.array([[1,2], [3,4]]　
　　
　print ('Tableau a :')
　print (a)
　b = np.array([[11,　12], [13,　14]]　
　　
　print ('Tableau b :')
　print (b)
　　
　print ('Norme intérieure :')
　print (np.inner(a,b))

Le résultat de la sortie est :

　Tableau a :
　[[1　2]
　　[3　4]]
　Tableau b :
　[[11　12]
　　[13　14]]
　Norme intérieure :
　[[35　41]
　　[81　95]]
　Tableau a :
　[[1　2]
　　[3　4]]
　Tableau b :
　[[11　12]
　　[13　14]]
　Norme intérieure :
　[[35　41]
　　[81　95]]

L'expression de calcul de la norme intérieure est :

　1*11+2*12,　1*13+2*14　
　3*11+4*12,　3*13+4*14

numpy.matmul

La fonction numpy.matmul retourne le produit matriciel de deux tableaux. Bien que le produit de deux tableaux deux dimensions soit normal, si la dimension d'un paramètre est supérieure2, alors il est considéré comme existant dans la pile des matrices aux deux derniers indices, et une diffusion correspondante est effectuée.

D'autre part, si l'un des paramètres est un tableau unidimensionnel, il est ajouté sur sa dimension 1 Pour le lever en matrice, puis être supprimé après la multiplication.

Pour un tableau bidimensionnel, il s'agit de la multiplication matricielle :

　import numpy.matlib　
　import numpy as np　
　　
　a = [[1,0],[0,1]]　
　b = [[4,1],[2,2]]　
　print (np.matmul(a,b))

Le résultat de la sortie est :

　　　[[4　1]　
　　[2　2]]

Opérations vectorielles et matricielles :

　import numpy.matlib　
　import numpy as np　
　　
　a = [[1,0],[0,1]]　
　b = [1,2]　
　print (np.matmul(a,b))
　print (np.matmul(b,a))

Le résultat de la sortie est :

　[1　2]　
　[1　2]

Tableau de dimension supérieure à deux :

　import numpy.matlib　
　import numpy as np　
　　
　a = np.arange(8).reshape(2,2,2)　
　b = np.arange(4).reshape(2,2)　
　print (np.matmul(a,b))

Le résultat de la sortie est :

　　　[[[　2　3]
　　　[　6　11]]
　　[[10　19]
　　　[14　27]]

numpy.linalg.det()

La fonction numpy.linalg.det() calcule le déterminant de la matrice entrée.

Le déterminant est une valeur très utile en algèbre linéaire. Il est calculé à partir des éléments diagonaux de la matrice. Pour 2×2 Matrice, qui est la différence du produit des éléments de gauche en haut et de droite en bas avec le produit des deux autres.

Autrement dit, pour la matrice [[a, b], [c, d]], le déterminant est calculé comme ad-bc. Un grand carré est considéré comme 2×2 Combinatoire de matrices.

import numpy as np
a = np.array([[1,2], [3,4]]　
　　
print (np.linalg.det(a))

Le résultat de la sortie est :

-2.0

　import numpy as np
　　
　b = np.array([[6,1,1], [4,　-2,　5], [2,8,7]]　
　print (b)
　print (np.linalg.det(b))
　print (6*(-2*7　-　5*8)　-　1*(4*7　-　5*2)　+　1*(4*8　-　-2*2))

Le résultat de la sortie est :

　　　[[　6　1　1]
　　[　4　-2　5]
　　[　2　8　7]]
　-306.0
　-306

numpy.linalg.solve()

La fonction numpy.linalg.solve() donne la solution de l'équation linéaire sous forme matricielle.

Considérons l'équation linéaire suivante :

　x　+　y　+　z =　6
　2y　+　5z =　-4
　2x　+　5y　-　z =　27

Il peut être représenté par une matrice :

Si la matrice devient A, X et B, l'équation devient :

　AX = B
　ou
　X = A^(-1)B

numpy.linalg.inv()

La fonction numpy.linalg.inv() calcule l'inverse matriciel de la multiplication.

Matrice inverse (inverse matrix)：Soit A un matrice n-niveau sur un corps de nombres, si il existe un autre matrice n-niveau B dans le même corps de nombres, de sorte que : AB=BA=E , alors on appelle B l'inverse de A, et A est appelé matrice inversible. Remarque : E est la matrice unité.

　import numpy as np　
　　
　x = np.array([[1,2],[3,4]]　
　y = np.linalg.inv(x)　
　print (x)
　print (y)
　print (np.dot(x, y))

Le résultat de la sortie est :

　[[1　2]
　　[3　4]]
　[[-2.　1.　]
　　[　1.5　-0.5]]
　[[1.0000000e+00 0.0000000e+00]
　　[8.8817842e-16　1.0000000e+00]]

Maintenant, créons l'inverse de la matrice A :

　import numpy as np　
　　
　a = np.array([[1,1,1],[0,2,5],[2,5,-1]]　
　　
　print ('Tableau a :')
　print (a)
　ainv = np.linalg.inv(a)　
　　
　print ('Inverse de a :')
　print (ainv)
　　
　print ('Matrice b :')
　b = np.array([[6],[-4],[27]]　
　print (b)
　　
　print ('Calcul : A^(-1)B :'
　x = np.linalg.solve(a, b)　
　print (x)
　# Cela est le vecteur de direction linéaire x =　5, y =　3, z =　-2　solution

Le résultat de la sortie est :

　Tableau a :
　[[　1　1　1]
　　[ 0　2　5]
　　[　2　5　-1]]
　Inverse de a :
　[[　1.28571429　-0.28571429　-0.14285714]
　　[-0.47619048　0.14285714　0.23809524]
　　[ 0.19047619　0.14285714　-0.0952381　]]
　Matrice b :
　[[　6]
　　[-4]
　　[27]]
　Calcul : A^(-1)B :
　[[　5.]
　　[　3.]
　　[-2.]]

　　　x = np.dot(ainv, b)