eyeling 1.19.4 → 1.19.6

package/examples/extra/pn-junction-tunneling.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Toy PN-junction tunneling model expressed as overlap counts between discrete energy levels.
+ * The curve is small enough to inspect directly, so the checks focus on the peak and negative differential region.
+ */
+
+const N_FILLED = [1, 2, 3, 4];
+const P_EMPTY_ZERO_BIAS = [3, 4, 5, 6];
+const BIAS_POINTS = [0, 1, 2, 3, 4, 5, 6];
+
+function overlapCount(lhs, rhs) {
+  let count = 0;
+  for (const left of lhs) {
+    for (const right of rhs) {
+      if (left === right) {
+        count += 1;
+        break;
+      }
+    }
+  }
+  return count;
+}
+
+// Shift the P-side levels across the bias points and record the overlap curve.
+function main() {
+  const curve = [];
+  let peakIndex = 0;
+
+  for (let i = 0; i < BIAS_POINTS.length; i += 1) {
+    const shifted = P_EMPTY_ZERO_BIAS.map((value) => value - BIAS_POINTS[i]);
+    curve[i] = overlapCount(N_FILLED, shifted);
+    if (curve[i] > curve[peakIndex]) peakIndex = i;
+  }
+
+  const valleyIndex = 6;
+  const barrierNarrower = 1 < 8;
+  const peakBeforeValley = peakIndex < valleyIndex;
+  let negativeDifferential = false;
+  for (let i = peakIndex; i < 6; i += 1) if (curve[i + 1] < curve[i]) negativeDifferential = true;
+  const overlapCloses = curve[valleyIndex] === 0;
+  const fullOverlapPeak = curve[peakIndex] === 4;
+  const ok = barrierNarrower && peakBeforeValley && negativeDifferential && overlapCloses && fullOverlapPeak;
+
+  const lines = [];
+  lines.push('=== Answer ===');
+  lines.push(
+    'In this toy PN-junction tunneling model, heavy doping narrows the depletion region enough for a tunneling window that rises to a peak and then falls.',
+  );
+  lines.push('');
+  lines.push('=== Reason Why ===');
+  lines.push('We count exact state overlap while forward bias shifts the empty P-side levels.');
+  lines.push(`bias -> overlap current proxy : ${BIAS_POINTS.map((bias, i) => `${bias}->${curve[i]}`).join(', ')}`);
+  lines.push(`peak point                    : ${BIAS_POINTS[peakIndex]} -> ${curve[peakIndex]}`);
+  lines.push(`high-bias point               : ${BIAS_POINTS[valleyIndex]} -> ${curve[valleyIndex]}`);
+  lines.push('');
+  lines.push('=== Check ===');
+  lines.push(`heavily doped barrier is narrower : ${barrierNarrower ? 'yes' : 'no'}`);
+  lines.push(`peak occurs before overlap closes : ${peakBeforeValley ? 'yes' : 'no'}`);
+  lines.push(`negative differential region      : ${negativeDifferential ? 'yes' : 'no'}`);
+  lines.push(`high-bias overlap closes          : ${overlapCloses ? 'yes' : 'no'}`);
+  lines.push(`peak equals full overlap          : ${fullOverlapPeak ? 'yes' : 'no'}`);
+
+  process.stdout.write(`${lines.join('\n')}\n`);
+  process.exit(ok ? 0 : 1);
+}
+
+main();

