@lapxo/obligations 0.2.0

package/dist/lattice/vacuity.js

@@ -0,0 +1,55 @@
+import { unitStream } from "../debit/shuffle.js";
+export function isMonotone(c, value) {
+    for (let a = 0; a < c.levels.length; a++) {
+        for (let b = 0; b < c.levels.length; b++) {
+            if (c.leq(a, b) && value(a) > value(b) + 1e-12)
+                return false;
+        }
+    }
+    return true;
+}
+export function vacuityOf(predicate, structure, c, test, opts = {}) {
+    const samples = opts.samples ?? 2000;
+    const spread = opts.spread ?? 20;
+    const next = unitStream(1);
+    const n = c.levels.length;
+    let yes = 0;
+    let no = 0;
+    let sawYes;
+    let sawNo;
+    let read = false;
+    for (let i = 0; i < samples; i++) {
+        const v = [];
+        for (let k = 0; k < n; k++)
+            v.push(Math.round(next() * spread));
+        if (opts.monotone) {
+            v.sort((a, b) => a - b);
+            if (!isMonotone(c, (x) => v[x]))
+                continue;
+        }
+        const probe = (x) => {
+            read = true;
+            return v[x];
+        };
+        if (test(c, probe)) {
+            yes += 1;
+            if (!sawYes)
+                sawYes = [...v];
+        }
+        else {
+            no += 1;
+            if (!sawNo)
+                sawNo = [...v];
+        }
+    }
+    const both = yes > 0 && no > 0;
+    return {
+        predicate,
+        structure,
+        samples: yes + no,
+        yes,
+        no,
+        verdict: both ? 'DISCRIMINATES' : read ? 'CONSTANT' : 'INDEPENDENT',
+        ...(both ? { witnesses: { yes: sawYes, no: sawNo } } : {}),
+    };
+}

package/dist/replay.d.ts

@@ -0,0 +1,2 @@
+import type { Fold, Point, Region } from './field/field.ts';
+export declare function replay<T>(landed: readonly Point[], where: Region, verdict: (met: readonly Point[]) => T): readonly Fold<T>[];

package/dist/replay.js

@@ -0,0 +1,4 @@
+import { foldRegion } from "./field/field.js";
+export function replay(landed, where, verdict) {
+    return foldRegion(landed, where, verdict);
+}

package/dist/views/chain.d.ts

@@ -0,0 +1,5 @@
+export { downset, freedom, unitToIdeal, upset } from '../debit/ideal.ts';
+export { weakest } from '../debit/provenance.ts';
+export { anyOf, missing } from '../debit/unit-span.ts';
+export { composeState, conflictDebits, entails, unit } from '../debit/unit.ts';
+export { coarsen, foldRegion, size, sufficientResolution } from '../field/field.ts';

package/dist/views/chain.js

@@ -0,0 +1,5 @@
+export { downset, freedom, unitToIdeal, upset } from "../debit/ideal.js";
+export { weakest } from "../debit/provenance.js";
+export { anyOf, missing } from "../debit/unit-span.js";
+export { composeState, conflictDebits, entails, unit } from "../debit/unit.js";
+export { coarsen, foldRegion, size, sufficientResolution } from "../field/field.js";

package/dist/views/complement.d.ts

@@ -0,0 +1,2 @@
+export { and, canonical, opinion } from '../debit/packed.ts';
+export { asBoolean, bitLoss } from '../debit/unit.ts';

package/dist/views/complement.js

@@ -0,0 +1,2 @@
+export { and, canonical, opinion } from "../debit/packed.js";
+export { asBoolean, bitLoss } from "../debit/unit.js";

package/dist/views/dual.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/views/dual.js

@@ -0,0 +1 @@
+export {};

package/dist/views/field/physics.d.ts

@@ -0,0 +1,13 @@
+import type { Lattice } from '../../lattice/lattice.ts';
+import type { Claim, Obligatory } from '../../lattice/obligatory.ts';
+type Band = {
+    readonly lo: number;
+    readonly hi: number;
+};
+export declare function disturbance(lattice: Lattice<Band>, one: Obligatory<Band>, claim: Claim<Band>): number;
+export declare function budget(cells: number, resolution: number): number;
+export declare function sameObject(lattice: Lattice<Band>, a: Obligatory<Band>, b: Obligatory<Band>, width: number): boolean;
+export declare function distinct(lattice: Lattice<Band>, world: readonly Obligatory<Band>[], width: number): number;
+export declare function evolve(world: readonly Obligatory<Band>[], epochs: number, budget_: number, seed: number): readonly (readonly Obligatory<Band>[])[];
+export declare function decohere(claims: readonly Claim<Band>[], environment: number, period: number): number;
+export {};

