Calcul de la valeur propre de plus grand module d'une matrice

Le contexte

On se donne $A\in\cal M_n(\mathbb C)$ une matrice dont les valeurs propres distinctes $\lambda_1,\dots,\lambda_m$ vérifient :

. $$|\lambda_1|>|\lambda_2|\geq \cdots \geq |\lambda_m|$$

Alors on a :

$$\frac{\text{Tr}(A^{k+1})}{\text{Tr}(A^{k})} \underset{k\to+\infty}{\longrightarrow}\lambda_1$$

On peut utiliser ce résultat pour obtenir une valeur numérique approchée de la valeur propre de plus grand module $\lambda_1$.

Le code

In [1]:
# On représente les matrices par des listes de listes. 
# On suppose dans la suite que toutes les matrices données par l'utilisateur sont carrées.

def trace(A):
    """ Calcule la trace de la matrice A """
    n = len(A)
    T = 0
    for i in range(n):
        T += A[i][i]
    return T
    
def produit(A,B):
    """ Calcule le produit des matrices A et B """
    n = len(A)
    P = []
    for i in range(n):
        L = []
        for j in range(n):
            C = 0
            for k in range(n):
                C += A[i][k]*B[k][j]
            L += [C]
        P += [L]
    return P
    
def puissance(A,k):
    """ Calcule la puissance k-ème de A """
    if k==1:
        return A
    else:
        return produit(A,puissance(A,k-1))
        
def calcul(A,k):
    """ Calcule le quotient des traces des puissances (k+1)-ème et k-ème de A """
    return trace(puissance(A,k+1))/trace(puissance(A,k))

Exemples

Premier exemple

In [2]:
A = [[1,2,3],[0,-1,5],[0,0,6]]
# A est une matrice triangulaire, ses valeurs propres sont 1, -1 et 6. 
# Sa valeur propre de plus grand module est donc 6.
In [3]:
calcul(A,5)
Out[3]:
6.00025720164609
In [4]:
calcul(A,10)
Out[4]:
5.9999998015419465
In [5]:
calcul(A,100)
Out[5]:
6.0

 Deuxième exemple

In [6]:
A = [[3,1,1],[-8,-3,-4],[6,3,4]]
# A est une matrice de valeurs propres 2 avec multiplicité 1 et 1 avec multiplicité 2.
# Sa valeur propre de plus grand module est donc 2.
In [7]:
calcul(A,5)
Out[7]:
1.9411764705882353
In [8]:
calcul(A,10)
Out[8]:
1.9980506822612085
In [9]:
calcul(A,100)
Out[9]:
2.0