@mark1russell7/layout-contract 0.2.4 → 0.2.6

package/README.md

@@ -16,6 +16,10 @@ The package has no runtime dependencies.
 | The measures | `MeasureSpec`, `Direction`, `JointMeasureId`, `JOINT_MEASURES`, `JOINT_MOVED_MIN`, `Verdict`, `compareMeasure`, `minEffectOf` |
 | The edges step | `edgeStep`, `EdgeShape`, `EdgeStepParams`, `EDGE_DENSITY`, `EDGE_STEP_VERSION` |
 | The random numbers | `mulberry32`, `fnv1a32`, `stepRandom`, `randomInt` |
+| The hashes | `sha256Hex`, `canonicalJson`, `documentHash`, `outputHash`, `HashOptions` |
+| The promotion guards | `outputGroups`, `OutputGroup`, `exercised`, `ExerciseEvidence` |
+| The portfolio | `portfolio`, `Portfolio`, `PortfolioKey`, `PortfolioLevel`, `PortfolioOptions`, `PortfolioPick`, `PortfolioTrace`, `Member`, `MemberTrace`, `MemberStatus`, `pickMoves` |
+| The pick rule | `selectBest`, `SelectCandidate`, `SelectLevel`, `Selection`, `PickSpec` |
 | The turn | `turnBox`, `turnPort`, `turnMargin`, `turnRegion`, `turnSide`, `turnPoint` |
 | The tolerances | `EPS`, `RECORD_EPS`, `Tolerance`, `DEFAULT_TOLERANCE` |
 | The hard rules | `countOverlaps`, `countObstacleHits`, `regionHitsRect`, `rectInRegion`, `countOutside`, `ContainerTest`, `countPortsOffBorder`, `packHard`, `PackHard`, `placedRect`, `checkInput` |
@@ -29,6 +33,7 @@ The package has no runtime dependencies.
 - **The hard rules of a pack.** `no-overlap` counts the pairs of boxes and the pairs of a box and an obstacle. A locked box without a placement, or with a move of more than `RECORD_EPS`, breaks `locked-kept`. `checkInput` refuses a locked box without a position. Another box without a placement and not in `overflow` breaks `complete`.
 - **The container rule.** `in-container` counts each box that goes out of the container made smaller by `inset`. The box counts with its margin. By default, a shaped container counts as its bounding box.
 - **The exact container.** Give `{ exactContainer: true }` to `packHard` or `countOutside`. Then a box of a shaped container with the size `fixed` must stay inside the shape. A cut corner, a notch and a hole count. A container with a free side keeps the bounding test. The default changes to the exact test at the next breaking version.
+- **The output hash.** `outputHash` gives the first 16 hex characters of the SHA-256 of the canonical JSON of an output. Each number goes to the grid of `RECORD_EPS` first.
 - **The tolerances.** `EPS` (`1e-6`) is for the float compares in an engine. `RECORD_EPS` (`1e-3`) is for the compares on a written file. A record writes the tolerance of each hard rule in its field `tolerance`. The defaults are `overlap` `0.001` and `through` `0.5`.
 
 ## An example
