isEven, isOdd, isNegative, isMaxValue, isMinValue, isInfinite, isPositive, isSingleValue.

pkg/fixnum/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.
 
 /**
  * An immutable 64-bit signed integer, in the range [-2^63, 2^63 - 1].
  * Arithmetic operations may overflow in order to maintain this range.
  */
 class int64 implements intx {
 
@@ skipping 348 matching lines @@
     c1 += c0 >> _BITS;
     c0 &= _MASK;
     c2 += c1 >> _BITS;
     c1 &= _MASK;
     c2 &= _MASK_2;
 
     return new int64._bits(c0, c1, c2);
   }
 
   int64 operator %(other) {
-    if (other.isZero()) {
+    if (other.isZero) {
       throw new IntegerDivisionByZeroException();
     }
-    if (this.isZero()) {
+    if (this.isZero) {
       return ZERO;
     }
     int64 o = _promote(other).abs();
     _divMod(this, o, true);
     return _remainder < 0 ? (_remainder + o) : _remainder;
   }
 
   int64 operator ~/(other) => _divMod(this, _promote(other), false);
 
   // int64 remainder(other) => this - (this ~/ other) * other;
   int64 remainder(other) {
-    if (other.isZero()) {
+    if (other.isZero) {
       throw new IntegerDivisionByZeroException();
     }
     int64 o = _promote(other).abs();
     _divMod(this, o, true);
     return _remainder;
   }
 
   int64 operator &(other) {
     int64 o = _promote(other);
     int a0 = _l & o._l;
@@ skipping 159 matching lines @@
   }
 
   bool operator >(other) {
     return this.compareTo(other) > 0;
   }
 
   bool operator >=(other) {
     return this.compareTo(other) >= 0;
   }
 
-  bool isEven() => (_l & 0x1) == 0;
-  bool isMaxValue() => (_h == _MASK_2 >> 1) && _m == _MASK && _l == _MASK;
-  bool isMinValue() => _h == _SIGN_BIT_VALUE && _m == 0 && _l == 0;
-  bool isNegative() => (_h >> (_BITS2 - 1)) != 0;
-  bool isOdd() => (_l & 0x1) == 1;
-  bool isZero() => _h == 0 && _m == 0 && _l == 0;
+  bool get isEven => (_l & 0x1) == 0;
+  bool get isMaxValue => (_h == _MASK_2 >> 1) && _m == _MASK && _l == _MASK;
+  bool get isMinValue => _h == _SIGN_BIT_VALUE && _m == 0 && _l == 0;
+  bool get isNegative => (_h >> (_BITS2 - 1)) != 0;
+  bool get isOdd => (_l & 0x1) == 1;
+  bool get isZero => _h == 0 && _m == 0 && _l == 0;
 
   /**
    * Returns a hash code based on all the bits of this [int64].
    */
   int get hashCode {
     int bottom = ((_m & 0x3ff) << _BITS) | _l;
     int top = (_h << 12) | ((_m >> 10) & 0xfff);
     return bottom ^ top;
   }
 
@@ skipping 87 matching lines @@
    * Returns [this].
    */
   int64 toInt64() => this;
 
   /**
    * Returns the value of this [int64] as a decimal [String].
    */
   // TODO(rice) - Make this faster by converting several digits at once.
   String toString() {
     int64 a = this;
-    if (a.isZero()) {
+    if (a.isZero) {
       return "0";
     }
-    if (a.isMinValue()) {
+    if (a.isMinValue) {
       return "-9223372036854775808";
     }
 
     String result = "";
     bool negative = false;
-    if (a.isNegative()) {
+    if (a.isNegative) {
       negative = true;
       a = -a;
     }
 
     int64 ten = new int64._bits(10, 0, 0);
-    while (!a.isZero()) {
+    while (!a.isZero) {
       a = _divMod(a, ten, true);
       result = "${_remainder._l}$result";
     }
     if (negative) {
       result = "-$result";
     }
     return result;
   }
 
   // TODO(rice) - Make this faster by avoiding arithmetic.
   String toHexString() {
     int64 x = new int64._copy(this);
-    if (isZero()) {
+    if (isZero) {
       return "0";
     }
     String hexStr = "";
     int64 digit_f = new int64.fromInt(0xf);
-    while (!x.isZero()) {
+    while (!x.isZero) {
       int digit = x._l & 0xf;
       hexStr = "${_hexDigit(digit)}$hexStr";
       x = x.shiftRightUnsigned(4);
     }
     return hexStr;
   }
 
   String toRadixString(int radix) {
     if ((radix <= 1) || (radix > 16)) {
       throw "Bad radix: $radix";
     }
     int64 a = this;
-    if (a.isZero()) {
+    if (a.isZero) {
       return "0";
     }
-    if (a.isMinValue()) {
+    if (a.isMinValue) {
       return _minValues[radix];
     }
 
     String result = "";
     bool negative = false;
-    if (a.isNegative()) {
+    if (a.isNegative) {
       negative = true;
       a = -a;
     }
 
     int64 r = new int64._bits(radix, 0, 0);
-    while (!a.isZero()) {
+    while (!a.isZero) {
       a = _divMod(a, r, true);
       result = "${_hexDigit(_remainder._l)}$result";
     }
     return negative ? "-$result" : result;
   }
 
   String toDebugString() {
     return "int64[_l=$_l, _m=$_m, _h=$_h]";
   }
 
@@ skipping 120 matching lines @@
     // Align the leading one bits of a and b by shifting b left.
     int shift = b.numberOfLeadingZeros() - a.numberOfLeadingZeros();
     int64 bshift = b << shift;
 
     // Quotient must be a new instance since we mutate it.
     int64 quotient = new int64();
     while (shift >= 0) {
       bool gte = _trialSubtract(a, bshift);
       if (gte) {
         quotient._setBit(shift);
-        if (a.isZero()) {
+        if (a.isZero) {
           break;
         }
       }
 
       bshift._toShru1();
       shift--;
     }
 
     if (negative) {
       quotient._negate();
     }
 
     if (computeRemainder) {
       if (aIsNegative) {
         _remainder = -a;
         if (aIsMinValue) {
           _remainder = _remainder - ONE;
         }
       } else {
         _remainder = a;
       }
     }
 
     return quotient;
   }
 
   int64 _divModByMinValue(bool computeRemainder) {
     // MIN_VALUE / MIN_VALUE == 1, remainder = 0
     // (x != MIN_VALUE) / MIN_VALUE == 0, remainder == x
-    if (isMinValue()) {
+    if (isMinValue) {
       if (computeRemainder) {
         _remainder = ZERO;
       }
       return ONE;
     }
     if (computeRemainder) {
       _remainder = this;
     }
     return ZERO;
   }
@@ skipping 69 matching lines @@
       return int32._numberOfTrailingZeros(m) + _BITS;
     }
     if (h != 0 && m == 0 && l == 0) {
       return int32._numberOfTrailingZeros(h) + _BITS01;
     }
 
     return -1;
   }
 
   int64 _divMod(int64 a, int64 b, bool computeRemainder) {
-    if (b.isZero()) {
+    if (b.isZero) {
       throw new IntegerDivisionByZeroException();
     }
-    if (a.isZero()) {
+    if (a.isZero) {
       if (computeRemainder) {
         _remainder = ZERO;
       }
       return ZERO;
     }
     // MIN_VALUE / MIN_VALUE = 1, anything other a / MIN_VALUE is 0.
-    if (b.isMinValue()) {
+    if (b.isMinValue) {
       return a._divModByMinValue(computeRemainder);
     }
     // Normalize b to abs(b), keeping track of the parity in 'negative'.
     // We can do this because we have already ensured that b != MIN_VALUE.
     bool negative = false;
-    if (b.isNegative()) {
+    if (b.isNegative) {
       b = -b;
       negative = !negative;
     }
     // If b == 2^n, bpower will be n, otherwise it will be -1.
     int bpower = b._powerOfTwo();
 
     // True if the original value of a is negative.
     bool aIsNegative = false;
     // True if the original value of a is int64.MIN_VALUE.
     bool aIsMinValue = false;
 
     /*
      * Normalize a to a positive value, keeping track of the sign change in
      * 'negative' (which tracks the sign of both a and b and is used to
      * determine the sign of the quotient) and 'aIsNegative' (which is used to
      * determine the sign of the remainder).
      *
      * For all values of a except MIN_VALUE, we can just negate a and modify
      * negative and aIsNegative appropriately. When a == MIN_VALUE, negation is
      * not possible without overflowing 64 bits, so instead of computing
      * abs(MIN_VALUE) / abs(b) we compute (abs(MIN_VALUE) - 1) / abs(b). The
      * only circumstance under which these quotients differ is when b is a power
      * of two, which will divide abs(MIN_VALUE) == 2^64 exactly. In this case,
      * we can get the proper result by shifting MIN_VALUE in unsigned fashion.
      *
      * We make a single copy of a before the first operation that needs to
      * modify its value.
      */
     bool aIsCopy = false;
-    if (a.isMinValue()) {
+    if (a.isMinValue) {
       aIsMinValue = true;
       aIsNegative = true;
       // If b is not a power of two, treat -a as MAX_VALUE (instead of the
       // actual value (MAX_VALUE + 1)).
       if (bpower == -1) {
         a = new int64._copy(MAX_VALUE);
         aIsCopy = true;
         negative = !negative;
       } else {
         // Signed shift of MIN_VALUE produces the right answer.
         int64 c = a >> bpower;
         if (negative) {
           c._negate();
         }
         if (computeRemainder) {
           _remainder = ZERO;
         }
         return c;
       }
-    } else if (a.isNegative()) {
+    } else if (a.isNegative) {
       aIsNegative = true;
       a = -a;
       aIsCopy = true;
       negative = !negative;
     }
 
     // Now both a and b are non-negative.
     // If b is a power of two, just shift.
     if (bpower != -1) {
       return _divModByShift(a, bpower, negative, aIsCopy, aIsNegative,
@@ skipping 10 matching lines @@
         }
       }
       return ZERO;
     }
 
     // Generate the quotient using bit-at-a-time long division.
     return _divModHelper(aIsCopy ? a : new int64._copy(a), b, negative,
         aIsNegative, aIsMinValue, computeRemainder);
   }
 }