बंधक COBOL और गणित। भाग 1

आइए इसका सामना करें: कोई भी भिन्नात्मक संख्या पसंद नहीं करता है - यहां तक ​​कि कंप्यूटर भी।

जब बात आती है COBOL प्रोग्रामिंग लैंग्वेज की, तो सबसे पहला सवाल जो हर किसी के सिर में उठता है, वह हमेशा इस तरह दिखता है: "मानवता अब भी कई महत्वपूर्ण क्षेत्रों में इस भाषा का उपयोग क्यों करती है?" बैंक अभी भी COBOL का उपयोग कर रहे हैं। यूएस सकल घरेलू उत्पाद का लगभग 7% सीएमएस से प्रसंस्करण भुगतान में COBOL पर निर्भर है। संयुक्त राज्य की आंतरिक राजस्व सेवा (आईआरएस), जैसा कि सभी जानते हैं, अभी भी COBOL का उपयोग करता है। इस भाषा का उपयोग विमानन में भी किया जाता है ( यहां से मैंने इस विषय पर एक दिलचस्प बात सीखी: हवाई टिकट पर आरक्षण संख्या एक सामान्य सूचक हुआ करती थी)। यह कहा जा सकता है कि कई बहुत गंभीर संगठन, चाहे वह एक निजी या सार्वजनिक क्षेत्र हो, अभी भी COBOL का उपयोग कर रहे हैं।



→ दूसरा भाग

सामग्री के लेखक, जिस अनुवाद का पहला भाग आज हम प्रकाशित करते हैं, वह इस सवाल का उत्तर खोजने जा रहा है कि 1959 में दिखाई देने वाली भाषा COBOL क्यों अभी भी इतनी व्यापक है।

COBOL अभी भी जीवित क्यों है?

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

यह सब तो है। लेकिन जब मैंने आईआरएस में काम किया, तो कोबोल के दिग्गजों ने बात की कि कैसे उन्होंने जावा में कोड को फिर से लिखने की कोशिश की और यह पता चला कि जावा सही तरीके से गणना नहीं कर सकता है।

यह मुझे बहुत अजीब लग रहा था। यह बहुत अजीब है कि मैंने तुरंत अलार्मिस्ट को सोचा: "भगवान, इसका मतलब है कि आईआरएस 50 वर्षों से सभी के लिए कर भुगतान बंद कर रहा है!" मैं बस विश्वास नहीं कर सकता था कि आईआरएस द्वारा आवश्यक गणितीय गणना के संदर्भ में COBOL जावा के आसपास प्राप्त करने में सक्षम है। अंत में - उन्होंने लोगों को अंतरिक्ष में लॉन्च नहीं किया।

गर्मियों में COBOL सीखने के दिलचस्प दुष्प्रभावों में से एक यह है कि मैंने निम्नलिखित को समझना शुरू किया। मुद्दा यह नहीं है कि जावा गणितीय गणना सही ढंग से नहीं कर सकता है। बिंदु वास्तव में है कि कैसे जावा गणना को सही बनाता है। और जब आप समझते हैं कि जावा में गणना कैसे की जाती है, और COBOL में समान कार्य कैसे किया जाता है, तो आप यह समझने लगते हैं कि कई संगठनों को अपने कंप्यूटर की विरासत से छुटकारा पाना इतना मुश्किल क्यों लगता है।

क्या "मैं" बिंदीदार होना चाहिए?

मैं COBOL कहानी से थोड़ा हटकर और कंप्यूटर के द्विआधारी प्रतिनिधित्व से पहले सूचनाओं को कैसे संग्रहीत करता है, इस बारे में बात करने जा रहा हूं कि यह वास्तव में मानक है (लेकिन z / OS इंटरफ़ेस का उपयोग कैसे किया जाए, यह कुछ विशेष है)। मुझे लगता है कि हमारे मुद्दे पर विचार करने से इस दिशा में मुख्य विषय से भटकना उपयोगी होगा। उपरोक्त सामग्री में, मैंने बाइनरी स्विच का उपयोग करने के विभिन्न तरीकों के बारे में बात की, जो बाइनरी, टर्नरी, दशमलव सिस्टम में संख्याओं को स्टोर करने के लिए, नकारात्मक संख्याओं को संग्रहीत करने के लिए - और इसी तरह। केवल एक चीज पर मैंने पर्याप्त ध्यान नहीं दिया कि दशमलव संख्या कैसे संग्रहीत की जाती है।

