मेथेमेटिका

Question

में सरल लक्षित

मैं सामान्य रूप से बहुत लंबे और जटिल विश्लेषणात्मक भाव उत्पन्न:

(...something not so complex...)(...ditto...)(...ditto...)...lots... 

जब मैं Simplify इस्तेमाल करने की कोशिश, मेथेमेटिका रोकने के लिए grinds, मैं तथ्य यह है कि यह कोशिश करता है की वजह से संभालने हूँ ब्रैकेट का विस्तार करने और विभिन्न ब्रैकेट में सरलीकृत करने के लिए। ब्रैकेट्स, जबकि लंबी अभिव्यक्तियां होती हैं, उन्हें गणित द्वारा आसानी से सरल किया जाता है। क्या कोई तरीका है कि मैं एक समय में एक ही ब्रैकेट में Simplify के दायरे को सीमित कर सकता हूं?

संपादित करें: कुछ अतिरिक्त जानकारी और प्रगति।

तो सलाह तुम लोगों से मैं अब

In[1]:= trouble = Log[(x + I y) (x - I y) + Sqrt[(a + I b) (a - I b)]]; 

In[2]:= Replace[trouble, form_ /; (Head[form] == Times) :> Simplify[form],{3}] 

Out[2]= Log[Sqrt[a^2 + b^2] + (x - I y) (x + I y)] 

Plus या Power की तरह एक उचित सिर के Times बदलने की नस में कुछ का उपयोग शुरू करने के लिए यह संभव काफी सही सरलीकरण लक्षित करने के लिए बनाता है का उपयोग कर। समस्या/प्रश्न जो बनी हुई है, निम्न है: Simplify अभी भी Replace पर निर्दिष्ट स्तर से गहराई से उतरेगा, उदा।

In[3]:= Replace[trouble, form_ /; (Head[form] == Plus) :> Simplify[form], {1}] 

Out[3]= Log[Sqrt[a^2 + b^2] + x^2 + y^2] 

वर्ग रूट को भी सरल बनाता है।

मेरे योजना iteratively एक समय में नीचे से ऊपर एक स्तर से Replace उपयोग करने के लिए गया था, लेकिन यह स्पष्ट रूप से Simplify द्वारा बार-बार काम के विशाल राशि में परिणाम होगा और अंत में ठीक उसी मेथेमेटिका के नीचे bogging में परिणाम मैं शुरू में अनुभवी । क्या Simplify को किसी निश्चित स्तर पर प्रतिबंधित करने का कोई तरीका है?

मुझे लगता है कि प्रतिबंध की इस तरह इष्टतम परिणाम नहीं हो सकता है, लेकिन यह विचार यहाँ कुछ है कि है "पर्याप्त" हो रही है।

Answer 1

तरीकों से आप यह कर सकते हैं की एक संख्या हैं, लेकिन यह एक छोटे से मुश्किल हो सकता है और अपने वास्तविक अभिव्यक्ति की संरचना पर निर्भर करता जा सकता है।हालांकि, आमतौर पर कोष्ठक में शर्तों के एक नंबर का एक उत्पाद सिर Times होगा, और आप FullForm उपयोग कर सकते हैं इस सत्यापित करने के लिए:

In[1]:= FullForm[(a+b)(c+d)] 
Out[1]= Times[Plus[a, b], Plus[c, d]] 

आप सिर Times ही साथ भाव के साथ उच्च क्रम समारोह Map उपयोग कर सकते हैं जिस तरह से आप सिर List साथ भाव के साथ उपयोग करें, और कहा कि आप एक समय में अभिव्यक्ति एक शब्द Simplify है, इसलिए जैसे अनुमति दे सकता है:

Map[Simplify, yourGinormousExpression] 

आप परिणाम पर Expand उपयोग कर सकते हैं यदि आप बाद में विस्तार करने के लिए की जरूरत है ओ ब्रैकेट के रूप में।

