tmp += BigIntegerMath.divide(nonzero1[j], nonzero2[j], mode).intValue();
    }
    return tmp;
  }

  @Benchmark
  long roundToDouble(int reps) {
    long tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;
      tmp += Double.doubleToRawLongBits(BigIntegerMath.roundToDouble(nonzero1[j], mode));
    }
    return tmp;
  }

   *     is not precisely representable as a {@code double}
   * @since 30.0
   */
  public static double roundToDouble(BigDecimal x, RoundingMode mode) {
    return BigDecimalToDoubleRounder.INSTANCE.roundToDouble(x, mode);
  }

  private static class BigDecimalToDoubleRounder extends ToDoubleRounder<BigDecimal> {

   *     is not precisely representable as a {@code double}
   * @since 30.0
   */
  public static double roundToDouble(BigDecimal x, RoundingMode mode) {
    return BigDecimalToDoubleRounder.INSTANCE.roundToDouble(x, mode);
  }

  private static class BigDecimalToDoubleRounder extends ToDoubleRounder<BigDecimal> {

        RoundingMode mode = entry.getKey();
        Double expectation = entry.getValue();
        assertWithMessage("roundToDouble(" + input + ", " + mode + ")")
            .that(BigDecimalMath.roundToDouble(input, mode))
            .isEqualTo(expectation);
      }

      if (!expectedValues.containsKey(UNNECESSARY)) {

      tmp += BigIntegerMath.divide(nonzero1[j], nonzero2[j], mode).intValue();
    }
    return tmp;
  }

  @Benchmark
  long roundToDouble(int reps) {
    long tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;
      tmp += Double.doubleToRawLongBits(BigIntegerMath.roundToDouble(nonzero1[j], mode));
    }
    return tmp;
  }

    for (RoundingMode roundingMode : EnumSet.complementOf(EnumSet.of(UNNECESSARY))) {
      for (long candidate : roundToDoubleTestCandidates) {
        assertThat(LongMath.roundToDouble(candidate, roundingMode))
            .isEqualTo(BigIntegerMath.roundToDouble(BigInteger.valueOf(candidate), roundingMode));
      }
    }
  }

  @GwtIncompatible
  public void testRoundToDoubleAgainstBigIntegerUnnecessary() {

  abstract X toX(double d, RoundingMode mode);

  /** Returns a - b, guaranteed that both arguments are nonnegative. */
  abstract X minus(X a, X b);

  /** Rounds {@code x} to a {@code double}. */
  final double roundToDouble(X x, RoundingMode mode) {
    checkNotNull(x, "x");
    checkNotNull(mode, "mode");
    double roundArbitrarily = roundToDoubleArbitrarily(x);
    if (Double.isInfinite(roundArbitrarily)) {
      switch (mode) {

   *     is not precisely representable as a {@code double}
   * @since 30.0
   */
  @GwtIncompatible
  public static double roundToDouble(BigInteger x, RoundingMode mode) {
    return BigIntegerToDoubleRounder.INSTANCE.roundToDouble(x, mode);
  }

  @GwtIncompatible
  private static class BigIntegerToDoubleRounder extends ToDoubleRounder<BigInteger> {

  abstract X toX(double d, RoundingMode mode);

  /** Returns a - b, guaranteed that both arguments are nonnegative. */
  abstract X minus(X a, X b);

  /** Rounds {@code x} to a {@code double}. */
  final double roundToDouble(X x, RoundingMode mode) {
    checkNotNull(x, "x");
    checkNotNull(mode, "mode");
    double roundArbitrarily = roundToDoubleArbitrarily(x);
    if (Double.isInfinite(roundArbitrarily)) {
      switch (mode) {

   *     is not precisely representable as a {@code double}
   * @since 30.0
   */
  @SuppressWarnings("deprecation")
  @GwtIncompatible
  public static double roundToDouble(long x, RoundingMode mode) {
    // Logic adapted from ToDoubleRounder.
    double roundArbitrarily = (double) x;
    long roundArbitrarilyAsLong = (long) roundArbitrarily;
    int cmpXToRoundArbitrarily;