*/
  @InlineMe(replacement = "Double.compare(a, b)")
  public static int compare(double a, double b) {
    return Double.compare(a, b);
  }

  /**
   * Returns {@code true} if {@code value} represents a real number. This is equivalent to, but not
   * necessarily implemented as, {@code !(Double.isInfinite(value) || Double.isNaN(value))}.
   *
   * <p>Prefer {@link Double#isFinite(double)} instead.
   *
   * @since 10.0

    testRotate(new double[] {}, -1, new double[] {});
    testRotate(new double[] {}, 0, new double[] {});
    testRotate(new double[] {}, 1, new double[] {});

    testRotate(new double[] {1}, -2, new double[] {1});
    testRotate(new double[] {1}, -1, new double[] {1});
    testRotate(new double[] {1}, 0, new double[] {1});
    testRotate(new double[] {1}, 1, new double[] {1});
    testRotate(new double[] {1}, 2, new double[] {1});

  }

  static final ImmutableSet<Double> INTEGRAL_DOUBLE_CANDIDATES;
  static final ImmutableSet<Double> FRACTIONAL_DOUBLE_CANDIDATES;
  static final Iterable<Double> INFINITIES =
      Doubles.asList(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY);
  static final Iterable<Double> FINITE_DOUBLE_CANDIDATES;
  static final Iterable<Double> POSITIVE_FINITE_DOUBLE_CANDIDATES;

    }
  }

  private static double[] longsToDoubles(long[] longs) {
    int len = longs.length;
    double[] doubles = new double[len];
    for (int i = 0; i < len; i++) {
      doubles[i] = longs[i];
    }
    return doubles;
  }

  private static double[] intsToDoubles(int[] ints) {
    int len = ints.length;
    double[] doubles = new double[len];
    for (int i = 0; i < len; i++) {

    testRotate(new double[] {}, -1, new double[] {});
    testRotate(new double[] {}, 0, new double[] {});
    testRotate(new double[] {}, 1, new double[] {});

    testRotate(new double[] {1}, -2, new double[] {1});
    testRotate(new double[] {1}, -1, new double[] {1});
    testRotate(new double[] {1}, 0, new double[] {1});
    testRotate(new double[] {1}, 1, new double[] {1});
    testRotate(new double[] {1}, 2, new double[] {1});

   * 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}.
   * If it contains {@link Double#NEGATIVE_INFINITY} and finite values only or {@link
   * Double#NEGATIVE_INFINITY} only, the result is {@link Double#NEGATIVE_INFINITY}.

   *
   * <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}.

   * 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

          Doubles.asList(
              -Double.MIN_VALUE,
              -Double.MIN_NORMAL,
              -1,
              -20,
              Double.NaN,
              Double.NEGATIVE_INFINITY,
              -0.001));

  public void testFuzzyEqualsFinite() {
    for (double a : FINITE_DOUBLE_CANDIDATES) {
      for (double b : FINITE_DOUBLE_CANDIDATES) {