क्या फ्लोटिंग पॉइंट नंबरों के बिना यथार्थवादी चित्रों को प्रस्तुत करना संभव है?

परिचय

---

"क्या होगा यदि हम फ़्लोटिंग पॉइंट नंबरों को तर्कसंगत संख्याओं से बदल दें और छवि को रेंडर करने का प्रयास करें?"

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

इसने मुझमें इस विचार को जन्म दिया - अगर हम यह मान लें कि आने वाले सभी रेंडरर डेटा (वर्टेक्स कोऑर्डिनेट्स, 3 डी ट्रांसफॉर्म आदि) को तर्कसंगत संख्याओं के रूप में सेट किया गया था, तो वे सभी ऑपरेशन बनाएंगे, एक किरण बनाने से लेकर चौराहे तक त्वरण संरचना का पता लगाते हुए त्रिकोण वाली किरणें केवल परिमेय संख्याएँ हैं? अगर ऐसा होता, तो हम वास्तव में एक कॉपलनरीटी टेस्ट कर सकते थे! आप सोच रहे होंगे कि परिमेय संख्याओं में व्यक्त 3 डी दृश्य को केवल परिमेय संख्याओं में परिणाम क्यों देना चाहिए ...


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

सबसे पहले, एक तर्कसंगत संख्या एक संख्या है जिसे दो पूर्णांकों के अनुपात के रूप में व्यक्त किया जा सकता है, उदाहरण के लिए 1/2 या 355/113। दूसरे, "साधारण रेंडरिंग ऑपरेशंस", जैसे कि बॉक्स परीक्षण को बाध्य करना, एक त्रिकोण के साथ एक किरण के चौराहे की जांच करना, एक किरण का प्रतिबिंब, आदि, वेक्टर और स्केलर उत्पादों पर आधारित होते हैं, साथ ही साथ स्केलर डिवीजन (इसमें शामिल हैं) समन्वय परिवर्तन और मैट्रिक्स व्युत्क्रम, चतुर्भुज, आदि), जो बदले में चार बुनियादी कार्यों पर आधारित हैं: इसके अलावा, घटाव, गुणा और भाग। परिमेय संख्याओं को जोड़ने, घटाने, गुणा करने और विभाजित करने पर, परिमेय संख्याएँ भी प्राप्त होती हैं। गणितज्ञ कहेंगे कि कई तर्कसंगत संख्याएं एक क्षेत्र बनाती हैं जो चार बुनियादी अंकगणितीय कार्यों के तहत बंद होती हैं। हमारे लिए, इसका मतलब है कि यदि हम विशेष रूप से तर्कसंगत संख्याओं का पालन करते हैं, तो हम वास्तव में 3 डी दृश्य के इनपुट डेटा से तर्कसंगत संख्याओं की दुनिया को छोड़कर पूरी तरह से प्रदान की गई छवि में स्थानांतरित कर सकते हैं।

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

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

यह लेख इस तरह के विचार के यथार्थवाद में अनुसंधान की दो रातों की कहानी है। मैं उन कई पहलुओं के बारे में बात करूंगा जो मैंने सीखीं, इस बारे में कि मैं क्या लेकर आया था और इस प्रक्रिया में खोजे गए कुछ आश्चर्य के बारे में। लेख मेरे काम के अधिक या कम कालानुक्रमिक क्रम में लिखा गया है। इसके अलावा, यह मेरी असामान्य रूप से अनौपचारिक और बहुत ही अवैज्ञानिक शैली में लिखा गया था (जिस पर मुझे गर्व है)। ऊपर दिखाई गई छवि एक प्रकार का स्पॉइलर है, लेकिन लेख को अंत तक पढ़ें, क्योंकि मैं अच्छे और बुरे के बारे में बात करूंगा।

ट्रेनिंग

---

