wolfram-mathematica
मूल्यांकन आदेश
खोज…
टिप्पणियों
यह मूल्यांकन आदेश को यथासंभव स्पष्ट रूप से व्याख्या करने के लिए माना जाता है। यह शायद कम आदर्श रूप से गणितज्ञ निष्पादन के लिए एक परिचय के रूप में अनुकूल है। यह मैथेमेटिका के tutorial/Evaluation पृष्ठ पर उस आदेश की व्याख्या करके बनाता है जिसमें विभिन्न नियमों को लागू किया जाता है और यह समझाते हुए कि मूल्यांकन इंजन द्वारा विशेष रूप से कौन से कार्य किए जाते हैं।
मूल्यांकन संदर्भ
किसी भी बिंदु पर, कोड एक संदर्भ में निष्पादित हो रहा है। एक संदर्भ में प्रतिस्थापन नियमों (इसका शब्दकोश) का एक सेट होता है, और एक प्राथमिकता जिसमें उनका मूल्यांकन किया जाना चाहिए। हम अलग-अलग व्यवहार और प्रतिबंधों के साथ पांच प्रकार के समूह बनाते हैं: * संदर्भ सेट करें * ब्लॉक संदर्भ * मिलान प्रसंग * प्रतिलक्ष संदर्भ * प्रतिस्थापना प्रसंग
संदर्भ सेट करें
एक सेट संदर्भ वह है जो सेट के कुछ सेटों द्वारा परिभाषित किया गया है [] संचालन (अधिक सामान्यतः लिखा = ) फ़ंक्शन। मुख्य उदाहरण प्राथमिक निष्पादन वातावरण है। जब भी सेट [] एक चर पर चलाया जाता है तो इसका शब्दकोश संशोधित होता है जो अन्यथा स्कोप नहीं होता है। सेट कॉन्टेक्ट्स के अन्य उदाहरण पैकेज से उत्पन्न होते हैं। एक पैकेज संदर्भ इसके मूल संदर्भ से संबंधित है कि पैकेज के भीतर कोई भी पैटर्न मूल संदर्भ के भीतर भी पैटर्न बन जाता है, एक उपयुक्त उपसर्ग (एक परिभाषा foo[x_]=3*x हो जाता है InnerPackageName\ foo [x _] - 3 * x) `)।
सेट कॉन्टेक्ट में केवल वे नियम हो सकते हैं जिनमें एक संबद्ध "टैग" हो, नियम से अधिक तेज़ी से पहचान करने के लिए सिर से जुड़ा एक स्ट्रिंग। Set[yyy_,zzz_] का एक अनुप्रयोग Set[yyy_,zzz_] यह जांच कर टैग निर्धारित करेगा कि क्या yyy एक प्रतीक है। अगर यह है, तो यह टैग है। अन्यथा, यह yyy[[0]] जांच करता है, फिर yyy[[0,0]] , और इसी तरह। यदि किसी बिंदु पर यह एक प्रतीक होने के लिए निर्धारित किया जाता है, तो वह टैग के रूप में लिया जाता है। यदि यह एक गैर-प्रतीक परमाणु (जैसे स्ट्रिंग, इंटेगर, रियल ...) के बजाय है, तो यह एक त्रुटि फेंक देगा और कोई नियम नहीं बनाया जाएगा।
कार्य उपसेट (लिखित ^= ) और टैगसेट (लिखित /: / = ) (और उनके चचेरे भाई उपसेटलेड और टैगसेटलेट) एक अलग टैग के साथ एक नियम को जोड़ने की अनुमति देते हैं। अभी भी प्रतिबंध है कि टैग का प्रतीक होना चाहिए। UpSet इसे अभिव्यक्ति के प्रत्येक तर्कों या उनके सिर के साथ जोड़ देगा यदि वे एक सिर के लिए एक प्रतीक के साथ एक फ़ंक्शन हैं। उदाहरण के लिए, पर परेशान बुला f[a,b,c+d,e[f,g],5,h[i][j][k],p_] के साथ बनाया शासन से संबद्ध कर देगा a , b , e , और h । c+d , 5 , और p_ तर्कों में उनके साथ कुछ भी जुड़ा नहीं होगा, और त्रुटि संदेश प्रदर्शित होने का कारण होगा। असाइनमेंट अभी भी प्रत्येक तर्क पर सफल होगा, और (जैसा कि मूल्यांकन आदेश में बाद में स्पष्ट किया जाएगा) यह अभी भी लगभग सभी उद्देश्यों के लिए काम करेगा। TagSet UpSet की तरह है, लेकिन आप टैग के लिए एक प्रतीक निर्दिष्ट कर सकते हैं। प्रतीक अभी भी कुछ ऐसा होना चाहिए जो सेट या अपसेट (सिर या तर्कों में शीर्ष-स्तरीय प्रतीक) द्वारा सेट किया जा सके। उदाहरण के लिए, TagSet[f, f[a,b[c]], 2] स्वीकार्य है और परिभाषा को f साथ जोड़ देगा; TagSet[a, f[a,b[c]], 2] और TagSet[b, f[a,b[c]], 2] भी स्वीकार्य हैं, लेकिन TagSet[c, f[a,b[c]], 2] नहीं है।
एक संदर्भ में नियमों के लिए एक आवेदन प्राथमिकता की आवश्यकता होती है, क्योंकि कई नियम हो सकते हैं जो किसी दिए गए अभिव्यक्ति पर लागू होते हैं। (यह रिप्लेसमेंट और रिप्लेसेप्ड कंटेस्टेंट्स में भी सही है, लेकिन वे इसे बहुत अलग तरीके से हैंडल करते हैं)। प्राथमिकता आमतौर पर पैटर्न की विशिष्टता के अनुरूप होती है। मूल्यांकन करने के लिए a[q][b[c,d],e[f,g]] को देखते हुए, सिर और तर्कों के साथ सभी का पूरी तरह से मूल्यांकन किया जाता है कि वे क्या होंगे (TODO के नीचे देखें), नियमों की तलाश में शुरू किए गए टैग b साथ कि लागू; तब e साथ टैग किए गए नियम; उसके बाद नियमों को टैग किया a । नियमों के प्रत्येक सेट के भीतर, दिए गए प्रतीक से जुड़े लोगों पर एक आदेश बनाए रखा जाता है। बिना किसी रिक्त स्थान वाले नियम (जैसे f[a,b]=3 ) को स्वचालित रूप से शीर्ष पर रखा जाता है और विहित आदेश (सॉर्ट का क्रम) में क्रमबद्ध किया जाता है। हर बार एक नया नियम जोड़ा जाता है, कर्नेल सूची से गुजरेगा; यदि कुछ नियम में समान LHS है, तो यह जगह-जगह हो जाता है। अन्यथा, यह एक विशिष्टता की तुलना करता है। यदि सूची में पहले से मौजूद एक नियम X, नए नियम Y की तुलना में "कम विशिष्ट" होना निर्धारित किया जाता है, तो Y को X के ठीक पहले रखा जाता है। अन्यथा, यह सूची के माध्यम से जारी रहता है। यदि कोई नियम कम विशिष्ट नहीं है, तो नियम को सूची के अंत में रखा गया है। विशिष्टता की जाँच अधिक जटिल है और नीचे अनुभाग में अधिक विस्तार से दी गई है।
नियम विशिष्टता
* यदि दो भाव BlankSequence (का कोई उदाहरण नहीं है __ ), BlankNullSequence ( ___ ), वैकल्पिक ( : ), वैकल्पिक ( | ), बार-बार ( .. ), RepeatedNull ( ... ), या वैकल्पिक तर्क ( _. ), तो उनकी तुलना संरचनात्मक रूप से की जा सकती है। दो समान अभिव्यक्ति वाले पेड़ों X और Y को देखते हुए, जहां Y में सभी रिक्तियां भी X में रिक्त हैं, लेकिन X में रिक्त स्थान हैं जहां Y नहीं है, तो Y अधिक विशिष्ट है। * यदि दो अभिव्यक्तियाँ समान हैं सिवाय इसके कि _ कुछ उदाहरणों को अन्य अभिव्यक्ति में __ साथ बदल दिया गया है, या __ को ___ बदल दिया गया है, तो पूर्व अधिक विशिष्ट है। * एक और वैकल्पिक अलग करना है ( : ) (या वैकल्पिक _. ) नियमों अन्य अभिव्यक्ति देता है, तो बाद के अधिक विशिष्ट है। * यदि विकल्पों में से विकल्पों का एक निश्चित सेट अन्य अभिव्यक्ति देता है, तो बाद वाला अधिक विशिष्ट है। * यदि के सभी उदाहरणों की जगह RepeatedNull[foo] के साथ Repeated[foo] , या Repeated[foo] के साथ foo , अन्य अभिव्यक्ति तो देता है उत्तरार्द्ध अधिक विशिष्ट * इन नियमों में से कुछ combations एक ही बार में लागू किया जा सकता है, लेकिन यह अभी नहीं है जानते हैं कि इसके लिए क्या मामले हैं। * अभिव्यक्ति के संयोजन जैसे कि _List और {___} सैद्धांतिक रूप से उन्हें पहचान के साथ व्यवहार करना चाहिए, लेकिन तुलना अजीब संदर्भ-निर्भर प्रतीत होती है, कभी-कभी उन्हें एक या दूसरे तरीके से रैंकिंग करते हैं।
ब्लॉक प्रसंग
एक ब्लॉक संदर्भ अधिक प्रतिबंधक है, जिसमें ब्लॉक में एक नियम का एलएचएस केवल एक प्रतीक हो सकता है। अर्थात्, केवल f=2+x के रूप की परिभाषा, न कि f[x_]=2+x । (ध्यान दें कि, व्यावहारिक दृष्टिकोण से, कार्यों का निर्माण अभी भी परिभाषाओं के साथ किया जा सकता है जैसे `सेट [ब्लॉक] इसके मूल संदर्भ से संबंधित है कि ब्लॉक के मूल्यांकन के दौरान किसी भी नई परिभाषा को सामान्य के रूप में घिरे संदर्भ के लिए अग्रेषित किया जाता है, लेकिन यह कुछ प्रकार के चर का "छाया" करेंगे, जो परिभाषा प्रदान करते हैं जो आसपास के संदर्भ को छिपा सकते हैं। आसपास के संदर्भ से परिभाषाएं आंतरिक अभिव्यक्ति के मूल्यांकन के दौरान अभी भी सुलभ हैं। क्योंकि केवल एक प्रतीक से जुड़ी परिभाषा हो सकती है, कोई धारणा नहीं है। ऊपर की तरह प्राथमिकता।
मिलान किया गया
एक नियम के मिलान के बाद, चरों के लिए स्थानीय रूप से बाध्य परिभाषाएँ हैं। यह शाब्दिक रूप से होता है । यह कहना है, यह अभिव्यक्ति में चर के लिए बाध्य परिभाषाओं में, कुछ और का मूल्यांकन किए बिना। केवल एक बार सभी उपसमुच्चय होने के बाद, यह अभिव्यक्ति का मूल्यांकन करना शुरू कर देता है, एक पूरे के रूप में, ऊपर से फिर से। मिलान किए गए कॉन्टेक्ट्स का प्राथमिक तरीका सेट संदर्भ या नियम से एक नियम है। उदाहरण के लिए, में
g[a_]:=a+x;
f[x_]:=x+g[1];
f[x^2]
(*Yields 1+x+x^2 *)
f[x_] नियम को f[y] , प्रतीक x मान x^2 लिए बाध्य है। यह एक प्रतिस्थापन करता है, लेकिन क्योंकि यह g मूल्यांकन नहीं करता है, इसलिए यह x^2+g[1] । इसके बाद आसपास के सेट संदर्भ में फिर से मूल्यांकन किया जाता है और 1+x+x^2 हो जाता है। एक मिलान संदर्भ में मूल्यांकन में महत्वपूर्ण अंतर यह है कि प्रतिस्थापन पुनरावर्ती नहीं है । जब यह x->x^2 करता है, तो यह अपने परिणामों पर भी नहीं दोहराता है।
मेल खाने वाले संदर्भ भी द्वारा बनाई गई हैं With , Module , Function , और Replace विशेष रूप से। कई अन्य कार्य उन्हें आंतरिक रूप से बनाते हैं, उदाहरण के लिए, Plot की अभिव्यक्ति के मूल्यांकन में Plot इस प्रकार के संदर्भ का उपयोग करता है।
रिप्लेसमेंट ने प्रसंग को बदल दिया
रिप्लेसमेंट रिपीटेड के किसी भी एप्लिकेशन के होने पर ReplaceRepeated बनाया जाता है। यह अलग है कि इसमें एक नियम LHS के रूप में कोई भी अभिव्यक्ति हो सकती है, जिसमें कोई टैग नहीं है, जैसे कि _[_] । इस अर्थ में यह सबसे लचीला संदर्भ है। इसमें कई नियम भी शामिल हो सकते हैं जो संघर्ष कर सकते हैं, इसलिए इसे प्राथमिकता को बनाए रखना चाहिए। एक रिप्लेस्ड कंटेस्टेंट जहां भी लागू होगा, सूची में पहला नियम पहले लागू करेगा। यदि यह मिलान करने में विफल रहता है, तो यह दूसरे तक आगे बढ़ता है, और इसी तरह। यदि किसी बिंदु पर एक नियम मेल खाता है, तो वह पहले नियम पर लौटता है और फिर से शुरू होता है। यदि किसी बिंदु पर कोई नियम लागू होता है और कोई परिवर्तन नहीं होता है, तो यह बाहर निकल जाएगा - भले ही सूची में अन्य नियम बाद में कोई बदलाव करें। इसका मतलब यह है कि सूची में पहले से कम विशिष्ट नियम बाद के नियमों को कभी भी उपयोग करने से रोकेंगे। इसके अतिरिक्त, नियम सूची के सामने a_->a रखने से पूरे ReplaceRepeated की तत्काल समाप्ति हो ReplaceRepeated ।
प्रतिस्थापन सभी संदर्भ
जब कोई भी ReplaceAll होता है, तो एक रिप्लेसमेंट संदर्भ बनाया जाता है। इसकी कार्यप्रणाली रिप्लेसमेंट के समान है कि इसकी नियम आवेदन प्राथमिकता सूची में क्रम में जाती है जब दो अभिव्यक्ति के समान स्तर पर दोनों लागू हो सकते हैं। हालाँकि, यह एक मिलान संदर्भ की तरह है कि प्रतिस्थापित सामग्री का आगे मूल्यांकन नहीं किया जाता है, बाद के नियमों द्वारा भी नहीं । उदाहरण के लिए x/.{x->y,y->z} पैदावार y । इस प्रकार, यह बदले में प्रत्येक नियम को लागू करने के लिए रिप्लेसमेंट के एक आवेदन को देखना गलत है। इसके बजाय, यह लागू नियमों की तलाश में पेड़ का पता लगाता है। जब यह कुछ ऐसा पाता है जो मेल खाता है, यह प्रतिस्थापन को क्रियान्वित करता है, तो पेड़ को वापस करता है, बिना नए पेड़ को काटे। यह भी ध्यान देने योग्य है कि यह ऊपर से नियमों को लागू करने का प्रयास करता है, संभवतः परिणामस्वरूप सूची के क्रम से बाहर जा रहा है। उदाहरण के लिए,
Cos[1 + 2 Sqrt[Sin[x]]] /. {Cos[_] -> 5, Sin[_] :> (Print[1]; 10)}
Cos[1 + 2 Sqrt[Sin[x]]] /. {Sin[_] :> (Print[1]; 10), Cos[_] -> 5}
दोनों कुछ भी छपाई के बिना 5 उपज। क्योंकि Cos[_] पेड़ के उच्च स्तर से मेल खाता है, इसलिए यह पहले लागू होता है।
Hold और Evaluate और निष्पादन आदेश
मूल्यांकन का क्रम, एक अभिव्यक्ति देते हुए, आगे बढ़ता है: * जितना संभव हो सके सिर का मूल्यांकन करें * यदि सिर में एक Hold प्रॉपर्टी ( HoldFirst , HoldRest , HoldAll , HoldAllComplete ) है, तो * प्रासंगिक तर्कों की जांच करें। जब तक कि यह HoldAllComplete न हो HoldAllComplete , जांच लें कि क्या सिर का Evaluate । यदि यह है, तो Evaluate को Evaluate और इसे वैसे भी मूल्यांकन करने के लिए चिह्नित करें। * Unevaluated उदाहरणों के लिए तर्कों की जाँच करें और उन्हें आवश्यक रूप से पट्टी करें, जब तक कि प्रॉपर्टी HoldAllComplete न हो। Sequence एस से सपाट तर्क, जब तक SequenceHold लागू नहीं किया जाता है। * लागू विशेषताओं Flat , Listable , लागू के रूप में Orderless । * तर्क के स्तर (उनके टैग) से जुड़े मूल्यांकन को लागू करें * सिर से जुड़े मूल्यांकन को लागू करें।
जब किसी अभिव्यक्ति का मूल्यांकन पूरा हो जाता है, तो इसे पूरी तरह से मूल्यांकन के रूप में चिह्नित किया जाता है। इसके बाद के मूल्यांकन जो उस अभिव्यक्ति से टकराते हैं, वह इसका मूल्यांकन करने की कोशिश नहीं करेंगे। यदि एक नया नियम एक प्रतीक पर परिभाषित किया गया है जो अंदर होता है, तो ध्वज को हटा दिया जाता है, और इसे फिर से मूल्यांकन किया जा सकता है। उल्लेखनीय स्थान जो इस 'विफल' Condition साथ है ( \; ): एक सशर्त नियम संभवतः प्रारंभिक मूल्यांकन पर लागू नहीं हो सकता है। यदि एक असंबंधित प्रतीक मूल्यों को बदलता है और अब स्थिति लागू होती है, तो अभिव्यक्ति अभी भी पूरी तरह से मूल्यांकन की जाती है, और परिणामस्वरूप नहीं बदलेगी। फ़ंक्शन Update इस मायने में अद्वितीय है कि यह अपने पहले से मूल्यांकित स्थिति की परवाह किए बिना अपने तर्क का मूल्यांकन करेगा या नहीं, "कैश फ्लश" प्रकार के लिए मजबूर करता है।
अन्य कार्यों के एक नंबर है कि अक्सर असाधारण, इस तरह के रूप में माना जाता हैं Hold , Defer , ReplacePart , Extract , या ReleaseHold । इन प्रभावों को सभी विशेषताओं (जैसे HoldAll ) और सामान्य फ़ंक्शन परिभाषा के माध्यम से प्राप्त किया जा सकता है, और मूल्यांकनकर्ता द्वारा विशिष्ट रूप से नियंत्रित करने की आवश्यकता नहीं है।
`रिप्लेसमेंट` और` रिप्लेसमेंट` के आवेदन
ReplaceAll कैसे ReplaceAll उदाहरण केवल एक बार में एक नियम लागू होता है, जबकि ReplaceRepeated एक लूप में ऐसा करेगा लेकिन हमेशा पहले नियम से आवेदन को पुनरारंभ करें।
x + a /. {
a_ + z :> (Print[0]; DoneA),
a_ + x :> (Print[1]; y + z),
a_ + y :> (Print[2]; DoneB)}
(* Prints "1", yields "y+z" *)
x + a //. {
a_ + z :> (Print[0]; DoneA),
a_ + x :> (Print[1]; y + z),
a_ + y :> (Print[2]; DoneB)}
(* Prints "1", then prints "0", yields "DoneA" *)
बबल शॅाट
नियम और प्रतिस्थापन के साथ बुलबुला छँटाई:
list = {1, 4, 2, 3, 6, 7, 8, 0, 1, 2, 5, 4}
list //. {fsts___, x_, y_, lsts___} :> {fsts, y, x, lsts} /; y < x
(*
Out[1] := {1, 4, 2, 3, 6, 7, 8, 0, 1, 2, 5, 4}
Out[1] := {0, 1, 1, 2, 2, 3, 4, 4, 5, 6, 7, 8}
*)