package/dist/views/field/physics.js

@@ -0,0 +1,64 @@
+import { meet } from "../../lattice/obligatory.js";
+import { coherence } from "./wave.js";
+export function disturbance(lattice, one, claim) {
+    const was = meet(lattice, one);
+    const now = meet(lattice, { ...one, seen: [...one.seen, claim] });
+    const width = (span) => Math.max(0, span.hi - span.lo);
+    return width(was) - width(now);
+}
+export function budget(cells, resolution) {
+    if (resolution <= 0)
+        throw new Error('obligations: REFUSE·budget a region read at no resolution has no budget to take');
+    return Math.ceil((2 * cells) / resolution);
+}
+export function sameObject(lattice, a, b, width) {
+    const bin = (one) => {
+        const held = meet(lattice, one);
+        return width <= 0 ? held.lo : Math.round(held.lo / width);
+    };
+    return bin(a) === bin(b);
+}
+export function distinct(lattice, world, width) {
+    const seen = new Set();
+    for (const one of world) {
+        const held = meet(lattice, one);
+        seen.add(width <= 0 ? held.lo : Math.round(held.lo / width));
+    }
+    return seen.size;
+}
+export function evolve(world, epochs, budget_, seed) {
+    let held = seed;
+    const next = () => { held = (held * 1103515245 + 12345) % 2147483648; return held / 2147483648; };
+    const out = [];
+    let now = world;
+    for (let epoch = 1; epoch <= epochs; epoch += 1) {
+        for (let k = 0; k < budget_; k += 1) {
+            const weight = now.map((one) => 1 + 20 * one.seen.length);
+            const total = weight.reduce((sum, w) => sum + w, 0);
+            const where = () => {
+                let pick = next() * total;
+                let at = 0;
+                while (pick > weight[at] && at < now.length - 1) {
+                    pick -= weight[at];
+                    at += 1;
+                }
+                return at;
+            };
+            const i = where();
+            let j = where();
+            if (j === i)
+                j = (j + 1) % now.length;
+            const name = `e${epoch}-${k}`;
+            now = now.map((one, at) => (at === i || at === j ? { ...one, epoch, seen: [...one.seen, { id: `${name}-${at}`, origin: name, at: epoch, span: { lo: 0, hi: 100 } }] } : one));
+        }
+        out.push(now);
+    }
+    return out;
+}
+export function decohere(claims, environment, period) {
+    const about = claims.map((claim, i) => ({ ...claim, epoch: claim.at ?? 0, origin: claim.origin || `o${i}` }));
+    const noise = Array.from({ length: environment }, (_, i) => ({
+        origin: `n${i}`, span: { lo: 0, hi: 1 }, epoch: i % Math.max(1, period), at: i % Math.max(1, period),
+    }));
+    return coherence([...about, ...noise].map((claim) => ({ origin: claim.origin, epoch: claim.epoch, span: claim.span })), period);
+}

package/dist/views/field/policy.d.ts

@@ -0,0 +1,20 @@
+import type { Lattice } from '../../lattice/lattice.ts';
+import type { Obligatory } from '../../lattice/obligatory.ts';
+type Band = {
+    readonly lo: number;
+    readonly hi: number;
+};
+export interface Weights {
+    readonly reach: number;
+    readonly coherence: number;
+    readonly rank: number;
+    readonly bits: number;
+}
+export declare function choose(lattice: Lattice<Band>, world: readonly Obligatory<Band>[], weights: Weights, held: ReadonlySet<string>): string;
+export declare function play(lattice: Lattice<Band>, world: readonly Obligatory<Band>[], weights: Weights, epochs: number, seed: number, spread: number): {
+    readonly closed: number;
+    readonly forks: number;
+    readonly reopened: number;
+    readonly coverage: number;
+};
+export {};

package/dist/views/field/policy.js