पहली बात मैंने Shadertoy में एक प्लेन, गोले, आयताकार समानांतर चतुर्भुज और एक त्रिकोण से मिलकर एक अत्यंत सरल दृश्य के लिए एक न्यूनतम सीमित अनुरेखक को लागू करना था - वास्तविक रेंडरर्स के बिल्डिंग ब्लॉक। तब मैंने कोड को C ++ फ़ाइल में कॉपी किया और, कुछ छोटे बदलाव करने के बाद, अपने piLibs ढांचे का उपयोग करके इसे संकलित किया। इसलिए तुलना के लिए, मुझे एक अस्थायी छवि के साथ IEEE754 मानक के अनुसार नियमित नंबरों का उपयोग करके सीपीयू को एक ट्रेस छवि प्रदान की गई। मैंने ट्रेस कोड से सभी किरण सामान्यीकरण को भी हटा दिया, क्योंकि, जैसा कि ऊपर उल्लेख किया गया है, उनमें से कोई भी वास्तव में आवश्यक नहीं है। आपको याद दिलाता हूं कि सामान्यीकरण के लिए एक वर्गमूल की आवश्यकता होती है, और तर्कसंगत संख्याओं को संरक्षित नहीं किया जाता है जब इसका उपयोग किया जाता है (तर्कसंगत संख्या का वर्गमूल एक परिमेय संख्या नहीं है)। थोड़ी देर बाद हम देखेंगे कि वर्गमूल को लागू करना, अभी भी संभव है, मैं बस कोड को गणितीय रूप से साफ करना चाहता था, यह देखने के लिए कि मैं गोलाकार के बिना तर्कसंगत संख्याओं के सटीक अंकगणित के साथ कितनी दूर जा सकता हूं।

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

टेस्ट 1 - द नेवी सॉल्यूशन

---

लेकिन आइए देखें कि यह पहला कार्यान्वयन कैसा था। सबसे पहले मैं हमेशा सबसे सरल कोशिश करता हूं, और फिर मैं परिणामों को देखता हूं। और तर्कसंगत मूल्यों को लागू करने का सबसे सरल तरीका दो पूर्णांकों का उपयोग करना था। जैसा कि अनुभाग का नाम बताता है, यह मेरा अंतिम निर्णय नहीं होगा, लेकिन पहले प्रयास के लिए यह एक उचित निर्णय था। इसलिए, प्रत्येक संख्या x को अंश N और हर D के रूप में दर्शाया जाना चाहिए, जिससे मान N / D बनता है । एक्स मान सबसे अच्छा संभव एन / डी जोड़ी (निर्दिष्ट बिट गहराई के भीतर) द्वारा अनुमानित है, जो कि वास्तविक एक्स मूल्य के सबसे करीब है। मैंने फैसला किया कि दोनों संख्याओं को सकारात्मक होना चाहिए, और काम को आसान बनाने और अस्पष्टता से छुटकारा पाने के लिए संख्या का संकेत एक अलग बिट में संग्रहीत किया जाना चाहिए, हालांकि यह बहुत महत्वपूर्ण नहीं है। इस स्तर पर, संख्यात्मक और भाजक दोनों अहस्ताक्षरित प्रकार के थे। लेकिन संकेत को अलग करते हुए भी, एन / डी में बहुत अधिक अतिरेक था: उदाहरण के लिए, 1/4 और 7/28 एक ही संख्या को दर्शाते हैं, लेकिन पूरी तरह से अलग प्रतिनिधित्व करते हैं। हम बाद में इस पर विचार करेंगे, लेकिन अभी के लिए, हम अपना ध्यान केंद्रित नहीं करते हैं और देखते हैं कि चार बुनियादी अंकगणितीय संचालन इस तर्कसंगत रूप में कैसे दिखते हैं।

सबसे पहले, ध्यान दें कि a - b को घटाना केवल a और b के विपरीत मान है, अर्थात, a + ( -b ), जहां -b की गणना केवल b के चिन्ह को बदलकर की जा सकती है। इसी तरह, a / b को विभाजित करना a और b के व्युत्क्रम को गुणा करने के समान है। या, दूसरे शब्दों में, a / b = a · (1 / b ), जहां (1 / b ) को अंश b _n के स्थानों को बदलकर और संख्या b के हर b के _{d को} बदलकर गणना की जा सकती है। तो, यहाँ तर्कसंगत अंकगणितीय की पहली दिलचस्प संपत्ति है - विभाजन और गुणन की समान लागत है, इसलिए, सामान्य फ़्लोटिंग पॉइंट रेंडरिंग के विपरीत, जिसमें डिवीजनों को आमतौर पर धीमी बनावट के अनुरोधों की देरी के तहत टाला जाता है, देरी या छिपाई जाती है, तर्कसंगत अरिथमेटिक में इन ऑपरेशनों से डरने की कोई आवश्यकता नहीं है। ।

