numbl 0.0.7 → 0.0.10

package/native/lapack_addon.cpp

@@ -6,11 +6,16 @@
  *   inv(data, n)                      — real matrix inversion      (lapack_inv.cpp)
  *   invComplex(dataRe, dataIm, n)     — complex matrix inversion   (lapack_inv.cpp)
  *   qr(data, m, n, econ, wantQ)       — QR decomposition           (lapack_qr.cpp)
+ *   qrComplex(dataRe, dataIm, m, n, econ, wantQ) — complex QR      (lapack_qr.cpp)
+ *   lu(data, m, n)                    — LU factorization           (lapack_lu.cpp)
+ *   luComplex(dataRe, dataIm, m, n)  — complex LU factorization   (lapack_lu.cpp)
  *   svd(data, m, n, econ, computeUV)  — Singular Value Decomp.     (lapack_svd.cpp)
  *   matmul(A, m, k, B, n)             — matrix-matrix multiply     (lapack_matmul.cpp)
  *   linsolve(A, m, n, B, nrhs)        — linear solve / least-sq    (lapack_linsolve.cpp)
  *   linsolveComplex(ARe, AIm, m, n, BRe, BIm, nrhs) — complex linear solve (lapack_linsolve.cpp)
  *   eig(data, n, computeVL, computeVR, balance) — eigenvalue decomp. (lapack_eig.cpp)
+ *   chol(data, n, upper)             — Cholesky factorization    (lapack_chol.cpp)
+ *   cholComplex(dataRe, dataIm, n, upper) — complex Cholesky     (lapack_chol.cpp)
  */
 
 #include "lapack_common.h"
@@ -24,8 +29,16 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
               Napi::Function::New(env, InvComplex));
   exports.Set(Napi::String::New(env, "qr"),
               Napi::Function::New(env, Qr));
+  exports.Set(Napi::String::New(env, "qrComplex"),
+              Napi::Function::New(env, QrComplex));
+  exports.Set(Napi::String::New(env, "lu"),
+              Napi::Function::New(env, Lu));
+  exports.Set(Napi::String::New(env, "luComplex"),
+              Napi::Function::New(env, LuComplex));
   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"),
@@ -34,6 +47,10 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
               Napi::Function::New(env, LinsolveComplex));
   exports.Set(Napi::String::New(env, "eig"),
               Napi::Function::New(env, Eig));
+  exports.Set(Napi::String::New(env, "chol"),
+              Napi::Function::New(env, Chol));
+  exports.Set(Napi::String::New(env, "cholComplex"),
+              Napi::Function::New(env, CholComplex));
   return exports;
 }
 

package/native/lapack_chol.cpp

