सब लोग,

मैं कुछ गणना करने और परिणामों की साजिश रचने की कोशिश कर रहा हूं, लेकिन ऐसा लगता है कि ये मैक्सिमा के लिए बहुत भारी हैं। जब मैं N1 और N2 की गणना करने का प्रयास करता हूं तो प्रोग्राम क्रैश हो जाता है जब पैरामीटर j बहुत अधिक होता है या जब मैं उन्हें प्लॉट करने का प्रयास करता हूं, तो प्रोग्राम निम्न त्रुटि संदेश प्रदर्शित करता है: "हीप समाप्त, गेम ओवर।" मुझे क्या करना चाहिए? मैंने कुछ लोगों को मैक्सिमा को सीसीएल के साथ संकलित करने का प्रयास करने के लिए कहा है, लेकिन मुझे नहीं पता कि यह कैसे करना है या अगर यह काम करेगा।

मुझे आमतौर पर त्रुटि संदेश मिलते हैं जैसे:

Message from maxima's stderr stream: Heap exhausted during garbage collection: 0 bytes available, 16     requested. 
Gen  Boxed Unboxed   LgBox LgUnbox  Pin       Alloc     Waste        Trig      WP GCs Mem-age 
 0       0       0       0       0    0           0         0    20971520       0   0  0,0000 
 1       0       0       0       0    0           0         0    20971520       0   0  0,0000 
 2       0       0       0       0    0           0         0    20971520       0   0  0,0000 
 3   16417       2       0       0   43  1075328496    707088   293986768   16419   1  0,8032 
 4   13432      21       0    1141   70   955593760    838624     2000000   14594   0  0,2673 
 5       0       0       0       0    0           0         0     2000000       0   0  0,0000 
 6     741     184      34      28    0    63259792   1424240     2000000     987   0  0,0000 
 7       0       0       0       0    0           0         0     2000000       0   0  0,0000 
           Total bytes allocated    =    2094182048 
           Dynamic-space-size bytes =    2097152000 
GC control variables: 
   *GC-INHIBIT* = true 
   *GC-PENDING* = true 
   *STOP-FOR-GC-PENDING* = false 
fatal error encountered in SBCL pid 13884(tid 0000000001236360): 
Heap exhausted, game over. 

यहाँ कोड जाता है:

enter code here

a: 80$;
b: 6*a$;
h1: 80$;
t: 2$;
j: 5$;
carga: 250$;
sig: -carga/2$;

n: 2*q*%pi/b$;
m: i*%pi/a$;
i: 2*p-1$;
i1: 2*p1-1$;
/*i1: p1$;*/

Φ: a/b$;
τ: cosh(x) - (x/sinh(x))$;
σ: sinh(x) - (x/cosh(x))$;
Ψ: sinh(x)/τ$;
Χ: cosh(x)/σ$;

Λ0: 1/(((i/2)^2+Φ^2*q^2)^2)$;
Λ1: sum((((i/2)^3*subst([x=(i*%pi/(2*Φ))],Ψ))/(((i/2)^2+Φ^2*q1^2)^2))*Λ0, p, 1, j)$;
Λ2: sum(((q1^3*subst([x=(q1*%pi*Φ)],Χ))/(((i/2)^2+Φ^2*q1^2)^2))*Λ1, q1, 1, j)$;
Λ3: sum((((i/2)^3*subst([x=(i*%pi/(2*Φ))],Ψ))/(((i/2)^2+Φ^2*q1^2)^2))*Λ2, p, 1, j)$;
Λ4: sum(((q1^3*subst([x=(q1*%pi*Φ)],Χ))/(((i/2)^2+Φ^2*q1^2)^2))*Λ3, q1, 1, j)$;
Λ5: sum((((i/2)^3*subst([x=(i*%pi/(2*Φ))],Ψ))/(((i/2)^2+Φ^2*q1^2)^2))*Λ4, p, 1, j)$;

Ζ0: sum(((q^3*subst([x=(q*%pi*Φ)],Χ))/(((i1/2)^2+Φ^2*q^2)^2))*Λ0, q, 1, j)$;
Ζ2: sum(((q^3*subst([x=(q*%pi*Φ)],Χ))/(((i1/2)^2+Φ^2*q^2)^2))*Λ2, q, 1, j)$;
Ζ4: sum(((q^3*subst([x=(q*%pi*Φ)],Χ))/(((i1/2)^2+Φ^2*q^2)^2))*Λ4, q, 1, j)$;

