numbl 0.1.6 → 0.2.0

package/native/ops/comparison.c

@@ -0,0 +1,150 @@
+/**
+ * Real + complex comparison ops.  Output is a logical tensor stored as
+ * 0.0 / 1.0 in a double buffer (numbl stores logicals as FloatXArray with
+ * an _isLogical flag on the runtime tensor).
+ *
+ * Caller-allocated input/output buffers; never copies.
+ */
+
+#include "numbl_ops.h"
+
+static inline double rcmp(int op, double a, double b) {
+  switch (op) {
+    case NUMBL_CMP_EQ: return a == b ? 1.0 : 0.0;
+    case NUMBL_CMP_NE: return a != b ? 1.0 : 0.0;
+    case NUMBL_CMP_LT: return a <  b ? 1.0 : 0.0;
+    case NUMBL_CMP_LE: return a <= b ? 1.0 : 0.0;
+    case NUMBL_CMP_GT: return a >  b ? 1.0 : 0.0;
+    case NUMBL_CMP_GE: return a >= b ? 1.0 : 0.0;
+    default:           return -1.0;   /* sentinel; caller checks bad op */
+  }
+}
+
+int numbl_real_comparison(int op, size_t n,
+                          const double* a, const double* b,
+                          double* out) {
+  if (!a || !b || !out) return NUMBL_ERR_NULL_PTR;
+  if (op < 0 || op > NUMBL_CMP_GE) return NUMBL_ERR_BAD_OP;
+  switch (op) {
+    case NUMBL_CMP_EQ:
+      for (size_t i = 0; i < n; i++) out[i] = a[i] == b[i] ? 1.0 : 0.0;
+      return NUMBL_OK;
+    case NUMBL_CMP_NE:
+      for (size_t i = 0; i < n; i++) out[i] = a[i] != b[i] ? 1.0 : 0.0;
+      return NUMBL_OK;
+    case NUMBL_CMP_LT:
+      for (size_t i = 0; i < n; i++) out[i] = a[i] <  b[i] ? 1.0 : 0.0;
+      return NUMBL_OK;
+    case NUMBL_CMP_LE:
+      for (size_t i = 0; i < n; i++) out[i] = a[i] <= b[i] ? 1.0 : 0.0;
+      return NUMBL_OK;
+    case NUMBL_CMP_GT:
+      for (size_t i = 0; i < n; i++) out[i] = a[i] >  b[i] ? 1.0 : 0.0;
+      return NUMBL_OK;
+    case NUMBL_CMP_GE:
+      for (size_t i = 0; i < n; i++) out[i] = a[i] >= b[i] ? 1.0 : 0.0;
+      return NUMBL_OK;
+    default:
+      return NUMBL_ERR_BAD_OP;
+  }
+}
+
+int numbl_real_scalar_comparison(int op, size_t n,
+                                 double scalar, const double* arr,
+                                 int scalar_on_left, double* out) {
+  if (!arr || !out) return NUMBL_ERR_NULL_PTR;
+  if (op < 0 || op > NUMBL_CMP_GE) return NUMBL_ERR_BAD_OP;
+  if (scalar_on_left) {
+    for (size_t i = 0; i < n; i++) out[i] = rcmp(op, scalar, arr[i]);
+  } else {
+    for (size_t i = 0; i < n; i++) out[i] = rcmp(op, arr[i], scalar);
+  }
+  return NUMBL_OK;
+}
+
+int numbl_complex_comparison(int op, size_t n,
+                             const double* a_re, const double* a_im,
+                             const double* b_re, const double* b_im,
+                             double* out) {
+  if (!a_re || !b_re || !out) return NUMBL_ERR_NULL_PTR;
+  switch (op) {
+    case NUMBL_CMP_EQ:
+      for (size_t i = 0; i < n; i++) {
+        double ar = a_re[i], ai = a_im ? a_im[i] : 0.0;
+        double br = b_re[i], bi = b_im ? b_im[i] : 0.0;
+        out[i] = (ar == br && ai == bi) ? 1.0 : 0.0;
+      }
+      return NUMBL_OK;
+    case NUMBL_CMP_NE:
+      for (size_t i = 0; i < n; i++) {
+        double ar = a_re[i], ai = a_im ? a_im[i] : 0.0;
+        double br = b_re[i], bi = b_im ? b_im[i] : 0.0;
+        out[i] = (ar != br || ai != bi) ? 1.0 : 0.0;
+      }
+      return NUMBL_OK;
+    /* MATLAB semantics: <, <=, >, >= compare real parts only. */
+    case NUMBL_CMP_LT:
+      for (size_t i = 0; i < n; i++) out[i] = a_re[i] <  b_re[i] ? 1.0 : 0.0;
+      return NUMBL_OK;
+    case NUMBL_CMP_LE:
+      for (size_t i = 0; i < n; i++) out[i] = a_re[i] <= b_re[i] ? 1.0 : 0.0;
+      return NUMBL_OK;
+    case NUMBL_CMP_GT:
+      for (size_t i = 0; i < n; i++) out[i] = a_re[i] >  b_re[i] ? 1.0 : 0.0;
+      return NUMBL_OK;
+    case NUMBL_CMP_GE:
+      for (size_t i = 0; i < n; i++) out[i] = a_re[i] >= b_re[i] ? 1.0 : 0.0;
+      return NUMBL_OK;
+    default:
+      return NUMBL_ERR_BAD_OP;
+  }
+}
+
+int numbl_complex_scalar_comparison(int op, size_t n,
+                                    double s_re, double s_im,
+                                    const double* arr_re,
+                                    const double* arr_im,
+                                    int scalar_on_left, double* out) {
+  if (!arr_re || !out) return NUMBL_ERR_NULL_PTR;
+  switch (op) {
+    case NUMBL_CMP_EQ:
+      if (scalar_on_left) {
+        for (size_t i = 0; i < n; i++) {
+          double ar = arr_re[i], ai = arr_im ? arr_im[i] : 0.0;
+          out[i] = (s_re == ar && s_im == ai) ? 1.0 : 0.0;
+        }
+      } else {
+        for (size_t i = 0; i < n; i++) {
+          double ar = arr_re[i], ai = arr_im ? arr_im[i] : 0.0;
+          out[i] = (ar == s_re && ai == s_im) ? 1.0 : 0.0;
+        }
+      }
+      return NUMBL_OK;
+    case NUMBL_CMP_NE:
+      if (scalar_on_left) {
+        for (size_t i = 0; i < n; i++) {
+          double ar = arr_re[i], ai = arr_im ? arr_im[i] : 0.0;
+          out[i] = (s_re != ar || s_im != ai) ? 1.0 : 0.0;
+        }
+      } else {
+        for (size_t i = 0; i < n; i++) {
+          double ar = arr_re[i], ai = arr_im ? arr_im[i] : 0.0;
+          out[i] = (ar != s_re || ai != s_im) ? 1.0 : 0.0;
+        }
+      }
+      return NUMBL_OK;
+    /* Real-part-only comparisons. */
+    case NUMBL_CMP_LT:
+    case NUMBL_CMP_LE:
+    case NUMBL_CMP_GT:
+    case NUMBL_CMP_GE:
+      if (scalar_on_left) {
+        for (size_t i = 0; i < n; i++) out[i] = rcmp(op, s_re, arr_re[i]);
+      } else {
+        for (size_t i = 0; i < n; i++) out[i] = rcmp(op, arr_re[i], s_re);
+      }
+      return NUMBL_OK;
+    default:
+      return NUMBL_ERR_BAD_OP;
+  }
+}