package/examples/extra/polynomial.js

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Polynomial case with lightweight complex arithmetic and numerical root finding.
+ * The result is checked both by evaluating the polynomial at the roots and by reconstructing the coefficients.
+ */
+
+const ROOT_TOL = 1e-10;
+const COEFF_TOL = 1e-8;
+const MAX_ITER = 200;
+
+function cx(re, im) {
+  return { re, im };
+}
+function add(a, b) {
+  return cx(a.re + b.re, a.im + b.im);
+}
+function sub(a, b) {
+  return cx(a.re - b.re, a.im - b.im);
+}
+function mul(a, b) {
+  return cx(a.re * b.re - a.im * b.im, a.re * b.im + a.im * b.re);
+}
+function divcx(a, b) {
+  const s = b.re * b.re + b.im * b.im;
+  return cx((a.re * b.re + a.im * b.im) / s, (a.im * b.re - a.re * b.im) / s);
+}
+function abscx(a) {
+  return Math.hypot(a.re, a.im);
+}
+function powu(a, e) {
+  let out = cx(1, 0);
+  for (let i = 0; i < e; i += 1) out = mul(out, a);
+  return out;
+}
+function dist(a, b) {
+  return abscx(sub(a, b));
+}
+function evalPoly(coeffs, x) {
+  let acc = cx(0, 0);
+  for (const coeff of coeffs) acc = add(mul(acc, x), coeff);
+  return acc;
+}
+function multiplyPolys(left, right) {
+  const out = new Array(left.length + right.length - 1).fill(null).map(() => cx(0, 0));
+  for (let i = 0; i < left.length; i += 1) {
+    for (let j = 0; j < right.length; j += 1) {
+      out[i + j] = add(out[i + j], mul(left[i], right[j]));
+    }
+  }
+  return out;
+}
+// Durand-Kerner-style iteration on a monic copy of the polynomial.
+function rootsFromCoeffs(coeffs) {
+  const degree = coeffs.length - 1;
+  const monic = [];
+  const lead = coeffs[0];
+  let radius = 1.0;
+  for (let i = 0; i < coeffs.length; i += 1) {
+    monic[i] = divcx(coeffs[i], lead);
+    if (i > 0) {
+      const a = abscx(monic[i]);
+      if (a > radius - 1.0) radius = 1.0 + a;
+    }
+  }
+  const seed = cx(0.4, 0.9);
+  const roots = [];
+  for (let i = 0; i < degree; i += 1) roots[i] = mul(powu(seed, i), cx(radius, 0));
+
+  for (let iter = 0; iter < MAX_ITER; iter += 1) {
+    let maxDelta = 0.0;
+    for (let i = 0; i < degree; i += 1) {
+      let denom = cx(1, 0);
+      for (let j = 0; j < degree; j += 1) {
+        if (j !== i) denom = mul(denom, sub(roots[i], roots[j]));
+      }
+      if (abscx(denom) < 1e-18) denom = add(denom, cx(1e-12, 1e-12));
+      const delta = divcx(evalPoly(monic, roots[i]), denom);
+      roots[i] = sub(roots[i], delta);
+      const a = abscx(delta);
+      if (a > maxDelta) maxDelta = a;
+    }
+    if (maxDelta < ROOT_TOL) break;
+  }
+
+  return roots;
+}
+function sortRoots(roots) {
+  for (let i = 0; i < roots.length; i += 1) {
+    for (let j = i + 1; j < roots.length; j += 1) {
+      const leftReal = Math.abs(roots[i].im) < 1e-8;
+      const rightReal = Math.abs(roots[j].im) < 1e-8;
+      let swap = false;
+      if (leftReal && rightReal) swap = roots[j].re > roots[i].re;
+      else if (!leftReal && rightReal) swap = false;
+      else if (leftReal && !rightReal) swap = true;
+      else if (roots[j].im > roots[i].im || (Math.abs(roots[j].im - roots[i].im) < 1e-8 && roots[j].re > roots[i].re))
+        swap = true;
+      if (swap) {
+        const t = roots[i];
+        roots[i] = roots[j];
+        roots[j] = t;
+      }
+    }
+  }
+}
+function fmtG(value) {
+  const v = Math.abs(value) < 1e-8 ? 0 : value;
+  if (v === 0) return '0';
+  const s = Number(v).toPrecision(10);
+  return s
+    .replace(/(?:\.0+|(\.\d*?[1-9])0+)(e|$)/, '$1$2')
+    .replace(/\.0+$/, '')
+    .replace(/e\+?/, 'e');
+}
+function printCx(z) {
+  const re = Math.abs(z.re) < 1e-8 ? 0 : z.re;
+  const im = Math.abs(z.im) < 1e-8 ? 0 : z.im;
+  if (im === 0) return fmtG(re);
+  if (re === 0) return `${fmtG(im)}i`;
+  return `${fmtG(re)} ${im >= 0 ? '+' : '-'} ${fmtG(Math.abs(im))}i`;
+}
+
+// Solve, reconstruct, and validate the polynomial in three complementary ways.
+// Build the final ARC-style report and exit non-zero if a check fails.
+function main() {
+  const cases = [
+    [cx(1, 0), cx(-10, 0), cx(35, 0), cx(-50, 0), cx(24, 0)],
+    [cx(1, 0), cx(-9, -5), cx(14, 33), cx(24, -44), cx(-26, 0)],
+  ];
+  const labels = ['real quartic', 'complex quartic'];
+  let allOk = true;
+
+  const lines = [];
+  lines.push('=== Answer ===');
+  lines.push(
+    'Both polynomial examples are solved consistently: the computed roots satisfy the source polynomials and reconstruct the original coefficients.',
+  );
+  lines.push('');
+  lines.push('=== Reason Why ===');
+  lines.push(
+    'For each quartic, the program solves for the roots numerically, substitutes them back, and rebuilds the polynomial from those roots.',
+  );
+  for (let c = 0; c < 2; c += 1) {
+    const roots = rootsFromCoeffs(cases[c]);
+    sortRoots(roots);
+    const coeffs1 = [cx(1, 0), sub(cx(0, 0), roots[0])];
+    const coeffs2 = [cx(1, 0), sub(cx(0, 0), roots[1])];
+    const coeffs3 = [cx(1, 0), sub(cx(0, 0), roots[2])];
+    const coeffs4 = [cx(1, 0), sub(cx(0, 0), roots[3])];
+    const tmp1 = multiplyPolys(coeffs1, coeffs2);
+    const tmp2 = multiplyPolys(tmp1, coeffs3);
+    const rebuilt = multiplyPolys(tmp2, coeffs4);
+    let rootsValid = true;
+    let rebuildOk = true;
+    const residuals = [];
+    for (let i = 0; i < 4; i += 1) {
+      residuals[i] = evalPoly(cases[c], roots[i]);
+      if (abscx(residuals[i]) > 1e-6) rootsValid = false;
+    }
+    for (let i = 0; i < 5; i += 1) {
+      if (dist(rebuilt[i], cases[c][i]) > COEFF_TOL) rebuildOk = false;
+    }
+    allOk &&= rootsValid && rebuildOk;
+    lines.push('');
+    lines.push(`Example #${c + 1} (${labels[c]})`);
+    lines.push(`roots               : ${roots.map(printCx).join(', ')}`);
+    lines.push(`residuals           : ${residuals.map(printCx).join(', ')}`);
+    lines.push(`reconstruction ok   : ${rebuildOk ? 'yes' : 'no'}`);
+    lines.push(`roots valid         : ${rootsValid ? 'yes' : 'no'}`);
+  }
+  lines.push('');
+  lines.push('=== Check ===');
+  lines.push(`all examples valid  : ${allOk ? 'yes' : 'no'}`);
+
+  process.stdout.write(`${lines.join('\n')}\n`);
+  process.exit(allOk ? 0 : 1);
+}
+
+main();

