Multiplications

Pour une matrice (matrix), le produit * est le produit matriciel.

Passons aux tableaux...

Produit terme à terme

Dans le cas d'un tableau (array), le produit terme à terme de deux matrices, qui n'est pas le produit matriciel, s'effectue ainsi :

  >>> print matr * matr

Multiplication matricielle

La multiplication matricielle des arrays M par N se fait ainsi :

  >>> dot(M,N)

Trace

Pour obtenir la trace d'une matrice, c'est-à-dire la somme de ses éléments diagonaux, on procède ainsi

  >>> trace(M)

Les fonctions universelles

Définition

Les fonctions universelles (ufuncs) peuvent s'appliquer à tous les éléments d'une matrice. Ainsi

  >>> print sin([pi/2., pi/4., pi/6.])

va renvoyer le vecteur des sinus :

  [ 1. , 0.70710678, 0.5 ]

Exemples

Quelques fonctions universelles particulières :

  >>> print add.reduce([1,2,4,5])
  12

c'est la somme de tous les termes du vecteur. Et

  >>> greater([1,2,4,5], [5,4,3,2])

renvoie [0 0 1 1] : 1 n'est pas plus grand que 5, 2 n'est pas plus grand que 4, mais 4 est plus grand que 3, etc.

Déterminant et inverse d'une matrice

Le sous-module linalg de numpy permet de calculer un déterminant, une inverse :

  >>> from numpy import *
  >>> M=array([ [1,1,1],[1,0,2],[1,1,0] ])

  >>> linalg.det(M)
  >>> linalg.inv(M)

On peut aussi obtenir la pseudo-inverse (de Moore-Penrose) d'une matrice rectangle M, avec linalg.pinv(M)

Systèmes linéaires

Le sous-module linalg de numpy permet la résolution de systèmes linéaires.

Pour résoudre le système linéaire AX=B, où la matrice A et le vecteur B sont données, et X (un vecteur) est recherché :

  >>> from numpy import *
  >>> A=array([ [1,1,1],[1,0,2],[1,1,0] ])
  >>> linalg.det(A)
  1.0

  >>> B=array([1,1,1])
  >>> X=linalg.solve(A,B)
  >>> X
  array([ 1.,  0.,  0.])

  >>> matrixmultiply(A,X)
  array([ 1.,  1.,  1.])

Eléments propres

Le sous-module linalg de numpy permet aussi de déterminer les éléments propres d'une matrice.

Valeur propre

Pour obtenir les valeurs propres de M :

  >>> M=array([ [1,1,1],[1,0,2],[1,1,0] ])
  >>> linalg.eigvals(M)
  array([ 2.65109341, -0.27389055, -1.37720285])

Vecteurs propres

Et pour les vecteurs propres :

  >>> linalg.eig(M)
  (array([ 2.65109341, -0.27389055, -1.37720285]), array([ [-0.64781865, -0.71678956,  0.14048209],
         [-0.59922186,  0.64273638, -0.84686764],
         [-0.47038724,  0.27037507,  0.51291322] ]))

(on récupère la matrice des valeurs propres, suivie de celle des vecteurs propres.)

Normes matricielle et vectorielle

Le sous-module linalg de numpy permet encore le calcule des normes de matrices et de vecteurs.

  >>> from numpy import *
  >>> linalg.norm(x)

calcule :

• la norme euclidienne, si x est un vecteur,
• la norme de Frobenius, si x est une matrice.

On peut passer un deuxième argument à norm, pour préciser quelle norme on souhaite : help(linalg.norm) pour plus de précisions.

Décomposition de matrices

On peut obtenir des décompositions de matrices avec linalg...

Cholesky

Par exemple, pour la décomposition de Cholesky (possible uniquement pour les matrices définies positives) :

  >>> from numpy import *
  >>> M=array([ [1,1,1],[1,3,2],[1,1,4] ])
  >>> linalg.cholesky(M)
  array([ [ 1.        ,  0.        ,  0.        ],
         [ 1.        ,  1.41421356,  0.        ],
         [ 1.        ,  0.        ,  1.73205081] ])

Décomposition QR

Ou, pour la décomposition QR :

  >>> linalg.qr(M)
  (array([ [ -5.77350269e-01,   4.08248290e-01,  -7.07106781e-01],
         [ -5.77350269e-01,  -8.16496581e-01,  -1.09179159e-16],
         [ -5.77350269e-01,   4.08248290e-01,   7.07106781e-01] ]),
   array([ [-1.73205081, -2.88675135, -4.04145188],
         [ 0.        , -1.63299316,  0.40824829],
         [ 0.        ,  0.        ,  2.12132034] ]))

qui retourne le couple (Q,R).

Décomposition en valeurs singulières

Enfin, pour la décomposition en valeurs singulières (les valeurs singulières de M sont les racines carrées des valeurs propres de $M^T M$) :

  >>> linalg.svd(M)