E: 200000$;
ν: 0.3$;
λ: (ν*E)/((1+ν)*(1-2*ν))$;
μ: E/(2*(1+ν))$;

a0: float(1/(b/2)*integrate(0, y, -(b/2), -h1/2)+1/b*integrate(sig, y, -h1/2,     h1/2)+1/(b/2)*integrate(0, y, h1/2, (b/2)))$;
aq: float(1/(b/2)*integrate(0*cos(q*y*%pi/(b/2)), y, -(b/2), - h1/2)+1/(b/2)*integrate(sig*cos(q*y*%pi/(b/2)), y, -h1/2, h1/2)+1/(b/2)*integrate(0*cos(q*y*%pi/(b/2)),   y, h1/2, (b/2)))$;
aq1: float(1/(b/2)*integrate(0*cos(q1*y*%pi/(b/2)), y, -(b/2), - h1/2)+1/(b/2)*integrate(sig*cos(q1*y*%pi/(b/2)), y, -h1/2,   h1/2)+1/(b/2)*integrate(0*cos(q1*y*%pi/(b/2)), y, h1/2, (b/2)))$;

Bq:  aq/((λ+μ)*subst([x=q*%pi*Φ],σ))+((16*Φ^4*q^2*(-1)^q)/((λ+μ)*%pi^2*subst([x=q*%pi*Φ],σ)))*sum(q1*aq1*(-1) ^q1*subst([x=q1*%pi*Φ],Χ)*(Λ1+(16*Φ^4/(%pi^2))*Λ3+((16*Φ^4/(%pi^2))^2)*Λ5), q1, 1,  j)+(8*λ*Φ^3*q^2*(-1)^q*a0)/((λ+μ)*(λ+2*μ)*(%pi^3)*subst([x=q*%pi*Φ],σ))*sum(subst([x=i*%pi/(2*Φ)],Ψ)/(i/ 2)*(Λ0+(16*Φ^4/(%pi^2))*Λ2+((16*Φ^4/(%pi^2))^2)*Λ4), p, 1, j)$;

βp: -(2*λ*a0*(-1)^((i-1)/2))/((λ+μ)*(λ+2*μ)*(i/2)^2*%pi^2*subst([x=i*%pi/(2*Φ)],τ))-((32*λ*Φ^4*(i/2)^2*a0*(-1)^((i-1)/2))/((λ+μ)*(λ+2*μ)*%pi^2*subst([x=i*%pi/(2*Φ)],τ)))*sum(((subst([x=i1*%pi/(2*Φ)],Ψ))/(i1/2))*(Ζ0+Ζ2*((16*Φ^4)/%pi^2)+Ζ4*(((16*Φ^4)/%pi^2)^2)),p1,1,j)-((4*Φ*(i/2)^2*(-1)^((i-1)/2))/((λ+μ)*%pi*subst([x=i*%pi/(2*Φ)],τ)))*sum(q*aq*(-1)^q*subst([x=q*%pi*Φ],Χ)*(Λ0+Λ2*(16*Φ^4/%pi^2)+Λ4*(16*Φ^4/%pi^2)^2),q,1,j)$;

N1: (2*a0/a)*x+(λ+μ)*sum(Bq*((1+((n*a*sinh(n*a/2))/(2*cosh(n*a/2))))*sinh(n*x)-n*x*cosh(n*x))*cos(n*y),q,1,j)+(λ+μ)*sum(βp*((1-((m*b*cosh(m*b/2))/(2*sinh(m*b/2))))*cosh(m*y)+m*y*sinh(m*y))*sin(m*x),p,1,j)$;

N2: ((2*λ*a0)/(a*(λ+2*μ)))*x+(λ+μ)*sum(Bq*((1-((n*a*sinh(n*a/2))/(2*cosh(n*a/2))))*sinh(n*x)+n*x*cosh(n*x))*cos(n*y),q,1,j)+(λ+μ)*sum(βp*((1+((m*b*cosh(m*b/2))/(2*sinh(m*b/2))))*cosh(m*y)-m*y*sinh(m*y))*sin(m*x),p,1,j);