package/examples/extra/sudoku.js

@@ -0,0 +1,330 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Sudoku solver specialized to a single-file search-and-propagation implementation.
+ * The state keeps row, column, and box usage bitmasks so constraints can be checked quickly.
+ */
+
+const ALL_MASK = 0x1ff;
+const DEFAULT_PUZZLE = '100007090030020008009600500005300900010080002600004000300000010040000007007000300';
+
+function popcount16(x) {
+  let c = 0;
+  while (x) {
+    x &= x - 1;
+    c += 1;
+  }
+  return c;
+}
+
+function digitMask(d) {
+  return 1 << (d - 1);
+}
+
+function boxIndex(r, c) {
+  return Math.floor(r / 3) * 3 + Math.floor(c / 3);
+}
+
+function pushMove(state, move) {
+  state.moves.push(move);
+}
+
+function cloneState(src) {
+  return {
+    cells: src.cells.slice(),
+    rowUsed: src.rowUsed.slice(),
+    colUsed: src.colUsed.slice(),
+    boxUsed: src.boxUsed.slice(),
+    moves: src.moves.map((move) => ({ ...move })),
+  };
+}
+
+function place(state, idx, value) {
+  if (state.cells[idx] !== 0) return state.cells[idx] === value;
+  const r = Math.floor(idx / 9);
+  const c = idx % 9;
+  const b = boxIndex(r, c);
+  const bit = digitMask(value);
+  if ((state.rowUsed[r] | state.colUsed[c] | state.boxUsed[b]) & bit) return false;
+  state.cells[idx] = value;
+  state.rowUsed[r] |= bit;
+  state.colUsed[c] |= bit;
+  state.boxUsed[b] |= bit;
+  return true;
+}
+
+function candidates(state, idx) {
+  const r = Math.floor(idx / 9);
+  const c = idx % 9;
+  const b = boxIndex(r, c);
+  return ALL_MASK & ~(state.rowUsed[r] | state.colUsed[c] | state.boxUsed[b]);
+}
+
+function parsePuzzle(text) {
+  if (text.length !== 81) return null;
+  const out = new Array(81).fill(0);
+  for (let i = 0; i < 81; i += 1) {
+    const ch = text[i];
+    if (ch >= '1' && ch <= '9') out[i] = ch.charCodeAt(0) - 48;
+    else if (ch === '0' || ch === '.' || ch === '_') out[i] = 0;
+    else return null;
+  }
+  return out;
+}
+
+// Initialize the board and the occupancy bitmasks from the input puzzle.
+function stateFromPuzzle(puzzle) {
+  const state = {
+    cells: new Array(81).fill(0),
+    rowUsed: new Array(9).fill(0),
+    colUsed: new Array(9).fill(0),
+    boxUsed: new Array(9).fill(0),
+    moves: [],
+  };
+  for (let i = 0; i < 81; i += 1) {
+    if (puzzle[i] && !place(state, i, puzzle[i])) return null;
+  }
+  return state;
+}
+
+function propagateSingles(state, stats) {
+  for (;;) {
+    let progress = false;
+    for (let idx = 0; idx < 81; idx += 1) {
+      if (state.cells[idx] !== 0) continue;
+      const mask = candidates(state, idx);
+      const count = popcount16(mask);
+      if (count === 0) return false;
+      if (count === 1) {
+        let digit = 0;
+        for (let d = 1; d <= 9; d += 1) {
+          if (mask & digitMask(d)) {
+            digit = d;
+            break;
+          }
+        }
+        pushMove(state, { index: idx, value: digit, candidatesMask: mask, forced: true });
+        if (!place(state, idx, digit)) return false;
+        stats.forcedMoves += 1;
+        progress = true;
+      }
+    }
+    if (!progress) return true;
+  }
+}
+
+function selectUnfilledCell(state) {
+  let found = false;
+  let bestCount = 10;
+  let bestIdx = -1;
+  let bestMask = 0;
+  for (let idx = 0; idx < 81; idx += 1) {
+    if (state.cells[idx] !== 0) continue;
+    const mask = candidates(state, idx);
+    const count = popcount16(mask);
+    if (count < bestCount) {
+      bestCount = count;
+      bestIdx = idx;
+      bestMask = mask;
+      found = true;
+      if (count === 2) break;
+    }
+  }
+  return found ? { idx: bestIdx, mask: bestMask } : null;
+}
+
+function solve(state, stats, depth) {
+  stats.recursiveNodes += 1;
+  if (depth > stats.maxDepth) stats.maxDepth = depth;
+  if (!propagateSingles(state, stats)) {
+    stats.backtracks += 1;
+    return false;
+  }
+  const selected = selectUnfilledCell(state);
+  if (!selected) return true;
+  for (let d = 1; d <= 9; d += 1) {
+    if (!(selected.mask & digitMask(d))) continue;
+    const next = cloneState(state);
+    pushMove(next, { index: selected.idx, value: d, candidatesMask: selected.mask, forced: false });
+    stats.guessedMoves += 1;
+    if (place(next, selected.idx, d) && solve(next, stats, depth + 1)) {
+      state.cells = next.cells;
+      state.rowUsed = next.rowUsed;
+      state.colUsed = next.colUsed;
+      state.boxUsed = next.boxUsed;
+      state.moves = next.moves;
+      return true;
+    }
+  }
+  stats.backtracks += 1;
+  return false;
+}
+
+function countSolutions(state, limit, countRef) {
+  if (countRef.count >= limit) return;
+  const dummy = {
+    forcedMoves: 0,
+    guessedMoves: 0,
+    recursiveNodes: 0,
+    backtracks: 0,
+    maxDepth: 0,
+  };
+  if (!propagateSingles(state, dummy)) return;
+  const selected = selectUnfilledCell(state);
+  if (!selected) {
+    countRef.count += 1;
+    return;
+  }
+  for (let d = 1; d <= 9; d += 1) {
+    if (!(selected.mask & digitMask(d))) continue;
+    const next = cloneState(state);
+    if (place(next, selected.idx, d)) countSolutions(next, limit, countRef);
+    if (countRef.count >= limit) return;
+  }
+}
+
+function unitComplete(vals) {
+  let seen = 0;
+  for (const v of vals) {
+    if (v < 1 || v > 9) return false;
+    const bit = digitMask(v);
+    if (seen & bit) return false;
+    seen |= bit;
+  }
+  return seen === ALL_MASK;
+}
+
+function replayMovesAreLegal(puzzle, solved) {
+  const state = stateFromPuzzle(puzzle);
+  if (!state) return false;
+  for (const move of solved.moves) {
+    if (state.cells[move.index] !== 0) return false;
+    const mask = candidates(state, move.index);
+    if (mask !== move.candidatesMask) return false;
+    if (!(mask & digitMask(move.value))) return false;
+    if (move.forced && popcount16(mask) !== 1) return false;
+    if (!place(state, move.index, move.value)) return false;
+  }
+  return true;
+}
+
+function boardLines(cells) {
+  const lines = [];
+  for (let r = 0; r < 9; r += 1) {
+    if (r > 0 && r % 3 === 0) lines.push('');
+    let line = '';
+    for (let c = 0; c < 9; c += 1) {
+      if (c > 0 && c % 3 === 0) line += '| ';
+      const v = cells[r * 9 + c];
+      line += v === 0 ? '. ' : `${v} `;
+    }
+    lines.push(line);
+  }
+  return lines;
+}
+
+// Solve the fixed puzzle and report both the solution and the internal consistency checks.
+function main() {
+  const puzzle = parsePuzzle(DEFAULT_PUZZLE);
+  if (!puzzle) process.exit(1);
+  const initial = stateFromPuzzle(puzzle);
+  if (!initial) process.exit(1);
+
+  const stats = {
+    givens: 0,
+    blanks: 0,
+    forcedMoves: 0,
+    guessedMoves: 0,
+    recursiveNodes: 0,
+    backtracks: 0,
+    maxDepth: 0,
+  };
+  for (let i = 0; i < 81; i += 1) {
+    if (puzzle[i]) stats.givens += 1;
+    else stats.blanks += 1;
+  }
+
+  const solved = cloneState(initial);
+  const solvedOk = solve(solved, stats, 0);
+
+  const countState = cloneState(initial);
+  const countRef = { count: 0 };
+  countSolutions(countState, 2, countRef);
+  const solutionCount = countRef.count;
+  const unique = solutionCount === 1;
+
+  let givensPreserved = true;
+  let rowsOk = true;
+  let colsOk = true;
+  let boxesOk = true;
+  let replayOk = false;
+
+  if (solvedOk) {
+    for (let i = 0; i < 81; i += 1) if (puzzle[i] && puzzle[i] !== solved.cells[i]) givensPreserved = false;
+    for (let r = 0; r < 9; r += 1) {
+      const row = [];
+      for (let c = 0; c < 9; c += 1) row.push(solved.cells[r * 9 + c]);
+      if (!unitComplete(row)) rowsOk = false;
+    }
+    for (let c = 0; c < 9; c += 1) {
+      const col = [];
+      for (let r = 0; r < 9; r += 1) col.push(solved.cells[r * 9 + c]);
+      if (!unitComplete(col)) colsOk = false;
+    }
+    for (let b = 0; b < 9; b += 1) {
+      const br = Math.floor(b / 3) * 3;
+      const bc = (b % 3) * 3;
+      const box = [];
+      for (let dr = 0; dr < 3; dr += 1) {
+        for (let dc = 0; dc < 3; dc += 1) {
+          box.push(solved.cells[(br + dr) * 9 + (bc + dc)]);
+        }
+      }
+      if (!unitComplete(box)) boxesOk = false;
+    }
+    replayOk = replayMovesAreLegal(puzzle, solved);
+  }
+
+  const ok = solvedOk && givensPreserved && rowsOk && colsOk && boxesOk && replayOk && unique;
+
+  const lines = [];
+  lines.push('=== Answer ===');
+  lines.push(
+    unique
+      ? 'The puzzle is solved, and the completed grid is the unique valid Sudoku solution.'
+      : 'The puzzle is solved, and the completed grid is a valid Sudoku solution.',
+  );
+  lines.push('');
+  lines.push('Puzzle');
+  lines.push(...boardLines(puzzle));
+  lines.push('');
+  lines.push('Completed grid');
+  if (solvedOk) lines.push(...boardLines(solved.cells));
+  lines.push('');
+  lines.push('=== Reason Why ===');
+  lines.push(
+    'The solver combines constraint propagation with depth-first search. It fills forced singles immediately and branches on the blank cell with the fewest candidates.',
+  );
+  lines.push(`givens             : ${stats.givens}`);
+  lines.push(`blanks             : ${stats.blanks}`);
+  lines.push(`forced placements  : ${stats.forcedMoves}`);
+  lines.push(`guesses            : ${stats.guessedMoves}`);
+  lines.push(`search nodes       : ${stats.recursiveNodes}`);
+  lines.push(`backtracks         : ${stats.backtracks}`);
+  lines.push(`solution unique    : ${unique ? 'yes' : 'no'}`);
+  lines.push('');
+  lines.push('=== Check ===');
+  lines.push(`solver found solution           : ${solvedOk ? 'yes' : 'no'}`);
+  lines.push(`givens preserved                : ${givensPreserved ? 'yes' : 'no'}`);
+  lines.push(`rows complete                   : ${rowsOk ? 'yes' : 'no'}`);
+  lines.push(`columns complete                : ${colsOk ? 'yes' : 'no'}`);
+  lines.push(`boxes complete                  : ${boxesOk ? 'yes' : 'no'}`);
+  lines.push(`recorded placements replay legally: ${replayOk ? 'yes' : 'no'}`);
+  lines.push(`uniqueness check                : ${unique ? 'yes' : 'no'}`);
+
+  process.stdout.write(`${lines.join('\n')}\n`);
+  process.exit(ok ? 0 : 1);
+}
+
+main();

