Added bitLength, clamp(), toDouble(), toSigned(), toUnsigned().

pkg/fixnum/lib/src/int64.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of fixnum;
 
 /**
  * An immutable 64-bit signed integer, in the range [-2^63, 2^63 - 1].
  * Arithmetic operations may overflow in order to maintain this range.
  */
@@ skipping 498 matching lines @@
     return this.compareTo(other) >= 0;
   }
 
   bool get isEven => (_l & 0x1) == 0;
   bool get isMaxValue => (_h == _MASK2 >> 1) && _m == _MASK && _l == _MASK;
   bool get isMinValue => _h == _SIGN_BIT_MASK && _m == 0 && _l == 0;
   bool get isNegative => (_h & _SIGN_BIT_MASK) != 0;
   bool get isOdd => (_l & 0x1) == 1;
   bool get isZero => _h == 0 && _m == 0 && _l == 0;
 
+  int get bitLength {
+    if (isZero) return 0;
+    int a0 = _l, a1 = _m, a2 = _h;
+    if (isNegative) {
+      a0 = ~a0 & _MASK;

[sra1, 2013/09/24 02:58:04]

a0 = _MASK & a0

to help dart2js inference and consistency with most places.

[Chris Bracken, 2013/09/24 20:16:00]

Done.

+      a1 = ~a1 & _MASK;
+      a2 = ~a2 & _MASK2;
+    }
+    int len = a2.bitLength;
+    if (len > 0) return len + _BITS01;

[sra1, 2013/09/24 02:58:04]

if a2 is nonzero, we don't use len.

How about
  if (a2 != 0) return _BITS01 + a2.bitLength;
  if (a1 != 0) return _BITS + a2.bitLength;
  return a0.bitLength;

[Chris Bracken, 2013/09/24 20:16:00]

Done.

+    len = a1.bitLength;
+    if (len > 0) return len + _BITS;
+    return a0.bitLength;
+  }
+
   /**
    * Returns a hash code based on all the bits of this [Int64].
    */
   int get hashCode {
     // TODO(sra): Should we ensure that hashCode values match corresponding int?
     // i.e. should `new Int64(x).hashCode == x.hashCode`?
     int bottom = ((_m & 0x3ff) << _BITS) | _l;
     int top = (_h << 12) | ((_m >> 10) & 0xfff);
     return bottom ^ top;
   }
 
   Int64 abs() {
     return this.isNegative ? -this : this;
   }
 
+  Int64 clamp(lowerLimit, upperLimit) {
+    Int64 lower = _promote(lowerLimit);
+    Int64 upper = _promote(upperLimit);
+    if (this < lowerLimit) {

[sra1, 2013/09/24 02:58:04]

Use the promoted values :-)

[Chris Bracken, 2013/09/24 20:16:00]

Done. Looks like I got two lines into cleaning this up then got distracted by
something!

+      if (lowerLimit is IntX) return lowerLimit.toInt64();
+      if (lowerLimit is int) return new Int64.fromInt(lowerLimit);
+      throw new ArgumentError(lowerLimit);
+    } else if (this > upperLimit) {
+      if (upperLimit is IntX) return upperLimit.toInt64();
+      if (upperLimit is int) return new Int64.fromInt(upperLimit);
+      throw new ArgumentError(upperLimit);
+    }
+    return this;
+  }
+
   /**
    * 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;
@@ skipping 21 matching lines @@
     }
 
     zeros = Int32._numberOfTrailingZeros(_h);
     if (zeros < 32) {
       return _BITS01 + zeros;
     }
     // All zeros
     return 64;
   }
 
+  Int64 toSigned(int width) {
+    if (width < 1 || width > 64) throw new ArgumentError(width);
+    if (width > _BITS01) {
+      return Int64._masked(_l, _m, _h.toSigned(width - _BITS01));
+    } else if (width > _BITS) {
+      int m = _m.toSigned(width - _BITS);
+      return m.isNegative ? Int64._masked(_l, m, _MASK2) :
+          new Int64._bits(_l, m, 0);
+    } else {
+      int l = _l.toSigned(width);
+      return l.isNegative ? Int64._masked(l, _MASK, _MASK2) :
+          new Int64._bits(l, 0, 0);
+    }
+  }
+
+  Int64 toUnsigned(int width) {
+    if (width < 0 || width > 64) throw new ArgumentError(width);
+    if (width > 2 * _BITS) {
+      int h = _h.toUnsigned(width - 2 * _BITS);
+      return Int64._masked(_l, _m, h);
+    } else if (width > _BITS) {
+      int m = _m.toUnsigned(width - _BITS);
+      return Int64._masked(_l, m, 0);
+    } else {
+      int l = _l.toUnsigned(width);
+      return Int64._masked(l, 0, 0);
+    }
+  }
+
   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;
   }
 
+  double toDouble() => toInt().toDouble();

[sra1, 2013/09/24 02:58:04]

I think this can round incorrectly.

The problem lies in dart2js using doubles for the arithmetic on line 665 and
667.
Doing:
  big2 = (big1 + small1) + small2;
can cause both small1 and small2 to be effectively ignored.
We need to do
  big2 = big1 + (small1 + small2)
which can be written
  big2 = small1 + small2 + big1;

[Chris Bracken, 2013/09/24 20:16:00]

Done.

+
   int toInt() {
     int l = _l;
     int m = _m;
     int h = _h;
     bool negative = false;
     if ((_h & _SIGN_BIT_MASK) != 0) {
       l = ~_l & _MASK;
       m = ~_m & _MASK;
       h = ~_h & _MASK2;
       negative = true;
     }
 
     int result;
     if (_haveBigInts) {
       result = (h << _BITS01) | (m << _BITS) | l;

[sra1, 2013/09/24 02:58:04]

return negative ? -result - 1 : result;

[Chris Bracken, 2013/09/24 20:16:00]

Done.

     } else {
       result = (h * 17592186044416) + (m * 4194304) + l;

[sra1, 2013/09/24 02:58:04]

return negative ? -result - 1 : result;

But that has the problem we mention, so rewrite these two lines to

  if (negative) {
    result = ((l + 1) + (m * 4194304)) + (h * 17592186044416);
    return -result;
  } else {
    return (l + (m * 4194304)) + (h * 17592186044416);
  }
  

You should be able to find a value A near -(2^(53+1)) where you can see the
difference.  On a single value, the rounding will seem arbitrary.

Take 100 random negative Int64s in this range (or 100 consecutive values).
  A. convert to double, add.
  B. add, then convert to double.

A will be closer to the correct answer B if the conversion does not have a bias
due to doing arithmetic with values that have already lost precision.
I could have an off-by-one error in my description.

I think a batch of 9 specific value tests for
-10000000000000000
-10000000000000001
-10000000000000002
-10000000000000003
-10000000000000004
...
-10000000000000008
should ensure that the exact VM and inexact dart2js produce the same values.

[Chris Bracken, 2013/09/24 20:16:00]

Done.

     }
     return negative ? -result - 1 : result;
   }
 
   /**
    * Returns an [Int32] containing the low 32 bits of this [Int64].
    */
   Int32 toInt32() {
     return new Int32(((_m & 0x3ff) << _BITS) | _l);
   }
@@ skipping 369 matching lines @@
       if (r0 == 0 && r1 == 0 && r2 == 0) {
         return ZERO;
       } else {
         return _sub(b0, b1, b2, r0, r1, r2);
       }
     } else {
       return _negate(r0, r1, r2);
     }
   }
 }