, wie 64-Bit-Integer in zwei 32-Bit-Integer

Question

ich eine 64-Bit-Ganzzahl in zwei 32-Bit-Integer teilen teilen möchten:

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; 

Leider weder immer die HIGHINT noch immer die lowInt funktioniert ... geben Sie mir Könnte jemand die Antwort Wie muss ich die bitweisen Operatoren verwenden? benutzerdefinierte große Integer-Bibliotheken

Grüße

Answer 1

EDIT JavaScript für ganze Zahlen using IEEE double precision format, so gibt es keine Möglichkeit, ohne Verlust an Präzision beliebige 64-Bit-Integer zu speichern, es sei denn durch. Bitweise Operationen auf potentiell beschnittenen Werten machen offensichtlich keinen Sinn.

---

Im Allgemeinen für Sprachen, die Unterstützung 64-Bit-Integer tun:

Ein 64-Bit-Muster von Einsen ist 0xffffffffffffffff. Um die oberen 32 Bits zu extrahieren, müssen Sie um 32: >> 32 verschieben. Um die unteren 32 Bit zu extrahieren, einfach und sie mit 32 Einsen: & 0xffffffff.

Sie haben das Prinzip richtig - Ihre Arithmetik, wie viele Bits zu verschieben oder zu maskieren ist einfach falsch.

Answer 2

In JavaScript werden alle Zahlen mit 53 Bits dargestellt. JavaScript verwendet Gleitkommadarstellung intern alle Zahlen zu speichern, was bedeutet, dass ganze Zahlen als Gleitkommazahlen gespeichert werden (Mantisse 53 Bit)

So mit 53 Bits wir max darstellen können 2^53 = 9007199254740992.

Aber Sie können die Rechtsverschiebung und die AND-Binäroperationen nicht verwenden, um niedrigere 32 Bits und höhere 21 Bits selbst aus 53-Bit-Zahlen zu extrahieren.

Der Grund ist, wenn wir den binären Operator auf eine beliebige Zahl anwenden - Javascript zuerst diese Zahl in 32-Bit-Zahl mit Vorzeichen konvertieren, die binäre Operation anwenden und das Ergebnis zurückgeben. Dies bedeutet, dass jedes Bit, das an einer höheren Position als 32 sitzt, verworfen wird.

Ich habe folgenden Ansatz verwendet, um die höheren (21 Bit) und niedrigeren (32 Bit) Teile von einer positiven Zahl < = 2^53 zu extrahieren.

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); 

Nur um zu bestätigen, über Logik korrekt ist, können versuchen, die grossezahl von zwei Teilen bauen

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