How to use

doubleValue

method

in

java.math.BigInteger

@Override
public double doubleValue() { return _value.doubleValue(); }

@Override
public double doubleValue() { return _value.doubleValue(); }

/**
 * Returns this {@code BigInteger} as a float. If {@code this} is too big to
 * be represented as a float, then {@code Float.POSITIVE_INFINITY} or
 * {@code Float.NEGATIVE_INFINITY} is returned. Note that not all integers
 * in the range {@code [-Float.MAX_VALUE, Float.MAX_VALUE]} can be exactly
 * represented as a float.
 */
@Override
public float floatValue() {
  return (float) doubleValue();
}

@Override
public double getDoubleValue() { return _value.doubleValue(); }

@Override
public double getRingFraction(String start, String end)
{
  return getTokenCountInRange(start, end).doubleValue() / TOTAL_TOKEN_COUNT.doubleValue();
}

@Override
public double getRingFraction(String start, String end)
{
  return getTokenCountInRange(start, end).doubleValue() / TOTAL_TOKEN_COUNT.doubleValue();
}

@Override
public double doubleValue() { return _value.doubleValue(); }

protected void convertNumberToDouble() throws IOException
{
  /* 05-Aug-2008, tatus: Important note: this MUST start with
   *   more accurate representations, since we don't know which
   *   value is the original one (others get generated when
   *   requested)
   */

  if ((_numTypesValid & NR_BIGDECIMAL) != 0) {
    _numberDouble = _numberBigDecimal.doubleValue();
  } else if ((_numTypesValid & NR_BIGINT) != 0) {
    _numberDouble = _numberBigInt.doubleValue();
  } else if ((_numTypesValid & NR_LONG) != 0) {
    _numberDouble = (double) _numberLong;
  } else if ((_numTypesValid & NR_INT) != 0) {
    _numberDouble = (double) _numberInt;
  } else {
    _throwInternal();
  }
  _numTypesValid |= NR_DOUBLE;
}

protected void convertNumberToDouble() throws IOException
{
  /* 05-Aug-2008, tatus: Important note: this MUST start with
   *   more accurate representations, since we don't know which
   *   value is the original one (others get generated when
   *   requested)
   */

  if ((_numTypesValid & NR_BIGDECIMAL) != 0) {
    _numberDouble = _numberBigDecimal.doubleValue();
  } else if ((_numTypesValid & NR_BIGINT) != 0) {
    _numberDouble = _numberBigInt.doubleValue();
  } else if ((_numTypesValid & NR_LONG) != 0) {
    _numberDouble = (double) _numberLong;
  } else if ((_numTypesValid & NR_INT) != 0) {
    _numberDouble = (double) _numberInt;
  } else {
    _throwInternal();
  }
  _numTypesValid |= NR_DOUBLE;
}

/**
 * Power of a BigInteger to a BigInteger certain exponent. Called by the '**' operator.
 *
 * @param self     a BigInteger
 * @param exponent a BigInteger exponent
 * @return a BigInteger to the power of a the exponent
 * @since 2.3.8
 */
public static BigInteger power(BigInteger self, BigInteger exponent) {
  if ((exponent.signum() >= 0) && (exponent.compareTo(BI_INT_MAX) <= 0)) {
    return self.pow(exponent.intValue());
  } else {
    return BigDecimal.valueOf(Math.pow(self.doubleValue(), exponent.doubleValue())).toBigInteger();
  }
}

 private static final double LOG2 = Math.log(2.0);

/**
 * Computes the natural logarithm of a BigInteger. Works for really big
 * integers (practically unlimited)
 * 
 * @param val Argument, positive integer
 * @return Natural logarithm, as in <tt>Math.log()</tt>
 */
public static double logBigInteger(BigInteger val) {
  int blex = val.bitLength() - 1022; // any value in 60..1023 is ok
  if (blex > 0)
    val = val.shiftRight(blex);
  double res = Math.log(val.doubleValue());
  return blex > 0 ? res + blex * LOG2 : res;
}