यदि आपने अपना बाइनरी कंप्यूटर डिज़ाइन किया है, तो आप यह तय करके शुरू कर सकते हैं कि आप बाइनरी नंबर सिस्टम का उपयोग करेंगे। बिंदु के बाईं ओर के बिट्स पूर्णांक - 1, 2, 4, 8 का प्रतिनिधित्व करते हैं। और बिट्स को दाईं ओर - भिन्नात्मक संख्या - 1/2, 1/4, 1/8 ...


बाइनरी प्रतिनिधित्व में 2.75

यहां समस्या यह समझने की है कि दशमलव बिंदु को कैसे स्टोर किया जाए (वास्तव में - मुझे "बाइनरी पॉइंट" कहना चाहिए - क्योंकि, आखिरकार, हम बाइनरी नंबर के बारे में बात कर रहे हैं)। यह किसी प्रकार का "कंप्यूटर कीमिया" नहीं है, इसलिए आप अच्छी तरह से अनुमान लगा सकते हैं कि मैं फ्लोटिंग पॉइंट नंबर और फिक्स्ड-पॉइंट नंबर के बारे में क्या बात कर रहा हूँ। फ्लोटिंग पॉइंट नंबरों में, एक बाइनरी पॉइंट को कहीं भी रखा जा सकता है (अर्थात, यह "फ्लोट" हो सकता है)। बिंदु की स्थिति को एक घातांक के रूप में संग्रहीत किया जाता है। एक बिंदु को स्थानांतरित करने की क्षमता इस तरह के अवसर की अनुपस्थिति में उपलब्ध संख्या की एक विस्तृत श्रृंखला को संग्रहीत करना संभव बनाती है। दशमलव बिंदु को संख्या के बहुत पीछे ले जाया जा सकता है और पूर्णांक मानों को संग्रहीत करने के लिए सभी बिट्स का चयन कर सकते हैं, बहुत बड़ी संख्याओं का प्रतिनिधित्व करते हैं। बिंदु को संख्या के सामने स्थानांतरित किया जा सकता है और बहुत छोटे मूल्यों को व्यक्त कर सकता है। लेकिन यह स्वतंत्रता सटीकता की कीमत पर आती है। आइए पिछले उदाहरण से 2.75 के द्विआधारी प्रतिनिधित्व पर एक और नज़र डालें। चार से आठ तक का संक्रमण एक चौथाई से एक आठवें तक के संक्रमण से बहुत अधिक है। यदि हम नीचे दिखाए गए उदाहरण को फिर से लिखें तो यह कल्पना करना हमारे लिए आसान हो सकता है।


मैंने आंख के द्वारा संख्याओं के बीच की दूरी को चुना - बस अपने विचार को प्रदर्शित करने के लिए

संख्याओं के बीच का अंतर अपने आप गणना करना आसान है। उदाहरण के लिए, 1/16 और 1/32 के बीच की दूरी 0.03125 है, लेकिन 1/2 और 1/4 के बीच की दूरी पहले से ही 0.25 है।

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

यह 0.1 (एक दसवां) संख्या के क्लासिक उदाहरण द्वारा चित्रित किया गया है। बाइनरी प्रारूप में इस संख्या का प्रतिनिधित्व कैसे करें? 2 ^-1 1/2, या 0.5 है। यह बहुत ज्यादा है। 1/16 0.0635 है। यह बहुत कम है। 1/16 + 1/32 पहले से ही करीब (0.09375) है, लेकिन 1/16 + 1/32 + 1/64 पहले से ही हमारी ज़रूरत (0.109375) से अधिक है।

यदि आप मानते हैं कि इस तर्क को अनिश्चित काल तक जारी रखा जा सकता है - तो आप सही हैं - जिस तरह से यह है ।

यहाँ आप खुद से कह सकते हैं: “हम सिर्फ उसी तरह से 0.1 नहीं बचाते हैं जिस तरह हम नंबर 1 को स्टोर करते हैं? हम बिना किसी समस्या के नंबर 1 को बचा सकते हैं - तो चलो बस दशमलव बिंदु को हटा दें और किसी भी संख्या को उसी तरह स्टोर करें जैसे हम पूर्णांक को संग्रहीत करते हैं। "

