Calcul numérique matriciel

Très rapidement, listons les commandes. Certaines commandes étant spécialisées (tout le monde n’a pas besoin d’inverser les matrices) il faut ajouter linalg : np.linalg.X

• rang d’une matrice : np.rank(a)

  >>> a=np.arange(15).reshape(3,5)
  >>> a
  array([[ 0,  1,  2,  3,  4],
      [ 5,  6,  7,  8,  9],
      [10, 11, 12, 13, 14]])
  >>> np.rank(a)
  2
  >>> np.rank(a.transpose())
  2
  

• inverse d’une matrice : np.linalg.inv(a) inverse d’une matrice carrée

  >>> a=np.array([2,4,6,8],float).reshape(2,2)
  >>> np.linalg.inv(a)
  array([[-1.  ,  0.5 ],
       [ 0.75, -0.25]])
  

  Comme d’habitude avec les logiciels de calcul scientifique, il faut d’abord savoir si la matrice est inversible pour l’inverser, ou encore rester critique vis à vis du résultat retourné. L’exemple suivant est caractéristique.

  >>> a=np.arange(16).reshape(4,4)
  >>> a
  array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])
  >>> np.rank(a)  # la matrice n'est pas inversible
  2
  >>> np.linalg.inv(a)
  array([[  9.00719925e+14,  -4.50359963e+14,  -1.80143985e+15,
          1.35107989e+15],
       [ -2.40191980e+15,   2.70215978e+15,   1.80143985e+15,
         -2.10167983e+15],
       [  2.10167983e+15,  -4.05323966e+15,   1.80143985e+15,
          1.50119988e+14],
       [ -6.00479950e+14,   1.80143985e+15,  -1.80143985e+15,
          6.00479950e+14]])
  

  Les valeurs très grandes laissent tout de même planer un certain soupçon.

• résolution d’un système linéaire : np.linalg.solve(a,b) où a est une matrice carrée et b un vecteur ou une matrice (avec condition de compatibilité)

  >>> a=np.array([2,4,6,8],float).reshape(2,2)
  >>> b=np.array([1, 4],float)
  >>> np.linalg.solve(a,b)
  array([ 1.  , -0.25])
  >>> b=np.array([[1, 1],[4, -4]],float)
  >>> np.linalg.solve(a,b)
  array([[ 1.  , -3.  ],
       [-0.25,  1.75]])
  

  Il en est de même que pour l’inversion de matrice : il faut savoir rester critique.

  >>> a=np.arange(16,dtype=float).reshape(4,4)
  >>> b=np.arange(4,dtype=float)
  >>> b[1]=5
  >>> x=np.linalg.solve(a,b)
  >>> np.dot(a,x)
  array([ -2.,   2.,   6.,  10.])
  >>> b
  array([ 0.,  5.,  2.,  3.])
  

• calcul du déterminant : np.linalg.det(a) bien sûr !

• calcul des valeurs propres et vecteurs propres : np.linalg.eig(a)

  >>> a=np.array([2,4,6,8],float).reshape(2,2)
  >>> np.linalg.eig(a)
  (array([ -0.74456265,  10.74456265]), array([[-0.82456484, -0.41597356],
       [ 0.56576746, -0.90937671]]))
  

  Le premier argument représente les valeurs propres, tandis que le deuxième retourne la matrice des vecteurs propres en colonne (une colonne est un vecteur propre).

• calcul de norme vectorielle/matricielle : np.linalg.norm(x[, ord]) où ord est pour une matrice

  • Fro , norme de Frobenius
  • inf : max(sum(abs(x), axis=1))
  • -inf : min(sum(abs(x), axis=1))
  • 1 : max(sum(abs(x), axis=0))
  • -1 : min(sum(abs(x), axis=0))
  • 2 : norme 2 matricielle
  • -2 : plus petite valeur singulière

  pour un vecteur

  • Fro , norme de Frobenius
  • inf : max(sum(abs(x), axis=1))
  • -inf : min(sum(abs(x), axis=1))
  • les autres donnent les mêmes résultats (à tester)