हम एक "कैलकुलेटर" लिख रहे हैं। भाग II समीकरणों को हल करें, LaTeX में प्रस्तुत करें, सुपरलाइट को कार्यों को गति दें

नमस्ते!

इसलिए, पहले भाग में, हमने पहले से ही एक अच्छा काम किया है जो व्युत्पन्न, सरलीकरण और संकलन है। तो, हमारे सरल कैलकुलेटर को और क्या करने में सक्षम होना चाहिए? खैर, कम से कम फॉर्म के समीकरण

$$

$$(x - b) (\ tan (\ sin (x)) ^ 2 - 3 \ tan (\ sin (x)) + c) = 0$$

निश्चित रूप से तय करना होगा। यह मामला लेटच में खींचने के लिए भी सुंदर है, और यह ठीक रहेगा! चलो चलते हैं!

संकलन त्वरण

पिछले भाग में, हमने फ़ंक्शन को संकलित किया ताकि हम इसे एक बार संकलित कर सकें, और फिर भविष्य में इसे कई बार चला सकें।
इसलिए, हम फ़ंक्शन का परिचय देते हैं

$$

$$\ sin (x ^ 2) + \ cos (x ^ 2) + x ^ 2 + \ sin (x ^ 2)$$

पहले भाग के अंत में, इस फ़ंक्शन की गति इस प्रकार थी:


जैसा कि हम देख सकते हैं, इस फ़ंक्शन में दोहराए गए भाग हैं, उदाहरण के लिए, $$$x ^ 2$ , और उन्हें कैश करना अच्छा होगा।

ऐसा करने के लिए, हम PULLCACHE और TOCACHE दो और निर्देश पेश करते हैं। पहले वाले कैश में संख्या को उस पते पर धकेलेंगे, जिसे हम स्टैक पर पास करते हैं। दूसरा स्टैक से कैश में आखिरी नंबर ( stack.Peek() ) को भी एक विशिष्ट पते पर कॉपी करेगा।

यह एक तालिका बनाने के लिए बनी हुई है जिसमें संकलन के दौरान हम कैशिंग के लिए कार्य लिखेंगे। क्या हम कैश नहीं करेंगे? खैर, सबसे पहले, एक बार क्या होता है। कैश एक्सेस करने का अतिरिक्त निर्देश अच्छा नहीं है। दूसरे, ऑपरेशन जो बहुत सरल हैं वे भी कैश के लिए कोई मतलब नहीं रखते हैं। ठीक है, उदाहरण के लिए, एक चर या संख्या तक पहुंच।

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

 PUSHCONST (2, 0) PUSHVAR 0 CALL powf TOCACHE 0 #   ,         , -  . CALL sinf TOCACHE 1 #      PULLCACHE 0 # ,   .    PULLCACHE 0 CALL cosf PULLCACHE 1 CALL sumf CALL sumf CALL sumf 

उसके बाद हमें स्पष्ट रूप से बेहतर परिणाम मिलता है:

शलजम में, निर्देशों के संकलन और व्याख्या दोनों को यहां लागू किया जाता है ।

LaTeX

यह गणितीय फ़ार्मुलों की रिकॉर्डिंग के लिए एक प्रसिद्ध प्रारूप है (हालांकि केवल उन्हें नहीं!), जिसे सुंदर चित्रों में प्रस्तुत किया गया है। यह हब पर भी है, और मेरे द्वारा लिखे गए सभी सूत्र इस प्रारूप में लिखे गए हैं।

एक अभिव्यक्ति वृक्ष होने से लेटेक्स में प्रतिपादन बहुत सरल हो जाता है। तर्क की दृष्टि से यह कैसे किया जाए? तो, हमारे पास पेड़ की चोटी है। यदि यह एक संख्या या एक चर है, तो सब कुछ सरल है। यदि यह शीर्ष, उदाहरण के लिए, डिवीजन ऑपरेटर, हम और अधिक चाहेंगे $$$\ frac {a} {b}$ से $$$ए / बी$ , इसलिए विभाजन के लिए हम कुछ ऐसा लिखते हैं

 public static class Div { internal static string Latex(List<Entity> args) => @"\frac{" + args[0].Latexise() + "}{" + args[1].Latexise() + "}"; } 

