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

Sujet précédent

Vecteurs, matrices et tableaux

Sujet suivant

Tracer les courbes

Cette page