@hviana/sema 0.1.3 → 0.1.5

package/dist/src/alu/src/kernel-nd.js

@@ -39,170 +39,210 @@ import { asBit, asInt, int, isNd, nd } from "./value.js";
 /** The element list of an nd, or throw — so a structural op called on a non-list
  *  declines (the Alu facade maps the throw to "this rule does not fire"). */
 function listOf(v) {
-    if (!isNd(v))
-        throw new Error("nd op: operand is not an n-dimensional value");
-    return v.items;
+  if (!isNd(v)) {
+    throw new Error("nd op: operand is not an n-dimensional value");
+  }
+  return v.items;
 }
 /** Resolve an operation-value to a canonical name of the wanted arity, or throw
  *  (decline) when it names no known operation — the higher-order ops' shared
  *  front door, so an unrecognised function argument never silently no-ops. */
 function resolveFn(ctx, op, arity) {
-    const name = ctx.resolveOp(op, arity);
-    if (name === null)
-        throw new Error("nd op: unrecognised operation argument");
-    return name;
+  const name = ctx.resolveOp(op, arity);
+  if (name === null) {
+    throw new Error("nd op: unrecognised operation argument");
+  }
+  return name;
 }
 /** Register the n-dimensional layer into `r`.  All ops are STRUCTURAL. */
 export function registerNd(r) {
-    // ── core primitives (the only ops that touch `items`) ────────────────────
-    // nd: PACK operands into a list.  Variadic, so `nd(a, b, c)` = [a, b, c] and
-    // `nd()` = the empty list.  An operand that is itself a list nests (a matrix
-    // is `nd(row0, row1, …)`), so rank grows by composition, never a new type.
-    r.prim("nd", "variadic", ["nd", "list", "vector", "tuple", "array"], (args) => nd(args.slice()), { structural: true });
-    // length: the top-level element count, as an exact int.
-    r.prim("length", 1, ["length", "size", "len"], (args) => int(BigInt(listOf(args[0]).length)), { structural: true });
-    // at: project the i-th element.  A negative index counts from the end
-    // (−1 = last), Python-style; out of range throws (the rule declines).
-    r.prim("at", 2, ["at", "nth", "elem", "index"], (args) => {
-        const xs = listOf(args[0]);
-        let i = Number(asInt(args[1]));
-        if (i < 0)
-            i += xs.length;
-        if (i < 0 || i >= xs.length)
-            throw new Error("at: index out of range");
-        return xs[i];
-    }, { structural: true });
-    // ── derived: construction ────────────────────────────────────────────────
-    // range(n) = [0, 1, …, n−1]; range(a, b) = [a, a+1, …, b−1].  The index
-    // generator map/reduce iterate over when there is no input list yet.
-    r.derive("range", "variadic", ["range", "iota", "upto"], (args) => {
-        const lo = args.length >= 2 ? asInt(args[0]) : 0n;
-        const hi = args.length >= 2 ? asInt(args[1]) : asInt(args[0]);
-        const out = [];
-        for (let k = lo; k < hi; k++)
-            out.push(int(k));
-        return nd(out);
-    }, { structural: true });
-    // ── derived: the higher-order trio (op argument = any existing operation) ──
-    // map(xs, f): apply the UNARY op f to each element.  Built on at/length/nd; f
-    // is resolved by meaning, so `map(xs, negate)`, `map(xs, sqrt)`, `map(xs,
-    // inverse)` all work, and (via broadcast) map over a list of lists is fine.
-    r.derive("map", 2, ["map", "each"], (args, ctx) => {
-        const xs = listOf(args[0]);
-        const f = resolveFn(ctx, args[1], 1);
-        return nd(xs.map((e) => ctx.apply(f, [e])));
-    }, { structural: true });
-    // filter(xs, p): keep the elements for which the UNARY predicate p is truthy
-    // (its result read as a bit).  `filter(xs, isprime)`, `filter(xs, >0)`, … —
-    // any op that returns a truth value is a predicate.
-    r.derive("filter", 2, ["filter", "where", "keep"], (args, ctx) => {
-        const xs = listOf(args[0]);
-        const p = resolveFn(ctx, args[1], 1);
-        return nd(xs.filter((e) => asBit(ctx.apply(p, [e])) === 1));
-    }, { structural: true });
-    // reduce(xs, f) / reduce(xs, f, z): left-fold the BINARY op f across the list,
-    // optionally from a seed z.  `reduce(xs, +)` sums, `reduce(xs, *)` multiplies,
-    // `reduce(xs, max)` is the maximum, `reduce(xs, or)` is "any", … — the scalar
-    // kernel's whole binary vocabulary becomes a fold.  With no seed an empty list
-    // declines (nothing to fold); with a seed it returns the seed.
-    r.derive("reduce", "variadic", ["reduce", "fold", "accumulate"], (args, ctx) => {
-        if (args.length < 2) {
-            throw new Error("reduce: needs a list and an operation");
+  // ── core primitives (the only ops that touch `items`) ────────────────────
+  // nd: PACK operands into a list.  Variadic, so `nd(a, b, c)` = [a, b, c] and
+  // `nd()` = the empty list.  An operand that is itself a list nests (a matrix
+  // is `nd(row0, row1, …)`), so rank grows by composition, never a new type.
+  r.prim(
+    "nd",
+    "variadic",
+    ["nd", "list", "vector", "tuple", "array"],
+    (args) => nd(args.slice()),
+    { structural: true },
+  );
+  // length: the top-level element count, as an exact int.
+  r.prim(
+    "length",
+    1,
+    ["length", "size", "len"],
+    (args) => int(BigInt(listOf(args[0]).length)),
+    { structural: true },
+  );
+  // at: project the i-th element.  A negative index counts from the end
+  // (−1 = last), Python-style; out of range throws (the rule declines).
+  r.prim("at", 2, ["at", "nth", "elem", "index"], (args) => {
+    const xs = listOf(args[0]);
+    let i = Number(asInt(args[1]));
+    if (i < 0) {
+      i += xs.length;
+    }
+    if (i < 0 || i >= xs.length) {
+      throw new Error("at: index out of range");
+    }
+    return xs[i];
+  }, { structural: true });
+  // ── derived: construction ────────────────────────────────────────────────
+  // range(n) = [0, 1, …, n−1]; range(a, b) = [a, a+1, …, b−1].  The index
+  // generator map/reduce iterate over when there is no input list yet.
+  r.derive("range", "variadic", ["range", "iota", "upto"], (args) => {
+    const lo = args.length >= 2 ? asInt(args[0]) : 0n;
+    const hi = args.length >= 2 ? asInt(args[1]) : asInt(args[0]);
+    const out = [];
+    for (let k = lo; k < hi; k++) {
+      out.push(int(k));
+    }
+    return nd(out);
+  }, { structural: true });
+  // ── derived: the higher-order trio (op argument = any existing operation) ──
+  // map(xs, f): apply the UNARY op f to each element.  Built on at/length/nd; f
+  // is resolved by meaning, so `map(xs, negate)`, `map(xs, sqrt)`, `map(xs,
+  // inverse)` all work, and (via broadcast) map over a list of lists is fine.
+  r.derive("map", 2, ["map", "each"], (args, ctx) => {
+    const xs = listOf(args[0]);
+    const f = resolveFn(ctx, args[1], 1);
+    return nd(xs.map((e) => ctx.apply(f, [e])));
+  }, { structural: true });
+  // filter(xs, p): keep the elements for which the UNARY predicate p is truthy
+  // (its result read as a bit).  `filter(xs, isprime)`, `filter(xs, >0)`, … —
+  // any op that returns a truth value is a predicate.
+  r.derive("filter", 2, ["filter", "where", "keep"], (args, ctx) => {
+    const xs = listOf(args[0]);
+    const p = resolveFn(ctx, args[1], 1);
+    return nd(xs.filter((e) => asBit(ctx.apply(p, [e])) === 1));
+  }, { structural: true });
+  // reduce(xs, f) / reduce(xs, f, z): left-fold the BINARY op f across the list,
+  // optionally from a seed z.  `reduce(xs, +)` sums, `reduce(xs, *)` multiplies,
+  // `reduce(xs, max)` is the maximum, `reduce(xs, or)` is "any", … — the scalar
+  // kernel's whole binary vocabulary becomes a fold.  With no seed an empty list
+  // declines (nothing to fold); with a seed it returns the seed.
+  r.derive(
+    "reduce",
+    "variadic",
+    ["reduce", "fold", "accumulate"],
+    (args, ctx) => {
+      if (args.length < 2) {
+        throw new Error("reduce: needs a list and an operation");
+      }
+      const xs = listOf(args[0]);
+      const f = resolveFn(ctx, args[1], 2);
+      const hasSeed = args.length >= 3;
+      let acc;
+      let start;
+      if (hasSeed) {
+        acc = args[2];
+        start = 0;
+      } else {
+        if (xs.length === 0) {
+          throw new Error("reduce: empty list, no seed");
         }
-        const xs = listOf(args[0]);
-        const f = resolveFn(ctx, args[1], 2);
-        const hasSeed = args.length >= 3;
-        let acc;
-        let start;
-        if (hasSeed) {
-            acc = args[2];
-            start = 0;
+        acc = xs[0];
+        start = 1;
+      }
+      for (let i = start; i < xs.length; i++) {
+        acc = ctx.apply(f, [acc, xs[i]]);
+      }
+      return acc;
+    },
+    { structural: true },
+  );
+  // find(xs, p): the FIRST element satisfying the unary predicate p, or the
+  // empty nd when none does (a graph-evidenced "nothing matched", never a guess).
+  r.derive("find", 2, ["find", "first", "search"], (args, ctx) => {
+    const xs = listOf(args[0]);
+    const p = resolveFn(ctx, args[1], 1);
+    for (const e of xs) {
+      if (asBit(ctx.apply(p, [e])) === 1) {
+        return e;
+      }
+    }
+    return nd([]);
+  }, { structural: true });
+  // ── derived: shape-preserving plumbing ────────────────────────────────────
+  // concat(a, b, …): join lists end to end into one list.
+  r.derive("concat", "variadic", ["concat", "append", "join"], (args) => {
+    const out = [];
+    for (const a of args) {
+      for (const e of listOf(a)) {
+        out.push(e);
+      }
+    }
+    return nd(out);
+  }, { structural: true });
+  // reverse(xs): the list back to front.
+  r.derive(
+    "reverse",
+    1,
+    ["reverse", "flip"],
+    (args) => nd(listOf(args[0]).slice().reverse()),
+    { structural: true },
+  );
+  // flatten(xs): splice one level — each nd element is spliced in, each scalar
+  // kept.  flatten ∘ flatten goes deeper; one level is the primitive step.
+  r.derive("flatten", 1, ["flatten", "flat"], (args) => {
+    const out = [];
+    for (const e of listOf(args[0])) {
+      if (isNd(e)) {
+        for (const sub of e.items) {
+          out.push(sub);
         }
-        else {
-            if (xs.length === 0)
-                throw new Error("reduce: empty list, no seed");
-            acc = xs[0];
-            start = 1;
+      } else {
+        out.push(e);
+      }
+    }
+    return nd(out);
+  }, { structural: true });
+  // zip(a, b, …): the lists braided into a list of tuples; length = the shortest
+  // input (a ragged braid stops at the short one, never inventing elements).
+  r.derive("zip", "variadic", ["zip", "braid"], (args) => {
+    const lists = args.map(listOf);
+    if (lists.length === 0) {
+      return nd([]);
+    }
+    const m = Math.min(...lists.map((l) => l.length));
+    const out = [];
+    for (let i = 0; i < m; i++) {
+      out.push(nd(lists.map((l) => l[i])));
+    }
+    return nd(out);
+  }, { structural: true });
+  // rank(v): the nesting DEPTH — 0 for a scalar, 1 + the deepest element's rank
+  // for a list (so a vector is 1, a matrix 2, ragged depth taken as the max).
+  r.derive("rank", 1, ["rank", "depth", "ndim"], (args) => {
+    const rank = (v) => {
+      if (!isNd(v)) {
+        return 0n;
+      }
+      let m = 0n;
+      for (const e of v.items) {
+        const rr = rank(e);
+        if (rr > m) {
+          m = rr;
         }
-        for (let i = start; i < xs.length; i++)
-            acc = ctx.apply(f, [acc, xs[i]]);
-        return acc;
-    }, { structural: true });
-    // find(xs, p): the FIRST element satisfying the unary predicate p, or the
-    // empty nd when none does (a graph-evidenced "nothing matched", never a guess).
-    r.derive("find", 2, ["find", "first", "search"], (args, ctx) => {
-        const xs = listOf(args[0]);
-        const p = resolveFn(ctx, args[1], 1);
-        for (const e of xs)
-            if (asBit(ctx.apply(p, [e])) === 1)
-                return e;
-        return nd([]);
-    }, { structural: true });
-    // ── derived: shape-preserving plumbing ────────────────────────────────────
-    // concat(a, b, …): join lists end to end into one list.
-    r.derive("concat", "variadic", ["concat", "append", "join"], (args) => {
-        const out = [];
-        for (const a of args)
-            for (const e of listOf(a))
-                out.push(e);
-        return nd(out);
-    }, { structural: true });
-    // reverse(xs): the list back to front.
-    r.derive("reverse", 1, ["reverse", "flip"], (args) => nd(listOf(args[0]).slice().reverse()), { structural: true });
-    // flatten(xs): splice one level — each nd element is spliced in, each scalar
-    // kept.  flatten ∘ flatten goes deeper; one level is the primitive step.
-    r.derive("flatten", 1, ["flatten", "flat"], (args) => {
-        const out = [];
-        for (const e of listOf(args[0])) {
-            if (isNd(e)) {
-                for (const sub of e.items)
-                    out.push(sub);
-            }
-            else
-                out.push(e);
-        }
-        return nd(out);
-    }, { structural: true });
-    // zip(a, b, …): the lists braided into a list of tuples; length = the shortest
-    // input (a ragged braid stops at the short one, never inventing elements).
-    r.derive("zip", "variadic", ["zip", "braid"], (args) => {
-        const lists = args.map(listOf);
-        if (lists.length === 0)
-            return nd([]);
-        const m = Math.min(...lists.map((l) => l.length));
-        const out = [];
-        for (let i = 0; i < m; i++)
-            out.push(nd(lists.map((l) => l[i])));
-        return nd(out);
-    }, { structural: true });
-    // rank(v): the nesting DEPTH — 0 for a scalar, 1 + the deepest element's rank
-    // for a list (so a vector is 1, a matrix 2, ragged depth taken as the max).
-    r.derive("rank", 1, ["rank", "depth", "ndim"], (args) => {
-        const rank = (v) => {
-            if (!isNd(v))
-                return 0n;
-            let m = 0n;
-            for (const e of v.items) {
-                const rr = rank(e);
-                if (rr > m)
-                    m = rr;
-            }
-            return m + 1n;
-        };
-        return int(rank(args[0]));
-    }, { structural: true });
-    // shape(v): the size along each axis, following the FIRST element down — the
-    // regular-tensor shape (a ragged list is reported by its top length, the
-    // recursion only descending the head).  Returns a list of ints.
-    r.derive("shape", 1, ["shape", "dims"], (args) => {
-        const dims = [];
-        let cur = args[0];
-        while (isNd(cur)) {
-            dims.push(int(BigInt(cur.items.length)));
-            if (cur.items.length === 0)
-                break;
-            cur = cur.items[0];
-        }
-        return nd(dims);
-    }, { structural: true });
+      }
+      return m + 1n;
+    };
+    return int(rank(args[0]));
+  }, { structural: true });
+  // shape(v): the size along each axis, following the FIRST element down — the
+  // regular-tensor shape (a ragged list is reported by its top length, the
+  // recursion only descending the head).  Returns a list of ints.
+  r.derive("shape", 1, ["shape", "dims"], (args) => {
+    const dims = [];
+    let cur = args[0];
+    while (isNd(cur)) {
+      dims.push(int(BigInt(cur.items.length)));
+      if (cur.items.length === 0) {
+        break;
+      }
+      cur = cur.items[0];
+    }
+    return nd(dims);
+  }, { structural: true });
 }

package/dist/src/alu/src/kernel-numeric.d.ts

@@ -3,51 +3,115 @@ import type { OperationRegistry } from "./operation.js";
  *  agree within `tol` (absolute, or relative for large magnitudes), or until
  *  `maxIter` is reached.  Returns the last iterate — the refinement's fixed
  *  point.  This is the single irreducible operator of the numerical layer. */
-export declare function converge(step: (x: number) => number, x0: number, tol: number, maxIter: number): number;
+export declare function converge(
+  step: (x: number) => number,
+  x0: number,
+  tol: number,
+  maxIter: number,
+): number;
 /** Numerical derivative f′(a) by a central difference refined as h → 0 — a
  *  `converge` instance over shrinking step sizes (Richardson-style halving). */
-export declare function diff(f: (x: number) => number, a: number, tol: number, maxIter: number): number;
+export declare function diff(
+  f: (x: number) => number,
+  a: number,
+  tol: number,
+  maxIter: number,
+): number;
 /** A root of f near x0, by Newton's method: converge x − f(x)/f′(x), with f′
  *  from {@link diff}.  Falls back to a secant step if the derivative vanishes. */
-export declare function solve(f: (x: number) => number, x0: number, tol: number, maxIter: number): number;
+export declare function solve(
+  f: (x: number) => number,
+  x0: number,
+  tol: number,
+  maxIter: number,
+): number;
 /** Definite integral of f over [a, b], by composite Simpson refined until the
  *  estimate stops moving — a `converge` over partition count. */
-export declare function integrate(f: (x: number) => number, a: number, b: number, tol: number, maxIter: number): number;
+export declare function integrate(
+  f: (x: number) => number,
+  a: number,
+  b: number,
+  tol: number,
+  maxIter: number,
+): number;
 /** e^x by its Taylor series, summed until a term is below tolerance — a
  *  `converge` over partial sums.  (Range-reduction-free; adequate for the
  *  arguments a query produces, and exact in the limit.) */
-export declare function expSeries(x: number, tol: number, maxIter: number): number;
+export declare function expSeries(
+  x: number,
+  tol: number,
+  maxIter: number,
+): number;
 /** ln(x), x > 0, as the root of e^t − x = 0 (Newton via {@link solve}, with a
  *  good initial guess from the host log to keep iteration counts low). */
-export declare function logNewton(x: number, tol: number, maxIter: number): number;
+export declare function logNewton(
+  x: number,
+  tol: number,
+  maxIter: number,
+): number;
 /** sin / cos by their Taylor series (a `converge` over partial sums), with
  *  argument reduction into [−π, π] for accuracy. */
-export declare function sinSeries(x: number, tol: number, maxIter: number): number;
-export declare function cosSeries(x: number, tol: number, maxIter: number): number;
+export declare function sinSeries(
+  x: number,
+  tol: number,
+  maxIter: number,
+): number;
+export declare function cosSeries(
+  x: number,
+  tol: number,
+  maxIter: number,
+): number;
 /** √x as the positive root of t² − x = 0 (Newton via {@link solve}). */
-export declare function sqrtNewton(x: number, tol: number, maxIter: number): number;
+export declare function sqrtNewton(
+  x: number,
+  tol: number,
+  maxIter: number,
+): number;
 /** A local minimum of f near x0: a root of f′ = 0 (optimize = solve(diff f)). */
-export declare function optimize(f: (x: number) => number, x0: number, tol: number, maxIter: number): number;
+export declare function optimize(
+  f: (x: number) => number,
+  x0: number,
+  tol: number,
+  maxIter: number,
+): number;
 /** Integrate an ODE y′ = f(t, y) from (t0, y0) to t1 by classical RK4 stepping
  *  — explicit stepping is the layer's other use of refinement (here a fixed
  *  fine step; an implicit step would close with {@link solve}). */
-export declare function odeSolve(f: (t: number, y: number) => number, t0: number, y0: number, t1: number, steps?: number): number;
+export declare function odeSolve(
+  f: (t: number, y: number) => number,
+  t0: number,
+  y0: number,
+  t1: number,
+  steps?: number,
+): number;
 /** Least-squares polynomial regression of degree `deg` over (x, y) samples:
  *  build the normal equations and solve them with {@link linsolve} — regression
  *  reduces to structured arithmetic.  Returns coefficients constant-first. */
-export declare function regress(xs: number[], ys: number[], deg: number): number[] | null;
+export declare function regress(
+  xs: number[],
+  ys: number[],
+  deg: number,
+): number[] | null;
 /** Linear interpolation of y at `xq` over sorted sample points (xs, ys). */
-export declare function interpolate(xs: number[], ys: number[], xq: number): number;
+export declare function interpolate(
+  xs: number[],
+  ys: number[],
+  xq: number,
+): number;
 /** Dominant eigenpair of a (preferably symmetric) matrix by POWER ITERATION —
  *  the canonical "iteration = converge" of this layer.  Returns the eigenvalue
  *  (Rayleigh quotient) and its unit eigenvector. */
 export declare function powerEig(A: number[][], tol: number, maxIter: number): {
-    value: number;
-    vector: number[];
+  value: number;
+  vector: number[];
 };
 /** Largest singular value of A: √(dominant eigenvalue of AᵀA) — power iteration
  *  again, the prototypical `converge`. */
-export declare function topSingular(A: number[][], tol: number, maxIter: number): number;
+export declare function topSingular(
+  A: number[][],
+  tol: number,
+  maxIter: number,
+): number;
 /** Register the scalar transcendentals as ops (they have surface forms).  The
  *  matrix routines stay exported functions — there is no infix surface for a
  *  matrix, and auto-firing them from query spans is neither wanted nor safe. */