int64 Class / fixnum Library / Dart Documentation

int64 Class

An immutable 64-bit signed integer, in the range -2^63, 2^63 - 1. Arithmetic operations may overflow in order to maintain this range.

Implements

intx

Constructors

Code new int64._copy(int64 other) #

Constructs an int64 with the same value as an existing int64.

int64._copy(int64 other) {
  _l = other._l;
  _m = other._m;
  _h = other._h;
}

Code new int64._bits(int _l, int _m, int _h) #

Constructs an int64 with a given bitwise representation. No validation is performed.

int64._bits(int this._l, int this._m, int this._h);

Code new int64.fromInts(int top, int bottom) #

Constructs an int64 from a pair of 32-bit integers having the value ((top & 0xffffffff) << 32) | (bottom & 0xffffffff).

int64.fromInts(int top, int bottom) {
  top &= 0xffffffff;
  bottom &= 0xffffffff;
  _l = bottom & _MASK;
  _m = ((top & 0xfff) << 10) | ((bottom >> _BITS) & 0x3ff);
  _h = (top >> 12) & _MASK_2;
}

Code factory int64.fromBytesBigEndian(List<int> bytes) #

factory int64.fromBytesBigEndian(List<int> bytes) {
  int top = bytes[0] & 0xff; 
  top <<= 8;
  top |= bytes[1] & 0xff;
  top <<= 8;
  top |= bytes[2] & 0xff;
  top <<= 8;
  top |= bytes[3] & 0xff;

  int bottom = bytes[4] & 0xff; 
  bottom <<= 8;
  bottom |= bytes[5] & 0xff;
  bottom <<= 8;
  bottom |= bytes[6] & 0xff;
  bottom <<= 8;
  bottom |= bytes[7] & 0xff;

  return new int64.fromInts(top, bottom);
}

Code factory int64.fromBytes(List<int> bytes) #

factory int64.fromBytes(List<int> bytes) {
  int top = bytes[7] & 0xff; 
  top <<= 8;
  top |= bytes[6] & 0xff;
  top <<= 8;
  top |= bytes[5] & 0xff;
  top <<= 8;
  top |= bytes[4] & 0xff;

  int bottom = bytes[3] & 0xff; 
  bottom <<= 8;
  bottom |= bytes[2] & 0xff;
  bottom <<= 8;
  bottom |= bytes[1] & 0xff;
  bottom <<= 8;
  bottom |= bytes[0] & 0xff;

  return new int64.fromInts(top, bottom);
}

Code new int64.fromInt(int value) #

Constructs an int64 with a given int value.

int64.fromInt(int value) {
  bool negative = false;
  if (value < 0) {
    negative = true;
    value = -value - 1;
  }
  if (_haveBigInts) {
    _l = value & _MASK;
    _m = (value >> _BITS) & _MASK;
    _h = (value >> _BITS01) & _MASK_2;
  } else {
    // Avoid using bitwise operations that coerce their input to 32 bits.
    _h = value ~/ 17592186044416; // 2^44
    value -= _h * 17592186044416;
    _m = value ~/ 4194304; // 2^22
    value -= _m * 4194304;
    _l = value;
  }

  if (negative) {
    _l = ~_l & _MASK;
    _m = ~_m & _MASK;
    _h = ~_h & _MASK_2;
  }
}

Code new int64() #

Constructs an int64 equal to 0.

int64() : _l = 0, _m = 0, _h = 0;

Static Methods

Code int64 get MAX_VALUE() #

The maximum positive value attainable by an int64, namely 9,223,372,036,854,775,807.

static int64 get MAX_VALUE() {
  if (_MAX_VALUE == null) {
    _MAX_VALUE = new int64._bits(_MASK, _MASK, _MASK_2 >> 1);
  }
  return _MAX_VALUE;
}

Code int64 get MIN_VALUE() #

The minimum positive value attainable by an int64, namely -9,223,372,036,854,775,808.

static int64 get MIN_VALUE() {
  if (_MIN_VALUE == null) {
    _MIN_VALUE = new int64._bits(0, 0, _SIGN_BIT_VALUE);
  }
  return _MIN_VALUE;
}

Code int64 get ONE() #

An int64 constant equal to 1.

static int64 get ONE() {
  if (_ONE == null) {
    _ONE = new int64._bits(1, 0, 0);
  }
  return _ONE;
}

Code int64 get TWO() #