@@ -48,4 +53,4 @@ const placed = applyPack(input, output);
 const hard = packHard(input, output);
 ```
 
-The formats are in `docs/FORMAT.md` of `packing` and `docs/LAYOUT-RECORDS.md` of `highways`. The joint measures are in `docs/JOINT-MEASURES.md` of this repository, and the joint corpus is in `docs/JOINT-CORPUS.md`.
+The formats are in `docs/FORMAT.md` of `packing` and `docs/LAYOUT-RECORDS.md` of `highways`. The joint measures are in `docs/JOINT-MEASURES.md` of this repository, and the joint corpus is in `docs/JOINT-CORPUS.md`. The promotion guards are in `docs/PROMOTION.md`. The portfolio and its pick rule are in `docs/PORTFOLIO.md`.

package/build/index.d.ts

@@ -493,4 +493,194 @@ export declare const EDGE_STEP_VERSION = 1;
  * The rules of each shape are in `docs/JOINT-CORPUS.md`.
  */
 export declare function edgeStep(input: LayoutInput, params: EdgeStepParams, seed?: number): LayoutInput;
+/**
+ * This function gives the SHA-256 digest of the UTF-8 bytes of a string, as 64 lowercase hex characters.
+ * It uses no API of Node or of the browser.
+ */
+export declare function sha256Hex(text: string): string;
+/**
+ * This function gives the canonical form of a value: sorted keys and no whitespace, with the numbers of `JSON.stringify`.
+ * A key with the value `undefined` is not in the form. An `undefined` in an array becomes `null`.
+ */
+export declare function canonicalJson(value: unknown): string;
+/** The options of `outputHash` and `documentHash`. */
+export interface HashOptions {
+  /**
+   * The step of the grid of the numbers. The default is `RECORD_EPS`, so a number keeps 3 decimals.
+   * The value `0` keeps the exact numbers. A negative value or a value that is not finite causes a `RangeError`.
+   */
+  readonly grid?: number;
+}
+/**
+ * This function gives the hash of an output: the first 16 hex characters of the SHA-256 of its canonical form.
+ * Before the canonical form, each number goes to the nearest point of the grid, and `-0` becomes `0`.
+ * With the default grid, the rounding is `round3` of `packing`: `Math.round(x * 1000) / 1000`.
+ * The function throws a `RangeError` for `NaN` and for an infinite number.
+ *
+ * The grid can split two outputs. Two numbers near a rounding boundary can go to two different points.
+ * The grid can also merge two outputs whose numbers go to the same points. This merge is intentional: it removes the noise of floating-point numbers.
+ */
+export declare function outputHash(value: unknown, options?: HashOptions): string;
+/**
+ * This function gives the hash of a document. It uses the rule of `outputHash`, but the form does not include the field `hash` of the document.
+ * With the default grid, it is the input hash of `docs/FORMAT.md` of `packing`.
+ */
+export declare function documentHash(doc: object, options?: HashOptions): string;
+/** One output group: the candidates with the same output hash on each decision input. */
+export interface OutputGroup {
+  /** The id of the group: its first member. */
+  readonly id: string;
+  /** The ids of the candidates of the group, in sorted order. */
+  readonly members: readonly string[];
+}
+/**
+ * This function gives the output groups of the candidates. The key of `hashes` is the id of a candidate.
+ * Its value is the list of the output hashes of the candidate, in the order of the decision inputs.
+ * Candidates with equal lists make one group. The groups are in the order of their ids.
+ * The function throws a `RangeError` when two lists have different lengths.
+ */
+export declare function outputGroups(hashes: Readonly<Record<string, readonly string[]>>): OutputGroup[];
+/** The evidence that a candidate is exercised on its decision inputs. */
+export interface ExerciseEvidence {
+  /** The move counts of the candidate, by name. A record keeps each one as the trace measure `move.<name>`. */
+  readonly moves?: Readonly<Record<string, number>>;
+  /** The output hashes of the candidate, in the order of the decision inputs. */
+  readonly hashes?: readonly string[];
+  /** The output hashes of the base of the candidate, in the same order. */
+  readonly baseHashes?: readonly string[];
+}
+/**
+ * This function tells if a candidate is exercised. It gives `true` when a move count is more than 0.
+ * It also gives `true` when `hashes` and `baseHashes` are different at one place or more.
+ * Without evidence, it gives `false`.
+ * The function throws a `RangeError` when only one of the two lists is given, or when their lengths are different.
+ */
+export declare function exercised(evidence: ExerciseEvidence): boolean;
+/** The part of a `MeasureSpec` that a pick uses: the direction and the `minEffect`. */
+export type PickSpec = Pick<MeasureSpec, "direction" | "minEffect">;
+/** A member of a portfolio: a function with an id. A portfolio is also a member. */
+export interface Member<I, O> {
+  readonly id: string;
+  /** This function gives the output of the member for an input. */
+  run(input: I): O;
+}
+/** One level of the key of a portfolio: a measure of an output. */
+export interface PortfolioLevel<I, O> {
+  /** The id of the level. The id `hard` is reserved. */
+  readonly id: string;
+  readonly spec: PickSpec;
+  /** This function gives the value of the measure for the output of a member. The value must be finite. */
+  value(input: I, output: O): number;
+}
+/** The key of a portfolio: the hard level, then the other levels in order. */
+export interface PortfolioKey<I, O> {
+  /** This function gives the count of hard breaks. It is level 0, with the direction `lower` and the `minEffect` 0. */
+  hard(input: I, output: O): number;
+  /** The levels after the hard level, in the order of the pick. */
+  readonly levels: readonly PortfolioLevel<I, O>[];
+  /** This function gives the hash of an output. The default is `outputHash` with the default grid. */
+  hash?(output: O): string;
+}
+/** The options of a portfolio. */
+export interface PortfolioOptions {
+  /** The time limit in milliseconds, 0 or more. The first member always starts. A member that starts always finishes. */
+  readonly budgetMs?: number;
+  /** The largest count of members that run, a whole number of 1 or more. The other members are cut. */
+  readonly maxMembers?: number;
+  /** The clock in milliseconds. The default is `performance.now`, or `Date.now` without `performance`. */
+  readonly now?: () => number;
+}
+/** The status of a member in a pick. */
+export type MemberStatus = "ran" | "cut" | "error";
+/** The trace of one member in a pick. */
+export interface MemberTrace {
+  readonly id: string;
+  readonly status: MemberStatus;
+  /** The value of each level, with the key `hard` for the hard level. Only a member with the status `ran` has values. */
+  readonly values?: Readonly<Record<string, number>>;
+  /** The time of the run of the member, in milliseconds. */
+  readonly ms?: number;
+  /** The hash of the output of the member. */
+  readonly outputHash?: string;
+  /** The message of the error of a member with the status `error`. */
+  readonly error?: string;
+}
+/** The trace of one pick of a portfolio. */
+export interface PortfolioTrace {
+  /** One entry for each member, in the order of the members. A cut member is also in the list. */
+  readonly members: readonly MemberTrace[];
+  readonly winner: string;
+  /** The index of the winner in the list of the members. */
+  readonly winnerIndex: number;
+  /** The value `true` tells that the winner is not member 0 and has a different output hash. */
+  readonly picked: boolean;
+  /** The time of the full pick, in milliseconds. */
+  readonly totalMs: number;
+  readonly budgetMs?: number;
+  readonly maxMembers?: number;
+  /** The count of the cut members. */
+  readonly cut: number;
+  /** The value `false` tells that the time limit cut one member or more. Then a run on a different computer can give a different pick. */
+  readonly deterministic: boolean;
+  /** The ids of the members that stay in after each level of `selectBest`. The first list is for the hard level. */
+  readonly kept: readonly (readonly string[])[];
+}
+/** The result of one pick of a portfolio: the output of the winner, its id and the trace. */
+export interface PortfolioPick<O> {
+  readonly output: O;
+  readonly winner: string;
+  readonly trace: PortfolioTrace;
+}
+/** A portfolio: a member that runs its members and gives the output of the best member. */
+export interface Portfolio<I, O> extends Member<I, O> {
+  /** This function starts the members on an input and gives the output of the winner with the trace. */
+  pick(input: I): PortfolioPick<O>;
+}
+/** A candidate of `selectBest`: an id and the value of each level. */
+export interface SelectCandidate {
+  readonly id: string;
+  readonly values: Readonly<Record<string, number>>;
+}
+/** A level of `selectBest`: the id of a value and its spec. */
+export interface SelectLevel {
+  readonly id: string;
+  readonly spec: PickSpec;
+}
+/** The result of `selectBest`. */
+export interface Selection {
+  readonly winner: string;
+  /** The ids of the candidates that stay in after each level, in the given order. */
+  readonly kept: readonly (readonly string[])[];
+}
+/**
+ * This function picks the best candidate. For each level, it finds the best value of the candidates that stay in.
+ * It keeps each candidate that is not worse than that best value by `compareMeasure`.
+ * The winner is the first candidate, in the given order, that stays in after the last level.
+ * Without levels, the winner is the first candidate and `kept` is empty.
+ *
+ * The reason for the rule: a scan that compares each candidate with the current winner is not transitive, because of the `minEffect` ties.
+ * Such a scan can drift away from the best value. An example: "a" is lower with the `minEffect` 0.005, and "b" is higher.
+ * The candidates A (0, 1), B (0.004, 2) and C (0.008, 3) give the winner B.
+ * The scan picks C, but A is better than C on "a".
+ *
+ * The function throws a `RangeError` for an empty list of candidates, for a missing value, and for a value that is not finite.
+ */
+export declare function selectBest(candidates: readonly SelectCandidate[], levels: readonly SelectLevel[]): Selection;
+/** This function gives the move `pick` of a pick: 1 when `picked` is true, else 0. A record keeps it as the trace measure `move.pick`. */
+export declare function pickMoves(trace: Pick<PortfolioTrace, "picked">): {
+  pick: number;
+};
+/**
+ * This function makes a portfolio. Its `pick` starts the members in their order. `selectBest` picks the winner of the members with the status `ran`.
+ * The first level is the hard level, then the levels of the key follow.
+ * `members` is a list, or a function of the input that gives the list.
+ *
+ * A member that throws, or that gives a value that is not finite, gets the status `error`. It does not win.
+ * When each member has an error, `pick` throws the error of the first member.
+ * `docs/PORTFOLIO.md` tells the rules of the time limit, the trace and `picked`.
+ *
+ * The function throws a `RangeError` for a level with the id `hard`, for two levels with the same id and for a bad option.
+ * It also throws a `RangeError` for an empty list of members, or for two members with the same id.
+ */
+export declare function portfolio<I, O>(id: string, members: readonly Member<I, O>[] | ((input: I) => readonly Member<I, O>[]), key: PortfolioKey<I, O>, options?: PortfolioOptions): Portfolio<I, O>;
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/geometry.ts","../src/tolerance.ts","../src/input.ts","../src/output.ts","../src/record.ts","../src/rules.ts","../src/turn.ts","../src/measures.ts","../src/strategy.ts","../src/random.ts","../src/edges.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/geometry.ts","../src/tolerance.ts","../src/input.ts","../src/output.ts","../src/record.ts","../src/rules.ts","../src/turn.ts","../src/measures.ts","../src/strategy.ts","../src/random.ts","../src/edges.ts","../src/hash.ts","../src/portfolio.ts"],"mappings":"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"}