संपादित करें जोड़ने के लिए: यदि आप रूपों है कि आप को आसान बनाने में करना चाहते हैं निर्दिष्ट करना चाहते हैं हैं, तो आप Replace या ReplaceAll बजाय Map के रिश्तेदारों में से एक का उपयोग कर सकते हैं। Replace विशेष रूप से उपयोगी है क्योंकि यह level specification लेता है, जिससे आप केवल शीर्षतम उत्पाद में कारकों को प्रभावित कर सकते हैं। एक साधारण उदाहरण के रूप में, निम्नलिखित पर विचार:

In[1]:= expr = Sqrt[(a + 1)/a] Sqrt[(b + 1)/b]; 

In[2]:= Simplify[expr] 
Out[2]= Sqrt[1 + 1/a] Sqrt[1 + 1/b] 

आप कारक है कि a पर निर्भर सरल करने के लिए नहीं करना चाहते हैं। आप इस के बजाय कर सकते हैं:

In[3]:= Replace[expr, form_ /; FreeQ[form, a] :> Simplify[form], {1}] 
Out[3]= Sqrt[(1 + a)/a] Sqrt[1 + 1/b] 

केवल दूसरे कार्यकाल, जो b पर निर्भर करता है, बदल दिया गया है। ध्यान में रखना एक बात यह है कि कुछ परिवर्तन स्वचालित रूप से Times या Plus द्वारा किए जाते हैं; उदाहरण के लिए a + a2 a में Simplify के उपयोग किए बिना भी बदलेगा।

Answer 2

आप Map कोशिश करनी चाहिए। इतना के लिए

Map[Simplify, a b c d e] 

यह देता है

Simplify[a] Simplify[b] Simplify[c] Simplify[d] Simplify[e] 

नोट
सामान्य तौर पर, Map[foo, G[a, b, c, ...]] किसी भी सिर G और किसी भी अभिव्यक्ति foo के लिए G[foo[a], foo[b], foo[c], ...] देता है, आप Map[foo, expr] als foo /@ expr निरूपित कर सकते हैं अगर आपको लगता है कि और अधिक सुविधाजनक लगता है।

Answer 3

मैं अपने सहयोगियों के साथ अलग होना चाहता हूं, Map का उपयोग Simplify प्रत्येक उप-संपीड़न को लागू करने के लिए किसी भी समय सहेज नहीं सकता क्योंकि यह अभी भी प्रत्येक पर लागू होगा। इसके बजाय कोशिश, MapAt, इस प्रकार है:

In[1]:= MapAt[f, SomeHead[a,b,c,d], {4}] 
Out[1]:= SomeHead[a, b, c, f[d]] 

मुश्किल हिस्सा स्थिति विनिर्देश का निर्धारण किया जाता है। यद्यपि, अगर आप जिस अभिव्यक्ति को सरल बनाना चाहते हैं, वह पहले स्तर पर है, तो मैंने ऊपर लिखा है कि यह और भी मुश्किल नहीं होना चाहिए।

---

अब अगर आप अब भी सब कुछ आसान बनाने के लिए चाहते हैं, लेकिन आप कुछ संरचना की रक्षा करना चाहते हैं, विकल्प ExcludedForms उपयोग करके देखें। अतीत में, मैं इस सरलीकरण को रोकने के लिए उपयोग किया है:

In[2]:= Simplify[d Exp[I (a + b)] Cos[c/2]] 
Out[2]:= Exp[I(a + b + c)](d + d Exp[c]) 

मेथेमेटिका तरह लगता है जो, तो मैं

In[3]:= Simplify[d Exp[I (a + b)] Cos[c/2], ExcludedForms -> {_Cos,_Sin}] 
Out[3]:= d Exp[I (a + b)] Cos[c/2] 

कर इसके अलावा, भूल नहीं है कि Simplify के लिए दूसरा पैरामीटर के लिए है धारणाएं, और आपके अभिव्यक्तियों को उपयोगी रूप में प्राप्त करने में आपके संघर्ष को बहुत आसानी से कम कर सकती हैं।