update Java version

Author: peteroupc

README.md

@@ -19,7 +19,7 @@ project, add the following to the `dependencies` section in your `pom.xml` file:
 <dependency>
   <groupId>com.github.peteroupc</groupId>
   <artifactId>numbers</artifactId>
-  <version>0.2.0</version>
+  <version>0.2.1</version>
 </dependency>
 ```
 

pom.xml

@@ -4,7 +4,7 @@
 	<groupId>com.github.peteroupc</groupId>
 	<artifactId>numbers</artifactId>
 	<packaging>jar</packaging>
-	<version>0.2.0</version>
+	<version>0.2.1</version>
 	<name>Numbers</name>
 	<description>
     A Java implementation that supports arbitrary-precision binary and decimal floating-point numbers and rational numbers with arbitrary-precision components, and supports arithmetic with these numbers.

src/main/java/com/upokecenter/numbers/EContext.java

@@ -191,7 +191,7 @@ public final class EContext {
     private int traps;
 
     /**
-     * Initializes a new instance of the <see cref='T:PeterO.Numbers.EContext'/>
+     * Initializes a new instance of the {@link com.upokecenter.numbers.EContext}
      * class. <code>HasFlags</code> will be set to false.
      * @param precision The parameter {@code precision} is not documented yet.
      * @param rounding The parameter {@code rounding} is not documented yet.
@@ -298,7 +298,8 @@ public final EInteger getEMin() {
      * method. For example: <code>(this.getFlags() &amp; EContext.FlagInexact) !=
      * 0</code> returns TRUE if the Inexact flag is set.
      * @return The flags that are set from converting numbers according to this
-     * arithmetic context. If HasFlags is false, this value will be 0.
+     * arithmetic context. If {@code HasFlags} is false, this value will be
+     * 0.
      */
     public final int getFlags() {
         return this.flags;

src/main/java/com/upokecenter/numbers/EDecimal.java

@@ -47,52 +47,52 @@
      * (NaN) values, and infinity. <b>Negative zero</b> is generally used
      * when a negative number is rounded to 0; it has the same mathematical
      * value as positive zero. <b>Infinity</b> is generally used when a
-     * non-zero number is divided by zero, or when a very high number can't
-     * be represented in a given exponent range. <b>Not-a-number</b> is
-     * generally used to signal errors.</p> <p>This class implements the
-     * General Decimal Arithmetic Specification version 1.70 (except part of
-     * chapter 6): <code>http://speleotrove.com/decimal/decarith.html</code></p>
-     * <p><b>Errors and Exceptions</b></p> <p>Passing a signaling NaN to any
-     * arithmetic operation shown here will signal the flag FlagInvalid and
-     * return a quiet NaN, even if another operand to that operation is a
-     * quiet NaN, unless noted otherwise.</p> <p>Passing a quiet NaN to any
-     * arithmetic operation shown here will return a quiet NaN, unless noted
-     * otherwise. Invalid operations will also return a quiet NaN, as stated
-     * in the individual methods.</p> <p>Unless noted otherwise, passing a
-     * null arbitrary-precision decimal argument to any method here will
-     * throw an exception.</p> <p>When an arithmetic operation signals the
-     * flag FlagInvalid, FlagOverflow, or FlagDivideByZero, it will not
-     * throw an exception too, unless the flag's trap is enabled in the
-     * arithmetic context (see EContext's Traps property).</p> <p>If an
-     * operation requires creating an intermediate value that might be too
-     * big to fit in memory (or might require more than 2 gigabytes of
-     * memory to store -- due to the current use of a 32-bit integer
-     * internally as a length), the operation may signal an
-     * invalid-operation flag and return not-a-number (NaN). In certain rare
-     * cases, the compareTo method may throw OutOfMemoryError (called
-     * OutOfMemoryError in Java) in the same circumstances.</p>
-     * <p><b>Serialization</b></p> <p>An arbitrary-precision decimal value
-     * can be serialized (converted to a stable format) in one of the
-     * following ways:</p> <ul> <li>By calling the toString() method, which
-     * will always return distinct strings for distinct arbitrary-precision
-     * decimal values.</li> <li>By calling the UnsignedMantissa, Exponent,
-     * and IsNegative properties, and calling the IsInfinity, IsQuietNaN,
-     * and IsSignalingNaN methods. The return values combined will uniquely
-     * identify a particular arbitrary-precision decimal value.</li></ul>
-     * <p><b>Thread safety</b></p> <p>Instances of this class are immutable,
-     * so they are inherently safe for use by multiple threads. Multiple
-     * instances of this object with the same properties are
-     * interchangeable, so they should not be compared using the "=="
-     * operator (which only checks if each side of the operator is the same
-     * instance).</p> <p><b>Comparison considerations</b></p> <p>This
-     * class's natural ordering (under the compareTo method) is not
-     * consistent with the Equals method. This means that two values that
-     * compare as equal under the compareTo method might not be equal under
-     * the Equals method. The compareTo method compares the mathematical
-     * values of the two instances passed to it (and considers two different
-     * NaN values as equal), while two instances with the same mathematical
-     * value, but different exponents, will be considered unequal under the
-     * Equals method.</p>
+     * non-zero number is divided by zero, or when a very high or very low
+     * number can't be represented in a given exponent range.
+     * <b>Not-a-number</b> is generally used to signal errors.</p> <p>This
+     * class implements the General Decimal Arithmetic Specification version
+     * 1.70 (except part of chapter 6):
+     * <code>http://speleotrove.com/decimal/decarith.html</code></p> <p><b>Errors
+     * and Exceptions</b></p> <p>Passing a signaling NaN to any arithmetic
+     * operation shown here will signal the flag FlagInvalid and return a
+     * quiet NaN, even if another operand to that operation is a quiet NaN,
+     * unless noted otherwise.</p> <p>Passing a quiet NaN to any arithmetic
+     * operation shown here will return a quiet NaN, unless noted otherwise.
+     * Invalid operations will also return a quiet NaN, as stated in the
+     * individual methods.</p> <p>Unless noted otherwise, passing a null
+     * arbitrary-precision decimal argument to any method here will throw an
+     * exception.</p> <p>When an arithmetic operation signals the flag
+     * FlagInvalid, FlagOverflow, or FlagDivideByZero, it will not throw an
+     * exception too, unless the flag's trap is enabled in the arithmetic
+     * context (see EContext's Traps property).</p> <p>If an operation
+     * requires creating an intermediate value that might be too big to fit
+     * in memory (or might require more than 2 gigabytes of memory to store
+     * -- due to the current use of a 32-bit integer internally as a
+     * length), the operation may signal an invalid-operation flag and
+     * return not-a-number (NaN). In certain rare cases, the compareTo
+     * method may throw OutOfMemoryError (called OutOfMemoryError in
+     * Java) in the same circumstances.</p> <p><b>Serialization</b></p>
+     * <p>An arbitrary-precision decimal value can be serialized (converted
+     * to a stable format) in one of the following ways:</p> <ul> <li>By
+     * calling the toString() method, which will always return distinct
+     * strings for distinct arbitrary-precision decimal values.</li> <li>By
+     * calling the UnsignedMantissa, Exponent, and IsNegative properties,
+     * and calling the IsInfinity, IsQuietNaN, and IsSignalingNaN methods.
+     * The return values combined will uniquely identify a particular
+     * arbitrary-precision decimal value.</li></ul> <p><b>Thread
+     * safety</b></p> <p>Instances of this class are immutable, so they are
+     * inherently safe for use by multiple threads. Multiple instances of
+     * this object with the same properties are interchangeable, so they
+     * should not be compared using the "==" operator (which only checks if
+     * each side of the operator is the same instance).</p> <p><b>Comparison
+     * considerations</b></p> <p>This class's natural ordering (under the
+     * compareTo method) is not consistent with the Equals method. This
+     * means that two values that compare as equal under the compareTo
+     * method might not be equal under the Equals method. The compareTo
+     * method compares the mathematical values of the two instances passed
+     * to it (and considers two different NaN values as equal), while two
+     * instances with the same mathematical value, but different exponents,
+     * will be considered unequal under the Equals method.</p>
      */
   public final class EDecimal implements Comparable<EDecimal> {
     //----------------------------------------------------------------

src/main/java/com/upokecenter/numbers/EFloat.java

@@ -2384,94 +2384,43 @@ public double ToDouble() {
         }
         return Extras.IntegersToDouble(nan);
       }
-      if (this.isNegative() && this.isZero()) {
-        return Extras.IntegersToDouble(new int[] { 0, ((int)(1 << 31)) });
-      }
-      EInteger bigmant = this.unsignedMantissa.Abs();
-      FastInteger bigexponent = FastInteger.FromBig(this.exponent);
-      int bitLeftmost = 0;
-      int bitsAfterLeftmost = 0;
-      if (this.unsignedMantissa.isZero()) {
-        return 0.0d;
+      EFloat thisValue = this.RoundToPrecision(EContext.Binary64);
+      if (!thisValue.isFinite()) {
+        return thisValue.ToDouble();
       }
-      int[] mantissaBits;
-      if (bigmant.compareTo(ValueOneShift52) < 0) {
-        mantissaBits = FastInteger.GetLastWords(bigmant, 2);
-        // This will be an infinite loop if both elements
-        // of the bits array are 0, but the check for
-        // 0 was already done above
-        while (!NumberUtility.HasBitSet(mantissaBits, 52)) {
-          NumberUtility.ShiftLeftOne(mantissaBits);
-          bigexponent.Decrement();
-        }
-      } else {
-        BitShiftAccumulator accum = new BitShiftAccumulator(bigmant, 0, 0);
-        accum.ShiftToDigitsInt(53);
-        bitsAfterLeftmost = accum.getOlderDiscardedDigits();
-        bitLeftmost = accum.getLastDiscardedDigit();
-        bigexponent.Add(accum.getDiscardedDigitCount());
-        mantissaBits = FastInteger.GetLastWords(accum.getShiftedInt(), 2);
-      }
-      // Round half-even
-      if (bitLeftmost > 0 && (bitsAfterLeftmost > 0 ||
-                    NumberUtility.HasBitSet(mantissaBits, 0))) {
-        // Add 1 to the bits
-        mantissaBits[0] = ((int)(mantissaBits[0] + 1));
-        if (mantissaBits[0] == 0) {
-          mantissaBits[1] = ((int)(mantissaBits[1] + 1));
-        }
-        if (mantissaBits[0] == 0 &&
-            mantissaBits[1] == (1 << 21)) {  // if mantissa is now 2^53
-          mantissaBits[1] >>= 1;  // change it to 2^52
-          bigexponent.Increment();
-        }
+      EInteger mant = thisValue.unsignedMantissa;
+      if (thisValue.isNegative() && mant.isZero()) {
+        return Extras.IntegersToDouble(new int[] { 0, ((int)(1 << 31)) });
+      } else if (mant.isZero()) {
+        return 0.0;
       }
+      // DebugUtility.Log("-->" + (//
+      // thisValue.unsignedMantissa.ToRadixString(2)) + ", " + (//
+      // thisValue.exponent));
+      int bitLength = mant.GetUnsignedBitLength();
+
+      int expo = thisValue.exponent.ToInt32Checked();
       boolean subnormal = false;
-      if (bigexponent.CompareToInt(971) > 0) {
-        // exponent too big
-        return this.isNegative() ? Double.NEGATIVE_INFINITY :
-          Double.POSITIVE_INFINITY;
-      }
-      if (bigexponent.CompareToInt(-1074) < 0) {
-        // subnormal
-        subnormal = true;
-        // Shift while number remains subnormal
-        BitShiftAccumulator accum = new BitShiftAccumulator(
-          FastInteger.WordsToEInteger(mantissaBits),
-          0,
-          0);
-        FastInteger fi = bigexponent.Copy().SubtractInt(-1074).Abs();
-        accum.ShiftRight(fi);
-        bitsAfterLeftmost = accum.getOlderDiscardedDigits();
-        bitLeftmost = accum.getLastDiscardedDigit();
-        bigexponent.Add(accum.getDiscardedDigitCount());
-        mantissaBits = FastInteger.GetLastWords(accum.getShiftedInt(), 2);
-        // Round half-even
-        if (bitLeftmost > 0 && (bitsAfterLeftmost > 0 ||
-                    NumberUtility.HasBitSet(mantissaBits, 0))) {
-          // Add 1 to the bits
-          mantissaBits[0] = ((int)(mantissaBits[0] + 1));
-          if (mantissaBits[0] == 0) {
-            mantissaBits[1] = ((int)(mantissaBits[1] + 1));
-          }
-          if (mantissaBits[0] == 0 &&
-              mantissaBits[1] == (1 << 21)) {  // if mantissa is now 2^53
-            mantissaBits[1] >>= 1;  // change it to 2^52
-            bigexponent.Increment();
-          }
+      if (bitLength < 53) {
+        int diff = 53 - bitLength;
+        expo -= diff;
+        if (expo < -1074) {
+          // DebugUtility.Log("Diff changed from " + diff + " to " + (diff -
+          // (-1074 - expo)));
+          diff -= -1074 - expo;
+          expo = -1074;
+          subnormal = true;
         }
+        mant = mant.ShiftLeft(diff);
+        bitLength += diff;
       }
-      if (bigexponent.CompareToInt(-1074) < 0) {
-        // exponent too small, so return zero
-        return this.isNegative() ?
-          Extras.IntegersToDouble(new int[] { 0, ((int)0x80000000) }) :
-          0.0d;
-      }
-      bigexponent.AddInt(1075);
+      // DebugUtility.Log("2->" + (mant.ToRadixString(2)) + ", " + expo);
+      int[] mantissaBits;
+      mantissaBits = FastInteger.GetLastWords(mant, 2);
       // Clear the high bits where the exponent and sign are
       mantissaBits[1] &= 0xfffff;
       if (!subnormal) {
-        int smallexponent = bigexponent.AsInt32() << 20;
+        int smallexponent = (expo + 1075) << 20;
         mantissaBits[1] |= smallexponent;
       }
       if (this.isNegative()) {
@@ -2728,89 +2677,45 @@ public float ToSingle() {
         }
         return Float.intBitsToFloat(nan);
       }
-      if (this.isNegative() && this.isZero()) {
-        return Float.intBitsToFloat(1 << 31);
+      EFloat thisValue = this.RoundToPrecision(EContext.Binary32);
+      if (!thisValue.isFinite()) {
+        return thisValue.ToSingle();
       }
-      EInteger bigmant = this.unsignedMantissa.Abs();
-      FastInteger bigexponent = FastInteger.FromBig(this.exponent);
-      int bitLeftmost = 0;
-      int bitsAfterLeftmost = 0;
-      if (this.unsignedMantissa.isZero()) {
+      EInteger mant = thisValue.unsignedMantissa;
+      if (thisValue.isNegative() && mant.isZero()) {
+        return Float.intBitsToFloat(1 << 31);
+      } else if (mant.isZero()) {
         return 0.0f;
       }
-      int smallmant = 0;
-      FastInteger fastSmallMant;
-      if (bigmant.compareTo(ValueOneShift23) < 0) {
-        smallmant = bigmant.AsInt32Checked();
-        int exponentchange = 0;
-        while (smallmant < (1 << 23)) {
-          smallmant <<= 1;
-          ++exponentchange;
-        }
-        bigexponent.SubtractInt(exponentchange);
-        fastSmallMant = new FastInteger(smallmant);
-      } else {
-        BitShiftAccumulator accum = new BitShiftAccumulator(bigmant, 0, 0);
-        accum.ShiftToDigitsInt(24);
-        bitsAfterLeftmost = accum.getOlderDiscardedDigits();
-        bitLeftmost = accum.getLastDiscardedDigit();
-        bigexponent.Add(accum.getDiscardedDigitCount());
-        fastSmallMant = accum.getShiftedIntFast();
-      }
-      // Round half-even
-      if (bitLeftmost > 0 && (bitsAfterLeftmost > 0 ||
-                    !fastSmallMant.isEvenNumber())) {
-        fastSmallMant.Increment();
-        if (fastSmallMant.CompareToInt(1 << 24) == 0) {
-          fastSmallMant = new FastInteger(1 << 23);
-          bigexponent.Increment();
-        }
-      }
+      // DebugUtility.Log("-->" + (//
+      // thisValue.unsignedMantissa.ToRadixString(2)) + ", " + (//
+      // thisValue.exponent));
+      int bitLength = mant.GetUnsignedBitLength();
+
+      int expo = thisValue.exponent.ToInt32Checked();
       boolean subnormal = false;
-      if (bigexponent.CompareToInt(104) > 0) {
-        // exponent too big
-        return this.isNegative() ? Float.NEGATIVE_INFINITY :
-          Float.POSITIVE_INFINITY;
-      }
-      if (bigexponent.CompareToInt(-149) < 0) {
-        // subnormal
-        subnormal = true;
-        // Shift while number remains subnormal
-        BitShiftAccumulator accum =
-          BitShiftAccumulator.FromInt32(fastSmallMant.AsInt32());
-        FastInteger fi = bigexponent.Copy().SubtractInt(-149).Abs();
-        accum.ShiftRight(fi);
-        bitsAfterLeftmost = accum.getOlderDiscardedDigits();
-        bitLeftmost = accum.getLastDiscardedDigit();
-        bigexponent.Add(accum.getDiscardedDigitCount());
-        fastSmallMant = accum.getShiftedIntFast();
-        // Round half-even
-        if (bitLeftmost > 0 && (bitsAfterLeftmost > 0 ||
-                    !fastSmallMant.isEvenNumber())) {
-          fastSmallMant.Increment();
-          if (fastSmallMant.CompareToInt(1 << 24) == 0) {
-            fastSmallMant = new FastInteger(1 << 23);
-            bigexponent.Increment();
-          }
+      if (bitLength < 24) {
+        int diff = 24 - bitLength;
+        expo -= diff;
+        if (expo < -149) {
+          // DebugUtility.Log("Diff changed from " + diff + " to " + (diff -
+          // (-149 - expo)));
+          diff -= -149 - expo;
+          expo = -149;
+          subnormal = true;
         }
+        mant = mant.ShiftLeft(diff);
+        bitLength += diff;
       }
-      if (bigexponent.CompareToInt(-149) < 0) {
-        // exponent too small, so return zero
-        return this.isNegative() ?
-          Float.intBitsToFloat(1 << 31) :
-          Float.intBitsToFloat(0);
-      } else {
-        int smallexponent = bigexponent.AsInt32();
-        smallexponent += 150;
-        int smallmantissa = ((int)fastSmallMant.AsInt32()) & 0x7fffff;
-        if (!subnormal) {
-          smallmantissa |= smallexponent << 23;
-        }
-        if (this.isNegative()) {
+      // DebugUtility.Log("2->" + (mant.ToRadixString(2)) + ", " + expo);
+      int smallmantissa = ((int)mant.ToInt32Checked()) & 0x7fffff;
+      if (!subnormal) {
+          smallmantissa |= (expo + 150) << 23;
+      }
+      if (this.isNegative()) {
           smallmantissa |= 1 << 31;
-        }
-        return Float.intBitsToFloat(smallmantissa);
       }
+      return Float.intBitsToFloat(smallmantissa);
     }
 
     /**