return LinearTransformation.vertical(xStats.mean());
    }
  }

  /**
   * {@inheritDoc}
   *
   * <p><b>Note:</b> This tests exact equality of the calculated statistics, including the floating
   * point values. Two instances are guaranteed to be considered equal if one is copied from the
   * other using {@code second = new PairedStatsAccumulator().addAll(first).snapshot()}, if both

   * Returns the current sum. The returned value is NOT an atomic snapshot; invocation in
   * the absence of concurrent updates returns an accurate result, but concurrent updates that occur
   * while the sum is being calculated might not be incorporated.
   *
   * @return the sum
   */
  @Override
  public long sum() {
    long sum = base;
    Cell[] as = cells;
    if (as != null) {
      int n = as.length;

        if (inputs != null) {
            Arrays.sort(inputs);
        }
        if (newInputs != null) {
            Arrays.sort(newInputs);
        }
    }

    /**
     * Calculates the hash code for this CharMappingItem based on inputs and output.
     *
     * @return the hash code value for this object
     */
    @Override
    public int hashCode() {

    <function-signature>boolean fileExists(java.lang.String)</function-signature>
    <example>
      ${fe:fileExists(path)}
    </example>
  </function>

  <function>
    <description>Calculates URL.</description>
    <name>url</name>
    <function-class>org.codelibs.fess.taglib.FessFunctions</function-class>
    <function-signature>java.lang.String url(java.lang.String)</function-signature>

than the minimum font size\n    @if $fs <= $rfs-base-font-size or not $enable-responsive-font-sizes {\n      font-size: #{$rfs-static}#{$rfs-suffix};\n    }\n    @else {\n      // Calculate the minimum font size for $fs\n      $fs-min: $rfs-base-font-size + divide($fs - $rfs-base-font-size, $rfs-factor);\n\n      // Calculate difference between $fs and the minimum font size\n      $fs-diff: $fs - $fs-min;\n\n      // Base font-size formatting\n      $min-width: if($rfs-font-size-unit == rem, #{divide($fs-min,...

- ResourceQuota of an entity now inclusively calculate Pod overhead ([#99600](https://github.com/kubernetes/kubernetes/pull/99600), [@gjkim42](https://github.com/gjkim42))

        this.partialResults = partialResults;
        this.facetResponse = facetResponse;
        if (pageSize > 0) {
            calculatePageInfo();
        }
    }

    /**
     * Calculates pagination information based on the current parameters.
     * This method computes page counts, navigation flags, record numbers, and page number lists.
     */
    protected void calculatePageInfo() {

   * unless the user is actually calling a parse method.
   */
  private static final class ParseOverflowDetection {
    private ParseOverflowDetection() {}

    // calculated as 0xffffffffffffffff / radix
    static final long[] maxValueDivs = new long[Character.MAX_RADIX + 1];
    static final int[] maxValueMods = new int[Character.MAX_RADIX + 1];

  }

  public void testScale_indexes_varargs_compute_doubleCollection_snapshotsIndexes() {
    // This test is the same as testScale_indexes_varargs_compute_doubleCollection except that the
    // array of indexes to be calculated is modified between the calls to indexes and compute: since
    // the contract is that it is snapshotted, this shouldn't make any difference to the result.
    int[] indexes = {0, 10, 5, 1, 8, 10};

  }

  public void testScale_indexes_varargs_compute_doubleCollection_snapshotsIndexes() {
    // This test is the same as testScale_indexes_varargs_compute_doubleCollection except that the
    // array of indexes to be calculated is modified between the calls to indexes and compute: since
    // the contract is that it is snapshotted, this shouldn't make any difference to the result.
    int[] indexes = {0, 10, 5, 1, 8, 10};