हम गुणन के साथ जुड़ने की ओर मुड़ते हैं: हम जानते हैं कि विपरीत और व्युत्क्रम मान सामान्य रूप से गणना करने के लिए सरल हैं, इसलिए हमें यह मिल सकता है:


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

मैं फ्रैक्चर () और फर्श () के कार्यान्वयन को भी छोड़ दूंगा; यदि आप उन्हें स्वयं लागू करने का प्रयास करने का निर्णय लेते हैं, तो आप उनकी सादगी और सुंदरता देखेंगे। तुलना ऑपरेटरों के लिए भी ध्यान दिया जाना चाहिए। संकेतों का ध्यान रखने और यह मानकर कि ए और बी सकारात्मक हैं, हमें मिलता है


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

अंत में, हम एक अलग खंड में वर्ग जड़ों को देखते हैं, यह जानते हुए कि अधिकांश भाग के लिए हमें उनकी आवश्यकता नहीं है (इस पहले परीक्षण से क्षेत्र को छोड़कर)।

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


"Naive" 65-बिट तर्कसंगत संख्या


फ़्लोटिंग पॉइंट संदर्भ

परिणाम बहुत बुरा था, बॉक्स और त्रिकोण भी रेंडर पर दिखाई नहीं दिया, और फर्श के गोले और विमान भी शोर थे। बेशक, समस्या यह थी कि हर बार जब मेरे तर्कसंगत संख्याओं ने प्रतिपादन के किसी भी एल्गोरिथम चरणों में कोई बुनियादी अंकगणितीय ऑपरेशन किया, तो अंश और भाजक अधिक से अधिक अनियंत्रित हो गए, क्योंकि पूर्णांक गुणन का उपयोग किया गया था। निम्नलिखित के बारे में सोचें: यदि हमारी प्रारंभिक दुनिया की इकाइयां मीटर थीं, और हम मिलीमीटर सटीकता के लिए स्रोत ज्यामिति (कोने और कैमरा) संलग्न करेंगे, तो केवल स्रोत डेटा एक छोटे दृश्य के लिए 16-बिट वॉल्यूम पर कब्जा कर लेंगे। एक ही समय में, मानक HD स्क्रीन रिज़ॉल्यूशन और 4X चौरसाई के साथ, तर्कसंगत बीम दिशा संख्याओं को आसानी से 12 बिट्स की आवश्यकता होगी। अर्थात्, बीम और ज्यामिति की पहली बातचीत के दौरान, इनपुट डेटा के दोनों सेटों का उपयोग करते हुए सबसे सरल अंकगणितीय ऑपरेशन, परिणाम को 28-बिट लंबाई में बदल देगा - 32-बिट सीमा के करीब पर्याप्त है जो मैंने इस पहले कार्यान्वयन में खुद के लिए निर्धारित किया था। और इससे पहले कि हम बहुत पहले वेक्टर या स्केलर उत्पाद का प्रदर्शन करते हैं। जब तक स्केलर उत्पाद पूरा हो जाता है, तब तक रेंडरर को संख्याओं का प्रतिनिधित्व करने के लिए सैकड़ों बिट्स की तर्कसंगत संख्या की आवश्यकता होती है। बेशक, यह सबसे खराब मामला है, लेकिन औसत मामला इसके करीब होगा। यह देखते हुए कि मैंने अंश और हर के लिए केवल 32-बिट क्षमता आवंटित की है, यह समझना आसान है कि इस परीक्षण में मूल्य कितनी जल्दी सीमाओं से परे जाते हैं - यह आश्चर्य की बात नहीं है कि फर्श के तल और क्षेत्र के भाग के अपवाद के साथ, लगभग कुछ भी दिखाई नहीं देता है।

टेस्ट 2 - सबसे बड़े सामान्य कारक द्वारा कटौती

---

