*/

package org.gradle.internal.util;

import javax.annotation.Nullable;
import java.math.BigDecimal;
import java.math.MathContext;
import java.util.List;

import static java.math.RoundingMode.FLOOR;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;

/**
 * Utility methods for working with numbers
 */
public class NumberUtil {

      }
    }
  }

  // Relies on the correctness of log10(long, FLOOR) and of pow(long, int).
  @GwtIncompatible // TODO
  public void testLog10Exact() {
    for (long x : POSITIVE_LONG_CANDIDATES) {
      int floor = LongMath.log10(x, FLOOR);
      boolean expectedSuccess = LongMath.pow(10, floor) == x;
      try {
        assertEquals(floor, LongMath.log10(x, UNNECESSARY));
        assertTrue(expectedSuccess);

     * can narrow the possible floor(log10(x)) values to two. For example, if floor(log2(x)) is 6,
     * then 64 <= x < 128, so floor(log10(x)) is either 1 or 2.
     */
    int y = maxLog10ForLeadingZeros[Integer.numberOfLeadingZeros(x)];
    /*
     * y is the higher of the two possible values of floor(log10(x)). If x < 10^y, then we want the

     * can narrow the possible floor(log10(x)) values to two. For example, if floor(log2(x)) is 6,
     * then 64 <= x < 128, so floor(log10(x)) is either 1 or 2.
     */
    int y = maxLog10ForLeadingZeros[Integer.numberOfLeadingZeros(x)];
    /*
     * y is the higher of the two possible values of floor(log10(x)). If x < 10^y, then we want the

     * can narrow the possible floor(log10(x)) values to two. For example, if floor(log2(x)) is 6,
     * then 64 <= x < 128, so floor(log10(x)) is either 1 or 2.
     */
    int y = maxLog10ForLeadingZeros[Long.numberOfLeadingZeros(x)];
    /*
     * y is the higher of the two possible values of floor(log10(x)). If x < 10^y, then we want the

            }
            roundFloor = toX(roundFloorAsDouble, RoundingMode.FLOOR);
          }

          X deltaToFloor = minus(x, roundFloor);
          X deltaToCeiling = minus(roundCeiling, x);
          int diff = deltaToFloor.compareTo(deltaToCeiling);
          if (diff < 0) { // closer to floor
            return roundFloorAsDouble;
          } else if (diff > 0) { // closer to ceiling

// CHECK: %[[arg1_add:.*]] = "tf.AddV2"(%[[arg1_div]]
// CHECK: %[[arg1_floor:.*]] = "tf.Floor"(%[[arg1_add]]
// CHECK: %[[arg1_clip:.*]] = "tf.ClipByValue"(%[[arg1_floor]]
// CHECK: %[[arg1_cast:.*]] = "tf.Cast"(%[[arg1_clip]]

// CHECK: %[[arg0_div:.*]] = "tf.Div"(%arg0
// CHECK: %[[arg0_add:.*]] = "tf.AddV2"(%[[arg0_div]]
// CHECK: %[[arg0_floor:.*]] = "tf.Floor"(%[[arg0_add]]
// CHECK: %[[arg0_clip:.*]] = "tf.ClipByValue"(%[[arg0_floor]]

  }

  @Override
  @CheckForNull
  public E floor(@ParametricNullness E e) {
    return delegate().floor(e);
  }

  /**
   * A sensible definition of {@link #floor} in terms of the {@code descendingIterator} method of
   * {@link #headSet(Object, boolean)}. If you override {@link #headSet(Object, boolean)}, you may
   * wish to override {@link #floor} to forward to this implementation.
   */
  @CheckForNull

  }

  @Override
  @CheckForNull
  public E floor(@ParametricNullness E e) {
    return delegate().floor(e);
  }

  /**
   * A sensible definition of {@link #floor} in terms of the {@code descendingIterator} method of
   * {@link #headSet(Object, boolean)}. If you override {@link #headSet(Object, boolean)}, you may
   * wish to override {@link #floor} to forward to this implementation.
   */
  @CheckForNull

// supports float types. tf.round with integer input type will become an
// identity op, so we will never face an mhlo.floor with an integer input type.
// The pattern matched executes the following computation:
// frac = x - floor(x)
// to_even = (floor(x) - 2 * floor(0.5 * x)) == 1
// if frac > 0.5 || (frac == 0.5 && to_even)
//   return floor(x) + 1
// else
//   return floor(x)