An int64 constant equal to 2.

static int64 get TWO() {
  if (_TWO == null) {
    _TWO = new int64._bits(2, 0, 0);
  }
  return _TWO;
}

Code int64 get ZERO() #

An int64 constant equal to 0.

static int64 get ZERO() {
  if (_ZERO == null) {
    _ZERO = new int64();
  }
  return _ZERO;
}

Code int64 parseHex(String s) #

Parses a hexadecimal String and returns an int64.

static int64 parseHex(String s) => parseRadix(s, 16);

Code int64 parseInt(String s) #

Parses a decimal String and returns an int64.

static int64 parseInt(String s) => parseRadix(s, 10);

Code int64 parseRadix(String s, int radix) #

Parses a String in a given radix between 2 and 16 and returns an int64.

static int64 parseRadix(String s, int radix) {
  if ((radix <= 1) || (radix > 16)) {
    throw "Bad radix: $radix";
  }
  int64 x = ZERO;
  int i = 0;
  bool negative = false;
  if (s[0] == '-') {
    negative = true;
    i++;
  }
  for (; i < s.length; i++) {
    int c = s.charCodeAt(i);
    int digit = int32._decodeHex(c);
    if (digit < 0 || digit >= radix) {
      throw new Exception("Non-radix char code: $c");
    }
    x = (x * radix) + digit;
  }
  return negative ? -x : x;
}

Methods

Code int64 abs() #

int64 abs() {
  return this < 0 ? -this : this;
}

Code int compareTo(Comparable other) #

int compareTo(Comparable other) {
  int64 o = _promote(other);
  int signa = _h >> (_BITS2 - 1);
  int signb = o._h >> (_BITS2 - 1);
  if (signa != signb) {
    return signa == 0 ? 1 : -1;
  }
  if (_h > o._h) {
    return 1;
  } else if (_h < o._h) {
    return -1;
  }
  if (_m > o._m) {
    return 1;
  } else if (_m < o._m) {
    return -1;
  }
  if (_l > o._l) {
    return 1;
  } else if (_l < o._l) {
    return -1;
  }
  return 0;
}

Code int hashCode() #

Returns a hash code based on all the bits of this int64.

int hashCode() {
  int bottom = ((_m & 0x3ff) << _BITS) | _l;
  int top = (_h << 12) | ((_m >> 10) & 0xfff);
  return bottom ^ top;
}

Code bool isEven() #

bool isEven() => (_l & 0x1) == 0;

Code bool isMaxValue() #

bool isMaxValue() => (_h == _MASK_2 >> 1) && _m == _MASK && _l == _MASK;

Code bool isMinValue() #

bool isMinValue() => _h == _SIGN_BIT_VALUE && _m == 0 && _l == 0;

Code bool isNegative() #

bool isNegative() => (_h >> (_BITS2 - 1)) != 0;

Code bool isOdd() #

bool isOdd() => (_l & 0x1) == 1;

Code bool isZero() #

bool isZero() => _h == 0 && _m == 0 && _l == 0;

Code int numberOfLeadingZeros() #

Returns the number of leading zeros in this int64 as an int between 0 and 64.

int numberOfLeadingZeros() {
  int b2 = int32._numberOfLeadingZeros(_h);
  if (b2 == 32) {
    int b1 = int32._numberOfLeadingZeros(_m);
    if (b1 == 32) {
      return int32._numberOfLeadingZeros(_l) + 32;
    } else {
      return b1 + _BITS2 - (32 - _BITS);
    }
  } else {
    return b2 - (32 - _BITS2);
  }
}

Code int numberOfTrailingZeros() #

Returns the number of trailing zeros in this int64 as an int between 0 and 64.

int numberOfTrailingZeros() {
  int zeros = int32._numberOfTrailingZeros(_l);
  if (zeros < 32) {
    return zeros;
  }

  zeros = int32._numberOfTrailingZeros(_m);
  if (zeros < 32) {
    return _BITS + zeros;
  }

  zeros = int32._numberOfTrailingZeros(_h);
  if (zeros < 32) {
    return _BITS01 + zeros;
  }
  // All zeros
  return 64;
}

Code int64 operator negate() #

int64 operator -() {
  // Like 0 - this.
  int sum0 = -_l;
  int sum1 = -_m + _shiftRight(sum0, _BITS);
  int sum2 = -_h + _shiftRight(sum1, _BITS);

  return new int64._bits(sum0 & _MASK, sum1 & _MASK, sum2 & _MASK_2);
}

