numbl 0.0.22 → 0.0.23

package/binding.gyp

@@ -1,20 +1,22 @@
 {
   "targets": [
     {
-      "target_name": "lapack_addon",
+      "target_name": "numbl_addon",
       "sources": [
-        "native/lapack_addon.cpp",
+        "native/numbl_addon.cpp",
         "native/lapack_inv.cpp",
         "native/lapack_qr.cpp",
         "native/lapack_lu.cpp",
         "native/lapack_svd.cpp",
         "native/lapack_matmul.cpp",
+        "native/lapack_matmul_complex.cpp",
         "native/lapack_linsolve.cpp",
         "native/lapack_eig.cpp",
         "native/lapack_chol.cpp",
         "native/lapack_qz.cpp",
         "native/lapack_fft.cpp",
-        "native/lapack_fft_batch.cpp"
+        "native/lapack_fft_batch.cpp",
+        "native/elemwise.cpp"
       ],
       "include_dirs": [
         "<!@(node -p \"require('node-addon-api').include\")",
@@ -29,7 +31,7 @@
         "<!@(pkg-config --libs fftw3 2>/dev/null || echo '-lfftw3')",
         "<!@(pkg-config --libs-only-L fftw3 2>/dev/null | sed 's/-L/-Wl,-rpath,/g' || true)"
       ],
-      "cflags_cc": [ "-std=c++17", "-O2" ]
+      "cflags_cc": [ "-std=c++17", "-O3", "-march=native" ]
     }
   ]
 }

package/dist-cli/cli.js

@@ -1214,6 +1214,10 @@ var RTV = {
     while (s.length > 2 && s[s.length - 1] === 1) s.pop();
     return { kind: "tensor", data: d, imag: im, shape: s, _rc: 1 };
   },