फिर मैंने संपत्ति का उपयोग करके प्रणाली में सुधार किया जिसे मैंने ऊपर उल्लेख किया है - विभिन्न तर्कसंगत संख्याओं का मतलब समान राशि हो सकता है। और वास्तव में, 6/12 1/2 के समान मूल्य है, लेकिन यह पिछले की तुलना में बहुत अधिक बिट्स का उपयोग करता है। इसलिए, विचार इस प्रकार था: यदि प्रत्येक मूल अंकगणितीय ऑपरेशन के बाद (या इसके बाद) मैं अंश और हर से सभी सामान्य भाजक निकालूंगा, और अंश को सरलतम रूप में लाऊंगा, तो शायद मैं नियंत्रण में रहूंगा और संचालन को लंबे समय तक जारी रखूंगा। सटीकता की हानि के बिना सटीक अंकगणित के साथ। शायद आप साफ, प्रदान की गई छवियों को प्राप्त करने के लिए इतना लंबा कर सकते हैं? मैं एक और उदाहरण दिखाने के लिए एक छोटा विषयांतर लूंगा: 588/910 को 42/65 तक सरल किया जा सकता है, क्योंकि 14 588 और 910 दोनों का विभाजक है। लेकिन 42/65 को संग्रहीत करने के लिए, जाहिर है, 588/910 से कम बिट्स की आवश्यकता होती है। एक साथ अन्य दो संख्याओं को विभाजित करने वाली सबसे बड़ी संभावित संख्या को खोजना, सामान्य कॉमन डिविज़र (GCD) एल्गोरिथ्म का उपयोग करके किया जा सकता है, जिनमें से प्रभावी कार्यान्वयन आपको कहीं भी मिल सकते हैं (मैंने व्यक्तिगत रूप से इसे सीधे विकिपीडिया से कॉपी किया और स्कैनिंग चरण का प्रदर्शन करके इसे थोड़ा तेज किया आंतरिक x64 संचालन का उपयोग करके बिट्स)। इसलिए, जीसीडी एल्गोरिथ्म से लैस, मेरे तर्कसंगत वर्ग को प्रतिपादन प्रक्रिया के दौरान उत्पन्न होने वाले भिन्नों को लगातार सरल करना चाहिए। यह दो तरीकों से किया जा सकता है:

पहला अतिरिक्त और बिटकॉइन ऑपरेटरों के मध्यवर्ती परिणाम को अगले प्रकार के बिट डेटा में बदलना है (मेरे वर्तमान भोले समाधान में यह uin64_t है), इस अधिक अस्थिर डेटा प्रकार में जीसीडी की खोज करें, और फिर मूल बिट लंबाई (32) के परिणाम को कम करें। दूसरा तरीका यह है कि दोनों अंकगणितीय संचालकों में एक _n , _d , b _n और b _d को एक दूसरे के साथ कैसे जोड़ा जाए और गुणन करने से पहले उनसे आम विभाजक निकालें। दूसरे दृष्टिकोण ने मूल रूप से बड़ी बिट लंबाई की आवश्यकता को समाप्त कर दिया। यह जानते हुए कि उनका उपयोग करना आवश्यक हो सकता है, वैसे भी, मैंने पहली विधि चुनने का फैसला किया, क्योंकि इसे लागू करना आसान है और इसने मुझे अपना काम तेज करने की अनुमति दी (शाम बहुत जल्दी उड़ जाती है)। यह सब करने के बाद, आइए देखते हैं कि अब मैं क्या रेंडर कर सकता हूं:


65-बिट तर्कसंगत संख्या जीसीडी से कम हो गई


फ़्लोटिंग पॉइंट संदर्भ

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

तर्कसंगत संख्याओं की प्रयोज्यता को साबित करने की प्रक्रिया में अगले चरण पर आगे बढ़ने से पहले, मैं संक्षेप में जीसीडी और तर्कसंगत संख्याओं की कटौती के बारे में अपने निष्कर्षों को रोकना और साझा करना चाहता हूं।