सब कुछ बहुत सरल है, जैसा कि हम देखते हैं। कार्यान्वयन के दौरान मुझे एकमात्र समस्या यह है कि यह स्पष्ट नहीं है कि कोष्ठक कैसे रखा जाए। अगर हम उन्हें प्रत्येक ऑपरेटर पर छोड़ते हैं, तो हमें ऐसी बकवास मिलेगी:

$$

$$\ छोड़ दिया (\ बाएँ (\ बाएँ (\ बाएँ + x + 3) दायाँ) + बायाँ (a + b \ दाएँ) \ दाएँ) \ दाएँ) + c \ दाएँ)$$

हालांकि, एक चौकस व्यक्ति तुरंत (और मेरे जैसा नहीं) नोटिस करेगा कि यदि वे पूरी तरह से हटा दिए जाते हैं, तो फॉर्म की अभिव्यक्ति का निर्माण करते समय $$$c * (a + b)$ , हम छापेंगे

$$

$$सी * ए + बी$$

यह बस हल किया जाता है, हम ऑपरेटरों की प्राथमिकताओं में एक ला दर्ज करते हैं

 args[0].Latexise(args[0].Priority < Const.PRIOR_MUL) + "*" + args[1].Latexise(args[1].Priority < Const.PRIOR_MUL); 

और वोइला, तुम खूबसूरत हो।

लेटेक्सरीकरण यहाँ किया गया । और लेटेक्सिस शब्द मौजूद नहीं है, मैंने इसे स्वयं आविष्कार किया, इसके लिए मुझे मत मारो।

समीकरण समाधान

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

संख्यात्मक समाधान। न्यूटन की विधि

वह बेहद सरल है, फ़ंक्शन को जानना $$$च (x)$ हम पुनरावृत्त सूत्र का उपयोग करके रूट की खोज करेंगे

$$

