carray 3.0.0 → 3.0.1

data/ext/carray_element.c

@@ -254,10 +254,10 @@ rb_ca_elem_store (VALUE self, VALUE ridx, VALUE obj)
     from_array = 0;
   }
 
-  /* Super-hot path: entity + no mask + common numeric dtype + Numeric obj.
+  /* Super-hot path: entity + no mask + common numeric data type + Numeric obj.
      Bypasses rb_ca_store_index/addr -> ca_update_mask + rb_ca_obj2ptr ->
      cast_table dispatch.  Falls through to general path for: views,
-     existing mask, non-numeric dtype, UNDEF, or non-Numeric obj. */
+     existing mask, non-numeric data type, UNDEF, or non-Numeric obj. */
   if ( ca_is_entity(ca) && ! ca->mask && obj != CA_UNDEF ) {
     int8_t dt = ca->data_type;
     if ( dt == CA_FLOAT64 || dt == CA_FLOAT32 ||
@@ -269,7 +269,7 @@ rb_ca_elem_store (VALUE self, VALUE ridx, VALUE obj)
       /* Compute flat addr if T_ARRAY index path. */
       if ( from_array ) addr = elem_entity_addr(ca, idx);
       char *p = ca->ptr + ca->bytes * addr;
-      /* Convert obj to dtype + store.  Restrict to Fixnum / Float / true
+      /* Convert obj to data type + store.  Restrict to Fixnum / Float / true
          / false to avoid Bignum / Rational / Complex coercion that the
          cast_table handles in the general path. */
       switch ( dt ) {
@@ -311,7 +311,7 @@ rb_ca_elem_store (VALUE self, VALUE ridx, VALUE obj)
         if ( FIXNUM_P(obj) )             { *(uint8_t *)p = (FIX2LONG(obj) != 0); return obj; }
         break;
       }
-      /* Fall through: dtype matches but obj kind needs general coercion. */
+      /* Fall through: data type matches but obj kind needs general coercion. */
     }
   }
 
@@ -344,7 +344,7 @@ rb_ca_elem_fetch (VALUE self, VALUE ridx)
     volatile VALUE out;
     elem_parse_idx_array(ca, ridx, idx);
 
-    /* Super-hot path: entity + common numeric dtype + no mask.
+    /* Super-hot path: entity + common numeric data type + no mask.
        Bypass ca_fetch_index dispatch AND rb_ca_ptr2obj cast-table dispatch.
        Covers the bench's float64 / int64 / int32 cases. */
     if ( ca_is_entity(ca) && ! ca->mask ) {
@@ -454,7 +454,7 @@ rb_ca_elem_incr (VALUE self, VALUE ridx1)
 
   has_mask = elem_probe_mask(ca);
 
-  /* Super-hot path: entity + no mask + integer dtype.
+  /* Super-hot path: entity + no mask + integer data type.
      Reads p directly, modifies in place — no separate fetch/store dispatch. */
   if ( ca_is_entity(ca) && ! has_mask ) {
     ca_size_t addr;
@@ -818,7 +818,7 @@ rb_ca_elem_min (VALUE self, VALUE ridx, VALUE rval)
              "elem_min requires a numeric array");
   }
 
-  /* Super-hot path: entity + numeric dtype + Fixnum/Float rval. */
+  /* Super-hot path: entity + numeric data type + Fixnum/Float rval. */
   ELEM_MINMAX_BODY(<);
 
   /* General path: view / Bignum-Rational-Complex rval / fall-through.

data/ext/carray_factorize.c

@@ -59,7 +59,7 @@
       codes  : narrow unsigned CArray (uint8 / uint16 / uint32), the code
                storage; masked source cells store the type-max sentinel
                (from_codes derives the mask from it, matching categorize).
-      levels : integer CArray (source dtype) of the k distinct values in
+      levels : integer CArray (source data type) of the k distinct values in
                first-appearance order.
     self.__mask_duplicates__(axis) -> boolean CArray of self.shape, true at
       each cell that duplicates an earlier-seen one along axis (per-fiber
@@ -487,7 +487,7 @@ fz_levels_free (fz_levels *l)
      codes  = narrow unsigned CArray; masked source cells store the type-max
               sentinel (0xFF / 0xFFFF / 0xFFFFFFFF), so from_codes reconstructs
               the mask exactly as the mask_duplicates path does.
-     levels = CArray (source dtype) of the k distinct values, in first-appearance
+     levels = CArray (source data type) of the k distinct values, in first-appearance
               (row-major flatten) order.
 */
 static VALUE
