carray 3.0.3 → 3.0.4

data/ext/carray_kernels_reduce_boolean.c

@@ -0,0 +1,406 @@
+/* ---------------------------------------------------------------------------
+
+   carray_kernels.c -- GENERATED by ext/mkkernel.rb -- DO NOT EDIT
+
+   Kernel definitions live in mkkernel.rb (search for `MkKernel.reduce`).
+   Regenerate by running:
+
+     cd ext && ruby mkkernel.rb > carray_kernels.c
+
+   extconf.rb regenerates automatically when mkkernel.rb is touched.
+
+   --------------------------------------------------------------------------- */
+
+#include "carray.h"
+#include "ca_kernel_iterator.h"
+#include "ca_sort_kernels.h"   /* sort kernels: internal, not via the carray.h umbrella */
+#include "carray_internal.h"   /* ca_lazy_arena_*, ca_is_lazy_view (streaming reduce) */
+#include "ca_obj_face.h"       /* rb_ca_strip_face_value (Face ordering gate) */
+#include <math.h>
+#include <stdint.h>
+#include <stdlib.h>   /* qsort, mergesort (HAVE_MERGESORT) -- for :sort kind */
+
+/* MEMO_REDUCTION_FASTPATH_ENTITY_ONLY_GUARD Tier 2: CAStack identity is
+   probed by operation-table function pointer (obj_type is runtime-
+   assigned, so no CA_OBJ_STACK compile-time constant exists). */
+extern ca_operation_function_t ca_stack_func;
+/* The square root of a variance: an ε-negative from rounding becomes 0,
+   a NaN stays NaN (fmax(NaN, 0.0) is 0.0). */
+#ifndef CARRAY_SQRT_CLAMP_DEFINED
+#define CARRAY_SQRT_CLAMP_DEFINED
+static inline double ca_sqrt_clamp (double v) { return sqrt(v < 0.0 ? 0.0 : v); }
+#endif
+
+/* BOOL2VAL: bool -> Ruby (Qtrue/Qfalse).  Used as ruby_scalar wrapper
+   for the all/any flat-reduction Ruby surface so `a.all` / `a.any`
+   return real true/false, not Integer 0/1.  (BOOL2OBJ already exists
+   but returns Integer per CArray's boolean-as-int convention.)  */
+#ifndef CARRAY_BOOL2VAL_DEFINED
+#define CARRAY_BOOL2VAL_DEFINED
+static inline VALUE BOOL2VAL (boolean8_t x) { return x ? Qtrue : Qfalse; }
+#endif
+
+#include "ca_op_powi.h"
+#include "ca_op_cmplx64.h"
+
+/* ===== all_ki ============================================ */
+
+typedef struct {
+  void      *chunk;
+  CArray    *ca;
+} all_ki_stream_bool_t;
+
+static VALUE
+all_ki_stream_bool (VALUE arg)
+{
+      all_ki_stream_bool_t *__ctx = (all_ki_stream_bool_t *) arg;
+      CArray *ca = __ctx->ca;
+      ca_size_t __inner = 1;
+      int       __k;
+      for ( __k = 1; __k < ca->ndim; __k++ ) __inner *= ca->dim[__k];
+      ca_size_t __target = 4096;   /* L1d-friendly element budget (32KB for f64) */
+      ca_size_t __rows   = (__inner > 0) ? (__target / __inner) : __target;
+      if ( __rows < 1 ) __rows = 1;       /* at least one row per chunk */
+      ca_size_t __chunk_elems = __rows * __inner;
+      ca_size_t __outer       = ca->dim[0];
+      ca_size_t __starts[CA_RANK_MAX]  = {0};
+      ca_size_t __counts[CA_RANK_MAX];
+      ca_size_t __strides[CA_RANK_MAX];
+      ca_size_t __s = sizeof(boolean8_t);
+      for ( __k = ca->ndim - 1; __k >= 0; __k-- ) {
+        __strides[__k] = __s;
+        __s *= ca->dim[__k];
+      }
+      for ( __k = 1; __k < ca->ndim; __k++ ) __counts[__k] = ca->dim[__k];
+      ca_size_t __outer_off = 0;
+      boolean8_t acc;
+      acc = (1);
+      boolean8_t *__chunk = (boolean8_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(boolean8_t));
+      __ctx->chunk = __chunk;
+      while ( __outer_off < __outer ) {
+        ca_size_t __r = (__outer - __outer_off < __rows) ? (__outer - __outer_off) : __rows;
+        ca_size_t __n = __r * __inner;
+        __starts[0] = __outer_off;
+        __counts[0] = __r;
+        ca_xfer_stride(ca, __starts, __counts, __strides, __chunk, CA_XFER_GET);
+        ca_size_t __i;
+        for ( __i = 0; __i < __n; __i++ ) {
+          boolean8_t v = __chunk[__i];
+          acc &= v;
+        }
+        __outer_off += __r;
+      }
+      return BOOL2VAL((boolean8_t) (acc));
+}
+
+static VALUE
+all_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis)
+{
+    if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
+         ca->elements > 0 &&
+         ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
+         ca_fast_paths_enabled() ) {
+      all_ki_stream_bool_t __ctx;
+      __ctx.chunk = NULL;
+      __ctx.ca    = ca;
+      return ca_lazy_arena_protect(all_ki_stream_bool, ca_lazy_arena_release_held,
+                                   (VALUE) &__ctx);
+    }
+VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_BOOLEAN, keep_axis);
+CArray *co;
+GetCArray(vout, co);
+boolean8_t *op = (boolean8_t *) co->ptr;
+ca_iter_state st;
+int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                               slab_axes, naxes, 0);
+if ( rc != CA_ITER_OK ) {
+  rb_raise(rb_eRuntimeError,
+           "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+}
+char       *p;
+boolean8_t *m;
+ca_size_t   out_i = 0;
+      while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+      boolean8_t acc;
+      CA_SLAB_REDUCE_T(boolean8_t, st, p, m, acc, 1, acc &= v);
+      op[out_i++] = (boolean8_t) (acc);
+      }
+      ca_iter_state_finish(&st);
+      if ( naxes == ca->ndim && !keep_axis ) return BOOL2VAL(op[0]);
+      return vout;
+    }
+
+VALUE
+rb_ca_all_ki (int argc, VALUE *argv, VALUE self)
+{
+  CArray *src;
+  GetCArray(self, src);
+  volatile VALUE ropt = rb_pop_options(&argc, &argv);
+  volatile VALUE raxis = Qnil, rkeep_axis = Qnil;
+  rb_scan_options(ropt, "axis,keep_axis", &raxis, &rkeep_axis);
+  int keep_axis = RTEST(rkeep_axis);
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = rb_ca_parse_reduce_axes_kw(raxis, src, slab_axes);
+  if ( ca_is_lazy_view(src) && ! ( naxes == src->ndim && src->ndim >= 1 && ! keep_axis && ! ca_has_mask(src) ) ) {
+    volatile VALUE evaluated = ca_lazy_evaluated(self);
+    if ( ! NIL_P(evaluated) ) {
+      self = evaluated;
+      GetCArray(self, src);
+    }
+  }
+  if ( argc > 0 ) {
+    rb_raise(rb_eArgError, "%s: positional axis arguments are no longer accepted (got %d); use the axis: keyword, e.g. a.%s(axis: 0) or a.%s(axis: [0, 1])", ca_calling_method_name(), argc, ca_calling_method_name(), ca_calling_method_name());
+  }
+  switch ( src->data_type ) {
+    case CA_BOOLEAN: CA_RETURN_KEEPING(self, all_ki_native_bool(self, src, slab_axes, naxes, keep_axis));
+    default:
+      ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+      rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: boolean)", ca_calling_method_name(), ca_type_name[src->data_type]);
+  }
+  return Qnil;  /* unreachable */
+}
+
+/* ===== any_ki ============================================ */
+
+typedef struct {
+  void      *chunk;
+  CArray    *ca;
+} any_ki_stream_bool_t;
+
+static VALUE
+any_ki_stream_bool (VALUE arg)
+{
+      any_ki_stream_bool_t *__ctx = (any_ki_stream_bool_t *) arg;
+      CArray *ca = __ctx->ca;
+      ca_size_t __inner = 1;
+      int       __k;
+      for ( __k = 1; __k < ca->ndim; __k++ ) __inner *= ca->dim[__k];
+      ca_size_t __target = 4096;   /* L1d-friendly element budget (32KB for f64) */
+      ca_size_t __rows   = (__inner > 0) ? (__target / __inner) : __target;
+      if ( __rows < 1 ) __rows = 1;       /* at least one row per chunk */
+      ca_size_t __chunk_elems = __rows * __inner;
+      ca_size_t __outer       = ca->dim[0];
+      ca_size_t __starts[CA_RANK_MAX]  = {0};
+      ca_size_t __counts[CA_RANK_MAX];
+      ca_size_t __strides[CA_RANK_MAX];
+      ca_size_t __s = sizeof(boolean8_t);
+      for ( __k = ca->ndim - 1; __k >= 0; __k-- ) {
+        __strides[__k] = __s;
+        __s *= ca->dim[__k];
+      }
+      for ( __k = 1; __k < ca->ndim; __k++ ) __counts[__k] = ca->dim[__k];
+      ca_size_t __outer_off = 0;
+      boolean8_t acc;
+      acc = (0);
+      boolean8_t *__chunk = (boolean8_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(boolean8_t));
+      __ctx->chunk = __chunk;
+      while ( __outer_off < __outer ) {
+        ca_size_t __r = (__outer - __outer_off < __rows) ? (__outer - __outer_off) : __rows;
+        ca_size_t __n = __r * __inner;
+        __starts[0] = __outer_off;
+        __counts[0] = __r;
+        ca_xfer_stride(ca, __starts, __counts, __strides, __chunk, CA_XFER_GET);
+        ca_size_t __i;
+        for ( __i = 0; __i < __n; __i++ ) {
+          boolean8_t v = __chunk[__i];
+          acc |= v;
+        }
+        __outer_off += __r;
+      }
+      return BOOL2VAL((boolean8_t) (acc));
+}
+
+static VALUE
+any_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis)
+{
+    if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
+         ca->elements > 0 &&
+         ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
+         ca_fast_paths_enabled() ) {
+      any_ki_stream_bool_t __ctx;
+      __ctx.chunk = NULL;
+      __ctx.ca    = ca;
+      return ca_lazy_arena_protect(any_ki_stream_bool, ca_lazy_arena_release_held,
+                                   (VALUE) &__ctx);
+    }
+VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_BOOLEAN, keep_axis);
+CArray *co;
+GetCArray(vout, co);
+boolean8_t *op = (boolean8_t *) co->ptr;
+ca_iter_state st;
+int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                               slab_axes, naxes, 0);
+if ( rc != CA_ITER_OK ) {
+  rb_raise(rb_eRuntimeError,
+           "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+}
+char       *p;
+boolean8_t *m;
+ca_size_t   out_i = 0;
+      while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+      boolean8_t acc;
+      CA_SLAB_REDUCE_T(boolean8_t, st, p, m, acc, 0, acc |= v);
+      op[out_i++] = (boolean8_t) (acc);
+      }
+      ca_iter_state_finish(&st);
+      if ( naxes == ca->ndim && !keep_axis ) return BOOL2VAL(op[0]);
+      return vout;
+    }
+
+VALUE
+rb_ca_any_ki (int argc, VALUE *argv, VALUE self)
+{
+  CArray *src;
+  GetCArray(self, src);
+  volatile VALUE ropt = rb_pop_options(&argc, &argv);
+  volatile VALUE raxis = Qnil, rkeep_axis = Qnil;
+  rb_scan_options(ropt, "axis,keep_axis", &raxis, &rkeep_axis);
+  int keep_axis = RTEST(rkeep_axis);
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = rb_ca_parse_reduce_axes_kw(raxis, src, slab_axes);
+  if ( ca_is_lazy_view(src) && ! ( naxes == src->ndim && src->ndim >= 1 && ! keep_axis && ! ca_has_mask(src) ) ) {
+    volatile VALUE evaluated = ca_lazy_evaluated(self);
+    if ( ! NIL_P(evaluated) ) {
+      self = evaluated;
+      GetCArray(self, src);
+    }
+  }
+  if ( argc > 0 ) {
+    rb_raise(rb_eArgError, "%s: positional axis arguments are no longer accepted (got %d); use the axis: keyword, e.g. a.%s(axis: 0) or a.%s(axis: [0, 1])", ca_calling_method_name(), argc, ca_calling_method_name(), ca_calling_method_name());
+  }
+  switch ( src->data_type ) {
+    case CA_BOOLEAN: CA_RETURN_KEEPING(self, any_ki_native_bool(self, src, slab_axes, naxes, keep_axis));
+    default:
+      ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+      rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: boolean)", ca_calling_method_name(), ca_type_name[src->data_type]);
+  }
+  return Qnil;  /* unreachable */
+}
+
+/* ===== none_ki ============================================ */
+
+typedef struct {
+  void      *chunk;
+  CArray    *ca;
+} none_ki_stream_bool_t;
+
+static VALUE
+none_ki_stream_bool (VALUE arg)
+{
+      none_ki_stream_bool_t *__ctx = (none_ki_stream_bool_t *) arg;
+      CArray *ca = __ctx->ca;
+      ca_size_t __inner = 1;
+      int       __k;
+      for ( __k = 1; __k < ca->ndim; __k++ ) __inner *= ca->dim[__k];
+      ca_size_t __target = 4096;   /* L1d-friendly element budget (32KB for f64) */
+      ca_size_t __rows   = (__inner > 0) ? (__target / __inner) : __target;
+      if ( __rows < 1 ) __rows = 1;       /* at least one row per chunk */
+      ca_size_t __chunk_elems = __rows * __inner;
+      ca_size_t __outer       = ca->dim[0];
+      ca_size_t __starts[CA_RANK_MAX]  = {0};
+      ca_size_t __counts[CA_RANK_MAX];
+      ca_size_t __strides[CA_RANK_MAX];
+      ca_size_t __s = sizeof(boolean8_t);
+      for ( __k = ca->ndim - 1; __k >= 0; __k-- ) {
+        __strides[__k] = __s;
+        __s *= ca->dim[__k];
+      }
+      for ( __k = 1; __k < ca->ndim; __k++ ) __counts[__k] = ca->dim[__k];
+      ca_size_t __outer_off = 0;
+      boolean8_t acc;
+      acc = (1);
+      boolean8_t *__chunk = (boolean8_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(boolean8_t));
+      __ctx->chunk = __chunk;
+      while ( __outer_off < __outer ) {
+        ca_size_t __r = (__outer - __outer_off < __rows) ? (__outer - __outer_off) : __rows;
+        ca_size_t __n = __r * __inner;
+        __starts[0] = __outer_off;
+        __counts[0] = __r;
+        ca_xfer_stride(ca, __starts, __counts, __strides, __chunk, CA_XFER_GET);
+        ca_size_t __i;
+        for ( __i = 0; __i < __n; __i++ ) {
+          boolean8_t v = __chunk[__i];
+          acc &= !v;
+        }
+        __outer_off += __r;
+      }
+      return BOOL2VAL((boolean8_t) (acc));
+}
+
+static VALUE
+none_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis)
+{
+    if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
+         ca->elements > 0 &&
+         ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
+         ca_fast_paths_enabled() ) {
+      none_ki_stream_bool_t __ctx;
+      __ctx.chunk = NULL;
+      __ctx.ca    = ca;
+      return ca_lazy_arena_protect(none_ki_stream_bool, ca_lazy_arena_release_held,
+                                   (VALUE) &__ctx);
+    }
+VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_BOOLEAN, keep_axis);
+CArray *co;
+GetCArray(vout, co);
+boolean8_t *op = (boolean8_t *) co->ptr;
+ca_iter_state st;
+int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                               slab_axes, naxes, 0);
+if ( rc != CA_ITER_OK ) {
+  rb_raise(rb_eRuntimeError,
+           "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+}
+char       *p;
+boolean8_t *m;
+ca_size_t   out_i = 0;
+      while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+      boolean8_t acc;
+      CA_SLAB_REDUCE_T(boolean8_t, st, p, m, acc, 1, acc &= !v);
+      op[out_i++] = (boolean8_t) (acc);
+      }
+      ca_iter_state_finish(&st);
+      if ( naxes == ca->ndim && !keep_axis ) return BOOL2VAL(op[0]);
+      return vout;
+    }
+
+VALUE
+rb_ca_none_ki (int argc, VALUE *argv, VALUE self)
+{
+  CArray *src;
+  GetCArray(self, src);
+  volatile VALUE ropt = rb_pop_options(&argc, &argv);
+  volatile VALUE raxis = Qnil, rkeep_axis = Qnil;
+  rb_scan_options(ropt, "axis,keep_axis", &raxis, &rkeep_axis);
+  int keep_axis = RTEST(rkeep_axis);
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = rb_ca_parse_reduce_axes_kw(raxis, src, slab_axes);
+  if ( ca_is_lazy_view(src) && ! ( naxes == src->ndim && src->ndim >= 1 && ! keep_axis && ! ca_has_mask(src) ) ) {
+    volatile VALUE evaluated = ca_lazy_evaluated(self);
+    if ( ! NIL_P(evaluated) ) {
+      self = evaluated;
+      GetCArray(self, src);
+    }
+  }
+  if ( argc > 0 ) {
+    rb_raise(rb_eArgError, "%s: positional axis arguments are no longer accepted (got %d); use the axis: keyword, e.g. a.%s(axis: 0) or a.%s(axis: [0, 1])", ca_calling_method_name(), argc, ca_calling_method_name(), ca_calling_method_name());
+  }
+  switch ( src->data_type ) {
+    case CA_BOOLEAN: CA_RETURN_KEEPING(self, none_ki_native_bool(self, src, slab_axes, naxes, keep_axis));
+    default:
+      ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+      rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: boolean)", ca_calling_method_name(), ca_type_name[src->data_type]);
+  }
+  return Qnil;  /* unreachable */
+}
+
+void
+Init_carray_kernels_reduce_boolean (void)
+{
+  /* Phase E rewire: legacy 'all' now dispatches via all_ki */
+  rb_define_method(rb_cCArray, "all", rb_ca_all_ki, -1);
+  /* Phase E rewire: legacy 'any' now dispatches via any_ki */
+  rb_define_method(rb_cCArray, "any", rb_ca_any_ki, -1);
+  /* Phase E rewire: legacy 'none' now dispatches via none_ki */
+  rb_define_method(rb_cCArray, "none", rb_ca_none_ki, -1);
+}