NumPy 1.14 - numpy.linalg.eigh()

numpy.linalg.eigh




numpy

numpy.linalg.eigh

numpy.linalg.eigh(a, UPLO='L') [source]

एक हर्मिटियन या सममित मैट्रिक्स के आइगेनवेल्यूज और आइजनवेक्टर लौटाएं।

दो ऑब्जेक्ट्स, एक 1-D सरणी जिसमें एक के eigenvalues ​​होते हैं, और एक 2-D वर्ग सरणी या मैट्रिक्स (इनपुट प्रकार के आधार पर) इसी eigenvectors (कॉलम में)।

पैरामीटर:

a : (…, M, M) सरणी

हर्मिटियन / सिमिट्रिक मैट्रिसेस जिनके आइगेनवैल्यूज़ और ईजेनवेक्टर की गणना की जानी है।

यूपीएलओ : {'एल', 'यू'}, वैकल्पिक

निर्दिष्ट करता है कि गणना a ('एल', डिफ़ॉल्ट) के निचले त्रिकोणीय भाग या ऊपरी त्रिकोणीय भाग ('यू') के साथ की जाती है। इस मूल्य के बावजूद, विकर्ण के वास्तविक भागों को हर्मिटियन मैट्रिक्स की धारणा को संरक्षित करने के लिए गणना में माना जाएगा। इसलिए यह इस प्रकार है कि विकर्ण के काल्पनिक भाग को हमेशा शून्य माना जाएगा।

यह दिखाता है:

डब्ल्यू : (…, एम) ndarray

आरोही क्रम में प्रतिजन, प्रत्येक अपनी बहुलता के अनुसार दोहराया गया।

v : {(…, M, M) ndarray, (…, M, M) मैट्रिक्स}

कॉलम v[:, i] आईजेनवेल्यू w[i] अनुरूप सामान्यीकृत आइगेनवेक्टर है। यदि कोई मैट्रिक्स ऑब्जेक्ट है तो मैट्रिक्स ऑब्जेक्ट लौटाएगा।

जन्म देती है:

LinAlgError

यदि आइजनवेल्यू अभिकलन अभिसरण नहीं करता है।

यह भी देखें

eigvalsh
सममित या हर्मिटियन सरणियों के eigenvalues।
eig
गैर-सममितीय सरणियों के लिए eigenvalues ​​और सही eigenvectors।
eigvals
गैर-सममितीय सरणियों के eigenvalues।

टिप्पणियाँ

संस्करण 1.8.0 में नया।

प्रसारण नियम लागू होते हैं, विवरण के लिए numpy.linalg प्रलेखन देखें।

Eigenvalues ​​/ eigenvectors का उपयोग LAPACK रूटीन _syevd, _heevd का उपयोग करके किया जाता है

वास्तविक सममित या जटिल हर्मिटियन मेट्रिसेस के आइजनवेल्यू हमेशा वास्तविक होते हैं। [R7575] (कॉलम) eigenvectors की सरणी v एकात्मक, और w , और v समीकरण dot(a, v[:, i]) = w[i] * v[:, i] के समीकरणों को पूरा करती है।

संदर्भ

[R7575] ( 1 , 2 ) जी। स्ट्रेंग, रेखीय बीजगणित और इसके अनुप्रयोग , 2 एड।, ऑरलैंडो, एफएल, अकादमिक प्रेस, इंक।, 1980, स्नातकोत्तर। 222।

उदाहरण

>>> from numpy import linalg as LA
>>> a = np.array([[1, -2j], [2j, 5]])
>>> a
array([[ 1.+0.j,  0.-2.j],
       [ 0.+2.j,  5.+0.j]])
>>> w, v = LA.eigh(a)
>>> w; v
array([ 0.17157288,  5.82842712])
array([[-0.92387953+0.j        , -0.38268343+0.j        ],
       [ 0.00000000+0.38268343j,  0.00000000-0.92387953j]])
>>> np.dot(a, v[:, 0]) - w[0] * v[:, 0] # verify 1st e-val/vec pair
array([2.77555756e-17 + 0.j, 0. + 1.38777878e-16j])
>>> np.dot(a, v[:, 1]) - w[1] * v[:, 1] # verify 2nd e-val/vec pair
array([ 0.+0.j,  0.+0.j])
>>> A = np.matrix(a) # what happens if input is a matrix object
>>> A
matrix([[ 1.+0.j,  0.-2.j],
        [ 0.+2.j,  5.+0.j]])
>>> w, v = LA.eigh(A)
>>> w; v
array([ 0.17157288,  5.82842712])
matrix([[-0.92387953+0.j        , -0.38268343+0.j        ],
        [ 0.00000000+0.38268343j,  0.00000000-0.92387953j]])
>>> # demonstrate the treatment of the imaginary part of the diagonal
>>> a = np.array([[5+2j, 9-2j], [0+2j, 2-1j]])
>>> a
array([[ 5.+2.j,  9.-2.j],
       [ 0.+2.j,  2.-1.j]])
>>> # with UPLO='L' this is numerically equivalent to using LA.eig() with:
>>> b = np.array([[5.+0.j, 0.-2.j], [0.+2.j, 2.-0.j]])
>>> b
array([[ 5.+0.j,  0.-2.j],
       [ 0.+2.j,  2.+0.j]])
>>> wa, va = LA.eigh(a)
>>> wb, vb = LA.eig(b)
>>> wa; wb
array([ 1.,  6.])
array([ 6.+0.j,  1.+0.j])
>>> va; vb
array([[-0.44721360-0.j        , -0.89442719+0.j        ],
       [ 0.00000000+0.89442719j,  0.00000000-0.4472136j ]])
array([[ 0.89442719+0.j       ,  0.00000000-0.4472136j],
       [ 0.00000000-0.4472136j,  0.89442719+0.j       ]])