carray 3.0.4 → 3.0.5

data/ext/carray_memory_view.c

@@ -1410,7 +1410,7 @@ ca_mv_wrap_body (VALUE arg)
                            a->target_class);
   rb_ivar_set(wrap, rb_intern("memory_view_source"), a->obj);
   rb_ivar_set(wrap, rb_intern("memory_view_holder"), a->data_holder_obj);
-  ca_mv_extract(wrap, &ca);
+  GetCArray(wrap, ca);
   if ( v->readonly ) {
     ca_set_flag(ca, CA_FLAG_READ_ONLY);
   }
@@ -1527,7 +1527,7 @@ ca_mv_from_body (VALUE arg)
 
   result = rb_carray_new(data_type, d->ndim, d->dim,
                          ca_mv_carray_bytes_for(data_type, v->item_size), NULL);
-  ca_mv_extract(result, &ca);
+  GetCArray(result, ca);
 
   if ( d->contiguous ) {
     memcpy(ca->ptr, v->data, (size_t) ca_length(ca));

data/ext/carray_operator.c

@@ -1473,7 +1473,7 @@ rb_ca_call_binop (volatile VALUE self, volatile VALUE other,
       /* 1-shot ALLOCV path.  At most 1 operand needs ALLOCV; the other is
          alias-direct. */
       volatile VALUE h1 = Qnil, h2 = Qnil;
-      char *p1, *p2;
+      char *p1 = NULL, *p2 = NULL;
       int a1 = 0, a2 = 0;
       (void) h1; (void) h2;
 
@@ -1841,7 +1841,7 @@ rb_ca_call_triop (VALUE self, VALUE other2, VALUE other3,
 
     if ( !use_chunked ) {
       volatile VALUE h1 = Qnil, h2 = Qnil, h3 = Qnil;
-      char *p1, *p2, *p3;
+      char *p1 = NULL, *p2 = NULL, *p3 = NULL;
       int attached1, attached2, attached3;
       (void) h1; (void) h2; (void) h3;
 
@@ -1984,7 +1984,7 @@ rb_ca_call_triop_bang (VALUE self, VALUE other2, VALUE other3,
 
     if ( !use_chunked ) {
       volatile VALUE h2 = Qnil, h3 = Qnil;
-      char *p2, *p3;
+      char *p2 = NULL, *p3 = NULL;
       int attached2, attached3;
       ca_triop_call_t k;
       CArray *held[3];
@@ -2129,7 +2129,7 @@ rb_ca_call_moncmp (VALUE self, ca_moncmp_func_t func[])
 
   {
     volatile VALUE h1 = Qnil;
-    char *p1;
+    char *p1 = NULL;
     int attached1;
     (void) h1;
 
@@ -2452,7 +2452,7 @@ rb_ca_call_bincmp (volatile VALUE self, volatile VALUE other,
 
       if ( !use_chunked ) {
         volatile VALUE h1 = Qnil, h2 = Qnil;
-        char *p1, *p2;
+        char *p1 = NULL, *p2 = NULL;
         int attached1, attached2;
         (void) h1; (void) h2;
 

data/ext/carray_order.c

@@ -242,7 +242,13 @@ rb_ca_project (int argc, VALUE *argv, VALUE self)
   char *lfval, *ufval;
   int self_is_face;
 
-  rb_scan_args(argc, argv, "12", (VALUE *)&ridx, (VALUE *) &vlfval, (VALUE *) &vufval);
+  {
+    VALUE ropt = Qnil;
+    /* project takes no keyword: one given was read as a fill value. */
+    rb_scan_args(argc, argv, "12:", (VALUE *)&ridx, (VALUE *) &vlfval,
+                 (VALUE *) &vufval, &ropt);
+    rb_scan_options(ropt, "");
+  }
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
   self_is_face = ca_is_face(ca);
@@ -721,13 +727,14 @@ rb_ca_range_method (VALUE self)
 
 /* ---- nlargest / nsmallest family ------------------------------------- */
 
-/* The partition picks the right values but, among cells that tie with the
-   last one picked, any of them.  The answer is the cells first in the
-   order (value, then NaN, then masked; the values descending for the
-   largest) with ties broken by position, as `order` breaks them.  So the
-   tied candidates are replaced by the earliest cells that tie, and the
-   candidates are sorted by (order, position): O(n) per fiber besides the
-   sort of the candidates. */
+/* The answer is the cells first in the order (value, then NaN, then
+   masked; the values descending for the largest) with ties broken by
+   position, as `order` breaks them.  Fewer cells than the fiber are found
+   by the buffered walk below.  The other routes (the whole fiber, and the
+   keys the walk does not read) sort or partition every cell, which picks
+   the right values but, among cells that tie with the last one picked,
+   any of them; ca_topk_stable replaces the tied candidates by the
+   earliest cells that tie and sorts the candidates by (order, position). */
 
 typedef struct {
   const char       *v;      /* the fiber's values, contiguous */
@@ -936,6 +943,206 @@ ca_topk_has_cells_after_numbers (VALUE self, CArray *ca)
   return 0;
 }
 
+/* ---- the buffered walk ------------------------------------------------
+   Each fiber is read once.  The cells that come before the cut (the last
+   of the cap cells kept so far, in (order, position)) are collected in a
+   buffer of a few times cap; when it fills, a selection keeps the first
+   cap and the cut moves up.  The work area is the buffer, whatever the
+   length of the fiber, and a fiber in order costs one selection per
+   bufferful instead of a heap update per cell.
+
+   The walk is written once as a macro over three others: CLASS(i) (0 a
+   value, 1 NaN, 2 masked), AFTER(i, j) (cell i comes after cell j in
+   (order, position)) and ENTERS(j) (cell j comes before the cut), and
+   instantiated per type so that the comparisons
+   are inline.  The fixlen type takes the generic comparison. */
+
+/* Rearranges b[0..nb) so that b[0..cap) hold the cap cells first in
+   (order, position): quickselect with median-of-three pivots; past a
+   depth limit the remaining range is sorted (tmp holds nb positions). */
+#define CA_TOPK_SELECT(AFTER)                                                 \
+  do {                                                                        \
+    lo = 0; hi = nb;                                                        \
+    depth = 2;                                                              \
+    for (s = nb; s > 1; s >>= 1) depth += 2;                                \
+    while ( hi - lo > 16 ) {                                                \
+      mid = lo + ( hi - lo ) / 2; last = hi - 1;                            \
+      if ( depth-- == 0 ) break;                                            \
+      if ( AFTER(b[lo], b[mid]) )   { t = b[lo]; b[lo] = b[mid]; b[mid] = t; }     \
+      if ( AFTER(b[mid], b[last]) ) { t = b[mid]; b[mid] = b[last]; b[last] = t; } \
+      if ( AFTER(b[lo], b[mid]) )   { t = b[lo]; b[lo] = b[mid]; b[mid] = t; }     \
+      t = b[mid]; b[mid] = b[last]; b[last] = t;                            \
+      for (s = lo, i = lo; i < last; i++) {                                 \
+        if ( AFTER(b[last], b[i]) ) { t = b[s]; b[s] = b[i]; b[i] = t; s++; } \
+      }                                                                     \
+      t = b[s]; b[s] = b[last]; b[last] = t;                                \
+      if ( s == cap || s + 1 == cap ) { lo = hi; break; }                   \
+      if ( cap < s ) hi = s;                                                \
+      else           lo = s + 1;                                            \
+    }                                                                       \
+    if ( hi > lo ) ca_topk_sort(f, b + lo, tmp, hi - lo);                   \
+  } while (0)
+
+#define CA_TOPK_DEFINE_BUF(NAME, T, CLASS, AFTER, ENTERS)                    \
+static void                                                                   \
+NAME (const ca_topk_fiber_t *f, ca_size_t len, ca_size_t cap,                 \
+      ca_size_t *b, ca_size_t *tmp, ca_size_t size)                           \
+{                                                                             \
+  const T *v_ = (const T *) f->v;                                             \
+  ca_size_t j, nb = 0, cut = 0, lo, hi, i, s, t, mid, last;                   \
+  int rc_ = 3, depth;                                                         \
+  T rv_;                                                                      \
+  (void) v_;                                                                  \
+  memset(&rv_, 0, sizeof(rv_));                                               \
+  for (j = 0; j < len; j++) {                                                 \
+    if ( rc_ != 3 && ! ( ENTERS(j) ) ) continue;                              \
+    b[nb++] = j;                                                              \
+    if ( nb == size ) {                                                       \
+      CA_TOPK_SELECT(AFTER);                                                  \
+      nb = cap;                                                               \
+    }                                                                         \
+    else if ( ! ( nb == cap && rc_ == 3 ) ) {    /* the first cap cells */    \
+      continue;                                                               \
+    }                                                                         \
+    cut = b[0];                                                               \
+    for (i = 1; i < cap; i++) if ( AFTER(b[i], cut) ) cut = b[i];             \
+    rc_ = CLASS(cut);                                                         \
+    if ( rc_ == 0 ) memcpy(&rv_, f->v + cut * f->bytes, sizeof(rv_));         \
+  }                                                                           \
+  if ( nb > cap ) CA_TOPK_SELECT(AFTER);                                      \
+  ca_topk_sort(f, b, tmp, cap);                                               \
+}
+
+/* The typed comparisons.  A cell enters when it comes before the cut;
+   one that ties the cut does not, it lies later. */
+#define CA_TOPK_CLASS_INT(i)   ( ( f->m && f->m[i] ) ? 2 : 0 )
+#define CA_TOPK_CLASS_FLT(i)   ( ( f->m && f->m[i] ) ? 2 : ( isnan(v_[i]) ? 1 : 0 ) )
+#define CA_TOPK_AFTER_V(CLASS, i, j)                                          \
+  ( CLASS(i) != CLASS(j) ? CLASS(i) > CLASS(j)                                \
+  : ( CLASS(i) == 0 && v_[i] != v_[j] )                                       \
+      ? ( f->desc ? v_[i] < v_[j] : v_[i] > v_[j] )                           \
+      : (i) > (j) )
+#define CA_TOPK_AFTER_INT(i, j) CA_TOPK_AFTER_V(CA_TOPK_CLASS_INT, i, j)
+#define CA_TOPK_AFTER_FLT(i, j) CA_TOPK_AFTER_V(CA_TOPK_CLASS_FLT, i, j)
+#define CA_TOPK_ENTERS_V(CLASS, j)                                            \
+  ( CLASS(j) < rc_ ||                                                         \
+    ( CLASS(j) == 0 && rc_ == 0 &&                                            \
+      ( f->desc ? v_[j] > rv_ : v_[j] < rv_ ) ) )
+#define CA_TOPK_ENTERS_INT(j) CA_TOPK_ENTERS_V(CA_TOPK_CLASS_INT, j)
+#define CA_TOPK_ENTERS_FLT(j) CA_TOPK_ENTERS_V(CA_TOPK_CLASS_FLT, j)
+
+CA_TOPK_DEFINE_BUF(ca_topk_buf_u8,  uint8_t,  CA_TOPK_CLASS_INT, CA_TOPK_AFTER_INT, CA_TOPK_ENTERS_INT)
+CA_TOPK_DEFINE_BUF(ca_topk_buf_i8,  int8_t,   CA_TOPK_CLASS_INT, CA_TOPK_AFTER_INT, CA_TOPK_ENTERS_INT)
+CA_TOPK_DEFINE_BUF(ca_topk_buf_i16, int16_t,  CA_TOPK_CLASS_INT, CA_TOPK_AFTER_INT, CA_TOPK_ENTERS_INT)
+CA_TOPK_DEFINE_BUF(ca_topk_buf_u16, uint16_t, CA_TOPK_CLASS_INT, CA_TOPK_AFTER_INT, CA_TOPK_ENTERS_INT)
+CA_TOPK_DEFINE_BUF(ca_topk_buf_i32, int32_t,  CA_TOPK_CLASS_INT, CA_TOPK_AFTER_INT, CA_TOPK_ENTERS_INT)
+CA_TOPK_DEFINE_BUF(ca_topk_buf_u32, uint32_t, CA_TOPK_CLASS_INT, CA_TOPK_AFTER_INT, CA_TOPK_ENTERS_INT)
+CA_TOPK_DEFINE_BUF(ca_topk_buf_i64, int64_t,  CA_TOPK_CLASS_INT, CA_TOPK_AFTER_INT, CA_TOPK_ENTERS_INT)
+CA_TOPK_DEFINE_BUF(ca_topk_buf_u64, uint64_t, CA_TOPK_CLASS_INT, CA_TOPK_AFTER_INT, CA_TOPK_ENTERS_INT)
+CA_TOPK_DEFINE_BUF(ca_topk_buf_f32, float,    CA_TOPK_CLASS_FLT, CA_TOPK_AFTER_FLT, CA_TOPK_ENTERS_FLT)
+CA_TOPK_DEFINE_BUF(ca_topk_buf_f64, double,   CA_TOPK_CLASS_FLT, CA_TOPK_AFTER_FLT, CA_TOPK_ENTERS_FLT)
+
+/* fixlen: the generic comparison; v_ is unused. */
+#define CA_TOPK_CLASS_GEN(i)    ca_topk_class(f, i)
+#define CA_TOPK_AFTER_GEN(i, j) ca_topk_after(f, i, j)
+#define CA_TOPK_ENTERS_GEN(j)   ( ca_topk_cmp(f, j, cut) < 0 )
+
+/* Whether cell i comes after cell j in (order, position). */
+static int
+ca_topk_after (const ca_topk_fiber_t *f, ca_size_t i, ca_size_t j)
+{
+  int r = ca_topk_cmp(f, i, j);
+  return r > 0 || ( r == 0 && i > j );
+}
+
+CA_TOPK_DEFINE_BUF(ca_topk_buf_gen, char, CA_TOPK_CLASS_GEN, CA_TOPK_AFTER_GEN, CA_TOPK_ENTERS_GEN)
+
+#undef CA_TOPK_DEFINE_BUF
+#undef CA_TOPK_SELECT
+#undef CA_TOPK_CLASS_INT
+#undef CA_TOPK_CLASS_FLT
+#undef CA_TOPK_AFTER_V
+#undef CA_TOPK_AFTER_INT
+#undef CA_TOPK_AFTER_FLT
+#undef CA_TOPK_ENTERS_V
+#undef CA_TOPK_ENTERS_INT
+#undef CA_TOPK_ENTERS_FLT
+#undef CA_TOPK_CLASS_GEN
+#undef CA_TOPK_AFTER_GEN
+#undef CA_TOPK_ENTERS_GEN
+
+/* The first cap cells of one fiber in (order, position), sorted, into
+   b[0..cap).  b and tmp hold size positions, cap < size <= len. */
+static void
+ca_topk_buf_fiber (const ca_topk_fiber_t *f, ca_size_t len, ca_size_t cap,
+                   ca_size_t *b, ca_size_t *tmp, ca_size_t size)
+{
+  switch ( f->type ) {
+  case CA_BOOLEAN:
+  case CA_UINT8:   ca_topk_buf_u8(f, len, cap, b, tmp, size);  break;
+  case CA_INT8:    ca_topk_buf_i8(f, len, cap, b, tmp, size);  break;
+  case CA_INT16:   ca_topk_buf_i16(f, len, cap, b, tmp, size); break;
+  case CA_UINT16:  ca_topk_buf_u16(f, len, cap, b, tmp, size); break;
+  case CA_INT32:   ca_topk_buf_i32(f, len, cap, b, tmp, size); break;
+  case CA_UINT32:  ca_topk_buf_u32(f, len, cap, b, tmp, size); break;
+  case CA_INT64:   ca_topk_buf_i64(f, len, cap, b, tmp, size); break;
+  case CA_UINT64:  ca_topk_buf_u64(f, len, cap, b, tmp, size); break;
+  case CA_FLOAT32: ca_topk_buf_f32(f, len, cap, b, tmp, size); break;
+  case CA_FLOAT64: ca_topk_buf_f64(f, len, cap, b, tmp, size); break;
+  default:         ca_topk_buf_gen(f, len, cap, b, tmp, size); break;
+  }
+}
+
+/* Per-axis top-k positions of `key` (an order key: not object, not
+   complex) by the buffered walk, for cap < the length of the axis.  The
+   fibers come in the row-major order of the other axes, so the answer is
+   filled with the axis last and moved into place at the end (cap cells
+   per fiber). */
+static VALUE
+ca_topk_buffered_positions (VALUE key, long cap, long axis, int desc)
+{
+  volatile VALUE holder = 0, out;
+  VALUE perm[CA_RANK_MAX];
+  ca_size_t odim[CA_RANK_MAX];
+  CArray *ck, *co;
+  ca_iter_state st;
+  ca_topk_fiber_t f;
+  ca_size_t *buf, *tmp, n, o = 0, k, len, size;
+  int64_t *op;
+  boolean8_t *m;
+  char *p;
+  int ndim, i, j = 0;
+
+  GetCArray(key, ck);
+  ndim = ck->ndim;
+  for (i = 0; i < ndim; i++) if ( i != axis ) odim[j++] = ck->dim[i];
+  odim[ndim - 1] = cap;
+  len = ck->dim[axis];
+  out = rb_carray_new(CA_INT64, ndim, odim, 0, NULL);
+  GetCArray(out, co);
+  op = (int64_t *) co->ptr;
+
+  f.type  = ck->data_type;
+  f.bytes = ck->bytes;
+  f.desc  = desc;
+  size = ( len < 4 * cap + 256 ) ? len : 4 * cap + 256;
+  buf = ALLOCV_N(ca_size_t, holder, 2 * size);
+  tmp = buf + size;
+  CA_FOR_EACH_FIBER_MASKED(st, ck, axis, 0, p, n, m) {
+    f.v = p;
+    f.m = m;
+    ca_topk_buf_fiber(&f, n, cap, buf, tmp, size);
+    for (k = 0; k < cap; k++) op[o * cap + k] = (int64_t) buf[k];
+    o++;
+  }
+  ALLOCV_END(holder);
+  if ( axis == ndim - 1 ) return out;
+  for (i = 0; i < ndim; i++) {
+    perm[i] = INT2FIX( i < axis ? i : ( i == axis ? ndim - 1 : i - 1 ) );
+  }
+  return rb_ca_copy(rb_funcallv(out, rb_intern("transpose"), ndim, perm));
+}
+
 /* Per-axis top-k positions (cap clamped, axis normalized).
  * Called by rb_ca_topk_index below. */
 static VALUE
@@ -946,6 +1153,18 @@ rb_ca_topk_positions (VALUE self, long cap, long axis_norm, int desc)
   long dim_axis = (long) ca->dim[axis_norm];
   VALUE raxis_norm = LONG2NUM(axis_norm);
 
+  /* The buffered walk reads any key but an object (its cells compare in
+     Ruby) or a complex one (no order), and keeps cap cells per fiber. */
+  if ( ca->data_type != CA_OBJECT && ! ca_is_complex_type(ca) ) {
+    VALUE key = ca_order_key(self, desc ? "nlargest" : "nsmallest");
+    CArray *ck;
+    GetCArray(key, ck);
+    if ( ck->data_type != CA_OBJECT && ! ca_is_complex_type(ck) &&
+         cap < dim_axis ) {
+      return ca_topk_buffered_positions(key, cap, axis_norm, desc);
+    }
+  }
+
   /* The largest: reversing the ascending order would put the NaN and the
      masked cells first, so rank them descending (NaN, then the masked
      cells, last) when there are any.  An object array is ranked by

data/ext/carray_random.c

@@ -165,7 +165,7 @@ ca_random_bang_fill (VALUE arg)
   ca_rng_bind(&c->source);
   switch (ca->data_type) {
   case CA_FLOAT64: {
-    double *p = (double *)ca->ptr;
+    CA_U(double) *p = (CA_U(double) *)ca->ptr;
     if (is_default) {
       for (i = 0; i < n; i++)
         p[i] = ca_random_real(&c->source);
@@ -177,7 +177,7 @@ ca_random_bang_fill (VALUE arg)
     break;
   }
   case CA_FLOAT32: {
-    float *p = (float *)ca->ptr;
+    CA_U(float) *p = (CA_U(float) *)ca->ptr;
     if (is_default) {
       for (i = 0; i < n; i++)
         p[i] = (float)ca_random_real(&c->source);
@@ -189,7 +189,7 @@ ca_random_bang_fill (VALUE arg)
     break;
   }
   case CA_CMPLX128: {
-    double complex *p = (double complex *)ca->ptr;
+    ca_u_cmplx128_t *p = (ca_u_cmplx128_t *)ca->ptr;
     if (is_default) {
       for (i = 0; i < n; i++)
         p[i] = ca_random_real(&c->source) + ca_random_real(&c->source) * I;
@@ -202,7 +202,7 @@ ca_random_bang_fill (VALUE arg)
     break;
   }
   case CA_CMPLX64: {
-    float complex *p = (float complex *)ca->ptr;
+    ca_u_cmplx64_t *p = (ca_u_cmplx64_t *)ca->ptr;
     if (is_default) {
       for (i = 0; i < n; i++)
         p[i] = (float)ca_random_real(&c->source) + (float)ca_random_real(&c->source) * I;
@@ -242,37 +242,37 @@ ca_random_bang_fill (VALUE arg)
       break;
     }
     case CA_INT16: {
-      int16_t *p = (int16_t *)ca->ptr;
+      CA_U(int16_t) *p = (CA_U(int16_t) *)ca->ptr;
       for (i = 0; i < n; i++)
         p[i] = (int16_t)(low_long + ca_random_ulong_limited(&c->source, limit));
       break;
     }
     case CA_UINT16: {
-      uint16_t *p = (uint16_t *)ca->ptr;
+      CA_U(uint16_t) *p = (CA_U(uint16_t) *)ca->ptr;
       for (i = 0; i < n; i++)
         p[i] = (uint16_t)(low_long + ca_random_ulong_limited(&c->source, limit));
       break;
     }
     case CA_INT32: {
-      int32_t *p = (int32_t *)ca->ptr;
+      CA_U(int32_t) *p = (CA_U(int32_t) *)ca->ptr;
       for (i = 0; i < n; i++)
         p[i] = (int32_t)(low_long + ca_random_ulong_limited(&c->source, limit));
       break;
     }
     case CA_UINT32: {
-      uint32_t *p = (uint32_t *)ca->ptr;
+      CA_U(uint32_t) *p = (CA_U(uint32_t) *)ca->ptr;
       for (i = 0; i < n; i++)
         p[i] = (uint32_t)(low_long + ca_random_ulong_limited(&c->source, limit));
       break;
     }
     case CA_INT64: {
-      int64_t *p = (int64_t *)ca->ptr;
+      CA_U(int64_t) *p = (CA_U(int64_t) *)ca->ptr;
       for (i = 0; i < n; i++)
         p[i] = (int64_t)(low_long + ca_random_ulong_limited(&c->source, limit));
       break;
     }
     case CA_UINT64: {
-      uint64_t *p = (uint64_t *)ca->ptr;
+      CA_U(uint64_t) *p = (CA_U(uint64_t) *)ca->ptr;
       for (i = 0; i < n; i++)
         p[i] = (uint64_t)(low_long + ca_random_ulong_limited(&c->source, limit));
       break;
@@ -483,19 +483,19 @@ ca_randomn_bang_fill (VALUE arg)
   if (c->source.kind == CA_RNG_OWN) {
     switch (ca->data_type) {
     case CA_FLOAT64: {
-      double *p = (double *)ca->ptr;
+      CA_U(double) *p = (CA_U(double) *)ca->ptr;
       for (i = 0; i < n; i++)
         p[i] = ca_random_normal(&c->source);
       break;
     }
     case CA_FLOAT32: {
-      float *p = (float *)ca->ptr;
+      CA_U(float) *p = (CA_U(float) *)ca->ptr;
       for (i = 0; i < n; i++)
         p[i] = (float) ca_random_normal(&c->source);
       break;
     }
     case CA_CMPLX128: {
-      double complex *p = (double complex *)ca->ptr;
+      ca_u_cmplx128_t *p = (ca_u_cmplx128_t *)ca->ptr;
       for (i = 0; i < n; i++) {
         /* Into locals first: C does not say which order a call's
            arguments are evaluated in, and these two advance a state. */
@@ -506,7 +506,7 @@ ca_randomn_bang_fill (VALUE arg)
       break;
     }
     case CA_CMPLX64: {
-      float complex *p = (float complex *)ca->ptr;
+      ca_u_cmplx64_t *p = (ca_u_cmplx64_t *)ca->ptr;
       for (i = 0; i < n; i++) {
         double re = ca_random_normal(&c->source);
         double im = ca_random_normal(&c->source);
@@ -522,7 +522,7 @@ ca_randomn_bang_fill (VALUE arg)
 
   switch (ca->data_type) {
   case CA_FLOAT64: {
-    double *p = (double *)ca->ptr;
+    CA_U(double) *p = (CA_U(double) *)ca->ptr;
     ca_size_t pairs = n / 2;
     for (i = 0; i < pairs; i++) {
       box_muller_pair(&c->source, &p[2*i], &p[2*i+1]);
@@ -535,7 +535,7 @@ ca_randomn_bang_fill (VALUE arg)
     break;
   }
   case CA_FLOAT32: {
-    float *p = (float *)ca->ptr;
+    CA_U(float) *p = (CA_U(float) *)ca->ptr;
     ca_size_t pairs = n / 2;
     for (i = 0; i < pairs; i++) {
       double r1, r2;
@@ -551,7 +551,7 @@ ca_randomn_bang_fill (VALUE arg)
     break;
   }
   case CA_CMPLX128: {
-    double complex *p = (double complex *)ca->ptr;
+    ca_u_cmplx128_t *p = (ca_u_cmplx128_t *)ca->ptr;
     for (i = 0; i < n; i++) {
       double r1, r2;
       box_muller_pair(&c->source, &r1, &r2);
@@ -560,7 +560,7 @@ ca_randomn_bang_fill (VALUE arg)
     break;
   }
   case CA_CMPLX64: {
-    float complex *p = (float complex *)ca->ptr;
+    ca_u_cmplx64_t *p = (ca_u_cmplx64_t *)ca->ptr;
     for (i = 0; i < n; i++) {
       double r1, r2;
       box_muller_pair(&c->source, &r1, &r2);

data/ext/carray_scatter.c

@@ -13,7 +13,8 @@
                min / max: real numeric only (complex has no order)
                (boolean / object / fixlen → CADataTypeError; the bang
                cannot widen self, same rationale as fma! / fms!)
-               replace: numeric or boolean (assignment, no widening)
+               replace: any type (assignment, no widening); an object or
+               fixlen array is written through the indexer
     scalar     any Numeric, true / false, or UNDEF; converted to self's
                type as the indexer's store converts it (a value that does
                not fit raises, as `self[i] = v` does)
@@ -63,7 +64,7 @@ typedef union {
 #define LOOP_SCALAR(T, APPLY) LOOP_SCALAR_V(T, APPLY, SCALAR_REAL(T))
 
 #define LOOP_SCALAR_V(T, APPLY, VS) do { \
-  T *q = (T *) qbase; \
+  CA_U(T) *q = (CA_U(T) *) qbase; \
   T  vs = VS; \
   if ( mself ) { \
     for (i = 0; i < n; i++) { \
@@ -85,8 +86,8 @@ typedef union {
 } while (0)
 
 #define LOOP_VEC(T, APPLY) do { \
-  T *q = (T *) qbase; \
-  T *r = (T *) cv->ptr; \
+  CA_U(T) *q = (CA_U(T) *) qbase; \
+  CA_U(T) *r = (CA_U(T) *) cv->ptr; \
   if ( mself ) { \
     for (i = 0; i < n; i++) { \
       if ( maddrs && maddrs[i] ) continue; \
@@ -120,7 +121,7 @@ typedef union {
 #define LOOP_SCALAR_REPLACE(T) LOOP_SCALAR_REPLACE_V(T, SCALAR_REAL(T))
 
 #define LOOP_SCALAR_REPLACE_V(T, VS) do { \
-  T *q = (T *) qbase; \
+  CA_U(T) *q = (CA_U(T) *) qbase; \
   T  vs = VS; \
   for (i = 0; i < n; i++) { \
     if ( maddrs && maddrs[i] ) continue; \
@@ -136,8 +137,8 @@ typedef union {
 } while (0)
 
 #define LOOP_VEC_REPLACE(T) do { \
-  T *q = (T *) qbase; \
-  T *r = (T *) cv->ptr; \
+  CA_U(T) *q = (CA_U(T) *) qbase; \
+  CA_U(T) *r = (CA_U(T) *) cv->ptr; \
   for (i = 0; i < n; i++) { \
     if ( maddrs && maddrs[i] ) continue; \
     addr = p[i]; \
@@ -592,6 +593,22 @@ AT_BODY(ca_scatter_replace_body, DISPATCH_NUMERIC_REPLACE())
 static VALUE
 rb_ca_scatter_replace_bang (VALUE self, VALUE raddrs, VALUE rvals)
 {
+  /* An object or fixlen array takes the assignment through the indexer,
+     which reads and writes its cells by their own rules (a VALUE kept
+     visible to the GC, a fixlen value fitted to the cell); the kernel
+     below is for the numeric and boolean cells. */
+  {
+    CArray *cs;
+    TypedData_Get_Struct(self, CArray, &carray_data_type, cs);
+    if ( cs->data_type == CA_OBJECT || cs->data_type == CA_FIXLEN ) {
+      rb_ca_modify(self);
+      if ( RB_TYPE_P(raddrs, T_ARRAY) ) {     /* a list of addresses */
+        raddrs = rb_ca_wrap_readonly(raddrs, INT2NUM(CA_SIZE));
+      }
+      rb_funcall(rb_ca_flatten(self), rb_intern("[]="), 2, raddrs, rvals);
+      return self;
+    }
+  }
   /* Pre-scan: if vals is a masked CArray and self isn't yet masked,
      promote self so the kernel can flip target cells to masked (indexer
      `self[addrs] = vals` establishes self.mask lazily the same way). */

data/ext/carray_slab.c

@@ -346,6 +346,26 @@ ca_slab_build_output_view (int8_t data_type, ca_size_t bytes,
   return TypedData_Wrap_Struct(rb_cCAWrap, &cawrap_data_type, cw);
 }
 
+/* The array the slab views move onto when the walk ends (see
+   slab_state_release_views), made with the carrier and held by it.  It is
+   made here rather than at the end: the end runs in an ensure, after the
+   block, and an allocation failing there would leave the walk open and
+   the views pointing into freed scratch. */
+static void
+ca_slab_prepare_backing (ca_slab_iter_state_t *st)
+{
+  CArray *cw, *backing;
+  volatile VALUE bv;
+  TypedData_Get_Struct(st->carrier, CArray, &carray_data_type, cw);
+  bv = rb_carray_new(cw->data_type, cw->ndim, cw->dim, cw->bytes, NULL);
+  TypedData_Get_Struct(bv, CArray, &carray_data_type, backing);
+  if ( cw->mask ) {
+    ca_create_mask(backing);
+  }
+  rb_ivar_set(st->carrier, rb_intern("__slab_backing__"), bv);
+  RB_GC_GUARD(bv);
+}
+
 /* Common setup of the input slab view for all 4 forms.  Decides ALIAS
    vs SCRATCH from T1's slab_strides[0] vs src->bytes equality, builds
    the slab_view + (when SCRATCH) carrier in place.  The mask travels
@@ -465,6 +485,10 @@ ca_slab_setup_input_slab_view (ca_slab_iter_state_t *st, CArray *src,
     }
   }
 
+  if ( st->carrier != Qnil ) {
+    ca_slab_prepare_backing(st);
+  }
+
   /* The slab is a window onto the source when the fiber is contiguous and
      a copy in the iterator's scratch when it is not, so writing through it
      landed on one axis and vanished on the next.  Nothing in the surface
@@ -861,7 +885,6 @@ ca_slab_reduce_setup (ca_slab_iter_state_t *st, CArray **out_src,
                       ca_size_t *out_n)
 {
   CArray *src;
-  CArray *out;
   ca_size_t fiber_len;
   ca_size_t out_dim[CA_RANK_MAX];
   int8_t out_ndim;
@@ -904,7 +927,6 @@ ca_slab_reduce_setup (ca_slab_iter_state_t *st, CArray **out_src,
 
   st->output = rb_carray_new(st->out_data_type, out_ndim, out_dim,
                              st->out_bytes, NULL);
-  TypedData_Get_Struct(st->output, CArray, &carray_data_type, out);
 
   /* FIBER_CONTIG is naxes==1 only (T1 substrate contract).  Multi-axis
      omits the flag and uses bare CA_SLAB_AXES; T1 picks an in-src
@@ -1178,8 +1200,9 @@ slab_state_run_body (VALUE arg)
    as it has a ptr.  Before the scratch they point into is freed, the
    input slab and its carrier are moved onto a copy of the last slab,
    held by the carrier, and the internal output view lets go of its
-   buffer.  A slab that is a window onto the source itself points into
-   the source and needs nothing. */
+   buffer.  The copy is made into the array ca_slab_prepare_backing set
+   aside, so nothing here allocates.  A slab that is a window onto the
+   source itself points into the source and needs nothing. */
 static void
 slab_state_release_views (ca_slab_iter_state_t *st)
 {
@@ -1196,12 +1219,12 @@ slab_state_release_views (ca_slab_iter_state_t *st)
     if ( cw->ptr == NULL ) {
       return;
     }
-    backing = ca_copy(cw);
-    bv = ca_wrap_struct(backing);
-    if ( cw->mask && ! backing->mask ) {
-      ca_create_mask(backing);
+    bv = rb_ivar_get(st->carrier, rb_intern("__slab_backing__"));
+    TypedData_Get_Struct(bv, CArray, &carray_data_type, backing);
+    memcpy(backing->ptr, cw->ptr, (size_t) (cw->elements * cw->bytes));
+    if ( cw->mask && cw->mask->ptr ) {
+      memcpy(backing->mask->ptr, cw->mask->ptr, (size_t) cw->elements);
     }
-    rb_ivar_set(st->carrier, rb_intern("__slab_backing__"), bv);
     if ( cs->ptr ) {
       cs->ptr = backing->ptr;
     }