numbl 0.1.7 → 0.3.0

package/native/jit_runtime/jit_runtime.c

@@ -0,0 +1,261 @@
+/**
+ * numbl_jit_runtime — see jit_runtime.h for the shape and invariants.
+ */
+
+#include "jit_runtime.h"
+#include "numbl_ops.h"
+
+#include <math.h>
+#include <string.h>
+#include <time.h>
+
+int numbl_jit_rt_version(void) {
+  return NUMBL_JIT_RT_VERSION;
+}
+
+double numbl_idx1r(const double* data, size_t len, double i, double* err_flag) {
+  /* Truncation-to-zero via int64 cast mirrors JS-JIT's `(i - 1) | 0`.
+   * Unsigned compare catches both negative idx and idx >= len in one
+   * branch. */
+  int64_t idx = (int64_t)(i - 1.0);
+  if ((uint64_t)idx >= (uint64_t)len) {
+    *err_flag = 1.0;
+    return 0.0;
+  }
+  return data[idx];
+}
+
+void numbl_set1r_h(double* data, size_t len, double i, double v,
+                   double* err_flag) {
+  int64_t idx = (int64_t)(i - 1.0);
+  if ((uint64_t)idx >= (uint64_t)len) {
+    /* 2.0 = "growth needed → soft-bail to interpreter", distinct from
+     * 1.0 which the JS wrapper translates into a hard bounds error. */
+    *err_flag = 2.0;
+    return;
+  }
+  data[idx] = v;
+}
+
+double numbl_idx2r(const double* data, size_t len, size_t d0,
+                   double i, double j, double* err_flag) {
+  int64_t r = (int64_t)(i - 1.0);
+  int64_t c = (int64_t)(j - 1.0);
+  /* d0 == 0 would mean an empty tensor — any index is OOB. */
+  if (d0 == 0 || (uint64_t)r >= (uint64_t)d0) {
+    *err_flag = 1.0;
+    return 0.0;
+  }
+  size_t cols = len / d0;
+  if ((uint64_t)c >= (uint64_t)cols) {
+    *err_flag = 1.0;
+    return 0.0;
+  }
+  return data[(size_t)c * d0 + (size_t)r];
+}
+
+double numbl_idx3r(const double* data, size_t len, size_t d0, size_t d1,
+                   double i, double j, double k, double* err_flag) {
+  int64_t k0 = (int64_t)(i - 1.0);
+  int64_t k1 = (int64_t)(j - 1.0);
+  int64_t k2 = (int64_t)(k - 1.0);
+  if (d0 == 0 || d1 == 0 ||
+      (uint64_t)k0 >= (uint64_t)d0 ||
+      (uint64_t)k1 >= (uint64_t)d1) {
+    *err_flag = 1.0;
+    return 0.0;
+  }
+  size_t plane = d0 * d1;
+  size_t d2 = len / plane;
+  if ((uint64_t)k2 >= (uint64_t)d2) {
+    *err_flag = 1.0;
+    return 0.0;
+  }
+  return data[(size_t)k2 * plane + (size_t)k1 * d0 + (size_t)k0];
+}
+
+void numbl_set2r_h(double* data, size_t len, size_t d0,
+                   double i, double j, double v, double* err_flag) {
+  int64_t r = (int64_t)(i - 1.0);
+  int64_t c = (int64_t)(j - 1.0);
+  if (d0 == 0) {
+    *err_flag = 2.0;
+    return;
+  }
+  size_t cols = len / d0;
+  if ((uint64_t)r >= (uint64_t)d0 || (uint64_t)c >= (uint64_t)cols) {
+    *err_flag = 2.0;
+    return;
+  }
+  data[(size_t)c * d0 + (size_t)r] = v;
+}
+
+void numbl_set3r_h(double* data, size_t len, size_t d0, size_t d1,
+                   double i, double j, double k, double v,
+                   double* err_flag) {
+  int64_t k0 = (int64_t)(i - 1.0);
+  int64_t k1 = (int64_t)(j - 1.0);
+  int64_t k2 = (int64_t)(k - 1.0);
+  if (d0 == 0 || d1 == 0) {
+    *err_flag = 2.0;
+    return;
+  }
+  size_t plane = d0 * d1;
+  size_t d2 = len / plane;
+  if ((uint64_t)k0 >= (uint64_t)d0 ||
+      (uint64_t)k1 >= (uint64_t)d1 ||
+      (uint64_t)k2 >= (uint64_t)d2) {
+    *err_flag = 2.0;
+    return;
+  }
+  data[(size_t)k2 * plane + (size_t)k1 * d0 + (size_t)k0] = v;
+}
+
+void numbl_setRange1r_h(double* dstData, size_t dstLen,
+                        double dstStart, double dstEnd,
+                        const double* srcData, size_t srcLen,
+                        double srcStart, double srcEnd,
+                        double* err_flag) {
+  int64_t dS = (int64_t)(dstStart - 1.0);
+  int64_t dE = (int64_t)(dstEnd - 1.0);
+  int64_t sS = (int64_t)(srcStart - 1.0);
+  int64_t sE = (int64_t)(srcEnd - 1.0);
+  int64_t dN = dE - dS + 1;
+  int64_t sN = sE - sS + 1;
+  if (dN != sN) {
+    /* 3.0 — length-mismatch error; JS wrapper translates to MATLAB's
+     * "Unable to perform assignment..." message. */
+    *err_flag = 3.0;
+    return;
+  }
+  if (dN <= 0) return;
+  if ((uint64_t)dS >= (uint64_t)dstLen ||
+      (uint64_t)dE >= (uint64_t)dstLen ||
+      (uint64_t)sS >= (uint64_t)srcLen ||
+      (uint64_t)sE >= (uint64_t)srcLen) {
+    *err_flag = 1.0;
+    return;
+  }
+  /* memmove handles overlap when src and dst alias. */
+  memmove(dstData + (size_t)dS, srcData + (size_t)sS,
+          (size_t)dN * sizeof(double));
+}
+
+void numbl_setCol2r_h(double* dstData, size_t dstRows, size_t dstLen,
+                      double col,
+                      const double* srcData, size_t srcLen,
+                      double* err_flag) {
+  if (srcLen != dstRows) {
+    *err_flag = 3.0;
+    return;
+  }
+  int64_t j = (int64_t)(col - 1.0);
+  if (j < 0) {
+    *err_flag = 1.0;
+    return;
+  }
+  if (dstRows == 0) {
+    /* Empty dst with a nonempty src: growth territory — soft-bail. */
+    *err_flag = 2.0;
+    return;
+  }
+  size_t dstCols = dstLen / dstRows;
+  if ((uint64_t)j >= (uint64_t)dstCols) {
+    /* Growth on write — the interpreter handles growing dst; JS-JIT
+     * mirrors this with JitBailToInterpreter. */
+    *err_flag = 2.0;
+    return;
+  }
+  memcpy(dstData + (size_t)j * dstRows, srcData,
+         dstRows * sizeof(double));
+}
+
+void numbl_copyRange1r(const double* srcData, size_t srcLen,
+                       double start, double end,
+                       double* dstData,
+                       double* err_flag) {
+  int64_t s = (int64_t)(start - 1.0);
+  int64_t e = (int64_t)(end - 1.0);
+  int64_t n = e - s + 1;
+  if (n <= 0) return;
+  if ((uint64_t)s >= (uint64_t)srcLen ||
+      (uint64_t)e >= (uint64_t)srcLen) {
+    *err_flag = 1.0;
+    return;
+  }
+  memcpy(dstData, srcData + (size_t)s, (size_t)n * sizeof(double));
+}
+
+double numbl_mod(double a, double b) {
+  if (b == 0.0) return a;
+  double r = fmod(a, b);
+  if (r != 0.0 && ((r < 0.0) != (b < 0.0))) r += b;
+  return r;
+}
+
+double numbl_sign(double x) {
+  if (x > 0.0) return 1.0;
+  if (x < 0.0) return -1.0;
+  return 0.0;
+}
+
+double numbl_reduce_flat(int op, const double* data, int64_t len) {
+  double out = 0.0;
+  numbl_real_flat_reduce(op, (size_t)len, data, &out);
+  return out;
+}
+
+double numbl_monotonic_time(void) {
+  struct timespec ts;
+  clock_gettime(CLOCK_MONOTONIC, &ts);
+  return (double)ts.tv_sec + (double)ts.tv_nsec * 1e-9;
+}
+
+double numbl_tic(double* state) {
+  double t = numbl_monotonic_time();
+  *state = t;
+  return t;
+}
+
+double numbl_toc(const double* state) {
+  return numbl_monotonic_time() - *state;
+}
+
+/* ── NaN / Inf / finite predicates ─────────────────────────────────────
+ *
+ * Bit-pattern inspection so the answer doesn't depend on the caller's
+ * `-ffast-math` / `-ffinite-math-only` posture. IEEE-754 binary64
+ * double: sign bit (1) | exponent (11) | mantissa (52). NaN has
+ * exponent all-1s and non-zero mantissa; ±Inf has exponent all-1s and
+ * zero mantissa; finite values have exponent != all-1s.
+ *
+ * memcpy is the portable way to reinterpret the bit pattern (type-
+ * punning through a union is UB in strict C; the compiler may still
+ * generate a type-punning read from memcpy as a single mov on any
+ * real platform).
+ */
+
+static uint64_t bits_of(double x) {
+  uint64_t u;
+  memcpy(&u, &x, sizeof u);
+  return u;
+}
+
+#define NUMBL_DBL_EXP_MASK 0x7FF0000000000000ULL
+#define NUMBL_DBL_MANT_MASK 0x000FFFFFFFFFFFFFULL
+
+int numbl_is_nan(double x) {
+  uint64_t u = bits_of(x);
+  return (u & NUMBL_DBL_EXP_MASK) == NUMBL_DBL_EXP_MASK
+      && (u & NUMBL_DBL_MANT_MASK) != 0;
+}
+
+int numbl_is_inf(double x) {
+  uint64_t u = bits_of(x);
+  return (u & ~0x8000000000000000ULL) == NUMBL_DBL_EXP_MASK;
+}
+
+int numbl_is_finite(double x) {
+  uint64_t u = bits_of(x);
+  return (u & NUMBL_DBL_EXP_MASK) != NUMBL_DBL_EXP_MASK;
+}

