मैं जावास्क्रिप्ट में 64-बिट (हस्ताक्षरित) पूर्णांक के बिटवाई रोटेशन का अनुकरण कैसे करूं?

Question

मुझे जावास्क्रिप्ट में 64-बिट पूर्णांक की गोलाकार बाएं शिफ्ट करने की आवश्यकता है। हालांकि:

• जावास्क्रिप्ट संख्या डबल्स हैं
• जावास्क्रिप्ट उन्हें 32-बिट पर हस्ताक्षर किए ints में धर्मान्तरित जब आप < < के साथ शुरू और >> और >>> और ~ और बिट-twiddling के सभी व्यापार। और फिर जब आप कर लेंगे तो यह युगल पर वापस आ जाएगा। मुझे लगता है।
• मुझे साइन नहीं चाहिए। और मैं निश्चित रूप से दशमलव बिट्स नहीं चाहता। लेकिन मुझे निश्चित रूप से 64 बिट चाहिए।

तो, मैं 64-बिट मान के थोड़ा सा बाएं रोटेशन कैसे करूं?

Answer 1

अपने 64-बिट संख्या को अलग उच्च और निम्न हिस्सों के रूप में रखें। एन छोड़ दिया करने के लिए घुमाएं जब एन < 32:

hi_rot = ((hi << N) | (lo >>> (32-N))) & (0xFFFFFFFF)

lo_rot = ((lo << N) | (hi >>> (32-N))) & (0xFFFFFFFF)

एन> = 32 है, तो एन से 32 घटाना हैं, हाय और लो स्वैप, और फिर ऊपर से करते हैं।

Answer 2

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

Answer 3

एकमात्र तरीका मुझे लगता है कि यह एक इंट 64 वर्ग बनाना है जिसमें आंतरिक रूप से दो 32 बिट पूर्णांक होते हैं और उनके बीच ले जाकर स्थानांतरण करते हैं।

Answer 4

यहां एक मान आधारित घुमाव है।

double d = 12345678901.0; 
// get high int bits in hi, and the low in 
int hi = (int)(d/16.0/16.0/16.0/16.0); 
int low = (int)d; 

int rot = 3; // thus * 8 
int newhi = (low >> (32 - rot)) | (hi << rot); 
int newlow = (hi >> (32 - rot)) | (low << rot); 

double newdouble = ((double)hi * 16.0 * 16.0 * 16.0 * 16.0) + (double)low; 

Answer 5

रूप @Doug करी डाल दिया आप दो नंबर के रूप में 64-बिट संख्या का प्रतिनिधित्व करने के लिए, तो उन पर बिट के लिहाज से कार्य कर की जरूरत है। कोड मैं का उपयोग किया है है: console.log(new Long(0,1).rotateLeft(4)); तो _high और _low गुण निरीक्षण:

//Constructor for a Long.. 
function Long(high, low) { 
    //note: doing "or 0", truncates to 32 bit signed 
    //big-endian 2's complement int.. 
    this._high = high | 0; 
    this._low = low | 0; 
} 
Long.prototype.rotateLeft = function(bits) { 
    var newHigh; 
    if(bits === 32){ //just switch high and low over in this case.. 
     newHigh = this._low; 
     this._low = this._high; 
     this._high = newHigh; 
    } else { 
     newHigh = (this._high << bits) | (this._low >>> (32-bits)); 
     this._low = (this._low << bits) | (this._high >>> (32-bits)); 
     this._high = newHigh; 
    } 
    return this; //for chaining.. 
}; 
//Rotates the bits of this word round to the right (max 32).. 
Long.prototype.rotateRight = function(bits) { 
    var newHigh; 
    if(bits === 32){ //just switch high and low over in this case.. 
     newHigh = this._low; 
     this._low = this._high; 
     this._high = newHigh; 
    } else { 
     newHigh = (this._low << (32-bits)) | (this._high >>> bits); 
     this._low = (this._high << (32-bits)) | (this._low >>> bits); 
     this._high = newHigh; 
    } 
    return this; //for chaining.. 
}; 

इसे चलाने की कोशिश का उपयोग करें।

Answer 6

मैं यह कोशिश करेंगे:

function rotate(hi,lo,n) { 
    var N = n/%32; 
    if(Math.floor(n/32)%2) { 
     var hi_rot = ((hi << N) | (lo >>> (32-N))) & (~0); 
     var lo_rot = ((lo << N) | (hi >>> (32-N))) & (~0); 
    } else { 
     var hi_rot = ((lo << N) | (hi >>> (32-N))) & (~0); 
     var lo_rot = ((hi << N) | (lo >>> (32-N))) & (~0); 
    } 
    return (hi_rot<<32)+lo_rot; 
}