@@ -508,7 +508,7 @@ rb_ca_factorize_appearance (VALUE self)
     break;
   default:
     rb_raise(rb_eCADataTypeError,
-             "__factorize_appearance__: integer, float, object, or fixlen dtype required (got %d)", dt);
+             "__factorize_appearance__: integer, float, object, or fixlen data type required (got %d)", dt);
   }
   if ( ca->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__factorize_appearance__: need ndim >= 1");
@@ -535,8 +535,8 @@ rb_ca_factorize_appearance (VALUE self)
   boolean8_t *m;
   ca_size_t   n;
 
-  /* Fiber inner loop, monomorphised per dtype.  WIDEN sign- or zero-extends the
-     element to a 64-bit key; equality within one dtype is preserved. */
+  /* Fiber inner loop, monomorphised per data type.  WIDEN sign- or zero-extends the
+     element to a 64-bit key; equality within one data type is preserved. */
   #define FZ_LOOP(T, WIDEN)                                                  \
     do {                                                                     \
       const T  *ip = (const T *) p_in;                                       \
@@ -664,7 +664,7 @@ rb_ca_factorize_appearance (VALUE self)
     }
   }
 
-  /* Levels: the interned raw values, in source dtype.  CA_FIXLEN carries its
+  /* Levels: the interned raw values, in source data type.  CA_FIXLEN carries its
      element width; numeric / object use bytes = 0. */
   ca_size_t ldim[1];
   ldim[0] = k;
