carray 3.0.4 → 3.0.5

data/ext/ca_obj_monop.c

@@ -370,12 +370,19 @@ apply_monop_in_place (uint16_t op_id, int8_t cur_dt,
   fn(slab_n, mask, (char *) data, 1, (char *) data, 1);
 }
 
-/* Minimal CArray-shaped stub used as ca_cast_block's data_type-only carrier.
-   ca_cast_block only reads data_type to index into ca_cast_func_table.  */
-typedef struct {
-  int16_t obj_type;
-  int8_t  data_type;
-} ca_data_type_stub_t;
+/* A zeroed CArray carrying only data_type and bytes, handed to
+   ca_cast_block in place of a real array.  It is a whole CArray, not a
+   shorter struct cast to one: ca_cast_block reads data_type through a
+   CArray pointer, and a fixlen cast reads bytes as well.  */
+static CArray
+ca_data_type_stub (int8_t data_type)
+{
+  CArray stub;
+  memset(&stub, 0, sizeof(stub));
+  stub.data_type = data_type;
+  stub.bytes     = ca_sizeof[data_type];
+  return stub;
+}
 
 /* Pull leaf into the output buffer.  Three paths:
 
@@ -428,8 +435,8 @@ pull_leaf_with_optional_cast (CArray *leaf, uint16_t innermost_op,
   if ( has_cast_at_leaf ) {
     /* Path 2: cast scratch → data with output layout in target data_type.  */
     int8_t target_dt = (int8_t)(innermost_op - CA_MONOP_CAST_BASE);
-    ca_data_type_stub_t src_stub = { 0, leaf->data_type };
-    ca_data_type_stub_t dst_stub = { 0, target_dt };
+    CArray src_stub = ca_data_type_stub(leaf->data_type);
+    CArray dst_stub = ca_data_type_stub(target_dt);
     ca_cast_block(slab_n, &src_stub, scratch, &dst_stub, data);
     result_dt = target_dt;
   } else {
@@ -555,6 +562,30 @@ ca_monop_eval (CAMonOp *mo, const ca_lazy_req_t *req, void *data, int dir)
     chain_apply_count = chain_len - 1;
   }
 
