overtake 1.4.0 → 2.0.1

package/build/reporter.js

@@ -1,36 +1,18 @@
-import { div, max, divs, isqrt } from "./utils.js";
-import { DURATION_SCALE } from "./types.js";
+import { div, max, divs, isqrt } from './utils.js';
+import { DURATION_SCALE } from './types.js';
 const units = [
-    {
-        unit: 'ns',
-        factor: 1
-    },
-    {
-        unit: 'µs',
-        factor: 1e3
-    },
-    {
-        unit: 'ms',
-        factor: 1e6
-    },
-    {
-        unit: 's',
-        factor: 1e9
-    },
-    {
-        unit: 'm',
-        factor: 60 * 1e9
-    },
-    {
-        unit: 'h',
-        factor: 3600 * 1e9
-    }
+    { unit: 'ns', factor: 1 },
+    { unit: 'µs', factor: 1e3 },
+    { unit: 'ms', factor: 1e6 },
+    { unit: 's', factor: 1e9 },
+    { unit: 'm', factor: 60 * 1e9 },
+    { unit: 'h', factor: 3600 * 1e9 },
 ];
 function smartFixed(n) {
     return n.toLocaleString(undefined, {
         minimumFractionDigits: 0,
         maximumFractionDigits: 2,
-        useGrouping: true
+        useGrouping: true,
     });
 }
 export class Report {
@@ -38,7 +20,7 @@ export class Report {
     value;
     uncertainty;
     scale;
-    constructor(type, value, uncertainty = 0, scale = 1n){
+    constructor(type, value, uncertainty = 0, scale = 1n) {
         this.type = type;
         this.value = value;
         this.uncertainty = uncertainty;
@@ -60,20 +42,11 @@ export class Report {
             let display = value;
             let unit = 'ns²';
             const varianceUnits = [
-                {
-                    unit: 'ns²',
-                    factor: 1
-                },
-                {
-                    unit: 'µs²',
-                    factor: 1e6
-                },
-                {
-                    unit: 'ms²',
-                    factor: 1e12
-                }
+                { unit: 'ns²', factor: 1 },
+                { unit: 'µs²', factor: 1e6 },
+                { unit: 'ms²', factor: 1e12 },
             ];
-            for (const { unit: u, factor } of varianceUnits){
+            for (const { unit: u, factor } of varianceUnits) {
                 const candidate = value / factor;
                 if (candidate < 1000) {
                     display = candidate;
@@ -85,7 +58,7 @@ export class Report {
         }
         let display = value;
         let unit = 'ns';
-        for (const { unit: u, factor } of units){
+        for (const { unit: u, factor } of units) {
             const candidate = value / factor;
             if (candidate < 1000) {
                 display = candidate;
@@ -96,198 +69,187 @@ export class Report {
         return `${smartFixed(display)} ${unit}${uncertainty}`;
     }
 }
-const SQRT_SCALE = 1_000_000n;
+const SQRT_SCALE = 1000000n;
 const SQRT_SCALE_SQ = SQRT_SCALE * SQRT_SCALE;
 const Z95_NUM = 196n;
 const Z95_DENOM = 100n;
-const computeStats = (durations)=>{
+export const computeStats = (durations) => {
     let sum = 0n;
-    for (const d of durations)sum += d;
+    for (const d of durations)
+        sum += d;
     const n = BigInt(durations.length);
     const mean = sum / n;
     let ssd = 0n;
-    for (const d of durations){
+    for (const d of durations) {
         const diff = d - mean;
         ssd += diff * diff;
     }
-    return {
-        sum,
-        mean,
-        ssd,
-        n
-    };
+    return { sum, mean, ssd, n };
 };
-export const createReport = (durations, type)=>{
+export const createReport = (durations, type, stats) => {
     const n = durations.length;
     if (n === 0) {
         return new Report(type, 0n);
     }
-    switch(type){
-        case 'min':
-            {
-                return new Report(type, durations[0], 0, DURATION_SCALE);
-            }
-        case 'max':
-            {
-                return new Report(type, durations[n - 1], 0, DURATION_SCALE);
-            }
-        case 'median':
-            {
-                const mid = Math.floor(n / 2);
-                const med = n % 2 === 0 ? (durations[mid - 1] + durations[mid]) / 2n : durations[mid];
-                return new Report(type, med, 0, DURATION_SCALE);
-            }
-        case 'mode':
-            {
-                const freq = new Map();
-                let maxCount = 0n;
-                let modeVal = durations[0];
-                for (const d of durations){
-                    const count = (freq.get(d) || 0n) + 1n;
-                    freq.set(d, count);
-                    if (count > maxCount) {
-                        maxCount = count;
-                        modeVal = d;
-                    }
-                }
-                let lower = modeVal;
-                let upper = modeVal;
-                const firstIdx = durations.indexOf(modeVal);
-                const lastIdx = durations.lastIndexOf(modeVal);
-                if (firstIdx > 0) lower = durations[firstIdx - 1];
-                if (lastIdx < n - 1) upper = durations[lastIdx + 1];
-                const gap = max(modeVal - lower, upper - modeVal);
-                const uncertainty = modeVal > 0 ? Number(gap / 2n * 100n / modeVal) : 0;
-                return new Report(type, modeVal, uncertainty, DURATION_SCALE);
-            }
-        case 'ops':
-            {
-                const { mean: avgScaled, ssd, n: nBig } = computeStats(durations);
-                const nsPerSecScaled = 1_000_000_000n * DURATION_SCALE;
-                const raw = Number(nsPerSecScaled) / Number(avgScaled);
-                const extra = raw < 1 ? Math.ceil(-Math.log10(raw)) : 0;
-                const exp = raw > 100 ? 0 : 2 + extra;
-                const scale = 10n ** BigInt(exp);
-                const value = avgScaled > 0n ? nsPerSecScaled * scale / avgScaled : 0n;
-                let uncertainty = 0;
-                if (n >= 2 && avgScaled > 0n) {
-                    const RME_PRECISION = 1_000_000n;
-                    const semOverMeanSqScaled = ssd * RME_PRECISION * RME_PRECISION / (BigInt(n - 1) * nBig * avgScaled * avgScaled);
-                    const semOverMeanScaled = isqrt(semOverMeanSqScaled);
-                    uncertainty = Number(Z95_NUM * semOverMeanScaled) / Number(RME_PRECISION);
+    const st = stats ?? computeStats(durations);
+    switch (type) {
+        case 'min': {
+            return new Report(type, durations[0], 0, DURATION_SCALE);
+        }
+        case 'max': {
+            return new Report(type, durations[n - 1], 0, DURATION_SCALE);
+        }
+        case 'median': {
+            const mid = Math.floor(n / 2);
+            const med = n % 2 === 0 ? (durations[mid - 1] + durations[mid]) / 2n : durations[mid];
+            return new Report(type, med, 0, DURATION_SCALE);
+        }
+        case 'mode': {
+            const freq = new Map();
+            let maxCount = 0n;
+            let modeVal = durations[0];
+            for (const d of durations) {
+                const count = (freq.get(d) || 0n) + 1n;
+                freq.set(d, count);
+                if (count > maxCount) {
+                    maxCount = count;
+                    modeVal = d;
                 }
-                return new Report(type, value, uncertainty, scale);
-            }
-        case 'mean':
-            {
-                const { sum } = computeStats(durations);
-                const value = divs(sum, BigInt(n), 1n);
-                return new Report(type, value, 0, DURATION_SCALE);
-            }
-        case 'variance':
-            {
-                if (n < 2) return new Report(type, 0n, 0, DURATION_SCALE * DURATION_SCALE);
-                const { ssd } = computeStats(durations);
-                const variance = ssd / BigInt(n - 1);
-                return new Report(type, variance, 0, DURATION_SCALE * DURATION_SCALE);
-            }
-        case 'sd':
-            {
-                if (n < 2) return new Report(type, 0n, 0, DURATION_SCALE);
-                const { ssd } = computeStats(durations);
-                const scaledVariance = ssd * SQRT_SCALE_SQ / BigInt(n - 1);
-                const sdScaled = isqrt(scaledVariance);
-                return new Report(type, sdScaled, 0, DURATION_SCALE * SQRT_SCALE);
             }
-        case 'sem':
-            {
-                if (n < 2) return new Report(type, 0n, 0, DURATION_SCALE);
-                const { ssd, n: nBig } = computeStats(durations);
-                const semSqScaled = ssd * SQRT_SCALE_SQ / (BigInt(n - 1) * nBig);
-                const semScaled = isqrt(semSqScaled);
-                return new Report(type, semScaled, 0, DURATION_SCALE * SQRT_SCALE);
-            }
-        case 'moe':
-            {
-                if (n < 2) return new Report(type, 0n, 0, DURATION_SCALE);
-                const { ssd, n: nBig } = computeStats(durations);
-                const semSqScaled = ssd * SQRT_SCALE_SQ / (BigInt(n - 1) * nBig);
-                const semScaled = isqrt(semSqScaled);
-                const moeScaled = Z95_NUM * semScaled / Z95_DENOM;
-                return new Report(type, moeScaled, 0, DURATION_SCALE * SQRT_SCALE);
-            }
-        case 'rme':
-            {
-                if (n < 2) return new Report(type, 0n);
-                const { mean, ssd, n: nBig } = computeStats(durations);
-                if (mean === 0n) return new Report(type, 0n);
-                const RME_PRECISION = 1_000_000n;
-                const semOverMeanSqScaled = ssd * RME_PRECISION * RME_PRECISION / (BigInt(n - 1) * nBig * mean * mean);
+            let lower = modeVal;
+            let upper = modeVal;
+            const firstIdx = durations.indexOf(modeVal);
+            const lastIdx = durations.lastIndexOf(modeVal);
+            if (firstIdx > 0)
+                lower = durations[firstIdx - 1];
+            if (lastIdx < n - 1)
+                upper = durations[lastIdx + 1];
+            const gap = max(modeVal - lower, upper - modeVal);
+            const uncertainty = modeVal > 0 ? Number(((gap / 2n) * 100n) / modeVal) : 0;
+            return new Report(type, modeVal, uncertainty, DURATION_SCALE);
+        }
+        case 'ops': {
+            const { mean: avgScaled, ssd, n: nBig } = st;
+            const nsPerSecScaled = 1000000000n * DURATION_SCALE;
+            const raw = Number(nsPerSecScaled) / Number(avgScaled);
+            const extra = raw < 1 ? Math.ceil(-Math.log10(raw)) : 0;
+            const exp = raw > 100 ? 0 : 2 + extra;
+            const scale = 10n ** BigInt(exp);
+            const value = avgScaled > 0n ? (nsPerSecScaled * scale) / avgScaled : 0n;
+            let uncertainty = 0;
+            if (n >= 2 && avgScaled > 0n) {
+                const RME_PRECISION = 1000000n;
+                const semOverMeanSqScaled = (ssd * RME_PRECISION * RME_PRECISION) / (BigInt(n - 1) * nBig * avgScaled * avgScaled);
                 const semOverMeanScaled = isqrt(semOverMeanSqScaled);
-                const rmeScaled = Z95_NUM * semOverMeanScaled * 100n / RME_PRECISION;
-                return new Report(type, rmeScaled, 0, 100n);
-            }
-        case 'mad':
-            {
-                const medianIdx = Math.floor(n / 2);
-                const median = n % 2 === 1 ? durations[medianIdx] : (durations[medianIdx - 1] + durations[medianIdx]) / 2n;
-                const deviations = new BigUint64Array(n);
-                for(let i = 0; i < n; i++){
-                    const diff = durations[i] > median ? durations[i] - median : median - durations[i];
-                    deviations[i] = diff;
-                }
-                deviations.sort();
-                const madIdx = Math.floor(n / 2);
-                const mad = n % 2 === 1 ? deviations[madIdx] : (deviations[madIdx - 1] + deviations[madIdx]) / 2n;
-                return new Report(type, mad, 0, DURATION_SCALE);
-            }
-        case 'iqr':
-            {
-                const q1Idx = Math.floor(n * 0.25);
-                const q3Idx = Math.floor(n * 0.75);
-                const q1 = durations[q1Idx];
-                const q3 = durations[q3Idx];
-                const iqr = q3 - q1;
-                return new Report(type, iqr, 0, DURATION_SCALE);
-            }
-        case 'ci_lower':
-            {
-                if (n < 2) return new Report(type, 0n, 0, DURATION_SCALE);
-                const { mean, ssd, n: nBig } = computeStats(durations);
-                const semSqScaled = ssd * SQRT_SCALE_SQ / (BigInt(n - 1) * nBig);
-                const semScaled = isqrt(semSqScaled);
-                const moeScaled = Z95_NUM * semScaled / Z95_DENOM;
-                const ciLowerScaled = mean * SQRT_SCALE - moeScaled;
-                return new Report(type, ciLowerScaled > 0n ? ciLowerScaled : 0n, 0, DURATION_SCALE * SQRT_SCALE);
+                uncertainty = Number(Z95_NUM * semOverMeanScaled) / Number(RME_PRECISION);
             }
-        case 'ci_upper':
-            {
-                if (n < 2) return new Report(type, 0n, 0, DURATION_SCALE);
-                const { mean, ssd, n: nBig } = computeStats(durations);
-                const semSqScaled = ssd * SQRT_SCALE_SQ / (BigInt(n - 1) * nBig);
-                const semScaled = isqrt(semSqScaled);
-                const moeScaled = Z95_NUM * semScaled / Z95_DENOM;
-                const ciUpperScaled = mean * SQRT_SCALE + moeScaled;
-                return new Report(type, ciUpperScaled, 0, DURATION_SCALE * SQRT_SCALE);
+            return new Report(type, value, uncertainty, scale);
+        }
+        case 'mean': {
+            const { sum } = st;
+            const value = divs(sum, BigInt(n), 1n);
+            return new Report(type, value, 0, DURATION_SCALE);
+        }
+        case 'variance': {
+            if (n < 2)
+                return new Report(type, 0n, 0, DURATION_SCALE * DURATION_SCALE);
+            const { ssd } = st;
+            const variance = ssd / BigInt(n - 1);
+            return new Report(type, variance, 0, DURATION_SCALE * DURATION_SCALE);
+        }
+        case 'sd': {
+            if (n < 2)
+                return new Report(type, 0n, 0, DURATION_SCALE);
+            const { ssd } = st;
+            const scaledVariance = (ssd * SQRT_SCALE_SQ) / BigInt(n - 1);
+            const sdScaled = isqrt(scaledVariance);
+            return new Report(type, sdScaled, 0, DURATION_SCALE * SQRT_SCALE);
+        }
+        case 'sem': {
+            if (n < 2)
+                return new Report(type, 0n, 0, DURATION_SCALE);
+            const { ssd, n: nBig } = st;
+            const semSqScaled = (ssd * SQRT_SCALE_SQ) / (BigInt(n - 1) * nBig);
+            const semScaled = isqrt(semSqScaled);
+            return new Report(type, semScaled, 0, DURATION_SCALE * SQRT_SCALE);
+        }
+        case 'moe': {
+            if (n < 2)
+                return new Report(type, 0n, 0, DURATION_SCALE);
+            const { ssd, n: nBig } = st;
+            const semSqScaled = (ssd * SQRT_SCALE_SQ) / (BigInt(n - 1) * nBig);
+            const semScaled = isqrt(semSqScaled);
+            const moeScaled = (Z95_NUM * semScaled) / Z95_DENOM;
+            return new Report(type, moeScaled, 0, DURATION_SCALE * SQRT_SCALE);
+        }
+        case 'rme': {
+            if (n < 2)
+                return new Report(type, 0n);
+            const { mean, ssd, n: nBig } = st;
+            if (mean === 0n)
+                return new Report(type, 0n);
+            const RME_PRECISION = 1000000n;
+            const semOverMeanSqScaled = (ssd * RME_PRECISION * RME_PRECISION) / (BigInt(n - 1) * nBig * mean * mean);
+            const semOverMeanScaled = isqrt(semOverMeanSqScaled);
+            const rmeScaled = (Z95_NUM * semOverMeanScaled * 100n) / RME_PRECISION;
+            return new Report(type, rmeScaled, 0, 100n);
+        }
+        case 'mad': {
+            const medianIdx = Math.floor(n / 2);
+            const median = n % 2 === 1 ? durations[medianIdx] : (durations[medianIdx - 1] + durations[medianIdx]) / 2n;
+            const deviations = new BigUint64Array(n);
+            for (let i = 0; i < n; i++) {
+                const diff = durations[i] > median ? durations[i] - median : median - durations[i];
+                deviations[i] = diff;
+            }
+            deviations.sort();
+            const madIdx = Math.floor(n / 2);
+            const mad = n % 2 === 1 ? deviations[madIdx] : (deviations[madIdx - 1] + deviations[madIdx]) / 2n;
+            return new Report(type, mad, 0, DURATION_SCALE);
+        }
+        case 'iqr': {
+            const q1Idx = Math.floor(n * 0.25);
+            const q3Idx = Math.floor(n * 0.75);
+            const q1 = durations[q1Idx];
+            const q3 = durations[q3Idx];
+            const iqr = q3 - q1;
+            return new Report(type, iqr, 0, DURATION_SCALE);
+        }
+        case 'ci_lower': {
+            if (n < 2)
+                return new Report(type, 0n, 0, DURATION_SCALE);
+            const { mean, ssd, n: nBig } = st;
+            const semSqScaled = (ssd * SQRT_SCALE_SQ) / (BigInt(n - 1) * nBig);
+            const semScaled = isqrt(semSqScaled);
+            const moeScaled = (Z95_NUM * semScaled) / Z95_DENOM;
+            const ciLowerScaled = mean * SQRT_SCALE - moeScaled;
+            return new Report(type, ciLowerScaled > 0n ? ciLowerScaled : 0n, 0, DURATION_SCALE * SQRT_SCALE);
+        }
+        case 'ci_upper': {
+            if (n < 2)
+                return new Report(type, 0n, 0, DURATION_SCALE);
+            const { mean, ssd, n: nBig } = st;
+            const semSqScaled = (ssd * SQRT_SCALE_SQ) / (BigInt(n - 1) * nBig);
+            const semScaled = isqrt(semSqScaled);
+            const moeScaled = (Z95_NUM * semScaled) / Z95_DENOM;
+            const ciUpperScaled = mean * SQRT_SCALE + moeScaled;
+            return new Report(type, ciUpperScaled, 0, DURATION_SCALE * SQRT_SCALE);
+        }
+        default: {
+            const p = Number(type.slice(1));
+            if (p === 0) {
+                return new Report(type, durations[0], 0, DURATION_SCALE);
             }
-        default:
-            {
-                const p = Number(type.slice(1));
-                if (p === 0) {
-                    return new Report(type, durations[0], 0, DURATION_SCALE);
-                }
-                if (p === 100) {
-                    return new Report(type, durations[n - 1], 0, DURATION_SCALE);
-                }
-                const idx = Math.ceil(p / 100 * n) - 1;
-                const value = durations[Math.min(Math.max(idx, 0), n - 1)];
-                const prev = idx > 0 ? durations[idx - 1] : value;
-                const next = idx < n - 1 ? durations[idx + 1] : value;
-                const gap = max(value - prev, next - value);
-                const uncertainty = value > 0 ? Number(div(divs(gap, 2n, 100_00n), value)) / 100 : 0;
-                return new Report(type, value, uncertainty, DURATION_SCALE);
+            if (p === 100) {
+                return new Report(type, durations[n - 1], 0, DURATION_SCALE);
             }
+            const idx = Math.ceil((p / 100) * n) - 1;
+            const value = durations[Math.min(Math.max(idx, 0), n - 1)];
+            const prev = idx > 0 ? durations[idx - 1] : value;
+            const next = idx < n - 1 ? durations[idx + 1] : value;
+            const gap = max(value - prev, next - value);
+            const uncertainty = value > 0 ? Number(div(divs(gap, 2n, 10000n), value)) / 100 : 0;
+            return new Report(type, value, uncertainty, DURATION_SCALE);
+        }
     }
 };
-
-//# sourceMappingURL=reporter.js.map

package/build/runner.d.ts

@@ -1,2 +1,2 @@
-import { Options } from './types.js';
+import { type Options } from './types.js';
 export declare const benchmark: <TContext, TInput>({ setup, teardown, pre, run: runRaw, post, data, warmupCycles, minCycles, absThreshold, relThreshold, gcObserver, durationsSAB, controlSAB, }: Required<Options<TContext, TInput>>) => Promise<number>;