package/examples/extra/transistor-switch.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Toy transistor-switch calculation in millivolts, microamps, and ohms.
+ * Two input cases are enough to demonstrate the OFF and saturated ON states and verify the arithmetic.
+ */
+
+const VCC_MV = 5000;
+const VIN_LOW_MV = 0;
+const VIN_HIGH_MV = 5000;
+const VBE_ON_MV = 700;
+const VCE_SAT_MV = 200;
+const RB_OHMS = 10000;
+const RL_OHMS = 1000;
+const BETA = 100;
+
+// Evaluate one DC operating point using simple cutoff / active / saturation logic.
+function evaluateState(inputMv) {
+  if (inputMv <= VBE_ON_MV) {
+    return {
+      inputMv,
+      baseCurrentUa: 0,
+      collectorGainLimitUa: 0,
+      collectorLoadLimitUa: 0,
+      collectorCurrentUa: 0,
+      loadVoltageMv: 0,
+      collectorEmitterVoltageMv: VCC_MV,
+      cutoff: true,
+      saturation: false,
+    };
+  }
+  const ib = Math.floor(((inputMv - VBE_ON_MV) * 1000) / RB_OHMS);
+  const gainLimit = ib * BETA;
+  const loadLimit = Math.floor(((VCC_MV - VCE_SAT_MV) * 1000) / RL_OHMS);
+  const ic = Math.min(gainLimit, loadLimit);
+  const sat = gainLimit >= loadLimit;
+  const loadV = Math.floor((ic * RL_OHMS) / 1000);
+  const vce = sat ? VCE_SAT_MV : VCC_MV - loadV;
+  return {
+    inputMv,
+    baseCurrentUa: ib,
+    collectorGainLimitUa: gainLimit,
+    collectorLoadLimitUa: loadLimit,
+    collectorCurrentUa: ic,
+    loadVoltageMv: loadV,
+    collectorEmitterVoltageMv: vce,
+    cutoff: false,
+    saturation: sat,
+  };
+}
+
+function stateName(state) {
+  return state.cutoff ? 'cutoff / OFF' : state.saturation ? 'saturation / ON' : 'active / linear';
+}
+
+// Compare the low-input and high-input operating points and verify the switching story.
+function main() {
+  const low = evaluateState(VIN_LOW_MV);
+  const high = evaluateState(VIN_HIGH_MV);
+  const lowCutoff = low.cutoff && low.collectorCurrentUa === 0 && low.collectorEmitterVoltageMv === VCC_MV;
+  const highSat = high.saturation && high.collectorEmitterVoltageMv === VCE_SAT_MV;
+  const switchingCleanly = low.cutoff && high.saturation;
+  const loadLimited =
+    high.collectorCurrentUa === high.collectorLoadLimitUa && high.collectorGainLimitUa > high.collectorLoadLimitUa;
+  const ohmOk = high.loadVoltageMv === Math.floor((high.collectorCurrentUa * RL_OHMS) / 1000);
+  const ok = lowCutoff && highSat && switchingCleanly && loadLimited && ohmOk;
+
+  const lines = [];
+  lines.push('=== Answer ===');
+  lines.push(
+    'In this toy transistor-switch model, a low input leaves the transistor OFF and a high input drives it ON in saturation.',
+  );
+  lines.push('');
+  lines.push('=== Reason Why ===');
+  lines.push(`low input state   : ${stateName(low)}`);
+  lines.push(`high input state  : ${stateName(high)}`);
+  lines.push(`high base current : ${high.baseCurrentUa} uA`);
+  lines.push(`high collector Ic : ${high.collectorCurrentUa} uA`);
+  lines.push(`load-limited Ic   : ${high.collectorLoadLimitUa} uA`);
+  lines.push('');
+  lines.push('=== Check ===');
+  lines.push(`low input cutoff                : ${lowCutoff ? 'yes' : 'no'}`);
+  lines.push(`high input saturation           : ${highSat ? 'yes' : 'no'}`);
+  lines.push(`switching states differ         : ${switchingCleanly ? 'yes' : 'no'}`);
+  lines.push(`on-state current is load-limited: ${loadLimited ? 'yes' : 'no'}`);
+  lines.push(`load voltage matches Ohm's law  : ${ohmOk ? 'yes' : 'no'}`);
+
+  process.stdout.write(`${lines.join('\n')}\n`);
+  process.exit(ok ? 0 : 1);
+}
+
+main();