पहली खोज तर्कसंगत संख्याओं के बिट वॉल्यूम से संबंधित है। भले ही मैं अभी भी सुंदर छवियों को प्रस्तुत नहीं कर सकता हूं और यह डेटा वॉल्यूम के अनुकूलन के बारे में चिंता करने से ज्यादा महत्वपूर्ण है, और हालांकि इस प्रारंभिक कार्यान्वयन में अभी भी बड़ी संख्या में बिट्स (1 + 32 + 32) का उपयोग किया गया था, मैं पहले से उल्लेख किए गए कचरे के बारे में पहले से ही सोच रहा था। अतिरिक्त अंशों के रूप में बिट्स। विशेष रूप से, जीसीडी के साथ एक चरण जोड़ने के बाद, 2/4 जैसे बिट कॉम्बिनेशन अब लागू नहीं होते हैं, क्योंकि वे किसी भी रजिस्टर या वेरिएबल में लिखने से पहले स्वचालित रूप से 1/2 तक कम हो जाते हैं। यही है, एक अर्थ में, बिट्स के सभी 2 ⁶⁴ संयोजनों में से जो एक अंश और एक भाजक हो सकता है, कई अप्रयुक्त रह गए। और आप इस तरह से बिट्स बर्बाद नहीं कर सकते। या यह संभव है? मैं वास्तव में कितना स्थान खोता हूं? मैंने इस मुद्दे का पता लगाने के लिए एक छोटा सा विषयांतर किया।

पाचन - पारस्परिक रूप से अभाज्य संख्याओं पर

---

नीचे दिए गए चित्र 5/5 बिट्स और 7/7 बिट्स में तर्कसंगत संख्याओं के लिए बिट्स के उपयोग को दर्शाते हैं। रेखांकन के क्षैतिज और ऊर्ध्वाधर अक्ष 5 अंश (31) और 7 बिट (127) तक संख्यात्मक और हर होने वाले सभी संभावित तर्कसंगत संख्याओं के अंश और हर के मान का प्रतिनिधित्व करते हैं। ब्लैक पिक्सल अप्रयुक्त संयोजन हैं, और सफेद पिक्सेल का उपयोग किया जाता है। उदाहरण के लिए, 1/1 पिक्सेल को छोड़कर पूरा विकर्ण काला होता है, क्योंकि प्रपत्र n / n के सभी अंश 1/1 तक कम हो जाते हैं।



5/5 तर्कसंगत के लिए बिट्स का उपयोग करना



7/7 तर्कसंगत के लिए बिट्स का उपयोग करना

यदि आप पिक्सेल की गणना करते हैं, जैसा कि मैंने किया है, तो आप जल्दी से समझ सकते हैं कि बिट्स की संख्या में वृद्धि के साथ उपयोगी पिक्सल का अनुपात 60.8% तक है। थोड़े से ऑनलाइन शोध से मुझे पता चला कि यह अनुपात ठीक 6 / because ^{2 का है} , क्योंकि यह दो यादृच्छिक संख्याओं के लिए अपेक्षाकृत प्रमुख (सामान्य भाजक नहीं होने) की संभावना है। आप पूछ सकते हैं कि पाई कहां से आई?यह पता चला है कि "सिक्स बाय पी स्क्वायर्ड" एक मूल्य के बराबर है जो कि रीमैन ज़ेटा फ़ंक्शन द्वारा विभाजित किया गया है जो बिंदु 2, 1 / ζ (2) पर गणना की जाती है। यह हमें बहुत आश्चर्यचकित नहीं करना चाहिए, क्योंकि रीमैन ज़ेटा फ़ंक्शन अक्सर प्राइम और पारस्परिक रूप से अभाज्य संख्याओं की समस्याओं में पॉप अप करता है।

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

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

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

परीक्षण 3 - परिमेय संख्याओं का सामान्यीकरण

---

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

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

मेरे पहले कार्यान्वयन में, मैंने अंश और हर के लिए आवश्यक बिट्स की संख्या को देखा, दोनों के लिए अधिकतम लिया और बिट्स की इस संख्या (निकटतम पूर्णांक तक गोलाई) द्वारा दोनों को स्थानांतरित कर दिया। जब इसे जोड़ और गुणा ऑपरेटरों में लागू किया गया, तो सब कुछ काफी स्वीकार्य लगने लगा:


65-बिट तर्कसंगत संख्या GCD और सामान्यीकरण से कम हो गई


फ्लोटिंग-पॉइंट मानक