+  /* The chain runs in place, so the buffer must hold slab_n cells of the
+     widest type along it: the leaf, or a step that widens before a later
+     one narrows (cmplx128.lazy.abs pulls 16-byte cells and answers 8-byte
+     ones).  When that is wider than the output, run in a scratch and copy
+     the answer into `data` at the end. */
+  void   *out  = data;
+  void   *work = NULL;
+  {
+    ca_size_t max_bytes = leaf->bytes;
+    int8_t    dt        = leaf->data_type;
+    for ( i = chain_len - 1; i >= 0; i-- ) {
+      dt = ca_monop_is_cast(op_chain[i])
+             ? (int8_t)(op_chain[i] - CA_MONOP_CAST_BASE)
+             : ca_lazy_promote_monop(op_chain[i], dt);
+      if ( ca_sizeof[dt] > max_bytes ) max_bytes = ca_sizeof[dt];
+    }
+    if ( max_bytes > mo->bytes ) {
+      work = ( leaf->data_type == CA_OBJECT )
+               ? ca_lazy_arena_acquire_object((slab_n * max_bytes + sizeof(VALUE) - 1) / sizeof(VALUE))
+               : ca_lazy_arena_acquire(slab_n * max_bytes);
+      data = work;
+    }
+  }
+
   /* === 2. pull leaf into output buffer (with optional cast) === */
   cur_dt = pull_leaf_with_optional_cast(
     leaf,
@@ -576,8 +607,8 @@ ca_monop_eval (CAMonOp *mo, const ca_lazy_req_t *req, void *data, int dir)
       ca_size_t src_bytes = ca_sizeof[cur_dt];
       ca_size_t total_bytes = slab_n * src_bytes;
       void *scratch;
-      ca_data_type_stub_t src_stub = { 0, cur_dt };
-      ca_data_type_stub_t dst_stub = { 0, target_dt };
+      CArray src_stub = ca_data_type_stub(cur_dt);
+      CArray dst_stub = ca_data_type_stub(target_dt);
 
       /* Copy current data → scratch (in src data_type), then cast scratch
          → data (in target data_type).  Required because in-place cast
@@ -604,6 +635,10 @@ ca_monop_eval (CAMonOp *mo, const ca_lazy_req_t *req, void *data, int dir)
   if ( slab_mask ) {
     ca_lazy_arena_release(slab_mask);
   }
+  if ( work ) {
+    memcpy(out, work, slab_n * mo->bytes);
+    ca_lazy_arena_release(work);
+  }
 }
 
 static void
@@ -1116,6 +1151,7 @@ Init_ca_obj_monop (void)
   rb_define_const(rb_cCAMonOp, "OP_RAD_PI",  INT2NUM(CA_MONOP_RAD_PI));
   rb_define_const(rb_cCAMonOp, "OP_SIGN",    INT2NUM(CA_MONOP_SIGN));
   rb_define_const(rb_cCAMonOp, "OP_ARG_I",   INT2NUM(CA_MONOP_ARG_I));
+  rb_define_const(rb_cCAMonOp, "OP_BYTE_SWAP", INT2NUM(CA_MONOP_BYTE_SWAP));
   rb_define_const(rb_cCAMonOp, "CAST_BASE",  INT2NUM(CA_MONOP_CAST_BASE));
 
   rb_define_alloc_func(rb_cCAMonOp, rb_ca_monop_s_allocate);

data/ext/ca_obj_object.c

@@ -171,18 +171,66 @@ ca_object_empty_wrap (CArray *w)
   }
 }
 
+/* Moves the cells of a wrap (or of its lent mask, `w`) into an array of
+   their own, held by `holder` under `name`, and points `w` at them.  The
+   cells are those the hook left in the caller's buffer. */
+static void
+ca_object_keep_cells (VALUE holder, const char *name, CArray *w)
+{
+  volatile VALUE cells;
+  CArray *c;
+  cells = rb_carray_new(w->data_type, w->ndim, w->dim, w->bytes, NULL);
+  c = (CArray *) DATA_PTR(cells);
+  memcpy(c->ptr, w->ptr, (size_t) w->elements * w->bytes);
+  rb_ivar_set(holder, rb_intern(name), cells);
+  w->ptr = c->ptr;
+}
+
+/* Takes the caller's buffer back from a wrap the hook was lent, together
+   with `lent_mask`, the wrap of the data's mask bits it was lent with (or
+   NULL).  When the hook took a view of either, the view outlives the call,
+   so both keep their cells; otherwise both are left with none.  A mask the
+   hook made on the wrap is the wrap's own, with cells of its own. */
+static void
+ca_object_take_back (VALUE wrap, CArray *lent_mask)
+{
+  CArray *w = (CArray *) DATA_PTR(wrap);
+  CArray *m = ( lent_mask != NULL && w->mask == lent_mask ) ? lent_mask : NULL;
+  int viewed = ca_test_flag(w, CA_FLAG_LENT_VIEWED) ||
+               ( m != NULL && ca_test_flag(m, CA_FLAG_LENT_VIEWED) );
+  ca_unset_flag(w, CA_FLAG_LENT | CA_FLAG_LENT_VIEWED);
+  if ( lent_mask != NULL ) {
+    ca_unset_flag(lent_mask, CA_FLAG_LENT | CA_FLAG_LENT_VIEWED);
+  }
+  if ( viewed ) {
+    ca_object_keep_cells(wrap, "kept_cells", w);
+    if ( m != NULL ) {
+      ca_object_keep_cells(wrap, "kept_mask_cells", m);
+    }
+  }
+  else {
+    if ( m != NULL ) {
+      ca_object_empty_wrap(m);
+    }
+    ca_object_empty_wrap(w);
+  }
+}
+
 /* Calls copy_data / sync_data with a wrap of a caller's buffer, shaped as
-   the object, and takes the buffer back however the call leaves.  The wrap
-   shares the object's mask (the data's), and whatever mask it holds after
-   the call becomes the data's: a hook that writes masked values masks the
-   object's cells.  The data points at the buffer for the duration too, for
-   a hook that reads the object back while it runs. */
+   the object, and takes the buffer back however the call leaves.  When the
+   data has a mask, the wrap's mask is a wrap of its bits: a hook that writes
+   masked values masks the object's cells, and the data keeps its mask
+   whatever the hook does with the wrap's.  A mask the hook makes on a wrap
+   that had none is the wrap's own and goes with it.  The data points at the
+   buffer for the duration too, for a hook that reads the object back while
+   it runs. */
 
 typedef struct {
   CAObject *ca;
   char     *saved;
   ID        mid;
   VALUE     wrap;
+  CArray   *mask;      /* the wrap of the data's mask bits, or NULL */
 } ca_object_lend_t;
 
 static VALUE
@@ -196,11 +244,8 @@ static VALUE
 ca_object_lend_restore (VALUE varg)
 {
   ca_object_lend_t *l = (ca_object_lend_t *) varg;
-  CArray *w = (CArray *) DATA_PTR(l->wrap);
-  l->ca->data->mask = w->mask;
-  w->mask = NULL;
-  ca_object_empty_wrap(w);
   l->ca->data->ptr = l->saved;
+  ca_object_take_back(l->wrap, l->mask);
   return Qnil;
 }
 
@@ -213,7 +258,14 @@ ca_object_call_lending (CAObject *ca, void *ptr, const char *mid)
   w = ca_wrap_new(data->data_type, data->ndim, data->dim, data->bytes,
                   NULL, (char *) ptr);
   l.wrap  = ca_wrap_struct(w);
-  w->mask = data->mask;
+  l.mask  = NULL;
+  if ( data->mask != NULL ) {
+    l.mask = (CArray *) ca_wrap_new(CA_BOOLEAN, data->ndim, data->dim, 0,
+                                    NULL, data->mask->ptr);
+    ca_set_flag(l.mask, CA_FLAG_LENT);
+    w->mask = l.mask;
+  }
+  ca_set_flag(w, CA_FLAG_LENT);
   l.ca    = ca;
   l.saved = data->ptr;
   l.mid   = rb_intern(mid);
@@ -253,7 +305,7 @@ ca_object_hook_release (VALUE varg)
   ca_object_hook_t *h = (ca_object_hook_t *) varg;
   int i;
   for ( i = 0; i < h->ntrans; i++ ) {
-    ca_object_empty_wrap((CArray *) DATA_PTR(h->trans[i]));
+    ca_object_take_back(h->trans[i], NULL);
   }
   return Qnil;
 }
