*
 * <h3>Examples</h3>
 *
 * <p>To compute the median:
 *
 * {@snippet :
 * double myMedian = median().compute(myDataset);
 * }
 *
 * where {@link #median()} has been statically imported.
 *
 * <p>To compute the 99th percentile:
 *
 * {@snippet :
 * double myPercentile99 = percentiles().index(99).compute(myDataset);
 * }
 *

        return (logX2Floor < 2 * logFloor + 1) ? logFloor : logFloor + 1;
    }
    throw new AssertionError();
  }

  /*
   * The maximum number of bits in a square root for which we'll precompute an explicit half power
   * of two. This can be any value, but higher values incur more class load time and linearly
   * increasing memory consumption.
   */

internal fun <T : Any> AtomicReference<Tags>.computeIfAbsent(
  type: KClass<T>,
  compute: () -> T,
): T {
  var computed: T? = null

  while (true) {
    val tags = get()

    // If the element is already present. Return it.
    val existing = tags[type]
    if (existing != null) return existing

    if (computed == null) {
      computed = compute()
    }

    assertEquals(0x388ee898bad75cbfL, hasher.hash().asLong());
  }

  /** Convenience method to compute a fingerprint on a full bytes array. */
  private static long fingerprint(byte[] bytes) {
    return fingerprint(bytes, bytes.length);
  }

  /** Convenience method to compute a fingerprint on a subset of a byte array. */
  private static long fingerprint(byte[] bytes, int length) {

        // use original key
        return parent.computeIfPresent(key, remappingFunction);
    }

    @Override
    public V compute(final K key, final BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
        // use original key
        return parent.compute(key, remappingFunction);
    }

    @Override

   *
   * @since 21.0
   */
  @CanIgnoreReturnValue
  public long updateAndGet(K key, LongUnaryOperator updaterFunction) {
    checkNotNull(updaterFunction);
    Long result =
        map.compute(
            key,
            (K k, @Nullable Long value) ->
                updaterFunction.applyAsLong(value == null ? 0L : value.longValue()));
    return requireNonNull(result);
  }

  /**

    assertEquals(0xcf54171253fdc198L, hasher.hash().asLong());
  }

  /** Convenience method to compute a fingerprint on a full bytes array. */
  private static long fingerprint(byte[] bytes) {
    return fingerprint(bytes, bytes.length);
  }

  /** Convenience method to compute a fingerprint on a subset of a byte array. */
  private static long fingerprint(byte[] bytes, int length) {

            }

            // Compute Resource Group IDs with Resource Domain ID to get SIDs
            this.resourceGroupSids = new SID[resourceGroups.length];
            for (int i = 0; i < resourceGroups.length; i++) {
                this.resourceGroupSids[i] = new SID(resourceDomainId, resourceGroups[i].getId());
            }

            // Compute User IDs with Domain ID to get User SIDs

    (For example, a function in a library to compute square roots has
    a purpose that is entirely well-defined independent of the
    application.  Therefore, Subsection 2d requires that any
    application-supplied function or table used by this function must
    be optional: if the application does not supply it, the square
    root function must still compute square roots.)

    this.nextOrNull = firstOrNull;
  }

  /**
   * Returns the element that follows {@code previous}, or returns {@code null} if no elements
   * remain. This method is invoked during each call to {@link #next()} in order to compute the
   * result of a <i>future</i> call to {@code next()}.
   */
  protected abstract @Nullable T computeNext(T previous);

  @Override
  public final boolean hasNext() {
    return nextOrNull != null;
  }