@@ -0,0 +1,68 @@
+import { encounter, meet } from "../../lattice/obligatory.js";
+import { coherence } from "./wave.js";
+import { neighbours, reach } from "../product/reach.js";
+const at = (cell) => cell.at.join('/');
+const said = (lattice, cell) => {
+    const held = meet(lattice, cell);
+    if (encounter(lattice, cell).origins < 2)
+        return 'one';
+    return held.lo > held.hi ? 'apart' : 'together';
+};
+const widthOf = (lattice, cell) => {
+    const held = meet(lattice, cell);
+    return Math.max(0, held.hi - held.lo);
+};
+export function choose(lattice, world, weights, held) {
+    let best = '';
+    let top;
+    for (const cell of world) {
+        const name = at(cell);
+        if (held.has(name))
+            continue;
+        const said = cell.seen.map((claim, i) => ({ origin: claim.origin, epoch: claim.at ?? i, span: claim.span }));
+        const score = weights.reach * reach(world, name)
+            + weights.coherence * coherence(said, 8)
+            + weights.rank * (neighbours(world).get(name) ?? []).length
+            + weights.bits * Math.log2(1 + widthOf(lattice, cell));
+        if (top === undefined || score > top) {
+            top = score;
+            best = name;
+        }
+    }
+    return best;
+}
+export function play(lattice, world, weights, epochs, seed, spread) {
+    let held = seed;
+    const next = () => { held = (held * 1103515245 + 12345) % 2147483648; return held / 2147483648; };
+    let now = [...world];
+    const closed = new Set();
+    const forked = new Set();
+    let reopened = 0;
+    for (let epoch = 1; epoch <= epochs; epoch += 1) {
+        const name = choose(lattice, now, weights, new Set());
+        if (!name)
+            break;
+        now = now.map((cell) => {
+            if (at(cell) !== name)
+                return cell;
+            const was = said(lattice, cell);
+            const held = meet(lattice, cell);
+            const centre = (held.lo + held.hi) / 2 + (next() * 2 - 1) * spread;
+            const one = { id: `p${epoch}`, origin: `p${epoch}`, at: epoch, span: { lo: centre - 5, hi: centre + 5 } };
+            const after = { ...cell, epoch, seen: [...cell.seen, one] };
+            const verdict = said(lattice, after);
+            if (verdict === 'together' && was !== 'together')
+                closed.add(name);
+            if (verdict === 'apart') {
+                forked.add(name);
+                if (closed.has(name)) {
+                    reopened += 1;
+                    closed.delete(name);
+                }
+            }
+            return after;
+        });
+    }
+    const covered = now.filter((cell) => encounter(lattice, cell).origins > 1).length;
+    return { closed: closed.size, forks: forked.size, reopened, coverage: Math.round((100 * covered) / now.length) };
+}

package/dist/views/field/self.d.ts

@@ -0,0 +1,8 @@
+import type { Obligatory } from '../../lattice/obligatory.ts';
+import type { Lattice } from '../../lattice/lattice.ts';
+type Band = {
+    readonly lo: number;
+    readonly hi: number;
+};
+export declare function selfFold(lattice: Lattice<Band>, one: Obligatory<Band>, epochs: number, width: number, spread: number, seed: number): readonly Obligatory<Band>[];
+export {};

package/dist/views/field/self.js

@@ -0,0 +1,14 @@
+import { meet, observe } from "../../lattice/obligatory.js";
+export function selfFold(lattice, one, epochs, width, spread, seed) {
+    let held = seed;
+    const next = () => { held = (held * 1103515245 + 12345) % 2147483648; return held / 2147483648; };
+    const out = [];
+    let now = one;
+    for (let epoch = 1; epoch <= epochs; epoch += 1) {
+        const at = meet(lattice, now);
+        const centre = (at.lo + at.hi) / 2 + (next() * 2 - 1) * spread;
+        now = observe(now, { origin: `self${epoch}`, at: epoch, span: { lo: centre - width / 2, hi: centre + width / 2 } });
+        out.push(now);
+    }
+    return out;
+}

package/dist/views/field/wave.d.ts

