दो 32 बिट पूर्णांकों

Question

को 64 बिट पूर्णांक विभाजित करने के लिए कैसे मैं दो 32 बिट पूर्णांक में एक 64 बिट पूर्णांक विभाजित करना चाहते हैं: न तो highInt हो रही है और न ही हो रही lowInt काम करता है ... किसी ने मुझसे जवाब दे सकता है

var bigInt = 0xffffff; 

var highInt = bigInt >> 8 // get the high bits 0xfff 
var lowInt = bigInt // cut of the first part (with &)? 

console.log(highInt); // 0xfff 
console.log(lowInt); // 0xfff 

// set them together again 
var reBigInt = (highInt << 8) + lowInt; 

दुर्भाग्य से मुझे बिटवाई ऑपरेटरों का उपयोग करने की ज़रूरत है?

संबंध

Answer 1

संपादित जावास्क्रिप्ट पूर्णांकों using IEEE double precision format का प्रतिनिधित्व करता है, इसलिए वहाँ कस्टम बड़ा पूर्णांक पुस्तकालयों के माध्यम से छोड़कर, सटीक की हानि के बिना मनमाने ढंग से 64 बिट पूर्णांकों स्टोर करने के लिए कोई रास्ता नहीं है। संभावित रूप से फसल वाले मूल्यों पर बिटवाई ऑपरेशंस स्पष्ट रूप से कोई समझ नहीं लेते हैं।

---

सामान्य तौर पर, भाषाओं ऐसा समर्थन 64 बिट पूर्णांकों के लिए:

लोगों का एक 64-बिट पैटर्न 0xffffffffffffffff है। ऊपरी 32 बिट्स निकालने के लिए, आपको 32: >> 32 द्वारा स्थानांतरित करने की आवश्यकता है। निचले 32 बिट निकालने के लिए, बस और 32 लोगों के साथ: & 0xffffffff।

आपको सिद्धांत सही मिला - आपके अंकगणित पर कितने बिट्स को स्थानांतरित करना या मुखौटा करना गलत है।

Answer 2

जावास्क्रिप्ट में सभी नंबरों को 53 बिट्स के प्रयोग किया जाता है। जावास्क्रिप्ट जिसका अर्थ है कि पूर्णांक चल बिन्दु संख्या (अपूर्णांश 53 बिट है)

तो 53 बिट के साथ हम अधिकतम प्रतिनिधित्व कर सकते हैं के रूप में जमा हो जाती है, सभी नंबरों को आंतरिक रूप से स्टोर करने के लिए चल बिन्दु प्रतिनिधित्व का उपयोग करता है 2^53 = 9007199254740992.

लेकिन आप 53 बिट संख्याओं से भी कम 32 बिट्स और उच्च 21 बिट्स निकालने के लिए सही शिफ्ट और बाइनरी ऑपरेशंस का उपयोग नहीं कर सकते हैं।

कारण यह है कि जब हम किसी भी संख्या पर बाइनरी ऑपरेटर लागू करते हैं - जावास्क्रिप्ट पहले उस संख्या को 32 बिट हस्ताक्षरित संख्या में परिवर्तित करता है, बाइनरी ऑपरेशन लागू करता है और परिणाम देता है। इसका मतलब यह है कि 32 से अधिक की स्थिति में बैठे किसी भी बिट को त्याग दिया जाएगा।

मैंने सकारात्मक संख्या < = 2^53 से उच्च (21 बिट) और निचले (32 बिट्स) भाग निकालने के लिए निम्नलिखित दृष्टिकोण का उपयोग किया है।

var bigNumber = Math.pow(2, 53); // 9007199254740992 
var bigNumberAsBinaryStr = bigNumber.toString(2); // '100000000000000000000000000000000000000000000000000000' 
// Convert the above binary str to 64 bit (actually 52 bit will work) by padding zeros in the left 
var bigNumberAsBinaryStr2 = ''; 
for (var i = 0; i < 64 - bigNumberAsBinaryStr.length; i++) { 
    bigNumberAsBinaryStr2 += '0'; 
}; 

bigNumberAsBinaryStr2 += bigNumberAsBinaryStr; 

var lowInt = parseInt(bigNumberAsBinaryStr2.substring(0, 32), 2); 
var highInt = parseInt(bigNumberAsBinaryStr2.substring(32), 2); 

बस ऊपर तर्क सही है की पुष्टि के लिए, चलो दो भागों

Assert((lowInt * Math.pow(2, 32) + highInt) === bigNumber);