यह इस समस्या का एक उत्कृष्ट समाधान है, सिवाय इसके कि इसे कुछ पूर्व निर्धारित स्थान पर बाइनरी / दशमलव बिंदु को ठीक करने की आवश्यकता होती है। अन्यथा, 10.00001 और 100000.1 की संख्या बिल्कुल समान दिखेंगी। लेकिन अगर बिंदु तय किया जाता है, तो यह कहें कि, संख्या के आंशिक भाग को 2 अंक आवंटित किए जाते हैं, फिर हम 10.00001 से 10.00 तक गोल कर सकते हैं, और 100000.1 100000.10 हो जाएगा।

हम बस "निर्धारित बिंदुओं" का आविष्कार किया।

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


TI-84 प्लस कैलकुलेटर

मुलर और पायथन पुनरावृत्ति अनुपात

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

COBOL एक भाषा के रूप में बनाया गया था, जिसमें डिफ़ॉल्ट रूप से, निश्चित-बिंदु संख्याओं का उपयोग किया जाता है। लेकिन क्या इसका मतलब यह है कि गणितीय गणना करने के लिए COBOL आधुनिक भाषाओं से बेहतर है? यदि हम 0.1 + 0.2 मान की गणना के परिणाम जैसी समस्या को पकड़ते हैं, तो ऐसा लग सकता है कि पिछले प्रश्न का उत्तर "हाँ" में दिया जाना चाहिए। लेकिन यह उबाऊ होगा। तो चलिए आगे बढ़ते हैं।

हम तथाकथित मुलर के पुनरावृत्ति संबंध का उपयोग करके COBOL के साथ प्रयोग करने जा रहे हैं। जीन-मिशेल मुलर एक फ्रांसीसी वैज्ञानिक हैं जिन्होंने सूचना प्रौद्योगिकी के क्षेत्र में एक बड़ी वैज्ञानिक खोज की है। उन्होंने गणित का उपयोग करते हुए कंप्यूटर के सही संचालन को तोड़ने का एक तरीका पाया। मुझे यकीन है कि वह कहेगा कि वह विश्वसनीयता और सटीकता की समस्याओं का अध्ययन करता है, लेकिन नहीं और फिर से नहीं: वह गणितीय समस्याएं पैदा करता है जो कंप्यूटर को "तोड़" देते हैं। इन कार्यों में से एक इसका पुनरावृत्ति फार्मूला है। यह इस तरह दिखता है:


यह उदाहरण यहाँ से लिया गया है।

सूत्र बिल्कुल भी डरावना नहीं लगता। सच? यह कार्य निम्नलिखित कारणों से हमारे उद्देश्यों के लिए उपयुक्त है:

• गणित के केवल सरल नियमों का उपयोग यहां किया जाता है - कोई जटिल सूत्र या गहन विचार नहीं।
• हम एक संख्या के साथ शुरू करते हैं जिसमें दशमलव बिंदु के बाद दो अंक होते हैं। नतीजतन, यह कल्पना करना आसान है कि हम कुछ मात्रा में धन का प्रतिनिधित्व करने वाले मूल्यों के साथ काम कर रहे हैं।
• गणना के परिणामस्वरूप होने वाली त्रुटि एक छोटी गोलाई त्रुटि नहीं है। यह परिमाण के पूरे आदेशों के सही परिणाम से विचलन है।

यहाँ एक छोटी पायथन लिपि है जो फ्लोटिंग-पॉइंट और फिक्स्ड-पॉइंट संख्याओं का उपयोग करके मुलर के पुनरावृत्ति संबंध के परिणामों की गणना करती है:

from decimal import Decimal def rec(y, z):  return 108 - ((815-1500/z)/y)  def floatpt(N):  x = [4, 4.25]  for i in range(2, N+1):   x.append(rec(x[i-1], x[i-2]))  return x  def fixedpt(N):  x = [Decimal(4), Decimal(17)/Decimal(4)]  for i in range(2, N+1):   x.append(rec(x[i-1], x[i-2]))  return x N = 20 flt = floatpt(N) fxd = fixedpt(N) for i in range(N):  print str(i) + ' | '+str(flt[i])+' | '+str(fxd[i]) 