$$x_ {n + 1} = x_n - \ frac {f (x)} {f (x) ''$$

चूंकि हम सभी एक जटिल विमान में हल करते हैं, हम मूल रूप से एक द्वि-आयामी चक्र लिख सकते हैं जो समाधान की तलाश करेंगे और फिर अद्वितीय लोगों को वापस करेंगे। इसके अलावा, हम अब फ़ंक्शन के व्युत्पन्न को विश्लेषणात्मक रूप से पा सकते हैं, और फिर दोनों फ़ंक्शन $$$च (x)$ और $$$च (x) '$ संकलन।

न्यूटन यहाँ बैठा है ।

विश्लेषणात्मक समाधान

पहले विचार बहुत स्पष्ट हैं। तो, अभिव्यक्ति, समीकरण की जड़ें $$$a (x) * b (x)$ जड़ों की समान समग्रता $$$(x)$ और $$$b (x)$ , इसी तरह विभाजन के लिए:

 internal static void Solve(Entity expr, VariableEntity x, EntitySet dst) { if (expr is OperatorEntity) { switch (expr.Name) { case "mul": Solve(expr.Children[0], x, dst); Solve(expr.Children[1], x, dst); return; case "div": Solve(expr.Children[0], x, dst); return; } } ... 

साइन के लिए, यह थोड़ा अलग दिखेगा:

 case "sinf": Solve(expr.Children[0] + "n" * MathS.pi, x, dst); return; 

आखिरकार, हम सभी जड़ों को ढूंढना चाहते हैं, और न कि केवल वे जो 0 हैं।

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

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

$$

$$\ sin (x) ^ 2 + \ sin (x) - 0.4 = 0$$

कोई टेम्पलेट नहीं है, लेकिन जोड़ी के लिए

$$

$$\ शुरू {मामलों} टी ^ 2 + टी - 0.4 = 0 \\ टी = \ पाप (एक्स) \ अंत {मामलों$$

यहां तक ​​कि यह मौजूद है।

इसलिए, हम GetMinimumSubtree प्रकार का एक फ़ंक्शन बनाते हैं, जो सबसे कुशल परिवर्तनीय प्रतिस्थापन लौटाएगा। एक प्रभावी प्रतिस्थापन क्या है? यह ऐसा प्रतिस्थापन है जिसमें हम

1. इस प्रतिस्थापन का उपयोग अधिकतम करें
   
2. पेड़ की गहराई को अधिकतम करें (ताकि समीकरण में $$$\ sin (\ sin (x)) ^ 2 + 3$ हमारे पास एक प्रतिस्थापन था $$$\ sin (\ sin (x))$ )
   
3. हम यह सुनिश्चित करते हैं कि इस प्रतिस्थापन के साथ हमने सभी संदर्भों को एक चर में बदल दिया है, उदाहरण के लिए, यदि समीकरण में $$$\ sin (x) ^ 2 + \ sin (x) + x$ हम एक प्रतिस्थापन करेंगे $$$t = \ sin (x)$ तब सब खराब हो जाएगा। इसलिए, इस समीकरण में, के लिए सबसे अच्छा प्रतिस्थापन $$$x$ यह है $$$x$ (अर्थात्, कोई अच्छा प्रतिस्थापन नहीं है), लेकिन उदाहरण के लिए $$$\ sin (x) ^ 2 + \ sin (x) + c$ हम सुरक्षित रूप से एक प्रतिस्थापन कर सकते हैं $$$t = \ sin (x)$ ।
   

समीकरण को बदलने के बाद बहुत सरल दिखता है।

बहुपद

तो, पहली बात हम करते हैं, हम expr.Expand() - expr.Expand() से छुटकारा पाने के लिए सभी ब्रैकेट खोलें $$$x (x + 2)$ में बदल रहा है $$$x ^ 2 + 2x$ । अब, खुलासे के बाद, हमें कुछ ऐसा मिलता है

$$

$$c + x ^ 3 + 3x ^ 2 - एक * x ^ 3 + x$$

विहित नहीं? फिर पहले हम प्रत्येक मोनोमियल के बारे में जानकारी इकट्ठा करते हैं, "रैखिक बच्चों" ( अंतिम लेख में) को लागू करते हैं और सभी शर्तों का विस्तार करते हैं।

हमारे पास मोनोमियल के बारे में क्या है? एक मोनोमियल कारकों का एक उत्पाद है, जिसमें से एक चर है, या एक चर की डिग्री और पूर्णांक का एक ऑपरेटर है। इसलिए, हम दो चर पेश करेंगे, एक में डिग्री होगी, और दूसरे में गुणांक होगा। अगला, बस कारकों के माध्यम से जाना, और हर बार हम यह सुनिश्चित करते हैं कि या तो वहाँ $$$x$ एक हद तक, या बिना किसी डिग्री के। यदि हम बाकू से मिलते हैं - हम अशक्त होकर लौटते हैं।


ठीक है, हमने एक शब्दकोश संकलित किया है जिसमें कुंजी एक डिग्री (पूर्णांक) है और मान एक मोनोमियल गुणांक है। यह वही है जो पिछले उदाहरण के लिए दिखता है:

 0 => c 1 => 1 2 => 3 3 => 1 - a 

यहां, उदाहरण के लिए, द्विघात समीकरण के समाधान का कार्यान्वयन

 if (powers[powers.Count - 1] == 2) { var a = GetMonomialByPower(2); var b = GetMonomialByPower(1); var c = GetMonomialByPower(0); var D = MathS.Sqr(b) - 4 * a * c; res.Add((-b - MathS.Sqrt(D)) / (2 * a)); res.Add((-b + MathS.Sqrt(D)) / (2 * a)); return res; } 

यह बिंदु अभी तक पूरा नहीं हुआ है (उदाहरण के लिए, आपको इसे क्यूबिक पॉलीओनियल के लिए सही ढंग से करने की आवश्यकता है), लेकिन सामान्य तौर पर यह यहां होता है ।

रिवर्स स्वीप

इसलिए, यहां हमने कुछ प्रकार के प्रतिस्थापन किए हैं $$$t = \ arcsin (x ^ 3 + a ^ 2)$ , और अब हम वहां से x प्राप्त करना चाहते हैं। यहां हमारे पास फ़ंक्शंस और ऑपरेटरों की एक कदम-दर-चरण तैनाती है, जैसे कि

$$

$$t = \ arcsin (x ^ 3 + a ^ 2)$$

$$

$$\ sin (t) = x ^ 3 + a ^ 2$$

$$

$$\ sin (t) - एक ^ 2 = x ^ 3$$

$$

$$(\ sin (t) - a ^ 2) ^ {\ frac {1} {3}} = x$$

कोड स्निपेट कुछ इस तरह दिखता है:

 switch (func.Name) { case "sinf": // sin(x) = value => x = arcsin(value) return FindInvertExpression(a, MathS.Arcsin(value), x); case "cosf": // cos(x) = value => x = arccos(value) return FindInvertExpression(a, MathS.Arccos(value), x); case "tanf": // tan(x) = value => x = arctan(value) return FindInvertExpression(a, MathS.Arctan(value), x); ... 

इन कार्यों के लिए कोड यहाँ है ।

सब कुछ, समीकरणों का अंतिम समाधान (अलविदा!) कुछ इस तरह दिखता है

1. यदि हम शून्य फ़ंक्शन या ऑपरेटर को जानते हैं, तो वहां समाधान भेजें (उदाहरण के लिए, यदि $$$a * b = 0$ उसके बाद हल (ए) और हल (बी) चलाएं
2. एक प्रतिस्थापन खोजें
3. यदि संभव हो तो एक बहुपद के रूप में हल करें
4. सभी समाधानों के लिए, अंतिम समाधान प्राप्त करने के लिए एक प्रतिस्थापन तैनात करें
5. यदि, एक बहुपद के रूप में, यह हल नहीं है और हमारे पास केवल एक चर है, तो हम इसे न्यूटन विधि द्वारा हल करते हैं

तो, आज हम हैं:

• कैश के कारण संकलित फ़ंक्शन को गति दें
• LaTeX में रेंडर किया गया
• हमने समीकरणों के मामलों का एक छोटा सा हिस्सा हल किया

मैं निश्चित रूप से एक निश्चित अभिन्न की संख्यात्मक गणना के बारे में बात नहीं करने जा रहा हूं, क्योंकि यह बहुत सरल है । मैंने पार्सिंग के बारे में बात नहीं की, क्योंकि पिछले लेख में मुझे इस बारे में आलोचना मिली थी। विचार अपने लिखने का था। फिर भी, इस बारे में बात करना आवश्यक है कि हम एक स्ट्रिंग से अभिव्यक्ति को कैसे पार्स करते हैं?
परियोजना यहाँ है ।





और यहाँ कुछ उदाहरण हैं जो हमने आज किए

 var x = MathS.Var("x"); var y = MathS.Var("y"); var expr = x.Pow(y) + MathS.Sqrt(x + y / 4) * (6 / x); Console.WriteLine(expr.Latexise()); >>> {x}^{y}+\sqrt{x+\frac{y}{4}}*\frac{6}{x} 

$$${x} ^ {y} + \ sqrt {x + \ frac {y} {4}} * \ frac {6} {x}$

 var x = MathS.Var("x"); var expr = MathS.Sin(x) + MathS.Sqrt(x) / (MathS.Sqrt(x) + MathS.Cos(x)) + MathS.Pow(x, 3); var func = expr.Compile(x); Console.WriteLine(func.Substitute(3)); >>> 29.4752368584034 

 Entity expr = "(sin(x)2 - sin(x) + a)(b - x)((-3) * x + 2 + 3 * x ^ 2 + (x + (-3)) * x ^ 3)"; foreach (var root in expr.Solve("x")) Console.WriteLine(root); >>> arcsin((1 - sqrt(1 + (-4) * a)) / 2) >>> arcsin((1 + sqrt(1 + (-4) * a)) / 2) >>> b >>> 1 >>> 2 >>> i >>> -i 

आपका ध्यान के लिए धन्यवाद!