चूंकि सब कुछ बहुत अच्छा लग रहा था, इस स्तर पर मैं वर्तमान कार्यान्वयन में प्रयुक्त बिट्स की एक बड़ी समस्या को हल करने के लिए आगे बढ़ा। मैंने 32/32 (65 बिट्स) के बजाय 16/16 (33 बिट्स) का उपयोग करने की कोशिश की, और चित्र आश्चर्यजनक रूप से अच्छे निकले! मैंने अभी भी देखा कि गोले के कुछ किनारों में छोटे छेद हैं, और त्रिकोण की बनावट के आंकड़े में छोटे अंतराल हैं। लेकिन यह मात्रा के लिए बुरा नहीं है जो फ्लोटिंग पॉइंट नंबरों के काफी करीब है। इसने मुझे नए विचारों को सीखने की ऊर्जा दी।

टेस्ट 4 - फ्लोटिंग स्लैश

---

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

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

यह जाँच के लायक था। वैसे भी, आंतरिक बसने वाले और गेटर्स में कोडिंग / अनपैकिंग कोड की कुछ पंक्तियों को जल्दी से लिखा जा सकता है। मेरे लिए सबसे तार्किक योजना 1 थी। 5 | 26, जो है:

1 बिट:
5-बिट संकेत : अंश रेखा स्थिति (बी)
26-बिट: संयुक्त अंश और हर डेटा; अंश 26-B बिट है, भाजक निचला B बिट है,

जहां अंश बार (B) हर का आकार निर्धारित करता है। उदाहरण के लिए, संख्या 7/3 के रूप में लिखा जाएगा

7/3 = 0 00010 000000000000000000000111 11,

जहाँ संकेत 0 का अर्थ धनात्मक मान होता है, भिन्न 2 की रेखा हर को निरूपित करती है (संख्या 3), जिसे प्रस्तुत करने के लिए 2 बिट्स की आवश्यकता होती है, और शेष बिट्स अंशांक पर जाते हैं।

जिन पाठकों ने IEEE754 मानक के साथ काम किया है वे इस अवलोकन को परिचित पा सकते हैं: भाजक का द्विआधारी निरूपण हमेशा "1" से शुरू होता है क्योंकि अंश रेखा संख्या हमेशा इसे कम से कम प्रतिनिधित्व करती है। यही है, हर का पहला बिट वैकल्पिक है। इस स्थिति में, संख्या "3" को केवल द्विआधारी मान "1" और अंश रेखा "1" के मूल्य द्वारा दर्शाया जा सकता है:

7/3 = 0 00001 0000000000000000000000111 1

इस ट्रिक ने न केवल मुझे एक कीमती बिट बचा लिया, बल्कि इसका एक उत्कृष्ट दुष्प्रभाव भी है: जब किसी अंश का स्लैश मान शून्य होता है, तो इसका स्वाभाविक रूप से एक ही समय में अर्थ होता है कि हर 1 है और इसे संग्रहीत करने के लिए किसी स्थान की आवश्यकता नहीं है। इसका अर्थ है कि संख्याओं का मेरा तर्कसंगत प्रतिनिधित्व अचानक पूर्णांक के सामान्य प्रतिनिधित्व और अंकगणितीय के साथ पूरी तरह से संगत हो गया, जब तक कि संख्याओं का मान 2 ^{26 से} ऊपर नहीं बढ़ जाता, अर्थात् पर्याप्त रूप से बड़ी सीमा तक। क्या आश्चर्य की बात है! यही है, सैद्धांतिक रूप से, मैं बिल्कुल समान डेटा प्रकार, "तर्कसंगत" का उपयोग कर सकता हूं, मानक प्रतिपादन और छायांकन संचालन करने के लिए, लेकिन पथ अनुरेखक में कमांड प्रवाह के सभी तर्क और कार्य भी करता हूं - मुझे अब दो डेटा प्रकारों का उपयोग करने की आवश्यकता नहीं है, जैसा कि ऐसा होता है। अधिकांश रेंडरर्स में ("int" और "float") और एक दिशा और दूसरे में रूपांतरण करते हैं! हालाँकि, समय मेरे लिए चल रहा था, इसलिए मैंने सभी लूप इंडेक्स को "int" से "तर्कसंगत" में नहीं बदला। शाम करीब आ रही थी, और मुझे अभी भी रेंडरिंग की गुणवत्ता में सुधार करने के लिए बहुत सी चीजों की जांच करनी थी।

