¿Cómo simulo una rotación a nivel de bits de un entero de 64 bits (sin signo) en JavaScript?

Question

Necesito realizar un desplazamiento circular a la izquierda de un entero de 64 bits en JavaScript. Sin embargo: los números

• JavaScript son dobles
• JavaScript los convierte en enteros con signo de 32 bits cuando se inicia con la < < y el >> y el >>> y el ~ y todos los bits haciendo girar negocio. Y luego vuelve al doble cuando terminas. Creo.
• No quiero el letrero. Y definitivamente no quiero los bits decimales. Pero definitivamente quiero 64 bits.

Entonces, ¿cómo realizo una rotación a la izquierda en modo bit de un valor de 64 bits?

Answer 1

Mantenga su número de 64 bits como mitades altas y bajas separadas. Para girar a la izquierda N cuando N < 32:

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

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

si n> = 32, entonces restar 32 a partir de N, intercambiar hi y lo, y luego hacer lo anterior.

Answer 2

Creo que sí, aunque no es la manera más eficiente, convertir el número a una cadena en formato binario (64 bits), usar subcadena para mover el carácter al principio y anexarlo al final (para girar a la izquierda) y convierte la forma binaria de nuevo a número. Estoy seguro de que puede averiguar cómo convertir un número decimal a su forma binaria en una cadena y viceversa.

Answer 3

La única forma en que creo que se puede hacer es crear una clase int64 que internamente contenga dos enteros de 32 bits y realice el cambio llevando entre ellos.

Answer 4

Aquí hay una rotación basada en valores.

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

Como @Doug Currie puso necesita para representar el número de 64 bits como dos números, y luego hacer las operaciones bit a bit sobre ellos. El código que he usado es:

//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.. 
}; 

para usarlo intente ejecutar: console.log(new Long(0,1).rotateLeft(4)); continuación, la inspección de las propiedades _high y GIRATORIO BAJO.

Answer 6

me gustaría probar esto:

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