गुणन अतिप्रवाह

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

unsigned long long getTickCount(); 

अहस्ताक्षरित लंबा लंबा 64 बिट्स है। सिस्टम में भौतिक समय इकाइयों में बदलने के लिए एक स्थिरांक है:

 const unsigned long long TICKS_PER_SECOND = 1999000001ULL; 

शब्दार्थ के साथ नैनोसेकंड getNsec (अहस्ताक्षरित लंबी लंबी टिक) में टिक्स के अनुवाद के कार्य को परिभाषित करना आवश्यक है:

 unsigned long long getNsecNaive(unsigned long long ticks) { static const unsigned long long NSEC_PER_SECOND = 1000000000ULL; unsigned long long nsec = NSEC_PER_SECOND * ticks / TICKS_PER_SECOND; return nsec; } 

GetNsec () फ़ंक्शन यथासंभव सटीक होना चाहिए। टिक्स पैरामीटर बड़ा या छोटा हो सकता है। छोटे टिक्स के लिए (कहें, 2 ^ 34 तक), आपको निम्नलिखित क्रम में गणना करने की आवश्यकता है:

 (NSEC_PER_SECOND * ticks) / TICKS_PER_SECOND 

यही है, पहले गुणा करें, फिर विभाजित करें। NSEC_PER_SECOND <2 ^ 30 के बाद से, गुणन अतिप्रवाह का कारण नहीं होगा, क्योंकि इसका परिणाम 2 ^ 64 से कम होगा।
बड़े टिक्स के लिए, चूंकि गुणन अतिप्रवाह का कारण बन सकता है, इसलिए निम्न क्रम में संचालन करना बेहतर है:

 NSEC_PER_SECOND * (ticks / TICKS_PER_SECOND) 

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

 (NSEC_PER_SECOND / TICKS_PER_SECOND) * ticks 

और

 ticks / (TICKS_PER_SECOND / NSEC_PER_SECOND) 

पहला हमेशा शून्य देता है, और दूसरा - टिक, यानी लगभग 50% त्रुटि (जो इस मामले में 0.1% तक कम हो सकती है, लेकिन यह त्रुटि अभी भी सबसे छोटी संभव नहीं है)।
तो, सबसे अच्छे मामले में, हमें दूसरी सटीकता मिलती है। बढ़ती सटीकता की समस्या को निम्नलिखित तरीकों से हल किया जा सकता है (बढ़ती वरीयता के क्रम में):

1. वास्तविक (डबल) प्रकारों के साथ गणना करें
2. 128-बिट पूर्णांक के लिए तर्क वितर्क करें
3. मल्टीडिव () फ़ंक्शन का उपयोग करें

ये दृष्टिकोण प्लेटफ़ॉर्म (प्रोसेसर) सीमाओं, प्रोग्रामिंग वातावरण और पुस्तकालयों और परियोजना आवश्यकताओं के कारणों के लिए लागू नहीं हो सकते हैं।
हम निम्नलिखित दृष्टिकोण का उपयोग करते हैं। मान लीजिए, TICKS_PER_SECOND द्वारा टिकों को विभाजित करके, हम सेकंड के अपूर्ण भाग और शेष r प्राप्त करते हैं:

 unsigned long long seconds = ticks / TICKS_PER_SECOND; unsigned long long r = ticks % TICKS_PER_SECOND; 

फिर टिक = सेकंड * TICKS_PER_SECOND + r। सूत्र में nsec के लिए:
nsec = NSEC_PER_SECOND * (सेकंड * TICKS_PER_SECOND + r) / TICKS_PER_SECOND = NSEC_PER_SECOND * सेकंड + (NSIC_PER_SECOND * r) / TICKS_PER_SECOND। चूंकि r <TICKS_PER_SECOND, (NSEC_PER_SECOND * r) कभी भी ओवरफ़्लो नहीं देगा। सारांश समारोह:

 unsigned long long getNsec(unsigned long long ticks) { static const unsigned long long NSEC_PER_SECOND = 1000000000ULL; return NSEC_PER_SECOND * (ticks / TICKS_PER_SECOND) + ((NSEC_PER_SECOND)*(ticks % TICKS_PER_SECOND))/TICKS_PER_SECOND; } 

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