@@ -0,0 +1,173 @@
+/**
+ * chol() and cholComplex() — Cholesky factorization via LAPACK.
+ *
+ *   chol(data: Float64Array, n: number, upper: boolean):
+ *       {R: Float64Array, info: number}
+ *
+ *   cholComplex(dataRe: Float64Array, dataIm: Float64Array, n: number, upper: boolean):
+ *       {RRe: Float64Array, RIm: Float64Array, info: number}
+ *
+ *     Cholesky factorization of an n×n symmetric (Hermitian) positive definite
+ *     matrix stored in column-major order.
+ *     Uses LAPACK dpotrf (real) / zpotrf (complex).
+ *     Returns the triangular factor and info (0 = success, >0 = not pos def).
+ */
+
+#include "lapack_common.h"
+
+// ── chol() ───────────────────────────────────────────────────────────────────
+
+Napi::Value Chol(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 3
+      || !info[0].IsTypedArray()
+      || !info[1].IsNumber()
+      || !info[2].IsBoolean()) {
+    Napi::TypeError::New(env,
+      "chol: expected (Float64Array data, number n, boolean upper)")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  auto arr = info[0].As<Napi::TypedArray>();
+  if (arr.TypedArrayType() != napi_float64_array) {
+    Napi::TypeError::New(env, "chol: data must be a Float64Array")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  int n = info[1].As<Napi::Number>().Int32Value();
+  bool upper = info[2].As<Napi::Boolean>().Value();
+
+  if (n <= 0 || static_cast<int>(arr.ElementLength()) != n * n) {
+    Napi::RangeError::New(env, "chol: data.length must equal n*n")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  auto float64arr = info[0].As<Napi::Float64Array>();
+
+  // Copy input (dpotrf overwrites in-place)
+  std::vector<double> a(n * n);
+  std::memcpy(a.data(), float64arr.Data(), n * n * sizeof(double));
+
+  char uplo = upper ? 'U' : 'L';
+  int info_val = 0;
+
+  dpotrf_(&uplo, &n, a.data(), &n, &info_val);
+
+  if (info_val < 0) {
+    Napi::Error::New(env, "chol: illegal argument passed to dpotrf")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  // Zero out the opposite triangle
+  if (upper) {
+    for (int j = 0; j < n; j++)
+      for (int i = j + 1; i < n; i++)
+        a[i + j * n] = 0.0;
+  } else {
+    for (int j = 0; j < n; j++)
+      for (int i = 0; i < j; i++)
+        a[i + j * n] = 0.0;
+  }
+
+  auto R_arr = Napi::Float64Array::New(env, static_cast<size_t>(n * n));
+  std::memcpy(R_arr.Data(), a.data(), n * n * sizeof(double));
+
+  auto result = Napi::Object::New(env);
+  result.Set("R", R_arr);
+  result.Set("info", Napi::Number::New(env, info_val));
+  return result;
+}
+
+// ── cholComplex() ────────────────────────────────────────────────────────────
+
+Napi::Value CholComplex(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 4
+      || !info[0].IsTypedArray()
+      || !info[1].IsTypedArray()
+      || !info[2].IsNumber()
+      || !info[3].IsBoolean()) {
+    Napi::TypeError::New(env,
+      "cholComplex: expected (Float64Array dataRe, Float64Array dataIm, "
+      "number n, boolean upper)")
+        .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, "cholComplex: dataRe and dataIm must be Float64Arrays")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  int n = info[2].As<Napi::Number>().Int32Value();
+  bool upper = info[3].As<Napi::Boolean>().Value();
+
+  if (n <= 0 ||
+      static_cast<int>(arrRe.ElementLength()) != n * n ||
+      static_cast<int>(arrIm.ElementLength()) != n * n) {
+    Napi::RangeError::New(env,
+      "cholComplex: dataRe.length and dataIm.length must equal n*n")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  auto float64arrRe = info[0].As<Napi::Float64Array>();
+  auto float64arrIm = info[1].As<Napi::Float64Array>();
+
+  // Convert to interleaved complex format
+  std::vector<lapack_complex_double> a(n * n);
+  for (int i = 0; i < n * n; ++i) {
+    a[i].real = float64arrRe[i];
+    a[i].imag = float64arrIm[i];
+  }
+
+  char uplo = upper ? 'U' : 'L';
+  int info_val = 0;
+
+  zpotrf_(&uplo, &n, a.data(), &n, &info_val);
+
+  if (info_val < 0) {
+    Napi::Error::New(env, "cholComplex: illegal argument passed to zpotrf")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  // Zero out the opposite triangle
+  if (upper) {
+    for (int j = 0; j < n; j++)
+      for (int i = j + 1; i < n; i++) {
+        a[i + j * n].real = 0.0;
+        a[i + j * n].imag = 0.0;
+      }
+  } else {
+    for (int j = 0; j < n; j++)
+      for (int i = 0; i < j; i++) {
+        a[i + j * n].real = 0.0;
+        a[i + j * n].imag = 0.0;
+      }
+  }
+
+  auto RRe_arr = Napi::Float64Array::New(env, static_cast<size_t>(n * n));
+  auto RIm_arr = Napi::Float64Array::New(env, static_cast<size_t>(n * n));
+  for (int i = 0; i < n * n; ++i) {
+    RRe_arr[i] = a[i].real;
+    RIm_arr[i] = a[i].imag;
+  }
+
+  auto result = Napi::Object::New(env);
+  result.Set("RRe", RRe_arr);
+  result.Set("RIm", RIm_arr);
+  result.Set("info", Napi::Number::New(env, info_val));
+  return result;
+}

package/native/lapack_common.h

@@ -43,12 +43,37 @@ extern "C" {
   void dorgqr_(int* m, int* n, int* k, double* a, int* lda, double* tau,
                double* work, int* lwork, int* info);
 
+  // ── Complex QR factorisation ───────────────────────────────────────────────
+  // Compute QR factorisation of a general complex m×n matrix: A = Q * R
+  void zgeqrf_(int* m, int* n, lapack_complex_double* a, int* lda,
+               lapack_complex_double* tau,
+               lapack_complex_double* work, int* lwork, int* info);
+  // Generate the m×n (or m×m) unitary matrix Q from zgeqrf reflectors
+  void zungqr_(int* m, int* n, int* k, lapack_complex_double* a, int* lda,
+               lapack_complex_double* tau,
+               lapack_complex_double* work, int* lwork, int* info);
+
   // ── SVD ───────────────────────────────────────────────────────────────────
   // Compute SVD using divide-and-conquer: A = U * Sigma * V^T
   void dgesdd_(char* jobz, int* m, int* n, double* a, int* lda,
                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);
+
+  // Complex SVD (standard algorithm, more robust fallback): A = U * Sigma * V^H
+  void zgesvd_(char* jobu, char* jobvt, 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* info);
+
   // ── Matrix-matrix multiplication (BLAS) ──────────────────────────────────
   // C = alpha * op(A) * op(B) + beta * C
   void dgemm_(char* transa, char* transb,
@@ -88,6 +113,15 @@ extern "C" {
               double* wr, double* wi,
               double* vl, int* ldvl, double* vr, int* ldvr,
               double* work, int* lwork, int* info);
+
+  // ── Cholesky factorization ─────────────────────────────────────────────────
+  // Compute the Cholesky factorization of a real symmetric positive definite
+  // matrix: A = U^T * U (uplo='U') or A = L * L^T (uplo='L')
+  void dpotrf_(char* uplo, int* n, double* a, int* lda, int* info);
+
+  // Complex Cholesky factorization of a Hermitian positive definite matrix:
+  // A = U^H * U (uplo='U') or A = L * L^H (uplo='L')
+  void zpotrf_(char* uplo, int* n, lapack_complex_double* a, int* lda, int* info);
 }
 
 // ── Function prototypes (implemented in their respective .cpp files) ──────────
@@ -95,8 +129,14 @@ extern "C" {
 Napi::Value Inv(const Napi::CallbackInfo& info);
 Napi::Value InvComplex(const Napi::CallbackInfo& info);
 Napi::Value Qr(const Napi::CallbackInfo& info);
+Napi::Value QrComplex(const Napi::CallbackInfo& info);
+Napi::Value Lu(const Napi::CallbackInfo& info);
+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 Linsolve(const Napi::CallbackInfo& info);
 Napi::Value LinsolveComplex(const Napi::CallbackInfo& info);
 Napi::Value Eig(const Napi::CallbackInfo& info);
+Napi::Value Chol(const Napi::CallbackInfo& info);
+Napi::Value CholComplex(const Napi::CallbackInfo& info);

package/native/lapack_lu.cpp

@@ -0,0 +1,156 @@
+/**
+ * lu() and luComplex() — LU factorization with partial pivoting via LAPACK.
+ *
+ *   lu(data: Float64Array, m: number, n: number):
+ *       {LU: Float64Array, ipiv: Int32Array}
+ *
+ *   luComplex(dataRe: Float64Array, dataIm: Float64Array, m: number, n: number):
+ *       {LURe: Float64Array, LUIm: Float64Array, ipiv: Int32Array}
+ *
+ *     LU factorization of an m×n matrix stored in column-major order.
+ *     Uses LAPACK dgetrf (real) / zgetrf (complex) with partial pivoting.
+ *     Returns the packed LU matrix and 1-based pivot indices.
+ */
+
+#include "lapack_common.h"
+
+// ── lu() ─────────────────────────────────────────────────────────────────────
+
+Napi::Value Lu(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 3
+      || !info[0].IsTypedArray()
+      || !info[1].IsNumber()
+      || !info[2].IsNumber()) {
+    Napi::TypeError::New(env,
+      "lu: expected (Float64Array data, number m, number n)")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  auto arr = info[0].As<Napi::TypedArray>();
+  if (arr.TypedArrayType() != napi_float64_array) {
+    Napi::TypeError::New(env, "lu: 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();
+
+  if (m <= 0 || n <= 0 || static_cast<int>(arr.ElementLength()) != m * n) {
+    Napi::RangeError::New(env, "lu: 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 (dgetrf overwrites A in-place)
+  std::vector<double> a(m * n);
+  std::memcpy(a.data(), float64arr.Data(), m * n * sizeof(double));
+
+  std::vector<int> ipiv(k);
+  int info_val = 0;
+
+  dgetrf_(&m, &n, a.data(), &m, ipiv.data(), &info_val);
+
+  if (info_val < 0) {
+    Napi::Error::New(env, "lu: illegal argument passed to dgetrf")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  // info_val > 0 means U(info_val,info_val) is zero (singular) — still return result like MATLAB
+
+  auto LU_arr = Napi::Float64Array::New(env, static_cast<size_t>(m * n));
+  std::memcpy(LU_arr.Data(), a.data(), m * n * sizeof(double));
+
+  auto ipiv_arr = Napi::Int32Array::New(env, static_cast<size_t>(k));
+  std::memcpy(ipiv_arr.Data(), ipiv.data(), k * sizeof(int));
+
+  auto result = Napi::Object::New(env);
+  result.Set("LU", LU_arr);
+  result.Set("ipiv", ipiv_arr);
+  return result;
+}
+
+// ── luComplex() ──────────────────────────────────────────────────────────────
+
+Napi::Value LuComplex(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 4
+      || !info[0].IsTypedArray()
+      || !info[1].IsTypedArray()
+      || !info[2].IsNumber()
+      || !info[3].IsNumber()) {
+    Napi::TypeError::New(env,
+      "luComplex: expected (Float64Array dataRe, Float64Array dataIm, "
+      "number m, number n)")
+        .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, "luComplex: 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();
+
+  if (m <= 0 || n <= 0 ||
+      static_cast<int>(arrRe.ElementLength()) != m * n ||
+      static_cast<int>(arrIm.ElementLength()) != m * n) {
+    Napi::RangeError::New(env,
+      "luComplex: dataRe.length and dataIm.length must equal m*n")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  auto float64arrRe = info[0].As<Napi::Float64Array>();
+  auto float64arrIm = info[1].As<Napi::Float64Array>();
+  int k = m < n ? m : n;
+
+  // Convert to interleaved complex format
+  std::vector<lapack_complex_double> a(m * n);
+  for (int i = 0; i < m * n; ++i) {
+    a[i].real = float64arrRe[i];
+    a[i].imag = float64arrIm[i];
+  }
+
+  std::vector<int> ipiv(k);
+  int info_val = 0;
+
+  zgetrf_(&m, &n, a.data(), &m, ipiv.data(), &info_val);
+
+  if (info_val < 0) {
+    Napi::Error::New(env, "luComplex: illegal argument passed to zgetrf")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  // info_val > 0 means U(info_val,info_val) is zero (singular) — still return result like MATLAB
+
+  auto LURe_arr = Napi::Float64Array::New(env, static_cast<size_t>(m * n));
+  auto LUIm_arr = Napi::Float64Array::New(env, static_cast<size_t>(m * n));
+  for (int i = 0; i < m * n; ++i) {
+    LURe_arr[i] = a[i].real;
+    LUIm_arr[i] = a[i].imag;
+  }
+
+  auto ipiv_arr = Napi::Int32Array::New(env, static_cast<size_t>(k));
+  std::memcpy(ipiv_arr.Data(), ipiv.data(), k * sizeof(int));
+
+  auto result = Napi::Object::New(env);
+  result.Set("LURe", LURe_arr);
+  result.Set("LUIm", LUIm_arr);
+  result.Set("ipiv", ipiv_arr);
+  return result;
+}

package/native/lapack_qr.cpp

@@ -1,14 +1,17 @@
 /**
- * qr() — QR decomposition via LAPACK dgeqrf + dorgqr.
+ * qr() and qrComplex() — QR decomposition via LAPACK.
  *
  *   qr(data: Float64Array, m: number, n: number, econ: boolean,
  *      wantQ: boolean): {Q: Float64Array | undefined, R: Float64Array}
  *
+ *   qrComplex(dataRe: Float64Array, dataIm: Float64Array, m: number, n: number,
+ *             econ: boolean, wantQ: boolean):
+ *             {QRe?: Float64Array, QIm?: Float64Array, RRe: Float64Array, RIm: Float64Array}
+ *
  *     QR decomposition of an m×n matrix stored in column-major order.
  *     econ=true:   economy/thin QR — Q is m×k, R is k×n  (k = min(m,n))
  *     econ=false:  full QR         — Q is m×m, R is m×n
- *     wantQ=false: skips dorgqr; Q property is absent from the returned object.
- *     Returns object with {Q, R} as Float64Arrays in column-major order.
+ *     wantQ=false: skips Q generation; Q properties are absent from the returned object.
  */
 
 #include "lapack_common.h"
@@ -131,3 +134,138 @@ Napi::Value Qr(const Napi::CallbackInfo& info) {
 
   return result;
 }
+
+// ── qrComplex() ──────────────────────────────────────────────────────────────
+
+Napi::Value QrComplex(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,
+      "qrComplex: expected (Float64Array dataRe, Float64Array dataIm, "
+      "number m, number n, boolean econ, boolean wantQ)")
+        .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, "qrComplex: 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();
+  bool wantQ = 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,
+      "qrComplex: dataRe.length and dataIm.length must equal m*n")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  auto float64arrRe = info[0].As<Napi::Float64Array>();
+  auto float64arrIm = info[1].As<Napi::Float64Array>();
+  int k = m < n ? m : n;
+
+  // ── Step 1: Convert to interleaved complex format ──────────────────────────
+  std::vector<lapack_complex_double> a(m * n);
+  for (int i = 0; i < m * n; ++i) {
+    a[i].real = float64arrRe[i];
+    a[i].imag = float64arrIm[i];
+  }
+
+  std::vector<lapack_complex_double> tau(k);
+  int info_val = 0;
+
+  // ── Step 2: QR factorisation (zgeqrf) ──────────────────────────────────────
+  int lwork = -1;
+  lapack_complex_double work_query;
+  zgeqrf_(&m, &n, a.data(), &m, tau.data(), &work_query, &lwork, &info_val);
+  lwork = static_cast<int>(work_query.real);
+  if (lwork < 1) lwork = k;
+
+  std::vector<lapack_complex_double> work(lwork);
+  zgeqrf_(&m, &n, a.data(), &m, tau.data(), work.data(), &lwork, &info_val);
+
+  if (info_val != 0) {
+    Napi::Error::New(env, "qrComplex: zgeqrf failed")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  // ── Step 3: Extract R from the upper triangle ──────────────────────────────
+  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;
+    }
+  }
+
+  // ── Step 4: Generate Q via zungqr (only if wantQ) ─────────────────────────
+  int q_cols = econ ? k : m;
+
+  auto result = Napi::Object::New(env);
+
+  if (wantQ) {
+    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 (info_val != 0) {
+      Napi::Error::New(env, "qrComplex: zungqr failed")
+          .ThrowAsJavaScriptException();
+      return env.Null();
+    }
+
+    auto QRe_arr = Napi::Float64Array::New(env, static_cast<size_t>(m * q_cols));
+    auto QIm_arr = Napi::Float64Array::New(env, static_cast<size_t>(m * q_cols));
+    for (int i = 0; i < m * q_cols; ++i) {
+      QRe_arr[i] = q_buf[i].real;
+      QIm_arr[i] = q_buf[i].imag;
+    }
+    result.Set("QRe", QRe_arr);
+    result.Set("QIm", QIm_arr);
+  }
+
+  auto RRe_arr = Napi::Float64Array::New(env, static_cast<size_t>(r_rows * n));
+  auto RIm_arr = Napi::Float64Array::New(env, static_cast<size_t>(r_rows * n));
+  std::memcpy(RRe_arr.Data(), R_re.data(), r_rows * n * sizeof(double));
+  std::memcpy(RIm_arr.Data(), R_im.data(), r_rows * n * sizeof(double));
+  result.Set("RRe", RRe_arr);
+  result.Set("RIm", RIm_arr);
+
+  return result;
+}