}

  public void testLog2NaNInfinity() {
    assertEquals(Double.POSITIVE_INFINITY, DoubleMath.log2(Double.POSITIVE_INFINITY));
    assertTrue(Double.isNaN(DoubleMath.log2(Double.NEGATIVE_INFINITY)));
    assertTrue(Double.isNaN(DoubleMath.log2(Double.NaN)));
  }

  @GwtIncompatible // StrictMath
  private strictfp double trueLog2(double d) {

    BigDecimal maxDoubleAsBD = new BigDecimal(Double.MAX_VALUE);
    new RoundToDoubleTester(maxDoubleAsBD).setExpectation(Double.MAX_VALUE, values()).test();
  }

  public void testRoundToDouble_maxDoublePlusOne() {
    BigDecimal maxDoubleAsBD = new BigDecimal(Double.MAX_VALUE).add(BigDecimal.ONE);
    new RoundToDoubleTester(maxDoubleAsBD)
        .setExpectation(Double.MAX_VALUE, DOWN, FLOOR, HALF_EVEN, HALF_UP, HALF_DOWN)

  static final double MANY_VALUES_MAX = 555.555;
  static final double MANY_VALUES_MIN = -44.44;

  // Doubles which will overflow if summed:
  static final double[] LARGE_VALUES = {Double.MAX_VALUE, Double.MAX_VALUE / 2.0};
  static final double LARGE_VALUES_MEAN = 0.75 * Double.MAX_VALUE;

  static final ImmutableList<Double> OTHER_MANY_VALUES =

   * each other or identical non-finite values.
   */
  private static final Correspondence<Double, Double> QUANTILE_CORRESPONDENCE =
      Correspondence.from(
          new BinaryPredicate<Double, Double>() {
            @Override
            public boolean apply(@Nullable Double actual, @Nullable Double expected) {
              // Test for equality to allow non-finite values to match; otherwise, use the finite

   * each other or identical non-finite values.
   */
  private static final Correspondence<Double, Double> QUANTILE_CORRESPONDENCE =
      Correspondence.from(
          new BinaryPredicate<Double, Double>() {
            @Override
            public boolean apply(@Nullable Double actual, @Nullable Double expected) {
              // Test for equality to allow non-finite values to match; otherwise, use the finite

  static final double MANY_VALUES_MAX = 555.555;
  static final double MANY_VALUES_MIN = -44.44;

  // Doubles which will overflow if summed:
  static final double[] LARGE_VALUES = {Double.MAX_VALUE, Double.MAX_VALUE / 2.0};
  static final double LARGE_VALUES_MEAN = 0.75 * Double.MAX_VALUE;

  static final ImmutableList<Double> OTHER_MANY_VALUES =

  public static final class ImmutableDoubleArrayMiddleSubListAsListGenerator
      extends TestDoubleListGenerator {
    @Override
    protected List<Double> create(Double[] elements) {
      Double[] prefix = {Double.MIN_VALUE, Double.MAX_VALUE};
      Double[] suffix = {86.0, 99.0};
      Double[] all = concat(concat(prefix, elements), suffix);
      return makeArray(all).subArray(2, elements.length + 2).asList();
    }
  }

   *
   * <p>If the dataset contains {@link Double#NaN} then the result is {@link Double#NaN}. If it
   * contains both {@link Double#POSITIVE_INFINITY} and {@link Double#NEGATIVE_INFINITY} then the
   * result is {@link Double#NaN}. If it contains {@link Double#POSITIVE_INFINITY} and finite values
   * only or {@link Double#POSITIVE_INFINITY} only, the result is {@link Double#POSITIVE_INFINITY}.

            ConstantValueKind.UnsignedShort -> KtConstantValue.KtUnsignedShortConstantValue(value as UShort, psi)

            ConstantValueKind.Double -> KtConstantValue.KtDoubleConstantValue(value as Double, psi)
            ConstantValueKind.Float -> KtConstantValue.KtFloatConstantValue(value as Float, psi)

    for (double positiveValue : POSITIVE_FINITE_DOUBLE_CANDIDATES) {
      assertEquals(positiveValue, DoubleUtils.ensureNonNegative(positiveValue));
      assertEquals(0.0, DoubleUtils.ensureNonNegative(-positiveValue));
    }
    assertEquals(Double.POSITIVE_INFINITY, DoubleUtils.ensureNonNegative(Double.POSITIVE_INFINITY));
    assertEquals(0.0, DoubleUtils.ensureNonNegative(Double.NEGATIVE_INFINITY));