Allow DD creation from an unsigned int value.

Author: aherbert

commons-numbers-core/src/main/java/org/apache/commons/numbers/core/DD.java

@@ -325,7 +325,7 @@ static DD of(double x, double xx) {
     /**
      * Creates the double-double number as the value {@code (x, 0)}.
      *
-     * <p>Note this method exists to avoid using {@link #of(long)} for {@code integer}
+     * <p>Note this method exists to avoid using {@link #of(long)} for {@code int}
      * arguments; the {@code long} variation is slower as it preserves all 64-bits
      * of information.
      *
@@ -363,13 +363,36 @@ public static DD of(long x) {
 
     /**
      * Creates the double-double number using the argument {@code x} as an unsigned
-     * 64-bit integer.
+     * 32-bit integer. Equivalent to:
      *
-     * <p>Note this method preserves all 64-bits of precision. It can be used to
-     * represent the positive difference between two ordered {@code long} values
-     * without using {@link DD#subtract(DD)}.
+     * <pre>
+     * DD.of((double) Integer.toUnsignedLong(x))
+     * </pre>
+     *
+     * <p>Note this method exists to avoid using {@link #ofUnsigned(long)} for {@code int}
+     * arguments as sign extension on negative values will generate an incorrect result.
+     *
+     * @param x Value.
+     * @return the double-double
+     */
+    public static DD ofUnsigned(int x) {
+        return new DD(Integer.toUnsignedLong(x), 0);
+    }
+
+    /**
+     * Creates the double-double number using the argument {@code x} as an unsigned 64-bit
+     * integer.
+     *
+     * <p>Zero and positive values are mapped to a numerically equal double-double value;
+     * and negative values are mapped to a value equal to the positive {@code long} value
+     * of the low order 63-bits plus 2<sup>63</sup>.
+     *
+     * <p>Note this method preserves all 64-bits of precision. It can be used to represent
+     * the positive difference between two ordered {@code long} values without using
+     * {@link DD#subtract(DD)}.
      *
      * <p>Given two {@code long} values {@code a <= b} the following are equivalent:
+     *
      * <pre>
      * DD.of(b).subtract(DD.of(a))
      *

commons-numbers-core/src/test/java/org/apache/commons/numbers/core/DDTest.java

@@ -27,7 +27,6 @@
 import java.util.function.Supplier;
 import java.util.function.UnaryOperator;
 import java.util.stream.IntStream;
-import java.util.stream.LongStream;
 import java.util.stream.Stream;
 import org.apache.commons.rng.UniformRandomProvider;
 import org.apache.commons.rng.simple.RandomSource;
@@ -145,6 +144,28 @@ void testOfLong(long x) {
         Assertions.assertEquals(BigDecimal.valueOf(-x).subtract(bd(-x)).doubleValue(), dd.lo(), "-x lo should be remaining bits");
     }
 
+    /**
+     * Test conversion of an unsigned {@code int}.
+     */
+    @ParameterizedTest
+    @ValueSource(ints = {0, 1, 42, 89545664,
+        -1, -42, -89545664,
+        Integer.MAX_VALUE - (1 << 10), Integer.MAX_VALUE - 42, Integer.MAX_VALUE - 1, Integer.MAX_VALUE,
+        Integer.MIN_VALUE + (1 << 10), Integer.MIN_VALUE + 42, Integer.MIN_VALUE + 1, Integer.MIN_VALUE})
+    @MethodSource
+    void testOfUnsignedInt(int x) {
+        final DD dd = DD.ofUnsigned(x);
+        Assertions.assertTrue(dd.hi() >= 0, "x hi should be positive");
+        final double expected = Integer.toUnsignedLong(x);
+        Assertions.assertEquals(expected, dd.hi(), "x hi");
+        Assertions.assertEquals(0, dd.lo(), "x lo");
+    }
+
+    static int[] testOfUnsignedInt() {
+        // Random
+        return createRNG().ints(10).toArray();
+    }
+
     /**
      * Test conversion of an unsigned {@code long}.
      */
@@ -172,9 +193,9 @@ void testOfUnsignedLong(long x) {
         Assertions.assertEquals(lo, dd.lo(), "x lo");
     }
 
-    static LongStream testOfUnsignedLong() {
+    static long[] testOfUnsignedLong() {
         // Random
-        return createRNG().longs(10);
+        return createRNG().longs(10).toArray();
     }
 
     @ParameterizedTest

src/changes/changes.xml

@@ -57,7 +57,7 @@ If the output is not quite correct, check for invisible trailing spaces!
 New features, updates and bug fixes.
 ">
       <action dev="aherbert" type="add">
-        "DD": Allow creation from an unsigned long value.
+        "DD": Allow creation from an unsigned int or long value.
       </action>
       <action dev="aherbert" type="add" issue="NUMBERS-208">
         "Selection": Add support for selection from a long array.