wxplot3d(N1, [x,-a/2,a/2], [y,-b/2,b/2])$;

wxplot3d(N2, [x,-a/2,a/2], [y,-b/2,b/2])$;
4
Mateus Nogueira 22 फरवरी 2020, 22:56
2
आप SBCL हीप आकार सीमा को पार कर रहे हैं, जो इस मामले में 2GB प्रतीत होती है। यह मानते हुए कि आपकी मशीन में इससे अधिक मेमोरी है, आप ढेर के आकार की सीमा को काफी हद तक बढ़ा सकते हैं, जिससे आप आगे बढ़ सकते हैं। इसके लिए एसबीसीएल चलाते समय आप --dynamic-space-size <MB> का उपयोग करते हैं: मुझे नहीं पता कि आप मैक्सिमा को ऐसा करने के लिए कैसे राजी करते हैं (यही कारण है कि यह एक टिप्पणी है उत्तर नहीं)।
 – 
user5920214
23 फरवरी 2020, 17:28
प्रश्न के लिए क्षमा करें, लेकिन मैं इसका उपयोग कैसे करूं?
 – 
Mateus Nogueira
24 फरवरी 2020, 01:27
मेरी सलाह है कि यह कम करने की कोशिश करें कि कौन सा ऑपरेशन परेशानी पैदा कर रहा है। स्मृति समाप्त होने से पहले आप कितनी दूर जाते हैं? क्या आप पता लगा सकते हैं कि आखिरी ऑपरेशन कौन सा है जो सफलतापूर्वक पूरा हुआ है? अधिक मेमोरी आवंटित करके समस्या के आसपास काम करना संभव हो सकता है, हालांकि, समस्या बहुत बड़े एक्सप्रेशन या ऐसा कुछ फैक्टरिंग से संबंधित हो सकती है, जिसके लिए अधिक मेमोरी आवंटित करने का मतलब यह हो सकता है कि यह विफल होने से पहले लंबे समय तक चलता है। आप मैक्सिमा मेलिंग सूची पर एक संदेश पोस्ट करना चाह सकते हैं। देखें: sourceforge.net/projects/maxima/lists/maxima-discuss
 – 
Robert Dodier
25 फरवरी 2020, 03:28

2 जवाब

यह एक पूर्ण उत्तर नहीं है, क्योंकि मुझे नहीं पता कि यह wxMaxima के साथ कैसे काम करना चाहिए। : मेरा सुझाव है कि आप डेवलपर्स से पूछें। हालांकि यह एक टिप्पणी के लिए बहुत लंबा है और मुझे लगता है कि यह लोगों के लिए उपयोगी हो सकता है, और यह करता है इस सवाल का जवाब देता है कि आप Maxima स्वयं SBCL का उपयोग करते समय, कम से कम जब Linux या किसी अन्य प्लेटफ़ॉर्म पर कमांड-लाइन के साथ चलाया जाता है।

एक नोट के रूप में, मुझे संदेह है कि अंतर्निहित समस्या ढेर आकार नहीं है, लेकिन यह गणना कुछ भयानक तरीके से उड़ रही है: सबसे अच्छा फिक्स शायद यह समझना है कि क्या उड़ रहा है और इसे ठीक करें। रॉबर्ट डोडियर का उत्तर देखें, जो शायद बहुत अधिक सहायक होने जा रहा है। हालांकि, अगर हीप साइज है समस्या है, तो आप मैक्सिमा के लिए इससे कैसे निपटते हैं।

चाल यह है कि आप एसबीसीएल को --dynamic-space-size <MB> तर्क पारित करके बता सकते हैं कि ढेर सीमा क्या होनी चाहिए, और आप ऐसा करने के लिए maxima रैपर के माध्यम से तर्क पारित कर सकते हैं।

यहाँ मैक्सिमा का एक प्रतिलेख है, जिसे लिनक्स पर चलाया जा रहा है, जिसमें एसबीसीएल एक बैक एंड के रूप में है (यह स्रोत से निर्मित एक संस्करण है: पैक किया गया संस्करण मैं वही मानूंगा):