Code int64 operator +(other) #

int64 operator +(other) {
  int64 o = _promote(other);
  int sum0 = _l + o._l;
  int sum1 = _m + o._m + _shiftRight(sum0, _BITS);
  int sum2 = _h + o._h + _shiftRight(sum1, _BITS);

  int64 result = new int64._bits(sum0 & _MASK, sum1 & _MASK, sum2 & _MASK_2);
  return result;
}

Code int64 operator *(other) #

int64 operator *(other) {
  int64 o = _promote(other);
  // Grab 13-bit chunks.
  int a0 = _l & 0x1fff;
  int a1 = (_l >> 13) | ((_m & 0xf) << 9);
  int a2 = (_m >> 4) & 0x1fff;
  int a3 = (_m >> 17) | ((_h & 0xff) << 5);
  int a4 = (_h & 0xfff00) >> 8;

  int b0 = o._l & 0x1fff;
  int b1 = (o._l >> 13) | ((o._m & 0xf) << 9);
  int b2 = (o._m >> 4) & 0x1fff;
  int b3 = (o._m >> 17) | ((o._h & 0xff) << 5);
  int b4 = (o._h & 0xfff00) >> 8;

  // Compute partial products.
  // Optimization: if b is small, avoid multiplying by parts that are 0.
  int p0 = a0 * b0; // << 0
  int p1 = a1 * b0; // << 13
  int p2 = a2 * b0; // << 26
  int p3 = a3 * b0; // << 39
  int p4 = a4 * b0; // << 52

  if (b1 != 0) {
    p1 += a0 * b1;
    p2 += a1 * b1;
    p3 += a2 * b1;
    p4 += a3 * b1;
  }
  if (b2 != 0) {
    p2 += a0 * b2;
    p3 += a1 * b2;
    p4 += a2 * b2;
  }
  if (b3 != 0) {
    p3 += a0 * b3;
    p4 += a1 * b3;
  }
  if (b4 != 0) {
    p4 += a0 * b4;
  }

  // Accumulate into 22-bit chunks:
  // .........................................c10|...................c00|
  // |....................|..................xxxx|xxxxxxxxxxxxxxxxxxxxxx| p0
  // |....................|......................|......................|
  // |....................|...................c11|......c01.............|
  // |....................|....xxxxxxxxxxxxxxxxxx|xxxxxxxxx.............| p1
  // |....................|......................|......................|
  // |.................c22|...............c12....|......................|
  // |..........xxxxxxxxxx|xxxxxxxxxxxxxxxxxx....|......................| p2
  // |....................|......................|......................|
  // |.................c23|..c13.................|......................|
  // |xxxxxxxxxxxxxxxxxxxx|xxxxx.................|......................| p3
  // |....................|......................|......................|
  // |.........c24........|......................|......................|
  // |xxxxxxxxxxxx........|......................|......................| p4

  int c00 = p0 & 0x3fffff;
  int c01 = (p1 & 0x1ff) << 13;
  int c0 = c00 + c01;

  int c10 = p0 >> 22;
  int c11 = p1 >> 9;
  int c12 = (p2 & 0x3ffff) << 4;
  int c13 = (p3 & 0x1f) << 17;
  int c1 = c10 + c11 + c12 + c13;

  int c22 = p2 >> 18;
  int c23 = p3 >> 5;
  int c24 = (p4 & 0xfff) << 8;
  int c2 = c22 + c23 + c24;

  // Propagate high bits from c0 -> c1, c1 -> c2.
  c1 += c0 >> _BITS;
  c0 &= _MASK;
  c2 += c1 >> _BITS;
  c1 &= _MASK;
  c2 &= _MASK_2;

  return new int64._bits(c0, c1, c2);
}

Code int64 operator %(other) #

int64 operator %(other) {
  if (other.isZero()) {
    throw new IntegerDivisionByZeroException();
  }
  if (this.isZero()) {
    return ZERO;
  }
  int64 o = _promote(other).abs();
  _divMod(this, o, true);
  return _remainder < 0 ? (_remainder + o) : _remainder;
}

Code int64 operator ~/(other) #

int64 operator ~/(other) => _divMod(this, _promote(other), false);

Code int64 operator &(other) #