@@ -715,7 +715,7 @@ rb_ca_mask_duplicates (VALUE self, VALUE vaxis)
     break;
   default:
     rb_raise(rb_eCADataTypeError,
-             "__mask_duplicates__: numeric, object, or fixlen dtype required (got %d)", dt);
+             "__mask_duplicates__: numeric, object, or fixlen data type required (got %d)", dt);
   }
   if ( ca->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__mask_duplicates__: need ndim >= 1");
@@ -740,8 +740,8 @@ rb_ca_mask_duplicates (VALUE self, VALUE vaxis)
   boolean8_t *m;
   ca_size_t   n;
 
-  /* Fiber inner loop, monomorphised per dtype.  WIDEN sign- or zero-extends the
-     element to a 64-bit key; equality within one dtype is preserved.  The hash
+  /* Fiber inner loop, monomorphised per data type.  WIDEN sign- or zero-extends the
+     element to a 64-bit key; equality within one data type is preserved.  The hash
      interns first appearances, so is_new == 0 flags a duplicate. */
   #define MD_LOOP(T, WIDEN)                                                   \
     do {                                                                      \
@@ -839,7 +839,7 @@ rb_ca_mask_duplicates (VALUE self, VALUE vaxis)
 
    INTERNAL (CArray#unique). Collect the distinct values of self in
    first-appearance (row-major flatten) order, one linear pass, no sort. Returns
-   a 1-D CArray of source dtype. Masked cells do not participate.
+   a 1-D CArray of source data type. Masked cells do not participate.
 
    Numeric (integer / float): distinctness follows `==` except NaN collapses to a
    single distinct value (all NaN patterns map to one canonical hash key) and
@@ -876,7 +876,7 @@ rb_ca_unique_flat (VALUE self)
     break;
   default:
     rb_raise(rb_eCADataTypeError,
-             "__unique_flat__: numeric, object, or fixlen dtype required (got %d)", dt);
+             "__unique_flat__: numeric, object, or fixlen data type required (got %d)", dt);
   }
   if ( ca->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__unique_flat__: need ndim >= 1");
@@ -1098,8 +1098,8 @@ fz_intern_all (fz_hash *h, CArray *cv, fz_levels *lv)
    seen-set).  One pass to build the set from `values`, one pass to probe self;
    no sort, peak memory O(distinct values).
 
-   `values` must be a CArray of the same dtype as self (the Ruby surface coerces
-   Array / Range / other-dtype input first).  Masked cells of `values` do not
+   `values` must be a CArray of the same data type as self (the Ruby surface coerces
+   Array / Range / other-type input first).  Masked cells of `values` do not
    enter the set.  Masked cells of self stay masked in the output (membership is
    unknown), reproducing the mask propagation of the retired `contains`
    (self.eq(v)); their boolean payload is false.
@@ -1127,7 +1127,7 @@ rb_ca_is_in (VALUE self, VALUE rvalues)
     break;
   default:
     rb_raise(rb_eCADataTypeError,
-             "__is_in__: numeric, object, or fixlen dtype required (got %d)", dt);
+             "__is_in__: numeric, object, or fixlen data type required (got %d)", dt);
   }
   if ( ca->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__is_in__: need ndim >= 1");
@@ -1139,7 +1139,7 @@ rb_ca_is_in (VALUE self, VALUE rvalues)
   GetCArray(rvalues, cv);
   if ( cv->data_type != dt || (dt == CA_FIXLEN && cv->bytes != ca->bytes) ) {
     rb_raise(rb_eCADataTypeError,
-             "__is_in__: values dtype must match self (%d)", dt);
+             "__is_in__: values data type must match self (%d)", dt);
   }
   if ( cv->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__is_in__: values need ndim >= 1");
@@ -1256,7 +1256,7 @@ rb_ca_is_in (VALUE self, VALUE rvalues)
    through the discovery-family lanes (NaN collapse, rb_hash + rb_eql, byte
    equality).
 
-   `ref` must be a CArray of the same dtype as self (the Ruby surface coerces
+   `ref` must be a CArray of the same data type as self (the Ruby surface coerces
    first).  Masked cells of `ref` do not enter the map but still occupy their
    flat address (position counts).  Masked cells of self, and cells whose value
    is absent from `ref`, are UNDEF in the output.  "First" occurrence is
@@ -1286,7 +1286,7 @@ rb_ca_locate_addr (VALUE self, VALUE rref)
     break;
   default:
     rb_raise(rb_eCADataTypeError,
-             "__locate_addr__: numeric, object, or fixlen dtype required (got %d)", dt);
+             "__locate_addr__: numeric, object, or fixlen data type required (got %d)", dt);
   }
   if ( ca->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__locate_addr__: need ndim >= 1");
@@ -1297,7 +1297,7 @@ rb_ca_locate_addr (VALUE self, VALUE rref)
   GetCArray(rref, cr);
   if ( cr->data_type != dt || (dt == CA_FIXLEN && cr->bytes != ca->bytes) ) {
     rb_raise(rb_eCADataTypeError,
-             "__locate_addr__: ref dtype must match self (%d)", dt);
+             "__locate_addr__: ref data type must match self (%d)", dt);
   }
   if ( cr->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__locate_addr__: ref need ndim >= 1");
@@ -1521,7 +1521,7 @@ rb_ca_locate_addr (VALUE self, VALUE rref)
 /* Shared body of __intersection__ (keep_when_hit = 1) and __difference__
    (keep_when_hit = 0): the distinct values of self that are (resp. are not)
    present in `other`, in self's first-appearance order, as a 1-D CArray of
-   self's dtype.  Two seen-sets: `hoth` built from `other` is the probe set;
+   self's data type.  Two seen-sets: `hoth` built from `other` is the probe set;
    `hself` dedups self so each distinct value is decided once.  Masked cells of
    either array do not participate.  Distinctness is the discovery family's per
    lane (numeric `==` + NaN collapse + -0.0 == +0.0, object hash/eql? + NaN
@@ -1545,7 +1545,7 @@ fz_set_relation (VALUE self, VALUE rother, int keep_when_hit)
     break;
   default:
     rb_raise(rb_eCADataTypeError,
-             "set relation: numeric, object, or fixlen dtype required (got %d)", dt);
+             "set relation: numeric, object, or fixlen data type required (got %d)", dt);
   }
   if ( ca->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "set relation: need ndim >= 1");
@@ -1555,7 +1555,7 @@ fz_set_relation (VALUE self, VALUE rother, int keep_when_hit)
   }
   GetCArray(rother, co);
   if ( co->data_type != dt || (dt == CA_FIXLEN && co->bytes != ca->bytes) ) {
-    rb_raise(rb_eCADataTypeError, "set relation: other dtype must match self (%d)", dt);
+    rb_raise(rb_eCADataTypeError, "set relation: other data type must match self (%d)", dt);
   }
   if ( co->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "set relation: other need ndim >= 1");
@@ -1730,7 +1730,7 @@ rb_ca_set_union (VALUE self, VALUE rother)
     break;
   default:
     rb_raise(rb_eCADataTypeError,
-             "__union__: numeric, object, or fixlen dtype required (got %d)", dt);
+             "__union__: numeric, object, or fixlen data type required (got %d)", dt);
   }
   if ( ca->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__union__: need ndim >= 1");
@@ -1740,7 +1740,7 @@ rb_ca_set_union (VALUE self, VALUE rother)
   }
   GetCArray(rother, co);
   if ( co->data_type != dt || (dt == CA_FIXLEN && co->bytes != ca->bytes) ) {
-    rb_raise(rb_eCADataTypeError, "__union__: other dtype must match self (%d)", dt);
+    rb_raise(rb_eCADataTypeError, "__union__: other data type must match self (%d)", dt);
   }
   if ( co->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__union__: other need ndim >= 1");
@@ -1779,7 +1779,7 @@ rb_ca_set_union (VALUE self, VALUE rother)
    first-appearance (row-major flatten) order together with the number of times
    each occurs, one linear pass, no sort.
    Returns [levels, counts]:
-     levels = 1-D CArray of source dtype, the k distinct values in appearance
+     levels = 1-D CArray of source data type, the k distinct values in appearance
               order (identical to __unique_flat__).
      counts = 1-D CA_INT64 of length k, counts[i] = occurrences of levels[i].
    Masked cells do not participate (skipped, not counted). Numeric distinctness
@@ -1806,7 +1806,7 @@ rb_ca_value_counts_flat (VALUE self)
     break;
   default:
     rb_raise(rb_eCADataTypeError,
-             "__value_counts_flat__: numeric, object, or fixlen dtype required (got %d)", dt);
+             "__value_counts_flat__: numeric, object, or fixlen data type required (got %d)", dt);
   }
   if ( ca->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__value_counts_flat__: need ndim >= 1");
@@ -1979,7 +1979,7 @@ rb_ca_nunique (VALUE self, VALUE vaxis, VALUE vkeep)
     break;
   default:
     rb_raise(rb_eCADataTypeError,
-             "__nunique__: numeric, object, or fixlen dtype required (got %d)", dt);
+             "__nunique__: numeric, object, or fixlen data type required (got %d)", dt);
   }
   if ( ca->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__nunique__: need ndim >= 1");
@@ -2126,7 +2126,7 @@ rb_ca_is_mode (VALUE self, VALUE vaxis)
     break;
   default:
     rb_raise(rb_eCADataTypeError,
-             "__is_mode__: numeric, object, or fixlen dtype required (got %d)", dt);
+             "__is_mode__: numeric, object, or fixlen data type required (got %d)", dt);
   }
   if ( ca->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__is_mode__: need ndim >= 1");
@@ -2344,7 +2344,7 @@ rb_ca_mode_axis (VALUE self, VALUE vaxis)
     break;
   default:
     rb_raise(rb_eCADataTypeError,
-             "__mode_axis__: numeric dtype required (got %d)", dt);
+             "__mode_axis__: numeric data type required (got %d)", dt);
   }
   if ( ca->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__mode_axis__: need ndim >= 1");

data/ext/carray_hold.c

@@ -5,7 +5,7 @@
   (see devel/PROPOSAL_UNMASK_FILL_METHOD.md).
 
   Hold copies a cell's bytes into masked cells with no arithmetic and no
-  per-dtype behavior, so a single ca->bytes-width memcpy walk covers every
+  per-type behavior, so a single ca->bytes-width memcpy walk covers every
   data_type -- numeric, complex, bool, object (VALUE-slot byte copy of an
   already-live value), fixlen, and Face storage.  This native does forward
   hold along one axis only and returns a fresh same-shape entity; the

data/ext/carray_index_classifier.c

@@ -37,7 +37,6 @@ static ID ca_classifier_id_excl_end = 0;
 /* Symbol cache — see the range-macro comment above for why this
    file keeps its own copy independent of carray_access.c. */
 
-static VALUE ca_classifier_sym_star  = Qundef;
 static VALUE ca_classifier_sym_perc  = Qundef;
 static VALUE ca_classifier_sym_under = Qundef;
 static VALUE ca_classifier_sym_gt    = Qundef;   /* :> slab-iterator marker */
@@ -46,8 +45,7 @@ static VALUE ca_classifier_sym_tilde = Qundef;   /* :~ rubber-dim alias for `fal
 static inline void
 ca_classifier_sym_cache_init (void)
 {
-  if ( ca_classifier_sym_star == Qundef ) {
-    ca_classifier_sym_star  = ID2SYM(rb_intern("*"));
+  if ( ca_classifier_sym_perc == Qundef ) {
     ca_classifier_sym_perc  = ID2SYM(rb_intern("%"));
     ca_classifier_sym_under = ID2SYM(rb_intern("_"));
     ca_classifier_sym_gt    = ID2SYM(rb_intern(">"));
@@ -166,7 +164,7 @@ ca_classifier_try_address_fast_path (ca_classifier_ctx_t *ctx)
 /* Single-character alphabetic Symbols (`:a`-`:z` / `:A`-`:Z`) are
    reserved for future contraction notation.  Raises
    NotImplementedError rather than the generic IndexError.  The
-   caller passes any Symbol that is not `:_` / `:*` / `:%`; a
+   caller passes any Symbol that is not `:_` / `:%`; a
    non-reserved Symbol returns without action. */
 static inline void
 ca_classifier_check_reserved_contraction_symbol (VALUE sym)
@@ -763,12 +761,6 @@ ca_classifier_try_argc1_special (ca_classifier_ctx_t *ctx)
              ca_type_name[cs->data_type]);
   }
 
