वयस्क पोजिट चुनौतियां

Habré के पास पहले से ही कई लेख ( एक , दो , ढाई ) नए Posit फ़्लोटिंग-पॉइंट प्रारूप के लिए समर्पित थे, जिनमें से लेखक इसे सभी मामलों में IEEE 754 के मानक के रूप में बेहतर मानते हैं। नए प्रारूप में आलोचकों ( एक , दो ) का भी दावा किया गया है जो दावा करते हैं कि पॉज़िट की खामियां इसकी खूबियों को रेखांकित करती हैं। लेकिन क्या होगा अगर हमारे पास वास्तव में एक नया क्रांतिकारी प्रारूप है, और आलोचना केवल आलोचना करने वालों की ईर्ष्या और अक्षमता के कारण होती है? खैर, यह पता लगाने का सबसे अच्छा तरीका खुद को लेना और गणना करना है।

परिचय

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

ट्रेनिंग

परीक्षण के लिए, मैंने यहां से एक पाथोस शीर्षक के साथ पोजिट कार्यान्वयन लिया। विजुअल स्टूडियो में इसे संकलित करने के लिए, हमें use.h फ़ाइल में लाइन #define CLZ (n) __lzcnt (n) को जोड़ना था और posf.cpp फ़ाइल में 0.f / 0.f को std - syn_limits <float> :: शांत_NaN के साथ जोड़ना था। ()। वैसे, इस पुस्तकालय में प्राथमिक गणितीय कार्यों (अच्छी तरह से, जड़ को छोड़कर) के कार्यान्वयन भी नहीं पाए गए - यह कुछ और संदेह करने का एक और कारण था।

परीक्षण 1. जटिल संख्याओं का गुणन

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

यदि हम एक निश्चित वेक्टर लेते हैं और इसे 1 ° से 360 बार घुमाते हैं, तो अंत तक हमें उसी मूल वेक्टर को प्राप्त करना चाहिए। वास्तव में, त्रुटियों के संचय के कारण परिणाम थोड़ा अलग होगा - और घुमावों की संख्या जितनी बड़ी होगी, त्रुटि उतनी ही अधिक होगी। तो, इस सरल कोड का उपयोग कर

complex<T> rot(cos(a), sin(a)); complex<T> vec(length, 0); for (long i = 0; i < count; i++) { vec *= rot; } cout << "error: " << stdev(vec.real() - length, vec.imag()) << endl; 

हम वेक्टर को विभिन्न प्रकार के डेटा के साथ घुमाते हैं, और हम त्रुटि को मूल से परिणामस्वरूप वेक्टर के औसत वर्ग विचलन के रूप में मानेंगे (जिसे अंतर वेक्टर की लंबाई के रूप में भी व्याख्या किया जा सकता है)।

सबसे पहले, Posit के सबसे सहायक के रूप में यूनिट वेक्टर लें:

यहां कोई स्पष्ट नेता अभी तक नहीं है - लाभ एक या दूसरे के दो गुना है। घुमाए गए वेक्टर की लंबाई बढ़ाकर 1000:

त्रुटि मान लगभग बराबर हैं। आगे बढ़ो - 1,000,000:

यहां पोज़िट पहले से आत्मविश्वास से पीछे है, और डबल त्रुटि फ्लोट में रेंगना शुरू कर देता है। चलो फ़्लोटिंग-पॉइंट प्रारूपों के फायदों की पूरी तरह से सराहना करने के लिए एक लंबी लंबाई - 10 ¹⁰ लेते हैं:

यहां सबसे दिलचस्प बात शुरुआत में, 4 पुनरावृत्तियों पर - जब फ्लोट डबल के साथ एक त्रुटि देता है, और पॉज़िट में पहले से ही पूरी तरह से गलत परिणाम है।

परीक्षण 2. एक तर्कसंगत बहुपद की गणना

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

वोल्फ्राम मैथेमेटिका और पेडेप्रोसेसिमेंट कमांड का उपयोग करना [पाप [x], {x, 0, {11, 11}}]
हमें साइन को अंजाम देने के लिए एक तर्कसंगत बहुपद मिलता है, जो लगभग -2 से 2 तक की सीमा में दोहरी सटीकता प्रदान करता है:

$$

$$\ frac {- \ frac {481959816488503 x ^ {11}} {363275871831577908403200}} + \ frac {23704595077729 x ^ 9} (42339845201815607040) - \ frac {29334348899840}} ^ {frac {293343488998} x ^ 7} {}} } {617703157122660} - \ frac {109061004303 x ^ 3} {722459832892} + x} {\ frac {37291724011 x ^ {10}} = 11008359752472057830400} + \ frac {3924840709 x ^ 8} {3} {20163} x ^ 6} {168015258737363520} + \ frac {1679739379 x ^ 4} {13726736824948} + \ frac {34046903537 x ^ 2} {21677909378676} +1} $$$

गणना पर बचत करने के लिए हॉर्नर की योजना का उपयोग आम तौर पर गणना के लिए किया जाता है। हमारे मामले में (हॉर्नरफ़ॉर्म का उपयोग करके) यह दिखेगा

 template< typename T > T padesin(T x) { T xx = x*x; return (x*(T(363275871831577908403200.) + xx*(-T(54839355237791393068800.) + xx*(T(2120649063015013090560.) + xx*(-T(31712777908498486800.) + xx*(T(203385425766914820.) - T(481959816488503.) * xx)))))) / (T(363275871831577908403200.) + xx*(T(5706623400804924998400.) + xx*(T(44454031219351353600.) + xx* (T(219578286347980560.) + xx*(T(707177798947620.) + T(1230626892363.) * xx))))); } 

आइए देखें:


जैसा कि आप देख सकते हैं, यहां पॉसिट के साथ स्थिति विकराल दिखती है - मुश्किल से दो महत्वपूर्ण संख्याएं डायल की जाती हैं।

निष्कर्ष

दुर्भाग्य से, एक चमत्कार नहीं हुआ और क्रांति रद्द हो गई। एकल गणना पर प्रदर्शित पोजीट का लाभ एक चाल से अधिक कुछ नहीं है, जिसकी कीमत "भारी" वास्तविक गणना में सटीकता में एक भयावह कमी है। IEEE 754 फ्लोट या नियत बिंदु के बजाय Posit का उपयोग करने का एकमात्र कारण धार्मिक है। जादू प्रारूप का उपयोग करना, जिसकी सटीकता अपने रचनाकारों के पवित्र विश्वास से सुनिश्चित होती है, आपके कार्यक्रमों में कई चमत्कार ला सकती है!

सत्यापन और आलोचना के लिए PS स्रोत कोड ।

पीपीएस जारी रखा ।