🤚🏻 🎱 🤙🏼 निश्चित बिंदु गणना। मूल सिद्धांत (भाग 1) 🚮 👼🏾 ✊

परिचय या यह विषय क्यों

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

एक बार फिर मंटिसा और प्रतिपादक के बारे में

कम्प्यूटेशनल गणित में, भिन्न मानों को पूर्णांक (n, e) की एक जोड़ी के रूप में दर्शाया जाता है: मंटिसा और प्रतिपादक (रूसी में, "घातांक" अधिक सच है, लेकिन संक्षिप्तता और आदत के लिए, भविष्य में मैं "घातांक" शब्द का उपयोग करूंगा)। जोड़ी प्रपत्र n * 2 ^-e में एक भिन्नात्मक संख्या का प्रतिनिधित्व करती है।
दशमलव बिंदु को संख्या के भिन्नात्मक भाग को अलग करने से पहले घातांक को अंकों की संख्या माना जा सकता है।
यदि घातांक एक चर को रजिस्टर में लिखा गया है और संकलन में अज्ञात है, (n, e) को फ्लोटिंग पॉइंट नंबर कहा जाता है। यदि प्रतिपादक पहले से जाना जाता है, (n, e) को निश्चित बिंदु संख्या कहा जाता है। फिक्स्ड-पॉइंट नंबर केवल मंटिसा को स्टोर करके साधारण पूर्णांक चर (रजिस्टर) को लिखा जा सकता है। घातांक को आमतौर पर अक्षर क्ष के साथ दर्शाया जाता है। इसलिए, यदि आप किसी चर पर टिप्पणी में " q15 गुणक " की भावना से मिलते हैं, तो आपको इस चर को एक निश्चित-बिंदु संख्या और घातांक के बराबर मान लेना चाहिए। हालांकि, मैं नोटेशन के सवाल पर लौटूंगा, जो विभिन्न स्रोत कोड और लेखों में दिखाई देता है।

कंप्यूटिंग

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

जोड़ और घटाव

जोड़ सरल है यदि आप हमारे दिमाग में कल्पना करते हैं कि हमें एक पेपर के एक टुकड़े पर दो दशमलव अंश "एक कॉलम में" रखना चाहिए। इस ऑपरेशन को निष्पादित करते समय, संख्याएं एक कॉलम में लिखी जाती हैं ताकि भिन्नात्मक भाग को अलग करने वाले अल्पविराम एक दूसरे के नीचे स्थित हों। बाइनरी अंकगणित में, इस तरह के ऑपरेशन को घातीय की कमी कहा जाता है।
यदि हम गणितीय संकेतन के "कागज़ के टुकड़े" से जाते हैं, तो हमें निम्नलिखित मिलते हैं:
आज्ञा दें कि दो संख्याएँ a = n1 * 2 ^-q1 और b = n2 * 2 ^{-q2 हैं} ।
तब:
a + b = n1 * 2 ^-q1 + n2 * 2 ^-q2 = (n1 + n2 * 2 ^{(q1 - q2)} ) * ^-q1 ।
दूसरे कार्यकाल में कारक 2 ^{(q1 - q2)} का अर्थ अनिवार्य रूप से एक प्रतिपादक की संख्या को कम करने के लिए एक अंकगणितीय पारी है।
यह ध्यान देने योग्य है कि गणना परिणाम भी वांछित घातांक मान पर लाने के लिए स्थानांतरित किया जा सकता है।
सी कोड स्निपेट:

int32_t a = 0x1000L; // q15: a = 0.125 int32_t b = 0x20000L; // q20: b = 0.125 int32_t c = 0; // q25 c = (a << 5) + b; // q20: (a * 2 ^ (20 - 15) + b); c = 0x40000L (0.25  q20) c <<= 5; // q25: c = 0x800000L (0.25  q25)

उदाहरण से, यह समझा जा सकता है कि वास्तविक कंप्यूटिंग में, यहां तक कि इस तरह के एक सरल ऑपरेशन में भी, विचार के लिए जगह है। यह हमेशा सवालों को ध्यान में रखने लायक है:

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

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

गुणन

