32 बिट चर के ओवरफ्लो

Question

वर्तमान में मैं अपने अनुप्रयोगों में से एक में समीकरण (2^A)[X + Y*(2^B)] लागू कर रहा हूं।

समस्या 32 बिट मान के ओवरफ़्लो के साथ है और मैं 64 बिट डेटा प्रकार का उपयोग नहीं कर सकता।

मान लीजिए कि B = 3 और Y = 805306367, यह 32 बिट मान बहता है, लेकिन जब X = -2147483648, परिणाम 32 बिट रेंज पर आता है।
तो मैं (Y*2^B) के परिणाम को स्टोर करना चाहता हूं। क्या कोई इस के लिए कुछ समाधान सुझा सकता है .... ए और बी -15 से 15 और X, Y से 2147483647..-2147483648 से मूल्य हो सकता है।
आउटपुट 0...4294967295 से हो सकता है।

Answer 1

यदि 32 बिट चर के लिए संख्या बहुत बड़ी है, तो आप या तो अधिक बिट्स (या तो एक बड़े चर में स्टोर करके या एकाधिक चर का उपयोग करके) का उपयोग करते हैं या आप सटीक छोड़ देते हैं और इसे एक फ्लोट में स्टोर करते हैं। चूंकि वाई MAX_INT हो सकता है, परिभाषा के अनुसार आप इसे 1 से अधिक संख्या से गुणा नहीं कर सकते हैं और फिर भी यह 32 बिट int में फिट है।

Answer 2

मैं इस मामले में गुणा के बजाय लूप का उपयोग करता हूं। कुछ इस तरह:

int newX = X; 
int poweredB = (1 << B); // 2^B 
for(int i = 0; i < poweredB ; ++i) 
{ 
    newX += Y; // or change X directly, if you will not need it later. 
} 
int result = (1 << A) * newX; 

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

Answer 3

काम में मुझे लगता है की उम्मीद समाधान इस शामिल होगा एक के लिए मूल्यों और बी के आधार पर:

• सबसे अच्छा अहस्ताक्षरित किया जाता है निम्नलिखित इसलिए एक्स और वाई के लिए चिह्नों का संग्रह करने और उनके निरपेक्ष पर कार्य करते हैं मूल्य

• स्टोर एक्स और दो चर प्रत्येक, एक उच्च 16 बिट पकड़े कम बिट्स कुछ
  पूर्णांक HIY = Y & 0xFFFF0000 जैसे अन्य पकड़े में वाई;

  int loY = y & 0x0000FFFF;

• ठीक है तो सभी चर उच्च बिट्स है कि 0

• Y * (2^बी) वास्तव में बी बिट्स द्वारा छोड़ा लिए वाई के एक बदलाव है उच्च भागों शिफ्ट

  ।यह बी बिट्स द्वारा उच्च और निम्न भागों स्थानांतरण और, जब से तुम उच्च हिस्सा स्थानांतरित कर दिया गया है के बराबर है, दोनों के संचालन उच्च और निम्न भागों में

• प्रक्रिया एक्स इसी तरह उनके 32 बिट पूर्णांक के अंदर फिट होगा

• एक्स और वाई के लक्षण के रखते हुए ट्रैक एक बिट से उच्च और निम्न भागों के लिए गणना X + Y * (2^बी)

• फिर बदलाव उच्च और निम्न दोनों परिणाम

• शामिल हों अंतिम परिणाम में उच्च और निम्न भाग

Answer 4

आप क्योंकि अपने स्थानीय सी कुछ अन्य अधिभावी कारण से उन्हें नहीं बल्कि समर्थन नहीं करता 64-बिट उपयोग नहीं कर सकते हैं, तो आप http://gmplib.org/