package/native/ops/complex_binary_elemwise.c

@@ -0,0 +1,192 @@
+/**
+ * Complex element-wise binary ops, split storage (op-code dispatch).
+ *
+ * Caller-allocated input/output buffers; never copies.
+ * a_im or b_im may be NULL → treat as zero.
+ * out_re and out_im are required.
+ */
+
+#include "numbl_ops.h"
+
+/* Helper: produce JS-compatible Inf/NaN for division by zero, real part. */
+static inline double cdivz_re(double r, double i) {
+  if (r == 0.0 && i == 0.0) return 0.0 / 0.0;            /* NaN */
+  return (r > 0 ? 1.0 : r < 0 ? -1.0 : 0.0) / 0.0;       /* ±Inf */
+}
+
+/* Imaginary-part variant of the above. */
+static inline double cdivz_im(double r, double i) {
+  if (r == 0.0 && i == 0.0) return 0.0;
+  return (i > 0 ? 1.0 : i < 0 ? -1.0 : 0.0) / 0.0;
+}
+
+int numbl_complex_binary_elemwise(int op, size_t n,
+                                  const double* a_re, const double* a_im,
+                                  const double* b_re, const double* b_im,
+                                  double* out_re, double* out_im) {
+  if (!a_re || !b_re || !out_re || !out_im) return NUMBL_ERR_NULL_PTR;
+
+  switch (op) {
+    case NUMBL_COMPLEX_BIN_ADD:
+      for (size_t i = 0; i < n; i++) {
+        out_re[i] = a_re[i] + b_re[i];
+        out_im[i] = (a_im ? a_im[i] : 0.0) + (b_im ? b_im[i] : 0.0);
+      }
+      return NUMBL_OK;
+    case NUMBL_COMPLEX_BIN_SUB:
+      for (size_t i = 0; i < n; i++) {
+        out_re[i] = a_re[i] - b_re[i];
+        out_im[i] = (a_im ? a_im[i] : 0.0) - (b_im ? b_im[i] : 0.0);
+      }
+      return NUMBL_OK;
+    case NUMBL_COMPLEX_BIN_MUL:
+      for (size_t i = 0; i < n; i++) {
+        double ar = a_re[i], ai = a_im ? a_im[i] : 0.0;
+        double br = b_re[i], bi = b_im ? b_im[i] : 0.0;
+        out_re[i] = ar * br - ai * bi;
+        out_im[i] = ar * bi + ai * br;
+      }
+      return NUMBL_OK;
+    case NUMBL_COMPLEX_BIN_DIV: {
+      /* Hoist the a_im / b_im presence tests out of the loop so the
+       * vectorizer sees a straight-line body. The main SIMD pass uses
+       * the naive formula (fast but wrong when br=bi=0, since 0/0
+       * produces NaN); a single sequential fix-up pass then restores
+       * the C99 "complex divide by zero" semantics on any positions
+       * where the denominator was zero. Fix-up is only entered when
+       * the main pass actually produced such a position.
+       */
+      size_t zero_count = 0;
+      if (a_im && b_im) {
+        #pragma omp simd reduction(+:zero_count)
+        for (size_t i = 0; i < n; i++) {
+          double ar = a_re[i], ai = a_im[i];
+          double br = b_re[i], bi = b_im[i];
+          double denom = br * br + bi * bi;
+          double inv = 1.0 / denom;
+          out_re[i] = (ar * br + ai * bi) * inv;
+          out_im[i] = (ai * br - ar * bi) * inv;
+          zero_count += (denom == 0.0);
+        }
+      } else if (a_im) {
+        #pragma omp simd reduction(+:zero_count)
+        for (size_t i = 0; i < n; i++) {
+          double ar = a_re[i], ai = a_im[i];
+          double br = b_re[i];
+          double inv = 1.0 / br;
+          out_re[i] = ar * inv;
+          out_im[i] = ai * inv;
+          zero_count += (br == 0.0);
+        }
+      } else if (b_im) {
+        #pragma omp simd reduction(+:zero_count)
+        for (size_t i = 0; i < n; i++) {
+          double ar = a_re[i];
+          double br = b_re[i], bi = b_im[i];
+          double denom = br * br + bi * bi;
+          double inv = 1.0 / denom;
+          out_re[i] = (ar * br) * inv;
+          out_im[i] = (-ar * bi) * inv;
+          zero_count += (denom == 0.0);
+        }
+      } else {
+        #pragma omp simd reduction(+:zero_count)
+        for (size_t i = 0; i < n; i++) {
+          double ar = a_re[i];
+          double br = b_re[i];
+          out_re[i] = ar / br;
+          out_im[i] = 0.0;
+          zero_count += (br == 0.0);
+        }
+      }
+      if (zero_count) {
+        for (size_t i = 0; i < n; i++) {
+          double br = b_re[i], bi = b_im ? b_im[i] : 0.0;
+          if (br == 0.0 && bi == 0.0) {
+            double ar = a_re[i], ai = a_im ? a_im[i] : 0.0;
+            out_re[i] = cdivz_re(ar, ai);
+            out_im[i] = cdivz_im(ar, ai);
+          }
+        }
+      }
+      return NUMBL_OK;
+    }
+    default:
+      return NUMBL_ERR_BAD_OP;
+  }
+}
+
+int numbl_complex_scalar_binary_elemwise(int op, size_t n,
+                                         double s_re, double s_im,
+                                         const double* arr_re,
+                                         const double* arr_im,
+                                         int scalar_on_left,
+                                         double* out_re, double* out_im) {
+  if (!arr_re || !out_re || !out_im) return NUMBL_ERR_NULL_PTR;
+
+  switch (op) {
+    case NUMBL_COMPLEX_BIN_ADD:
+      for (size_t i = 0; i < n; i++) {
+        out_re[i] = s_re + arr_re[i];
+        out_im[i] = s_im + (arr_im ? arr_im[i] : 0.0);
+      }
+      return NUMBL_OK;
+    case NUMBL_COMPLEX_BIN_SUB:
+      if (scalar_on_left) {
+        for (size_t i = 0; i < n; i++) {
+          out_re[i] = s_re - arr_re[i];
+          out_im[i] = s_im - (arr_im ? arr_im[i] : 0.0);
+        }
+      } else {
+        for (size_t i = 0; i < n; i++) {
+          out_re[i] = arr_re[i] - s_re;
+          out_im[i] = (arr_im ? arr_im[i] : 0.0) - s_im;
+        }
+      }
+      return NUMBL_OK;
+    case NUMBL_COMPLEX_BIN_MUL:
+      for (size_t i = 0; i < n; i++) {
+        double ar = arr_re[i];
+        double ai = arr_im ? arr_im[i] : 0.0;
+        out_re[i] = s_re * ar - s_im * ai;
+        out_im[i] = s_re * ai + s_im * ar;
+      }
+      return NUMBL_OK;
+    case NUMBL_COMPLEX_BIN_DIV:
+      if (scalar_on_left) {
+        for (size_t i = 0; i < n; i++) {
+          double ar = arr_re[i];
+          double ai = arr_im ? arr_im[i] : 0.0;
+          double denom = ar * ar + ai * ai;
+          if (denom == 0.0) {
+            out_re[i] = cdivz_re(s_re, s_im);
+            out_im[i] = cdivz_im(s_re, s_im);
+          } else {
+            out_re[i] = (s_re * ar + s_im * ai) / denom;
+            out_im[i] = (s_im * ar - s_re * ai) / denom;
+          }
+        }
+      } else {
+        double denom = s_re * s_re + s_im * s_im;
+        if (denom == 0.0) {
+          for (size_t i = 0; i < n; i++) {
+            double ar = arr_re[i];
+            double ai = arr_im ? arr_im[i] : 0.0;
+            out_re[i] = cdivz_re(ar, ai);
+            out_im[i] = cdivz_im(ar, ai);
+          }
+        } else {
+          double inv_denom = 1.0 / denom;
+          for (size_t i = 0; i < n; i++) {
+            double ar = arr_re[i];
+            double ai = arr_im ? arr_im[i] : 0.0;
+            out_re[i] = (ar * s_re + ai * s_im) * inv_denom;
+            out_im[i] = (ai * s_re - ar * s_im) * inv_denom;
+          }
+        }
+      }
+      return NUMBL_OK;
+    default:
+      return NUMBL_ERR_BAD_OP;
+  }
+}

