FORMAV Votre partenaire Formation http://formav.eu

Diagonalisation de matrices d'endomorphisme

Déclaration des bibliothèques à importer

In [71]:
#-*- coding: utf-8 -*-
#Diagonalisation de matrices
#Programme créé par Martine Arrou-Vignod 11 Juin 2015
%matplotlib inline
from math import * 
import numpy as np
import numpy.linalg as la
import matplotlib.pyplot as plt
#pour faire du calcul formel
from sympy import *
In [72]:
#précision pour écriture des nombres réels dans les matrices et vecteurs 
np.set_printoptions(precision=2)

Fonctions utiles pour le programme

In [73]:
#Pour éviter que le nombre 0 soit approché 
#par les programmes de calcul par un nombre très petit
def precision(a):
    if abs(a)< 0.00001:
        a=0
    return a

Fonction diagonalisation et écriture du résultat

In [74]:
def diagonalisation(A, nom_matrice):
    print("La matrice à diagonaliser:  "+nom_matrice+"\n" ,A)
#Détermination de l'ordre de la matrice carrée
    n=A[0].size
#Vérification que la matrice est une matrice carrée
    if (A.size != n*n):
        print("La matrice n'est pas une matrice carrée ")
        print ( "Rappel :")
        print("Seules matrices d'endomorphismes peuvent être diagonalisées")
    print("Valeurs propres")
    val=la.eigvals(A)
    for i in range(0,n):
        val[i]=precision(val[i])
        print("%1.1f" %val[i])
    D=np.diag(val)
    print("Matrice diagonale obtenue par la connaissance des valeurs propres\n", D,"\n")
    print('Les vecteurs propres sont:')
    for i in range(0,n):
        if i ==0 or val[i] != val[i-1]:
            print("Valeur propre :",val[i])
        print("v_", i+1,"=",la.eig(A)[1][i])
    P=la.eig(A)[1]
    print('La matrice de passage est:')
    print("P=",P)
    print('L\'inverse de la  matrice de passage est:')
    print(la.inv(P))
    print('La matrice diagonale obtenue par calcul D=inverse(P)'+nom_matrice+  'P est :')
    D=np.dot(np.dot(la.inv(P),A),P)
    for i in range(0,n):
         for j in range(0,n):
            D[i][j]=precision( D[i][j])
    print(D)

Premier exemple

In [75]:
#Déclaration de la matrice#Diagonalisation
A=np.array([[1,1,1],[1,1,1],[1,1,1]] )
#Diagonalisation
diagonalisation(A,"A")

La matrice à diagonaliser:  A
 [[1 1 1]
 [1 1 1]
 [1 1 1]]
Valeurs propres
0.0
3.0
0.0
Matrice diagonale obtenue par la connaissance des valeurs propres
 [[ 0.  0.  0.]
 [ 0.  3.  0.]
 [ 0.  0.  0.]] 

Les vecteurs propres sont:
Valeur propre : 0.0
v_ 1 = [-0.82  0.58  0.  ]
Valeur propre : 3.0
v_ 2 = [ 0.41  0.58 -0.71]
Valeur propre : 0.0
v_ 3 = [ 0.41  0.58  0.71]
La matrice de passage est:
P= [[-0.82  0.58  0.  ]
 [ 0.41  0.58 -0.71]
 [ 0.41  0.58  0.71]]
L'inverse de la  matrice de passage est:
[[ -8.16e-01   4.08e-01   4.08e-01]
 [  5.77e-01   5.77e-01   5.77e-01]
 [ -1.18e-16  -7.07e-01   7.07e-01]]
La matrice diagonale obtenue par calcul D=inverse(P)AP est :
[[ 0.  0.  0.]
 [ 0.  3.  0.]
 [ 0.  0.  0.]]

Deuxième exemple

In [76]:
#Déclaration de la matrice
B=np.array([[-5,2,4,-4],[10,-3,-6,8],[11,-4,-6,8],[22,-8,-14,17]])
#Diagonalisation
diagonalisation(B,"B")

La matrice à diagonaliser:  B
 [[ -5   2   4  -4]
 [ 10  -3  -6   8]
 [ 11  -4  -6   8]
 [ 22  -8 -14  17]]
Valeurs propres
-1.0
1.0
2.0
1.0
Matrice diagonale obtenue par la connaissance des valeurs propres
 [[-1.  0.  0.  0.]
 [ 0.  1.  0.  0.]
 [ 0.  0.  2.  0.]
 [ 0.  0.  0.  1.]] 

