@fraczak/k 6.10.2 → 6.10.4

package/scripts/render-benchmark.mjs

@@ -5,6 +5,31 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+function printHelp() {
+  console.log(
+`Usage: node scripts/render-benchmark.mjs [in.json] [out.html]
+
+Renders benchmark results JSON into a standalone interactive HTML report.
+
+Arguments:
+  input-json
+      Path to benchmark results JSON file.
+      (default: benchmark-results.json)
+  output-html
+      Destination path for generated HTML report.
+      (default: benchmark-results.html)
+
+Options:
+  -h, --help
+      Show this help message and exit.`);
+}
+
+if (process.argv.includes("-h") || process.argv.includes("--help")) {
+  printHelp();
+  process.exit(0);
+}
+
 const inputPath = path.resolve(root, process.argv[2] || "benchmark-results.json");
 const outputPath = path.resolve(root, process.argv[3] || "benchmark-results.html");
 

package/scripts/run-tests.mjs

@@ -7,6 +7,24 @@ import { fileURLToPath } from "node:url";
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const node = process.execPath;
+
+function printHelp() {
+  console.log(`Usage: node scripts/run-tests.mjs [options]
+
+Runs the comprehensive K language test suite, including core unit tests,
+type derivation, codecs, object encoding, conformance, REPL, interpreter,
+and arithmetic suites.
+
+Options:
+  -h, --help
+      Show this help message and exit.`);
+}
+
+if (process.argv.includes("-h") || process.argv.includes("--help")) {
+  printHelp();
+  process.exit(0);
+}
+
 const derivationTests = fs.readdirSync(path.join(root, "tests/code-derivation"))
   .filter((name) => name.endsWith(".mjs"))
   .sort()