-  /* :* → UNBOUND_REPEAT. */
-  if ( arg == ca_classifier_sym_star ) {
-    info->type = CA_REG_UNBOUND_REPEAT;
-    return 1;
-  }
-
   /* ndim > 1 with Integer → ADDRESS.  Fixnum was caught by the
      fast path; this branch handles Bignum. */
   if ( ctx->ca_ndim > 1 && rb_obj_is_kind_of(arg, rb_cInteger) ) {
@@ -832,7 +824,7 @@ rb_ca_scan_index_v2 (int ca_ndim, ca_size_t *ca_dim, ca_size_t ca_elements,
   }
 
   /* argv[0] = multi-char Symbol → METHOD_CALL.  Single-char
-     specials (:_ / :* / :%) fall through the strlen check and are
+     specials (:_ / :%) fall through the strlen check and are
      handled downstream (argc == 1 special / fast paths / main
      loop).  Single-char alphabetic reserved-contraction Symbols
      also fall through here and are raised later by the per-axis
@@ -859,20 +851,15 @@ rb_ca_scan_index_v2 (int ca_ndim, ca_size_t *ca_dim, ca_size_t ca_elements,
      when argc == 1 && ndim == 1 falls through to the POINT 1-D
      classification below. */
 
-  /* CAREFUL: pre-scan for :% / :*.  Either Symbol at any position
-     pins the final REG and short-circuits both the main loop and
-     the argc / ndim validation below — skipping the pre-scan lets
-     the ndim mismatch check fire before the Symbol is
-     recognised. */
+  /* CAREFUL: pre-scan for :%.  The Symbol at any position pins the
+     final REG and short-circuits both the main loop and the argc /
+     ndim validation below — skipping the pre-scan lets the ndim
+     mismatch check fire before the Symbol is recognised. */
   for (i = 0; i < ctx.argc; i++) {
     if ( ctx.argv[i] == ca_classifier_sym_perc ) {
       info->type = CA_REG_REPEAT;
       return;
     }
-    if ( ctx.argv[i] == ca_classifier_sym_star ) {
-      info->type = CA_REG_UNBOUND_REPEAT;
-      return;
-    }
   }
 
   ca_classifier_expand_rubber_dim(&ctx);
@@ -941,7 +928,6 @@ rb_ca_s_scan_index_v2 (VALUE self, VALUE rdim, VALUE ridx)
     case CA_REG_GRID:
     case CA_REG_MAPPING:
     case CA_REG_METHOD_CALL:
-    case CA_REG_UNBOUND_REPEAT:
     case CA_REG_MEMBER:
     case CA_REG_ATTRIBUTE:
       break;

data/ext/carray_internal.h

@@ -59,8 +59,24 @@ void ca_bit_pack   (const boolean8_t *src, ca_size_t elements, ca_size_t pbytes,
 void    ca_lazy_arena_enter   (void);
 void    ca_lazy_arena_exit    (void);
 void   *ca_lazy_arena_acquire (ca_size_t bytes);
+void   *ca_lazy_arena_acquire_object (ca_size_t n_elements);
 void    ca_lazy_arena_release (void *ptr);
 
+/* ---- CA_OBJECT GC guard (carray_lazy.c) ----------------------------------
+
+   A CA_OBJECT cell is a VALUE, and a materialise writes those cells into a
+   buffer no Ruby object owns.  Object-lane kernels call rb_funcall per cell,
+   so a collection can happen halfway through and free what has been written
+   so far.  Hold the buffer while it is exposed like that, and after the
+   materialise until a Ruby object takes ownership of it.
+
+   The cells must already be valid VALUEs, so a fresh buffer is Qnil-filled
+   before it is held.  ca_gc_hold_push returns the depth to hand back to
+   ca_gc_hold_pop_to, so nested holds unwind in order. */
+
+int     ca_gc_hold_push   (void *ptr, ca_size_t n_elements);
+void    ca_gc_hold_pop_to (int depth);
+
 /* Non-zero iff the object is an element-wise lazy view (CAMonOp / CABinOp /
    CABinCmp / CAMonCmp / CALazyMarker).  The streaming branch of the
    mkkernel-generated reduction kernels tests this to decide whether it can
@@ -111,10 +127,10 @@ VALUE    rb_ca_fake_new (VALUE cary, int8_t data_type, ca_size_t bytes);
 CARepeat *ca_repeat_new (CArray *carray, int8_t ndim, ca_size_t *count);
 VALUE     rb_ca_repeat_new (VALUE cary, int8_t ndim, ca_size_t *count);
 
-/* ca_obj_unbound_repeat.c */
-VALUE    rb_ca_ubrep_new (VALUE cary, int32_t rep_ndim, ca_size_t *rep_dim);
-
 /* ca_obj_reduce.c */
 CAReduce *ca_reduce_new (CArray *carray, ca_size_t count, ca_size_t offset);
 
+/* carray_broadcast.c */
+void     ca_broadcast_to_destination (VALUE dst, volatile VALUE *src);
+
 #endif /* CARRAY_INTERNAL_H */

data/ext/carray_kernels_bincmp.c

@@ -34,6 +34,7 @@ static inline VALUE BOOL2VAL (boolean8_t x) { return x ? Qtrue : Qfalse; }
 #endif
 
 #include "ca_op_powi.h"
+#include "ca_op_cmplx64.h"
 
 /* ===== bincmp feq ============================================ */