@@ -0,0 +1,16 @@
+import type { Point } from '../../field/field.ts';
+export interface Claim {
+    readonly origin: string;
+    readonly epoch: number;
+    readonly span: {
+        readonly lo: number;
+        readonly hi: number;
+    };
+    readonly withdraws?: boolean;
+}
+export declare function amplitude(claim: Claim): number;
+export declare function phase(claim: Claim, period: number): number;
+export declare function coherence(claims: readonly Claim[], period: number): number;
+export declare function interfere(claims: readonly Claim[], period: number): number;
+export declare function fringes(claims: readonly Claim[], period: number, delays: readonly number[]): readonly number[];
+export declare const seenAs: (cell: Point, period: number) => readonly Claim[];

package/dist/views/field/wave.js

@@ -0,0 +1,34 @@
+export function amplitude(claim) {
+    const size = claim.span.hi - claim.span.lo;
+    const width = Number.isFinite(size) ? 1 / (1 + Math.max(size, 0)) : 0;
+    return claim.withdraws ? -width : width;
+}
+export function phase(claim, period) {
+    return period <= 0 ? 0 : ((claim.epoch % period) + period) % period;
+}
+export function coherence(claims, period) {
+    if (!claims.length)
+        return 0;
+    let x = 0;
+    let y = 0;
+    for (const claim of claims) {
+        const turn = (2 * Math.PI * phase(claim, period)) / period;
+        x += Math.cos(turn);
+        y += Math.sin(turn);
+    }
+    return Math.sqrt(x * x + y * y) / claims.length;
+}
+export function interfere(claims, period) {
+    let x = 0;
+    let y = 0;
+    for (const claim of claims) {
+        const turn = (2 * Math.PI * phase(claim, period)) / period;
+        x += amplitude(claim) * Math.cos(turn);
+        y += amplitude(claim) * Math.sin(turn);
+    }
+    return Math.sqrt(x * x + y * y) ** 2;
+}
+export function fringes(claims, period, delays) {
+    return delays.map((delay) => interfere(claims.map((claim, i) => (i % 2 === 0 ? claim : { ...claim, epoch: claim.epoch + delay })), period));
+}
+export const seenAs = (cell, period) => cell.seen.map((s) => ({ origin: s.origin, epoch: cell.epoch, span: s.span }));

package/dist/views/field.d.ts

@@ -0,0 +1,12 @@
+export { foldIn, witnessesIn } from '../debit/debit.ts';
+export { disagree, latest, meetAt, origins, potential, turned } from '../field/encounter.ts';
+export { contracts, coordinate, covers, exclusive, key, passes, point, region, resolution, within } from '../field/field.ts';
+export { converge, endsBeforeNow, present } from '../field/present.ts';
+export { amplitude, coherence, fringes, interfere, phase, seenAs } from './field/wave.ts';
+export type { Claim } from './field/wave.ts';
+export { cell, encounter, join, meet, observe, refine, sign } from '../lattice/obligatory.ts';
+export type { Obligatory } from '../lattice/obligatory.ts';
+export { budget, decohere, disturbance, distinct, evolve, sameObject } from './field/physics.ts';
+export { choose, play } from './field/policy.ts';
+export { selfFold } from './field/self.ts';
+export type { Weights } from './field/policy.ts';

package/dist/views/field.js

@@ -0,0 +1,9 @@
+export { foldIn, witnessesIn } from "../debit/debit.js";
+export { disagree, latest, meetAt, origins, potential, turned } from "../field/encounter.js";
+export { contracts, coordinate, covers, exclusive, key, passes, point, region, resolution, within } from "../field/field.js";
+export { converge, endsBeforeNow, present } from "../field/present.js";
+export { amplitude, coherence, fringes, interfere, phase, seenAs } from "./field/wave.js";
+export { cell, encounter, join, meet, observe, refine, sign } from "../lattice/obligatory.js";
+export { budget, decohere, disturbance, distinct, evolve, sameObject } from "./field/physics.js";
+export { choose, play } from "./field/policy.js";
+export { selfFold } from "./field/self.js";

package/dist/views/galois.d.ts

@@ -0,0 +1,2 @@
+export { alphabets } from '../lattice/forms.ts';
+export { relate } from '../lattice/lattice.ts';

package/dist/views/galois.js

@@ -0,0 +1,2 @@
+export { alphabets } from "../lattice/forms.js";
+export { relate } from "../lattice/lattice.js";

package/dist/views/ideal.d.ts