Les vecteurs propres sont:
Valeur propre : -1.0
v_ 1 = [ -4.08e-01   1.80e-01  -1.68e-15  -3.34e-01]
Valeur propre : 1.0
v_ 2 = [ -4.74e-15   8.98e-01  -6.67e-01  -8.44e-01]
Valeur propre : 2.0
v_ 3 = [ 0.41  0.18 -0.33 -0.33]
Valeur propre : 1.0
v_ 4 = [ 0.82  0.36 -0.67 -0.26]
La matrice de passage est:
P= [[ -4.08e-01   1.80e-01  -1.68e-15  -3.34e-01]
 [ -4.74e-15   8.98e-01  -6.67e-01  -8.44e-01]
 [  4.08e-01   1.80e-01  -3.33e-01  -3.34e-01]
 [  8.16e-01   3.59e-01  -6.67e-01  -2.55e-01]]
L'inverse de la  matrice de passage est:
[[ -7.35e+00   2.45e+00   4.90e+00  -4.90e+00]
 [ -1.11e+01   5.57e+00   2.12e+00  -6.63e+00]
 [ -1.50e+01   6.00e+00   9.00e+00  -1.20e+01]
 [ -4.59e-16   6.33e-16  -4.85e+00   2.43e+00]]
La matrice diagonale obtenue par calcul D=inverse(P)BP est :
[[-1.  0.  0.  0.]
 [ 0.  1.  0.  0.]
 [ 0.  0.  2.  0.]
 [ 0.  0.  0.  1.]]

Troisième exemple

In [77]:
C=np.array([[1,0,0],[1,-1,1],[3,0,-2]] )
#Diagonalisation
diagonalisation(C,"C")

La matrice à diagonaliser:  C
 [[ 1  0  0]
 [ 1 -1  1]
 [ 3  0 -2]]
Valeurs propres
-1.0
-2.0
1.0
Matrice diagonale obtenue par la connaissance des valeurs propres
 [[-1.  0.  0.]
 [ 0. -2.  0.]
 [ 0.  0.  1.]] 

Les vecteurs propres sont:
Valeur propre : -1.0
v_ 1 = [ 0.    0.    0.58]
Valeur propre : -2.0
v_ 2 = [ 1.   -0.71  0.58]
Valeur propre : 1.0
v_ 3 = [ 0.    0.71  0.58]
La matrice de passage est:
P= [[ 0.    0.    0.58]
 [ 1.   -0.71  0.58]
 [ 0.    0.71  0.58]]
L'inverse de la  matrice de passage est:
[[-2.    1.    1.  ]
 [-1.41  0.    1.41]
 [ 1.73  0.    0.  ]]
La matrice diagonale obtenue par calcul D=inverse(P)CP est :
[[-1.  0.  0.]
 [ 0. -2.  0.]
 [ 0.  0.  1.]]

Quatrième exemple

In [78]:
M=np.array([[4,-7,-7],[-10,7,13],[10,-10,-16]] )
#Diagonalisation
diagonalisation(M,"M")

La matrice à diagonaliser:  M
 [[  4  -7  -7]
 [-10   7  13]
 [ 10 -10 -16]]
Valeurs propres
-6.0
4.0
-3.0
Matrice diagonale obtenue par la connaissance des valeurs propres
 [[-6.  0.  0.]
 [ 0.  4.  0.]
 [ 0.  0. -3.]] 

Les vecteurs propres sont:
Valeur propre : -6.0
v_ 1 = [ 0.   -0.58  0.71]
Valeur propre : 4.0
v_ 2 = [-0.71  0.58  0.71]
Valeur propre : -3.0
v_ 3 = [  7.07e-01  -5.77e-01   2.78e-16]
La matrice de passage est:
P= [[  0.00e+00  -5.77e-01   7.07e-01]
 [ -7.07e-01   5.77e-01   7.07e-01]
 [  7.07e-01  -5.77e-01   2.78e-16]]
L'inverse de la  matrice de passage est:
[[-1.41  1.41  2.83]
 [-1.73  1.73  1.73]
 [ 0.    1.41  1.41]]
La matrice diagonale obtenue par calcul D=inverse(P)MP est :
[[-6.  0.  0.]
 [ 0.  4.  0.]
 [ 0.  0. -3.]]