$ maxima
Maxima 5.43.2 http://maxima.sourceforge.net
using Lisp SBCL 2.0.0
Distributed under the GNU Public License. See the file COPYING.
Dedicated to the memory of William Schelter.
The function bug_report() provides bug reporting information.
(%i1) :lisp (sb-ext:dynamic-space-size)

1073741824

तो, इस सिस्टम पर डिफॉल्ट हीप लिमिट 1GB है (यह प्लेटफॉर्म पर SBCL की डिफॉल्ट लिमिट है)।

अब हम -X <lisp options> उर्फ --lisp-options=<lisp options> विकल्प को maxima रैपर में पास कर सकते हैं ताकि sbcl के माध्यम से उपयुक्त विकल्प पास किया जा सके:

$ maxima -X '--dynamic-space-size 2000'
Lisp options: (--dynamic-space-size 2000)
Maxima 5.43.2 http://maxima.sourceforge.net
using Lisp SBCL 2.0.0
Distributed under the GNU Public License. See the file COPYING.
Dedicated to the memory of William Schelter.
The function bug_report() provides bug reporting information.
(%i1) :lisp (sb-ext:dynamic-space-size)

2097152000

जैसा कि आप देख सकते हैं कि इसने ढेर के आकार को दोगुना कर दिया है।


अगर किसी को wxMaxima का उत्तर पता है तो कृपया इस उत्तर में एक संपादन जोड़ें: मैं इसका प्रयोग नहीं कर सकता क्योंकि मेरे सभी लिनक्स वीएम हेडलेस हैं।

3
25 फरवरी 2020, 14:08

यहां एक पूर्ण उत्तर भी नहीं है, लेकिन कुछ और नोट्स और पॉइंटर्स जो मुझे आशा है कि मदद करेंगे।

मैक्सिमा को पचाने में समस्या को आसान बनाने के लिए, केवल सटीक संख्याओं (पूर्णांक और अनुपात) का उपयोग करें, और float और numer से बचें। (प्लॉटिंग फ़ंक्शन float और numer स्वचालित रूप से लागू होंगे।) मैंने 0.3 को 3/10 में बदल दिया और कॉल को float कर दिया।

साथ ही, j को छोटी संख्या में सेट करने का प्रयास करें (मैंने j 1 के बराबर की कोशिश की) समस्या को फिर से 5 तक बढ़ाने से पहले सभी तरह से काम करने का प्रयास करने के लिए।

साथ ही, सभी sum और integrate को 'sum और 'integrate से बदलें (अर्थात क्रिया अभिव्यक्तियों के बजाय संज्ञा भाव)। यह देखने के लिए कि क्या वे सही दिखते हैं, सारांश और एकीकृत पर एक नज़र डालें। आप क्रमशः 'sum, 'integrate, या सभी संज्ञा अभिव्यक्तियों का मूल्यांकन करने के लिए ev(expr, sum) या ev(expr, integrate) या ev(expr, nouns) के माध्यम से योग और/या इंटीग्रल या दोनों का मूल्यांकन कर सकते हैं।

j बराबर 1 के साथ, मुझे N1 के लिए निम्न व्यंजक मिलता है:

(2500000*((-(13*cosh(%pi/6)
               *((8503056*cosh(%pi/6)^2*sinh(3*%pi)^2)
                /(9765625*%pi^4
                         *(sinh(%pi/6)-%pi/(6*cosh(%pi/6)))^2
                         *(cosh(3*%pi)-(3*%pi)/sinh(3*%pi))^2)
                +(52488*cosh(%pi/6)*sinh(3*%pi))
                 /(15625*%pi^2*(sinh(%pi/6)-%pi/(6*cosh(%pi/6)))
                        *(cosh(3*%pi)-(3*%pi)/sinh(3*%pi)))
                +324/25))
         /(120000*%pi^2*(sinh(%pi/6)-%pi/(6*cosh(%pi/6)))
                 *(cosh(3*%pi)-(3*%pi)/sinh(3*%pi))))
         +(13*sinh(3*%pi)
             *((2754990144*cosh(%pi/6)^3*sinh(3*%pi)^2)
              /(244140625*%pi^4
                         *(sinh(%pi/6)-%pi/(6*cosh(%pi/6)))^3
                         *(cosh(3*%pi)-(3*%pi)/sinh(3*%pi))^2)
              +(17006112*cosh(%pi/6)^2*sinh(3*%pi))
               /(390625*%pi^2
                       *(sinh(%pi/6)-%pi/(6*cosh(%pi/6)))^2
                       *(cosh(3*%pi)-(3*%pi)/sinh(3*%pi)))
              +(104976*cosh(%pi/6))
               /(625*(sinh(%pi/6)-%pi/(6*cosh(%pi/6))))))
          /(22680000*%pi^2*(cosh(3*%pi)-(3*%pi)/sinh(3*%pi))^2)
         +13/(35000*%pi^2*(cosh(3*%pi)-(3*%pi)/sinh(3*%pi))))
        *sin((%pi*(2*p-1)*x)/80)
        *((%pi*(2*p-1)*y*sinh((%pi*(2*p-1)*y)/80))/80
         +(1-(3*%pi*(2*p-1)*cosh(3*%pi*(2*p-1)))
             /sinh(3*%pi*(2*p-1)))
          *cosh((%pi*(2*p-1)*y)/80)))
 /13
 +(2500000*((-(13*cosh(%pi/6)
                 *((344373768*cosh(%pi/6)^2*sinh(3*%pi)^3)
                  /(244140625*%pi^4
                             *(sinh(%pi/6)-%pi/(6*cosh(%pi/6)))
                              ^2
                             *(cosh(3*%pi)-(3*%pi)/sinh(3*%pi))
                              ^3)
                  +(2125764*cosh(%pi/6)*sinh(3*%pi)^2)
                   /(390625*%pi^2
                           *(sinh(%pi/6)-%pi/(6*cosh(%pi/6)))
                           *(cosh(3*%pi)-(3*%pi)/sinh(3*%pi))^2)
                  +(13122*sinh(3*%pi))
                   /(625*(cosh(3*%pi)-(3*%pi)/sinh(3*%pi)))))
           /(1620000*%pi^3*(sinh(%pi/6)-%pi/(6*cosh(%pi/6)))^2))
           +(13*sinh(3*%pi)
               *((8503056*cosh(%pi/6)^2*sinh(3*%pi)^2)
                /(9765625*%pi^4
                         *(sinh(%pi/6)-%pi/(6*cosh(%pi/6)))^2
                         *(cosh(3*%pi)-(3*%pi)/sinh(3*%pi))^2)
                +(52488*cosh(%pi/6)*sinh(3*%pi))
                 /(15625*%pi^2*(sinh(%pi/6)-%pi/(6*cosh(%pi/6)))
                        *(cosh(3*%pi)-(3*%pi)/sinh(3*%pi)))
                +324/25))
            /(3780000*%pi^3*(sinh(%pi/6)-%pi/(6*cosh(%pi/6)))
                     *(cosh(3*%pi)-(3*%pi)/sinh(3*%pi)))
           -13/(20000*%pi*(sinh(%pi/6)-%pi/(6*cosh(%pi/6)))))
          *(((%pi*sinh(%pi/6))/(6*cosh(%pi/6))+1)
           *sinh((%pi*x)/240)
           -(%pi*x*cosh((%pi*x)/240))/240)*cos((%pi*y)/240))
  /13-(25*x)/48$

अब इसे प्लॉट करने के लिए, यह केवल x और y का एक फंक्शन होना चाहिए। हालांकि listofvars रिपोर्ट करता है कि इसमें x, y, और p शामिल हैं। हम्म। मैं देख रहा हूँ कि βp का योग p1 से अधिक है, लेकिन इसमें Ζ0 है, जिसमें Λ0 है, जिसमें p है। क्या p1 से अधिक का योग p से अधिक होना चाहिए? क्या सारांश में p के बजाय p1 होना चाहिए?

इसी तरह ऐसा प्रतीत होता है कि N2, j के साथ योग और समाकल का मूल्यांकन करने के बाद, p शामिल है।

शायद आपको सूत्रों को कुछ हद तक फिर से काम करने की ज़रूरत है? मुझे नहीं पता कि सही फॉर्म क्या हो सकता है।

1
Robert Dodier 25 फरवरी 2020, 10:54
ढेर आकार की तुलना में यह सही उत्तर होने की अधिक संभावना है!
 – 
user5920214
25 फरवरी 2020, 14:09