@@ -0,0 +1,10 @@
+export { fromIdeals, idealComplexity, idealDebit, idealEntails, idealJoin, idealMeet, isDownset, isIdealPair, isUpset, unitComplexity } from '../debit/ideal.ts';
+export { packer } from '../debit/packed.ts';
+export { rebuild, register } from '../debit/register.ts';
+export { holds, touches } from '../debit/standing.ts';
+export { complexity, statesPerDebit } from '../debit/unit-span.ts';
+export { permitAll, state, table, widen } from '../debit/unit.ts';
+export { dangerous, moved, transitions } from '../debit/vector-move.ts';
+export { quadrants, runQuadrants, stateAt } from '../debit/vector.ts';
+export { closureViolationsIn } from '../lattice/axioms.ts';
+export { isDistributive } from '../lattice/order.ts';

package/dist/views/ideal.js

@@ -0,0 +1,10 @@
+export { fromIdeals, idealComplexity, idealDebit, idealEntails, idealJoin, idealMeet, isDownset, isIdealPair, isUpset, unitComplexity } from "../debit/ideal.js";
+export { packer } from "../debit/packed.js";
+export { rebuild, register } from "../debit/register.js";
+export { holds, touches } from "../debit/standing.js";
+export { complexity, statesPerDebit } from "../debit/unit-span.js";
+export { permitAll, state, table, widen } from "../debit/unit.js";
+export { dangerous, moved, transitions } from "../debit/vector-move.js";
+export { quadrants, runQuadrants, stateAt } from "../debit/vector.js";
+export { closureViolationsIn } from "../lattice/axioms.js";
+export { isDistributive } from "../lattice/order.js";

package/dist/views/product/design.d.ts

@@ -0,0 +1,13 @@
+import type { Obligatory } from '../../lattice/obligatory.ts';
+type Band = {
+    readonly lo: number;
+    readonly hi: number;
+};
+export declare function horizonTotal(world: readonly Obligatory<Band>[], bounds?: readonly string[]): number;
+export declare function design(world: readonly Obligatory<Band>[], budget: number, bounds?: readonly string[]): readonly (readonly [string, string])[];
+export declare function loom(world: readonly Obligatory<Band>[], epochs: number, budget: number, bounds?: readonly string[]): readonly number[];
+export declare const apart: (world: readonly Obligatory<Band>[], a: string, b: string, bounds?: readonly string[]) => boolean;
+export declare function rank(world: readonly Obligatory<Band>[], bound: string): number;
+export declare const sited: (world: readonly Obligatory<Band>[], sites: readonly (readonly [string, string])[], epoch?: number) => readonly Obligatory<Band>[];
+export declare const lone: (name: string, epoch?: number) => Obligatory<Band>;
+export {};

package/dist/views/product/design.js

@@ -0,0 +1,66 @@
+import { neighbours } from "./reach.js";
+import { cell } from "../../lattice/obligatory.js";
+const at = (one) => one.at.join('/');
+const BAND = { lo: 0, hi: 100 };
+function components(world, bounds = []) {
+    const graph = neighbours(world, bounds);
+    const seen = new Set();
+    const out = [];
+    for (const one of world.map(at)) {
+        if (seen.has(one))
+            continue;
+        const edge = [one];
+        const held = [];
+        seen.add(one);
+        while (edge.length) {
+            const here = edge.pop();
+            held.push(here);
+            for (const there of graph.get(here) ?? [])
+                if (!seen.has(there)) {
+                    seen.add(there);
+                    edge.push(there);
+                }
+        }
+        out.push(held);
+    }
+    return out;
+}
+export function horizonTotal(world, bounds = []) {
+    const sizes = components(world, bounds).map((part) => part.length);
+    const all = sizes.reduce((sum, n) => sum + n, 0);
+    return sizes.reduce((sum, n) => sum + n * (all - n), 0) / 2;
+}
+export function design(world, budget, bounds = []) {
+    const parts = [...components(world, bounds)].sort((a, b) => b.length - a.length);
+    const out = [];
+    for (let k = 0; k < budget && k + 1 < parts.length; k += 1)
+        out.push([parts[0][0], parts[k + 1][0]]);
+    return out;
+}
+const landed = (world, sites, epoch) => {
+    const named = new Map();
+    for (const [k, [a, b]] of sites.entries()) {
+        const name = `d${epoch}-${k}`;
+        named.set(a, [...(named.get(a) ?? []), name]);
+        named.set(b, [...(named.get(b) ?? []), name]);
+    }
+    return world.map((one) => {
+        const mine = named.get(at(one));
+        return mine === undefined ? one : { ...one, epoch, seen: [...one.seen, ...mine.map((origin) => ({ id: `${origin}-${at(one)}`, origin, at: epoch, span: BAND }))] };
+    });
+};
+export function loom(world, epochs, budget, bounds = []) {
+    let held = world;
+    const out = [horizonTotal(held, bounds)];
+    for (let epoch = 1; epoch <= epochs; epoch += 1) {
+        held = landed(held, design(held, budget, bounds), epoch);
+        out.push(horizonTotal(held, bounds));
+    }
+    return out;
+}
+export const apart = (world, a, b, bounds = []) => !components(world, bounds).some((part) => part.includes(a) && part.includes(b));
+export function rank(world, bound) {
+    return world.filter((one) => one.seen.some((claim) => claim.origin === bound)).length;
+}
+export const sited = (world, sites, epoch = 1) => landed(world, sites, epoch);
+export const lone = (name, epoch = 0) => cell(name, epoch, [{ id: `own-${name}`, origin: `own-${name}`, at: epoch, span: BAND }]);

