## com.google.common.math
Class DoubleMath

    java.lang.Object
      com.google.common.math.DoubleMath

    @Beta
    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
`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 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
    - `x` is infinite or NaN
    - `x` is not a mathematical integer and `mode` is `RoundingMode.UNNECESSARY`

### 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

    @Beta
    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

    @Beta
    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

Copyright © 2010-2012. All Rights Reserved.