CODEWITHSUNDEEP
dartcryptographybitwise-operators
AKushWarrior
AKushWarrior

Reputation: 544

How would one create a bitwise rotation function in dart?

I'm in the process of creating a cryptography package for Dart (https://pub.dev/packages/steel_crypt). Right now, most of what I've done is either exposed from PointyCastle or simple-ish algorithms where bitwise rotations are unnecessary or replaceable by >> and <<.

However, as I move toward complicated cryptography solutions, which I can do mathematically, I'm unsure of how to implement bitwise rotation in Dart with maximum efficiency. Because of the nature of cryptography, the speed part is emphasized and uncompromising, in that I need the absolute fastest implementation.

I've ported a method of bitwise rotation from Java. I'm pretty sure this is correct, but unsure of the efficiency and readability:

My tested implementation is below:


int INT_BITS = 64; //Dart ints are 64 bit

static int leftRotate(int n, int d) { 

    //In n<<d, last d bits are 0.  
    //To put first 3 bits of n at 
    //last, do bitwise-or of n<<d with 
    //n >> (INT_BITS - d)

    return (n << d) | (n >> (INT_BITS - d)); 
} 

static int rightRotate(int n, int d) { 

    //In n>>d, first d bits are 0.  
    //To put last 3 bits of n at 
    //first, we do bitwise-or of n>>d with 
    //n << (INT_BITS - d)

    return (n >> d) | (n << (INT_BITS - d)); 
}

EDIT (for clarity): Dart has no unsigned right or left shift, meaning that >> and << are signed right shifts, which bears more significance than I might have thought. It poses a challenge that other languages don't in terms of devising an answer. The accepted answer below explains this and also shows the correct method of bitwise rotation.

Upvotes: 1

Views: 469

Answers (1)

lrn
lrn

Reputation: 71763

As pointed out, Dart has no >>> (unsigned right shift) operator, so you have to rely on the signed shift operator.

In that case, 

int rotateLeft(int n, int count) {
  const bitCount = 64; // make it 32 for JavaScript compilation.
  assert(count >= 0 && count < bitCount);
  if (count == 0) return n;
  return (n << count) | 
      ((n >= 0) ? n >> (bitCount - count) : ~(~n >> (bitCount - count)));
}

should work.

This code only works for the native VM. When compiling to JavaScript, numbers are doubles, and bitwise operations are only done on 32-bit numbers.

Upvotes: 2

Related Questions