```java.lang.Object
```

```@Beta
public final class DoubleMathextends Object```

A class for arithmetic on doubles that is not covered by `Math`.

Since:
11.0
Author:
Louis Wasserman

Constructor Summary
`DoubleMath()`

Method Summary
`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 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 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`

Constructor Detail

### DoubleMath

`public DoubleMath()`
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 must be 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`