@@ -31,6 +49,7 @@ const tests = [
   ["tests/test-kvm.mjs", node, ["tests/test-kvm.mjs"]],
   ["tests/test-kvm-polymorphic.mjs", node, ["tests/test-kvm-polymorphic.mjs"]],
   ["tests/test-arithmetics.mjs", node, ["tests/test-arithmetics.mjs"]],
+  ["tests/test-karatsuba.mjs", node, ["tests/test-karatsuba.mjs"]],
   ["tests/test-poly.mjs", node, ["tests/test-poly.mjs"]],
   ["tests/test-ieee-arithmetic.mjs", node, ["tests/test-ieee-arithmetic.mjs"]],
   ["tests/integration.sh", path.join(root, "tests/integration.sh"), []]

package/tests/README.md

@@ -1,6 +1,7 @@
 # k Test Suite
 
-This directory contains the automated tests, type-derivation validation cases, and integration test scripts for the `k` compiler and runtime.
+This directory contains automated tests, type-derivation validation
+cases, and integration test scripts for the `k` compiler and runtime.
 
 ## Running the Tests
 
@@ -9,27 +10,37 @@ To run all core unit tests, type-derivation checks, and integration tests:
 ```bash
 npm test
 ```
-This executes `node scripts/run-tests.mjs`, which discovers and runs the test scripts sequentially.
+This executes `node scripts/run-tests.mjs`, which discovers and runs the
+test scripts sequentially.
 
 ## Test Directory Structure
 
 ### Core Test Files
-- **[test.mjs](file:///Users/wojtek/gits/k/tests/test.mjs)**: Verifies basic parser and runtime execution behavior.
-- **[test-kvm.mjs](file:///Users/wojtek/gits/k/tests/test-kvm.mjs)**: Comprehensive conformance testing for the kVM register compiler and interpreter under both envelope-aware and envelope-free modes.
-- **[test-ieee-arithmetic.mjs](file:///Users/wojtek/gits/k/tests/test-ieee-arithmetic.mjs)**: Verifies IEEE-754 double precision float arithmetic implementation (`Examples/ieee.k`).
-- **[test-repl.mjs](file:///Users/wojtek/gits/k/tests/test-repl.mjs)**: Tests interactive REPL commands, state transitions, imports, and auto-completions.
-- **[test-k-object.mjs](file:///Users/wojtek/gits/k/tests/test-k-object.mjs)**: Tests serialization, compilation, and loading of `.ko` binary objects.
-- **[test-fingerprint.mjs](file:///Users/wojtek/gits/k/tests/test-fingerprint.mjs)**: Tests semantic expression and relation hashing/fingerprinting.
-- **[test-hash-normalization.mjs](file:///Users/wojtek/gits/k/tests/test-hash-normalization.mjs)**: Verifies consistent normalization of type pattern graphs and hashes.
-- **[test-hash-fuzz.mjs](file:///Users/wojtek/gits/k/tests/test-hash-fuzz.mjs)**: Fuzzes expression/relation hashing to guard against collisions.
-
-### WebAssembly Benchmarks
-
-The WebAssembly execution benchmark moved to the separate
-[`fraczak/k-wasm`](https://github.com/fraczak/k-wasm) backend repository.
+- **[test.mjs](test.mjs)**: Verifies basic parser and runtime
+  execution behavior.
+- **[test-kvm.mjs](test-kvm.mjs)**: Conformance testing for the kVM
+  register compiler and interpreter in envelope-aware and envelope-free
+  modes.
+- **[test-kvm-polymorphic.mjs](test-kvm-polymorphic.mjs)**: Tests for
+  polymorphic `.kvm` templates (`layer: "KVM-P"`) and runtime input
+  envelope specialization (`specializeKVM`).
+- **[test-ieee-arithmetic.mjs](test-ieee-arithmetic.mjs)**: Verifies
+  IEEE-754 double precision float arithmetic (`Examples/ieee.k`).
+- **[test-repl.mjs](test-repl.mjs)**: Tests interactive REPL commands,
+  state transitions, imports, `.klib` and `.ko` exports.
+- **[test-k-object.mjs](test-k-object.mjs)**: Tests serialization,
+  compilation, and loading of `.ko` binary objects and `.klib` libraries.
+- **[test-fingerprint.mjs](test-fingerprint.mjs)**: Tests semantic
+  expression and relation hashing/fingerprinting (`@hash`).
+- **[test-hash-normalization.mjs](test-hash-normalization.mjs)**:
+  Verifies consistent normalization of type pattern graphs and hashes.
+- **[test-hash-fuzz.mjs](test-hash-fuzz.mjs)**: Fuzzes expression and
+  relation hashing to guard against collisions.
 
 ### Type Derivation Suites
-- **[code-derivation/](file:///Users/wojtek/gits/k/tests/code-derivation)**: Houses individual files (each containing a focused test scenario) validating type-derivation convergence and pattern-envelope generation.
+- **[code-derivation/](code-derivation/)**: Individual files validating
+  type-derivation convergence and pattern-envelope generation.
 
 ### Integration Scripts
-- **[integration.sh](file:///Users/wojtek/gits/k/tests/integration.sh)**: Shell script checking boundary data pipelines (`k-parse`, `k-show`, `k-print`) against binary outputs.
+- **[integration.sh](integration.sh)**: Shell script checking boundary
+  data pipelines (`k-parse`, `k-show`, `k-print`) against binary outputs.

package/tests/test-karatsuba.mjs

@@ -0,0 +1,133 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const root = path.resolve(scriptDir, "..");
+const node = process.execPath;
+const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "k-karatsuba-"));
+const libPath = path.join(tmpDir, "karatsuba-mult.klib");
+const kSource = path.join(root, "Examples/karatsuba-mult.k");
+const program = "{() x, () y} karatsuba";
+
+const smallInput =
+  "111111122222233333344444445555556666667777777888888999999000000" +
+  "11111122222233333344444455555";
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: root,
+    input: options.input,
+    encoding: options.encoding ?? null,
+    maxBuffer: 64 * 1024 * 1024
+  });
+  if (result.error && result.status == null) throw result.error;
+  return result;
+}
+
+function assertOk(result, label) {
+  if (result.status !== 0) {
+    const stderr = Buffer.isBuffer(result.stderr)
+      ? result.stderr.toString("utf8")
+      : String(result.stderr ?? "");
+    const stdout = Buffer.isBuffer(result.stdout)
+      ? result.stdout.toString("utf8")
+      : String(result.stdout ?? "");
+    assert.fail(
+      `${label} failed (status ${result.status})\n` +
+      `STDERR:\n${stderr}\nSTDOUT:\n${stdout}`
+    );
+  }
+}
+
+function parseIntWire(text) {
+  const result = run(node, ["codecs/int.mjs", "--parse"], {
+    input: `${text}\n`
+  });
+  assertOk(result, `parse int ${text}`);
+  return result.stdout;
+}
+
+function printIntWire(wire, label) {
+  const result = run(node, ["codecs/int.mjs", "--print"], {
+    input: wire,
+    encoding: "utf8"
+  });
+  assertOk(result, `${label} print`);
+  return result.stdout.trim();
+}
+
+function runKaratsuba(inputText) {
+  const wire = parseIntWire(inputText);
+  const result = run(node, [
+    "k.mjs",
+    "--lib", libPath,
+    "--export", "karatsuba:karatsuba",
+    program
+  ], { input: wire });
+  assertOk(result, `native karatsuba(${inputText})`);
+  return printIntWire(result.stdout, `native karatsuba`);
+}
+
+function expectedSquare(inputText) {
+  const n = BigInt(inputText);
+  return (n * n).toString();
+}
+
+try {
+  assertOk(
+    run(node, ["objects/compile.mjs", kSource, libPath], {
+      encoding: "utf8"
+    }),
+    "compile Examples/karatsuba-mult.k"
+  );
+
+  const testInputs = [
+    "0",
+    "1",
+    "-1",
+    "7",
+    "-7",
+    "42",
+    "-42",
+    "123456789",
+    "-123456789",
+    "987654321987654321",
+    "-987654321987654321",
+    smallInput,
+    `-${smallInput}`
+  ];
+
+  for (const input of testInputs) {
+    assert.equal(
+      runKaratsuba(input),
+      expectedSquare(input),
+      `karatsuba square(${input.slice(0, 20)}...) mismatch`
+    );
+  }
+
+  // Test asymmetric pair multiplication with mixed signs via int list
+  const pairWire = parseIntWire(
+    "[12345678901234567890, -98765432109876543210]"
+  );
+  const pairProgram = "/cons { .car x, .cdr /cons .car y } karatsuba";
+  const resPair = run(node, [
+    "k.mjs",
+    "--lib", libPath,
+    "--export", "karatsuba:karatsuba",
+    pairProgram
+  ], { input: pairWire });
+  assertOk(resPair, "pair multiplication");
+  assert.equal(
+    printIntWire(resPair.stdout, "pair multiplication"),
+    (12345678901234567890n * -98765432109876543210n).toString(),
+    "asymmetric pair multiplication should match BigInt oracle"
+  );
+
+  console.log("OK");
+} finally {
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+}