एरलांग में मनमानी परिशुद्धता के अंकगणित

@rawpixel

यहां तक ​​कि स्कूली बच्चों को विभिन्न संख्या प्रणालियों के अस्तित्व के बारे में पता है और यह तथ्य कि प्रत्येक परिमित दशमलव अंश बाइनरी संख्या प्रणाली में एक परिमित अंश नहीं है। कुछ लोगों को लगता है कि इस तथ्य के कारण, फ्लोट और डबल पर ऑपरेशन सटीक नहीं हैं।

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

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

मानकों, मानकों, मानकों ...

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

• एकल-सटीक 32 बिट्स
• डबल-सटीक 64 बिट्स
• एकल-विस्तारित परिशुद्धता> = 43 बिट्स (शायद ही कभी उपयोग किया जाता है)
• डबल-विस्तारित परिशुद्धता> = 79 बिट्स (आमतौर पर 80 बिट्स का उपयोग किया जाता है)
  और चार दौर मोड:
• गोलाई, निकटतम पूरे में झुकाव।
• राउंडिंग का रुझान शून्य तक।
• राउंडिंग की प्रवृत्ति + + तक
• गोलाई -∞ की ओर

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

जैसा कि ऊपर उल्लेख किया गया है, IEEE754 प्रारूप में संख्या एक परिमित सेट है जिस पर वास्तविक संख्याओं का एक अनंत सेट मैप किया जाता है, इसलिए मूल संख्या को IEEE754 प्रारूप में त्रुटि के साथ प्रस्तुत किया जा सकता है।

एक परिमित सेट पर प्रदर्शित होने पर संख्याओं के थोक में एक स्थिर और छोटी सापेक्ष त्रुटि होती है। तो, फ्लोट के लिए यह 11.920928955078125e-6% है, और डबल के लिए - 2.2204460492503130808472633361816e-14% है। प्रोग्रामर के जीवन में, अधिकांश रोजमर्रा के कार्य जिन्हें हल किया जा सकता है, हमें इस त्रुटि की उपेक्षा करने की अनुमति देते हैं, हालांकि यह ध्यान दिया जाना चाहिए कि साधारण कार्यों में भी आप रेक पर कदम रख सकते हैं, क्योंकि पूर्ण त्रुटि का परिमाण क्रमशः फ्लोट और डबल के लिए 10 ³¹ और ³⁰² तक पहुंच सकता है, जिससे गणना में कठिनाई हो सकती है।

प्रभाव चित्रण

सामान्य जानकारी से लेकर व्यवसाय तक। आइए एर्लैंग में उभरते प्रभावों को पुन: उत्पन्न करने का प्रयास करें।

नीचे दिए गए सभी उदाहरण सीटी-टेस्ट के रूप में तैयार किए गए हैं।

गोलाई और सटीकता की हानि

क्लासिक्स से शुरू करते हैं - दो संख्याओं का जोड़: 0.1 + 0.2 = ?:

t30000000000000004(_)-> ["0.30000000000000004"] = io_lib:format("~w", [0.1 + 0.2]). 

जोड़ का परिणाम सहज रूप से अपेक्षित एक से थोड़ा अलग है, और परीक्षण सफलतापूर्वक गुजरता है। आइए सही परिणाम प्राप्त करने का प्रयास करें। EAPA का उपयोग करके परीक्षण फिर से करें:

 t30000000000000004_eapa(_)-> %% prec = 1 symbols after coma X = eapa_int:with_val(1, <<"0.1">>), Y = eapa_int:with_val(1, <<"0.2">>), <<"0.3">> = eapa_int:to_float(1, eapa_int:add(X, Y)). 

यह परीक्षण भी सफल होता है, यह दर्शाता है कि समस्या हल हो गई है।
चलिए प्रयोग जारी रखते हैं, 1.0 में बहुत कम मूल्य जोड़ें:

 tiny(_)-> X = 1.0, Y = 0.0000000000000000000000001, 1.0 = X + Y. 

जैसा कि आप देख सकते हैं, हमारी वृद्धि पर किसी का ध्यान नहीं गया। हम समस्या को ठीक करने की कोशिश कर रहे हैं, साथ ही पुस्तकालय की विशेषताओं में से एक को दर्शाते हुए - स्वचालित स्केलिंग:

 tiny_eapa(_)-> X1 = eapa_int:with_val(1, <<"1.0">>), X2 = eapa_int:with_val(25, <<"0.0000000000000000000000001">>), <<"1.0000000000000000000000001">> = eapa_int:to_float(eapa_int:add(X1, X2)). 

बिट ग्रिड ओवरफ्लो