package/native/ops/complex_unary_elemwise.c

@@ -0,0 +1,152 @@
+/**
+ * Complex unary element-wise ops (op-code dispatch), split storage.
+ *
+ * Caller-allocated input/output buffers; never copies.
+ * a_im may be NULL → treat as zero.
+ * ABS is intentionally not supported here (output is real-valued; use
+ * numbl_complex_abs instead).
+ */
+
+#include "numbl_ops.h"
+
+#include <complex.h>
+#include <math.h>
+
+/* Construct a double complex from split parts. */
+static inline double _Complex cpack(double re, double im) {
+  return re + im * I;
+}
+
+#define WRITE_C(out_re_ptr, out_im_ptr, i, z) do {           \
+  double _Complex _z = (z);                                  \
+  (out_re_ptr)[i] = creal(_z);                               \
+  (out_im_ptr)[i] = cimag(_z);                               \
+} while (0)
+
+/* complex sign: z/|z| for z != 0, else 0.  Matches MATLAB's sign(z). */
+static inline double _Complex csign(double _Complex z) {
+  double m = cabs(z);
+  if (m == 0.0) return 0.0;
+  return z / m;
+}
+
+int numbl_complex_unary_elemwise(int op, size_t n,
+                                 const double* a_re, const double* a_im,
+                                 double* out_re, double* out_im) {
+  if (!a_re || !out_re || !out_im) return NUMBL_ERR_NULL_PTR;
+
+  switch (op) {
+    case NUMBL_UNARY_EXP:
+      for (size_t i = 0; i < n; i++)
+        WRITE_C(out_re, out_im, i, cexp(cpack(a_re[i], a_im ? a_im[i] : 0.0)));
+      return NUMBL_OK;
+    case NUMBL_UNARY_LOG:
+      for (size_t i = 0; i < n; i++)
+        WRITE_C(out_re, out_im, i, clog(cpack(a_re[i], a_im ? a_im[i] : 0.0)));
+      return NUMBL_OK;
+    case NUMBL_UNARY_LOG2: {
+      const double inv_ln2 = 1.0 / log(2.0);
+      for (size_t i = 0; i < n; i++)
+        WRITE_C(out_re, out_im, i,
+                clog(cpack(a_re[i], a_im ? a_im[i] : 0.0)) * inv_ln2);
+      return NUMBL_OK;
+    }
+    case NUMBL_UNARY_LOG10: {
+      const double inv_ln10 = 1.0 / log(10.0);
+      for (size_t i = 0; i < n; i++)
+        WRITE_C(out_re, out_im, i,
+                clog(cpack(a_re[i], a_im ? a_im[i] : 0.0)) * inv_ln10);
+      return NUMBL_OK;
+    }
+    case NUMBL_UNARY_SQRT:
+      for (size_t i = 0; i < n; i++)
+        WRITE_C(out_re, out_im, i, csqrt(cpack(a_re[i], a_im ? a_im[i] : 0.0)));
+      return NUMBL_OK;
+    case NUMBL_UNARY_ABS:
+      return NUMBL_ERR_BAD_OP; /* use numbl_complex_abs */
+    case NUMBL_UNARY_FLOOR:
+      for (size_t i = 0; i < n; i++) {
+        out_re[i] = floor(a_re[i]);
+        out_im[i] = a_im ? floor(a_im[i]) : 0.0;
+      }
+      return NUMBL_OK;
+    case NUMBL_UNARY_CEIL:
+      for (size_t i = 0; i < n; i++) {
+        out_re[i] = ceil(a_re[i]);
+        out_im[i] = a_im ? ceil(a_im[i]) : 0.0;
+      }
+      return NUMBL_OK;
+    case NUMBL_UNARY_ROUND:
+      for (size_t i = 0; i < n; i++) {
+        out_re[i] = round(a_re[i]);
+        out_im[i] = a_im ? round(a_im[i]) : 0.0;
+      }
+      return NUMBL_OK;
+    case NUMBL_UNARY_TRUNC:
+      for (size_t i = 0; i < n; i++) {
+        out_re[i] = trunc(a_re[i]);
+        out_im[i] = a_im ? trunc(a_im[i]) : 0.0;
+      }
+      return NUMBL_OK;
+    case NUMBL_UNARY_SIN:
+      for (size_t i = 0; i < n; i++)
+        WRITE_C(out_re, out_im, i, csin(cpack(a_re[i], a_im ? a_im[i] : 0.0)));
+      return NUMBL_OK;
+    case NUMBL_UNARY_COS:
+      for (size_t i = 0; i < n; i++)
+        WRITE_C(out_re, out_im, i, ccos(cpack(a_re[i], a_im ? a_im[i] : 0.0)));
+      return NUMBL_OK;
+    case NUMBL_UNARY_TAN:
+      for (size_t i = 0; i < n; i++)
+        WRITE_C(out_re, out_im, i, ctan(cpack(a_re[i], a_im ? a_im[i] : 0.0)));
+      return NUMBL_OK;
+    case NUMBL_UNARY_ASIN:
+      for (size_t i = 0; i < n; i++)
+        WRITE_C(out_re, out_im, i, casin(cpack(a_re[i], a_im ? a_im[i] : 0.0)));
+      return NUMBL_OK;
+    case NUMBL_UNARY_ACOS:
+      for (size_t i = 0; i < n; i++)
+        WRITE_C(out_re, out_im, i, cacos(cpack(a_re[i], a_im ? a_im[i] : 0.0)));
+      return NUMBL_OK;
+    case NUMBL_UNARY_ATAN:
+      for (size_t i = 0; i < n; i++)
+        WRITE_C(out_re, out_im, i, catan(cpack(a_re[i], a_im ? a_im[i] : 0.0)));
+      return NUMBL_OK;
+    case NUMBL_UNARY_SINH:
+      for (size_t i = 0; i < n; i++)
+        WRITE_C(out_re, out_im, i, csinh(cpack(a_re[i], a_im ? a_im[i] : 0.0)));
+      return NUMBL_OK;
+    case NUMBL_UNARY_COSH:
+      for (size_t i = 0; i < n; i++)
+        WRITE_C(out_re, out_im, i, ccosh(cpack(a_re[i], a_im ? a_im[i] : 0.0)));
+      return NUMBL_OK;
+    case NUMBL_UNARY_TANH:
+      for (size_t i = 0; i < n; i++)
+        WRITE_C(out_re, out_im, i, ctanh(cpack(a_re[i], a_im ? a_im[i] : 0.0)));
+      return NUMBL_OK;
+    case NUMBL_UNARY_SIGN:
+      for (size_t i = 0; i < n; i++)
+        WRITE_C(out_re, out_im, i,
+                csign(cpack(a_re[i], a_im ? a_im[i] : 0.0)));
+      return NUMBL_OK;
+    default:
+      return NUMBL_ERR_BAD_OP;
+  }
+}
+
+int numbl_complex_abs(size_t n,
+                      const double* a_re, const double* a_im,
+                      double* out) {
+  if (!a_re || !out) return NUMBL_ERR_NULL_PTR;
+  if (a_im) {
+    #pragma omp simd
+    for (size_t i = 0; i < n; i++) {
+      /* hypot avoids overflow/underflow that (re*re + im*im) would miss. */
+      out[i] = hypot(a_re[i], a_im[i]);
+    }
+  } else {
+    #pragma omp simd
+    for (size_t i = 0; i < n; i++) out[i] = fabs(a_re[i]);
+  }
+  return NUMBL_OK;
+}