यहाँ इस स्क्रिप्ट का परिणाम है:

 i | floating pt  | fixed pt -- | -------------- | --------------------------- 0 | 4       | 4 1 | 4.25      | 4.25 2 | 4.47058823529 | 4.4705882352941176470588235 3 | 4.64473684211 | 4.6447368421052631578947362 4 | 4.77053824363 | 4.7705382436260623229461618 5 | 4.85570071257 | 4.8557007125890736342039857 6 | 4.91084749866 | 4.9108474990827932004342938 7 | 4.94553739553 | 4.9455374041239167246519529 8 | 4.96696240804 | 4.9669625817627005962571288 9 | 4.98004220429 | 4.9800457013556311118526582 10 | 4.9879092328  | 4.9879794484783912679439415 11 | 4.99136264131 | 4.9927702880620482067468253 12 | 4.96745509555 | 4.9956558915062356478184985 13 | 4.42969049831 | 4.9973912683733697540253088 14 | -7.81723657846 | 4.9984339437852482376781601 15 | 168.939167671 | 4.9990600687785413938424188 16 | 102.039963152 | 4.9994358732880376990501184 17 | 100.099947516 | 4.9996602467866575821700634 18 | 100.004992041 | 4.9997713526716167817979714 19 | 100.000249579 | 4.9993671517118171375788238 

पुनरावृत्ति 12 तक, राउंडिंग त्रुटि अधिक या कम महत्वहीन लगती है, लेकिन फिर असली नरक शुरू होता है। फ़्लोटिंग-पॉइंट गणना एक संख्या में परिवर्तित होती है जो निर्धारित-पॉइंट गणना से परिणाम से बीस गुना बड़ी होती है।

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

मुसीबत यह है कि राम के पास कंप्यूटर की मात्रा अनंत नहीं है। इसलिए, अनंत संख्या में दशमलव (या बाइनरी) पदों को संग्रहीत करना असंभव है। फिक्स्ड-पॉइंट गणना फ़्लोटिंग-पॉइंट गणनाओं से अधिक सटीक हो सकती है यदि विश्वास है कि यह कम संभावना है कि उपयोग किए गए प्रारूप की तुलना में बिंदु के बाद अधिक संख्याओं की आवश्यकता होगी। यदि इस प्रारूप में संख्या फिट नहीं होती है, तो इसे गोल किया जाएगा। यह ध्यान दिया जाना चाहिए कि न तो निश्चित-बिंदु गणना और न ही फ्लोटिंग-पॉइंट गणना उस समस्या से सुरक्षित हैं जो मुलर के पुनरावृत्ति संबंध प्रदर्शित करता है। परिणामस्वरूप, दोनों और अन्य गलत परिणाम देते हैं। सवाल यह है कि ऐसा कब होता है। यदि आप पायथन लिपि में पुनरावृत्तियों की संख्या में वृद्धि करते हैं, उदाहरण के लिए, 20 से 22 तक, तो एक निश्चित बिंदु के साथ गणना में प्राप्त अंतिम संख्या 0.728107 होगी। 23 पुनरावृत्तियों? -५०१.७०,८१,२६१। 24? १०५.८५,९८,१८७।

विभिन्न भाषाओं में, यह समस्या अलग-अलग तरीकों से प्रकट होती है। कुछ, जैसे COBOL, आपको उन संख्याओं के साथ काम करने की अनुमति देता है जिनके पैरामीटर कसकर सेट होते हैं। और पायथन में, उदाहरण के लिए, डिफ़ॉल्ट मान हैं जिन्हें कॉन्फ़िगर किया जा सकता है यदि कंप्यूटर में पर्याप्त मेमोरी है। अगर हम अपने प्रोग्राम में लाइन getcontext().prec = 60 को हमारे प्रोग्राम में, पायथन दशमलव मॉड्यूल को बताते हुए कि यह अवधि के बाद 60 पदों का उपयोग करेगा, और 28 नहीं, जैसा कि डिफ़ॉल्ट रूप से किया जाता है, प्रोग्राम त्रुटियों के बिना पुनरावृत्ति संबंध के 40 पुनरावृत्तियों को करने में सक्षम होगा। मुलर।

जारी रखने के लिए ...

प्रिय पाठकों! क्या आपने फ्लोटिंग-पॉइंट गणनाओं की प्रकृति से उत्पन्न गंभीर समस्याओं का सामना किया है?