गणित मूल्यांकक

पूरी समस्या प्राथमिकता की है

2 + 3 * 4 पढ़ने के लिए यह जानना ज़रूरी है कि गुणा जोड़ से ज़्यादा मजबूती से बँधता है, इसलिए उत्तर 20 के बजाय 14 है। हर ऑपरेटर का एक प्राथमिकता स्तर और एक साहचर्य होता है। गुणा, भाग और शेषफल ऑपरेटर जोड़ और घटाव से ऊपर आते हैं; घातांक इन सबसे ऊपर है और दाएँ-साहचर्य है, इसलिए 2^3^2 का अर्थ 2^(3^2) है और यह 64 नहीं, 512 देता है।

यूनरी माइनस सूक्ष्म मामला है। गणितीय परंपरा इसे घातांक से नीचे रखती है, इसीलिए -3^2 का मान -9 है: घात 3 पर लागू होती है और ऋणात्मकता नतीजे पर। स्प्रेडशीट सॉफ़्टवेयर मशहूर तौर पर असहमत है और 9 देता है, इसलिए यदि आपने कभी एक ही फ़ॉर्मूले पर दो टूल से अलग उत्तर देखे हों, तो कारण आम तौर पर यही होता है। यह मूल्यांकक गणितीय परंपरा का पालन करता है।

कोष्ठक इन सब पर भारी पड़ते हैं, और उन्हें खुलकर इस्तेमाल करना चाहिए। जिस एक्सप्रेशन को पढ़ने के लिए प्राथमिकता तालिका चाहिए, वह एक्सप्रेशन कभी न कभी ग़लत पढ़ा ही जाएगा।

shunting-yard, संक्षेप में

एक्सप्रेशन को पहले टोकन में तोड़ा जाता है - संख्याएँ, नाम, ऑपरेटर और विराम चिह्न - और फिर Dijkstra के shunting-yard एल्गोरिद्म से पोस्टफ़िक्स रूप में क्रमबद्ध किया जाता है, जहाँ ऑपरेटर अपने ऑपरैंड के बाद आते हैं। 2 + 3 * 4 बन जाता है 2 3 4 * +। पोस्टफ़िक्स को न कोष्ठक चाहिए और न प्राथमिकता नियम, क्योंकि टोकन का क्रम ही संरचना बता देता है, इसलिए एक साधारण स्टैक मशीन उसे एक ही पास में हल कर सकती है।

एल्गोरिद्म दो संरचनाएँ रखता है: एक आउटपुट सूची और एक ऑपरेटर स्टैक। संख्याएँ सीधे आउटपुट में जाती हैं; कोई ऑपरेटर खुद पुश होने से पहले स्टैक पर पड़े हर ऐसे ऑपरेटर को पॉप करता है जो कम से कम उतनी ही मजबूती से बँधता है। कोष्ठक स्टैक पर निशान की तरह काम करते हैं, और बंद कोष्ठक अपने जोड़े तक सब कुछ पॉप कर देता है। फ़ंक्शन कॉल ऐसे ऑपरेटर की तरह साथ चलते हैं जिनकी तर्क-गिनती हर अल्पविराम पर बढ़ती जाती है।

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

फ़्लोटिंग पॉइंट, ईमानदारी से

नतीजे IEEE 754 डबल प्रिसीज़न में गिने जाते हैं — वही गणित जो हर ब्राउज़र और बहुत सी प्रोग्रामिंग भाषाएँ उपयोग करती हैं। यह संख्याएँ बाइनरी में रखता है, और 0.1 जैसे दशमलव भिन्न का कोई सटीक बाइनरी रूप नहीं होता, इसीलिए 0.1 + 0.2 मशहूर तौर पर 0.3 के बजाय 0.30000000000000004 देता है।

प्रदर्शन को तय संख्या के सार्थक अंकों तक गोल करना इस शोर को छिपा देता है, अंतर्निहित मान बदले बिना — और यही काम यहाँ प्रिसीज़न नियंत्रण करता है। इसे 12 पर रखने से उत्तर पठनीय रहता है और उन 15 से 17 अंकों से पहले भरपूर जगह बची रहती है जिन्हें डबल वास्तव में अलग कर सकता है।

दो सीमाएँ याद रखने लायक हैं। पूर्णांक केवल 2^53 तक सटीक रहते हैं, इसलिए बहुत बड़े फ़ैक्टोरियल और गुणनफल भटक जाते हैं; 170! से ऊपर कुछ भी सीधे अनंत में बह जाता है। और लगभग बराबर दो संख्याओं को घटाना परिशुद्धता नष्ट कर देता है - अग्रणी अंक कट जाते हैं और केवल शोर भरे अंतिम अंक बचते हैं - इसलिए उस घटाव से बचने के लिए पुनर्व्यवस्थित फ़ॉर्मूला अक्सर स्पष्ट रूप से लिखे फ़ॉर्मूले से बहुत ज़्यादा सटीक होता है।