+  /** Fast tensor constructor — data must be FloatXArray, shape already normalized (no trailing singletons). */
+  tensorRaw(data, shape) {
+    return { kind: "tensor", data, imag: void 0, shape, _rc: 1 };
+  },
   /** Create a scalar tensor (1x1) */
   scalar(value) {
     return value;
@@ -1352,6 +1356,7 @@ var getItemTypeFromRuntimeValue = (value) => {
 };
 
 // src/numbl-core/native/lapack-bridge.ts
+var NATIVE_ADDON_EXPECTED_VERSION = 1;
 var _bridge = null;
 function setLapackBridge(bridge) {
   _bridge = bridge;
@@ -19027,16 +19032,90 @@ function complexBinaryOp(a, b, op) {
     `Matrix dimensions must agree: [${at.shape.join(",")}] vs [${bt.shape.join(",")}]`
   );
 }
-function mAdd(a, b) {
-  if (typeof a === "object" && a !== null && a.kind === "tensor" && typeof b === "object" && b !== null && b.kind === "tensor") {
-    const at = a;
-    const bt = b;
-    if (!at.imag && !bt.imag && at.data.length === bt.data.length && at.shape.length === bt.shape.length && at.shape.every((d, i) => d === bt.shape[i])) {
-      const result = new FloatXArray(at.data.length);
-      for (let i = 0; i < result.length; i++)
-        result[i] = at.data[i] + bt.data[i];
-      return RTV.tensor(result, at.shape);
+var ELEMWISE_ADD = 0;
+var ELEMWISE_SUB = 1;
+var ELEMWISE_MUL = 2;
+var ELEMWISE_DIV = 3;
+function matchSameShapeTensors(a, b) {
+  if (typeof a !== "object" || a === null || a.kind !== "tensor" || typeof b !== "object" || b === null || b.kind !== "tensor")
+    return null;
+  const at = a;
+  const bt = b;
+  if (at.data.length !== bt.data.length || at.shape.length !== bt.shape.length || at.shape.some((d, i) => d !== bt.shape[i]))
+    return null;
+  return [at, bt];
+}
+function tryNativeElemwiseReal(at, bt, opCode) {
+  const bridge = getLapackBridge();
+  if (!bridge?.elemwise) return null;
+  const result = bridge.elemwise(
+    at.data,
+    bt.data,
+    opCode
+  );
+  return RTV.tensorRaw(result, at.shape);
+}
+function tensorElemwiseComplex(at, bt, opCode, jsOp) {
+  const bridge = getLapackBridge();
+  if (bridge?.elemwiseComplex) {
+    const r = bridge.elemwiseComplex(
+      at.data,
+      at.imag ?? null,
+      bt.data,
+      bt.imag ?? null,
+      opCode
+    );
+    if (r.im) return RTV.tensor(r.re, at.shape, r.im);
+    return RTV.tensorRaw(r.re, at.shape);
+  }
+  const len = at.data.length;
+  const aIm = at.imag;
+  const bIm = bt.imag;
+  const resultRe = new FloatXArray(len);
+  const resultIm = new FloatXArray(len);
+  if (aIm && bIm) {
+    for (let i = 0; i < len; i++) {
+      const r = jsOp(at.data[i], aIm[i], bt.data[i], bIm[i]);
+      resultRe[i] = r.re;
+      resultIm[i] = r.im;
+    }
+  } else if (aIm) {
+    for (let i = 0; i < len; i++) {
+      const r = jsOp(at.data[i], aIm[i], bt.data[i], 0);
+      resultRe[i] = r.re;
+      resultIm[i] = r.im;
     }
+  } else {
+    for (let i = 0; i < len; i++) {
+      const r = jsOp(at.data[i], 0, bt.data[i], bIm[i]);
+      resultRe[i] = r.re;
+      resultIm[i] = r.im;
+    }
+  }
+  const isReal = resultIm.every((x) => x === 0);
+  return RTV.tensor(resultRe, at.shape, isReal ? void 0 : resultIm);
+}
+function mAdd(a, b) {
+  const m = matchSameShapeTensors(a, b);
+  if (m) {
+    const [at, bt] = m;
+    if (!at.imag && !bt.imag) {
+      const nr = tryNativeElemwiseReal(at, bt, ELEMWISE_ADD);
+      if (nr) return nr;
+      const len = at.data.length;
+      const result = new FloatXArray(len);
+      for (let i = 0; i < len; i++) result[i] = at.data[i] + bt.data[i];
+      return RTV.tensorRaw(result, at.shape);
+    }
+    return tensorElemwiseComplex(
+      at,
+      bt,
+      ELEMWISE_ADD,
+      (aRe, aIm, bRe, bIm) => ({
+        re: aRe + bRe,
+        im: aIm + bIm
+      })
+    );
   }
   if (isRuntimeSparseMatrix(a) || isRuntimeSparseMatrix(b))
     return mAddSparse(a, b);
@@ -19049,6 +19128,27 @@ function mAdd(a, b) {
   return binaryOp(a, b, (x, y) => x + y);
 }
 function mSub(a, b) {
+  const m = matchSameShapeTensors(a, b);
+  if (m) {
+    const [at, bt] = m;
+    if (!at.imag && !bt.imag) {
+      const nr = tryNativeElemwiseReal(at, bt, ELEMWISE_SUB);
+      if (nr) return nr;
+      const len = at.data.length;
+      const result = new FloatXArray(len);
+      for (let i = 0; i < len; i++) result[i] = at.data[i] - bt.data[i];
+      return RTV.tensorRaw(result, at.shape);
+    }
+    return tensorElemwiseComplex(
+      at,
+      bt,
+      ELEMWISE_SUB,
+      (aRe, aIm, bRe, bIm) => ({
+        re: aRe - bRe,
+        im: aIm - bIm
+      })
+    );
+  }
   if (isRuntimeSparseMatrix(a) || isRuntimeSparseMatrix(b))
     return mSubSparse(a, b);
   if (isComplexOrMixed(a, b)) {
@@ -19074,15 +19174,26 @@ function mMul(a, b) {
   return binaryOp(a, b, (x, y) => x * y);
 }
 function mElemMul(a, b) {
-  if (typeof a === "object" && a !== null && a.kind === "tensor" && typeof b === "object" && b !== null && b.kind === "tensor") {
-    const at = a;
-    const bt = b;
-    if (!at.imag && !bt.imag && at.data.length === bt.data.length && at.shape.length === bt.shape.length && at.shape.every((d, i) => d === bt.shape[i])) {
-      const result = new FloatXArray(at.data.length);
-      for (let i = 0; i < result.length; i++)
-        result[i] = at.data[i] * bt.data[i];
-      return RTV.tensor(result, at.shape);
-    }
+  const m = matchSameShapeTensors(a, b);
+  if (m) {
+    const [at, bt] = m;
+    if (!at.imag && !bt.imag) {
+      const nr = tryNativeElemwiseReal(at, bt, ELEMWISE_MUL);
+      if (nr) return nr;
+      const len = at.data.length;
+      const result = new FloatXArray(len);
+      for (let i = 0; i < len; i++) result[i] = at.data[i] * bt.data[i];
+      return RTV.tensorRaw(result, at.shape);
+    }
+    return tensorElemwiseComplex(
+      at,
+      bt,
+      ELEMWISE_MUL,
+      (aRe, aIm, bRe, bIm) => ({
+        re: aRe * bRe - aIm * bIm,
+        im: aRe * bIm + aIm * bRe
+      })
+    );
   }
   if (isRuntimeSparseMatrix(a) || isRuntimeSparseMatrix(b))
     return mElemMulSparse(a, b);
@@ -19110,6 +19221,19 @@ function mDiv(a, b) {
   return binaryOp(a, b, (x, y) => x / y);
 }
 function mElemDiv(a, b) {
+  const m = matchSameShapeTensors(a, b);
+  if (m) {
+    const [at, bt] = m;
+    if (!at.imag && !bt.imag) {
+      const nr = tryNativeElemwiseReal(at, bt, ELEMWISE_DIV);
+      if (nr) return nr;
+      const len = at.data.length;
+      const result = new FloatXArray(len);
+      for (let i = 0; i < len; i++) result[i] = at.data[i] / bt.data[i];
+      return RTV.tensorRaw(result, at.shape);
+    }
+    return tensorElemwiseComplex(at, bt, ELEMWISE_DIV, complexDivide);
+  }
   if (isRuntimeSparseMatrix(a) || isRuntimeSparseMatrix(b))
     return mElemDivSparse(a, b);
   if (isComplexOrMixed(a, b)) {
@@ -19736,14 +19860,37 @@ function matMul(a, b) {
   }
   const isComplex2 = a.imag !== void 0 || b.imag !== void 0;
   if (!isComplex2) {
-    const bridge = getEffectiveBridge("matmul", "matmul");
+    const bridge2 = getEffectiveBridge("matmul", "matmul");
     const f64A = a.data instanceof Float64Array ? a.data : new Float64Array(a.data);
     const f64B = b.data instanceof Float64Array ? b.data : new Float64Array(b.data);
-    const raw = bridge.matmul(f64A, aRows, aCols, f64B, bCols);
+    const raw = bridge2.matmul(f64A, aRows, aCols, f64B, bCols);
     return unwrap1x1(RTV.tensor(new FloatXArray(raw), [aRows, bCols]));
   }
   const aIm = a.imag || new FloatXArray(a.data.length);
   const bIm = b.imag || new FloatXArray(b.data.length);
+  const bridge = getEffectiveBridge("matmul", "matmulComplex");
+  if (bridge.matmulComplex) {
+    const f64ARe = a.data instanceof Float64Array ? a.data : new Float64Array(a.data);
+    const f64AIm = aIm instanceof Float64Array ? aIm : new Float64Array(aIm);
+    const f64BRe = b.data instanceof Float64Array ? b.data : new Float64Array(b.data);
+    const f64BIm = bIm instanceof Float64Array ? bIm : new Float64Array(bIm);
+    const raw = bridge.matmulComplex(
+      f64ARe,
+      f64AIm,
+      aRows,
+      aCols,
+      f64BRe,
+      f64BIm,
+      bCols
+    );
+    return unwrap1x1(
+      RTV.tensor(
+        new FloatXArray(raw.re),
+        [aRows, bCols],
+        raw.im ? new FloatXArray(raw.im) : void 0
+      )
+    );
+  }
   const resultRe = new FloatXArray(aRows * bCols);
   const resultIm = new FloatXArray(aRows * bCols);
   for (let i = 0; i < aRows; i++) {
@@ -20239,6 +20386,30 @@ function indexIntoTensor1D(base, idx) {
 }
 function indexIntoTensor2D(base, rowIdx, colIdx) {
   const [rows, cols] = tensorSize2D(base);
+  if (isRuntimeNumber(rowIdx) && isColonIndex(colIdx)) {
+    const r = Math.round(rowIdx) - 1;
+    if (r < 0 || r >= rows)
+      throw new RuntimeError("Index exceeds array bounds");
+    const resultData2 = new FloatXArray(cols);
+    const resultImag2 = base.imag ? new FloatXArray(cols) : void 0;
+    for (let ci = 0; ci < cols; ci++) {
+      resultData2[ci] = base.data[r + ci * rows];
+      if (resultImag2 && base.imag) resultImag2[ci] = base.imag[r + ci * rows];
+    }
+    return RTV.tensor(resultData2, [1, cols], resultImag2);
+  }
+  if (isColonIndex(rowIdx) && isRuntimeNumber(colIdx)) {
+    const c = Math.round(colIdx) - 1;
+    if (c < 0 || c >= cols)
+      throw new RuntimeError("Index exceeds array bounds");
+    const offset = c * rows;
+    const resultData2 = new FloatXArray(rows);
+    for (let ri = 0; ri < rows; ri++) resultData2[ri] = base.data[offset + ri];
+    const resultImag2 = base.imag ? new FloatXArray(rows) : void 0;
+    if (resultImag2 && base.imag)
+      for (let ri = 0; ri < rows; ri++) resultImag2[ri] = base.imag[offset + ri];
+    return RTV.tensor(resultData2, [rows, 1], resultImag2);
+  }
   const rowIdxArr = resolveIndex(rowIdx, rows);
   const colIdxArr = resolveIndex(colIdx, cols);
   const numR = rowIdxArr.length;
@@ -27582,6 +27753,19 @@ function registerArrayManipulationFunctions() {
       if (n !== data.length) {
         throw new RuntimeError("reshape: number of elements must not change");
       }
+      if (isRuntimeTensor(v)) {
+        v._rc++;
+        const s = [...shape];
+        while (s.length > 2 && s[s.length - 1] === 1) s.pop();
+        return {
+          kind: "tensor",
+          data,
+          imag,
+          shape: s,
+          _isLogical: v._isLogical,
+          _rc: v._rc
+        };
+      }
       return RTV.tensor(
         new FloatXArray(data),
         shape,
@@ -30474,10 +30658,10 @@ function registerSortUnique() {
 }
 function uniqueByRows(v, nargout, stable) {
   const [rows, cols] = tensorSize2D(v);
-  const rowKey = (r) => {
-    const parts = [];
-    for (let c = 0; c < cols; c++) parts.push(v.data[c * rows + r]);
-    return parts.join(",");
+  const rowKey = cols === 2 ? (r) => v.data[r] + "," + v.data[rows + r] : (r) => {
+    let key = "" + v.data[r];
+    for (let c = 1; c < cols; c++) key += "," + v.data[c * rows + r];
+    return key;
   };
   const rowHasNaN = (r) => {
     for (let c = 0; c < cols; c++) {
@@ -30530,10 +30714,21 @@ function uniqueByRows(v, nargout, stable) {
     1
   ]);
   if (!stable) {
-    const sortedKeyOrder = uniqueRowOrder.map((r) => rowKey(r));
+    const sortedKeyToPos = /* @__PURE__ */ new Map();
+    for (let u = 0; u < nUnique; u++) {
+      sortedKeyToPos.set(rowKey(uniqueRowOrder[u]), u + 1);
+    }
     for (let r = 0; r < rows; r++) {
-      const key = rowKey(r);
-      ic[r] = sortedKeyOrder.indexOf(key) + 1;
+      if (rowHasNaN(r)) {
+        for (let u = 0; u < nUnique; u++) {
+          if (uniqueRowOrder[u] === r) {
+            ic[r] = u + 1;
+            break;
+          }
+        }
+      } else {
+        ic[r] = sortedKeyToPos.get(rowKey(r));
+      }
     }
   }
   const icTensor = RTV.tensor(ic, [rows, 1]);
@@ -37520,56 +37715,61 @@ function not(v) {
   return RTV.logical(false);
 }
 function binop(op, a, b) {
-  const an = asNumber(a);
-  const bn = asNumber(b);
-  if (an !== null && bn !== null) {
+  if (typeof a === "number" && typeof b === "number") {
     switch (op) {
       case "Add" /* Add */:
-        return an + bn;
+        return a + b;
       case "Sub" /* Sub */:
-        return an - bn;
+        return a - b;
       case "Mul" /* Mul */:
-        return an * bn;
+        return a * b;
       case "Div" /* Div */:
-        return an / bn;
+        return a / b;
       case "Pow" /* Pow */: {
-        const r = Math.pow(an, bn);
-        if (isNaN(r) && !isNaN(an) && !isNaN(bn)) break;
+        const r = Math.pow(a, b);
+        if (isNaN(r) && !isNaN(a) && !isNaN(b)) break;
         return r;
       }
       case "ElemMul" /* ElemMul */:
-        return an * bn;
+        return a * b;
       case "ElemDiv" /* ElemDiv */:
-        return an / bn;
+        return a / b;
       case "ElemPow" /* ElemPow */: {
-        const r = Math.pow(an, bn);
-        if (isNaN(r) && !isNaN(an) && !isNaN(bn)) break;
+        const r = Math.pow(a, b);
+        if (isNaN(r) && !isNaN(a) && !isNaN(b)) break;
         return r;
       }
       case "LeftDiv" /* LeftDiv */:
-        return bn / an;
+        return b / a;
       case "ElemLeftDiv" /* ElemLeftDiv */:
-        return bn / an;
+        return b / a;
       case "Equal" /* Equal */:
-        return RTV.logical(an === bn);
+        return RTV.logical(a === b);
       case "NotEqual" /* NotEqual */:
-        return RTV.logical(an !== bn);
+        return RTV.logical(a !== b);
       case "Less" /* Less */:
-        return RTV.logical(an < bn);
+        return RTV.logical(a < b);
       case "LessEqual" /* LessEqual */:
-        return RTV.logical(an <= bn);
+        return RTV.logical(a <= b);
       case "Greater" /* Greater */:
-        return RTV.logical(an > bn);
+        return RTV.logical(a > b);
       case "GreaterEqual" /* GreaterEqual */:
-        return RTV.logical(an >= bn);
+        return RTV.logical(a >= b);
       case "BitAnd" /* BitAnd */:
-        return RTV.logical(an !== 0 && bn !== 0);
+        return RTV.logical(a !== 0 && b !== 0);
       case "BitOr" /* BitOr */:
-        return RTV.logical(an !== 0 || bn !== 0);
+        return RTV.logical(a !== 0 || b !== 0);
     }
   }
-  const ma = ensureRuntimeValue(a);
-  const mb = ensureRuntimeValue(b);
+  if (typeof a !== "object" || typeof b !== "object") {
+    const an = asNumber(a);
+    const bn = asNumber(b);
+    if (an !== null && bn !== null) {
+      return binop(op, an, bn);
+    }
+  }
+  const ma = typeof a === "object" && a !== null && "kind" in a ? a : ensureRuntimeValue(a);
+  const mb = typeof b === "object" && b !== null && "kind" in b ? b : ensureRuntimeValue(b);
   let result;
   switch (op) {
     case "Add" /* Add */:
@@ -38013,13 +38213,6 @@ function callBuiltin(rt, name, nargout, args) {
   if (builtin) return builtin(nargout, args);
   throw new RuntimeError(`'${name}' is not a builtin function`);
 }
-function callBuiltinSync(rt, name, nargout, args) {
-  const plotResult = dispatchPlotCall(rt, name, args);
-  if (plotResult !== void 0) return plotResult;
-  const builtin = rt.builtins[name];
-  if (builtin) return builtin(nargout, args);
-  throw new RuntimeError(`'${name}' is not a builtin function`);
-}
 function callClassMethod(rt, className, methodName, nargout, args) {
   return dispatch(rt, methodName, nargout, args, className);
 }
@@ -38306,6 +38499,22 @@ function structfunImpl(rt, _nargout, args) {
     return RTV.struct(fields);
   }
 }
+var bsxfunOpMap = {
+  plus: mAdd,
+  minus: mSub,
+  times: mElemMul,
+  rdivide: mElemDiv
+};
+function resolveKnownBsxfunOp(fnArg) {
+  if (typeof fnArg === "function") {
+    return void 0;
+  }
+  const mv = ensureRuntimeValue(fnArg);
+  if (isRuntimeFunction(mv) && mv.impl === "builtin") {
+    return bsxfunOpMap[mv.name];
+  }
+  return void 0;
+}
 function bsxfunImpl(rt, _nargout, args) {
   if (args.length !== 3)
     throw new RuntimeError("bsxfun requires exactly 3 arguments");
@@ -38323,6 +38532,10 @@ function bsxfunImpl(rt, _nargout, args) {
       );
     }
   }
+  const knownOp = resolveKnownBsxfunOp(fnArg);
+  if (knownOp) {
+    return knownOp(ensureRuntimeValue(args[1]), ensureRuntimeValue(args[2]));
+  }
   const rawA = ensureRuntimeValue(args[1]);
   const rawB = ensureRuntimeValue(args[2]);
   const a = coerceToTensor2(rawA, "bsxfun", "first");
@@ -39089,7 +39302,7 @@ function registerSpecialBuiltins(rt) {
     if (fn) {
       return fn(nargout, args.slice(1));
     }
-    return rt.callBuiltinSync(fnName, nargout, args.slice(1));
+    return rt.callBuiltin(fnName, nargout, args.slice(1));
   };
   const requireFileIO = () => {
     if (!rt.fileIO)
@@ -41083,9 +41296,6 @@ var Runtime = class _Runtime {
     }
     return binop(op, a, b);
   }
-  binopSync(op, a, b) {
-    return binop(op, a, b);
-  }
   range(start, step, end) {
     return range(start, step, end);
   }
@@ -41205,9 +41415,6 @@ var Runtime = class _Runtime {
   callBuiltin(name, nargout, args) {
     return callBuiltin(this, name, nargout, args);
   }
-  callBuiltinSync(name, nargout, args) {
-    return callBuiltinSync(this, name, nargout, args);
-  }
   callClassMethod(className, methodName, nargout, args) {
     return callClassMethod(this, className, methodName, nargout, args);
   }
@@ -44347,9 +44554,6 @@ function genBinary(cg, kind) {
         break;
     }
   }
-  if (leftType.kind !== "Unknown" && rightType.kind !== "Unknown" && leftType.kind !== "ClassInstance" && rightType.kind !== "ClassInstance") {
-    return `$rt.binopSync(${JSON.stringify(kind.op)}, ${left}, ${right})`;
-  }
   return `$rt.binop(${JSON.stringify(kind.op)}, ${left}, ${right})`;
 }
 function genTensor(cg, kind) {
@@ -47572,7 +47776,7 @@ Call stack (most recent call first):`;
 }
 
 // src/numbl-core/version.ts
-var NUMBL_VERSION = "0.0.22";
+var NUMBL_VERSION = "0.0.23";
 
 // src/cli-repl.ts
 import { createInterface } from "readline";
@@ -48203,16 +48407,26 @@ var NodeFileIOAdapter = class {
 var __filename = fileURLToPath2(import.meta.url);
 var __dirname = dirname3(__filename);
 var packageDir2 = join6(__dirname, "..");
-var addonPath = join6(packageDir2, "build", "Release", "lapack_addon.node");
+var addonPath = join6(packageDir2, "build", "Release", "numbl_addon.node");
 var nativeAddonLoaded = false;
 if (!process.env.NUMBL_NO_NATIVE) {
   try {
     const req = createRequire(import.meta.url);
     const addon = req(addonPath);
-    setLapackBridge(addon);
-    setLapackBridge(addon);
-    nativeAddonLoaded = true;
+    const addonVer = typeof addon.addonVersion === "function" ? addon.addonVersion() : 0;
+    if (addonVer !== NATIVE_ADDON_EXPECTED_VERSION) {
+      console.error(
+        `Warning: native addon version mismatch (got ${addonVer}, expected ${NATIVE_ADDON_EXPECTED_VERSION}). Run "npx numbl build-addon" to rebuild. Using JS fallbacks.`
+      );
+    } else {
+      setLapackBridge(addon);
+      setLapackBridge(addon);
+      nativeAddonLoaded = true;
+    }
   } catch {
+    console.error(
+      `Warning: native addon not found. Run "npx numbl build-addon" to build it. Using JS fallbacks.`
+    );
   }
 }
 var nativeBridge;

package/native/elemwise.cpp

@@ -0,0 +1,168 @@
+/**
+ * Element-wise binary operations on Float64Arrays.
+ *
+ * Real:
+ *   elemwise(a: Float64Array, b: Float64Array, op: number): Float64Array
+ *     op: 0=add, 1=sub, 2=mul, 3=div
+ *
+ * Complex:
+ *   elemwiseComplex(aRe: Float64Array, aIm: Float64Array,
+ *                   bRe: Float64Array, bIm: Float64Array,
+ *                   op: number): { re: Float64Array, im: Float64Array }
+ *     op: 0=add, 1=sub, 2=mul, 3=div
+ *     Pass null for aIm or bIm to treat as zero (mixed real/complex).
+ */
+
+#include "numbl_addon_common.h"
+
+// ── elemwise() — real element-wise binary op ────────────────────────────────
+
+Napi::Value Elemwise(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 3
+      || !info[0].IsTypedArray()
+      || !info[1].IsTypedArray()
+      || !info[2].IsNumber()) {
+    Napi::TypeError::New(env,
+      "elemwise: expected (Float64Array a, Float64Array b, number op)")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  auto arrA = info[0].As<Napi::Float64Array>();
+  auto arrB = info[1].As<Napi::Float64Array>();
+  int op = info[2].As<Napi::Number>().Int32Value();
+
+  size_t n = arrA.ElementLength();
+  if (arrB.ElementLength() != n) {
+    Napi::RangeError::New(env, "elemwise: arrays must have same length")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  auto result = Napi::Float64Array::New(env, n);
+  const double* a = arrA.Data();
+  const double* b = arrB.Data();
+  double* out = result.Data();
+
+  switch (op) {
+    case 0: // add
+      for (size_t i = 0; i < n; i++) out[i] = a[i] + b[i];
+      break;
+    case 1: // sub
+      for (size_t i = 0; i < n; i++) out[i] = a[i] - b[i];
+      break;
+    case 2: // mul
+      for (size_t i = 0; i < n; i++) out[i] = a[i] * b[i];
+      break;
+    case 3: // div
+      for (size_t i = 0; i < n; i++) out[i] = a[i] / b[i];
+      break;
+    default:
+      Napi::RangeError::New(env, "elemwise: op must be 0-3")
+          .ThrowAsJavaScriptException();
+      return env.Null();
+  }
+
+  return result;
+}
+
+// ── elemwiseComplex() — complex element-wise binary op ──────────────────────
+
+Napi::Value ElemwiseComplex(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  // (aRe, aIm_or_null, bRe, bIm_or_null, op)
+  if (info.Length() < 5 || !info[0].IsTypedArray() || !info[2].IsTypedArray()
+      || !info[4].IsNumber()) {
+    Napi::TypeError::New(env,
+      "elemwiseComplex: expected (Float64Array aRe, Float64Array|null aIm, "
+      "Float64Array bRe, Float64Array|null bIm, number op)")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  auto arrARe = info[0].As<Napi::Float64Array>();
+  auto arrBRe = info[2].As<Napi::Float64Array>();
+  int op = info[4].As<Napi::Number>().Int32Value();
+
+  size_t n = arrARe.ElementLength();
+  if (arrBRe.ElementLength() != n) {
+    Napi::RangeError::New(env, "elemwiseComplex: arrays must have same length")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  const double* aRe = arrARe.Data();
+  const double* bRe = arrBRe.Data();
+
+  // aIm and bIm may be null (treat as zero)
+  bool hasAIm = info[1].IsTypedArray();
+  bool hasBIm = info[3].IsTypedArray();
+  const double* aIm = hasAIm ? info[1].As<Napi::Float64Array>().Data() : nullptr;
+  const double* bIm = hasBIm ? info[3].As<Napi::Float64Array>().Data() : nullptr;
+
+  auto outRe = Napi::Float64Array::New(env, n);
+  auto outIm = Napi::Float64Array::New(env, n);
+  double* oRe = outRe.Data();
+  double* oIm = outIm.Data();
+
+  switch (op) {
+    case 0: // add
+      for (size_t i = 0; i < n; i++) {
+        oRe[i] = aRe[i] + bRe[i];
+        oIm[i] = (aIm ? aIm[i] : 0.0) + (bIm ? bIm[i] : 0.0);
+      }
+      break;
+    case 1: // sub
+      for (size_t i = 0; i < n; i++) {
+        oRe[i] = aRe[i] - bRe[i];
+        oIm[i] = (aIm ? aIm[i] : 0.0) - (bIm ? bIm[i] : 0.0);
+      }
+      break;
+    case 2: { // mul: (a+bi)(c+di) = (ac-bd) + (ad+bc)i
+      for (size_t i = 0; i < n; i++) {
+        double ar = aRe[i], ai = aIm ? aIm[i] : 0.0;
+        double br = bRe[i], bi = bIm ? bIm[i] : 0.0;
+        oRe[i] = ar * br - ai * bi;
+        oIm[i] = ar * bi + ai * br;
+      }
+      break;
+    }
+    case 3: { // div: (a+bi)/(c+di) = ((ac+bd) + (bc-ad)i) / (c²+d²)
+      for (size_t i = 0; i < n; i++) {
+        double ar = aRe[i], ai = aIm ? aIm[i] : 0.0;
+        double br = bRe[i], bi = bIm ? bIm[i] : 0.0;
+        double denom = br * br + bi * bi;
+        if (denom == 0.0) {
+          oRe[i] = (ar == 0.0 && ai == 0.0) ? 0.0 / 0.0 /* NaN */
+                    : (ar > 0 ? 1.0 : ar < 0 ? -1.0 : 0.0) / 0.0 /* ±Inf */;
+          oIm[i] = (ar == 0.0 && ai == 0.0) ? 0.0
+                    : (ai > 0 ? 1.0 : ai < 0 ? -1.0 : 0.0) / 0.0;
+        } else {
+          oRe[i] = (ar * br + ai * bi) / denom;
+          oIm[i] = (ai * br - ar * bi) / denom;
+        }
+      }
+      break;
+    }
+    default:
+      Napi::RangeError::New(env, "elemwiseComplex: op must be 0-3")
+          .ThrowAsJavaScriptException();
+      return env.Null();
+  }
+
+  // Check if result is purely real
+  bool isReal = true;
+  for (size_t i = 0; i < n; i++) {
+    if (oIm[i] != 0.0) { isReal = false; break; }
+  }
+
+  auto result = Napi::Object::New(env);
+  result.Set("re", outRe);
+  if (!isReal) {
+    result.Set("im", outIm);
+  }
+  return result;
+}

package/native/lapack_chol.cpp

@@ -13,7 +13,7 @@
  *     Returns the triangular factor and info (0 = success, >0 = not pos def).
  */
 
-#include "lapack_common.h"
+#include "numbl_addon_common.h"
 
 // Zero out the opposite triangle of an n×n column-major matrix.
 template<typename T>

package/native/lapack_eig.cpp

@@ -12,7 +12,7 @@
  *   The ts-lapack bridge handles the nobalance case.
  */
 
-#include "lapack_common.h"
+#include "numbl_addon_common.h"
 
 // ── eig() ─────────────────────────────────────────────────────────────────────
 

package/native/lapack_fft.cpp

@@ -12,7 +12,7 @@
  *     Does NOT normalize for inverse (caller handles 1/n scaling).
  */
 
-#include "lapack_common.h"
+#include "numbl_addon_common.h"
 #include <fftw3.h>
 
 // Shared core: run FFTW on pre-filled input, return {re, im} result object.

package/native/lapack_fft_batch.cpp

@@ -17,7 +17,7 @@
  *   Does NOT normalize for inverse — caller handles 1/n scaling.
  */
 
-#include "lapack_common.h"
+#include "numbl_addon_common.h"
 #include <fftw3.h>
 #include <cmath>
 

package/native/lapack_inv.cpp

@@ -11,7 +11,7 @@
  *     zgetrf + zgetri.  Throws if the matrix is singular.
  */
 
-#include "lapack_common.h"
+#include "numbl_addon_common.h"
 
 // ── inv() ─────────────────────────────────────────────────────────────────────
 

package/native/lapack_linsolve.cpp

@@ -20,7 +20,7 @@
  *     Underdetermined (m < n): minimum-norm solution minimising ||X||₂.
  */
 
-#include "lapack_common.h"
+#include "numbl_addon_common.h"
 
 // ── linsolve() ────────────────────────────────────────────────────────────────
 

package/native/lapack_lu.cpp

@@ -12,7 +12,7 @@
  *     Returns the packed LU matrix and 1-based pivot indices.
  */
 
-#include "lapack_common.h"
+#include "numbl_addon_common.h"
 
 // ── lu() ─────────────────────────────────────────────────────────────────────
 

package/native/lapack_matmul.cpp

@@ -10,7 +10,7 @@
  *       C is an m×n matrix returned in column-major order
  */
 
-#include "lapack_common.h"
+#include "numbl_addon_common.h"
 
 // ── matmul() ──────────────────────────────────────────────────────────────────
 

package/native/lapack_matmul_complex.cpp

@@ -0,0 +1,110 @@
+/**
+ * matmulComplex() — Complex matrix-matrix multiplication via BLAS zgemm.
+ *
+ *   matmulComplex(ARe: Float64Array, AIm: Float64Array,
+ *                 m: number, k: number,
+ *                 BRe: Float64Array, BIm: Float64Array,
+ *                 n: number): { re: Float64Array, im: Float64Array }
+ *
+ *     Computes C = A * B where:
+ *       A is an m×k complex matrix (split re/im) stored in column-major order
+ *       B is a  k×n complex matrix (split re/im) stored in column-major order
+ *       C is an m×n complex matrix returned as {re, im} in column-major order
+ */
+
+#include "numbl_addon_common.h"
+
+Napi::Value MatmulComplex(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  // matmulComplex(ARe, AIm, m, k, BRe, BIm, n)
+  if (info.Length() < 7
+      || !info[0].IsTypedArray()   // ARe
+      || !info[1].IsTypedArray()   // AIm
+      || !info[2].IsNumber()       // m
+      || !info[3].IsNumber()       // k
+      || !info[4].IsTypedArray()   // BRe
+      || !info[5].IsTypedArray()   // BIm
+      || !info[6].IsNumber()) {    // n
+    Napi::TypeError::New(env,
+      "matmulComplex: expected (Float64Array ARe, Float64Array AIm, "
+      "number m, number k, Float64Array BRe, Float64Array BIm, number n)")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  auto arrARe = info[0].As<Napi::Float64Array>();
+  auto arrAIm = info[1].As<Napi::Float64Array>();
+  int m = info[2].As<Napi::Number>().Int32Value();
+  int k = info[3].As<Napi::Number>().Int32Value();
+  auto arrBRe = info[4].As<Napi::Float64Array>();
+  auto arrBIm = info[5].As<Napi::Float64Array>();
+  int n = info[6].As<Napi::Number>().Int32Value();
+
+  if (m < 0 || k < 0 || n < 0) {
+    Napi::RangeError::New(env, "matmulComplex: m, k, n must be non-negative")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  int mk = m * k;
+  int kn = k * n;
+  int mn = m * n;
+
+  // Handle empty-dimension multiply
+  if (m == 0 || k == 0 || n == 0) {
+    auto result = Napi::Object::New(env);
+    result.Set("re", Napi::Float64Array::New(env, static_cast<size_t>(mn)));
+    result.Set("im", Napi::Float64Array::New(env, static_cast<size_t>(mn)));
+    return result;
+  }
+
+  // Interleave into complex arrays for zgemm
+  std::vector<lapack_complex_double> a(mk);
+  for (int i = 0; i < mk; ++i) {
+    a[i].real = arrARe[i];
+    a[i].imag = arrAIm[i];
+  }
+
+  std::vector<lapack_complex_double> b(kn);
+  for (int i = 0; i < kn; ++i) {
+    b[i].real = arrBRe[i];
+    b[i].imag = arrBIm[i];
+  }
+
+  std::vector<lapack_complex_double> c(mn, {0.0, 0.0});
+
+  char transa = 'N';
+  char transb = 'N';
+  lapack_complex_double alpha = {1.0, 0.0};
+  lapack_complex_double beta  = {0.0, 0.0};
+  int lda = m;
+  int ldb = k;
+  int ldc = m;
+
+  zgemm_(&transa, &transb,
+         &m, &n, &k,
+         &alpha, a.data(), &lda,
+                 b.data(), &ldb,
+         &beta,  c.data(), &ldc);
+
+  // Deinterleave result
+  auto result = Napi::Object::New(env);
+  auto outRe = Napi::Float64Array::New(env, static_cast<size_t>(mn));
+  auto outIm = Napi::Float64Array::New(env, static_cast<size_t>(mn));
+  for (int i = 0; i < mn; ++i) {
+    outRe[i] = c[i].real;
+    outIm[i] = c[i].imag;
+  }
+
+  // Check if result is purely real
+  bool isReal = true;
+  for (int i = 0; i < mn; ++i) {
+    if (outIm[i] != 0.0) { isReal = false; break; }
+  }
+  result.Set("re", outRe);
+  if (!isReal) {
+    result.Set("im", outIm);
+  }
+  return result;
+}

package/native/lapack_qr.cpp

@@ -13,7 +13,7 @@
  *     wantQ=false: skips Q generation.
  */
 
-#include "lapack_common.h"
+#include "numbl_addon_common.h"
 
 // ── qr() ─────────────────────────────────────────────────────────────────────
 

package/native/lapack_qz.cpp

@@ -9,7 +9,7 @@
  *   where Q and Z are unitary (orthogonal for real case).
  */
 
-#include "lapack_common.h"
+#include "numbl_addon_common.h"
 
 Napi::Value Qz(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();

package/native/lapack_svd.cpp

@@ -13,7 +13,7 @@
  *     (k = min(m, n))
  */
 
-#include "lapack_common.h"
+#include "numbl_addon_common.h"
 #include <string>
 
 // ── svd() ─────────────────────────────────────────────────────────────────────

package/native/{lapack_addon.cpp → numbl_addon.cpp}

@@ -1,5 +1,5 @@
 /**
- * Native Node.js addon exposing LAPACK/BLAS routines for efficient linear algebra.
+ * numbl native addon — LAPACK/BLAS, FFT, element-wise arithmetic, and more.
  *
  * Exported functions (see individual .cpp files for full documentation):
  *
@@ -19,11 +19,32 @@
  *   cholComplex(dataRe, dataIm, n, upper) — complex Cholesky     (lapack_chol.cpp)
  */
 
-#include "lapack_common.h"
+#include "numbl_addon_common.h"
+#include <cstdlib>
+
+extern "C" {
+  void openblas_set_num_threads(int num_threads);
+}
+
+// ── Addon version ────────────────────────────────────────────────────────────
+// Bump this integer whenever the addon's API changes (new functions, signature
+// changes, etc.) so that the JS side can detect stale builds.
+static const int ADDON_VERSION = 1;
+
+static Napi::Value AddonVersion(const Napi::CallbackInfo& info) {
+  return Napi::Number::New(info.Env(), ADDON_VERSION);
+}
 
 // ── Module initialisation ─────────────────────────────────────────────────────
 
 Napi::Object Init(Napi::Env env, Napi::Object exports) {
+  // Use single-threaded BLAS unless the user explicitly set the env var.
+  // Multi-threaded BLAS adds overhead for the many small matmuls in numbl.
+  if (!std::getenv("OPENBLAS_NUM_THREADS")) {
+    openblas_set_num_threads(1);
+  }
+  exports.Set(Napi::String::New(env, "addonVersion"),
+              Napi::Function::New(env, AddonVersion));
   exports.Set(Napi::String::New(env, "inv"),
               Napi::Function::New(env, Inv));
   exports.Set(Napi::String::New(env, "invComplex"),
@@ -42,6 +63,8 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
               Napi::Function::New(env, SvdComplex));
   exports.Set(Napi::String::New(env, "matmul"),
               Napi::Function::New(env, Matmul));
+  exports.Set(Napi::String::New(env, "matmulComplex"),
+              Napi::Function::New(env, MatmulComplex));
   exports.Set(Napi::String::New(env, "linsolve"),
               Napi::Function::New(env, Linsolve));
   exports.Set(Napi::String::New(env, "linsolveComplex"),
@@ -64,7 +87,11 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
               Napi::Function::New(env, Fft1dComplex));
   exports.Set(Napi::String::New(env, "fftAlongDim"),
               Napi::Function::New(env, FftAlongDim));
+  exports.Set(Napi::String::New(env, "elemwise"),
+              Napi::Function::New(env, Elemwise));
+  exports.Set(Napi::String::New(env, "elemwiseComplex"),
+              Napi::Function::New(env, ElemwiseComplex));
   return exports;
 }
 
-NODE_API_MODULE(lapack_addon, Init)
+NODE_API_MODULE(numbl_addon, Init)

package/native/{lapack_common.h → numbl_addon_common.h}

@@ -1,6 +1,6 @@
 /**
  * Common includes, type definitions, LAPACK/BLAS declarations, and function
- * prototypes shared across the lapack_addon source files.
+ * prototypes shared across the numbl_addon source files.
  */
 
 #pragma once
@@ -83,6 +83,13 @@ extern "C" {
               double* b, int* ldb,
               double* beta, double* c, int* ldc);
 
+  // Complex matrix-matrix multiplication: C = alpha * op(A) * op(B) + beta * C
+  void zgemm_(char* transa, char* transb,
+              int* m, int* n, int* k,
+              lapack_complex_double* alpha, lapack_complex_double* a, int* lda,
+              lapack_complex_double* b, int* ldb,
+              lapack_complex_double* beta, lapack_complex_double* c, int* ldc);
+
   // ── Linear solve (square) ─────────────────────────────────────────────────
   // LU factorisation + solve: A * X = B  (A is n×n, B is n×nrhs)
   // On exit A contains the LU factors; B contains X.
@@ -253,6 +260,7 @@ Napi::Value LuComplex(const Napi::CallbackInfo& info);
 Napi::Value Svd(const Napi::CallbackInfo& info);
 Napi::Value SvdComplex(const Napi::CallbackInfo& info);
 Napi::Value Matmul(const Napi::CallbackInfo& info);
+Napi::Value MatmulComplex(const Napi::CallbackInfo& info);
 Napi::Value Linsolve(const Napi::CallbackInfo& info);
 Napi::Value LinsolveComplex(const Napi::CallbackInfo& info);
 Napi::Value Eig(const Napi::CallbackInfo& info);
@@ -264,3 +272,5 @@ Napi::Value QzComplex(const Napi::CallbackInfo& info);
 Napi::Value Fft1d(const Napi::CallbackInfo& info);
 Napi::Value Fft1dComplex(const Napi::CallbackInfo& info);
 Napi::Value FftAlongDim(const Napi::CallbackInfo& info);
+Napi::Value Elemwise(const Napi::CallbackInfo& info);
+Napi::Value ElemwiseComplex(const Napi::CallbackInfo& info);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numbl",
-  "version": "0.0.22",
+  "version": "0.0.23",
   "description": "Run .m source files in the browser and on the command line by compiling to JavaScript",
   "license": "Apache-2.0",
   "type": "module",