package/native/jit_runtime/jit_runtime.h

@@ -0,0 +1,204 @@
+/**
+ * numbl_jit_runtime — helpers the C-JIT emitter calls from generated code.
+ *
+ * Kept in a static archive (jit_runtime.a) separate from numbl_ops.a:
+ * the `ops/` directory is reserved for op-code-dispatched kernels that
+ * achieve parity with the TS ops layer. Anything the JIT emitter calls
+ * *directly* from emitted C (bounds-checked index reads, MATLAB-semantics
+ * math helpers, tic/toc, reduction shims, ...) lives here instead.
+ *
+ * When adding a new helper, bump NUMBL_JIT_RT_VERSION below AND
+ * NUMBL_JIT_RT_REQUIRED_VERSION in jitCodegenC.ts. The generated C asserts
+ * `NUMBL_JIT_RT_VERSION >= N`, so a stale archive fails the per-JIT
+ * compile step with a clear "rebuild the addon" message instead of a
+ * cryptic linker error.
+ */
+
+#ifndef NUMBL_JIT_RUNTIME_H
+#define NUMBL_JIT_RUNTIME_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ── Version ──────────────────────────────────────────────────────────── */
+
+/**
+ * Version log:
+ *   1 — initial: idx1r, mod, sign, reduce_flat, tic/toc/monotonic_time.
+ *   2 — set1r_h (scalar linear Index write with soft-bail on OOB).
+ *   3 — idx2r / idx3r / set2r_h / set3r_h (multi-index Index read/write).
+ *   4 — setRange1r_h / setCol2r_h / copyRange1r (range/col slice r/w).
+ *   5 — is_nan / is_inf / is_finite (predicates that survive -ffast-math
+ *       by inspecting IEEE-754 bit patterns, not FP ops).
+ */
+#define NUMBL_JIT_RT_VERSION 5
+
+/** Returns NUMBL_JIT_RT_VERSION baked into the compiled archive. */
+int numbl_jit_rt_version(void);
+
+/* ── Scalar linear Index read ─────────────────────────────────────────── */
+
+/**
+ * 1-based MATLAB linear Index read on a real-valued tensor buffer.
+ *
+ *   `i` — 1-based double index (truncation-to-zero via int64 cast). The
+ *         emitter wraps non-integer indices with `round()` beforehand to
+ *         match the JS-JIT's `Math.round`-then-truncate sequence.
+ *   `err_flag` — set to 1.0 on OOB (and returns 0.0) so the C function
+ *                finishes without a native crash. The caller must zero
+ *                the flag before each koffi call; the JS wrapper checks
+ *                it after and throws "Index exceeds array bounds".
+ */
+double numbl_idx1r(const double* data, size_t len, double i, double* err_flag);
+
+/**
+ * 1-based MATLAB linear Index write on a real-valued tensor buffer.
+ *
+ * On OOB, writes `2.0` to *err_flag (the "growth-needed" code the JS
+ * wrapper translates to a JitBailToInterpreter) and returns without
+ * writing, mirroring the JS-JIT's `set1r_h` helper. The interpreter
+ * then re-runs the call with proper tensor-growth semantics. As with
+ * the read path, the caller must zero the flag before each call.
+ */
+void numbl_set1r_h(double* data, size_t len, double i, double v, double* err_flag);
+
+/* ── Multi-index Index read (2D, 3D) ──────────────────────────────────── */
+
+/**
+ * 1-based MATLAB 2D Index read on a real-valued tensor buffer.
+ *
+ * Column-major: returns data[(j-1)*d0 + (i-1)]. `d0` is the row count.
+ * The derived column count is `len / d0`; both dimensions are bounds-
+ * checked independently. Emitter wraps non-integer indices with
+ * `round()` to match the JS-JIT's `Math.round`-then-truncate sequence.
+ * On OOB, sets *err_flag = 1.0 and returns 0.0 (hard bounds error).
+ */
+double numbl_idx2r(const double* data, size_t len, size_t d0,
+                   double i, double j, double* err_flag);
+
+/**
+ * 1-based MATLAB 3D Index read on a real-valued tensor buffer.
+ *
+ * Column-major: returns data[((k-1)*d1 + (j-1))*d0 + (i-1)]. `d0` is
+ * the row count, `d1` the column count. The derived page count is
+ * `len / (d0 * d1)`; each dimension is bounds-checked independently.
+ */
+double numbl_idx3r(const double* data, size_t len, size_t d0, size_t d1,
+                   double i, double j, double k, double* err_flag);
+
+/* ── Multi-index Index write (2D, 3D), soft-bail on OOB ───────────────── */
+
+/**
+ * 2D Index write. On OOB (along either dim) writes `2.0` to *err_flag
+ * (the "growth-needed" code the JS wrapper translates to a
+ * JitBailToInterpreter) and returns without writing.
+ */
+void numbl_set2r_h(double* data, size_t len, size_t d0,
+                   double i, double j, double v, double* err_flag);
+
+/** 3D Index write with the same soft-bail convention as set2r_h. */
+void numbl_set3r_h(double* data, size_t len, size_t d0, size_t d1,
+                   double i, double j, double k, double v,
+                   double* err_flag);
+
+/* ── Range / column slice read and write ──────────────────────────────── */
+
+/**
+ * Range → range write: `dst(dStart:dEnd) = src(sStart:sEnd)` on real
+ * tensors, 1-based MATLAB indices. Sizes must match: on mismatch,
+ * writes `3.0` to *err_flag and returns (the JS wrapper translates this
+ * into "Unable to perform assignment because the indices on the left
+ * side are not compatible with the size of the right side."). Bounds
+ * violations on either range write `1.0` and return. Uses memmove so
+ * overlapping dst == src ranges are handled correctly.
+ */
+void numbl_setRange1r_h(double* dstData, size_t dstLen,
+                        double dstStart, double dstEnd,
+                        const double* srcData, size_t srcLen,
+                        double srcStart, double srcEnd,
+                        double* err_flag);
+
+/**
+ * Column-vector write into column `col` of a 2-D tensor `dst` with row
+ * count `dstRows`. `srcLen` must equal `dstRows` (length mismatch →
+ * *err_flag = 3.0). When `col` exceeds the current column count, the
+ * MATLAB interpreter would grow dst — we soft-bail (*err_flag = 2.0) so
+ * the caller's stale hoisted aliases don't corrupt the growth path.
+ */
+void numbl_setCol2r_h(double* dstData, size_t dstRows, size_t dstLen,
+                      double col,
+                      const double* srcData, size_t srcLen,
+                      double* err_flag);
+
+/**
+ * Range read: copy `src(start:end)` into caller-provided `dstData`. The
+ * caller must ensure `dstData` has capacity >= `end - start + 1`. OOB
+ * on `src` writes `1.0` to *err_flag and returns without writing.
+ * `start > end` is a valid empty range (no write, no error).
+ */
+void numbl_copyRange1r(const double* srcData, size_t srcLen,
+                       double start, double end,
+                       double* dstData,
+                       double* err_flag);
+
+/* ── Scalar math helpers with MATLAB semantics ────────────────────────── */
+
+/** MATLAB `mod(a, b)`: result has the sign of `b`; `mod(a, 0) == a`. */
+double numbl_mod(double a, double b);
+
+/** Three-valued sign: -1, 0, or 1. */
+double numbl_sign(double x);
+
+/* ── Reduction wrapper ────────────────────────────────────────────────── */
+
+/**
+ * Thin wrapper around numbl_real_flat_reduce (from numbl_ops.a) that
+ * returns the scalar directly, so generated C doesn't need a local
+ * `double out; … ; return out;` dance inline.
+ */
+double numbl_reduce_flat(int op, const double* data, int64_t len);
+
+/* ── Timers (tic/toc) ─────────────────────────────────────────────────── */
+
+/**
+ * Monotonic wall-clock seconds. Exported by every JIT .so so the JS
+ * wrapper can cross-reference the C clock domain when bridging tic/toc
+ * state between JS and C.
+ */
+double numbl_monotonic_time(void);
+
+/** Capture the current monotonic time into *state, return it. */
+double numbl_tic(double* state);
+
+/** Elapsed seconds since *state. */
+double numbl_toc(const double* state);
+
+/* ── NaN / Inf / finite predicates ───────────────────────────────────── */
+
+/**
+ * Bit-pattern-based predicates that return 1 for true, 0 for false.
+ *
+ * The JIT emits calls to these instead of C99's `isnan` / `isinf` /
+ * `isfinite` because the generated C is compiled with `-ffast-math`,
+ * which implies `-ffinite-math-only` and constant-folds those macros
+ * away. These helpers inspect the IEEE-754 bit pattern via `memcpy`,
+ * so the optimizer can't prove they're always-false even if the
+ * caller's `-ffast-math` assumes operands are finite — the function
+ * call is opaque, and the bit operations have no FP semantics.
+ *
+ * Assumes IEEE-754 binary64 doubles (true on every platform numbl
+ * targets).
+ */
+int numbl_is_nan(double x);
+int numbl_is_inf(double x);
+int numbl_is_finite(double x);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NUMBL_JIT_RUNTIME_H */