फिक्स्ड-पॉइंट गुणा ट्रिकी संरेखण और एकल घातांक में कमी के बिना किया जा सकता है। फिर भी, गुणा एक बल्कि खतरनाक ऑपरेशन है, जो अक्सर सटीकता का नुकसान होता है और हैंडलिंग में विशेष देखभाल की आवश्यकता होती है।
आइए गुणन के गणितीय विवरण से शुरू करें:
आज्ञा दें कि दो संख्याएँ a = n1 * 2 ^-q1 और b = n2 * 2 ^{-q2 हैं} ।
तब:
a * b = n1 * 2 ^-q1 * n2 * 2 ^-q2 = n1 * n2 * 2 ^{- (q2 + q1)} ।
यह अभिव्यक्ति से देखा जा सकता है कि गुणा करने पर संख्याओं के घातांक: 2 ^{- (q2 + q1)} । इस लेख में डेटा की थोड़ी गहराई पर विचार नहीं किया गया है, अभी के लिए यह याद रखना पर्याप्त है कि अतिप्रवाह और सटीकता के नुकसान के बिना सुरक्षित गुणन के लिए, परिणाम की थोड़ी गहराई कारकों की कुल बिट गहराई से कम नहीं होनी चाहिए।
घातांक के जोड़ के कारण, गुणा परिणाम को आगे की गणना करने के लिए समायोजित किया जाना है। जैसे ही घातांक घटता है, परिणाम के कम से कम महत्वपूर्ण बिट्स को छोड़ दिया जाता है। यानी सटीकता का नुकसान है। आप सटीकता के नुकसान को कम कर सकते हैं (और कभी-कभी यह आवश्यक है), लेकिन नुकसान से निपटने के तरीके हमेशा ओवरहेड से जुड़े होते हैं।
सी कोड स्निपेट:

 int32_t a = 0x8000L; // q16: a = 0.5 int32_t b = 0x100000L; // q21: b = 0.5 int32_t c = 0xC0000L; // q20: c = 0.75 int64_t d; //      ,    . d = (int64_t)a * (int64_t)b; // q37 = q16 * q21; d = 0x800000000L (0.25 in q37) d >>= 17; // q37 / 2 ^ 17 = q20 c += (int32_t)d; // q20: c = 0x100000 (1 in q20)

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

विभाजन

चलो विभाजन के लिए गणितीय अभिव्यक्ति के साथ शुरू करते हैं:
आज्ञा दें कि दो संख्याएँ a = n1 * 2 ^-q1 और b = n2 * 2 ^{-q2 हैं} ।
तब:
a / b = n1 * 2 ^-q1 / (n2 * 2 ^-q2 ) = n1 / n2 * 2 ^{- (q1 - q2)} ।
कारक 2 ^{- (q1 - q2) का} अर्थ है कि विभाजन करते समय, घातांक स्वतः कम हो जाता है। यदि कोई कार्रवाई नहीं की जाती है, तो महत्वपूर्ण अंकों का हिस्सा स्वचालित रूप से छोड़ दिया जाता है।
सुधार विधि स्पष्ट है - यह आवश्यक है कि विभाजन की गहराई को पहले से बढ़ा दिया जाए ताकि विभाजन के परिणामस्वरूप महत्वपूर्ण बिट्स की वांछित संख्या प्राप्त हो सके:
a / b = n1 * 2 ^-q1 * 2 ^q3 / (n2 * 2 ^-q2 ) = n1 / n2 * 2 ^{- (q1 - q2 + q3)} ।
इस प्रकार, निजी घातांक को क्यू 3 डिस्चार्ज द्वारा बढ़ाया जाता है।
सी कोड स्निपेट:

 int32_t a = 0x4000L; // q15: a = 0.5 int32_t b = 0x80000L; // q20: b = 0.5 int32_t c = 0; // q25 int64_t d; //      . d = (int64_t)a << 30; // q45: d = 0x200000000000; (0.5 in q45) c = (int32_t)(d / (int64_t)b); // q25: c = 0x2000000; (1 in q25)

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

 int32_t a = 0x4000L; // q15: a = 0.5 int32_t b = 0x80000L; // q20: b = 0.5 int32_t c = 0; // q25 int norm_shift = norm(a); //   . norm_shift = 16 c = ((a << norm_shift) / b); // q(-5): c = 0x800 (1*2^norm in q(-5)) c <<= (30 - norm); // q25: c = 0x2000000; (1 in q25)

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