int64 operator &(other) {
  int64 o = _promote(other);
  int a0 = _l & o._l;
  int a1 = _m & o._m;
  int a2 = _h & o._h;
  return new int64._bits(a0, a1, a2);
}

Code int64 operator |(other) #

int64 operator |(other) {
  int64 o = _promote(other);
  int a0 = _l | o._l;
  int a1 = _m | o._m;
  int a2 = _h | o._h;
  return new int64._bits(a0, a1, a2);
}

Code int64 operator ^(other) #

int64 operator ^(other) {
  int64 o = _promote(other);
  int a0 = _l ^ o._l;
  int a1 = _m ^ o._m;
  int a2 = _h ^ o._h;
  return new int64._bits(a0, a1, a2);
}

Code int64 operator ~() #

int64 operator ~() {
  var result = new int64._bits((~_l) & _MASK, (~_m) & _MASK, (~_h) & _MASK_2);
  return result;
}

Code int64 operator >>(int n) #

int64 operator >>(int n) {
  if (n < 0) {
    throw new IllegalArgumentException("$n");
  }
  n &= 63;

  int res0, res1, res2;

  // Sign extend h(a).
  int a2 = _h;
  bool negative = (a2 & _SIGN_BIT_VALUE) != 0;
  if (negative) {
    a2 += 0x3 << _BITS2; // add extra one bits on the left
  }
  
  if (n < _BITS) {
    res2 = _shiftRight(a2, n);
    if (negative) {
      res2 |= _MASK_2 & ~(_MASK_2 >> n);
    }
    res1 = _shiftRight(_m, n) | (a2 << (_BITS - n));
    res0 = _shiftRight(_l, n) | (_m << (_BITS - n));
  } else if (n < _BITS01) {
    res2 = negative ? _MASK_2 : 0;
    res1 = _shiftRight(a2, n - _BITS);
    if (negative) {
      res1 |= _MASK & ~(_MASK >> (n - _BITS));
    }
    res0 = _shiftRight(_m, n - _BITS) | (a2 << (_BITS01 - n));
  } else {
    res2 = negative ? _MASK_2 : 0;
    res1 = negative ? _MASK : 0;
    res0 = _shiftRight(a2, n - _BITS01);
    if (negative) {
      res0 |= _MASK & ~(_MASK >> (n - _BITS01));
    }
  }

  return new int64._bits(res0 & _MASK, res1 & _MASK, res2 & _MASK_2);
}

Code bool operator ==(other) #

Returns true if this int64 has the same numeric value as the given object. The argument may be an int or an intx.

bool operator ==(other) {
  if (other == null) {
    return false;
  }
  int64 o = _promote(other);
  return _l == o._l && _m == o._m && _h == o._h;
}

Code bool operator <(other) #

bool operator <(other) {
  return this.compareTo(other) < 0;
}

Code int64 operator <<(int n) #

int64 operator <<(int n) {
  if (n < 0) {
    throw new IllegalArgumentException("$n");
  }
  n &= 63;

  int res0, res1, res2;
  if (n < _BITS) {
    res0 = _l << n;
    res1 = (_m << n) | (_l >> (_BITS - n));
    res2 = (_h << n) | (_m >> (_BITS - n));
  } else if (n < _BITS01) {
    res0 = 0;
    res1 = _l << (n - _BITS);
    res2 = (_m << (n - _BITS)) | (_l >> (_BITS01 - n));
  } else {
    res0 = 0;
    res1 = 0;
    res2 = _l << (n - _BITS01);
  }

  return new int64._bits(res0 & _MASK, res1 & _MASK, res2 & _MASK_2);
}

Code int64 operator -(other) #

int64 operator -(other) {
  int64 o = _promote(other);

  int sum0 = _l - o._l;
  int sum1 = _m - o._m + _shiftRight(sum0, _BITS);
  int sum2 = _h - o._h + _shiftRight(sum1, _BITS);

  int64 result = new int64._bits(sum0 & _MASK, sum1 & _MASK, sum2 & _MASK_2);
  return result;
}

Code bool operator >(other) #

bool operator >(other) {
  return this.compareTo(other) > 0;
}

Code bool operator >=(other) #

bool operator >=(other) {
  return this.compareTo(other) >= 0;
}

Code bool operator <=(other) #

bool operator <=(other) {
  return this.compareTo(other) <= 0;
}

Code int64 remainder(other) #

