numbl 0.0.7 → 0.0.8

package/native/lapack_addon.cpp

@@ -26,6 +26,8 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
               Napi::Function::New(env, Qr));
   exports.Set(Napi::String::New(env, "svd"),
               Napi::Function::New(env, Svd));
+  exports.Set(Napi::String::New(env, "svdComplex"),
+              Napi::Function::New(env, SvdComplex));
   exports.Set(Napi::String::New(env, "matmul"),
               Napi::Function::New(env, Matmul));
   exports.Set(Napi::String::New(env, "linsolve"),

package/native/lapack_common.h

@@ -49,6 +49,13 @@ extern "C" {
                double* s, double* u, int* ldu, double* vt, int* ldvt,
                double* work, int* lwork, int* iwork, int* info);
 
+  // Complex SVD using divide-and-conquer: A = U * Sigma * V^H
+  void zgesdd_(char* jobz, int* m, int* n, lapack_complex_double* a, int* lda,
+               double* s, lapack_complex_double* u, int* ldu,
+               lapack_complex_double* vt, int* ldvt,
+               lapack_complex_double* work, int* lwork, double* rwork,
+               int* iwork, int* info);
+
   // ── Matrix-matrix multiplication (BLAS) ──────────────────────────────────
   // C = alpha * op(A) * op(B) + beta * C
   void dgemm_(char* transa, char* transb,
@@ -96,6 +103,7 @@ Napi::Value Inv(const Napi::CallbackInfo& info);
 Napi::Value InvComplex(const Napi::CallbackInfo& info);
 Napi::Value Qr(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 Linsolve(const Napi::CallbackInfo& info);
 Napi::Value LinsolveComplex(const Napi::CallbackInfo& info);

package/native/lapack_svd.cpp

@@ -147,3 +147,161 @@ Napi::Value Svd(const Napi::CallbackInfo& info) {
 
   return result;
 }
+
+// ── svdComplex() ─────────────────────────────────────────────────────────────
+
+Napi::Value SvdComplex(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 6
+      || !info[0].IsTypedArray()
+      || !info[1].IsTypedArray()
+      || !info[2].IsNumber()
+      || !info[3].IsNumber()
+      || !info[4].IsBoolean()
+      || !info[5].IsBoolean()) {
+    Napi::TypeError::New(env,
+      "svdComplex: expected (Float64Array dataRe, Float64Array dataIm, number m, number n, boolean econ, boolean computeUV)")
+        .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, "svdComplex: data 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();
+  bool computeUV = info[5].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, "svdComplex: data.length must equal m*n")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  auto float64Re = info[0].As<Napi::Float64Array>();
+  auto float64Im = info[1].As<Napi::Float64Array>();
+  int k = m < n ? m : n;
+
+  // Convert split real/imag to interleaved complex format
+  std::vector<lapack_complex_double> a(m * n);
+  for (int i = 0; i < m * n; ++i) {
+    a[i].real = float64Re[i];
+    a[i].imag = float64Im[i];
+  }
+
+  std::vector<double> s(k);
+  int info_val = 0;
+
+  char jobz;
+  if (!computeUV) {
+    jobz = 'N';
+  } else if (econ) {
+    jobz = 'S';
+  } else {
+    jobz = 'A';
+  }
+
+  int ldu, ldvt;
+  std::vector<lapack_complex_double> u_vec, vt_vec;
+
+  if (jobz == 'N') {
+    ldu  = m;
+    ldvt = n;
+  } else if (jobz == 'S') {
+    ldu  = m;
+    ldvt = k;
+    u_vec.resize(m * k);
+    vt_vec.resize(k * n);
+  } else { // 'A'
+    ldu  = m;
+    ldvt = n;
+    u_vec.resize(m * m);
+    vt_vec.resize(n * n);
+  }
+
+  lapack_complex_double* u_ptr  = (jobz == 'N') ? nullptr : u_vec.data();
+  lapack_complex_double* vt_ptr = (jobz == 'N') ? nullptr : vt_vec.data();
+
+  // Compute rwork size for zgesdd
+  // For jobz='N': 5*min(m,n)
+  // For jobz='S' or 'A': max(5*min(m,n)^2 + 5*min(m,n), 2*max(m,n)*min(m,n) + 2*min(m,n)^2 + min(m,n))
+  int rwork_size;
+  if (jobz == 'N') {
+    rwork_size = 5 * k;
+  } else {
+    int t1 = 5 * k * k + 5 * k;
+    int t2 = 2 * std::max(m, n) * k + 2 * k * k + k;
+    rwork_size = std::max(t1, t2);
+  }
+  std::vector<double> rwork(rwork_size);
+  std::vector<int> iwork(8 * k);
+
+  // Workspace query
+  int lwork = -1;
+  lapack_complex_double work_query;
+  zgesdd_(&jobz, &m, &n, a.data(), &m, s.data(), u_ptr, &ldu, vt_ptr, &ldvt,
+          &work_query, &lwork, rwork.data(), iwork.data(), &info_val);
+
+  lwork = static_cast<int>(work_query.real);
+  if (lwork < 1) lwork = 3 * k + std::max(m, n);
+
+  std::vector<lapack_complex_double> work(lwork);
+  zgesdd_(&jobz, &m, &n, a.data(), &m, s.data(), u_ptr, &ldu, vt_ptr, &ldvt,
+          work.data(), &lwork, rwork.data(), iwork.data(), &info_val);
+
+  if (info_val != 0) {
+    Napi::Error::New(env, "svdComplex: zgesdd failed")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  // Build result
+  auto result = Napi::Object::New(env);
+
+  // S is always real
+  auto S_arr = Napi::Float64Array::New(env, static_cast<size_t>(k));
+  std::memcpy(S_arr.Data(), s.data(), k * sizeof(double));
+  result.Set("S", S_arr);
+
+  if (computeUV) {
+    // U: convert from interleaved to split real/imag
+    int u_size = (jobz == 'S') ? m * k : m * m;
+    auto URe = Napi::Float64Array::New(env, static_cast<size_t>(u_size));
+    auto UIm = Napi::Float64Array::New(env, static_cast<size_t>(u_size));
+    for (int i = 0; i < u_size; i++) {
+      URe[i] = u_vec[i].real;
+      UIm[i] = u_vec[i].imag;
+    }
+    result.Set("URe", URe);
+    result.Set("UIm", UIm);
+
+    // V = conj(VT^T): conjugate transpose of VT
+    int vt_rows = (jobz == 'S') ? k : n;
+    int vt_cols = n;
+    int v_size = vt_rows * vt_cols;
+    auto VRe = Napi::Float64Array::New(env, static_cast<size_t>(v_size));
+    auto VIm = Napi::Float64Array::New(env, static_cast<size_t>(v_size));
+    for (int i = 0; i < vt_rows; i++) {
+      for (int j = 0; j < vt_cols; j++) {
+        // V(j, i) = conj(VT(i, j)) — column-major conjugate transpose
+        int v_idx = j + i * vt_cols;
+        int vt_idx = i + j * vt_rows;
+        VRe[v_idx] = vt_vec[vt_idx].real;
+        VIm[v_idx] = -vt_vec[vt_idx].imag;  // conjugate
+      }
+    }
+    result.Set("VRe", VRe);
+    result.Set("VIm", VIm);
+  }
+
+  return result;
+}

package/package.json

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