numbl 0.0.22 → 0.1.0

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() ─────────────────────────────────────────────────────────────────────
 
@@ -115,6 +115,218 @@ Napi::Value Qr(const Napi::CallbackInfo& info) {
   return result;
 }
 
+// ── qrPivot() ────────────────────────────────────────────────────────────────
+// Column-pivoted QR: A*P = Q*R via dgeqp3 + dorgqr.
+// Returns {Q, R, jpvt} where jpvt is a 1-based permutation vector.
+
+Napi::Value QrPivot(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 4
+      || !info[0].IsTypedArray()
+      || !info[1].IsNumber()
+      || !info[2].IsNumber()
+      || !info[3].IsBoolean()) {
+    Napi::TypeError::New(env,
+      "qrPivot: expected (Float64Array data, number m, number n, boolean econ)")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  auto arr = info[0].As<Napi::TypedArray>();
+  if (arr.TypedArrayType() != napi_float64_array) {
+    Napi::TypeError::New(env, "qrPivot: data must be a Float64Array")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  int m    = info[1].As<Napi::Number>().Int32Value();
+  int n    = info[2].As<Napi::Number>().Int32Value();
+  bool econ = info[3].As<Napi::Boolean>().Value();
+
+  if (m <= 0 || n <= 0 || static_cast<int>(arr.ElementLength()) != m * n) {
+    Napi::RangeError::New(env, "qrPivot: data.length must equal m*n")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  auto float64arr = info[0].As<Napi::Float64Array>();
+  int k = m < n ? m : n;
+
+  // Copy input data
+  std::vector<double> a(m * n);
+  std::memcpy(a.data(), float64arr.Data(), m * n * sizeof(double));
+
+  // jpvt initialised to 0 → all columns are free
+  std::vector<int> jpvt(n, 0);
+  std::vector<double> tau(k);
+  int info_val = 0;
+
+  // Workspace query
+  int lwork = -1;
+  double work_query = 0.0;
+  dgeqp3_(&m, &n, a.data(), &m, jpvt.data(), tau.data(),
+           &work_query, &lwork, &info_val);
+  lwork = static_cast<int>(work_query);
+  if (lwork < 1) lwork = 3 * n + 1;
+
+  std::vector<double> work(lwork);
+  dgeqp3_(&m, &n, a.data(), &m, jpvt.data(), tau.data(),
+           work.data(), &lwork, &info_val);
+
+  if (!checkLapackInfo(env, info_val, "qrPivot", "dgeqp3"))
+    return env.Null();
+
+  // Extract R from the upper triangle
+  int r_rows = econ ? k : m;
+  std::vector<double> R(r_rows * n, 0.0);
+  for (int j = 0; j < n; j++) {
+    int ilim = j < k ? j : k - 1;
+    for (int i = 0; i <= ilim; i++) {
+      R[i + j * r_rows] = a[i + j * m];
+    }
+  }
+
+  // Generate Q via dorgqr
+  int q_cols = econ ? k : m;
+  std::vector<double> q_buf(m * q_cols, 0.0);
+  int cols_to_copy = n < q_cols ? n : q_cols;
+  for (int j = 0; j < cols_to_copy; j++) {
+    for (int i = 0; i < m; i++) {
+      q_buf[i + j * m] = a[i + j * m];
+    }
+  }
+
+  lwork = -1;
+  dorgqr_(&m, &q_cols, &k, q_buf.data(), &m, tau.data(),
+          &work_query, &lwork, &info_val);
+  lwork = static_cast<int>(work_query);
+  if (lwork < 1) lwork = q_cols;
+
+  work.assign(lwork, 0.0);
+  dorgqr_(&m, &q_cols, &k, q_buf.data(), &m, tau.data(),
+          work.data(), &lwork, &info_val);
+
+  if (!checkLapackInfo(env, info_val, "qrPivot", "dorgqr"))
+    return env.Null();
+
+  auto result = Napi::Object::New(env);
+  result.Set("Q", vecToF64(env, q_buf));
+  result.Set("R", vecToF64(env, R));
+  result.Set("jpvt", vecToI32(env, jpvt));
+  return result;
+}
+
+// ── qrPivotComplex() ─────────────────────────────────────────────────────────
+// Column-pivoted complex QR: A*P = Q*R via zgeqp3 + zungqr.
+
+Napi::Value QrPivotComplex(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 5
+      || !info[0].IsTypedArray()
+      || !info[1].IsTypedArray()
+      || !info[2].IsNumber()
+      || !info[3].IsNumber()
+      || !info[4].IsBoolean()) {
+    Napi::TypeError::New(env,
+      "qrPivotComplex: expected (Float64Array dataRe, Float64Array dataIm, "
+      "number m, number n, boolean econ)")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  auto arrRe = info[0].As<Napi::TypedArray>();
+  auto arrIm = info[1].As<Napi::TypedArray>();
+  if (arrRe.TypedArrayType() != napi_float64_array ||
+      arrIm.TypedArrayType() != napi_float64_array) {
+    Napi::TypeError::New(env, "qrPivotComplex: dataRe and dataIm must be Float64Arrays")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  int m    = info[2].As<Napi::Number>().Int32Value();
+  int n    = info[3].As<Napi::Number>().Int32Value();
+  bool econ = info[4].As<Napi::Boolean>().Value();
+
+  if (m <= 0 || n <= 0 ||
+      static_cast<int>(arrRe.ElementLength()) != m * n ||
+      static_cast<int>(arrIm.ElementLength()) != m * n) {
+    Napi::RangeError::New(env,
+      "qrPivotComplex: dataRe.length and dataIm.length must equal m*n")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  int k = m < n ? m : n;
+
+  auto a = splitToInterleaved(
+      info[0].As<Napi::Float64Array>(),
+      info[1].As<Napi::Float64Array>(), m * n);
+
+  std::vector<int> jpvt(n, 0);
+  std::vector<lapack_complex_double> tau(k);
+  std::vector<double> rwork(2 * n);
+  int info_val = 0;
+
+  // Workspace query
+  int lwork = -1;
+  lapack_complex_double work_query;
+  zgeqp3_(&m, &n, a.data(), &m, jpvt.data(), tau.data(),
+           &work_query, &lwork, rwork.data(), &info_val);
+  lwork = static_cast<int>(work_query.real);
+  if (lwork < 1) lwork = n + 1;
+
+  std::vector<lapack_complex_double> work(lwork);
+  zgeqp3_(&m, &n, a.data(), &m, jpvt.data(), tau.data(),
+           work.data(), &lwork, rwork.data(), &info_val);
+
+  if (!checkLapackInfo(env, info_val, "qrPivotComplex", "zgeqp3"))
+    return env.Null();
+
+  // Extract R
+  int r_rows = econ ? k : m;
+  std::vector<double> R_re(r_rows * n, 0.0);
+  std::vector<double> R_im(r_rows * n, 0.0);
+  for (int j = 0; j < n; j++) {
+    int ilim = j < k ? j : k - 1;
+    for (int i = 0; i <= ilim; i++) {
+      R_re[i + j * r_rows] = a[i + j * m].real;
+      R_im[i + j * r_rows] = a[i + j * m].imag;
+    }
+  }
+
+  // Generate Q via zungqr
+  int q_cols = econ ? k : m;
+  std::vector<lapack_complex_double> q_buf(m * q_cols, {0.0, 0.0});
+  int cols_to_copy = n < q_cols ? n : q_cols;
+  for (int j = 0; j < cols_to_copy; j++) {
+    for (int i = 0; i < m; i++) {
+      q_buf[i + j * m] = a[i + j * m];
+    }
+  }
+
+  lwork = -1;
+  zungqr_(&m, &q_cols, &k, q_buf.data(), &m, tau.data(),
+          &work_query, &lwork, &info_val);
+  lwork = static_cast<int>(work_query.real);
+  if (lwork < 1) lwork = q_cols;
+
+  work.assign(lwork, {0.0, 0.0});
+  zungqr_(&m, &q_cols, &k, q_buf.data(), &m, tau.data(),
+          work.data(), &lwork, &info_val);
+
+  if (!checkLapackInfo(env, info_val, "qrPivotComplex", "zungqr"))
+    return env.Null();
+
+  auto result = Napi::Object::New(env);
+  setSplitComplex(env, result, "QRe", "QIm", q_buf.data(), m * q_cols);
+  result.Set("RRe", vecToF64(env, R_re));
+  result.Set("RIm", vecToF64(env, R_im));
+  result.Set("jpvt", vecToI32(env, jpvt));
+  return result;
+}
+
 // ── qrComplex() ──────────────────────────────────────────────────────────────
 
 Napi::Value QrComplex(const Napi::CallbackInfo& info) {

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,17 +19,42 @@
  *   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"),
               Napi::Function::New(env, InvComplex));
   exports.Set(Napi::String::New(env, "qr"),
               Napi::Function::New(env, Qr));
+  exports.Set(Napi::String::New(env, "qrPivot"),
+              Napi::Function::New(env, QrPivot));
+  exports.Set(Napi::String::New(env, "qrPivotComplex"),
+              Napi::Function::New(env, QrPivotComplex));
   exports.Set(Napi::String::New(env, "qrComplex"),
               Napi::Function::New(env, QrComplex));
   exports.Set(Napi::String::New(env, "lu"),
@@ -42,6 +67,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 +91,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)