छोटी संख्या से जुड़ी समस्याओं के अलावा, अतिप्रवाह एक स्पष्ट और महत्वपूर्ण समस्या है।

 float_overflow(_) -> 1.0 = 9007199254740991.0 - 9007199254740990.0, 1.0 = 9007199254740992.0 - 9007199254740991.0, 0.0 = 9007199254740993.0 - 9007199254740992.0, 2.0 = 9007199254740994.0 - 9007199254740993.0. 

जैसा कि आप परीक्षण से देख सकते हैं, कुछ बिंदु पर अंतर 1.0 के बराबर होना बंद हो जाता है, जो स्पष्ट रूप से एक समस्या है। EAPA भी इस समस्या का हल:

 float_overflow_eapa(_)-> X11 = eapa_int:with_val(1, <<"9007199254740992.0">>), X21 = eapa_int:with_val(1, <<"9007199254740991.0">>), <<"1.0">> = eapa_int:to_float(1, eapa_int:sub(X11, X21)), X12 = eapa_int:with_val(1, <<"9007199254740993.0">>), X22 = eapa_int:with_val(1, <<"9007199254740992.0">>), <<"1.0">> = eapa_int:to_float(1, eapa_int:sub(X12, X22)), X13 = eapa_int:with_val(1, <<"9007199254740994.0">>), X23 = eapa_int:with_val(1, <<"9007199254740993.0">>), <<"1.0">> = eapa_int:to_float(1, eapa_int:sub(X13, X23)). 

खतरनाक कमी

निम्न परीक्षण एक खतरनाक कमी की घटना को दर्शाता है। यह प्रक्रिया संचालन में गणना की सटीकता में एक भयावह कमी के साथ होती है जहां परिणामी मूल्य इनपुट की तुलना में बहुत कम है। हमारे मामले में, घटाव का परिणाम 1।

हम दिखाते हैं कि एर्लैंग में यह समस्या मौजूद है:

 reduction(_)-> X = float(87654321098765432), Y = float(87654321098765431), 16.0 = XY. %% has to be 1.0 

यह अपेक्षित 1.0 के बजाय 16.0 निकला। आइए इस स्थिति को ठीक करने का प्रयास करें:

 reduction_eapa(_)-> X = eapa_int:with_val(1, <<"87654321098765432">>), Y = eapa_int:with_val(1, <<"87654321098765431">>), <<"1.0">> = eapa_int:to_float(eapa_int:sub(X, Y)). 

Erlang में फ्लोटिंग पॉइंट अंकगणित की अन्य विशेषताएं

नकारात्मक शून्य को अनदेखा करके शुरू करते हैं।

 eq(_)-> true = list_to_float("0.0") =:= list_to_float("-0.0"). 

केवल यह कहना चाहता हूं कि EAPA इस व्यवहार को बनाए रखता है:

 eq_eapa(_)-> X = eapa_int:with_val(1, <<"0.0">>), Y = eapa_int:with_val(1, <<"-0.0">>), true = eapa_int:eq(X, Y). 

चूंकि यह मान्य है। Erlang में NaN और शिशुओं की स्पष्ट वाक्य रचना और प्रसंस्करण नहीं है, जो कई विशेषताओं को जन्म देता है, उदाहरण के लिए, ये:

 1> math:sqrt(list_to_float("-0.0")). 0.0 

अगला बिंदु बड़ी और छोटी संख्या को संसाधित करने की विशेषता है। चलो छोटों के लिए प्रजनन करने की कोशिश करते हैं:

 2> list_to_float("0."++lists:duplicate(322, $0)++"1"). 1.0e-323 3> list_to_float("0."++lists:duplicate(323, $0)++"1"). 0.0 

और बड़ी संख्या के लिए:

 4> list_to_float("1"++lists:duplicate(308, $0)++".0"). 1.0e308 5> list_to_float("1"++lists:duplicate(309, $0)++".0"). ** exception error: bad argument 

यहाँ छोटी संख्या के लिए कुछ और उदाहरण दिए गए हैं:

 6> list_to_float("0."++lists:duplicate(322, $0)++"123456789"). 1.0e-323 7> list_to_float("0."++lists:duplicate(300, $0)++"123456789"). 1.23456789e-301 

 8> 0.123456789e-100 * 0.123456789e-100. 1.524157875019052e-202 9> 0.123456789e-200 * 0.123456789e-200. 0.0 

उपरोक्त उदाहरण Erlang परियोजनाओं के लिए सत्य की पुष्टि करते हैं: IEEE754 में धन की गणना नहीं की जा सकती।

EAPA (एर्लांग आरंगवर्थ-प्रिसिजन अरिथमेटिक)