साहित्य और विभिन्न स्रोत कोड में स्वीकार किए जाने वाले अंकन

लेख के अंतिम खंड में, मैं एक बार फिर से फिक्स्ड-पॉइंट एल्गोरिदम के विवरण में प्रयुक्त आम तौर पर स्वीकार किए गए नोटेशन पर लौटना चाहूंगा।
यह एक अधिक महत्वपूर्ण बिंदु है कि आपको अन्य लोगों के स्रोतों को पढ़ते समय ध्यान देना होगा।
निश्चित बिंदु संख्या को नामित करने के लिए सबसे आम दो विकल्प हैं:

Q M - जहाँ M दशमलव बिंदु के बाद अंकों की संख्या है। लेख में प्रयुक्त
Q N.M - जहां N , दशमलव बिंदु से पहले अंकों की संख्या है, साइन बिट को छोड़कर, और M - के बाद।

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

 a = 0x1000; // Q15 b = 0x8000; // Q15 int32_t c = a + b; // ???     ,      . a = 0x2000; // Q0.15 b = 0x8000; // Q16.15 c = a + b; // Q0.15 + Q16.15 = Q16.15: 16 + 15 = 31  + 1

दूसरे अंकन में टिप्पणियाँ स्पष्ट रूप से अधिक सुविधाजनक हैं।
मैं यहां टिप्पणियों की उपयोगिता पर चर्चा नहीं करूंगा (हर जगह वे जहां से भी दूर हैं), मैं केवल यह कहूंगा कि अपने लिए मैं गणना करते समय हमेशा चर के प्रकारों को चित्रित करता हूं, ताकि गलतियों को न करें और घातांक की कमी के साथ भ्रमित न हों।
यदि सिद्धांत में कोई टिप्पणी नहीं है, तो कोड को पढ़ना और समझना निश्चित रूप से जटिल है, लेकिन यदि आप भ्रमित हो जाते हैं, तो आप हमेशा क्यू-अंकन में इस तरह के डिक्रिप्शन को जोड़ सकते हैं यह समझने के लिए कि यह "यह 4 से बाईं ओर शिफ्ट किया गया था, और फिर दाईं ओर 10 पर शिफ्ट हो गया"।
मैं ध्यान देता हूं कि टिप्पणियों में हाल ही में प्रकाशित Google GIPS इंजन ( webrtc ) के स्रोत सबसे अधिक बार वे बस क्यू लिखते हैं, जिसका अर्थ है कि संख्या के सभी बिट्स आंशिक भाग को आवंटित किए जाते हैं। यह मुझे व्यक्तिगत रूप से भ्रमित करता है, क्योंकि मुझे स्पष्ट करना होगा कि कोड कैसे काम करता है, इसे स्पष्ट करने के लिए परिभाषाओं के माध्यम से अफवाह उड़ाई जाती है।
अपने लिए, मैं एक और नोटेशन का उपयोग करता हूं, जो ऊपर से अलग है और एक निश्चित बिंदु के साथ काम करने के लिए MATLAB टूलबॉक्स नोटेशन के करीब है। यह गणित को चर की क्षमता से जोड़ता है और जीवन को सरल बनाता है जब एक ऑपरेशन (क्षमता और प्रतिपादक) के परिणाम का मूल्यांकन करना आवश्यक होता है।
मेरी टिप्पणियों में, मैं QN.M के रूप में निश्चित बिंदु संख्याओं को चिह्नित करता हूं , जहां N संख्या की थोड़ी क्षमता है, दशमलव बिंदु के बाद M अंकों की संख्या है।
मुझे समझाएं कि मुझे ऐसी योजना अपने लिए सुविधाजनक क्यों लगी:

किसी संख्या की थोड़ी गहराई जानने के बाद, आप हमेशा परिणाम की थोड़ी गहराई का अनुमान लगा सकते हैं, अर्थात इसका प्रतिनिधित्व करने के लिए पर्याप्त एक चर प्रकार का चयन करें।
मुझे व्यक्तिगत रूप से क्यू (-एन) फॉर्म के रिकॉर्ड को पढ़ने में असुविधा हो रही है । एम , जो कि आंशिक भाग के लिए अंकों के दाईं ओर और कमी की ओर एक प्रदर्शन करने के बाद दूसरे अंकन में दिखाई देता है। उदाहरण के लिए, 16-बिट संख्या के लिए एक रिकॉर्ड जिसमें घातांक 18 है ( n * 2 ^-18 ) मेरे लिए q16.18 दिखता है, और दूसरा अंकन के लिए q (-3) .18 है। पहले अंकन में रिकॉर्ड, जैसा कि पहले ही उल्लेख किया गया है, किसी भी मामले में हमें गणना की सटीकता को समझने के लिए परिभाषा की ओर मुड़ने के लिए मजबूर करता है, लेकिन इस मामले में यह परिभाषा के बिना भी स्पष्ट नहीं है: अग्रणी महत्वपूर्ण बिट्स को पहले ही त्याग दिया गया है या नहीं।
अपने स्वयं के संकेतन का उपयोग करके गणना करने के बाद, मेरे लिए यह देखना आसान है कि किस चर में थोड़ी गहराई में परिणाम फिट होगा, और घातांक को कैसे संरेखित करें। उदाहरण के लिए, q32.15 * q16.4 = q48.19 । यह तुरंत स्पष्ट है कि परिणाम की पूरी प्रस्तुति के लिए, 48-बिट की आवश्यकता है। दूसरी संकेतन में, प्रविष्टि q16.15 * q11.4 = q27.19 की तरह दिखती है , और आपको उस 27+ 19 = 47 + 1 की गणना करनी होगी जो कि पहले कारक + 1 संकेत से दूसरे = 48 बिट्स से होगी । एक तिपहिया, लेकिन अच्छा है। खासकर जब बहुत सारे सोर्स कोड हों।

एक निश्चित बिंदु का उपयोग करने के पेशेवरों और विपक्षों के बारे में

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

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

विपक्ष:

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

निष्कर्ष में

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

संदर्भ

अद्यतन:

नोटेशन जो मैं उपयोग करता हूं, जैसा कि यह निकला, MATLAB से मेरे पास आया। मुझे अभी भी याद नहीं है कि मैंने अपने समय में कहां खोदा था। धन्यवाद nerudo , वापस बुला लिया। ऑब्जेक्ट बनाने के लिए, निर्दिष्ट पैकेज का फिक्स्ड-पॉइंट टूलबॉक्स केवल "बिट्स की संख्या" + "भिन्न प्रति बिट्स की संख्या" का उपयोग करता है, एक स्पष्ट संकेत के साथ: एक हस्ताक्षरित या अहस्ताक्षरित संख्या।
इस तथ्य के बावजूद कि उदाहरण 8-, 16-, 32- और 64-बिट शब्दों में प्रचुर मात्रा में हैं, मैंने केवल x86 और अन्य सामान्य प्रयोजन प्रोसेसर के विवरण संलग्न करने का प्रयास नहीं किया। यह सरल है, सबसे पहले, C में उदाहरण देना आसान है, और दूसरी बात, मैं FPGA, ASIC, आदि के विशेषज्ञ से बहुत दूर हूं (VERILOG, आदि पढ़ें), जो आपको स्पष्ट रूप से बताने के लिए मनमाने ढंग से बिट गहराई चुनने की अनुमति देते हैं। । शायद जो लोग इस मामले में अधिक जानकार हैं वे उदाहरण के साथ अपने विषयों के साथ लेख को पूरक कर पाएंगे।
अंकन विवरण यह नहीं कहते हैं कि अहस्ताक्षरित संख्याओं के साथ क्या करना है। सामान्य तौर पर, जिन प्राथमिक स्रोतों में मैंने उन्हें देखा, वे भी संकेतों के बारे में कुछ नहीं कहते हैं। मूल रूप से, यह निहित था कि सभी संख्याएँ महत्वपूर्ण हैं। मैं अभी यह नहीं कह सकता कि लेखकों ने हस्ताक्षरित संख्याओं का रिकॉर्ड कैसे देखा। मैं केवल इस बात पर ध्यान देता हूं कि मेरे / matlab संकेतन में मैंने अहस्ताक्षरित संख्या को चिह्नित करने के लिए Q के बाद 'u' अक्षर जोड़ा।

निश्चित बिंदु गणना। मूल सिद्धांत (भाग 1)