numbl 0.1.7 → 0.2.0

package/native/ops_napi.cpp

@@ -0,0 +1,320 @@
+/**
+ * N-API wrappers for the new tensor-ops layer (native/ops/).
+ *
+ * Each export is a thin shim: validate args, get raw pointers via Data(),
+ * call the C core, throw on negative return.  The output buffer is
+ * caller-allocated (passed in as the last argument).
+ *
+ * Categories exposed:
+ *   tensorOpRealBinary(op, n, a, b, out)
+ *   tensorOpRealScalarBinary(op, n, scalar, arr, scalarOnLeft, out)
+ *   tensorOpComplexBinary(op, n, aRe, aIm|null, bRe, bIm|null, outRe, outIm)
+ *   tensorOpComplexScalarBinary(op, n, sRe, sIm, arrRe, arrIm|null, scalarOnLeft, outRe, outIm)
+ *   tensorOpDumpCodes()  →  string (used only by drift-detection test)
+ */
+
+#include <napi.h>
+
+extern "C" {
+  #include "ops/numbl_ops.h"
+}
+
+namespace {
+
+inline void ThrowOnError(Napi::Env env, int code, const char* op_name) {
+  if (code != NUMBL_OK) {
+    std::string msg = std::string(op_name) + ": " + numbl_strerror(code);
+    Napi::Error::New(env, msg).ThrowAsJavaScriptException();
+  }
+}
+
+inline const double* AsF64(const Napi::Value& v) {
+  return v.As<Napi::Float64Array>().Data();
+}
+
+inline double* AsF64Mut(const Napi::Value& v) {
+  return v.As<Napi::Float64Array>().Data();
+}
+
+inline const double* AsF64OrNull(const Napi::Value& v) {
+  if (v.IsNull() || v.IsUndefined()) return nullptr;
+  return v.As<Napi::Float64Array>().Data();
+}
+
+}  // namespace
+
+Napi::Value TensorOpRealBinary(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 5) {
+    Napi::TypeError::New(env,
+      "tensorOpRealBinary(op, n, a, b, out)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int op = info[0].As<Napi::Number>().Int32Value();
+  size_t n = (size_t)info[1].As<Napi::Number>().Int64Value();
+  int rc = numbl_real_binary_elemwise(
+      op, n, AsF64(info[2]), AsF64(info[3]), AsF64Mut(info[4]));
+  ThrowOnError(env, rc, "tensorOpRealBinary");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpRealScalarBinary(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 6) {
+    Napi::TypeError::New(env,
+      "tensorOpRealScalarBinary(op, n, scalar, arr, scalarOnLeft, out)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int op = info[0].As<Napi::Number>().Int32Value();
+  size_t n = (size_t)info[1].As<Napi::Number>().Int64Value();
+  double scalar = info[2].As<Napi::Number>().DoubleValue();
+  int scalar_on_left = info[4].As<Napi::Boolean>().Value() ? 1 : 0;
+  int rc = numbl_real_scalar_binary_elemwise(
+      op, n, scalar, AsF64(info[3]), scalar_on_left, AsF64Mut(info[5]));
+  ThrowOnError(env, rc, "tensorOpRealScalarBinary");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpComplexBinary(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 8) {
+    Napi::TypeError::New(env,
+      "tensorOpComplexBinary(op, n, aRe, aIm|null, bRe, bIm|null, outRe, outIm)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int op = info[0].As<Napi::Number>().Int32Value();
+  size_t n = (size_t)info[1].As<Napi::Number>().Int64Value();
+  int rc = numbl_complex_binary_elemwise(
+      op, n,
+      AsF64(info[2]), AsF64OrNull(info[3]),
+      AsF64(info[4]), AsF64OrNull(info[5]),
+      AsF64Mut(info[6]), AsF64Mut(info[7]));
+  ThrowOnError(env, rc, "tensorOpComplexBinary");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpComplexScalarBinary(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 9) {
+    Napi::TypeError::New(env,
+      "tensorOpComplexScalarBinary(op, n, sRe, sIm, arrRe, arrIm|null, scalarOnLeft, outRe, outIm)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int op = info[0].As<Napi::Number>().Int32Value();
+  size_t n = (size_t)info[1].As<Napi::Number>().Int64Value();
+  double s_re = info[2].As<Napi::Number>().DoubleValue();
+  double s_im = info[3].As<Napi::Number>().DoubleValue();
+  int scalar_on_left = info[6].As<Napi::Boolean>().Value() ? 1 : 0;
+  int rc = numbl_complex_scalar_binary_elemwise(
+      op, n, s_re, s_im,
+      AsF64(info[4]), AsF64OrNull(info[5]),
+      scalar_on_left,
+      AsF64Mut(info[7]), AsF64Mut(info[8]));
+  ThrowOnError(env, rc, "tensorOpComplexScalarBinary");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpRealUnary(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 4) {
+    Napi::TypeError::New(env,
+      "tensorOpRealUnary(op, n, a, out)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int op = info[0].As<Napi::Number>().Int32Value();
+  size_t n = (size_t)info[1].As<Napi::Number>().Int64Value();
+  int rc = numbl_real_unary_elemwise(op, n, AsF64(info[2]), AsF64Mut(info[3]));
+  ThrowOnError(env, rc, "tensorOpRealUnary");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpComplexUnary(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 6) {
+    Napi::TypeError::New(env,
+      "tensorOpComplexUnary(op, n, aRe, aIm|null, outRe, outIm)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int op = info[0].As<Napi::Number>().Int32Value();
+  size_t n = (size_t)info[1].As<Napi::Number>().Int64Value();
+  int rc = numbl_complex_unary_elemwise(
+      op, n,
+      AsF64(info[2]), AsF64OrNull(info[3]),
+      AsF64Mut(info[4]), AsF64Mut(info[5]));
+  ThrowOnError(env, rc, "tensorOpComplexUnary");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpComplexAbs(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 4) {
+    Napi::TypeError::New(env,
+      "tensorOpComplexAbs(n, aRe, aIm|null, out)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  size_t n = (size_t)info[0].As<Napi::Number>().Int64Value();
+  int rc = numbl_complex_abs(
+      n, AsF64(info[1]), AsF64OrNull(info[2]), AsF64Mut(info[3]));
+  ThrowOnError(env, rc, "tensorOpComplexAbs");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpRealComparison(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 5) {
+    Napi::TypeError::New(env,
+      "tensorOpRealComparison(op, n, a, b, out)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int op = info[0].As<Napi::Number>().Int32Value();
+  size_t n = (size_t)info[1].As<Napi::Number>().Int64Value();
+  int rc = numbl_real_comparison(
+      op, n, AsF64(info[2]), AsF64(info[3]), AsF64Mut(info[4]));
+  ThrowOnError(env, rc, "tensorOpRealComparison");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpRealScalarComparison(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 6) {
+    Napi::TypeError::New(env,
+      "tensorOpRealScalarComparison(op, n, scalar, arr, scalarOnLeft, out)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int op = info[0].As<Napi::Number>().Int32Value();
+  size_t n = (size_t)info[1].As<Napi::Number>().Int64Value();
+  double scalar = info[2].As<Napi::Number>().DoubleValue();
+  int scalar_on_left = info[4].As<Napi::Boolean>().Value() ? 1 : 0;
+  int rc = numbl_real_scalar_comparison(
+      op, n, scalar, AsF64(info[3]), scalar_on_left, AsF64Mut(info[5]));
+  ThrowOnError(env, rc, "tensorOpRealScalarComparison");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpComplexComparison(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 7) {
+    Napi::TypeError::New(env,
+      "tensorOpComplexComparison(op, n, aRe, aIm|null, bRe, bIm|null, out)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int op = info[0].As<Napi::Number>().Int32Value();
+  size_t n = (size_t)info[1].As<Napi::Number>().Int64Value();
+  int rc = numbl_complex_comparison(
+      op, n,
+      AsF64(info[2]), AsF64OrNull(info[3]),
+      AsF64(info[4]), AsF64OrNull(info[5]),
+      AsF64Mut(info[6]));
+  ThrowOnError(env, rc, "tensorOpComplexComparison");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpComplexScalarComparison(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 8) {
+    Napi::TypeError::New(env,
+      "tensorOpComplexScalarComparison(op, n, sRe, sIm, arrRe, arrIm|null, scalarOnLeft, out)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int op = info[0].As<Napi::Number>().Int32Value();
+  size_t n = (size_t)info[1].As<Napi::Number>().Int64Value();
+  double s_re = info[2].As<Napi::Number>().DoubleValue();
+  double s_im = info[3].As<Napi::Number>().DoubleValue();
+  int scalar_on_left = info[6].As<Napi::Boolean>().Value() ? 1 : 0;
+  int rc = numbl_complex_scalar_comparison(
+      op, n, s_re, s_im,
+      AsF64(info[4]), AsF64OrNull(info[5]),
+      scalar_on_left, AsF64Mut(info[7]));
+  ThrowOnError(env, rc, "tensorOpComplexScalarComparison");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpRealFlatReduce(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 4) {
+    Napi::TypeError::New(env,
+      "tensorOpRealFlatReduce(op, n, a, out)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int op = info[0].As<Napi::Number>().Int32Value();
+  size_t n = (size_t)info[1].As<Napi::Number>().Int64Value();
+  int rc = numbl_real_flat_reduce(op, n, AsF64(info[2]), AsF64Mut(info[3]));
+  ThrowOnError(env, rc, "tensorOpRealFlatReduce");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpComplexFlatReduce(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 6) {
+    Napi::TypeError::New(env,
+      "tensorOpComplexFlatReduce(op, n, aRe, aIm|null, outRe, outIm|null)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int op = info[0].As<Napi::Number>().Int32Value();
+  size_t n = (size_t)info[1].As<Napi::Number>().Int64Value();
+  double* out_im = (info[5].IsNull() || info[5].IsUndefined())
+                       ? nullptr
+                       : AsF64Mut(info[5]);
+  int rc = numbl_complex_flat_reduce(
+      op, n,
+      AsF64(info[2]), AsF64OrNull(info[3]),
+      AsF64Mut(info[4]), out_im);
+  ThrowOnError(env, rc, "tensorOpComplexFlatReduce");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpBesselReal(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 6) {
+    Napi::TypeError::New(env,
+      "tensorOpBesselReal(op, nu, n, z, scale, out)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int op = info[0].As<Napi::Number>().Int32Value();
+  double nu = info[1].As<Napi::Number>().DoubleValue();
+  size_t n = (size_t)info[2].As<Napi::Number>().Int64Value();
+  int scale = info[4].As<Napi::Number>().Int32Value();
+  int rc = numbl_bessel_real(op, nu, n, AsF64(info[3]), scale, AsF64Mut(info[5]));
+  ThrowOnError(env, rc, "tensorOpBesselReal");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpBesselH(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 7) {
+    Napi::TypeError::New(env,
+      "tensorOpBesselH(kKind, nu, n, z, scale, outRe, outIm)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int k_kind = info[0].As<Napi::Number>().Int32Value();
+  double nu = info[1].As<Napi::Number>().DoubleValue();
+  size_t n = (size_t)info[2].As<Napi::Number>().Int64Value();
+  int scale = info[4].As<Napi::Number>().Int32Value();
+  int rc = numbl_bessel_h(k_kind, nu, n, AsF64(info[3]), scale,
+                          AsF64Mut(info[5]), AsF64Mut(info[6]));
+  ThrowOnError(env, rc, "tensorOpBesselH");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpDumpCodes(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  size_t need = numbl_dump_op_codes(nullptr, 0);
+  std::string buf(need, '\0');
+  numbl_dump_op_codes(&buf[0], need + 1);
+  return Napi::String::New(env, buf);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numbl",
-  "version": "0.1.7",
+  "version": "0.2.0",
   "description": "Run .m source files in the browser and on the command line by compiling to JavaScript",
   "license": "Apache-2.0",
   "type": "module",
@@ -38,15 +38,15 @@
   ],
   "scripts": {
     "dev": "npm run bundle:stdlib && vite",
-    "build": "npm run build:web && npm run build:cli && npm run build:plot-viewer",
+    "build": "npm run build:web && npm run build:test-runner && npm run copy:test-scripts && npm run build:cli && npm run build:plot-viewer",
     "build:plot-viewer": "vite build --config vite.plot-viewer.config.ts",
+    "build:test-runner": "npm run bundle:stdlib && vite build --config vite.test-runner.config.ts",
+    "dev:test-runner": "npm run bundle:stdlib && vite --config vite.test-runner.config.ts",
+    "copy:test-scripts": "tsx scripts/copy-test-scripts.ts",
     "bundle:stdlib": "tsx scripts/bundle-stdlib.ts",
     "build:web": "npm run bundle:stdlib && tsc -b && vite build",
     "build:lib": "npm run bundle:stdlib && esbuild src/lib.ts --bundle --platform=neutral --format=esm --outfile=dist-lib/lib.js --loader:.wasm=file && tsc -p tsconfig.lib.json",
     "build:cli": "npm run bundle:stdlib && esbuild src/cli.ts --bundle --platform=node --format=esm --outfile=dist-cli/cli.js --packages=external --loader:.wasm=file",
-    "build:server": "esbuild server/execution-service.ts --bundle --platform=node --format=esm --outfile=server/dist/execution-service.js --packages=external",
-    "server:dev": "node --env-file=server/.env node_modules/.bin/tsx server/execution-service.ts",
-    "server:start": "node --env-file=server/.env server/dist/execution-service.js",
     "install": "true",
     "build:addon": "node-gyp rebuild",
     "format": "prettier --write .",
@@ -60,6 +60,10 @@
     "test:coverage": "vitest run --coverage",
     "test:coverage:all": "bash scripts/coverage-all.sh",
     "test:scripts": "bash numbl_test_scripts/run_all.sh",
+    "test:browser": "playwright test",
+    "test:scripts:c-jit": "bash numbl_test_scripts/run_c_jit.sh",
+    "test:scripts:c-jit-fuse": "bash numbl_test_scripts/run_c_jit_fuse.sh",
+    "test:scripts:c-jit-parity": "bash numbl_test_scripts/run_c_jit_parity.sh",
     "build:wasm": "bash numbl_test_scripts/build_wasm.sh",
     "update-readme": "tsx scripts/update-readme-usage.ts",
     "check-readme": "tsx scripts/update-readme-usage.ts --check",
@@ -83,8 +87,7 @@
     "@monaco-editor/react": "^4.7.0",
     "@mui/icons-material": "^7.3.7",
     "@mui/material": "^7.3.7",
-    "@types/cors": "^2.8.17",
-    "@types/express": "^5.0.0",
+    "@playwright/test": "^1.59.1",
     "@types/node": "^24.10.1",
     "@types/pako": "^2.0.4",
     "@types/react": "^19.2.5",
@@ -95,14 +98,12 @@
     "@vitest/coverage-v8": "^4.0.18",
     "@xterm/addon-fit": "^0.11.0",
     "@xterm/xterm": "^6.0.0",
-    "cors": "^2.8.5",
     "dexie": "^4.3.0",
     "esbuild": "^0.27.3",
     "eslint": "^9.39.1",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-react-hooks": "^7.0.1",
     "eslint-plugin-react-refresh": "^0.4.24",
-    "express": "^4.21.2",
     "globals": "^16.5.0",
     "husky": "^9.1.7",
     "lint-staged": "^16.2.7",

package/dist-lib/numbl-core/interpreter/jit/jitHelpersTensor.d.ts

@@ -1,28 +0,0 @@
-/**
- * Tensor operation helpers for JIT-compiled code.
- * Handles element-wise binary/unary ops, comparison ops, concat, and
- * tensor coercion for struct-array field access.
- */
-import { type FloatXArrayType, type RuntimeTensor } from "../../runtime/types.js";
-import type { RuntimeComplexNumber } from "../../runtime/types.js";
-export declare function makeTensor(data: FloatXArrayType, imag: FloatXArrayType | undefined, shape: number[]): RuntimeTensor;
-type ScalarVal = number | RuntimeComplexNumber;
-export declare function tensorBinaryOp(a: unknown, b: unknown, realOp: (x: number, y: number) => number, complexOp: (a: ScalarVal, b: ScalarVal) => ScalarVal): RuntimeTensor | ScalarVal;
-export declare function tensorCompareOp(a: unknown, b: unknown, cmp: (x: number, y: number) => boolean): RuntimeTensor;
-export declare function tensorUnary(a: RuntimeTensor, fn: (x: number) => number): RuntimeTensor;
-export declare function tensorNeg(a: RuntimeTensor): RuntimeTensor;
-export declare function vconcatGrow1r(base: unknown, v: number): RuntimeTensor;
-export declare function unshare(t: unknown): RuntimeTensor;
-export declare function asTensor(v: unknown): RuntimeTensor;
-export declare const tAdd: (a: unknown, b: unknown) => RuntimeTensor | ScalarVal;
-export declare const tSub: (a: unknown, b: unknown) => RuntimeTensor | ScalarVal;
-export declare const tMul: (a: unknown, b: unknown) => RuntimeTensor | ScalarVal;
-export declare const tDiv: (a: unknown, b: unknown) => RuntimeTensor | ScalarVal;
-export declare const tPow: (a: unknown, b: unknown) => RuntimeTensor | ScalarVal;
-export declare const tEq: (a: unknown, b: unknown) => RuntimeTensor;
-export declare const tNeq: (a: unknown, b: unknown) => RuntimeTensor;
-export declare const tLt: (a: unknown, b: unknown) => RuntimeTensor;
-export declare const tLe: (a: unknown, b: unknown) => RuntimeTensor;
-export declare const tGt: (a: unknown, b: unknown) => RuntimeTensor;
-export declare const tGe: (a: unknown, b: unknown) => RuntimeTensor;
-export {};

package/dist-lib/numbl-core/interpreter/jit/jitLower.d.ts

@@ -1,23 +0,0 @@
-/**
- * AST -> JIT IR lowering with type propagation.
- *
- * Returns null if any unsupported construct is encountered,
- * causing the entire function to fall back to interpretation.
- *
- * Type-level helpers (sign algebra, result types, env management) are
- * in jitLowerTypes.ts. This file contains the core lowering logic.
- */
-import type { FunctionDef } from "../types.js";
-import type { Interpreter } from "../interpreter.js";
-import { type JitType, type JitStmt } from "./jitTypes.js";
-export interface LoweringResult {
-    body: JitStmt[];
-    outputNames: string[];
-    localVars: Set<string>;
-    hasTensorOps: boolean;
-    /** Generated JS code for called user functions: jitName → code */
-    generatedFns: Map<string, string>;
-    /** Type of the first output variable after lowering */
-    outputType: JitType | null;
-}
-export declare function lowerFunction(fn: FunctionDef, argTypes: JitType[], nargout: number, interp?: Interpreter, generatedFns?: Map<string, string>, loweringInProgress?: Set<string>): LoweringResult | null;