EAPA एक NIF एक्सटेंशन है जिसे रस्ट में लिखा गया है। फिलहाल, EAPA रिपॉजिटरी फिक्स्ड-पॉइंट नंबरों के साथ काम करने के लिए सबसे सरल और सुविधाजनक eapa_int इंटरफ़ेस प्रदान करता है। Eapa_int की विशेषताओं में निम्नलिखित शामिल हैं:

1. IEEE754 कोडिंग के प्रभाव का अभाव
2. बड़ी संख्या में समर्थन
3. 126 दशमलव स्थानों तक विन्यास योग्य सटीकता। (वर्तमान कार्यान्वयन में)
4. Avtoskeyling
5. संख्याओं पर सभी बुनियादी कार्यों के लिए समर्थन
6. अधिक या कम पूर्ण परीक्षण, संपत्ति आधारित सहित।

eapa_int इंटरफ़ेस:

• with_val/2 - एक फ्लोटिंग-पॉइंट नंबर का एक निश्चित प्रतिनिधित्व में अनुवाद, जिसका उपयोग किया जा सकता है, सुरक्षित रूप से, json, xml में।
• to_float/2 - किसी निश्चित सटीकता के साथ फ़्लोटिंग-पॉइंट नंबर में एक निश्चित-बिंदु संख्या का अनुवाद।
• to_float/1 - फ़्लोटिंग-पॉइंट नंबर के लिए एक निश्चित-बिंदु संख्या का अनुवाद करें।
• add/2 - दो संख्याओं का योग
• sub/2 - अंतर
• mul/2 - गुणन
• divp/2 - विभाजन
• min/2 - संख्या की न्यूनतम
• max/2 - संख्याओं की अधिकतम
• eq/2 - संख्याओं की समानता की जांच करें
• lt/2 - जांचें कि संख्या कम है
• lte/2 - बराबर से कम की जाँच करना
• gt/2 - जांचें कि संख्या अधिक है
• gte/2 - जाँच बराबर से अधिक है

EAPA कोड रिपॉजिटरी https://github.com/Vonmo/eapa में पाया जा सकता है

आपको eapa_int का उपयोग कब करना चाहिए? उदाहरण के लिए, यदि आपका आवेदन पैसे के साथ काम करता है या आपको 9223372036854775807922333636474780807.922337203685478080222222334785474775807 जैसे नंबरों पर आसानी से और सही ढंग से कम्प्यूटेशनल ऑपरेशन करने की आवश्यकता है, तो आप सुरक्षित रूप से EAPA का उपयोग कर सकते हैं।

किसी भी समाधान की तरह, ईएपीए एक समझौता है। हम स्मृति और कम्प्यूटेशनल गति का त्याग करके आवश्यक सटीकता प्राप्त करते हैं। वास्तविक प्रणालियों पर एकत्रित प्रदर्शन परीक्षण और आंकड़े बताते हैं कि अधिकांश ऑपरेशन 3-30 μs की सीमा में किए जाते हैं। EAPA निश्चित बिंदु इंटरफ़ेस का चयन करते समय इस बिंदु पर भी विचार किया जाना चाहिए।

निष्कर्ष

बेशक, एर्लांग या अमृत पर ऐसी समस्याओं को हल करने के लिए हमेशा आवश्यक है, लेकिन जब कोई समस्या उत्पन्न होती है और एक उपयुक्त उपकरण नहीं मिलता है, तो आपको एक समाधान का आविष्कार करना होगा।
यह लेख समुदाय को उपकरण और अनुभव के साथ साझा करने का एक प्रयास है, इस उम्मीद में कि कुछ लोगों के लिए यह पुस्तकालय उपयोगी होगा और समय बचाने में मदद करेगा।
एर्लांग में आप पैसे के बारे में क्या सोचते हैं?

PS तर्कसंगत और जटिल संख्याओं के साथ-साथ पूर्णांक, फ़्लोट, कॉम्प्लेक्स, देशी प्रकार की मनमानी सटीकता के साथ मूल कार्य निम्नलिखित प्रकाशनों में शामिल किया जाएगा। स्विच मत करो!

संबंधित सामग्री:

• फ्लोटिंग-पॉइंट अंकगणित के बारे में हर कंप्यूटर वैज्ञानिक को क्या जानना चाहिए
• फ्लोटिंग पॉइंट अंकगणित के बारे में आपको क्या जानने की जरूरत है
• IEEE स्टैंडर्ड 754 फ्लोटिंग पॉइंट नंबर
• IEEE 754 - बाइनरी अंकगणित मानक
  चल बिन्दु
• .30000000000000004