## Class DoubleMath

• ```public final class DoubleMath
extends Object```
A class for arithmetic on doubles that is not covered by `Math`.
Since:
11.0
Author:
Louis Wasserman
• ### Method Summary

Methods
Modifier and Type Method and Description
`static double` `factorial(int n)`
Returns `n!`, that is, the product of the first `n` positive integers, `1` if `n == 0`, or e n!}, or `Double.POSITIVE_INFINITY` if `n! > Double.MAX_VALUE`.
`static int` ```fuzzyCompare(double a, double b, double tolerance)```
Compares `a` and `b` "fuzzily," with a tolerance for nearly-equal values.
`static boolean` ```fuzzyEquals(double a, double b, double tolerance)```
Returns `true` if `a` and `b` are within `tolerance` of each other.
`static boolean` `isMathematicalInteger(double x)`
Returns `true` if `x` represents a mathematical integer.
`static boolean` `isPowerOfTwo(double x)`
Returns `true` if `x` is exactly equal to `2^k` for some finite integer `k`.
`static double` `log2(double x)`
Returns the base 2 logarithm of a double value.
`static int` ```log2(double x, RoundingMode mode)```
Returns the base 2 logarithm of a double value, rounded with the specified rounding mode to an `int`.
`static double` `mean(double... values)`
Returns the arithmetic mean of the values.
`static double` `mean(int... values)`
Returns the arithmetic mean of the values.
`static double` `mean(Iterable<? extends Number> values)`
Returns the arithmetic mean of the values.
`static double` `mean(Iterator<? extends Number> values)`
Returns the arithmetic mean of the values.
`static double` `mean(long... values)`
Returns the arithmetic mean of the values.
`static BigInteger` ```roundToBigInteger(double x, RoundingMode mode)```
Returns the `BigInteger` value that is equal to `x` rounded with the specified rounding mode, if possible.
`static int` ```roundToInt(double x, RoundingMode mode)```
Returns the `int` value that is equal to `x` rounded with the specified rounding mode, if possible.
`static long` ```roundToLong(double x, RoundingMode mode)```
Returns the `long` value that is equal to `x` rounded with the specified rounding mode, if possible.
• ### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`
• ### Method Detail

• #### roundToInt

```public static int roundToInt(double x,
RoundingMode mode)```
Returns the `int` value that is equal to `x` rounded with the specified rounding mode, if possible.
Throws:
`ArithmeticException` - if
• `x` is infinite or NaN
• `x`, after being rounded to a mathematical integer using the specified rounding mode, is either less than `Integer.MIN_VALUE` or greater than `Integer.MAX_VALUE`
• `x` is not a mathematical integer and `mode` is `RoundingMode.UNNECESSARY`
• #### roundToLong

```public static long roundToLong(double x,
RoundingMode mode)```
Returns the `long` value that is equal to `x` rounded with the specified rounding mode, if possible.
Throws:
`ArithmeticException` - if
• `x` is infinite or NaN
• `x`, after being rounded to a mathematical integer using the specified rounding mode, is either less than `Long.MIN_VALUE` or greater than `Long.MAX_VALUE`
• `x` is not a mathematical integer and `mode` is `RoundingMode.UNNECESSARY`
• #### roundToBigInteger

```public static BigInteger roundToBigInteger(double x,
RoundingMode mode)```
Returns the `BigInteger` value that is equal to `x` rounded with the specified rounding mode, if possible.
Throws:
`ArithmeticException` - if
• #### isPowerOfTwo

`public static boolean isPowerOfTwo(double x)`
Returns `true` if `x` is exactly equal to `2^k` for some finite integer `k`.
• #### log2

`public static double log2(double x)`
Returns the base 2 logarithm of a double value.

Special cases:

• If `x` is NaN or less than zero, the result is NaN.
• If `x` is positive infinity, the result is positive infinity.
• If `x` is positive or negative zero, the result is negative infinity.