package/examples/fibonacci.n3

@@ -23,6 +23,7 @@
     10 :fibonacci ?F10.
     100 :fibonacci ?F100.
     1000 :fibonacci ?F1000.
+    10000 :fibonacci ?F10000.
 } => {
     :test :is {
         0 :fibonacci ?F0.
@@ -30,6 +31,7 @@
         10 :fibonacci ?F10.
         100 :fibonacci ?F100.
         1000 :fibonacci ?F1000.
+        10000 :fibonacci ?F10000.
     }.
 }.
 

package/examples/output/fibonacci.n3

@@ -6,4 +6,5 @@
     10 :fibonacci 55 .
     100 :fibonacci 354224848179261915075 .
     1000 :fibonacci 43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875 .
+    10000 :fibonacci 33644764876431783266621612005107543310302148460680063906564769974680081442166662368155595513633734025582065332680836159373734790483865268263040892463056431887354544369559827491606602099884183933864652731300088830269235673613135117579297437854413752130520504347701602264758318906527890855154366159582987279682987510631200575428783453215515103870818298969791613127856265033195487140214287532698187962046936097879900350962302291026368131493195275630227837628441540360584402572114334961180023091208287046088923962328835461505776583271252546093591128203925285393434620904245248929403901706233888991085841065183173360437470737908552631764325733993712871937587746897479926305837065742830161637408969178426378624212835258112820516370298089332099905707920064367426202389783111470054074998459250360633560933883831923386783056136435351892133279732908133732642652633989763922723407882928177953580570993691049175470808931841056146322338217465637321248226383092103297701648054726243842374862411453093812206564914032751086643394517512161526545361333111314042436854805106765843493523836959653428071768775328348234345557366719731392746273629108210679280784718035329131176778924659089938635459327894523777674406192240337638674004021330343297496902028328145933418826817683893072003634795623117103101291953169794607632737589253530772552375943788434504067715555779056450443016640119462580972216729758615026968443146952034614932291105970676243268515992834709891284706740862008587135016260312071903172086094081298321581077282076353186624611278245537208532365305775956430072517744315051539600905168603220349163222640885248852433158051534849622434848299380905070483482449327453732624567755879089187190803662058009594743150052402532709746995318770724376825907419939632265984147498193609285223945039707165443156421328157688908058783183404917434556270520223564846495196112460268313970975069382648706613264507665074611512677522748621598642530711298441182622661057163515069260029861704945425047491378115154139941550671256271197133252763631939606902895650288268608362241082050562430701794976171121233066073310059947366875 .
 } .