numbl 0.1.7 → 0.3.0

package/native/ops/numbl_ops.h

@@ -0,0 +1,262 @@
+/**
+ * numbl_ops — pure C tensor-ops library.
+ *
+ * Stable C ABI for tensor operations dispatched by integer op-code.
+ * Caller owns input AND output memory; functions never allocate output.
+ *
+ * Mirrored 1:1 by the TS implementation in src/numbl-core/ops/.
+ * The N-API addon thin-wraps these entry points; the future C-JIT links
+ * directly against the same library.
+ *
+ * All numeric data is column-major (Fortran/MATLAB) double precision.
+ * Complex tensors use split storage: separate `re` and `im` Float64 buffers.
+ * For complex inputs, `im` may be NULL to indicate "all zero".
+ *
+ * Return codes: 0 on success, negative on error (see numbl_strerror).
+ */
+
+#ifndef NUMBL_OPS_H
+#define NUMBL_OPS_H
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ── Error codes ──────────────────────────────────────────────────────── */
+
+#define NUMBL_OK                 0
+#define NUMBL_ERR_BAD_OP        -1
+#define NUMBL_ERR_NULL_PTR      -2
+
+/** Human-readable message for a numbl error code. */
+const char* numbl_strerror(int code);
+
+/* ── Real binary element-wise ops ─────────────────────────────────────── */
+
+typedef enum {
+  NUMBL_REAL_BIN_ADD = 0,
+  NUMBL_REAL_BIN_SUB = 1,
+  NUMBL_REAL_BIN_MUL = 2,
+  NUMBL_REAL_BIN_DIV = 3
+} numbl_real_bin_op_t;
+
+/**
+ * out[i] = a[i] OP b[i]   for i in [0, n).
+ * a, b, out must each point to at least n doubles.
+ */
+int numbl_real_binary_elemwise(int op, size_t n,
+                               const double* a,
+                               const double* b,
+                               double* out);
+
+/**
+ * Scalar-tensor variant.
+ * If scalar_on_left:  out[i] = scalar OP arr[i]
+ * Else:               out[i] = arr[i] OP scalar
+ */
+int numbl_real_scalar_binary_elemwise(int op, size_t n,
+                                      double scalar,
+                                      const double* arr,
+                                      int scalar_on_left,
+                                      double* out);
+
+/* ── Complex binary element-wise ops ──────────────────────────────────── */
+
+typedef enum {
+  NUMBL_COMPLEX_BIN_ADD = 0,
+  NUMBL_COMPLEX_BIN_SUB = 1,
+  NUMBL_COMPLEX_BIN_MUL = 2,
+  NUMBL_COMPLEX_BIN_DIV = 3
+} numbl_complex_bin_op_t;
+
+/**
+ * Complex element-wise binary op, split storage.
+ * a_im or b_im may be NULL → treat as zero (mixed real/complex).
+ * out_re and out_im are required (caller allocates both, even if result is real).
+ */
+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);
+
+/**
+ * Complex-scalar / tensor variant.
+ * arr_im may be NULL → treat tensor as purely real.
+ * If scalar_on_left:  out[i] = scalar OP arr[i]
+ * Else:               out[i] = arr[i] OP scalar
+ */
+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);
+
+/* ── Unary element-wise ops (real + complex) ──────────────────────────── */
+
+typedef enum {
+  NUMBL_UNARY_EXP   = 0,
+  NUMBL_UNARY_LOG   = 1,
+  NUMBL_UNARY_LOG2  = 2,
+  NUMBL_UNARY_LOG10 = 3,
+  NUMBL_UNARY_SQRT  = 4,
+  NUMBL_UNARY_ABS   = 5,
+  NUMBL_UNARY_FLOOR = 6,
+  NUMBL_UNARY_CEIL  = 7,
+  NUMBL_UNARY_ROUND = 8,
+  NUMBL_UNARY_TRUNC = 9,
+  NUMBL_UNARY_SIN   = 10,
+  NUMBL_UNARY_COS   = 11,
+  NUMBL_UNARY_TAN   = 12,
+  NUMBL_UNARY_ASIN  = 13,
+  NUMBL_UNARY_ACOS  = 14,
+  NUMBL_UNARY_ATAN  = 15,
+  NUMBL_UNARY_SINH  = 16,
+  NUMBL_UNARY_COSH  = 17,
+  NUMBL_UNARY_TANH  = 18,
+  NUMBL_UNARY_SIGN  = 19
+} numbl_unary_op_t;
+
+/**
+ * Real unary element-wise: out[i] = OP(a[i]).
+ * a, out must point to at least n doubles.
+ */
+int numbl_real_unary_elemwise(int op, size_t n,
+                              const double* a, double* out);
+
+/**
+ * Complex unary element-wise, split storage.
+ * a_im may be NULL → treat as zero.
+ * out_re and out_im are both required.
+ *
+ * ABS is unsupported here (output would be real-valued — use
+ * numbl_complex_abs for that).  Other ops are supported.
+ */
+int numbl_complex_unary_elemwise(int op, size_t n,
+                                 const double* a_re, const double* a_im,
+                                 double* out_re, double* out_im);
+
+/**
+ * Complex absolute value: out[i] = sqrt(re[i]^2 + im[i]^2).
+ * Output is real-valued.  a_im may be NULL.
+ */
+int numbl_complex_abs(size_t n,
+                      const double* a_re, const double* a_im,
+                      double* out);
+
+/* ── Comparisons (logical output stored as 0.0/1.0 in double buffer) ──── */
+
+typedef enum {
+  NUMBL_CMP_EQ = 0,  /* ==  */
+  NUMBL_CMP_NE = 1,  /* !=  */
+  NUMBL_CMP_LT = 2,  /* <   */
+  NUMBL_CMP_LE = 3,  /* <=  */
+  NUMBL_CMP_GT = 4,  /* >   */
+  NUMBL_CMP_GE = 5   /* >=  */
+} numbl_cmp_op_t;
+
+/**
+ * Real comparison: out[i] = (a[i] OP b[i]) ? 1.0 : 0.0.
+ * NaN in either operand yields 0 (except for !=, which yields 1).
+ */
+int numbl_real_comparison(int op, size_t n,
+                          const double* a, const double* b,
+                          double* out);
+
+/** Scalar-tensor variant. */
+int numbl_real_scalar_comparison(int op, size_t n,
+                                 double scalar, const double* arr,
+                                 int scalar_on_left, double* out);
+
+/**
+ * Complex comparison.  EQ / NE compare both parts; LT/LE/GT/GE compare
+ * only the real parts (MATLAB semantics).  a_im, b_im may be NULL.
+ */
+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);
+
+/** Complex-scalar / tensor comparison. */
+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);
+
+/* ── Flat reductions (reduce entire buffer to a single value) ─────────── */
+
+typedef enum {
+  NUMBL_REDUCE_SUM  = 0,
+  NUMBL_REDUCE_PROD = 1,
+  NUMBL_REDUCE_MAX  = 2,
+  NUMBL_REDUCE_MIN  = 3,
+  NUMBL_REDUCE_ANY  = 4,  /* result: 1 if any nonzero, else 0 */
+  NUMBL_REDUCE_ALL  = 5,  /* result: 1 if all nonzero, else 0 */
+  NUMBL_REDUCE_MEAN = 6
+} numbl_reduce_op_t;
+
+/**
+ * Flat real reduction: reduce a contiguous real buffer to a single value.
+ * For MAX/MIN on an empty buffer returns +Inf/-Inf.  MEAN on empty → NaN.
+ * NaN handling: NaN propagates for SUM/PROD/MAX/MIN/MEAN (omit-NaN variants
+ * could be added later as separate op codes).  ANY/ALL treat NaN as nonzero.
+ */
+int numbl_real_flat_reduce(int op, size_t n, const double* a, double* out);
+
+/**
+ * Flat complex reduction: SUM, PROD, ANY, ALL supported.  MAX/MIN/MEAN
+ * return NUMBL_ERR_BAD_OP (use real-only for those).  a_im may be NULL.
+ * For SUM/PROD, both out_re and out_im must be non-NULL.
+ * For ANY/ALL, out_re receives 0/1 and out_im is untouched (may be NULL).
+ */
+int numbl_complex_flat_reduce(int op, size_t n,
+                              const double* a_re, const double* a_im,
+                              double* out_re, double* out_im);
+
+/* ── Bessel functions (real input) ────────────────────────────────────── */
+
+typedef enum {
+  NUMBL_BESSEL_J  = 0,  /* first kind,                   real output */
+  NUMBL_BESSEL_Y  = 1,  /* second kind,                  real output */
+  NUMBL_BESSEL_I  = 2,  /* modified first kind,          real output */
+  NUMBL_BESSEL_K  = 3   /* modified second kind,         real output */
+} numbl_bessel_real_op_t;
+
+/**
+ * Real-valued Bessel: out[i] = bessel<OP>(nu, z[i]).
+ * nu is a fixed scalar order.  z, out must each point to at least n doubles.
+ * scale: 0 unscaled; 1 applies the scaled variant (J,Y,I: exp(-|z|); K: exp(z)).
+ */
+int numbl_bessel_real(int op, double nu, size_t n,
+                      const double* z, int scale, double* out);
+
+/**
+ * Hankel function H_nu^{(k)}(z) with real z.
+ * k_kind = 1 →  out[i] = J_nu(z[i]) + i * Y_nu(z[i])
+ * k_kind = 2 →  out[i] = J_nu(z[i]) - i * Y_nu(z[i])
+ * Split complex output: out_re and out_im must each point to at least n doubles.
+ * scale: 0 unscaled; 1 multiplies output by exp(-i*z) (k=1) or exp(+i*z) (k=2).
+ */
+int numbl_bessel_h(int k_kind, double nu, size_t n,
+                   const double* z, int scale,
+                   double* out_re, double* out_im);
+
+/* ── Op-code dump (for drift detection) ───────────────────────────────── */
+
+/**
+ * Writes a small C string describing the op-code enum values into buf.
+ * Format is a JSON-like string of category=op_name=value triples.
+ * Returns the number of bytes that would be written (excluding terminator).
+ * If buf is NULL or buf_size is too small, nothing is written but the
+ * required size is still returned.
+ */
+size_t numbl_dump_op_codes(char* buf, size_t buf_size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NUMBL_OPS_H */

package/native/ops/real_binary_elemwise.c

@@ -0,0 +1,85 @@
+/**
+ * Real element-wise binary ops (op-code dispatch).
+ *
+ * Caller-allocated input/output buffers; never copies.
+ */
+
+#include "numbl_ops.h"
+
+int numbl_real_binary_elemwise(int op, size_t n,
+                               const double* a,
+                               const double* b,
+                               double* out) {
+  if (!a || !b || !out) return NUMBL_ERR_NULL_PTR;
+  switch (op) {
+    case NUMBL_REAL_BIN_ADD:
+      #pragma omp simd
+      for (size_t i = 0; i < n; i++) out[i] = a[i] + b[i];
+      return NUMBL_OK;
+    case NUMBL_REAL_BIN_SUB:
+      #pragma omp simd
+      for (size_t i = 0; i < n; i++) out[i] = a[i] - b[i];
+      return NUMBL_OK;
+    case NUMBL_REAL_BIN_MUL:
+      #pragma omp simd
+      for (size_t i = 0; i < n; i++) out[i] = a[i] * b[i];
+      return NUMBL_OK;
+    case NUMBL_REAL_BIN_DIV:
+      #pragma omp simd
+      for (size_t i = 0; i < n; i++) out[i] = a[i] / b[i];
+      return NUMBL_OK;
+    default:
+      return NUMBL_ERR_BAD_OP;
+  }
+}
+
+int numbl_real_scalar_binary_elemwise(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 (scalar_on_left) {
+    switch (op) {
+      case NUMBL_REAL_BIN_ADD:
+        #pragma omp simd
+        for (size_t i = 0; i < n; i++) out[i] = scalar + arr[i];
+        return NUMBL_OK;
+      case NUMBL_REAL_BIN_SUB:
+        #pragma omp simd
+        for (size_t i = 0; i < n; i++) out[i] = scalar - arr[i];
+        return NUMBL_OK;
+      case NUMBL_REAL_BIN_MUL:
+        #pragma omp simd
+        for (size_t i = 0; i < n; i++) out[i] = scalar * arr[i];
+        return NUMBL_OK;
+      case NUMBL_REAL_BIN_DIV:
+        #pragma omp simd
+        for (size_t i = 0; i < n; i++) out[i] = scalar / arr[i];
+        return NUMBL_OK;
+      default:
+        return NUMBL_ERR_BAD_OP;
+    }
+  } else {
+    switch (op) {
+      case NUMBL_REAL_BIN_ADD:
+        #pragma omp simd
+        for (size_t i = 0; i < n; i++) out[i] = arr[i] + scalar;
+        return NUMBL_OK;
+      case NUMBL_REAL_BIN_SUB:
+        #pragma omp simd
+        for (size_t i = 0; i < n; i++) out[i] = arr[i] - scalar;
+        return NUMBL_OK;
+      case NUMBL_REAL_BIN_MUL:
+        #pragma omp simd
+        for (size_t i = 0; i < n; i++) out[i] = arr[i] * scalar;
+        return NUMBL_OK;
+      case NUMBL_REAL_BIN_DIV:
+        #pragma omp simd
+        for (size_t i = 0; i < n; i++) out[i] = arr[i] / scalar;
+        return NUMBL_OK;
+      default:
+        return NUMBL_ERR_BAD_OP;
+    }
+  }
+}

package/native/ops/real_unary_elemwise.c

@@ -0,0 +1,104 @@
+/**
+ * Real unary element-wise ops (op-code dispatch).
+ * Caller-allocated input/output buffers; never copies.
+ */
+
+#include "numbl_ops.h"
+
+#include <math.h>
+
+static inline double rsign(double x) {
+  return x > 0.0 ? 1.0 : x < 0.0 ? -1.0 : 0.0;
+}
+
+int numbl_real_unary_elemwise(int op, size_t n,
+                              const double* a, double* out) {
+  if (!a || !out) return NUMBL_ERR_NULL_PTR;
+  // `#pragma omp simd` + `-fopenmp-simd -fno-math-errno -ffast-math`
+  // lets gcc emit calls to libmvec's vector math (`_ZGVdN4v_exp`, etc.)
+  // instead of scalar libm, giving 2-4x on AVX2 hardware.
+  switch (op) {
+    case NUMBL_UNARY_EXP:
+      #pragma omp simd
+      for (size_t i = 0; i < n; i++) out[i] = exp(a[i]);
+      return NUMBL_OK;
+    case NUMBL_UNARY_LOG:
+      #pragma omp simd
+      for (size_t i = 0; i < n; i++) out[i] = log(a[i]);
+      return NUMBL_OK;
+    case NUMBL_UNARY_LOG2:
+      #pragma omp simd
+      for (size_t i = 0; i < n; i++) out[i] = log2(a[i]);
+      return NUMBL_OK;
+    case NUMBL_UNARY_LOG10:
+      #pragma omp simd
+      for (size_t i = 0; i < n; i++) out[i] = log10(a[i]);
+      return NUMBL_OK;
+    case NUMBL_UNARY_SQRT:
+      #pragma omp simd
+      for (size_t i = 0; i < n; i++) out[i] = sqrt(a[i]);
+      return NUMBL_OK;
+    case NUMBL_UNARY_ABS:
+      #pragma omp simd
+      for (size_t i = 0; i < n; i++) out[i] = fabs(a[i]);
+      return NUMBL_OK;
+    case NUMBL_UNARY_FLOOR:
+      #pragma omp simd
+      for (size_t i = 0; i < n; i++) out[i] = floor(a[i]);
+      return NUMBL_OK;
+    case NUMBL_UNARY_CEIL:
+      #pragma omp simd
+      for (size_t i = 0; i < n; i++) out[i] = ceil(a[i]);
+      return NUMBL_OK;
+    case NUMBL_UNARY_ROUND:
+      #pragma omp simd
+      for (size_t i = 0; i < n; i++) out[i] = round(a[i]);
+      return NUMBL_OK;
+    case NUMBL_UNARY_TRUNC:
+      #pragma omp simd
+      for (size_t i = 0; i < n; i++) out[i] = trunc(a[i]);
+      return NUMBL_OK;
+    case NUMBL_UNARY_SIN:
+      #pragma omp simd
+      for (size_t i = 0; i < n; i++) out[i] = sin(a[i]);
+      return NUMBL_OK;
+    case NUMBL_UNARY_COS:
+      #pragma omp simd
+      for (size_t i = 0; i < n; i++) out[i] = cos(a[i]);
+      return NUMBL_OK;
+    case NUMBL_UNARY_TAN:
+      #pragma omp simd
+      for (size_t i = 0; i < n; i++) out[i] = tan(a[i]);
+      return NUMBL_OK;
+    case NUMBL_UNARY_ASIN:
+      #pragma omp simd
+      for (size_t i = 0; i < n; i++) out[i] = asin(a[i]);
+      return NUMBL_OK;
+    case NUMBL_UNARY_ACOS:
+      #pragma omp simd
+      for (size_t i = 0; i < n; i++) out[i] = acos(a[i]);
+      return NUMBL_OK;
+    case NUMBL_UNARY_ATAN:
+      #pragma omp simd
+      for (size_t i = 0; i < n; i++) out[i] = atan(a[i]);
+      return NUMBL_OK;
+    case NUMBL_UNARY_SINH:
+      #pragma omp simd
+      for (size_t i = 0; i < n; i++) out[i] = sinh(a[i]);
+      return NUMBL_OK;
+    case NUMBL_UNARY_COSH:
+      #pragma omp simd
+      for (size_t i = 0; i < n; i++) out[i] = cosh(a[i]);
+      return NUMBL_OK;
+    case NUMBL_UNARY_TANH:
+      #pragma omp simd
+      for (size_t i = 0; i < n; i++) out[i] = tanh(a[i]);
+      return NUMBL_OK;
+    case NUMBL_UNARY_SIGN:
+      #pragma omp simd
+      for (size_t i = 0; i < n; i++) out[i] = rsign(a[i]);
+      return NUMBL_OK;
+    default:
+      return NUMBL_ERR_BAD_OP;
+  }
+}

package/native/ops/reduce.c

@@ -0,0 +1,162 @@
+/**
+ * Flat reductions: reduce an entire buffer to a single value.
+ * Caller-allocated input; 1-double output.
+ */
+
+#include "numbl_ops.h"
+
+#include <math.h>
+#include <stdint.h>
+#include <string.h>
+
+/* Bit-level NaN detection + constant. `-ffast-math` implies
+ * `-ffinite-math-only`, which makes gcc fold `isnan(x)` / `x != x` to
+ * `false` and collapse `0.0 / 0.0` to 0. Max/min need MATLAB-compatible
+ * NaN-omit semantics, so we inspect the IEEE 754 bit pattern directly
+ * and fabricate NaN by bit pattern too. */
+static inline int nb_isnan(double x) {
+  uint64_t bits;
+  memcpy(&bits, &x, sizeof(bits));
+  return (bits & 0x7FFFFFFFFFFFFFFFULL) > 0x7FF0000000000000ULL;
+}
+
+static inline double nb_nan(void) {
+  uint64_t bits = 0x7FF8000000000000ULL; /* quiet NaN */
+  double x;
+  memcpy(&x, &bits, sizeof(x));
+  return x;
+}
+
+int numbl_real_flat_reduce(int op, size_t n, const double* a, double* out) {
+  if ((!a && n > 0) || !out) return NUMBL_ERR_NULL_PTR;
+
+  switch (op) {
+    case NUMBL_REDUCE_SUM: {
+      double s = 0.0;
+      for (size_t i = 0; i < n; i++) s += a[i];
+      *out = s;
+      return NUMBL_OK;
+    }
+    case NUMBL_REDUCE_PROD: {
+      double p = 1.0;
+      for (size_t i = 0; i < n; i++) p *= a[i];
+      *out = p;
+      return NUMBL_OK;
+    }
+    case NUMBL_REDUCE_MAX: {
+      /* MATLAB default: omitnan.  If ALL values are NaN, result is NaN. */
+      double m = -INFINITY;
+      int any = 0;
+      for (size_t i = 0; i < n; i++) {
+        double v = a[i];
+        if (nb_isnan(v)) continue;
+        if (v > m) m = v;
+        any = 1;
+      }
+      *out = any ? m : nb_nan();
+      return NUMBL_OK;
+    }
+    case NUMBL_REDUCE_MIN: {
+      double m = INFINITY;
+      int any = 0;
+      for (size_t i = 0; i < n; i++) {
+        double v = a[i];
+        if (nb_isnan(v)) continue;
+        if (v < m) m = v;
+        any = 1;
+      }
+      *out = any ? m : nb_nan();
+      return NUMBL_OK;
+    }
+    case NUMBL_REDUCE_ANY: {
+      double r = 0.0;
+      for (size_t i = 0; i < n; i++) {
+        if (a[i] != 0.0 || nb_isnan(a[i])) { r = 1.0; break; }
+      }
+      *out = r;
+      return NUMBL_OK;
+    }
+    case NUMBL_REDUCE_ALL: {
+      double r = 1.0;
+      for (size_t i = 0; i < n; i++) {
+        if (a[i] == 0.0) { r = 0.0; break; }
+      }
+      *out = r;
+      return NUMBL_OK;
+    }
+    case NUMBL_REDUCE_MEAN: {
+      if (n == 0) { *out = nb_nan(); return NUMBL_OK; }
+      double s = 0.0;
+      for (size_t i = 0; i < n; i++) s += a[i];
+      *out = s / (double)n;
+      return NUMBL_OK;
+    }
+    default:
+      return NUMBL_ERR_BAD_OP;
+  }
+}
+
+int numbl_complex_flat_reduce(int op, size_t n,
+                              const double* a_re, const double* a_im,
+                              double* out_re, double* out_im) {
+  if ((!a_re && n > 0) || !out_re) return NUMBL_ERR_NULL_PTR;
+
+  switch (op) {
+    case NUMBL_REDUCE_SUM: {
+      if (!out_im) return NUMBL_ERR_NULL_PTR;
+      double sr = 0.0, si = 0.0;
+      for (size_t i = 0; i < n; i++) {
+        sr += a_re[i];
+        if (a_im) si += a_im[i];
+      }
+      *out_re = sr;
+      *out_im = si;
+      return NUMBL_OK;
+    }
+    case NUMBL_REDUCE_PROD: {
+      if (!out_im) return NUMBL_ERR_NULL_PTR;
+      /* Accumulate Gauss multiplication: (accRe + accIm i)(ar + ai i). */
+      double ar_acc = 1.0, ai_acc = 0.0;
+      for (size_t i = 0; i < n; i++) {
+        double ar = a_re[i];
+        double ai = a_im ? a_im[i] : 0.0;
+        double nr = ar_acc * ar - ai_acc * ai;
+        double ni = ar_acc * ai + ai_acc * ar;
+        ar_acc = nr;
+        ai_acc = ni;
+      }
+      *out_re = ar_acc;
+      *out_im = ai_acc;
+      return NUMBL_OK;
+    }
+    case NUMBL_REDUCE_ANY: {
+      double r = 0.0;
+      for (size_t i = 0; i < n; i++) {
+        double ar = a_re[i];
+        double ai = a_im ? a_im[i] : 0.0;
+        if (ar != 0.0 || ai != 0.0 || nb_isnan(ar) || nb_isnan(ai)) {
+          r = 1.0;
+          break;
+        }
+      }
+      *out_re = r;
+      return NUMBL_OK;
+    }
+    case NUMBL_REDUCE_ALL: {
+      double r = 1.0;
+      for (size_t i = 0; i < n; i++) {
+        double ar = a_re[i];
+        double ai = a_im ? a_im[i] : 0.0;
+        if (ar == 0.0 && ai == 0.0) {
+          r = 0.0;
+          break;
+        }
+      }
+      *out_re = r;
+      return NUMBL_OK;
+    }
+    default:
+      /* MAX/MIN/MEAN on complex: ambiguous; caller handles. */
+      return NUMBL_ERR_BAD_OP;
+  }
+}