@@ -742,7 +794,6 @@ ca_object_setup (CAObject *ca,
                int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes)
 {
   ca_size_t elements;
-  int8_t i;
 
   /* check arguments */
 
@@ -1194,6 +1245,7 @@ ca_object_wrap_transient (int8_t data_type, ca_size_t bytes,
   }
 
   wrap = ca_wrap_new(data_type, ndim, dim, bytes, NULL, (char *) data);
+  ca_set_flag(wrap, CA_FLAG_LENT);
   return ca_wrap_struct(wrap);
 }
 

data/ext/ca_obj_record.c

@@ -309,6 +309,9 @@ rb_ca_record_s_wrap (int argc, VALUE *argv, VALUE klass)
     rb_scan_args(argc, argv, "2", &entity_val, &data_class);
   }
   rb_check_carray_object(entity_val);
+  /* A record array (or another Face) is wrapped from its storage, so the
+     new record is not a Face over a Face. */
+  entity_val = rb_ca_strip_face_value(entity_val);
   return ca_record_build(klass, data_class, entity_val);
 }
 

data/ext/ca_obj_reduce.c

@@ -56,6 +56,10 @@ ca_reduce_setup (CAReduce *ca, CArray *parent, ca_size_t count, ca_size_t offset
              "[BUG] CAReduce can't inherit other than boolean array");
   }
 
