source: trip-planner-front/node_modules/hdr-histogram-js/dist/JsHistogram.js@ e29cc2e

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = exports.JsHistogram = void 0;
/*
 * This is a TypeScript port of the original Java version, which was written by
 * Gil Tene as described in
 * https://github.com/HdrHistogram/HdrHistogram
 * and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 */
const RecordedValuesIterator_1 = require("./RecordedValuesIterator");
const PercentileIterator_1 = require("./PercentileIterator");
const formatters_1 = require("./formatters");
const ulp_1 = require("./ulp");
const Histogram_1 = require("./Histogram");
const { pow, floor, ceil, log2, max, min } = Math;
class JsHistogram {
    constructor(lowestDiscernibleValue, highestTrackableValue, numberOfSignificantValueDigits) {
        this.autoResize = false;
        this.startTimeStampMsec = Number.MAX_SAFE_INTEGER;
        this.endTimeStampMsec = 0;
        this.tag = Histogram_1.NO_TAG;
        this.maxValue = 0;
        this.minNonZeroValue = Number.MAX_SAFE_INTEGER;
        this.identity = 0;
        this.highestTrackableValue = 0;
        this.lowestDiscernibleValue = 0;
        this.numberOfSignificantValueDigits = 0;
        this.bucketCount = 0;
        this.subBucketCount = 0;
        this.countsArrayLength = 0;
        this.wordSizeInBytes = 0;
        // Verify argument validity
        if (lowestDiscernibleValue < 1) {
            throw new Error("lowestDiscernibleValue must be >= 1");
        }
        if (highestTrackableValue < 2 * lowestDiscernibleValue) {
            throw new Error(`highestTrackableValue must be >= 2 * lowestDiscernibleValue ( 2 * ${lowestDiscernibleValue} )`);
        }
        if (numberOfSignificantValueDigits < 0 ||
            numberOfSignificantValueDigits > 5) {
            throw new Error("numberOfSignificantValueDigits must be between 0 and 5");
        }
        this.identity = JsHistogram.identityBuilder++;
        this.init(lowestDiscernibleValue, highestTrackableValue, numberOfSignificantValueDigits);
    }
    incrementTotalCount() {
        this._totalCount++;
    }
    addToTotalCount(value) {
        this._totalCount += value;
    }
    setTotalCount(value) {
        this._totalCount = value;
    }
    /**
     * Get the total count of all recorded values in the histogram
     * @return the total count of all recorded values in the histogram
     */
    get totalCount() {
        return this._totalCount;
    }
    updatedMaxValue(value) {
        const internalValue = value + this.unitMagnitudeMask;
        this.maxValue = internalValue;
    }
    updateMinNonZeroValue(value) {
        if (value <= this.unitMagnitudeMask) {
            return;
        }
        const internalValue = floor(value / this.lowestDiscernibleValueRounded) *
            this.lowestDiscernibleValueRounded;
        this.minNonZeroValue = internalValue;
    }
    init(lowestDiscernibleValue, highestTrackableValue, numberOfSignificantValueDigits) {
        this.lowestDiscernibleValue = lowestDiscernibleValue;
        this.highestTrackableValue = highestTrackableValue;
        this.numberOfSignificantValueDigits = numberOfSignificantValueDigits;
        /*
         * Given a 3 decimal point accuracy, the expectation is obviously for "+/- 1 unit at 1000". It also means that
         * it's "ok to be +/- 2 units at 2000". The "tricky" thing is that it is NOT ok to be +/- 2 units at 1999. Only
         * starting at 2000. So internally, we need to maintain single unit resolution to 2x 10^decimalPoints.
         */
        const largestValueWithSingleUnitResolution = 2 * floor(pow(10, numberOfSignificantValueDigits));
        this.unitMagnitude = floor(log2(lowestDiscernibleValue));
        this.lowestDiscernibleValueRounded = pow(2, this.unitMagnitude);
        this.unitMagnitudeMask = this.lowestDiscernibleValueRounded - 1;
        // We need to maintain power-of-two subBucketCount (for clean direct indexing) that is large enough to
        // provide unit resolution to at least largestValueWithSingleUnitResolution. So figure out
        // largestValueWithSingleUnitResolution's nearest power-of-two (rounded up), and use that:
        const subBucketCountMagnitude = ceil(log2(largestValueWithSingleUnitResolution));
        this.subBucketHalfCountMagnitude =
            (subBucketCountMagnitude > 1 ? subBucketCountMagnitude : 1) - 1;
        this.subBucketCount = pow(2, this.subBucketHalfCountMagnitude + 1);
        this.subBucketHalfCount = this.subBucketCount / 2;
        this.subBucketMask =
            (floor(this.subBucketCount) - 1) * pow(2, this.unitMagnitude);
        this.establishSize(highestTrackableValue);
        this.leadingZeroCountBase =
            53 - this.unitMagnitude - this.subBucketHalfCountMagnitude - 1;
        this.percentileIterator = new PercentileIterator_1.default(this, 1);
        this.recordedValuesIterator = new RecordedValuesIterator_1.default(this);
    }
    /**
     * The buckets (each of which has subBucketCount sub-buckets, here assumed to be 2048 as an example) overlap:
     *
     * <pre>
     * The 0'th bucket covers from 0...2047 in multiples of 1, using all 2048 sub-buckets
     * The 1'th bucket covers from 2048..4097 in multiples of 2, using only the top 1024 sub-buckets
     * The 2'th bucket covers from 4096..8191 in multiple of 4, using only the top 1024 sub-buckets
     * ...
     * </pre>
     *
     * Bucket 0 is "special" here. It is the only one that has 2048 entries. All the rest have 1024 entries (because
     * their bottom half overlaps with and is already covered by the all of the previous buckets put together). In other
     * words, the k'th bucket could represent 0 * 2^k to 2048 * 2^k in 2048 buckets with 2^k precision, but the midpoint
     * of 1024 * 2^k = 2048 * 2^(k-1) = the k-1'th bucket's end, so we would use the previous bucket for those lower
     * values as it has better precision.
     */
    establishSize(newHighestTrackableValue) {
        // establish counts array length:
        this.countsArrayLength = this.determineArrayLengthNeeded(newHighestTrackableValue);
        // establish exponent range needed to support the trackable value with no overflow:
        this.bucketCount = this.getBucketsNeededToCoverValue(newHighestTrackableValue);
        // establish the new highest trackable value:
        this.highestTrackableValue = newHighestTrackableValue;
    }
    determineArrayLengthNeeded(highestTrackableValue) {
        if (highestTrackableValue < 2 * this.lowestDiscernibleValue) {
            throw new Error("highestTrackableValue (" +
                highestTrackableValue +
                ") cannot be < (2 * lowestDiscernibleValue)");
        }
        //determine counts array length needed:
        const countsArrayLength = this.getLengthForNumberOfBuckets(this.getBucketsNeededToCoverValue(highestTrackableValue));
        return countsArrayLength;
    }
    /**
     * If we have N such that subBucketCount * 2^N > max value, we need storage for N+1 buckets, each with enough
     * slots to hold the top half of the subBucketCount (the lower half is covered by previous buckets), and the +1
     * being used for the lower half of the 0'th bucket. Or, equivalently, we need 1 more bucket to capture the max
     * value if we consider the sub-bucket length to be halved.
     */
    getLengthForNumberOfBuckets(numberOfBuckets) {
        const lengthNeeded = (numberOfBuckets + 1) * (this.subBucketCount / 2);
        return lengthNeeded;
    }
    getBucketsNeededToCoverValue(value) {
        // the k'th bucket can express from 0 * 2^k to subBucketCount * 2^k in units of 2^k
        let smallestUntrackableValue = this.subBucketCount * pow(2, this.unitMagnitude);
        // always have at least 1 bucket
        let bucketsNeeded = 1;
        while (smallestUntrackableValue <= value) {
            if (smallestUntrackableValue > Number.MAX_SAFE_INTEGER / 2) {
                // TODO check array max size in JavaScript
                // next shift will overflow, meaning that bucket could represent values up to ones greater than
                // Number.MAX_SAFE_INTEGER, so it's the last bucket
                return bucketsNeeded + 1;
            }
            smallestUntrackableValue = smallestUntrackableValue * 2;
            bucketsNeeded++;
        }
        return bucketsNeeded;
    }
    /**
     * Record a value in the histogram
     *
     * @param value The value to be recorded
     * @throws may throw Error if value is exceeds highestTrackableValue
     */
    recordValue(value) {
        this.recordSingleValue(value);
    }
    recordSingleValue(value) {
        const countsIndex = this.countsArrayIndex(value);
        if (countsIndex >= this.countsArrayLength) {
            this.handleRecordException(1, value);
        }
        else {
            this.incrementCountAtIndex(countsIndex);
        }
        this.updateMinAndMax(value);
        this.incrementTotalCount();
    }
    handleRecordException(count, value) {
        if (!this.autoResize) {
            throw new Error("Value " + value + " is outside of histogram covered range");
        }
        this.resize(value);
        var countsIndex = this.countsArrayIndex(value);
        this.addToCountAtIndex(countsIndex, count);
        this.highestTrackableValue = this.highestEquivalentValue(this.valueFromIndex(this.countsArrayLength - 1));
    }
    countsArrayIndex(value) {
        if (value < 0) {
            throw new Error("Histogram recorded value cannot be negative.");
        }
        const bucketIndex = this.getBucketIndex(value);
        const subBucketIndex = this.getSubBucketIndex(value, bucketIndex);
        return this.computeCountsArrayIndex(bucketIndex, subBucketIndex);
    }
    computeCountsArrayIndex(bucketIndex, subBucketIndex) {
        // TODO
        //assert(subBucketIndex < subBucketCount);
        //assert(bucketIndex == 0 || (subBucketIndex >= subBucketHalfCount));
        // Calculate the index for the first entry that will be used in the bucket (halfway through subBucketCount).
        // For bucketIndex 0, all subBucketCount entries may be used, but bucketBaseIndex is still set in the middle.
        const bucketBaseIndex = (bucketIndex + 1) * pow(2, this.subBucketHalfCountMagnitude);
        // Calculate the offset in the bucket. This subtraction will result in a positive value in all buckets except
        // the 0th bucket (since a value in that bucket may be less than half the bucket's 0 to subBucketCount range).
        // However, this works out since we give bucket 0 twice as much space.
        const offsetInBucket = subBucketIndex - this.subBucketHalfCount;
        // The following is the equivalent of ((subBucketIndex  - subBucketHalfCount) + bucketBaseIndex;
        return bucketBaseIndex + offsetInBucket;
    }
    /**
     * @return the lowest (and therefore highest precision) bucket index that can represent the value
     */
    getBucketIndex(value) {
        // Calculates the number of powers of two by which the value is greater than the biggest value that fits in
        // bucket 0. This is the bucket index since each successive bucket can hold a value 2x greater.
        // The mask maps small values to bucket 0.
        // return this.leadingZeroCountBase - Long.numberOfLeadingZeros(value | subBucketMask);
        return max(floor(log2(value)) -
            this.subBucketHalfCountMagnitude -
            this.unitMagnitude, 0);
    }
    getSubBucketIndex(value, bucketIndex) {
        // For bucketIndex 0, this is just value, so it may be anywhere in 0 to subBucketCount.
        // For other bucketIndex, this will always end up in the top half of subBucketCount: assume that for some bucket
        // k > 0, this calculation will yield a value in the bottom half of 0 to subBucketCount. Then, because of how
        // buckets overlap, it would have also been in the top half of bucket k-1, and therefore would have
        // returned k-1 in getBucketIndex(). Since we would then shift it one fewer bits here, it would be twice as big,
        // and therefore in the top half of subBucketCount.
        return floor(value / pow(2, bucketIndex + this.unitMagnitude));
    }
    updateMinAndMax(value) {
        if (value > this.maxValue) {
            this.updatedMaxValue(value);
        }
        if (value < this.minNonZeroValue && value !== 0) {
            this.updateMinNonZeroValue(value);
        }
    }
    /**
     * Get the value at a given percentile.
     * When the given percentile is &gt; 0.0, the value returned is the value that the given
     * percentage of the overall recorded value entries in the histogram are either smaller than
     * or equivalent to. When the given percentile is 0.0, the value returned is the value that all value
     * entries in the histogram are either larger than or equivalent to.
     * <p>
     * Note that two values are "equivalent" in this statement if
     * {@link org.HdrHistogram.JsHistogram#valuesAreEquivalent} would return true.
     *
     * @param percentile  The percentile for which to return the associated value
     * @return The value that the given percentage of the overall recorded value entries in the
     * histogram are either smaller than or equivalent to. When the percentile is 0.0, returns the
     * value that all value entries in the histogram are either larger than or equivalent to.
     */
    getValueAtPercentile(percentile) {
        const requestedPercentile = min(percentile, 100); // Truncate down to 100%
        // round count up to nearest integer, to ensure that the largest value that the requested percentile
        // of overall recorded values is actually included. However, this must be done with care:
        //
        // First, Compute fp value for count at the requested percentile. Note that fp result end up
        // being 1 ulp larger than the correct integer count for this percentile:
        const fpCountAtPercentile = (requestedPercentile / 100.0) * this.totalCount;
        // Next, round up, but make sure to prevent <= 1 ulp inaccurancies in the above fp math from
        // making us skip a count:
        const countAtPercentile = max(ceil(fpCountAtPercentile - ulp_1.default(fpCountAtPercentile)), // round up
        1 // Make sure we at least reach the first recorded entry
        );
        let totalToCurrentIndex = 0;
        for (let i = 0; i < this.countsArrayLength; i++) {
            totalToCurrentIndex += this.getCountAtIndex(i);
            if (totalToCurrentIndex >= countAtPercentile) {
                var valueAtIndex = this.valueFromIndex(i);
                return percentile === 0.0
                    ? this.lowestEquivalentValue(valueAtIndex)
                    : this.highestEquivalentValue(valueAtIndex);
            }
        }
        return 0;
    }
    valueFromIndexes(bucketIndex, subBucketIndex) {
        return subBucketIndex * pow(2, bucketIndex + this.unitMagnitude);
    }
    valueFromIndex(index) {
        let bucketIndex = floor(index / this.subBucketHalfCount) - 1;
        let subBucketIndex = (index % this.subBucketHalfCount) + this.subBucketHalfCount;
        if (bucketIndex < 0) {
            subBucketIndex -= this.subBucketHalfCount;
            bucketIndex = 0;
        }
        return this.valueFromIndexes(bucketIndex, subBucketIndex);
    }
    /**
     * Get the lowest value that is equivalent to the given value within the histogram's resolution.
     * Where "equivalent" means that value samples recorded for any two
     * equivalent values are counted in a common total count.
     *
     * @param value The given value
     * @return The lowest value that is equivalent to the given value within the histogram's resolution.
     */
    lowestEquivalentValue(value) {
        const bucketIndex = this.getBucketIndex(value);
        const subBucketIndex = this.getSubBucketIndex(value, bucketIndex);
        const thisValueBaseLevel = this.valueFromIndexes(bucketIndex, subBucketIndex);
        return thisValueBaseLevel;
    }
    /**
     * Get the highest value that is equivalent to the given value within the histogram's resolution.
     * Where "equivalent" means that value samples recorded for any two
     * equivalent values are counted in a common total count.
     *
     * @param value The given value
     * @return The highest value that is equivalent to the given value within the histogram's resolution.
     */
    highestEquivalentValue(value) {
        return this.nextNonEquivalentValue(value) - 1;
    }
    /**
     * Get the next value that is not equivalent to the given value within the histogram's resolution.
     * Where "equivalent" means that value samples recorded for any two
     * equivalent values are counted in a common total count.
     *
     * @param value The given value
     * @return The next value that is not equivalent to the given value within the histogram's resolution.
     */
    nextNonEquivalentValue(value) {
        return (this.lowestEquivalentValue(value) + this.sizeOfEquivalentValueRange(value));
    }
    /**
     * Get the size (in value units) of the range of values that are equivalent to the given value within the
     * histogram's resolution. Where "equivalent" means that value samples recorded for any two
     * equivalent values are counted in a common total count.
     *
     * @param value The given value
     * @return The size of the range of values equivalent to the given value.
     */
    sizeOfEquivalentValueRange(value) {
        const bucketIndex = this.getBucketIndex(value);
        const subBucketIndex = this.getSubBucketIndex(value, bucketIndex);
        const distanceToNextValue = pow(2, this.unitMagnitude +
            (subBucketIndex >= this.subBucketCount ? bucketIndex + 1 : bucketIndex));
        return distanceToNextValue;
    }
    /**
     * Get a value that lies in the middle (rounded up) of the range of values equivalent the given value.
     * Where "equivalent" means that value samples recorded for any two
     * equivalent values are counted in a common total count.
     *
     * @param value The given value
     * @return The value lies in the middle (rounded up) of the range of values equivalent the given value.
     */
    medianEquivalentValue(value) {
        return (this.lowestEquivalentValue(value) +
            floor(this.sizeOfEquivalentValueRange(value) / 2));
    }
    /**
     * Get the computed mean value of all recorded values in the histogram
     *
     * @return the mean value (in value units) of the histogram data
     */
    get mean() {
        if (this.totalCount === 0) {
            return 0;
        }
        this.recordedValuesIterator.reset();
        let totalValue = 0;
        while (this.recordedValuesIterator.hasNext()) {
            const iterationValue = this.recordedValuesIterator.next();
            totalValue +=
                this.medianEquivalentValue(iterationValue.valueIteratedTo) *
                    iterationValue.countAtValueIteratedTo;
        }
        return totalValue / this.totalCount;
    }
    getStdDeviation(mean = this.mean) {
        if (this.totalCount === 0) {
            return 0;
        }
        let geometric_deviation_total = 0.0;
        this.recordedValuesIterator.reset();
        while (this.recordedValuesIterator.hasNext()) {
            const iterationValue = this.recordedValuesIterator.next();
            const deviation = this.medianEquivalentValue(iterationValue.valueIteratedTo) - mean;
            geometric_deviation_total +=
                deviation * deviation * iterationValue.countAddedInThisIterationStep;
        }
        const std_deviation = Math.sqrt(geometric_deviation_total / this.totalCount);
        return std_deviation;
    }
    /**
     * Get the computed standard deviation of all recorded values in the histogram
     *
     * @return the standard deviation (in value units) of the histogram data
     */
    get stdDeviation() {
        if (this.totalCount === 0) {
            return 0;
        }
        const mean = this.mean;
        let geometric_deviation_total = 0.0;
        this.recordedValuesIterator.reset();
        while (this.recordedValuesIterator.hasNext()) {
            const iterationValue = this.recordedValuesIterator.next();
            const deviation = this.medianEquivalentValue(iterationValue.valueIteratedTo) - mean;
            geometric_deviation_total +=
                deviation * deviation * iterationValue.countAddedInThisIterationStep;
        }
        const std_deviation = Math.sqrt(geometric_deviation_total / this.totalCount);
        return std_deviation;
    }
    /**
     * Produce textual representation of the value distribution of histogram data by percentile. The distribution is
     * output with exponentially increasing resolution, with each exponentially decreasing half-distance containing
     * <i>dumpTicksPerHalf</i> percentile reporting tick points.
     *
     * @param printStream    Stream into which the distribution will be output
     * <p>
     * @param percentileTicksPerHalfDistance  The number of reporting points per exponentially decreasing half-distance
     * <p>
     * @param outputValueUnitScalingRatio    The scaling factor by which to divide histogram recorded values units in
     *                                     output
     * @param useCsvFormat  Output in CSV format if true. Otherwise use plain text form.
     */
    outputPercentileDistribution(percentileTicksPerHalfDistance = 5, outputValueUnitScalingRatio = 1, useCsvFormat = false) {
        let result = "";
        if (useCsvFormat) {
            result += '"Value","Percentile","TotalCount","1/(1-Percentile)"\n';
        }
        else {
            result += "       Value     Percentile TotalCount 1/(1-Percentile)\n\n";
        }
        const iterator = this.percentileIterator;
        iterator.reset(percentileTicksPerHalfDistance);
        let lineFormatter;
        let lastLineFormatter;
        if (useCsvFormat) {
            const valueFormatter = formatters_1.floatFormatter(0, this.numberOfSignificantValueDigits);
            const percentileFormatter = formatters_1.floatFormatter(0, 12);
            const lastFormatter = formatters_1.floatFormatter(0, 2);
            lineFormatter = (iterationValue) => valueFormatter(iterationValue.valueIteratedTo / outputValueUnitScalingRatio) +
                "," +
                percentileFormatter(iterationValue.percentileLevelIteratedTo / 100) +
                "," +
                iterationValue.totalCountToThisValue +
                "," +
                lastFormatter(1 / (1 - iterationValue.percentileLevelIteratedTo / 100)) +
                "\n";
            lastLineFormatter = (iterationValue) => valueFormatter(iterationValue.valueIteratedTo / outputValueUnitScalingRatio) +
                "," +
                percentileFormatter(iterationValue.percentileLevelIteratedTo / 100) +
                "," +
                iterationValue.totalCountToThisValue +
                ",Infinity\n";
        }
        else {
            const valueFormatter = formatters_1.floatFormatter(12, this.numberOfSignificantValueDigits);
            const percentileFormatter = formatters_1.floatFormatter(2, 12);
            const totalCountFormatter = formatters_1.integerFormatter(10);
            const lastFormatter = formatters_1.floatFormatter(14, 2);
            lineFormatter = (iterationValue) => valueFormatter(iterationValue.valueIteratedTo / outputValueUnitScalingRatio) +
                " " +
                percentileFormatter(iterationValue.percentileLevelIteratedTo / 100) +
                " " +
                totalCountFormatter(iterationValue.totalCountToThisValue) +
                " " +
                lastFormatter(1 / (1 - iterationValue.percentileLevelIteratedTo / 100)) +
                "\n";
            lastLineFormatter = (iterationValue) => valueFormatter(iterationValue.valueIteratedTo / outputValueUnitScalingRatio) +
                " " +
                percentileFormatter(iterationValue.percentileLevelIteratedTo / 100) +
                " " +
                totalCountFormatter(iterationValue.totalCountToThisValue) +
                "\n";
        }
        while (iterator.hasNext()) {
            const iterationValue = iterator.next();
            if (iterationValue.percentileLevelIteratedTo < 100) {
                result += lineFormatter(iterationValue);
            }
            else {
                result += lastLineFormatter(iterationValue);
            }
        }
        if (!useCsvFormat) {
            // Calculate and output mean and std. deviation.
            // Note: mean/std. deviation numbers are very often completely irrelevant when
            // data is extremely non-normal in distribution (e.g. in cases of strong multi-modal
            // response time distribution associated with GC pauses). However, reporting these numbers
            // can be very useful for contrasting with the detailed percentile distribution
            // reported by outputPercentileDistribution(). It is not at all surprising to find
            // percentile distributions where results fall many tens or even hundreds of standard
            // deviations away from the mean - such results simply indicate that the data sampled
            // exhibits a very non-normal distribution, highlighting situations for which the std.
            // deviation metric is a useless indicator.
            //
            const formatter = formatters_1.floatFormatter(12, this.numberOfSignificantValueDigits);
            const _mean = this.mean;
            const mean = formatter(_mean / outputValueUnitScalingRatio);
            const std_deviation = formatter(this.getStdDeviation(_mean) / outputValueUnitScalingRatio);
            const max = formatter(this.maxValue / outputValueUnitScalingRatio);
            const intFormatter = formatters_1.integerFormatter(12);
            const totalCount = intFormatter(this.totalCount);
            const bucketCount = intFormatter(this.bucketCount);
            const subBucketCount = intFormatter(this.subBucketCount);
            result += `#[Mean    = ${mean}, StdDeviation   = ${std_deviation}]
#[Max     = ${max}, Total count    = ${totalCount}]
#[Buckets = ${bucketCount}, SubBuckets     = ${subBucketCount}]
`;
        }
        return result;
    }
    get summary() {
        return Histogram_1.toSummary(this);
    }
    toJSON() {
        return this.summary;
    }
    inspect() {
        return this.toString();
    }
    [Symbol.for("nodejs.util.inspect.custom")]() {
        return this.toString();
    }
    /**
     * Provide a (conservatively high) estimate of the Histogram's total footprint in bytes
     *
     * @return a (conservatively high) estimate of the Histogram's total footprint in bytes
     */
    get estimatedFootprintInBytes() {
        return this._getEstimatedFootprintInBytes();
    }
    recordSingleValueWithExpectedInterval(value, expectedIntervalBetweenValueSamples) {
        this.recordSingleValue(value);
        if (expectedIntervalBetweenValueSamples <= 0) {
            return;
        }
        for (let missingValue = value - expectedIntervalBetweenValueSamples; missingValue >= expectedIntervalBetweenValueSamples; missingValue -= expectedIntervalBetweenValueSamples) {
            this.recordSingleValue(missingValue);
        }
    }
    recordCountAtValue(count, value) {
        const countsIndex = this.countsArrayIndex(value);
        if (countsIndex >= this.countsArrayLength) {
            this.handleRecordException(count, value);
        }
        else {
            this.addToCountAtIndex(countsIndex, count);
        }
        this.updateMinAndMax(value);
        this.addToTotalCount(count);
    }
    /**
     * Record a value in the histogram (adding to the value's current count)
     *
     * @param value The value to be recorded
     * @param count The number of occurrences of this value to record
     * @throws ArrayIndexOutOfBoundsException (may throw) if value is exceeds highestTrackableValue
     */
    recordValueWithCount(value, count) {
        this.recordCountAtValue(count, value);
    }
    /**
     * Record a value in the histogram.
     * <p>
     * To compensate for the loss of sampled values when a recorded value is larger than the expected
     * interval between value samples, Histogram will auto-generate an additional series of decreasingly-smaller
     * (down to the expectedIntervalBetweenValueSamples) value records.
     * <p>
     * Note: This is a at-recording correction method, as opposed to the post-recording correction method provided
     * by {@link #copyCorrectedForCoordinatedOmission(long)}.
     * The two methods are mutually exclusive, and only one of the two should be be used on a given data set to correct
     * for the same coordinated omission issue.
     * <p>
     * See notes in the description of the Histogram calls for an illustration of why this corrective behavior is
     * important.
     *
     * @param value The value to record
     * @param expectedIntervalBetweenValueSamples If expectedIntervalBetweenValueSamples is larger than 0, add
     *                                           auto-generated value records as appropriate if value is larger
     *                                           than expectedIntervalBetweenValueSamples
     * @throws ArrayIndexOutOfBoundsException (may throw) if value is exceeds highestTrackableValue
     */
    recordValueWithExpectedInterval(value, expectedIntervalBetweenValueSamples) {
        this.recordSingleValueWithExpectedInterval(value, expectedIntervalBetweenValueSamples);
    }
    recordValueWithCountAndExpectedInterval(value, count, expectedIntervalBetweenValueSamples) {
        this.recordCountAtValue(count, value);
        if (expectedIntervalBetweenValueSamples <= 0) {
            return;
        }
        for (let missingValue = value - expectedIntervalBetweenValueSamples; missingValue >= expectedIntervalBetweenValueSamples; missingValue -= expectedIntervalBetweenValueSamples) {
            this.recordCountAtValue(count, missingValue);
        }
    }
    /**
     * Add the contents of another histogram to this one, while correcting the incoming data for coordinated omission.
     * <p>
     * To compensate for the loss of sampled values when a recorded value is larger than the expected
     * interval between value samples, the values added will include an auto-generated additional series of
     * decreasingly-smaller (down to the expectedIntervalBetweenValueSamples) value records for each count found
     * in the current histogram that is larger than the expectedIntervalBetweenValueSamples.
     *
     * Note: This is a post-recording correction method, as opposed to the at-recording correction method provided
     * by {@link #recordValueWithExpectedInterval(long, long) recordValueWithExpectedInterval}. The two
     * methods are mutually exclusive, and only one of the two should be be used on a given data set to correct
     * for the same coordinated omission issue.
     * by
     * <p>
     * See notes in the description of the Histogram calls for an illustration of why this corrective behavior is
     * important.
     *
     * @param otherHistogram The other histogram. highestTrackableValue and largestValueWithSingleUnitResolution must match.
     * @param expectedIntervalBetweenValueSamples If expectedIntervalBetweenValueSamples is larger than 0, add
     *                                           auto-generated value records as appropriate if value is larger
     *                                           than expectedIntervalBetweenValueSamples
     * @throws ArrayIndexOutOfBoundsException (may throw) if values exceed highestTrackableValue
     */
    addWhileCorrectingForCoordinatedOmission(otherHistogram, expectedIntervalBetweenValueSamples) {
        const toHistogram = this;
        const otherValues = new RecordedValuesIterator_1.default(otherHistogram);
        while (otherValues.hasNext()) {
            const v = otherValues.next();
            toHistogram.recordValueWithCountAndExpectedInterval(v.valueIteratedTo, v.countAtValueIteratedTo, expectedIntervalBetweenValueSamples);
        }
    }
    /**
     * Add the contents of another histogram to this one.
     * <p>
     * As part of adding the contents, the start/end timestamp range of this histogram will be
     * extended to include the start/end timestamp range of the other histogram.
     *
     * @param otherHistogram The other histogram.
     * @throws (may throw) if values in fromHistogram's are
     * higher than highestTrackableValue.
     */
    add(otherHistogram) {
        if (!(otherHistogram instanceof JsHistogram)) {
            // should be impossible to be in this situation but actually
            // TypeScript has some flaws...
            throw new Error("Cannot add a WASM histogram to a regular JS histogram");
        }
        const highestRecordableValue = this.highestEquivalentValue(this.valueFromIndex(this.countsArrayLength - 1));
        if (highestRecordableValue < otherHistogram.maxValue) {
            if (!this.autoResize) {
                throw new Error("The other histogram includes values that do not fit in this histogram's range.");
            }
            this.resize(otherHistogram.maxValue);
        }
        if (this.bucketCount === otherHistogram.bucketCount &&
            this.subBucketCount === otherHistogram.subBucketCount &&
            this.unitMagnitude === otherHistogram.unitMagnitude) {
            // Counts arrays are of the same length and meaning, so we can just iterate and add directly:
            let observedOtherTotalCount = 0;
            for (let i = 0; i < otherHistogram.countsArrayLength; i++) {
                const otherCount = otherHistogram.getCountAtIndex(i);
                if (otherCount > 0) {
                    this.addToCountAtIndex(i, otherCount);
                    observedOtherTotalCount += otherCount;
                }
            }
            this.setTotalCount(this.totalCount + observedOtherTotalCount);
            this.updatedMaxValue(max(this.maxValue, otherHistogram.maxValue));
            this.updateMinNonZeroValue(min(this.minNonZeroValue, otherHistogram.minNonZeroValue));
        }
        else {
            // Arrays are not a direct match (or the other could change on the fly in some valid way),
            // so we can't just stream through and add them. Instead, go through the array and add each
            // non-zero value found at it's proper value:
            // Do max value first, to avoid max value updates on each iteration:
            const otherMaxIndex = otherHistogram.countsArrayIndex(otherHistogram.maxValue);
            let otherCount = otherHistogram.getCountAtIndex(otherMaxIndex);
            this.recordCountAtValue(otherCount, otherHistogram.valueFromIndex(otherMaxIndex));
            // Record the remaining values, up to but not including the max value:
            for (let i = 0; i < otherMaxIndex; i++) {
                otherCount = otherHistogram.getCountAtIndex(i);
                if (otherCount > 0) {
                    this.recordCountAtValue(otherCount, otherHistogram.valueFromIndex(i));
                }
            }
        }
        this.startTimeStampMsec = min(this.startTimeStampMsec, otherHistogram.startTimeStampMsec);
        this.endTimeStampMsec = max(this.endTimeStampMsec, otherHistogram.endTimeStampMsec);
    }
    /**
     * Get the count of recorded values at a specific value (to within the histogram resolution at the value level).
     *
     * @param value The value for which to provide the recorded count
     * @return The total count of values recorded in the histogram within the value range that is
     * {@literal >=} lowestEquivalentValue(<i>value</i>) and {@literal <=} highestEquivalentValue(<i>value</i>)
     */
    getCountAtValue(value) {
        const index = min(max(0, this.countsArrayIndex(value)), this.countsArrayLength - 1);
        return this.getCountAtIndex(index);
    }
    /**
     * Subtract the contents of another histogram from this one.
     * <p>
     * The start/end timestamps of this histogram will remain unchanged.
     *
     * @param otherHistogram The other histogram.
     * @throws ArrayIndexOutOfBoundsException (may throw) if values in otherHistogram's are higher than highestTrackableValue.
     *
     */
    subtract(otherHistogram) {
        const highestRecordableValue = this.valueFromIndex(this.countsArrayLength - 1);
        if (!(otherHistogram instanceof JsHistogram)) {
            // should be impossible to be in this situation but actually
            // TypeScript has some flaws...
            throw new Error("Cannot subtract a WASM histogram to a regular JS histogram");
        }
        if (highestRecordableValue < otherHistogram.maxValue) {
            if (!this.autoResize) {
                throw new Error("The other histogram includes values that do not fit in this histogram's range.");
            }
            this.resize(otherHistogram.maxValue);
        }
        if (this.bucketCount === otherHistogram.bucketCount &&
            this.subBucketCount === otherHistogram.subBucketCount &&
            this.unitMagnitude === otherHistogram.unitMagnitude) {
            // optim
            // Counts arrays are of the same length and meaning, so we can just iterate and add directly:
            let observedOtherTotalCount = 0;
            for (let i = 0; i < otherHistogram.countsArrayLength; i++) {
                const otherCount = otherHistogram.getCountAtIndex(i);
                if (otherCount > 0) {
                    this.addToCountAtIndex(i, -otherCount);
                    observedOtherTotalCount += otherCount;
                }
            }
            this.setTotalCount(this.totalCount - observedOtherTotalCount);
        }
        else {
            for (let i = 0; i < otherHistogram.countsArrayLength; i++) {
                const otherCount = otherHistogram.getCountAtIndex(i);
                if (otherCount > 0) {
                    const otherValue = otherHistogram.valueFromIndex(i);
                    if (this.getCountAtValue(otherValue) < otherCount) {
                        throw new Error("otherHistogram count (" +
                            otherCount +
                            ") at value " +
                            otherValue +
                            " is larger than this one's (" +
                            this.getCountAtValue(otherValue) +
                            ")");
                    }
                    this.recordCountAtValue(-otherCount, otherValue);
                }
            }
        }
        // With subtraction, the max and minNonZero values could have changed:
        if (this.getCountAtValue(this.maxValue) <= 0 ||
            this.getCountAtValue(this.minNonZeroValue) <= 0) {
            this.establishInternalTackingValues();
        }
    }
    establishInternalTackingValues(lengthToCover = this.countsArrayLength) {
        this.maxValue = 0;
        this.minNonZeroValue = Number.MAX_VALUE;
        let maxIndex = -1;
        let minNonZeroIndex = -1;
        let observedTotalCount = 0;
        for (let index = 0; index < lengthToCover; index++) {
            const countAtIndex = this.getCountAtIndex(index);
            if (countAtIndex > 0) {
                observedTotalCount += countAtIndex;
                maxIndex = index;
                if (minNonZeroIndex == -1 && index != 0) {
                    minNonZeroIndex = index;
                }
            }
        }
        if (maxIndex >= 0) {
            this.updatedMaxValue(this.highestEquivalentValue(this.valueFromIndex(maxIndex)));
        }
        if (minNonZeroIndex >= 0) {
            this.updateMinNonZeroValue(this.valueFromIndex(minNonZeroIndex));
        }
        this.setTotalCount(observedTotalCount);
    }
    reset() {
        this.clearCounts();
        this.setTotalCount(0);
        this.startTimeStampMsec = 0;
        this.endTimeStampMsec = 0;
        this.tag = Histogram_1.NO_TAG;
        this.maxValue = 0;
        this.minNonZeroValue = Number.MAX_SAFE_INTEGER;
    }
    destroy() {
        // no op - not needed here
    }
}
exports.JsHistogram = JsHistogram;
exports.default = JsHistogram;
//# sourceMappingURL=JsHistogram.js.map