* infinite {@code double} values are considered infinitely far away. For example, 2^2000 is not
   * representable as a double, but {@code roundToDouble(BigDecimal.valueOf(2).pow(2000), HALF_UP)}
   * will return {@code Double.MAX_VALUE}, not {@code Double.POSITIVE_INFINITY}.
   *
   * <p>For the case of {@link RoundingMode#HALF_EVEN}, this implementation uses the IEEE 754

  private static final double ALLOWED_ERROR = 1.0e-10;
  private static final QuantilesAlgorithm REFERENCE_ALGORITHM = QuantilesAlgorithm.SORTING;
  private static final Set<QuantilesAlgorithm> NON_REFERENCE_ALGORITHMS =
      Sets.difference(
          ImmutableSet.copyOf(QuantilesAlgorithm.values()), ImmutableSet.of(REFERENCE_ALGORITHM));

  private double[] dataset;

  @Override
  protected void setUp() {

      PairedStatsAccumulator accumulatorByAddAllPartitionedPairedStats =
          createPartitionedFilledPairedStatsAccumulator(values.asIterable(), OTHER_MANY_VALUES, 2);
      double populationCovariance = accumulator.populationCovariance();
      double populationCovarianceByAddAllPartitionedPairedStats =
          accumulatorByAddAllPartitionedPairedStats.populationCovariance();
      if (values.hasAnyNonFinite()) {

    Random random = new Random();
    int warmupPermits = 10;
    double[] coldFactorsToTest = {2.0, 3.0, 10.0};
    double[] qpsToTest = {4.0, 2.0, 1.0, 0.5, 0.1};
    for (int trial = 0; trial < 100; trial++) {
      for (double coldFactor : coldFactorsToTest) {
        for (double qps : qpsToTest) {
          // If warmupPermits = maxPermits - thresholdPermits then

    Random random = new Random();
    int warmupPermits = 10;
    double[] coldFactorsToTest = {2.0, 3.0, 10.0};
    double[] qpsToTest = {4.0, 2.0, 1.0, 0.5, 0.1};
    for (int trial = 0; trial < 100; trial++) {
      for (double coldFactor : coldFactorsToTest) {
        for (double qps : qpsToTest) {
          // If warmupPermits = maxPermits - thresholdPermits then

 *
 * @author Louis Wasserman
 */
public class DoubleMathRoundingBenchmark {
  private static final double[] doubleInIntRange = new double[ARRAY_SIZE];
  private static final double[] doubleInLongRange = new double[ARRAY_SIZE];
  private static final double[] positiveDoubles = new double[ARRAY_SIZE];

  @Param({"DOWN", "UP", "FLOOR", "CEILING", "HALF_EVEN", "HALF_UP", "HALF_DOWN"})
  RoundingMode mode;

    // For datasets of many double values created from an iterable, we test many combinations of
    // finite and non-finite values:
    for (ManyValues values : ALL_MANY_VALUES) {
      StatsAccumulator accumulator = new StatsAccumulator();
      StatsAccumulator accumulatorByAddAllStats = new StatsAccumulator();
      accumulator.addAll(values.asIterable());
      for (double value : values.asIterable()) {

     * than lower ones.
     */
    return (int) Math.pow(a, 1.0 / concentration);
  }

  @AfterExperiment
  void tearDown() {
    double req = requests.get();
    double hit = req - misses.get();

    // Currently, this is going into /dev/null, but I'll fix that
    System.out.println("hit rate: " + hit / req);
  }

  // for proper distributions later:

    // For datasets of many double values created from an iterable, we test many combinations of
    // finite and non-finite values:
    for (ManyValues values : ALL_MANY_VALUES) {
      StatsAccumulator accumulator = new StatsAccumulator();
      StatsAccumulator accumulatorByAddAllStats = new StatsAccumulator();
      accumulator.addAll(values.asIterable());
      for (double value : values.asIterable()) {

  public static RateLimiter create(double permitsPerSecond, long warmupPeriod, TimeUnit unit) {
    checkArgument(warmupPeriod >= 0, "warmupPeriod must not be negative: %s", warmupPeriod);
    return create(
        permitsPerSecond, warmupPeriod, unit, 3.0, SleepingStopwatch.createFromSystemTimer());
  }

  @VisibleForTesting
  static RateLimiter create(
      double permitsPerSecond,
      long warmupPeriod,