कार्यान्वयन बनाने के बाद, मैं इसे सत्यापित करने में सक्षम था:


32-बिट भिन्नात्मक परिमेय संख्या (1 | 5 | 26)


32-बिट फ़्लोटिंग पॉइंट संदर्भ ओह्ह

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

इस स्तर पर, मैं एक और अधिक गंभीर परीक्षण करने के लिए तैयार था (लेकिन अभी भी प्रयोगात्मक है - प्रणाली अभी भी ऑपरेशन के लिए तैयार है)। मैंने एक न्यूनतम कार्य के सेट के साथ एक पथ अनुचर को लागू किया (आवश्यक रूप से शारीरिक रूप से सटीक या यहां तक ​​कि भौतिकी को ध्यान में रखते हुए नहीं) और कई आयताकार समानांतर चतुर्भुज और दो प्रकाश स्रोतों के साथ एक दृश्य बनाया, जिसका संदर्भ कार्यान्वयन GPU पर यहां है: https://shadertoy.com/view/Xd2fzR ।

मैंने फिर से दृश्य को सी ++ फ्रेमवर्क में बदल दिया, फिर से कुछ अनावश्यक किरण सामान्यीकरण हटा दिए, और रेंडर चलाया। यहाँ मुझे क्या मिला है:


32-बिट भिन्नात्मक परिमेय संख्या


32-बिट फ़्लोटिंग पॉइंट मानक

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



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

कुछ अन्य प्रयोग

---

64 बिट्स में सटीक अंकगणित

सटीक अंकगणित के विचार को भोले 64-बिट परिमेय संख्याओं में या 32-बिट (1 | 5 | 26) में महसूस नहीं किया जा सकता है। और एक अंश काम के 64-बिट फ्लोटिंग-पॉइंट नंबर होंगे?

मैंने जल्दी से तर्कसंगत संख्याओं को लागू किया 1 | 6 | 57 (हालांकि मुझे बिट्स शिफ्टिंग के लिए नए आंतरिक x64 तंत्र सीखना था)। अंश / भाजक के इन 57 बिट्स ने अधिक दूरी के अंतराल को ट्रेस करने की अनुमति दी। मैं वास्तव में सभी सटीक के साथ कई त्रिकोण के साथ एक दृश्य का पता लगाने में कामयाब रहाअंकगणित (आयताकार समानांतर चतुर्भुज और वैश्विक प्रकाश व्यवस्था के साथ उपर्युक्त दृश्य नहीं है, लेकिन कैमरे के सामने सिर्फ कुछ त्रिकोण हैं)। और सफलता ने मेरा इंतजार किया! हालांकि, कॉपलनारिटी परीक्षण, जिसे मैंने शुद्धता की जांच करने के लिए लागू किया था, को कई स्केलर और वेक्टर उत्पाद संचालन की आवश्यकता थी, जिसके कारण संख्याएं खुद को सामान्य करने के लिए शुरू हुईं। इसलिए, हालांकि मुझे पता था कि रेंडर सही था, मैं इसे प्रयोगात्मक रूप से "साबित" नहीं कर सका। कैसी विडंबना है। सामान्य तौर पर, इसका मतलब है कि कई त्रिकोणों के लिए 64 बिट्स पर्याप्त थे, लेकिन अधिक जटिल दृश्य अभी भी अलग हो जाएंगे। हालांकि, इससे मुझे एक और सवाल के बारे में सोचने को मिला: क्या कोई एल्गोरिथ्म है जिसका उपयोग पूर्णता पर नहीं, बल्कि मॉड्यूलर अंकगणित के आधार पर, कोप्लानैरिटी का परीक्षण करने के लिए किया जा सकता है? मुझे लगता हैमॉड्यूलर अंकगणितीय में, तर्कसंगत संख्याओं को "विस्फोट" नहीं करना चाहिए? मेरे पास यह सब जांचने का समय नहीं था, और मैं संख्या सिद्धांत का विशेषज्ञ नहीं हूं।

वर्गमूल

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

मैंने निम्नलिखित की कोशिश की: अंत में, यहां हम दो पूर्णांक x की तलाश कर रहे हैंऔर वाई ऐसा है


