एक 2x2 Eigensystem को हल करें

Question

थोड़ा रैखिक बीजगणित की पृष्ठभूमि वाले लोगों के लिए, चुनौती इस तरह से सरल है: किसी दिए गए जटिल 2x2 मैट्रिक्स के eigenvalues ​​और eigenvectors को निर्धारित करें । आप I / O विवरण आदि के लिए चैलेंज को आगे छोड़ सकते हैं, उन लोगों के लिए जिन्हें आइगेंस सिस्टम पर थोड़ा रिफ्रेशर की आवश्यकता होती है, पर पढ़ें।

पृष्ठभूमि

विशेषता समीकरण एक मैट्रिक्स के एक से परिभाषित किया गया है

det| A - λI | = 0

जहां λ एक जटिल (स्केलर) पैरामीटर है, मैं पहचान मैट्रिक्स और det | ... | है निर्धारक । बाएं हाथ की ओर λ में एक बहुपद का मूल्यांकन करती है , विशेषता बहुपद , जो 2x2 मैट्रिसेस के मामले में द्विघात है। इस विशेषता समीकरण के समाधान ए के आइजेनवल हैं , जिन्हें हम λ ₁ और λ _{2 के} रूप में निरूपित करेंगे ।

अब eigenvectors v _मैं का एक संतुष्ट

A vi = λi vi

प्रत्येक λ _{i के लिए} , यह आपको दो अज्ञात ( v _i के घटकों ) में दो समीकरणों की एक प्रणाली प्रदान करता है , जिन्हें आसानी से हल किया जा सकता है। आप ध्यान देंगे कि प्रणाली वास्तव में अंडरसिज्ड है, और ईजेनवेक्टरों का परिमाण समीकरणों द्वारा निर्धारित नहीं किया गया है। हम आमतौर पर चाहते हैं कि आइजनवेक्टर को सामान्य किया जाए, यानी √ (| x | ² + | y ​​| ² ) = 1 , जहाँ x और y वेक्टर घटक हैं, x | ² है एक्स इसकी जटिल संयुग्म से गुणा।

ध्यान दें कि आइजनवेल्यूज पतित हो सकते हैं, अर्थात λ ₁ = λ ₂ । इस मामले में, आप दो रेखीय स्वतंत्र eigenvectors के साथ समीकरणों की एकल प्रणाली को संतुष्ट करने या करने में सक्षम नहीं हो सकते हैं।

चुनौती

जटिल तत्वों के साथ एक 2x2 मैट्रिक्स को देखते हुए, इसके दो (संभवतः समान) eigenvalues ​​और प्रत्येक eigenvalue के लिए एक सामान्यीकृत eigenvector निर्धारित करें। परिणामी संख्या कम से कम 3 (दशमलव) महत्वपूर्ण अंकों के लिए सटीक होनी चाहिए। आप मान सकते हैं कि किसी भी मैट्रिक्स तत्व का वास्तविक और काल्पनिक भाग [-1,1] सीमा में है ।

आप एक फ़ंक्शन या प्रोग्राम लिख सकते हैं, STDIN, कमांड-लाइन तर्क, प्रॉम्प्ट या फ़ंक्शन तर्क के माध्यम से इनपुट ले सकते हैं। आप परिणाम को STDOUT, एक संवाद बॉक्स या फ़ंक्शन रिटर्न मान के रूप में आउटपुट कर सकते हैं।

आप इनपुट और आउटपुट के लिए किसी भी सुविधाजनक (लेकिन अस्पष्ट) स्ट्रिंग या सूची प्रारूप का उपयोग कर सकते हैं। आप व्यक्तिगत संख्याओं का प्रतिनिधित्व करने के लिए झांकियों या जटिल प्रकारों के जोड़े के बीच चयन कर सकते हैं।

आप eigensystems सुलझाने (मेथेमेटिका की तरह के लिए निर्मित उपयोग नहीं करना चाहिए कार्यों Eigenvectorsया Eigensystemया समीकरण समाधानकर्ताओं)।

यह कोड गोल्फ है, इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है।

उदाहरण

प्रत्येक उदाहरण तीन पंक्तियाँ हैं: इनपुट, आइजनवेल्यूज़ और इसी क्रम में एक ही eigenvectors। ध्यान दें कि eigenvectors केवल उनके चरण तक निर्धारित होते हैं, और यह कि पतित eigenvalues ​​के मामले में, eigenvectors वास्तव में मनमाना हो सकता है (जैसा कि पहले उदाहरण में)।

[[1.0, 0.0], [0.0, 1.0]]
[1.0, 1.0]
[[1.0, 0.0], [0.0, 1.0]]

[[0.0, 0.4], [-0.1, -0.4]]
[-0.2, -0.2]
[[0.894427, -0.447214], [0.894427, -0.447214]]

[[0.3, 0.1], [0.4, -0.9]]
[-0.932456, 0.332456]
[[-0.0808731, 0.996724], [0.951158, 0.308703]]

[[0.5, -1.0], [0.8, -0.5]]
[0.74162i, - 0.74162i]
[[0.745356, 0.372678 - 0.552771i], [0.745356, 0.372678 + 0.552771i]]

[[-0.0539222 + 0.654836i, -0.016102 + 0.221334i], [0.739514 - 0.17735i, -0.0849216 + 0.77977i]]
[0.238781 + 0.984333i, -0.377625 + 0.450273i]
[[0.313668 + 0.322289i, 0.893164], [-0.236405 - 0.442194i, 0.865204]]

