numbl 0.0.21 → 0.0.23

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.21",
+  "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",
@@ -106,10 +106,11 @@
     "vitest": "^4.0.18"
   },
   "lint-staged": {
-    "*.{js,jsx,ts,tsx}": [
+    "*.{ts,tsx}": [
       "prettier --write",
       "eslint"
     ],
+    "*.{js,jsx}": "prettier --write",
     "*.{json,css,md,yml}": "prettier --write"
   },
   "optionalDependencies": {