+  if ( count <= 0 ) {
+    rb_raise(rb_eArgError, "CAReduce: count should be positive");
+  }
+
   /* ca == NULL asks for the checks above only, so that a constructor can
      run them before it allocates. */
   if ( ca == NULL ) {

data/ext/ca_obj_refer.c

@@ -145,7 +145,9 @@ ca_refer_setup (CARefer *ca, CArray *parent,
   ca_stride_setup_view((CAStride *) ca, CA_OBJ_REFER, parent,
                        data_type, bytes, ndim, dim, strides, base_offset);
 
-  if (ca_is_scalar(parent)) {
+  /* A refer of a scalar stays one only while it has the one cell: read as
+     narrower elements it is an array of several. */
+  if (ca_is_scalar(parent) && ca->elements == 1) {
     ca_set_flag(ca, CA_FLAG_SCALAR);
   }
   return 0;
@@ -211,16 +213,20 @@ ca_refer_func_create_mask (void *ap)
   else if (ca->bytes < parent_bytes) {
     /* Divided reinterpret: one parent element splits into
        ratio = parent_bytes / bytes view elements.  Build a
-       CARepeat that broadcasts each parent mask bit across the
-       ratio sub-positions, then refer-reshape it to the view's
-       actual shape. */
+       repeat of two axes, (parent elements, ratio), that broadcasts
+       each parent mask bit across the ratio sub-positions, then
+       refer-reshape it to the view's actual shape.  Two axes whatever
+       the parent's rank, so a parent at CA_RANK_MAX needs no extra
+       one. */
     ca_size_t ratio = parent_bytes / ca->bytes;
-    ca_size_t count[CA_RANK_MAX];
-    int8_t i;
-    for (i = 0; i < ca->parent->ndim; i++) count[i] = 0;
-    count[ca->parent->ndim] = ratio;
+    ca_size_t mdim[2], mstrides[2];
+    mdim[0]     = ca->parent->elements;
+    mdim[1]     = ratio;
+    mstrides[0] = 1;
+    mstrides[1] = 0;
     ca->mask0 =
-      (CArray *) ca_repeat_new(ca->parent->mask, ca->parent->ndim + 1, count);
+      (CArray *) ca_stride_new(CA_OBJ_REPEAT, ca->parent->mask, CA_BOOLEAN, 1,
+                               2, mdim, mstrides, 0);
     ca_unset_flag(ca->mask0, CA_FLAG_READ_ONLY);
     /* mask0 has ratio cells per parent element, so the offset is counted
        in those. */
@@ -619,6 +625,9 @@ rb_ca_reshape (int argc, VALUE *argv, VALUE self)
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
+  if ( argc == 0 ) {
+    rb_raise(rb_eArgError, "reshape: give at least one axis");
+  }
   ca_check_rank_fits(argc, "reshape");
 
   /* Locate the (at most one) auto-infer placeholder.  `-1` is the

data/ext/ca_obj_roll.c

@@ -112,6 +112,8 @@ ca_roll_setup (CARoll *ca, CArray *parent, ca_size_t *shift)
   ca->parent    = parent;
   ca->attach    = 0;
   ca->nosync    = 0;
+  ca->reps      = NULL;               /* set before either allocation can raise */
+  ca->dim       = NULL;
   ca->reps      = ALLOC_N(ca_size_t, ndim);  /* repurposed as shift[] */
   ca->dim       = ALLOC_N(ca_size_t, ndim);
 
@@ -130,15 +132,33 @@ ca_roll_setup (CARoll *ca, CArray *parent, ca_size_t *shift)
   return 0;
 }
 
+typedef struct {
+  CARoll    *ca;
+  CArray    *parent;
+  ca_size_t *shift;
+} ca_roll_new_arg;
+
+static VALUE
+ca_roll_new_setup (VALUE varg)
+{
+  ca_roll_new_arg *a = (ca_roll_new_arg *) varg;
+  ca_roll_setup(a->ca, a->parent, a->shift);
+  return Qnil;
+}
+
+/* The setup allocates reps and dim after the struct: when either fails,
+   the struct goes too. */
 CARoll *
 ca_roll_new (CArray *parent, ca_size_t *shift)
 {
-  CARoll *ca;
+  ca_roll_new_arg a;
   ca_roll_setup(NULL, parent, shift);
-  ca = ALLOC(CARoll);
-  ca_roll_setup(ca, parent, shift);
-  ca_fill_or_free((CArray *) ca, ca_view_inherit_mask, (VALUE) ca);
-  return ca;
+  a.ca     = ALLOC(CARoll);
+  a.parent = parent;
+  a.shift = shift;
+  ca_fill_or_free((CArray *) a.ca, ca_roll_new_setup, (VALUE) &a);
+  ca_fill_or_free((CArray *) a.ca, ca_view_inherit_mask, (VALUE) a.ca);
+  return a.ca;
 }
 
 static void
@@ -629,7 +649,7 @@ rb_ca_roll (int argc, VALUE *argv, VALUE self)
   }
   for ( i = 0; i < ca->ndim; i++ ) {
     if ( i < argc ) {
-      shift[i] = NUM2SIZE(argv[i]);
+      shift[i] = ca_integer_arg(argv[i], "a shift", NULL);
     } else {
       shift[i] = 0;
     }

data/ext/ca_obj_select.c

@@ -130,7 +130,8 @@ ca_select_snapshot (CArray *select)
 
 /* Set up the view over `parent` from an owned selector snapshot (see
    ca_select_snapshot) and pre-compute ca->indices (TRUE positions in flat
-   parent order).  Does not raise. */
+   parent order).  Raises only when the indices cannot be allocated, after
+   every field free_ca_select reads is set. */
 static int
 ca_select_setup (CASelect *ca, CArray *parent, CArray *snapshot)
 {
@@ -211,14 +212,42 @@ ca_select_setup (CASelect *ca, CArray *parent, CArray *snapshot)
   return 0;
 }
 
+typedef struct {
+  CASelect *ca;
+  CArray   *parent;
+  CArray   *snapshot;
+} ca_select_new_arg;
+
+static VALUE
+ca_select_new_alloc (VALUE varg)
+{
+  ca_select_new_arg *a = (ca_select_new_arg *) varg;
+  a->ca = ALLOC(CASelect);
+  return Qnil;
+}
+
+static VALUE
+ca_select_new_setup (VALUE varg)
+{
+  ca_select_new_arg *a = (ca_select_new_arg *) varg;
+  ca_select_setup(a->ca, a->parent, a->snapshot);
+  return Qnil;
+}
+
+/* The struct and the indices are allocated after the snapshot.  When the
+   struct cannot be allocated the snapshot goes; when the indices cannot,
+   the struct goes and takes the snapshot with it (the setup stores the
+   snapshot before it allocates the indices). */
 CArray *
 ca_select_new (CArray *parent, CArray *select)
 {
-  CArray *snapshot = ca_select_snapshot(select);
+  ca_select_new_arg a;
+  a.parent   = parent;
+  a.snapshot = ca_select_snapshot(select);
   /* check: the setup checks nothing */
-  CASelect *ca = ALLOC(CASelect);
-  ca_select_setup(ca, parent, snapshot);
-  return (CArray*) ca;
+  ca_fill_or_free(a.snapshot, ca_select_new_alloc, (VALUE) &a);
+  ca_fill_or_free((CArray *) a.ca, ca_select_new_setup, (VALUE) &a);
+  return (CArray*) a.ca;
 }
 
 /* Alias for source compatibility.  Both constructors produce a

data/ext/ca_obj_shift.c

@@ -120,16 +120,40 @@ ca_shift_setup (CAShift *ca, CArray *parent,
   return 0;
 }
 
+typedef struct {
+  CAShift   *ca;
+  CArray    *parent;
+  ca_size_t *shift;
+  char      *fill;
+  int8_t    *roll;
+  int        fill_mask;
+} ca_shift_new_arg;
+
+static VALUE
+ca_shift_new_setup (VALUE varg)
+{
+  ca_shift_new_arg *a = (ca_shift_new_arg *) varg;
+  ca_shift_setup(a->ca, a->parent, a->shift, a->fill, a->roll, a->fill_mask);
+  return Qnil;
+}
+
+/* The setup allocates the fill value after the struct and its pool: when
+   that fails, the struct goes too. */
 CAShift *
 ca_shift_new (CArray *parent, ca_size_t *shift, char *fill, int8_t *roll,
               int fill_mask)
 {
-  CAShift *ca;
+  ca_shift_new_arg a;
   ca_shift_setup(NULL, parent, shift, fill, roll, fill_mask);
-  ca = (CAShift *) ca_array_alloc(CA_OBJ_SHIFT, parent->ndim);
-  ca_shift_setup(ca, parent, shift, fill, roll, fill_mask);
-  ca_fill_or_free((CArray *) ca, ca_window_create_bounds_mask, (VALUE) ca);
-  return ca;
+  a.ca        = (CAShift *) ca_array_alloc(CA_OBJ_SHIFT, parent->ndim);
+  a.parent    = parent;
+  a.shift     = shift;
+  a.fill      = fill;
+  a.roll      = roll;
+  a.fill_mask = fill_mask;
+  ca_fill_or_free((CArray *) a.ca, ca_shift_new_setup, (VALUE) &a);
+  ca_fill_or_free((CArray *) a.ca, ca_window_create_bounds_mask, (VALUE) a.ca);
+  return a.ca;
 }
 
 /* Clone: produce a CAShift (not CAWindow) by rebuilding via setup.
@@ -216,7 +240,7 @@ rb_ca_shift (int argc, VALUE *argv, VALUE self)
   }
 
   for (i=0; i<ca->ndim; i++) {
-    shift[i] = NUM2SIZE(argv[i]);
+    shift[i] = ca_integer_arg(argv[i], "a shift", NULL);
   }
 
   if ( rb_block_given_p() ) {
@@ -264,7 +288,7 @@ rb_ca_shift (int argc, VALUE *argv, VALUE self)
     }
 
     for (i=0; i<ca->ndim; i++) {
-      roll[i] = NUM2INT(rb_ary_entry(rroll, i));
+      roll[i] = ca_integer_arg(rb_ary_entry(rroll, i), "a shift", NULL);
     }
   }
 

data/ext/ca_obj_stack.c

@@ -970,6 +970,7 @@ ca_stack_func_fold_stride (void *ap, ca_fold_t *f, void **next_parent)
      correct (if non-folded) per-parent dispatch. */
   if ( ca->k_axis != 0 ) return 0;
   if ( ! ca_fast_paths_enabled() ) return 0;
+  if ( pbt == 0 ) return 0;                         /* empty parents: no parent holds the box */
 
   for ( i = 0; i < f->ndim; i++ ) {
     ca_size_t span = (f->counts[i] - 1) * f->strides[i];

data/ext/ca_obj_stride.c

@@ -247,6 +247,10 @@ ca_stride_compose_through (CAStride *leaf, CAStride *parent,
   for (k = parent->ndim - 1; k >= 0; k--)
     prod[k] = prod[k + 1] * parent->dim[k];
 
+  /* A parent with a zero-length axis has no cell for the leaf to start at
+     (and prod[] below would divide by zero). */
+  if (prod[0] == 0) return 0;
+
   /* Compose base offset first.  We need the per-dim base position
      to validate stride composition against parent dim bounds (a small
      forward stride starting near the end of a parent dim wraps into
@@ -1686,19 +1690,19 @@ ca_stride_func_fill_data (void *ap, void *ptr)
       }
       case 2: {
         int16_t v; memcpy(&v, ptr, 2);
-        int16_t *d = (int16_t *) dst;
+        ca_u_int16_t *d = (ca_u_int16_t *) dst;
         for (i = 0; i < inner_count; i++) d[i] = v;
         break;
       }
       case 4: {
         int32_t v; memcpy(&v, ptr, 4);
-        int32_t *d = (int32_t *) dst;
+        ca_u_int32_t *d = (ca_u_int32_t *) dst;
         for (i = 0; i < inner_count; i++) d[i] = v;
         break;
       }
       case 8: {
         int64_t v; memcpy(&v, ptr, 8);
-        int64_t *d = (int64_t *) dst;
+        ca_u_int64_t *d = (ca_u_int64_t *) dst;
         for (i = 0; i < inner_count; i++) d[i] = v;
         break;
       }
@@ -2164,11 +2168,11 @@ rb_ca_as_strided (int argc, VALUE *argv, VALUE self)
   ca_check_rank_fits(len, NULL);
   ndim = (int8_t) len;
   for (i = 0; i < len; i++) {
-    shape[i]   = NUM2SIZE(RARRAY_AREF(rshape,   i));
-    strides[i] = NUM2SIZE(RARRAY_AREF(rstrides, i));
+    shape[i]   = ca_integer_arg(RARRAY_AREF(rshape, i), "a length", NULL);
+    strides[i] = ca_integer_arg(RARRAY_AREF(rstrides, i), "a stride", NULL);
   }
   if (! NIL_P(roffset)) {
-    base_offset = NUM2SIZE(roffset);
+    base_offset = ca_integer_arg(roffset, "offset", NULL);
   }
 
   VALUE obj = rb_ca_stride_new(self, parent->data_type, parent->bytes,
@@ -2215,12 +2219,12 @@ rb_ca_sliding_windows (int argc, VALUE *argv, VALUE self)
                RARRAY_LEN(wary), (int) ndim);
     }
     for (i = 0; i < ndim; i++) {
-      window[i] = NUM2SIZE(RARRAY_AREF(wary, i));
+      window[i] = ca_integer_arg(RARRAY_AREF(wary, i), "a window size", NULL);
     }
   }
   else if (nargs == ndim) {
     for (i = 0; i < ndim; i++) {
-      window[i] = NUM2SIZE(RARRAY_AREF(rposary, i));
+      window[i] = ca_integer_arg(RARRAY_AREF(rposary, i), "a window size", NULL);
     }
   }
   else {
@@ -2239,11 +2243,11 @@ rb_ca_sliding_windows (int argc, VALUE *argv, VALUE self)
                RARRAY_LEN(rstep), (int) ndim);
     }
     for (i = 0; i < ndim; i++) {
-      step[i] = NUM2SIZE(RARRAY_AREF(rstep, i));
+      step[i] = ca_integer_arg(RARRAY_AREF(rstep, i), "a step", NULL);
     }
   }
   else {
-    ca_size_t s = NUM2SIZE(rstep);
+    ca_size_t s = ca_integer_arg(rstep, "step", NULL);
     for (i = 0; i < ndim; i++) step[i] = s;
   }
 
@@ -2326,13 +2330,13 @@ rb_ca_unfold (int argc, VALUE *argv, VALUE self)
     }
     nspatial = (int8_t) RARRAY_LEN(wary);
     for (i = 0; i < nspatial; i++) {
-      window[i] = NUM2SIZE(RARRAY_AREF(wary, i));
+      window[i] = ca_integer_arg(RARRAY_AREF(wary, i), "a window size", NULL);
     }
   }
   else if (nargs >= 1 && nargs <= ndim) {
     nspatial = (int8_t) nargs;
     for (i = 0; i < nspatial; i++) {
-      window[i] = NUM2SIZE(RARRAY_AREF(rposary, i));
+      window[i] = ca_integer_arg(RARRAY_AREF(rposary, i), "a window size", NULL);
     }
   }
   else {
@@ -2355,11 +2359,11 @@ rb_ca_unfold (int argc, VALUE *argv, VALUE self)
                RARRAY_LEN(rstep), (int) nspatial);
     }
     for (i = 0; i < nspatial; i++) {
-      step[i] = NUM2SIZE(RARRAY_AREF(rstep, i));
+      step[i] = ca_integer_arg(RARRAY_AREF(rstep, i), "a step", NULL);
     }
   }
   else {
-    ca_size_t s = NUM2SIZE(rstep);
+    ca_size_t s = ca_integer_arg(rstep, "step", NULL);
     for (i = 0; i < nspatial; i++) step[i] = s;
   }
 
@@ -2441,12 +2445,12 @@ rb_ca_block_view (int argc, VALUE *argv, VALUE self)
                RARRAY_LEN(bary), (int) ndim);
     }
     for (i = 0; i < ndim; i++) {
-      block[i] = NUM2SIZE(RARRAY_AREF(bary, i));
+      block[i] = ca_integer_arg(RARRAY_AREF(bary, i), "a block size", NULL);
     }
   }
   else if (nargs == ndim) {
     for (i = 0; i < ndim; i++) {
-      block[i] = NUM2SIZE(RARRAY_AREF(rposary, i));
+      block[i] = ca_integer_arg(RARRAY_AREF(rposary, i), "a block size", NULL);
     }
   }
   else {
@@ -2571,7 +2575,12 @@ rb_ca_dim_view (int argc, VALUE *argv, VALUE self)
     if (! seen[i]) imap[k++] = i;
   }
 
-  return rb_ca_trans_new(self, imap);
+  {
+    /* A reordering of the axes, as transpose is: a Face stays its Face. */
+    volatile VALUE obj = rb_ca_trans_new(self, imap);
+    CA_WRAPPER_LIFT(obj, self, parent);
+    return obj;
+  }
 }
 
 /* flip(*axes) -- reverses the listed axes by negating their strides; with no
@@ -2740,14 +2749,14 @@ rb_ca_diagonal (int argc, VALUE *argv, VALUE self)
 
   /* offset from positional or keyword (not both) */
   if (nargs == 0) {
-    if (! NIL_P(roffset)) offset = NUM2SIZE(roffset);
+    if (! NIL_P(roffset)) offset = ca_integer_arg(roffset, "offset", NULL);
   }
   else if (nargs == 1) {
     if (! NIL_P(roffset)) {
       rb_raise(rb_eArgError,
                "diagonal: give offset positionally OR as keyword, not both");
     }
-    offset = NUM2SIZE(RARRAY_AREF(rposary, 0));
+    offset = ca_integer_arg(RARRAY_AREF(rposary, 0), "offset", NULL);
   }
   else {
     rb_raise(rb_eArgError,

data/ext/ca_obj_string.c

@@ -216,7 +216,10 @@ ca_string_refuse_cell (VALUE v, const char *where)
            "UNDEF masks a cell)", where, rb_obj_classname(v));
 }
 
-/* Every cell of `parent` that is not masked is a String. */
+/* Every cell of `parent` that is not masked is a String.  Under a masked
+   cell of an entity that can be written, a value that is not a String (the
+   0 an object array starts with) becomes an empty String, so that the cell
+   is still a String once it is unmasked. */
 static void
 ca_string_check_cells (VALUE parent_val, CArray *parent)
 {
@@ -226,8 +229,14 @@ ca_string_check_cells (VALUE parent_val, CArray *parent)
     VALUE *p = (VALUE *) parent->ptr;
     boolean8_t *m = ( parent->mask && parent->mask->ptr )
                     ? (boolean8_t *) parent->mask->ptr : NULL;
+    int writable = ! ca_is_readonly(parent);
     for (i = 0; i < parent->elements; i++) {
-      if ( m && m[i] ) continue;
+      if ( m && m[i] ) {
+        if ( writable && ! RB_TYPE_P(p[i], T_STRING) ) {
+          p[i] = rb_utf8_str_new("", 0);
+        }
+        continue;
+      }
       if ( ! RB_TYPE_P(p[i], T_STRING) ) {
         snprintf(where, sizeof(where), "cell %" PRId64, (int64_t) i);
         ca_string_refuse_cell(p[i], where);