Il est très courant de faire face au problème des valeurs propres de l'algèbre linéaire dans de nombreux domaines des sciences et de l'ingénierie. Voici un résumé de la façon de résoudre le ** problème (généralisé) des valeurs propres ** en utilisant numpy et scipy de Python. La méthode est résumée dans l'addendum.
Le problème généralisé des valeurs propres consiste à trouver un vecteur $ \ mathbf {x} $ et une valeur numérique (complexe) $ \ lambda $ qui satisfont les équations suivantes, en utilisant $ A $ et $ B $ comme matrices. ** **
$ A \ \mathbf{x} = \lambda \ B \ \mathbf{x} \ {\tag 1}$
Si $ B $ est la matrice unitaire $ E $, le problème est $ A \ \mathbf{x} = \lambda \ \mathbf{x} \ {\tag 2}$ Sera. Ce problème est appelé le ** problème des valeurs propres standard **.
● J'ai publié un article sur la solution numérique par multiplication de puissance. [Calcul scientifique / technique par Python] Solution numérique du problème des valeurs propres de la matrice par méthode de multiplication de puissance, algèbre linéaire
Tout d'abord, considérons l'équation ci-dessus (2), qui est un problème de valeurs propres standard. Utilisez la méthode ** numpy.linalg.eig **.
** (1) En cas de colonne d'exécution ** ** (2) Pour matrice complexe **
Ensuite, considérons le type d'équation (1) ci-dessus. Utilisez ** scipy.linalg.eig **.
** (3) Résolution du problème général des valeurs propres **
Si ** $ B $ est utilisé comme matrice unitaire, les problèmes (1) et (2) peuvent être résolus. ** **
☆ ** Le vecteur propre obtenu pour normaliser le vecteur propre dans le code de calcul (1) et (2) de la colonne d'exécution a été divisé par sa norme. ** ** En d'autres termes
for i in range(len(eig_vec)):
eig_vec [i] = eig_vec[i]/np.linalg.norm(eig_vec[i])
Et dit.
Dans le cas d'une matrice complexe (code (2)), la solution normalisée est sortie depuis le début.
import numpy as np
"""
Calcul des valeurs propres et des vecteurs propres des colonnes d'exécution
"""
#A_matrix=np.matrix([[2,4],[0,4]]) #Générer la matrice A
A_matrix=np.array([[2,4],[0,4]]) #Générer la matrice A
eig_val, eig_vec =np.linalg.eig(A_matrix) #Eig chaque valeur propre et vecteur propre_val, eig_Magasin dans vec
for i in range(len(eig_vec)):
eig_vec [i] = eig_vec[i]/np.linalg.norm(eig_vec[i])
#Sortie du résultat du calcul
print (eig_val)
print(eig_vec)
[2. 4.] # 2 valeurs uniques (2 et 4)
[[ 0.74535599 0.66666667] [ 0. 1. ]] Le vecteur propre correspondant. Il est normalisé à 1.
Elle peut être calculée exactement de la même manière qu'une colonne d'exécution. Notez que le nombre complexe $ a + bi $ est exprimé comme a + bj en changeant i en j en python.
import numpy as np
"""
Calcul des valeurs propres et des vecteurs propres d'une matrice complexe
"""
#A_matrix=np.matrix([[1+4j,2j],[2,4j]]) #Les nombres complexes sont dans les éléments de la matrice
A_matrix=np.array([[1+4j,2j],[2,4j]]) #Les nombres complexes sont dans les éléments de la matrice
eig_val, eig_vec =np.linalg.eig(A_matrix) #Calcul des valeurs propres et des vecteurs propres
print (eig_val)
print(eig_vec)
** valeur propre ** [ 1.95907589+5.37073062j -0.95907589+2.62926938j]
** Vecteur unique (vecteur complexe avec norme normalisée à 1) ** [[ 0.76703668+0.j -0.36782319-0.52570033j], [ 0.52570033-0.36782319j 0.76703668+0.j ]]
import numpy as np
import scipy.linalg
A = np.array([[-32,16,0],[16,-32,16],[0,16,-32]])
B = np.array([[-2, 16, 13], [16, -5, 16], [0, 1, -32]]) #Matrice B
#B=np.identity(3)
eig_val,eig_vec = scipy.linalg.eig(A,B) #Résoudre le problème général de la valeur de solidification
for i in range(len(eig_vec)): #Normalisation
eig_vec [i] = eig_vec[i]/np.linalg.norm(eig_vec[i])
print (eig_val)
print(eig_vec)
Valeurs intrinsèques: ** Les valeurs propres étant généralement des nombres complexes, elles sont affichées sous forme de nombres complexes en utilisant j comme un nombre imaginaire pur ** [-0.81267990+0.j 2.48526372+0.j 1.00000000+0.j]
array([-0.81267990+0.j, 2.48526372+0.j, 1.00000000+0.j])
Vecteur unique:
[[ -7.43016156e-01 -5.06563678e-01 4.37401683e-01]
[ -6.38461105e-01 7.69654089e-01 2.24401124e-16]
[ -2.11406258e-01 -2.50015624e-01 -9.44880724e-01]]
1.eig: Calculer les valeurs propres et les vecteurs propres de la matrice générale
2.eigh: Elmeet ・ Calcul des valeurs propres et des vecteurs propres de la matrice symétrique réelle
3.eigvals: Calcul des valeurs propres de la matrice générale(Ne calcule pas le vecteur propre)
4.eigvalsh: Elmeet-Calcul des valeurs propres de la matrice symétrique réelle(Ne calcule pas le vecteur propre)
** En particulier, le calcul de eigh pour les matrices symétriques est meilleur que le eig utilisé pour les matrices générales. C'est très rapide. ** **
Il semble y avoir divers textes sur l'algèbre linéaire numérique. ..
[1] F. Chatlan, ["Valeur unique de la matrice"](https://www.amazon.co.jp/%E8%A1%8C%E5%88%97%E3%81%AE%E5%9B% BA% E6% 9C% 89% E5% 80% A4-% E6% 9C% 80% E6% 96% B0% E3% 81% AE% E8% A7% A3% E6% B3% 95% E3% 81% A8 % E5% BF% 9C% E7% 94% A8-F-% E3% 82% B7% E3% 83% A3% E3% 83% 88% E3% 83% A9% E3% 83% B3 / dp / 443171037X / ref = sr_1_1? s = books & ie = UTF8 & qid = 1504668098 & sr = 1-1), Springer Fairlark Tokyo, 2003., Masatake Mori et al. ["Iwanami Lecture Applied Mathematics <12 [Method 2] Linear Calculation"](https://www.amazon.co.jp/%E5%B2%A9%E6%B3%A2%E8%AC% 9B% E5% BA% A7-% E5% BF% 9C% E7% 94% A8% E6% 95% B0% E5% AD% A6% E3% 80% 8812% E3% 80% 89% E3% 80% 94 % E6% 96% B9% E6% B3% 951% E3% 80% 95-% E6% 95% B0% E5% 80% A4% E8% A8% 88% E7% AE% 97% E3% 81% AE% E5% 9F% BA% E7% A4% 8E% EF% BC% 8F% E3% 80% 94% E6% 96% B9% E6% B3% 952% E3% 80% 95-% E7% B7% 9A% E5 % BD% A2% E8% A8% 88% E7% AE% 97-% E6% AD% A3% E6% AD% A6 / dp / 4000108026), Iwanami Shoten, 1997.
[2] Site Web scipy: https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.eig.html
https://docs.scipy.org/doc/scipy-0.18.1/reference/tutorial/linalg.html Notez que ** scipy.linalg est toujours lié à BLAS / LAPACK (numpy est une option), il est donc indiqué qu'il est fondamentalement plus rapide que numpy.linalg. ** ** La pièce est réimprimée ci-dessous.
"scipy.linalg vs numpy.linal scipy.linalg contains all the functions in numpy.linalg. plus some other more advanced ones not contained in numpy.linalg
Another advantage of using scipy.linalg over numpy.linalg is that it is always compiled with BLAS/LAPACK support, while for numpy this is optional. Therefore, the scipy version might be faster depending on how numpy was installed.
Therefore, unless you don’t want to add scipy as a dependency to your numpy program, use scipy.linalg instead of numpy.linalg"
Recommended Posts