package/dist/views/product/mould.d.ts

@@ -0,0 +1,14 @@
+import type { Interval } from '../../lattice/forms.ts';
+import type { Point } from '../../field/field.ts';
+export type Lock = ReadonlyMap<string, Interval>;
+export declare function stretch(lock: Lock, k: number): Lock;
+export declare function red(world: readonly Point[], lock: Lock): readonly string[];
+export declare function pour(world: readonly Point[], lock: Lock): {
+    readonly filled: number;
+    readonly of: number;
+};
+export declare function tense(lock: Lock, world: readonly Point[], rate: number): Lock;
+export declare function tighter(before: Lock, after: Lock): {
+    readonly tightened: number;
+    readonly loosened: number;
+};

package/dist/views/product/mould.js

@@ -0,0 +1,55 @@
+import { meetAt } from "../../field/encounter.js";
+const at = (cell) => cell.at.join('/');
+const holds = (bound, held) => held.hi >= held.lo && held.lo >= bound.lo - 1e-12 && held.hi <= bound.hi + 1e-12;
+export function stretch(lock, k) {
+    const out = new Map();
+    for (const [place, bound] of lock) {
+        const middle = (bound.lo + bound.hi) / 2;
+        const half = ((bound.hi - bound.lo) / 2) * k;
+        out.set(place, { lo: middle - half, hi: middle + half });
+    }
+    return out;
+}
+export function red(world, lock) {
+    return world.filter((cell) => {
+        const bound = lock.get(at(cell));
+        return bound !== undefined && !holds(bound, meetAt(cell));
+    }).map(at);
+}
+export function pour(world, lock) {
+    const reached = new Set(world.map(at));
+    return { filled: [...lock.keys()].filter((place) => reached.has(place)).length, of: lock.size };
+}
+export function tense(lock, world, rate) {
+    const seen = new Map();
+    for (const cell of world)
+        seen.set(at(cell), meetAt(cell));
+    const out = new Map();
+    for (const [place, bound] of lock) {
+        const held = seen.get(place);
+        if (held === undefined || held.hi < held.lo) {
+            const half = ((bound.hi - bound.lo) / 2) * (1 + rate);
+            const middle = (bound.lo + bound.hi) / 2;
+            out.set(place, { lo: middle - half, hi: middle + half });
+            continue;
+        }
+        out.set(place, { lo: bound.lo + (held.lo - bound.lo) * rate, hi: bound.hi - (bound.hi - held.hi) * rate });
+    }
+    return out;
+}
+export function tighter(before, after) {
+    let tightened = 0;
+    let loosened = 0;
+    for (const [place, bound] of before) {
+        const now = after.get(place);
+        if (now === undefined)
+            continue;
+        const was = bound.hi - bound.lo;
+        const is = now.hi - now.lo;
+        if (is < was - 1e-12)
+            tightened += 1;
+        if (is > was + 1e-12)
+            loosened += 1;
+    }
+    return { tightened, loosened };
+}

package/dist/views/product/polygon.d.ts

