सी ++ में फिक्स्ड-पॉइंट अंकगणित

आज मैं आपको बताऊंगा कि निश्चित-बिंदु क्या है, इसकी आवश्यकता क्यों है और इसका उपयोग कैसे किया जा सकता है।

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

इस समस्या का एक समाधान है, जो पूर्णांक प्रकार पर एक निश्चित बिंदु के साथ गणना करने की अनुमति देता है।

इस प्रकार का सिद्धांत एन बिट्स द्वारा संख्या की एक निश्चित पारी है, जिसके परिणामस्वरूप अंश संख्या को पूर्णांक के रूप में दर्शाया जा सकता है और इसमें बिंदु के बाद 2 ^ एन की सटीकता होगी। 8 बिट्स (2 ^ 8 = 1024) के क्रम के फ़्लोटिंग-पॉइंट नंबर को एक निश्चित-पॉइंट संख्या में परिवर्तित करने का एक उदाहरण।

फ़्लोटिंग-पॉइंट संख्या को निश्चित-पॉइंट संख्या में परिवर्तित करने का एक उदाहरण यहाँ दिया गया है:

Fixed(12345,6789) = 1024 * 12345,6789 = 12641975,<s>1936</s> 

यह संख्या, बिंदु के बाद, दशमलव बिंदु के बाद 2 ^ 8 की सटीकता है।

फ़्लोटिंग-पॉइंट संख्या के लिए एक निश्चित-बिंदु संख्या का अनुवाद करने का एक उदाहरण।

 Float(12641975) = 12641975 / 1024 = 12345,678<s>7109375</s> 

इस मामले में, रिवर्स ट्रांसलेशन के बाद की संख्या का फॉर्म 12345.6787109375 है और अवधि के बाद सटीक 3 अंक है, अधिकतम सटीकता वास्तव में 2 ^ 8 = 1024 है।

निश्चित-बिंदु प्रकार पर गणना कैसे होती है?

सम और अंतर ऑपरेशन साधारण पूर्णांक ऑपरेशन के बराबर होते हैं।

Fixed(x) + Fixed(y) Fixed(x) - Fixed(y) , किसी भी क्रम में
(1024 * x) + (1024 * y) (1024 * x) - (1024 * y)

इस तरह की संख्याओं का गुणन इस रूप में किया जाता है।
(Fixed(x) * Fixed(y)) / p , यह बराबर है, 8 बिट्स के एक आदेश के साथ
((1024 * x) * (1024 * y)) / 1024

प्रभाग।
(Fixed(x) * p) / Fixed(y) , 8 बिट्स के ऑर्डर के साथ भी, यह
(1024 * 1024 * x)*(1024 * y)

बाढ़

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

• 64-बिट पूर्णांक प्रकार में गणना करें।
• "असंतुष्ट" रूप में गणना करें, उदाहरण के लिए, जब गुणा, (xi + xf) * (yi + yf) = xi * yi + xf * yf + xi * yf + yi / xf, उपसर्ग i और f का अर्थ है पूरा भाग और उसके बाद का भाग। बिंदु।

C ++ में फिक्स्ड-पॉइंट के साथ काम करने के लिए क्लास

 #define DIGITS 1024 //  #define EPS 20 //       using namespace std; typedef signed int __int32_t; class Fixed { signed int x; Fixed(signed int a){ x = a; } public: Fixed(){ x = 0; } static Fixed fromInt(signed int val){ return Fixed(val*DIGITS); } static Fixed fromFloat(float val){ return Fixed((signed int)(val*DIGITS)); } float fixed2float(){ return ((float)x)/DIGITS; } Fixed sum(Fixed a,Fixed b){ return Fixed(a.x+bx); } Fixed diff(Fixed a,Fixed b){ return Fixed(ax-bx); } Fixed mul(Fixed a,Fixed b){ signed int c=ax*bx; if(c/bx != ax){ // Overflow! signed int i1 = ax/DIGITS; signed int i2 = bx/DIGITS; signed int f1 = (ax&(DIGITS-1)); signed int f2 = (bx&(DIGITS-1)); return Fixed((i1*i2)*DIGITS+(f1*f2)/DIGITS+i1*f2+i2*f1); }else{ return Fixed(c/DIGITS); } } Fixed div(Fixed a,Fixed b){ if(ax>(1<<21)){ // Overflow! signed int i = ax/DIGITS; signed int f = (ax&(DIGITS-1)); return Fixed(((i*DIGITS)/bx)*DIGITS+(f*DIGITS)/bx); }else{ return Fixed((ax*DIGITS)/bx); } } Fixed sqrt(Fixed k){ Fixed tmp(0); tmp.x = kx/2; signed int min = 0; signed int max = kx; Fixed quick(0); do{ tmp.x = (min+max)/2; quick = Fixed::mul(tmp,tmp); if(abs(quick.xk.x)<EPS) return Fixed(tmp); if(quick.x>kx){ max = tmp.x; }else{ min = tmp.x; } }while(true); } };