package/native/ops/numbl_ops.c

@@ -0,0 +1,66 @@
+/**
+ * numbl_ops — shared bits: error strings, op-code dump.
+ */
+
+#include "numbl_ops.h"
+
+#include <stdio.h>
+#include <string.h>
+
+const char* numbl_strerror(int code) {
+  switch (code) {
+    case NUMBL_OK:           return "ok";
+    case NUMBL_ERR_BAD_OP:   return "unknown op code";
+    case NUMBL_ERR_NULL_PTR: return "null pointer argument";
+    default:                 return "unknown numbl error";
+  }
+}
+
+/* Dump op-code enum values in a stable text format.
+ * Used by the TS-side drift-detection test.
+ */
+size_t numbl_dump_op_codes(char* buf, size_t buf_size) {
+  /* Compose into a temporary; emit length only if buf is too small. */
+  char tmp[1024];
+  int n = 0;
+  n += snprintf(tmp + n, sizeof(tmp) - n,
+                "real_binary:ADD=%d,SUB=%d,MUL=%d,DIV=%d;",
+                NUMBL_REAL_BIN_ADD, NUMBL_REAL_BIN_SUB,
+                NUMBL_REAL_BIN_MUL, NUMBL_REAL_BIN_DIV);
+  n += snprintf(tmp + n, sizeof(tmp) - n,
+                "complex_binary:ADD=%d,SUB=%d,MUL=%d,DIV=%d;",
+                NUMBL_COMPLEX_BIN_ADD, NUMBL_COMPLEX_BIN_SUB,
+                NUMBL_COMPLEX_BIN_MUL, NUMBL_COMPLEX_BIN_DIV);
+  n += snprintf(tmp + n, sizeof(tmp) - n,
+                "unary:EXP=%d,LOG=%d,LOG2=%d,LOG10=%d,SQRT=%d,ABS=%d,"
+                "FLOOR=%d,CEIL=%d,ROUND=%d,TRUNC=%d,"
+                "SIN=%d,COS=%d,TAN=%d,ASIN=%d,ACOS=%d,ATAN=%d,"
+                "SINH=%d,COSH=%d,TANH=%d,SIGN=%d;",
+                NUMBL_UNARY_EXP, NUMBL_UNARY_LOG, NUMBL_UNARY_LOG2,
+                NUMBL_UNARY_LOG10, NUMBL_UNARY_SQRT, NUMBL_UNARY_ABS,
+                NUMBL_UNARY_FLOOR, NUMBL_UNARY_CEIL, NUMBL_UNARY_ROUND,
+                NUMBL_UNARY_TRUNC, NUMBL_UNARY_SIN, NUMBL_UNARY_COS,
+                NUMBL_UNARY_TAN, NUMBL_UNARY_ASIN, NUMBL_UNARY_ACOS,
+                NUMBL_UNARY_ATAN, NUMBL_UNARY_SINH, NUMBL_UNARY_COSH,
+                NUMBL_UNARY_TANH, NUMBL_UNARY_SIGN);
+  n += snprintf(tmp + n, sizeof(tmp) - n,
+                "cmp:EQ=%d,NE=%d,LT=%d,LE=%d,GT=%d,GE=%d;",
+                NUMBL_CMP_EQ, NUMBL_CMP_NE, NUMBL_CMP_LT,
+                NUMBL_CMP_LE, NUMBL_CMP_GT, NUMBL_CMP_GE);
+  n += snprintf(tmp + n, sizeof(tmp) - n,
+                "reduce:SUM=%d,PROD=%d,MAX=%d,MIN=%d,ANY=%d,ALL=%d,MEAN=%d;",
+                NUMBL_REDUCE_SUM, NUMBL_REDUCE_PROD, NUMBL_REDUCE_MAX,
+                NUMBL_REDUCE_MIN, NUMBL_REDUCE_ANY, NUMBL_REDUCE_ALL,
+                NUMBL_REDUCE_MEAN);
+  n += snprintf(tmp + n, sizeof(tmp) - n,
+                "bessel:J=%d,Y=%d,I=%d,K=%d;",
+                NUMBL_BESSEL_J, NUMBL_BESSEL_Y,
+                NUMBL_BESSEL_I, NUMBL_BESSEL_K);
+  size_t need = (size_t)n;
+  if (buf && buf_size > need) {
+    memcpy(buf, tmp, need + 1);
+  } else if (buf && buf_size > 0) {
+    buf[0] = '\0';
+  }
+  return need;
+}