int64 remainder(other) {
  if (other.isZero()) {
    throw new IntegerDivisionByZeroException();
  }
  int64 o = _promote(other).abs();
  _divMod(this, o, true);
  return _remainder;
}

Code int64 shiftRightUnsigned(int n) #

int64 shiftRightUnsigned(int n) {
  if (n < 0) {
    throw new IllegalArgumentException("$n");
  }
  n &= 63;

  int res0, res1, res2;
  int a2 = _h & _MASK_2; // Ensure a2 is positive.
  if (n < _BITS) {
    res2 = a2 >> n;
    res1 = (_m >> n) | (a2 << (_BITS - n));
    res0 = (_l >> n) | (_m << (_BITS - n));
  } else if (n < _BITS01) {
    res2 = 0;
    res1 = a2 >> (n - _BITS);
    res0 = (_m >> (n - _BITS)) | (_h << (_BITS01 - n));
  } else {
    res2 = 0;
    res1 = 0;
    res0 = a2 >> (n - _BITS01);
  }

  return new int64._bits(res0 & _MASK, res1 & _MASK, res2 & _MASK_2);
}

Code List<int> toBytes() #

List<int> toBytes() {
  List<int> result = new List<int>(8);
  result[0] = _l & 0xff;
  result[1] = (_l >> 8) & 0xff;
  result[2] = ((_m << 6) & 0xfc) | ((_l >> 16) & 0x3f);
  result[3] = (_m >> 2) & 0xff;
  result[4] = (_m >> 10) & 0xff;
  result[5] = ((_h << 4) & 0xf0) | ((_m >> 18) & 0xf);
  result[6] = (_h >> 4) & 0xff;
  result[7] = (_h >> 12) & 0xff;
  return result;
}

Code String toDebugString() #

String toDebugString() {
  return "int64[_l=$_l, _m=$_m, _h=$_h]";
}

Code String toHexString() #

String toHexString() {
  int64 x = new int64._copy(this);
  if (isZero()) {
    return "0";
  }
  String hexStr = "";
  int64 digit_f = new int64.fromInt(0xf);
  while (!x.isZero()) {
    int digit = x._l & 0xf;
    hexStr = "${_hexDigit(digit)}$hexStr";
    x = x.shiftRightUnsigned(4);
  }
  return hexStr;
}

Code int toInt() #

int toInt() {
  int l = _l;
  int m = _m;
  int h = _h;
  bool negative = false;
  if ((_h & _SIGN_BIT_VALUE) != 0) {
    l = ~_l & _MASK;
    m = ~_m & _MASK;
    h = ~_h & _MASK_2;
    negative = true;
  }

  int result;
  if (_haveBigInts) {
    result = (h << _BITS01) | (m << _BITS) | l;
  } else {
    result = (h * 17592186044416) + (m * 4194304) + l;
  }
  return negative ? -result - 1 : result;
}

Code int32 toInt32() #

Returns an int32 containing the low 32 bits of this int64.

int32 toInt32() {
  return new int32.fromInt(((_m & 0x3ff) << _BITS) | _l);
}

Code int64 toInt64() #

Returns this.

int64 toInt64() => this;

Code String toRadixString(int radix) #

String toRadixString(int radix) {
  if ((radix <= 1) || (radix > 16)) {
    throw "Bad radix: $radix";
  }
  int64 a = this;
  if (a.isZero()) {
    return "0";
  }
  if (a.isMinValue()) {
    return _minValues[radix];
  }

  String result = "";
  bool negative = false;
  if (a.isNegative()) {
    negative = true;
    a = -a;
  }

  int64 r = new int64._bits(radix, 0, 0);
  while (!a.isZero()) {
    a = _divMod(a, r, true);
    result = "${_hexDigit(_remainder._l)}$result";
  }
  return negative ? "-$result" : result;
}

Code String toString() #

Returns the value of this int64 as a decimal String.

String toString() {
  int64 a = this;
  if (a.isZero()) {
    return "0";
  }
  if (a.isMinValue()) {
    return "-9223372036854775808";
  }

  String result = "";
  bool negative = false;
  if (a.isNegative()) {
    negative = true;
    a = -a;
  }

  int64 ten = new int64._bits(10, 0, 0);
  while (!a.isZero()) {
    a = _divMod(a, ten, true);
    result = "${_remainder._l}$result";
  }
  if (negative) {
    result = "-$result";
  }
  return result;
}