मैट्रिक्स के आइगेनवेल्यूज़

Question

एक वर्ग मैट्रिक्स को देखते हुए, मैट्रिक्स के आइगेनवेल्यूज़ को आउटपुट करता है। प्रत्येक बीजगणित को उसकी बीजगणितीय बहुलता के बराबर कई बार दोहराया जाना चाहिए।

एक मैट्रिक्स के Aआइगेनवैल्यू स्केलर मान λहैं, जैसे कि कुछ कॉलम वेक्टर vके लिए A*v = λ*v। वे भी हैं A: det(A - λ*I) = 0(के Iरूप में एक ही आयाम के साथ पहचान मैट्रिक्स है A) की विशेषता बहुपद के लिए समाधान ।

आउटपुट 3 महत्वपूर्ण अंकों के लिए सटीक होना चाहिए। सभी इनपुट और आउटपुट आपकी चुनी हुई भाषा के लिए संख्यात्मक मानों के प्रतिनिधित्व योग्य सीमा के भीतर होंगे।

निर्मित स्वीकार्य हैं, लेकिन आपको उन समाधानों को शामिल करने के लिए प्रोत्साहित किया जाता है जो बिलिन का उपयोग नहीं करते हैं।

परीक्षण के मामलों

इन परीक्षण मामलों में, Iकाल्पनिक इकाई का प्रतिनिधित्व करता है। फॉर्म में जटिल संख्या लिखी जाती है a + b*I। सभी आउटपुट में परिशुद्धता के 3 महत्वपूर्ण अंक होते हैं।

[[42.0]] -> [42.0]
[[1.0, 0.0], [0.0, 1.0]] -> [1.00, 1.00]
[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] -> [16.1, -1.12, -1.24e-15]
[[1.2, 3.4, 5.6, 7.8], [6.3, 0.9, -5.4, -2.3], [-12.0, -9.7, 7.3, 5.9], [-2.5, 7.9, 5.3, 4.4]] -> [7.20 + 5.54*I, 7.20 - 5.54*I, -4.35, 3.75]
[[-3.22 - 9.07*I, 0.193 + 9.11*I, 5.59 + 1.33*I, -3.0 - 6.51*I, -3.73 - 6.42*I], [8.49 - 3.46*I, -1.12 + 6.39*I, -8.25 - 0.455*I, 9.37 - 6.43*I, -6.82 + 8.34*I], [-5.26 + 8.07*I, -6.68 + 3.72*I, -3.21 - 5.63*I, 9.31 + 3.86*I, 4.11 - 8.82*I], [-1.24 + 9.04*I, 8.87 - 0.0352*I, 8.35 + 4.5*I, -9.62 - 2.21*I, 1.76 - 5.72*I], [7.0 - 4.79*I, 9.3 - 2.31*I, -2.41 - 7.3*I, -7.77 - 6.85*I, -9.32 + 2.71*I]] -> [5.18 + 16.7*I, -24.9 - 2.01*I, -5.59 - 13.8*I, 0.0438 - 10.6*I, -1.26 + 1.82*I]
[[-30.6 - 73.3*I, 1.03 - 15.6*I, -83.4 + 72.5*I, 24.1 + 69.6*I, 52.3 + 2.68*I, 23.8 + 98.0*I, 96.8 + 49.7*I, -26.2 - 5.87*I, -52.4 + 98.2*I, 78.1 + 6.69*I], [-59.7 - 66.9*I, -26.3 + 65.0*I, 5.71 + 4.75*I, 91.9 + 82.5*I, -94.6 + 51.8*I, 61.7 + 82.3*I, 54.8 - 27.8*I, 45.7 + 59.2*I, -28.3 + 78.1*I, -59.9 - 54.5*I], [-36.0 + 22.9*I, -51.7 + 10.8*I, -46.6 - 88.0*I, -52.8 - 32.0*I, -75.7 - 23.4*I, 96.2 - 71.2*I, -15.3 - 32.7*I, 26.9 + 6.31*I, -59.2 + 25.8*I, -0.836 - 98.3*I], [-65.2 - 90.6*I, 65.6 - 24.1*I, 72.5 + 33.9*I, 1.47 - 93.8*I, -0.143 + 39.0*I, -3.71 - 30.1*I, 60.1 - 42.4*I, 55.6 + 5.65*I, 48.2 - 53.0*I, -3.9 - 33.0*I], [7.04 + 0.0326*I, -12.8 - 50.4*I, 70.1 - 30.3*I, 42.7 - 76.3*I, -3.24 - 64.1*I, 97.3 + 66.8*I, -11.0 + 16.5*I, -40.6 - 90.7*I, 71.5 - 26.2*I, 83.1 - 49.4*I], [-59.5 + 8.08*I, 74.6 + 29.1*I, -65.8 + 26.3*I, -76.7 - 83.2*I, 26.2 + 99.0*I, -54.8 + 33.3*I, 2.79 - 16.6*I, -85.2 - 3.64*I, 98.4 - 12.4*I, -27.6 - 62.3*I], [82.6 - 95.3*I, 55.8 - 73.6*I, -49.9 + 42.1*I, 53.4 + 16.5*I, 80.2 - 43.6*I, -43.3 - 3.9*I, -2.26 - 58.3*I, -19.9 + 98.1*I, 47.2 + 62.4*I, -63.3 - 54.0*I], [-88.7 + 57.7*I, 55.6 + 70.9*I, 84.1 - 52.8*I, 71.3 - 29.8*I, -3.74 - 19.6*I, 29.7 + 1.18*I, -70.6 - 10.5*I, 37.6 + 99.9*I, 87.0 + 19.0*I, -26.1 - 82.0*I], [69.5 - 47.1*I, 11.3 - 59.0*I, -84.3 - 35.1*I, -3.61 - 35.7*I, 88.0 + 88.1*I, -47.5 + 0.956*I, 14.1 + 89.8*I, 51.3 + 0.14*I, -78.5 - 66.5*I, 2.12 - 53.2*I], [0.599 - 71.2*I, 21.7 + 10.8*I, 19.9 - 97.1*I, 20.5 + 37.4*I, 24.7 + 40.6*I, -82.7 - 29.1*I, 77.9 + 12.5*I, 94.1 - 87.4*I, 78.6 - 89.6*I, 82.6 - 69.6*I]] -> [262. - 180.*I, 179. + 117.*I, 10.3 + 214.*I, 102. - 145.*I, -36.5 + 97.7*I, -82.2 + 89.8*I, -241. - 104.*I, -119. - 26.0*I, -140. - 218.*I, -56.0 - 160.*I]

