come dividere a 64 bit integer a due interi a 32 bit

Question

voglio dividere un numero intero a 64 bit in due numeri interi a 32 bit:

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; 

Purtroppo né ricevendo il highInt né ricevendo il funziona lowInt ... Qualcuno potrebbe darmi la risposta come devo usare gli operatori bit a bit?

riguarda

Answer 1

EDIT JavaScript rappresenta interi using IEEE double precision format, quindi non c'è alcun modo per memorizzare arbitrari interi a 64 bit, senza perdita di precisione, se non attraverso le grandi librerie personalizzate interi. Ovviamente le operazioni bit a bit su valori potenzialmente ritagliati non hanno senso.

---

In generale, per le lingue che fanno il supporto a 64 bit interi:

Un modello a 64 bit di quelli è 0xffffffffffffffff. Per estrarre i 32 bit superiori, è necessario spostare 32: >> 32. Per estrarre il 32 bit inferiore, solo e loro con 32: & 0xffffffff.

Hai ottenuto il principio giusto: la tua aritmetica su quanti bit spostare o mascherare è semplicemente sbagliata.

Answer 2

In JavaScript tutti i numeri sono rappresentati utilizzando 53 bit. JavaScript utilizza rappresentazione in virgola mobile per memorizzare tutti i numeri internamente, il che significa che gli interi vengono memorizzate come numeri in virgola mobile (mantissa ha 53 bit)

Così con 53 bit possiamo rappresentare max 2^53 = 9007199254740992.

Ma non è possibile utilizzare il passaggio a destra e le operazioni binarie AND per estrarre meno 32 bit e più alti 21 bit anche da numeri a 53 bit.

Il motivo è quando applichiamo un operatore binario su qualsiasi numero: Javascript converte prima quel numero in numero con segno a 32 bit, applica l'operazione binaria e restituisce il risultato. Ciò significa che qualsiasi bit che si trova in una posizione superiore a 32 verrà scartato.

Ho utilizzato il seguente approccio per estrarre le porzioni superiori (21 bit) e inferiori (32 bit) da un numero positivo < = 2^53.

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

solo per confermare sopra logica è corretta, lascia provare a costruire il BigNumber da due parti

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