@mark1russell7/rigor-bench 0.2.14 → 0.2.15

package/build/index.js

@@ -1,5 +1,5 @@
 import { n as checkPairedTime, r as firstArm, t as caseRatios } from "./paired.js";
-import { bootstrapMedian, bootstrapTwo, compareRatios, holm, median, medianInterval, quantile, quantileInterval, quantileSamples, signTest, signTestPower, wilson } from "@mark1russell7/rigor-statistics";
+import { bootstrapMedian, bootstrapTwo, compareRatios, holm, median, medianInterval, partialConjunction, quantile, quantileInterval, quantileSamples, signTest, signTestPower, wilson } from "@mark1russell7/rigor-statistics";
 import { random } from "@mark1russell7/rigor-generators";
 // src/budget.ts
 /**
@@ -212,6 +212,216 @@ function budgetLooksVerdict(rounds, aa, options) {
 function round$2(x) {
 	return Math.round(x * 1e4) / 1e4;
 }
+// src/gate.ts
+/**
+* The gate of a bench: the result that a check of a merge reads. A verdict gives one of the words of `LimitOutcome` for each
+* case, and the gate gives "pass", "block" or "no read". A case with no outcome does not pass.
+*/
+/**
+* This function gives the gate of a list of case outcomes.
+* - The result is "block" when a case is `beyond`.
+* - The result is "pass" when each case is `within`.
+* - Each other result is "no read", and so is a list with no cases. A caller does not count "no read" as a pass.
+*/
+function gateOf(cases) {
+	const names = (outcome) => cases.filter((c) => c.outcome === outcome).map((c) => c.case);
+	const blocks = names("beyond");
+	const noRead = names("cannot decide");
+	if (cases.length === 0) return {
+		outcome: "no read",
+		reason: "The gate has no cases.",
+		blocks,
+		noRead
+	};
+	if (blocks.length > 0) return {
+		outcome: "block",
+		reason: `${blocks.length} of ${cases.length} cases are beyond the claim. The first is ${JSON.stringify(blocks[0])}.`,
+		blocks,
+		noRead
+	};
+	if (noRead.length > 0) return {
+		outcome: "no read",
+		reason: `${noRead.length} of ${cases.length} cases have no outcome. The first is ${JSON.stringify(noRead[0])}.`,
+		blocks,
+		noRead
+	};
+	return {
+		outcome: "pass",
+		reason: `Each of the ${cases.length} cases is within the claim.`,
+		blocks,
+		noRead
+	};
+}
+const READ_OF = {
+	within: "not slower",
+	beyond: "slower",
+	"cannot decide": "no read"
+};
+/** The looks of `notSlowerVerdict`: the rounds in each job. The level of the family has an equal share at each look. */
+const GATE_LOOKS = [
+	12,
+	24,
+	48
+];
+/** This function examines the options. */
+function checkOptions(level, looks, need) {
+	if (!(level > 0 && level < 1)) throw new RangeError(`notSlowerVerdict: the level is above 0 and below 1, not ${level}.`);
+	if (looks.length === 0) throw new RangeError("notSlowerVerdict: the list of looks is empty.");
+	let last = 0;
+	for (const rounds of looks) {
+		if (!(Number.isInteger(rounds) && rounds > last && rounds % 2 === 0)) throw new RangeError(`notSlowerVerdict: the looks are even whole numbers in rising order, not ${rounds} after ${last}.`);
+		last = rounds;
+	}
+	if (!(Number.isInteger(need) && need >= 1)) throw new RangeError(`notSlowerVerdict: the count of jobs is a whole number of 1 or more, not ${need}.`);
+}
+/** This function gives the records of one case of one job in the order of the rounds. It refuses a round that comes twice. */
+function casesOf(records) {
+	const out = /* @__PURE__ */ new Map();
+	for (const record of records) {
+		checkPairedTime(record);
+		const list = out.get(record.case) ?? [];
+		if (list.some((r) => r.round === record.round)) throw new RangeError(`notSlowerVerdict: the round ${record.round} of ${JSON.stringify(record.case)} comes twice.`);
+		list.push(record);
+		out.set(record.case, list);
+	}
+	for (const list of out.values()) list.sort((a, b) => a.round - b.round);
+	return out;
+}
+/**
+* This function gives the differences of the first `rounds` rounds: log(b / a) of the candidate minus log(b / a) of the A/A arm.
+* A pair has two records with the same first arm, because a difference of two orders holds the effect of the order.
+*/
+function differences(candidate, aa, rounds) {
+	const out = [];
+	const ofOrder = (list, first) => list.slice(0, rounds).filter((r) => r.first === first);
+	for (const first of ["a", "b"]) {
+		const left = ofOrder(candidate, first);
+		const right = ofOrder(aa, first);
+		for (let i = 0; i < Math.min(left.length, right.length); i++) {
+			const c = left[i];
+			const a = right[i];
+			out.push(Math.log(c.b / c.a) - Math.log(a.b / a.a));
+		}
+	}
+	return out;
+}
+/** This function gives the read of one job. A job that has not reached the look gives a p of 1 in both directions. */
+function jobRead(job, diffs, margin, rounds) {
+	if (diffs.length < rounds) return {
+		job,
+		rounds: diffs.length,
+		below: 0,
+		above: 0,
+		notSlower: 1,
+		slower: 1,
+		centre: void 0
+	};
+	const below = diffs.filter((d) => d < margin).length;
+	const above = diffs.filter((d) => d > margin).length;
+	return {
+		job,
+		rounds: diffs.length,
+		below,
+		above,
+		notSlower: signTest(below, diffs.length - below),
+		slower: signTest(above, diffs.length - above),
+		centre: median(diffs)
+	};
+}
+/** This function gives the words of the facts of one job, for a reason. */
+function jobFacts(read) {
+	if (read.centre === void 0) return `job ${read.job} has ${read.rounds} pairs`;
+	return `job ${read.job} has ${read.below} of ${read.rounds} pairs below the margin, centre ${Math.round(read.centre * 1e5) / 1e3} %`;
+}
+/**
+* This function gives the gate of the claim "the candidate is not slower than the A/A arm by more than the margin" for each
+* case. A one-sided bound answers the claim. Thus a case with its whole interval under the margin reads "not slower", also
+* when its interval holds 1.
+*
+* - In each job, the sign test compares the median of the differences with the margin. It uses no random numbers.
+* - A case reads in `jobs` jobs or more: `partialConjunction` joins the p of each job, with no condition on how they depend.
+* - The level is for the family. Each look has `level / looks` of it, and `holm` corrects each look over all cases.
+* - The first look with an outcome decides a case. Later rounds do not change it. Each look uses the first rounds of a job.
+* - The result is "block" when a case reads "slower", and "pass" when each case reads "not slower".
+* - Each other result is "no read". The field `more` gives the next look of each case. After the last look, the caller adds jobs.
+*
+* The level needs independent rounds. Rounds with a shared cause, for example a slow computer for one job, do not have it.
+* A job that a caller adds after the last look is one more look, and the level does not count it.
+*/
+function notSlowerVerdict(jobs, options) {
+	const level = options.level ?? .05;
+	const looks = options.looks ?? GATE_LOOKS;
+	const need = options.jobs ?? 2;
+	checkOptions(level, looks, need);
+	const marginOf = (name) => {
+		const margin = typeof options.margin === "number" ? options.margin : options.margin(name);
+		if (!(margin >= 0 && Number.isFinite(margin))) throw new RangeError(`notSlowerVerdict: the margin of ${JSON.stringify(name)} is finite and 0 or more, not ${margin}.`);
+		return margin;
+	};
+	const records = jobs.map((job) => ({
+		job: job.job,
+		candidate: casesOf(job.candidate),
+		aa: casesOf(job.aa)
+	}));
+	const names = [...new Set(records.flatMap((job) => [...job.candidate.keys()]))].sort();
+	const margins = names.map(marginOf);
+	const decided = /* @__PURE__ */ new Map();
+	const reached = /* @__PURE__ */ new Map();
+	const each = level / looks.length;
+	for (const rounds of looks) {
+		const reads = names.map((name, i) => records.map((job) => jobRead(job.job, differences(job.candidate.get(name) ?? [], job.aa.get(name) ?? [], rounds), margins[i], rounds)));
+		const joined = (pick) => reads.map((list) => list.length < need ? 1 : partialConjunction(list.map(pick), need));
+		const within = holm(joined((read) => read.notSlower), each);
+		const beyond = holm(joined((read) => read.slower), each);
+		names.forEach((name, i) => {
+			const list = reads[i];
+			if (!reached.has(name) || list.some((read) => read.rounds >= rounds)) reached.set(name, list);
+			if (decided.has(name)) return;
+			if (within[i]?.reject === true) decided.set(name, {
+				outcome: "within",
+				look: rounds,
+				reads: list
+			});
+			else if (beyond[i]?.reject === true) decided.set(name, {
+				outcome: "beyond",
+				look: rounds,
+				reads: list
+			});
+		});
+	}
+	const cases = names.map((name, i) => {
+		const decision = decided.get(name);
+		const outcome = decision?.outcome ?? "cannot decide";
+		const reads = decision?.reads ?? reached.get(name) ?? [];
+		const facts = reads.map(jobFacts).join(", ");
+		const where = decision === void 0 ? `no look of ${looks.join(", ")} rounds decides it` : `the look of ${decision.look} rounds decides it`;
+		return {
+			case: name,
+			outcome,
+			read: READ_OF[outcome],
+			margin: margins[i],
+			look: decision?.look,
+			jobs: reads,
+			reason: `The case ${JSON.stringify(name)} reads "${READ_OF[outcome]}": ${where} (${facts}).`
+		};
+	});
+	const more = cases.flatMap((c) => {
+		if (c.outcome !== "cannot decide") return [];
+		const next = looks.find((rounds) => records.some((job) => differences(job.candidate.get(c.case) ?? [], job.aa.get(c.case) ?? [], rounds).length < rounds));
+		return next === void 0 ? [] : [{
+			case: c.case,
+			rounds: next
+		}];
+	});
+	return {
+		...gateOf(cases),
+		level,
+		looks,
+		need,
+		cases,
+		more
+	};
+}
 // src/control.ts
 /**
 * The load factor of a run, read from a control. Runs on shared machines differ by load. A change does not touch a control.
@@ -1660,6 +1870,6 @@ function timeRounds(arms, options) {
 		sink
 	};
 }
-export { BUDGET_LOOKS, LADDER_FORMAT, aaBand, aaSpread, armVerdicts, balanceOrders, budgetLookSpend, budgetLooksVerdict, budgetVerdict, caseIntervals, caseRatios, checkLadder, checkMeasures, checkPairedTime, controlFactor, firstArm, ladderVerdict, limitVerdict, poolRecords, pooledBand, pooledLimitVerdict, pooledVerdict, rungVerdict, timeRounds, timeVerdict, verdictMargin, verdictPower, winClaim };
+export { BUDGET_LOOKS, GATE_LOOKS, LADDER_FORMAT, aaBand, aaSpread, armVerdicts, balanceOrders, budgetLookSpend, budgetLooksVerdict, budgetVerdict, caseIntervals, caseRatios, checkLadder, checkMeasures, checkPairedTime, controlFactor, firstArm, gateOf, ladderVerdict, limitVerdict, notSlowerVerdict, poolRecords, pooledBand, pooledLimitVerdict, pooledVerdict, rungVerdict, timeRounds, timeVerdict, verdictMargin, verdictPower, winClaim };
 
 //# sourceMappingURL=index.js.map