@hviana/sema 0.1.5 → 0.1.6

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

@@ -39,210 +39,170 @@ 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");
-      }
-      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");
+    // ── 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");
         }
-        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);
+        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 {
-        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;
+        else {
+            if (xs.length === 0)
+                throw new Error("reduce: empty list, no seed");
+            acc = xs[0];
+            start = 1;
         }
-      }
-      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 });
+        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 });
 }

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

@@ -3,115 +3,51 @@ 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. */