@@ -0,0 +1,10 @@
+import type { Point } from '../../field/field.ts';
+export type Vertex = readonly [number, number];
+export declare function vertices(cell: Point): readonly Vertex[];
+export declare function hull(cell: Point): readonly Vertex[];
+export declare function area(cell: Point): number;
+export declare function centre(cell: Point): Vertex;
+export declare function outliers(cell: Point): readonly string[];
+export declare function steady(cell: Point): boolean;
+export declare function width(cell: Point): number;
+export declare function density(cell: Point): number;

package/dist/views/product/polygon.js

@@ -0,0 +1,65 @@
+import { disagree, meetAt, origins, potential } from "../../field/encounter.js";
+export function vertices(cell) {
+    const held = new Map();
+    for (const seen of cell.seen)
+        held.set(seen.origin, [seen.span.lo, seen.span.hi]);
+    return [...held.values()];
+}
+export function hull(cell) {
+    const said = [...vertices(cell)].sort((a, b) => (a[0] === b[0] ? a[1] - b[1] : a[0] - b[0]));
+    if (said.length < 3)
+        return said;
+    const turn = (o, a, b) => (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
+    const side = (order) => {
+        const out = [];
+        for (const one of order) {
+            while (out.length > 1 && turn(out[out.length - 2], out[out.length - 1], one) <= 0)
+                out.pop();
+            out.push(one);
+        }
+        out.pop();
+        return out;
+    };
+    return [...side(said), ...side([...said].reverse())];
+}
+export function area(cell) {
+    const ring = hull(cell);
+    if (ring.length < 3)
+        return 0;
+    let twice = 0;
+    for (let i = 0; i < ring.length; i += 1) {
+        const [x1, y1] = ring[i];
+        const [x2, y2] = ring[(i + 1) % ring.length];
+        twice += x1 * y2 - x2 * y1;
+    }
+    return Math.abs(twice) / 2;
+}
+export function centre(cell) {
+    const said = vertices(cell);
+    if (!said.length)
+        return [0, 0];
+    return [said.reduce((s, v) => s + v[0], 0) / said.length, said.reduce((s, v) => s + v[1], 0) / said.length];
+}
+const without = (cell, origin) => ({ ...cell, seen: cell.seen.filter((s) => s.origin !== origin) });
+export function outliers(cell) {
+    if (origins(cell) < 4)
+        throw new Error('REFUSE·outliers fewer than four origins enclose no figure a leaving one could shrink');
+    const whole = area(cell);
+    if (whole === 0)
+        throw new Error('REFUSE·outliers the origins lie on one line: the figure has no interior, so none of them is outside it');
+    return [...new Set(cell.seen.map((s) => s.origin))].filter((origin) => area(without(cell, origin)) < whole - 1e-12);
+}
+export function steady(cell) {
+    if (origins(cell) < 5)
+        return false;
+    const said = (one) => (potential(one) ? 'one' : disagree(one) ? 'apart' : 'together');
+    const held = said(cell);
+    return [...new Set(cell.seen.map((s) => s.origin))].every((origin) => said(without(cell, origin)) === held);
+}
+export function width(cell) {
+    const held = meetAt(cell);
+    return held.hi < held.lo ? 0 : held.hi - held.lo;
+}
+export function density(cell) {
+    return origins(cell) === 0 ? 0 : area(cell) / origins(cell);
+}

package/dist/views/product/reach.d.ts

@@ -0,0 +1,14 @@
+import type { Interval } from '../../lattice/forms.ts';
+import type { Point } from '../../field/field.ts';
+export declare function neighbours(world: readonly Point[], bounds?: readonly string[]): ReadonlyMap<string, readonly string[]>;
+export declare function distance(world: readonly Point[], from: string, to: string, bounds?: readonly string[]): number;
+export declare function horizon(world: readonly Point[], from: string, bounds?: readonly string[]): readonly string[];
+export declare function reach(world: readonly Point[], from: string, bounds?: readonly string[]): number;
+export declare function tunnel(world: readonly Point[], places: readonly string[], bounds?: readonly string[]): readonly (readonly [string, string])[];
+export declare function curvature(world: readonly Point[]): number;
+export declare function grow(walls: readonly number[], placed: readonly number[]): readonly {
+    readonly at: number;
+    readonly width: number;
+}[];
+export declare function entangled(world: readonly Point[], bound: string): readonly string[];
+export declare function resting(world: readonly Point[], bound: string, was: Interval, now: Interval): readonly string[];