@hviana/sema 0.1.5 → 0.1.7

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

@@ -23,164 +23,130 @@ import { asInt, bit, int } from "./value.js";
  *  Width is chosen by the caller wide enough that the signed result cannot
  *  overflow, so interpreting the top bit as the sign is always correct. */
 function toBits(n, width) {
-  const mod = 1n << BigInt(width);
-  let u = ((n % mod) + mod) % mod; // two's-complement representation
-  const bits = new Array(width);
-  for (let i = 0; i < width; i++) {
-    bits[i] = Number(u & 1n);
-    u >>= 1n;
-  }
-  return bits;
+    const mod = 1n << BigInt(width);
+    let u = ((n % mod) + mod) % mod; // two's-complement representation
+    const bits = new Array(width);
+    for (let i = 0; i < width; i++) {
+        bits[i] = Number(u & 1n);
+        u >>= 1n;
+    }
+    return bits;
 }
 /** Interpret a two's-complement little-endian bit array as a signed bigint. */
 function fromBits(bits) {
-  const width = bits.length;
-  let u = 0n;
-  for (let i = 0; i < width; i++) {
-    if (bits[i]) {
-      u |= 1n << BigInt(i);
-    }
-  }
-  const signBitSet = bits[width - 1] === 1;
-  return signBitSet ? u - (1n << BigInt(width)) : u;
+    const width = bits.length;
+    let u = 0n;
+    for (let i = 0; i < width; i++)
+        if (bits[i])
+            u |= 1n << BigInt(i);
+    const signBitSet = bits[width - 1] === 1;
+    return signBitSet ? u - (1n << BigInt(width)) : u;
 }
 /** Bits needed to hold |n| (at least 1). */
 function magnitudeBits(n) {
-  const a = n < 0n ? -n : n;
-  return a === 0n ? 1 : a.toString(2).length;
+    const a = n < 0n ? -n : n;
+    return a === 0n ? 1 : a.toString(2).length;
 }
 /** A single full adder built from the logic gates: sum = a⊕b⊕cin, carry =
  *  (a∧b) ∨ (cin ∧ (a⊕b)).  Every gate goes through ctx.apply → nand. */
 function fullAdder(ctx, a, b, cin) {
-  const A = bit(a), B = bit(b), C = bit(cin);
-  const axb = ctx.apply("xor", [A, B]);
-  const sum = ctx.apply("xor", [axb, C]);
-  const cout = ctx.apply("or", [
-    ctx.apply("and", [A, B]),
-    ctx.apply("and", [C, axb]),
-  ]);
-  return {
-    sum: sum.domain === "bit" ? sum.b : 0,
-    cout: cout.domain === "bit" ? cout.b : 0,
-  };
+    const A = bit(a), B = bit(b), C = bit(cin);
+    const axb = ctx.apply("xor", [A, B]);
+    const sum = ctx.apply("xor", [axb, C]);
+    const cout = ctx.apply("or", [
+        ctx.apply("and", [A, B]),
+        ctx.apply("and", [C, axb]),
+    ]);
+    return {
+        sum: sum.domain === "bit" ? sum.b : 0,
+        cout: cout.domain === "bit" ? cout.b : 0,
+    };
 }
 /** Ripple-carry add of two two's-complement bit arrays (equal width). */
 function rippleAdd(ctx, x, y) {
-  const width = x.length;
-  const out = new Array(width);
-  let carry = 0;
-  for (let i = 0; i < width; i++) {
-    const { sum, cout } = fullAdder(ctx, x[i], y[i], carry);
-    out[i] = sum;
-    carry = cout;
-  }
-  return out;
+    const width = x.length;
+    const out = new Array(width);
+    let carry = 0;
+    for (let i = 0; i < width; i++) {
+        const { sum, cout } = fullAdder(ctx, x[i], y[i], carry);
+        out[i] = sum;
+        carry = cout;
+    }
+    return out;
 }
 /** Bitwise NOT of a bit array, via the not gate. */
 function notBits(ctx, x) {
-  return x.map((b) => {
-    const r = ctx.apply("not", [bit(b)]);
-    return (r.domain === "bit" ? r.b : 0);
-  });
+    return x.map((b) => {
+        const r = ctx.apply("not", [bit(b)]);
+        return (r.domain === "bit" ? r.b : 0);
+    });
 }
 /** Two's-complement negate: invert every bit, then add one. */
 function negateBitsArr(ctx, x) {
-  const width = x.length;
-  const one = toBits(1n, width);
-  return rippleAdd(ctx, notBits(ctx, x), one);
+    const width = x.length;
+    const one = toBits(1n, width);
+    return rippleAdd(ctx, notBits(ctx, x), one);
 }
 // ── public pure functions (used by the tests and the explicit ops) ──────────
 /** Exact addition through the ripple of full_adders. */
 export function addBits(ctx, a, b) {
-  const width = Math.max(magnitudeBits(a), magnitudeBits(b)) + 2;
-  return fromBits(rippleAdd(ctx, toBits(a, width), toBits(b, width)));
+    const width = Math.max(magnitudeBits(a), magnitudeBits(b)) + 2;
+    return fromBits(rippleAdd(ctx, toBits(a, width), toBits(b, width)));
 }
 /** Exact two's-complement negation. */
 export function negateBits(ctx, a) {
-  const width = magnitudeBits(a) + 2;
-  return fromBits(negateBitsArr(ctx, toBits(a, width)));
+    const width = magnitudeBits(a) + 2;
+    return fromBits(negateBitsArr(ctx, toBits(a, width)));
 }
 /** Exact shift-add multiplication: for each set bit i of b, add (a << i) to the
  *  accumulator.  The per-bit gate is an AND mask of the shifted a with bᵢ; the
  *  accumulation is rippleAdd — so multiply traces entirely to nand. */
 export function mulBits(ctx, a, b) {
-  const width = magnitudeBits(a) + magnitudeBits(b) + 2;
-  const aBits = toBits(a, width);
-  const bBits = toBits(b, width);
-  let acc = toBits(0n, width);
-  for (let i = 0; i < width; i++) {
-    if (bBits[i] === 0) {
-      continue;
-    }
-    // a shifted left by i (within width), masked by bᵢ (= 1 here).
-    const shifted = new Array(width);
-    for (let k = 0; k < width; k++) {
-      const src = k - i >= 0 ? aBits[k - i] : 0;
-      const m = ctx.apply("and", [bit(src), bit(bBits[i])]);
-      shifted[k] = m.domain === "bit" ? m.b : 0;
+    const width = magnitudeBits(a) + magnitudeBits(b) + 2;
+    const aBits = toBits(a, width);
+    const bBits = toBits(b, width);
+    let acc = toBits(0n, width);
+    for (let i = 0; i < width; i++) {
+        if (bBits[i] === 0)
+            continue;
+        // a shifted left by i (within width), masked by bᵢ (= 1 here).
+        const shifted = new Array(width);
+        for (let k = 0; k < width; k++) {
+            const src = k - i >= 0 ? aBits[k - i] : 0;
+            const m = ctx.apply("and", [bit(src), bit(bBits[i])]);
+            shifted[k] = (m.domain === "bit" ? m.b : 0);
+        }
+        acc = rippleAdd(ctx, acc, shifted);
     }
-    acc = rippleAdd(ctx, acc, shifted);
-  }
-  return fromBits(acc);
+    return fromBits(acc);
 }
 /** Sign of an integer as {-1, 0, 1}: zero when every bit is zero, −1 when the
  *  two's-complement sign bit is set, +1 otherwise — read off the bit array. */
 export function signBits(ctx, a) {
-  if (a === 0n) {
-    return 0n;
-  }
-  const width = magnitudeBits(a) + 2;
-  const bits = toBits(a, width);
-  return bits[width - 1] === 1 ? -1n : 1n;
+    if (a === 0n)
+        return 0n;
+    const width = magnitudeBits(a) + 2;
+    const bits = toBits(a, width);
+    return bits[width - 1] === 1 ? -1n : 1n;
 }
 /** Compare via sign(subtract): −1 if a<b, 0 if a=b, +1 if a>b, where subtract is
  *  add ∘ negate — so comparison is structured arithmetic, not a new primitive. */
 export function compareBits(ctx, a, b) {
-  return signBits(ctx, addBits(ctx, a, negateBits(ctx, b)));
+    return signBits(ctx, addBits(ctx, a, negateBits(ctx, b)));
 }
 /** Register the bit-bootstrap ops (int domain) into `r`.  They have no surface
  *  forms — they are an internal exhibit, exercised by the tests and by anyone
  *  who wants to walk the nand→arithmetic chain, not matched from a query. */
 export function registerBits(r) {
-  // full_adder exposed as a 3-bit op returning the 2-bit {sum, carry} as an int
-  // 0..3 (carry in bit 1, sum in bit 0) so it is callable/testable on its own.
-  r.derive("bits.fullAdder", 3, [], (args, ctx) => {
-    const s = fullAdder(
-      ctx,
-      asInt(args[0]) === 0n ? 0 : 1,
-      asInt(args[1]) === 0n ? 0 : 1,
-      asInt(args[2]) === 0n ? 0 : 1,
-    );
-    return int(BigInt(s.sum) | (BigInt(s.cout) << 1n));
-  });
-  r.derive(
-    "bits.add",
-    2,
-    [],
-    (args, ctx) => int(addBits(ctx, asInt(args[0]), asInt(args[1]))),
-  );
-  r.derive(
-    "bits.negate",
-    1,
-    [],
-    (args, ctx) => int(negateBits(ctx, asInt(args[0]))),
-  );
-  r.derive(
-    "bits.multiply",
-    2,
-    [],
-    (args, ctx) => int(mulBits(ctx, asInt(args[0]), asInt(args[1]))),
-  );
-  r.derive(
-    "bits.sign",
-    1,
-    [],
-    (args, ctx) => int(signBits(ctx, asInt(args[0]))),
-  );
-  r.derive(
-    "bits.compare",
-    2,
-    [],
-    (args, ctx) => int(compareBits(ctx, asInt(args[0]), asInt(args[1]))),
-  );
+    // full_adder exposed as a 3-bit op returning the 2-bit {sum, carry} as an int
+    // 0..3 (carry in bit 1, sum in bit 0) so it is callable/testable on its own.
+    r.derive("bits.fullAdder", 3, [], (args, ctx) => {
+        const s = fullAdder(ctx, asInt(args[0]) === 0n ? 0 : 1, asInt(args[1]) === 0n ? 0 : 1, asInt(args[2]) === 0n ? 0 : 1);
+        return int(BigInt(s.sum) | (BigInt(s.cout) << 1n));
+    });
+    r.derive("bits.add", 2, [], (args, ctx) => int(addBits(ctx, asInt(args[0]), asInt(args[1]))));
+    r.derive("bits.negate", 1, [], (args, ctx) => int(negateBits(ctx, asInt(args[0]))));
+    r.derive("bits.multiply", 2, [], (args, ctx) => int(mulBits(ctx, asInt(args[0]), asInt(args[1]))));
+    r.derive("bits.sign", 1, [], (args, ctx) => int(signBits(ctx, asInt(args[0]))));
+    r.derive("bits.compare", 2, [], (args, ctx) => int(compareBits(ctx, asInt(args[0]), asInt(args[1]))));
 }

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

@@ -24,67 +24,37 @@ import { asBit, bit } from "./value.js";
 /** Register the logic layer into `r`.  Idempotent in effect (re-registering
  *  overwrites with the same definitions). */
 export function registerLogic(r) {
-  // The one irreducible gate.  ¬(a ∧ b).
-  r.prim("nand", 2, [], (args) => {
-    const a = asBit(args[0]);
-    const b = asBit(args[1]);
-    return bit(a & b ? 0 : 1);
-  });
-  // Exposed-but-derived basic gates.
-  r.derive(
-    "not",
-    1,
-    ["not", "!", "~", "¬"],
-    (args, ctx) => ctx.apply("nand", [args[0], args[0]]),
-  );
-  r.derive(
-    "and",
-    2,
-    ["and", "&", "&&", "∧"],
-    (args, ctx) => ctx.apply("not", [ctx.apply("nand", [args[0], args[1]])]),
-  );
-  r.derive("or", 2, ["or", "|", "||", "∨"], (args, ctx) => {
-    const na = ctx.apply("not", [args[0]]);
-    const nb = ctx.apply("not", [args[1]]);
-    return ctx.apply("nand", [na, nb]);
-  });
-  // Fully derived gates.
-  r.derive(
-    "nor",
-    2,
-    ["nor", "⊽"],
-    (args, ctx) => ctx.apply("not", [ctx.apply("or", [args[0], args[1]])]),
-  );
-  r.derive("xor", 2, ["xor", "^", "⊕"], (args, ctx) => {
-    const a = args[0], b = args[1];
-    const left = ctx.apply("and", [a, ctx.apply("not", [b])]);
-    const right = ctx.apply("and", [ctx.apply("not", [a]), b]);
-    return ctx.apply("or", [left, right]);
-  });
-  r.derive(
-    "xnor",
-    2,
-    ["xnor", "⊙"],
-    (args, ctx) => ctx.apply("not", [ctx.apply("xor", [args[0], args[1]])]),
-  );
-  r.derive(
-    "implies",
-    2,
-    ["implies", "=>", "→", "⇒"],
-    (args, ctx) => ctx.apply("or", [ctx.apply("not", [args[0]]), args[1]]),
-  );
-  r.derive(
-    "iff",
-    2,
-    ["iff", "<=>", "↔", "⇔"],
-    (args, ctx) => ctx.apply("xnor", [args[0], args[1]]),
-  );
-  // mux(s, a, b): select a when s = 0, b when s = 1.  The bridge to control
-  // flow — conditional selection, and (with recursion in the caller) looping.
-  r.derive("mux", 3, ["mux", "select", "?:"], (args, ctx) => {
-    const s = args[0], a = args[1], b = args[2];
-    const lo = ctx.apply("and", [ctx.apply("not", [s]), a]);
-    const hi = ctx.apply("and", [s, b]);
-    return ctx.apply("or", [lo, hi]);
-  });
+    // The one irreducible gate.  ¬(a ∧ b).
+    r.prim("nand", 2, [], (args) => {
+        const a = asBit(args[0]);
+        const b = asBit(args[1]);
+        return bit(a & b ? 0 : 1);
+    });
+    // Exposed-but-derived basic gates.
+    r.derive("not", 1, ["not", "!", "~", "¬"], (args, ctx) => ctx.apply("nand", [args[0], args[0]]));
+    r.derive("and", 2, ["and", "&", "&&", "∧"], (args, ctx) => ctx.apply("not", [ctx.apply("nand", [args[0], args[1]])]));
+    r.derive("or", 2, ["or", "|", "||", "∨"], (args, ctx) => {
+        const na = ctx.apply("not", [args[0]]);
+        const nb = ctx.apply("not", [args[1]]);
+        return ctx.apply("nand", [na, nb]);
+    });
+    // Fully derived gates.
+    r.derive("nor", 2, ["nor", "⊽"], (args, ctx) => ctx.apply("not", [ctx.apply("or", [args[0], args[1]])]));
+    r.derive("xor", 2, ["xor", "^", "⊕"], (args, ctx) => {
+        const a = args[0], b = args[1];
+        const left = ctx.apply("and", [a, ctx.apply("not", [b])]);
+        const right = ctx.apply("and", [ctx.apply("not", [a]), b]);
+        return ctx.apply("or", [left, right]);
+    });
+    r.derive("xnor", 2, ["xnor", "⊙"], (args, ctx) => ctx.apply("not", [ctx.apply("xor", [args[0], args[1]])]));
+    r.derive("implies", 2, ["implies", "=>", "→", "⇒"], (args, ctx) => ctx.apply("or", [ctx.apply("not", [args[0]]), args[1]]));
+    r.derive("iff", 2, ["iff", "<=>", "↔", "⇔"], (args, ctx) => ctx.apply("xnor", [args[0], args[1]]));
+    // mux(s, a, b): select a when s = 0, b when s = 1.  The bridge to control
+    // flow — conditional selection, and (with recursion in the caller) looping.
+    r.derive("mux", 3, ["mux", "select", "?:"], (args, ctx) => {
+        const s = args[0], a = args[1], b = args[2];
+        const lo = ctx.apply("and", [ctx.apply("not", [s]), a]);
+        const hi = ctx.apply("and", [s, b]);
+        return ctx.apply("or", [lo, hi]);
+    });
 }