गणित

Question

का उपयोग कर कंप्यूटिंग eigenvalues ​​के साथ समस्या मूल रूप से मैं मैट्रिक्स के लिए eigenvalues ​​खोजने की कोशिश कर रहा हूँ, और इसमें लगभग 12 घंटे लगते हैं। जब यह खत्म होता है, तो यह कहता है कि यह सभी eigenvectors (वास्तव में मुश्किल से कोई भी नहीं) मिल सकता है, और मैं उन लोगों के बारे में संदेह कर रहा हूं जो इसे मिला। मैं वास्तव में अपना कोड पोस्ट कर सकता हूं, और मुझे उम्मीद है कि कोई मुझे कुछ सुझाव दे सकता है। मैं गणित के साथ बहुत अनुभवी नहीं हूं और शायद धीमी गति से चलने वाला समय और खराब परिणामों में मेरे साथ कुछ करना है, न कि गणित की क्षमताओं। उत्तर देने वाले किसी भी व्यक्ति के लिए धन्यवाद, मैं वास्तव में इसकी सराहना करता हूं।

cutoff = 500; (* set a cutoff for the infinite series *) 
numStates = cutoff + 1; (* set the number of excited states to be printed *) 
If[numStates > 10, numStates = 10]; 

    $RecursionLimit = cutoff + 256; (* Increase the recursion limit to allow for the specified cutoff *) 
(* set the mass of the constituent quarks *) 
m1 := mS; (* just supposed to be a constant *) 
m2 := 0; 

(* construct the hamiltonian *) 
h0[n_,m_] := 4 Min[n,m] * ((-1)^(n+m) * m1^2 + m2^2); 

v[0,m_] := 0; 
v[n_,0] := 0; 
v[n_,1] := (8/n) * ((1 + (-1)^(n + 1))/2); 
v[n_,m_] := v[n - 1, m - 1] * (m/(m - 1)) + (8 m/(n + m - 1))*((1 + (-1)^(n + m))/2); 

h[n_,m_] := h0[n,m] + v[n,m]; 

(* construct the matrix from the hamiltonian *) 
mat = Table[h[n,m], {n, 0, cutoff}, {m, 0, cutoff}] // FullSimplify; 

(* find the eigenvalues and eigenvectors, then reverse the order *) 
PrintTemporary["Finding the eigenvalues"]; 
{vals, vecs} = Eigensystem[N[mat]] // FullSimplify; 

$RecursionLimit = 256; (* Put the recursion limit back to the default *) 

मेरे कोड का थोड़ा और अधिक है, लेकिन यह वह बिंदु है जहां यह वास्तव में धीमा हो रहा है। मुझे निश्चित रूप से कुछ उल्लेख करना चाहिए, यह है कि यदि मैं एम 1 और एम 2 दोनों शून्य होने के लिए सेट करता हूं, तो मुझे वास्तव में कोई समस्या नहीं है, लेकिन स्थिरता के लिए एम 1 सेट करना सबकुछ नरक में जाता है।

Answer 1

आपकी समस्या यह है कि निरंतर mS प्रतीकात्मक बना हुआ है। इसका मतलब है कि गणित संख्यात्मक रूप से eigenvalues ​​के लिए विश्लेषणात्मक रूप से हल करने की कोशिश कर रहा है। यदि आपकी समस्या आपको mS के लिए संख्यात्मक मान चुनने की अनुमति देती है तो आपको ऐसा करना चाहिए।

अन्य, असंबंधित, समस्या आप है कि आप किसी दिए गए n के लिए निम्न पंक्ति में Memoization एक पुनरावर्ती सूत्र का उपयोग कर रहे हैं और आप उपयोग करना चाहते हैं, जैसे,

v[n_, m_] := v[n, m] = v[n - 1, m - 1]*(m/(m - 1)) 
        + (8 m/(n + m - 1))*((1 + (-1)^(n + m))/2); 

अतिरिक्त v[n, m] = भंडार मूल्य है और m इसलिए आपको v[0,0] पर हर बार h[n, m] पर Table[] में कॉल करने की आवश्यकता नहीं है।

उन दो चीजों के साथ मेरे पुराने कोर 2 जोड़ी की देखभाल करने के लिए eigenvalues ​​करने के लिए एक मिनट से भी कम समय लगता है।

Answer 2

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

यह देखते हुए कि आप एक मैट्रिक्स के Eigenvalues ​​को ढूंढना चाहते हैं जिसमें 501 x 501 प्रतीकात्मक तत्व हैं। [बीटीडब्ल्यू आप उन्हें स्थिरांक कहते हैं, लेकिन यह एक गलत नाम है। कॉन्स्टेंट सिर्फ नाम के साथ परिभाषित, निश्चित मान हैं। टिमो के उत्तर में आपकी टिप्पणी में आप जो वर्णन करते हैं वह एक प्रतीकात्मक चर है।]

यह देखने के लिए अच्छा है कि Eigenvalue गणनाओं के लिए एक पूर्ण प्रतीकात्मक मैट्रिक्स क्या करता है। यह एक 2 एक्स 2 मैट्रिक्स के लिए है:

Array[f, {2, 2}] // Eigenvalues 

(* ==> 
{1/2 (f[1, 1]+f[2, 2]-Sqrt[f[1, 1]^2+4f[1, 2] f[2, 1]-2 f[1, 1] f[2, 2]+f[2, 2]^2]), 
1/2(f[1, 1]+f[2, 2]+Sqrt[f[1, 1]^2+4 f[1, 2] f[2, 1]-2 f[1, 1] f[2, 2]+f[2, 2]^2])} 
*) 

यह Array[f, {2, 2}] // Eigenvalues//ByteCount = 3384 बाइट्स लेता है। यह बहुत तेजी से विस्फोट करता है: एक 7x7 समाधान पहले से ही 70 एमबी लेता है (इसे खोजने में कई मिनट लगते हैं)।

फिट समारोह है: बाइट गिनती = ई^(2.2403067075863197 + 2.2617380321848457 एक्स मैट्रिक्स आकार) वास्तव में, वहाँ एक अच्छा संबंध मैट्रिक्स आकार और बाइट गिनती के बीच पाया जा सकता है।

जैसा कि आप देख सकते हैं, 501 x 501 प्रतीकात्मक मैट्रिक्स के Eigenvalues ​​ब्रह्मांड के अंत से पहले नहीं मिलेगा।

[BTW क्या मैट्रिक्स के स्वत्वबोधक रूप है?]