The computed result is within 1 ulp of the exact result.

If the result of this method will be immediately rounded to an `int`, `log2(double, RoundingMode)` is faster.

• #### log2

```public static int log2(double x,
RoundingMode mode)```
Returns the base 2 logarithm of a double value, rounded with the specified rounding mode to an `int`.

Regardless of the rounding mode, this is faster than `(int) log2(x)`.

Throws:
`IllegalArgumentException` - if `x <= 0.0`, `x` is NaN, or `x` is infinite
• #### isMathematicalInteger

`public static boolean isMathematicalInteger(double x)`
Returns `true` if `x` represents a mathematical integer.

This is equivalent to, but not necessarily implemented as, the expression `!Double.isNaN(x) && !Double.isInfinite(x) && x == Math.rint(x)`.

• #### factorial

`public static double factorial(int n)`
Returns `n!`, that is, the product of the first `n` positive integers, `1` if `n == 0`, or e n!}, or `Double.POSITIVE_INFINITY` if `n! > Double.MAX_VALUE`.

The result is within 1 ulp of the true value.

Throws:
`IllegalArgumentException` - if `n < 0`
• #### fuzzyEquals

```public static boolean fuzzyEquals(double a,
double b,
double tolerance)```
Returns `true` if `a` and `b` are within `tolerance` of each other.

Technically speaking, this is equivalent to `Math.abs(a - b) <= tolerance || Double.valueOf(a).equals(Double.valueOf(b))`.

Notable special cases include:

• All NaNs are fuzzily equal.
• If `a == b`, then `a` and `b` are always fuzzily equal.
• Positive and negative zero are always fuzzily equal.
• If `tolerance` is zero, and neither `a` nor `b` is NaN, then `a` and `b` are fuzzily equal if and only if `a == b`.
• With `Double.POSITIVE_INFINITY` tolerance, all non-NaN values are fuzzily equal.
• With finite tolerance, `Double.POSITIVE_INFINITY` and `Double.NEGATIVE_INFINITY` are fuzzily equal only to themselves.
• This is reflexive and symmetric, but not transitive, so it is not an equivalence relation and not suitable for use in `Object.equals(java.lang.Object)` implementations.

Throws:
`IllegalArgumentException` - if `tolerance` is `< 0` or NaN
Since:
13.0
• #### fuzzyCompare

```public static int fuzzyCompare(double a,
double b,
double tolerance)```
Compares `a` and `b` "fuzzily," with a tolerance for nearly-equal values.

This method is equivalent to `fuzzyEquals(a, b, tolerance) ? 0 : Double.compare(a, b)`. In particular, like `Double.compare(double, double)`, it treats all NaN values as equal and greater than all other values (including `Double.POSITIVE_INFINITY`).

This is not a total ordering and is not suitable for use in `Comparable.compareTo(T)` implementations. In particular, it is not transitive.

Throws:
`IllegalArgumentException` - if `tolerance` is `< 0` or NaN
Since:
13.0
• #### mean

`public static double mean(double... values)`
Returns the arithmetic mean of the values. There must be at least one value, and they must all be finite.
• #### mean

`public static double mean(int... values)`
Returns the arithmetic mean of the values. There must be at least one value. The values will be converted to doubles, which does not cause any loss of precision for ints.
• #### mean

`public static double mean(long... values)`
Returns the arithmetic mean of the values. There must be at least one value. The values will be converted to doubles, which causes loss of precision for longs of magnitude over 2^53 (slightly over 9e15).
• #### mean

`public static double mean(Iterable<? extends Number> values)`
Returns the arithmetic mean of the values. There must be at least one value, and they must all be finite. The values will be converted to doubles, which may cause loss of precision for some numeric types.
• #### mean

`public static double mean(Iterator<? extends Number> values)`
Returns the arithmetic mean of the values. There must be at least one value, and they must all be finite. The values will be converted to doubles, which may cause loss of precision for some numeric types.