फिर हम इस अभिव्यक्ति को निम्नलिखित डायोफैंटाइन समीकरण ("डायोफैंटाइन" के समाधान (गैर-तुच्छ) के रूप में फिर से लिख सकते हैं (इसका अर्थ है कि हम केवल पूर्णांक समाधानों में रुचि रखते हैं):


विकिपीडिया की खोज के बाद, मैंने पाया कि यह विशेष समीकरण तथाकथित "संशोधित पेल का समीकरण" है। ऐसे एल्गोरिदम हैं जो इस समीकरण को हल करने के लिए सबसे छोटे x और y मान पाते हैं। दुर्भाग्य से, मेरा ध्यान जल्दी से अन्य जिज्ञासु डायोफैंटीन गणित में स्थानांतरित हो गया, और मैं इनमें से किसी भी एल्गोरिदम के कार्यान्वयन के साथ आगे नहीं बढ़ा।

अधिक प्रभावी कमी

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


इस धारणा के तहत कि sy = a / b, tz = c / d, ty = e / f, sz = g / h

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

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

एक समझौते के रूप में, आप प्रक्रिया या जीसीडी योजना को लागू करने से इनकार कर सकते हैं, और इसके बजाय गणितीय रूप से सरल, कोड में हार्ड-कोडित और प्रभावी, केवल 2, 3, और 5. द्वारा विभाज्यता का निर्धारण करते हैं और यद्यपि हम विभाजकों की एक विस्तृत संख्या नहीं पाते हैं। व्यवहार में, यह बड़ी संख्या में संक्षिप्तीकरण का मार्ग प्रशस्त करेगा। इसके बारे में सोचो - 2 से विभाज्यता 7 से विभाज्यता की तुलना में तीन गुना अधिक होती है, और 41 से विभाज्यता की तुलना में 20 गुना अधिक होती है!

निष्कर्ष

---

इस प्रयोग के बाद, मुझे यह विश्वास होने लगा कि तर्कसंगत संख्याओं के आधार पर संख्याओं के निरूपण के लिए यह काफी संभव है, जिसे मैं "फ्लोटिंग लाइन अंश" कहता हूं। पूर्णांक के साथ संगत प्रतिनिधित्व और कई कार्यों के लिए सटीक अंकगणित में कई ऑपरेशन करने में सक्षम (बशर्ते कि इनपुट डेटा तर्कसंगत रूप में प्रस्तुत किया गया है)। 64-बिट संस्करण (1 | 6 | 57) में बड़ी क्षमता है, हालांकि 32-बिट संस्करण (1 | 5 | 26) पहले से ही दिलचस्प प्रस्तुतिकरण बनाता है।

यदि यह दो शामों के लिए एक प्रयोग नहीं था, लेकिन एक स्टूडियो या कंपनी में बनाया गया कुछ पेशेवर, तो भविष्य में निम्नलिखित कदम हो सकते हैं:

* सटीक और ठीक से पता लगाया पिक्सल की संख्या का एक हिस्टोग्राम प्राप्त करें (दूसरे शब्दों में, सामान्यीकरण निष्पादन आवृत्ति)
* डिवाइडर 2, 3, और 5 पर हार्ड-कोडित कटौती को लागू करने का प्रयास करें और खोए हुए सटीक पिक्सेल के प्रतिशत को मापें
* फ़्लोटिंग पॉइंट रेंडरिंग और फ़्लोटिंग फ़्लोटिंग पॉइंट रेंडरिंग के बीच पिक्सेल अंतर दिखाएँ
* बिट प्रारूप "फ्लोटिंग लाइन फ्रैक्शन" के अप्रयुक्त मूल्यों का उपयोग करने के लिए सरल तरीके खोजें, उदाहरण के लिए, Inf -N को निरूपित करने के लिए
* NaN, Inf, अंडरफ्लो, ओवरफ्लो का पता लगाना।

सब सब में, यह एक आकर्षक अध्ययन था। इस प्रक्रिया में, मैंने कुछ आश्चर्य की खोज की, एक छोटे से आविष्कार के साथ आया और पेल समीकरण, वर्गमूल, जीसीडी, x86_64 आंतरिक तंत्र, रीमैन जेटा फ़ंक्शन और कुछ अन्य पहलुओं के बारे में बहुत कुछ सीखा। मैं इससे बहुत प्रसन्न हूँ!