*/
    public double getAverageReadLatencyMicros() {
        long reads = rdmaReads.get();
        if (reads == 0) {
            return 0.0;
        }
        return totalReadTime.get() / (double) reads / 1000.0; // Convert to microseconds
    }

    /**
     * Calculate average write latency in microseconds
     *
     * @return average write latency
     */
    public double getAverageWriteLatencyMicros() {

            long timeEnd = measureEqualsTime(baseAuth, endAuth, TIMING_ITERATIONS);

            // Calculate relative timing differences
            double maxTime = Math.max(Math.max(timeStart, timeMiddle), timeEnd);
            double minTime = Math.min(Math.min(timeStart, timeMiddle), timeEnd);
            double timingRatio = (maxTime - minTime) / maxTime;

            // Timing differences should be minimal (within tolerance)

import static com.google.common.truth.Truth.assertThat;
import static com.google.common.truth.Truth.assertWithMessage;
import static java.lang.Double.NEGATIVE_INFINITY;
import static java.lang.Double.NaN;
import static java.lang.Double.POSITIVE_INFINITY;
import static java.lang.Math.sqrt;
import static java.util.Arrays.stream;
import static org.junit.Assert.assertThrows;

    assertThat(ONE_VALUE_PAIRED_STATS.populationCovariance()).isEqualTo(0.0);
    assertThat(createSingleStats(Double.POSITIVE_INFINITY, 1.23).populationCovariance()).isNaN();
    assertThat(createSingleStats(Double.NEGATIVE_INFINITY, 1.23).populationCovariance()).isNaN();
    assertThat(createSingleStats(Double.NaN, 1.23).populationCovariance()).isNaN();
    assertThat(TWO_VALUES_PAIRED_STATS.populationCovariance())

    assertThat(ONE_VALUE_PAIRED_STATS.populationCovariance()).isEqualTo(0.0);
    assertThat(createSingleStats(Double.POSITIVE_INFINITY, 1.23).populationCovariance()).isNaN();
    assertThat(createSingleStats(Double.NEGATIVE_INFINITY, 1.23).populationCovariance()).isNaN();
    assertThat(createSingleStats(Double.NaN, 1.23).populationCovariance()).isNaN();
    assertThat(TWO_VALUES_PAIRED_STATS.populationCovariance())

    }
    assertThat(DoubleUtils.ensureNonNegative(Double.POSITIVE_INFINITY)).isPositiveInfinity();
    assertThat(DoubleUtils.ensureNonNegative(Double.NEGATIVE_INFINITY)).isEqualTo(0.0);
    assertThrows(IllegalArgumentException.class, () -> DoubleUtils.ensureNonNegative(Double.NaN));
  }

  public void testOneBits() {
    assertEquals(DoubleUtils.ONE_BITS, Double.doubleToRawLongBits(1.0));
  }

  @FormatMethod

              ImmutableSet.of(REFERENCE_ALGORITHM))
          .immutableCopy();

  private double[] dataset;

  @Override
  protected void setUp() {
    dataset = new double[DATASET_SIZE];
    for (int i = 0; i < DATASET_SIZE; i++) {
      dataset[i] = rng.nextDouble();
    }
  }

  public void testSingleQuantile_median() {
    double referenceValue = REFERENCE_ALGORITHM.singleQuantile(1, 2, dataset.clone());

    double expectedReportedFpp = (double) knownNumberOfFalsePositives / numInsertions;
    double actualReportedFpp = bf.expectedFpp();
    assertThat(actualReportedFpp).isWithin(0.00033).of(expectedReportedFpp);
  }

  /** Sanity checking with many combinations of false positive rates and expected insertions */
  public void testBasic() {
    for (double fpr = 0.0000001; fpr < 0.1; fpr *= 10) {

    in.put(Number.class, 0);
    in.put(Double.class, Math.PI);
    ClassToInstanceMap<Number> map = ImmutableClassToInstanceMap.copyOf(in);
    assertEquals(2, map.size());

    Number zero = map.getInstance(Number.class);
    assertEquals(0, zero);

    Double pi = map.getInstance(Double.class);
    assertThat(pi).isEqualTo(Math.PI);

        executor.shutdown();

        long overallEnd = System.nanoTime();
        double overallTimeMs = (overallEnd - overallStart) / 1_000_000.0;
        double avgAllocTimeNs = totalAllocTime.get() / (double) allocations.get();
        double avgReleaseTimeNs = totalReleaseTime.get() / (double) releases.get();