- -
+ NS
- -
+ NS
- -
+ NS
- -
+ NS
- -
+ NS
- -
+ NS
|
: We are 95% confident the median difference is between
- +3.27
+ +3.57
and
@@ -1979,7 +1953,7 @@ exports[`Results View The table should match snapshot and other elements should
class="significance cell"
role="cell"
>
- -
+ NS
- -
+ NS
- -
+ NS
- -
+ NS
- -
+ NS
- -
+ NS
- -
+ NS
- -
+ NS
- -
+ NS
- -
+ NS
- -
+ NS
- -
+ NS
- -
+ NS
- -
+ NS
- -
+ NS
- -
+ NS
- -
+ NS
- -
+ NS
- -
+ NS
- -
+ NS
(BOOTSTRAP_SAMPLE_CAP);
+ const stride = values.length / BOOTSTRAP_SAMPLE_CAP;
+ for (let i = 0; i < BOOTSTRAP_SAMPLE_CAP; i++) {
+ out[i] = values[Math.floor(i * stride)];
+ }
+ return out;
+}
+
+// Resolve a row's KDE/BCa input sample set: prefer replicates over the
+// aggregated runs. Mirrors RevisionRowExpandable's selection for the chart
+// and KdeModesPanel so every view of the row uses the same underlying data.
+// Returned arrays are NOT downsampled — callers feeding BCa should pass
+// them through `downsampleForBootstrap` first.
+function runsFor(result: MannWhitneyResultsItem): {
+ baseRuns: number[];
+ newRuns: number[];
+} {
+ const baseRuns =
+ result.base_runs_replicates && result.base_runs_replicates.length
+ ? result.base_runs_replicates
+ : (result.base_runs ?? []);
+ const newRuns =
+ result.new_runs_replicates && result.new_runs_replicates.length
+ ? result.new_runs_replicates
+ : (result.new_runs ?? []);
+ return { baseRuns, newRuns };
+}
+
+/**
+ * Lazily compute (and cache) the bootstrap (BCa) [see
+ * src/utils/bootstrap-ci.ts#L163-L203] CI for the difference of medians
+ * on a single row.
+ *
+ * The lazy strategy: at load time we do NO BCa work (matches production
+ * speed). The Sig column's `matchesFunction`/`sortFunction`/cell-render
+ * call this helper as needed. Result is cached on `result.bootstrapCi`
+ * so the second click on the column is free.
+ *
+ * `undefined` vs `null`:
+ * - `undefined` ⇒ never computed
+ * - `null` ⇒ computed but couldn't produce a CI (< 2 samples)
+ * We check `=== undefined` instead of `?? null` to keep that distinction.
+ *
+ * Uses the replicates-preferred sample selection (via `runsFor`) and the
+ * downsampled-for-BCa cap so per-row cost stays bounded regardless of how
+ * many replicates the backend ships. See `BOOTSTRAP_SAMPLE_CAP` and
+ * `BOOTSTRAP_ITERATIONS` above.
+ */
+export function getBootstrapCi(
+ result: MannWhitneyResultsItem,
+): BootstrapCI | null {
+ if (result.bootstrapCi !== undefined) return result.bootstrapCi;
+ const { baseRuns, newRuns } = runsFor(result);
+ const baseSamples = downsampleForBootstrap(baseRuns);
+ const newSamples = downsampleForBootstrap(newRuns);
+ const ci =
+ baseSamples.length >= 2 && newSamples.length >= 2
+ ? bootstrapMedianDiffCI(baseSamples, newSamples, BOOTSTRAP_ITERATIONS)
+ : null;
+ result.bootstrapCi = ci;
+ return ci;
+}
+
+// Decide whether the Sig cell should render "S" or "NS".
+//
+// Cell renders run for EVERY row on every render — we can't afford to
+// compute BCa here at load time. So the cell uses whichever signal is
+// available without forcing compute:
+// - If the CI has been cached (filter/sort has been used, or the
+// expanded-row alert ran), use it — keeps the column consistent with
+// the rest of the UI on rows the user has engaged with.
+// - Otherwise fall back to the backend's `mann_whitney_test.interpretation`
+// — close to production's pre-branch behavior and free to read.
+//
+// First filter/sort click populates `bootstrapCi` for all rows; from then
+// on the column reads the CI-based verdict everywhere. So you only see the
+// fallback on first render before any Sig interaction.
+function isSignificantForDisplay(result: MannWhitneyResultsItem): boolean {
+ if (result.bootstrapCi !== undefined) {
+ return result.bootstrapCi?.significant ?? false;
+ }
+ return result.mann_whitney_test?.interpretation === 'significant';
+}
+
export const mannWhitneyStrategy = {
getColumns(isSubtestTable: boolean): TableConfig {
const platformConfig = isSubtestTable
@@ -222,25 +323,43 @@ export const mannWhitneyStrategy = {
{
label: 'Significant',
key: 'significant',
- icon: ,
+ icon: S ,
},
{
label: 'Not Significant',
key: 'not significant',
- icon: - ,
+ icon: NS ,
},
],
matchesFunction(result: MannWhitneyResultsItem, valueKey: string) {
- return result.mann_whitney_test?.interpretation === valueKey;
+ // Lazily compute and cache the CI on first filter-click. After
+ // that, the CI is read straight from `result.bootstrapCi` on
+ // every subsequent comparison/render (see getBootstrapCi above).
+ const ci = getBootstrapCi(result);
+ const isSig = ci?.significant ?? false;
+ return (isSig ? 'significant' : 'not significant') === valueKey;
},
sortFunction(
resultA: MannWhitneyResultsItem,
resultB: MannWhitneyResultsItem,
) {
- return (
- Math.abs(resultA.mann_whitney_test?.pvalue ?? 0) -
- Math.abs(resultB.mann_whitney_test?.pvalue ?? 0)
- );
+ // ASC semantics — useTableSort swaps args for DESC. So in DESC mode
+ // this produces "significant first, then |medianDiff| desc"; in ASC
+ // mode the inverse. Significance is the primary key, magnitude the
+ // tie-breaker so the biggest changes float to the top of each group.
+ //
+ // First sort-click pays the BCa cost across all rows (the
+ // comparator is invoked O(n log n) times but each row is computed
+ // only once and cached via getBootstrapCi). Subsequent sorts are
+ // free.
+ const ciA = getBootstrapCi(resultA);
+ const ciB = getBootstrapCi(resultB);
+ const sigA = ciA?.significant ?? false;
+ const sigB = ciB?.significant ?? false;
+ if (sigA !== sigB) return sigA ? 1 : -1;
+ const magA = Math.abs(ciA?.medianDiff ?? 0);
+ const magB = Math.abs(ciB?.medianDiff ?? 0);
+ return magA - magB;
},
},
@@ -264,17 +383,22 @@ export const mannWhitneyStrategy = {
},
renderSubtestColumns(result: CombinedResultsItemType, expanded: boolean) {
+ const mwResult = result as MannWhitneyResultsItem;
const {
test,
cliffs_delta,
- mann_whitney_test,
cles,
direction_of_change,
base_measurement_unit: baseUnit,
new_measurement_unit: newUnit,
base_app: baseApp,
new_app: newApp,
- } = result as MannWhitneyResultsItem;
+ } = mwResult;
+ // See `isSignificantForDisplay` above — uses the cached CI when one
+ // exists and falls back to the backend interpretation otherwise.
+ // Computing BCa here on every cell render would re-introduce the
+ // per-row load cost we just removed.
+ const sigDisplay = isSignificantForDisplay(mwResult) ? 'S' : 'NS';
const clesVal = ((cles?.cles ?? 0) * 100).toFixed(2);
const baseAvgValue =
(result as MannWhitneyResultsItem).base_standard_stats?.mean ?? 0;
@@ -363,11 +487,7 @@ export const mannWhitneyStrategy = {
{clesVal ? `${clesVal}% ` : '-'}
- {mann_whitney_test?.interpretation === 'significant' ? (
-
- ) : (
- '-'
- )}
+ {sigDisplay}
);
@@ -403,17 +523,22 @@ export const mannWhitneyStrategy = {
mann_whitney_u_cles: '',
};
const { cliffs_delta, cliffs_interpretation } = mwResult;
- const pValue = mwResult.mann_whitney_test?.pvalue;
- const p_value_cles = mwResult.mann_whitney_test?.interpretation
- ? capitalize(mwResult.mann_whitney_test.interpretation)
- : '';
- const baseRuns = mwResult.base_runs ?? [];
- const newRuns = mwResult.new_runs ?? [];
- const ci =
- baseRuns.length > 0 && newRuns.length > 0
- ? bootstrapMedianDiffCI(baseRuns, newRuns)
+ // Prefer the precomputed CI populated by the loader. Fall back to an
+ // inline compute for backwards compatibility (e.g. tests that mount the
+ // strategy without going through a loader, or stale results without the
+ // field). `baseRuns`/`newRuns` is the full replicates-preferred set
+ // (used for the median below); the BCa fallback runs on the capped
+ // downsample so it can't hang on rich-replicates rows.
+ const { baseRuns, newRuns } = runsFor(mwResult);
+ const ci = (() => {
+ if (mwResult.bootstrapCi !== undefined) return mwResult.bootstrapCi;
+ const baseSamples = downsampleForBootstrap(baseRuns);
+ const newSamples = downsampleForBootstrap(newRuns);
+ return baseSamples.length >= 2 && newSamples.length >= 2
+ ? bootstrapMedianDiffCI(baseSamples, newSamples, BOOTSTRAP_ITERATIONS)
: null;
+ })();
const rawUnit =
mwResult.base_measurement_unit ?? mwResult.new_measurement_unit ?? 'ms';
const { fmt, displayUnit } = ci
@@ -453,8 +578,6 @@ export const mannWhitneyStrategy = {
@@ -480,14 +603,18 @@ export const mannWhitneyStrategy = {
},
renderColumns(result: CombinedResultsItemType) {
+ const mwResult = result as MannWhitneyResultsItem;
const {
cliffs_delta,
direction_of_change,
- mann_whitney_test,
cles,
base_standard_stats,
new_standard_stats,
- } = result as MannWhitneyResultsItem;
+ } = mwResult;
+ // See `isSignificantForDisplay` — uses the cached CI if a filter/sort
+ // populated it, otherwise the backend's interpretation. Cell renders
+ // can't afford to trigger BCa on every row at load time.
+ const sigDisplay = isSignificantForDisplay(mwResult) ? 'S' : 'NS';
const clesValue = cles?.cles ? `${(cles.cles * 100).toFixed(2)} %` : '-';
const baseMedian = base_standard_stats?.median ?? 0;
const newMedian = new_standard_stats?.median ?? 0;
@@ -551,11 +678,7 @@ export const mannWhitneyStrategy = {
{clesValue}
- {mann_whitney_test?.interpretation === 'significant' ? (
-
- ) : (
- '-'
- )}
+ {sigDisplay}
);
diff --git a/src/components/CompareResults/PValCliffsDeltaComp.tsx b/src/components/CompareResults/PValCliffsDeltaComp.tsx
index a430b63ac..9465d825f 100644
--- a/src/components/CompareResults/PValCliffsDeltaComp.tsx
+++ b/src/components/CompareResults/PValCliffsDeltaComp.tsx
@@ -5,21 +5,12 @@ import { capitalize } from '../../utils/helpers';
interface PValCliffsDeltaCompProps {
cliffs_delta: number;
cliffs_interpretation: string;
- pValue: number | undefined | null;
- p_value_cles: string;
cles: number | string;
cles_direction: string;
}
function PValCliffsDeltaComp(props: PValCliffsDeltaCompProps) {
- const {
- cliffs_delta,
- cliffs_interpretation,
- pValue,
- p_value_cles,
- cles,
- cles_direction,
- } = props;
+ const { cliffs_delta, cliffs_interpretation, cles, cles_direction } = props;
return (
|
-