Comments

सैंडबॉक्स

— मेगो

सम्बंधित। सम्बंधित।

— मार्टिन एंडर

संबंधित ? शायद संबंधित हैं ? (दृष्टिकोण पर निर्भर करता है)

— user202729

Answer 1

हास्केल , 576 554 532 507 बाइट्स

कोई बिल्ट-इन नहीं!

import Data.Complex
s=sum
l=length
m=magnitude
i=fromIntegral
(&)=zip
t=zipWith
(x!a)b=x*a+b
a#b=[[s$t(*)x y|y<-foldr(t(:))([]<$b)b]|x<-a]
f a|let c=[1..l a];g(u,d)k|m<-[t(+)a b|(a,b)<-a#u&[[s[d|x==y]|y<-c]|x<-c]]=(m,-s[s[b|(n,b)<-c&a,n==m]|(a,m)<-a#m&c]/i k)=snd<$>scanl g(0<$c<$c,1)c
p?x|let f=foldl1(x!);c=l p-1;n=i c;q p=init$t(*)p$i<$>[c,c-1..];o=f(q p)/f p;a|d<-sqrt$(n-1)*(n*(o^2-f(q$q p)/f p)-o^2)=n/last(o-d:[o+d|m(o-d)<m(o+d)])=last$p?(x-a):[x|m a<1e-9]
z[a,b]=[-b/a]
z p=p?0:z(init$scanl1(p?0!)p)

इसे ऑनलाइन आज़माएं!

-47 बाइट्स के लिए बहुत धन्यवाद @ JrjanJohansen!

व्याख्या

पहले यह Faddeev-LeVerrier एल्गोरिथ्म के साथ विशेषता बहुपद की गणना करता है जो कार्य है f। फिर फ़ंक्शन zउस बहुपद की सभी जड़ों की गणना करके यह पता लगाता है कि एक जड़ को खोजने के लिए लैगुएरे की विधि को gलागू करता है, एक बार एक जड़ पाए जाने के बाद इसे हटा दिया जाता है और तब तक फिर से बुलाया जाता है जब तक कि बहुपद की डिग्री 1 नहीं होती है जो तुच्छ रूप से हल होती है ।gz[a,b]=[-b/a]

Ungolfed

मैं कार्यों फिर से inlined sum, length, magnitude, fromIntegral, zipWithऔर (&)साथ ही साथ थोड़ा सहायक (!)। समारोह faddeevLeVerrierमेल खाती है करने के लिए f, rootsकरने के लिए zऔर gकरने के लिए laguerreक्रमशः।

-- Transpose a matrix/list
transpose a = foldr (zipWith(:)) (replicate (length a) []) a

-- Straight forward implementation for matrix-matrix multiplication
(#) :: [[Complex Double]] -> [[Complex Double]] -> [[Complex Double]]
a # b = [[sum $ zipWith (*) x y | y <- transpose b]|x<-a]


-- Faddeev-LeVerrier algorithm
faddeevLeVerrier :: [[Complex Double]] -> [Complex Double]
faddeevLeVerrier a = snd <$> scanl go (zero,1) [1..n]
  where n = length a
        zero = replicate n (replicate n 0)
        trace m = sum [sum [b|(n,b)<-zip [1..n] a,n==m]|(m,a)<-zip [1..n] m]
        diag d = [[sum[d|x==y]|y<-[1..n]]|x<-[1..n]]
        add as bs = [[x+y | (x,y) <- zip a b] | (b,a) <- zip as bs]
        go (u,d) k = (m, -trace (a#m) / fromIntegral k)
          where m = add (diag d) (a#u)


-- Compute roots by succesively removing newly computed roots
roots :: [Complex Double] -> [Complex Double]
roots [a,b] = [-b/a]
roots   p   = root : roots (removeRoot p)
  where root = laguerre p 0
        removeRoot = init . scanl1 (\a b -> root*a + b)

-- Compute a root of a polynomial p with an initial guess x
laguerre :: [Complex Double] -> Complex Double -> Complex Double
laguerre p x = if magnitude a < 1e-9 then x else laguerre p new_x
  where evaluate = foldl1 (\a b -> x*a+b)
        order' = length p - 1
        order  = fromIntegral $ length p - 1
        derivative p = init $ zipWith (*) p $ map fromIntegral [order',order'-1..]
        g  = evaluate (derivative p) / evaluate p
        h  = (g ** 2 - evaluate (derivative (derivative p)) / evaluate p)
        d  = sqrt $ (order-1) * (order*h - g**2)
        ga = g - d
        gb = g + d
        s = if magnitude ga < magnitude gb then gb else ga
        a = order /s
        new_x = x - a

Comments

केवल प्रस्तुत करने के लिए जो बिल्डरों का उपयोग नहीं करता है, यह उच्चतम-मतदान जवाब होना चाहिए।

— फलन

+1 से कम समय में संबंधित-से-निर्धारक की गणना के लिए n!!

— user202729

धन्यवाद दोस्तों! @ user202729: शुरू में मैं ओवरसॉ !था और वास्तव में उलझन में था: D

— '

Answer 2

ऑक्टेव , 4 बाइट्स

@eig

इसे ऑनलाइन आज़माएं!

MATL गोल्फिंग लैंग्वेज से केवल दो बाइट्स बराबर!

एक अनाम फ़ंक्शन हैंडल को eigअंतर्निहित में परिभाषित करता है। दिलचस्प है, MATLAB डिजाइन दर्शन कई उच्च अंत भाषाओं के खिलाफ जाता है, जो उपयोग करना पसंद करते हैं DescripteFunctionNamesTakingArguments(), जबकि MATLAB और इसके परिणामस्वरूप ऑक्टेव सबसे कम अस्पष्ट फ़ंक्शन नाम संभव है। उदाहरण के लिए, एक पाने के लिए रों eigenvalues के ubset (जैसे, छोटी से छोटी nनिरपेक्ष परिमाण में), तो आप का उपयोगeigs ।

एक बोनस के रूप में, यहां एक फ़ंक्शन (MATLAB में काम करता है, और सिद्धांत में ओक्टेव में काम कर सकता है लेकिन उनका काम solveवास्तव में नहीं है) जो बिल्ट-इन का उपयोग नहीं करता है, लेकिन इसके बजाय प्रतीकात्मक रूप से आइजनवेल समस्या को हल करता है det(A-λI)=0, और इसे रूपांतरित करता है। उपयोग करने के लिए संख्यात्मक रूप मेंvpa

@(A)vpa(solve(det(A-sym('l')*eye(size(A)))))

Answer 3

MATL , 2 बाइट्स

Yv

इसे ऑनलाइन आज़माएं!

व्याख्या

मैंने संख्यात्मक लीनियर बीजगणित में सामान्य सलाह का पालन किया: अपने स्वयं के फ़ंक्शन को लिखने के बजाय, एक अंतर्निहित का उपयोग करें जो विशेष रूप से संख्यात्मक अस्थिरताओं से बचने के लिए डिज़ाइन किया गया है।

संयोग से, यह छोटा है। ¯ \ _ (ツ) _ / ¯

Comments

यह सवाल है, यह कब तक बिना होगा Yv?

— Sanchises

@ सेंचुरीज़ मुझे यकीन नहीं है। मैं संभवतः ZQबहुपद की जड़ों ( ) को खोजकर इसके बारे में जाऊंगा । लेकिन स्पष्ट रूप से बहुपद के गुणकों की गणना करने पर बहुत काम हो सकता है

— लुइस मेंडू

Answer 4

गणितज्ञ, 11 बाइट्स

Eigenvalues

इसे ऑनलाइन आज़माएं!

Comments

हां, मुझे "इस प्रश्न का 1 नया उत्तर" क्लिक करने से पहले एक अंतर्निहित उत्तर की उम्मीद थी। चलो कुछ गैर-निर्मित उत्तर की प्रतीक्षा करें ... / मूल रूप से गणितज्ञ समाधान अक्सर <शीर्षक में पहला शब्द है

— user202729

सबसे छोटा गैर-शुद्ध अंतर्निहित I मिला है First@Eigensystem@#&(20 बाइट्स)

— श्री एक्सकोडर

मैं वास्तव में यहाँ user202729 से सहमत हूँ। हालांकि यह सब कुछ के लिए मैथेमेटिका के एक बिल्डिन होने के बारे में मजाक करने के लिए मजेदार है, यह एक चुनौती पोस्टर के रूप में दोनों को बहुत परेशान कर रहा है और एक बिल्डिन के जवाब को देखने के लिए जवाब दे रहा है जो आपने अपेक्षाकृत कठिन कोशिश की थी। गोल्फिंग (IMO) उक्त एल्गोरिथ्म के सबसे छोटे एल्गोरिदम और कार्यान्वयन को खोजने का प्रयास करने के बारे में है, लेकिन एक अंतर्निहित उत्तर "खेल" से दूर ले जाता है।

— caird coinheringaahing

@cairdcoinheringaahing हमें वास्तव में xnor के प्रस्ताव को व्यवहार में लाना शुरू करना चाहिए ।

— मार्टिन एंडर

Answer 5

आर , 22 बाइट्स

function(m)eigen(m)$va

इसे ऑनलाइन आज़माएं!

mमैट्रिक्स के रूप में लेता है । निराशा की बात eigenहै कि R में फ़ंक्शन कक्षा की एक वस्तु देता है eigen, जिसमें दो फ़ील्ड हैं: valueseigenvalues ​​और vectors, eigenvectors।

हालाँकि, अधिक गुस्से में, वैकल्पिक तर्क दो फ़ील्ड के साथ only.valuesलौटता है , जिसमें आइगेनवेल्यूज़ होता है, और , पर सेट होता है , लेकिन चूंकि यह 22 बाइट्स भी है, इसलिए यह धोना है।listvaluesvectorsNULLeigen(m,,T)

Answer 6

जूलिया , 12 बाइट्स

n->eig(n)[1]

इसे ऑनलाइन आज़माएं!

दुर्भाग्य से, eigट्यूल के रूप में आइजनवेल्स और आईजेनवेक्टर दोनों को लौटाता है, इसलिए हम इसे लैंबिडाइज करने और पहले आइटम को हथियाने के लिए एक और 9 बाइट बर्बाद करते हैं।

Answer 7

अजगर + सुन्न, 33 बाइट्स

from numpy.linalg import*
eigvals

Answer 8

Pari / जीपी , 19 बाइट्स

m->mateigen(m,1)[1]

इसे ऑनलाइन आज़माएं!