package/native/numbl_addon.cpp

@@ -22,14 +22,34 @@
 #include "numbl_addon_common.h"
 #include <cstdlib>
 
+#ifndef __APPLE__
 extern "C" {
   void openblas_set_num_threads(int num_threads);
 }
+#endif
 
 // ── 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 = 3;
+static const int ADDON_VERSION = 8;
+
+// ── New tensor-ops layer (native/ops/) ───────────────────────────────────────
+Napi::Value TensorOpRealBinary(const Napi::CallbackInfo& info);
+Napi::Value TensorOpRealScalarBinary(const Napi::CallbackInfo& info);
+Napi::Value TensorOpComplexBinary(const Napi::CallbackInfo& info);
+Napi::Value TensorOpComplexScalarBinary(const Napi::CallbackInfo& info);
+Napi::Value TensorOpRealUnary(const Napi::CallbackInfo& info);
+Napi::Value TensorOpComplexUnary(const Napi::CallbackInfo& info);
+Napi::Value TensorOpComplexAbs(const Napi::CallbackInfo& info);
+Napi::Value TensorOpRealComparison(const Napi::CallbackInfo& info);
+Napi::Value TensorOpRealScalarComparison(const Napi::CallbackInfo& info);
+Napi::Value TensorOpComplexComparison(const Napi::CallbackInfo& info);
+Napi::Value TensorOpComplexScalarComparison(const Napi::CallbackInfo& info);
+Napi::Value TensorOpRealFlatReduce(const Napi::CallbackInfo& info);
+Napi::Value TensorOpComplexFlatReduce(const Napi::CallbackInfo& info);
+Napi::Value TensorOpBesselReal(const Napi::CallbackInfo& info);
+Napi::Value TensorOpBesselH(const Napi::CallbackInfo& info);
+Napi::Value TensorOpDumpCodes(const Napi::CallbackInfo& info);
 
 static Napi::Value AddonVersion(const Napi::CallbackInfo& info) {
   return Napi::Number::New(info.Env(), ADDON_VERSION);
@@ -40,9 +60,16 @@ static Napi::Value AddonVersion(const Napi::CallbackInfo& info) {
 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.
+#ifdef __APPLE__
+  // Accelerate reads VECLIB_MAXIMUM_THREADS from the environment on first use.
+  if (!std::getenv("VECLIB_MAXIMUM_THREADS")) {
+    setenv("VECLIB_MAXIMUM_THREADS", "1", 0);
+  }
+#else
   if (!std::getenv("OPENBLAS_NUM_THREADS")) {
     openblas_set_num_threads(1);
   }
+#endif
   exports.Set(Napi::String::New(env, "addonVersion"),
               Napi::Function::New(env, AddonVersion));
   exports.Set(Napi::String::New(env, "inv"),
@@ -107,6 +134,40 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
               Napi::Function::New(env, Gmres));
   exports.Set(Napi::String::New(env, "gmresComplex"),
               Napi::Function::New(env, GmresComplex));
+
+  // ── New tensor-ops layer ──────────────────────────────────────────────────
+  exports.Set(Napi::String::New(env, "tensorOpRealBinary"),
+              Napi::Function::New(env, TensorOpRealBinary));
+  exports.Set(Napi::String::New(env, "tensorOpRealScalarBinary"),
+              Napi::Function::New(env, TensorOpRealScalarBinary));
+  exports.Set(Napi::String::New(env, "tensorOpComplexBinary"),
+              Napi::Function::New(env, TensorOpComplexBinary));
+  exports.Set(Napi::String::New(env, "tensorOpComplexScalarBinary"),
+              Napi::Function::New(env, TensorOpComplexScalarBinary));
+  exports.Set(Napi::String::New(env, "tensorOpRealUnary"),
+              Napi::Function::New(env, TensorOpRealUnary));
+  exports.Set(Napi::String::New(env, "tensorOpComplexUnary"),
+              Napi::Function::New(env, TensorOpComplexUnary));
+  exports.Set(Napi::String::New(env, "tensorOpComplexAbs"),
+              Napi::Function::New(env, TensorOpComplexAbs));
+  exports.Set(Napi::String::New(env, "tensorOpRealComparison"),
+              Napi::Function::New(env, TensorOpRealComparison));
+  exports.Set(Napi::String::New(env, "tensorOpRealScalarComparison"),
+              Napi::Function::New(env, TensorOpRealScalarComparison));
+  exports.Set(Napi::String::New(env, "tensorOpComplexComparison"),
+              Napi::Function::New(env, TensorOpComplexComparison));
+  exports.Set(Napi::String::New(env, "tensorOpComplexScalarComparison"),
+              Napi::Function::New(env, TensorOpComplexScalarComparison));
+  exports.Set(Napi::String::New(env, "tensorOpRealFlatReduce"),
+              Napi::Function::New(env, TensorOpRealFlatReduce));
+  exports.Set(Napi::String::New(env, "tensorOpComplexFlatReduce"),
+              Napi::Function::New(env, TensorOpComplexFlatReduce));
+  exports.Set(Napi::String::New(env, "tensorOpBesselReal"),
+              Napi::Function::New(env, TensorOpBesselReal));
+  exports.Set(Napi::String::New(env, "tensorOpBesselH"),
+              Napi::Function::New(env, TensorOpBesselH));
+  exports.Set(Napi::String::New(env, "tensorOpDumpCodes"),
+              Napi::Function::New(env, TensorOpDumpCodes));
   return exports;
 }