/**
 * <p>
 * Returns a <code>double</code> whose value is
 * <tt>(this<sup>exponent</sup>)</tt>, returning the result in reduced form.
 * </p>
 *
 * @param exponent
 *            exponent to which this <code>BigFraction</code> is to be raised.
 * @return <tt>this<sup>exponent</sup></tt>.
 */
public double pow(final double exponent) {
  return FastMath.pow(numerator.doubleValue(),   exponent) /
      FastMath.pow(denominator.doubleValue(), exponent);
}

protected void convertNumberToDouble()
  throws IOException, JsonParseException
{
  /* 05-Aug-2008, tatus: Important note: this MUST start with
   *   more accurate representations, since we don't know which
   *   value is the original one (others get generated when
   *   requested)
   */

  if ((_numTypesValid & NR_BIGDECIMAL) != 0) {
    _numberDouble = _numberBigDecimal.doubleValue();
  } else if ((_numTypesValid & NR_BIGINT) != 0) {
    _numberDouble = _numberBigInt.doubleValue();
  } else if ((_numTypesValid & NR_LONG) != 0) {
    _numberDouble = (double) _numberLong;
  } else if ((_numTypesValid & NR_INT) != 0) {
    _numberDouble = (double) _numberInt;
  } else {
    _throwInternal(); // should never get here
  }

  _numTypesValid |= NR_DOUBLE;
}

private double extractDoubleValue(Object value) {
  if ( value instanceof BigInteger ) {
    return ( ( BigInteger ) value ).doubleValue();
  }
  else if ( value instanceof BigDecimal ) {
    return ( ( BigDecimal ) value ).doubleValue();
  }
  else {
    return Double.valueOf( value.toString() ).doubleValue();
  }
}

  @Override
  public Double parseLiteral(Object input) {
    if (input instanceof IntValue) {
      return ((IntValue) input).getValue().doubleValue();
    } else if (input instanceof FloatValue) {
      return ((FloatValue) input).getValue().doubleValue();
    } else {
      throw new CoercingParseLiteralException(
          "Expected AST type 'IntValue' or 'FloatValue' but was '" + typeName(input) + "'."
      );
    }
  }
});

@AndroidIncompatible // TODO(cpovirk): File bug for BigDecimal.doubleValue().
public void testBigToDouble() {
 for (BigInteger b : ALL_BIGINTEGER_CANDIDATES) {
  if (b.doubleValue() != DoubleUtils.bigToDouble(b)) {
   failFormat(
     "Converting %s to double: expected doubleValue %s but got bigToDouble %s",
     b, b.doubleValue(), DoubleUtils.bigToDouble(b));
  }
 }
}

public void testConstantsEverySixteenthFactorial() {
 for (int i = 0, n = 0; n <= DoubleMath.MAX_FACTORIAL; i++, n += 16) {
  assertEquals(
    BigIntegerMath.factorial(n).doubleValue(), DoubleMath.everySixteenthFactorial[i]);
 }
}

public void testDoubleValue() {
 for (long value : TEST_LONGS) {
  UnsignedLong unsignedValue = UnsignedLong.fromLongBits(value);
  assertEquals(unsignedValue.bigIntegerValue().doubleValue(), unsignedValue.doubleValue());
 }
}

public void testDoubleValue() {
 for (int value : TEST_INTS) {
  UnsignedInteger unsignedValue = UnsignedInteger.fromIntBits(value);
  assertEquals(unsignedValue.bigIntegerValue().doubleValue(), unsignedValue.doubleValue());
 }
}

@GwtIncompatible // Math.ulp
public void testFactorial() {
 for (int i = 0; i <= DoubleMath.MAX_FACTORIAL; i++) {
  double actual = BigIntegerMath.factorial(i).doubleValue();
  double result = DoubleMath.factorial(i);
  assertEquals(actual, result, Math.ulp(actual));
 }
}