[[-0.703107 - 0.331792i, 0.286719 - 0.587305i], [-0.418476 + 0.396347i, -0.885934 + 0.50534i]]
[-1.13654 - 0.32678i, -0.4525 + 0.500329i]
[[0.833367, -0.248208 - 0.493855i], [-0.441133 - 0.408236i, 0.799215]]

[[-0.156312 + 0.788441i, 0.045056 - 0.579167i], [0.130741 - 0.97017i, 0.049183 - 0.590768i]]
[-0.181759 + 1.11738i, 0.0746298 - 0.919707i]
[[0.86955, -0.493846 + 0.000213145i], [0.318856 - 0.0181135i, 0.94763]]

Answer 1

MATLAB, 91

सामान्यीकृत वेक्टर प्राप्त करने और स्वतंत्रता की बेकार डिग्री को हटाने के लिए एक मानक तकनीक वेक्टर के तत्वों को कुछ कोण के कोसाइन और साइन के रूप में दर्शा रही है।

मैंने मूल रूप से पायथन में कोड करने की कोशिश की, लेकिन इसकी गणित की हैंडलिंग बहुत अधिक मस्तिष्क-क्षतिग्रस्त साबित हुई। इसके गणित कार्यों ने जटिल मूल्यों को स्वीकार करने से इनकार कर दिया, और यह समझ में नहीं आता है कि शून्य से फ्लोटिंग-पॉइंट डिवीजन ठीक है।

function[]=f(a,b,c,d)
L=(a+d+[1,-1]*((a-d)^2+4*b*c)^.5)/2
t=atan((L-a)/b);v=[cos(t);sin(t)]

पहले दो आइजनवेल्स हेडिंग के नीचे प्रिंट किए जाते हैं L =। तब दो कॉलम वैक्टर एल के संगत मूल्यों के तहत मुद्रित होते हैं v =। कोड उन मामलों में रैखिक रूप से स्वतंत्र वैक्टर देने में विफल हो सकता है जहां ऐसा करना संभव है (इस तरह के कार्यक्रम को आमतौर पर टूटा हुआ माना जाएगा), लेकिन मार्टिन ने कहा कि इसकी आवश्यकता नहीं है।

Answer 2

पायथन 2, 198 बाइट्स

a,b,c,d=input()
H=(a+d)/2
D=(H*H-a*d+b*c)**.5
X,Y=H+D,H-D
p,q,r,s=[[1,0,0,1],[b,X-a,b,Y-a],[X-d,c,Y-d,c]][2*(c!=0)or(b!=0)]
A=abs
V=A(A(p)+A(q)*1j)
W=A(A(r)+A(s)*1j)
print[X,Y],[[p/V,q/V],[r/W,s/W]]

इनपुट STDIN के माध्यम से 4 जटिल संख्याओं की एक फ्लैट सूची है, जैसे

[0.0+0j, 0.4+0j, -0.1+0j, -0.4+0j]

ध्यान दें कि जटिल संख्याओं के jबजाय पायथन का उपयोग करता है i।

आउटपुट दो सूचियाँ हैं, जिनमें पहला आइगेनवैल्यूज़ और दूसरा ईज़ेनवेक्टर्स युक्त है, जैसे

[(-0.2+0j), (-0.2+0j)]
[[(0.8944271909999159+0j), (-0.4472135954999579+0j)], [(0.8944271909999159+0j), (-0.4472135954999579+0j)]]

(स्पष्टता के लिए डाली गई नई पंक्ति)

Answer 3

लुआ, 462 455 431 427 बाइट्स

लुआ में कोई अंतर्निहित जटिल गणित नहीं है। कोई वेक्टर ऑपरेशन भी नहीं। सभी को हाथ से लुढ़कना पड़ा।

a,b,c,d,e,f,g,h=...x=math.sqrt z=print i=a-g j=b-h
k=(i^2-j^2)/2+2*(c*e-d*f)m=x(k^2+(i*j+2*(c*f+d*e))^2)n=x(m+k)o=x(m-k)i=(a+g+n)/2
j=(b+h+o)/2 k=(a+g-n)/2 l=(b+h-o)/2 z(i,j,k,l)q=c^2+d^2 r=e^2+f^2 s=q+r if s==0
then z(1,0,0,0,0,0,1,0)else if r==0 then m,n,o,p=c,d,c,d c,d=i-a,j-b e,f=k-a,l-b
u=x(q+c^2+d^2)v=x(q+e^2+f^2)else m,n=i-g,j-h o,p=k-g,l-h c,d=e,f
u=x(r+m^2+n^2)v=x(r+o^2+p^2)end z(m/u,n/u,o/v,p/v,c/u,d/u,e/v,f/v)end

निम्न तर्कों के साथ कमांड-लाइन से चलाएँ:

lua eigen.lua Re(a) Im(a) Re(b) Im(b) Re(c) Im(c) Re(d) Im(d)

निम्नलिखित उत्पादन करता है:

Re(lambda1) Im(lambda1) Re(lambda2) Im(lambda2)
Re(v11) Im(v11) Re(v12) Im(v12) Re(v21) Im(v21) Re(v22) Im(v22)

... ए, बी, सी के लिए, इनपुट मैट्रिक्स के 4 घटकों, lambda1 और lambda2 दो eigenvalues, v11, v21 पहली इकाई eigenvector, और v12, v22 दूसरी इकाई higenvector। उदाहरण के लिए,

lua eigen.lua 1 0  1 0  1 0  0 0

... पैदा करता है ...

1.6180339887499 0   -0.61803398874989   0
0.85065080835204    0   -0.52573111211913   0   0.52573111211913    0   0.85065080835204    0