अंतर-रूट और पुनरावृत्ति कैसे करें गैर-संख्यात्मक अंतर समीकरणों के लिए उपयोगी?

Question

आज सुबह a physics forum question का जवाब देने में, मैं DifferenceRoot और RecurrenceTable के वास्तव में खराब प्रदर्शन में भाग गया, जो एक घातीय उत्पन्न करने वाले कार्यात्मक रूप से व्युत्पन्न व्युत्पन्न द्वारा अभिव्यक्तियों की गणना करने की तुलना में किया गया था। खुदाई की एक बहुत छोटी राशि से पता चला कि DifferenceRoot और RecurrenceTableअभिव्यक्तियों को सरल नहीं करते हैं क्योंकि वे पर जाते हैं।

उदाहरण के लिए, RecurrenceTable के निम्न उत्पादन को देखो और कैसे यह सिर्फ Expand परिणाम ing द्वारा सरल:

In[1]:= RecurrenceTable[f[n] == a f[n - 1] + (a - 1) f[n - 2] && 
         f[0] == 0 && f[1] == 1, 
         f, {n, 6}] 
% // Expand 

Out[1]= {0, 1, a, -1+a+a^2, -a+a^2+a (-1+a+a^2), 1-a-a^2+a (-1+a+a^2)+a (-a+a^2+a (-1+a+a^2))} 
Out[2]= {0, 1, a, -1+a+a^2, -2 a+2 a^2+a^3, 1-2 a-2 a^2+3 a^3+a^4} 

यह जल्दी से, हाथ से बाहर हो जाता है 20 वीं यात्रा की पत्ती गिनती के रूप में (का प्रयोग कर गणना DifferenceRoot) दिखाता है:

dr[k_] := DifferenceRoot[Function[{f, n}, 
      {f[n] == a f[n - 1] + (a - 1) f[n - 2], f[0] == 0, f[1] == 1}]][k] 

In[2]:= dr20 = dr[20]; // Timing 
     dr20Exp = Expand[dr20]; // Timing 
Out[2]= {0.26, Null} 
Out[3]= {2.39, Null} 

In[4]:= {LeafCount[dr20], LeafCount[dr20Exp]} 
Out[4]= {1188383, 92} 

कौन सा memoized कार्यान्वयन

01 की तुलना में किया जा सकता है

तो मेरे सवाल है: कोई विकल्प/चाल DifferenceRoot और RecurrenceTable पाने के लिए एक (सरल बनाने) समारोह लागू के रूप में वे जाने के लिए और इस प्रकार उन्हें गैर-संख्यात्मक काम के लिए उपयोगी बनाने के लिए कर रहे हैं?

संपादित करें: ए Sjoerd नीचे बताया गया, मैं मूर्खतापूर्वक RSolve सक्षम बंद फॉर्म समाधान के साथ एक उदाहरण चुना। इस प्रश्न में मैं मुख्य रूप से DifferenceRoot और RecurrenceTable के व्यवहार से चिंतित हूं। यदि यह मदद करता है, तो कल्पना करें कि f[n-2] शब्द n से गुणा किया गया है, ताकि कोई आसान बंद फॉर्म समाधान न हो।

Answer 1

मैं वास्तव में आपके प्रश्न के साथ मदद नहीं कर सकता क्योंकि मैंने अभी तक उन कार्यों का उपयोग नहीं किया है, और दस्तावेज़ एक सुराग नहीं देते हैं। लेकिन आप अभी RSolve का उपयोग क्यों नहीं करते?

sol = f /. RSolve[f[n] == a f[n - 1] + (a - 1) f[n - 2] && 
        f[0] == 0 && f[1] == 1, f, n 
      ][[1, 1]] 

sol@Range[6] // Simplify