carray 3.0.2 → 3.0.4

data/ext/ca_obj_refer.c

@@ -74,34 +74,51 @@ ca_refer_setup (CARefer *ca, CArray *parent,
   ca_size_t s;
   int8_t i;
 
-  CA_CHECK_DATA_TYPE(data_type);
-  CA_CHECK_RANK(ndim);
-  CA_CHECK_DIM(ndim, dim);
-  CA_CHECK_BYTES(data_type, bytes);
+  CA_CHECK_DATA_TYPE_GIVEN(data_type);
+  CA_CHECK_RANK_GIVEN(ndim);
+  CA_CHECK_DIM_GIVEN(ndim, dim);
+  CA_CHECK_BYTES_GIVEN(data_type, bytes);
 
+  /* An object cell is a VALUE the GC marks: reading other bytes as one
+     marks garbage, and reading one as bytes exposes an address. */
   if (ca_is_object_type(parent) && data_type != CA_OBJECT) {
-    rb_raise(rb_eRuntimeError,
+    rb_raise(rb_eCADataTypeError,
              "object array can't be referred by other data type");
   }
+  if (! ca_is_object_type(parent) && data_type == CA_OBJECT) {
+    rb_raise(rb_eCADataTypeError,
+             "non-object array can't be referred as object data type");
+  }
+  /* A boolean cell holds 0 or 1, and a view that reads other bytes as
+     boolean cannot keep them so: the parent is written as what it is. */
+  if (data_type == CA_BOOLEAN && parent->data_type != CA_BOOLEAN) {
+    rb_raise(rb_eCADataTypeError,
+             "%s: a %s array can't be referred as boolean (its bytes need not "
+             "be 0 or 1); compare it instead, e.g. ne(0)",
+             ca_calling_method_name(), ca_type_name[parent->data_type]);
+  }
   if (parent->elements && bytes > parent_bytes * parent->elements) {
-    rb_raise(rb_eRuntimeError, "bytes exceeds the data size of referent");
+    rb_raise(rb_eArgError, "bytes exceeds the data size of referent");
   }
   if (bytes < parent_bytes && parent_bytes % bytes != 0) {
-    rb_raise(rb_eRuntimeError,
+    rb_raise(rb_eArgError,
              "bytes of reference array must be a multiple of that of referent");
   }
   if (bytes > parent_bytes && bytes % parent_bytes != 0) {
-    rb_raise(rb_eRuntimeError,
+    rb_raise(rb_eArgError,
              "bytes of reference array must be a multiple of that of referent");
   }
   if (offset < 0) {
-    rb_raise(rb_eRuntimeError, "negative offset is not permitted for CARefer");
+    rb_raise(rb_eArgError, "negative offset is not permitted for CARefer");
+  }
+  elements = ca_shape_elements(ndim, dim, bytes);
+  if (offset > parent->elements) {
+    rb_raise(rb_eArgError,
+             "data size of reference array must not exceed that of referent");
   }
-  elements = 1;
-  for (i = 0; i < ndim; i++) elements *= dim[i];
   if ((bytes * elements + parent_bytes * offset) >
       (parent_bytes * parent->elements)) {
-    rb_raise(rb_eRuntimeError,
+    rb_raise(rb_eArgError,
              "data size of reference array must not exceed that of referent");
   }
 
@@ -114,14 +131,19 @@ ca_refer_setup (CARefer *ca, CArray *parent,
   /* base_offset is in bytes: `offset` is in parent-element units. */
   base_offset = offset * parent_bytes;
 
-  /* CAREFUL: initialise mask0 before ca_stride_setup — the setup
-     may dispatch to ca_refer_func_create_mask, which writes to
-     mask0.  Leaving it uninitialised risks freeing a garbage
-     pointer during error unwind. */
+  /* ca == NULL asks for the checks above only, so that a constructor can
+     run them before it allocates. */
+  if ( ca == NULL ) {
+    return 0;
+  }
+
+  /* mask0 is written by ca_refer_func_create_mask when the constructor
+     takes the parent's mask, and freed on error unwind, so it starts
+     NULL. */
   ca->mask0 = NULL;
 
-  ca_stride_setup((CAStride *) ca, CA_OBJ_REFER, parent,
-                  data_type, bytes, ndim, dim, strides, base_offset);
+  ca_stride_setup_view((CAStride *) ca, CA_OBJ_REFER, parent,
+                       data_type, bytes, ndim, dim, strides, base_offset);
 
   if (ca_is_scalar(parent)) {
     ca_set_flag(ca, CA_FLAG_SCALAR);
@@ -134,8 +156,11 @@ ca_refer_new (CArray *parent,
               int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes,
               ca_size_t offset)
 {
-  CARefer *ca = (CARefer *) ca_array_alloc(CA_OBJ_REFER, ndim);
+  CARefer *ca;
+  ca_refer_setup(NULL, parent, data_type, ndim, dim, bytes, offset);
+  ca = (CARefer *) ca_array_alloc(CA_OBJ_REFER, ndim);
   ca_refer_setup(ca, parent, data_type, ndim, dim, bytes, offset);
+  ca_fill_or_free((CArray *) ca, ca_view_inherit_mask, (VALUE) ca);
   return ca;
 }
 
@@ -172,10 +197,7 @@ ca_refer_func_create_mask (void *ap)
   ca_size_t parent_bytes = ca->parent->bytes;
   ca_size_t parent_offset;
 
-  ca_update_mask(ca->parent);
-  if (! ca->parent->mask) {
-    ca_create_mask(ca->parent);
-  }
+  ca_create_mask(ca->parent);
 
   parent_offset = ca->base_offset / parent_bytes;
 
@@ -200,9 +222,12 @@ ca_refer_func_create_mask (void *ap)
     ca->mask0 =
       (CArray *) ca_repeat_new(ca->parent->mask, ca->parent->ndim + 1, count);
     ca_unset_flag(ca->mask0, CA_FLAG_READ_ONLY);
+    /* mask0 has ratio cells per parent element, so the offset is counted
+       in those. */
     ca->mask =
       (CArray *) ca_refer_new(ca->mask0,
-                              CA_BOOLEAN, ca->ndim, ca->dim, 0, parent_offset);
+                              CA_BOOLEAN, ca->ndim, ca->dim, 0,
+                              parent_offset * ratio);
   }
   else {
     /* Spanned reinterpret: ratio = bytes / parent_bytes parent
@@ -232,6 +257,7 @@ rb_ca_refer_initialize_copy (VALUE self, VALUE other)
 {
   CARefer *ca, *cs;
   TypedData_Get_Struct(self,  CARefer, &carefer_data_type, ca);
+  ca_check_uninitialized(ca);
   TypedData_Get_Struct(other, CARefer, &carefer_data_type, cs);
   if ( ca_func[CA_OBJ_REFER].pool_init ) {
     ca_array_pool_alloc(ca, CA_OBJ_REFER, cs->ndim);
@@ -242,6 +268,7 @@ rb_ca_refer_initialize_copy (VALUE self, VALUE other)
      unusual mod-bytes alignments. */
   ca_refer_setup(ca, cs->parent, cs->data_type, cs->ndim, cs->dim,
                  cs->bytes, cs->base_offset / cs->parent->bytes);
+  ca_view_inherit_mask((VALUE) ca);
   return self;
 }
 
@@ -275,6 +302,34 @@ rb_ca_refer_initialize_copy (VALUE self, VALUE other)
  *   2. Match ranges of parent axes to new axes so element products
  *      agree.  Inside each matched range, root_strides must be
  *      inter-axis contiguous. */
+/* Three properties of an array are answered by walking its C parent chain:
+   ca_is_value_array, ca_is_readonly and ca_is_mask_array.  An array that is
+   built somewhere other than as a child of `src` -- a reshape that folds
+   onto the root, the copy that dup / clone makes -- does not have `src` on
+   that chain, so carry each property across from `src`.  Without this a
+   reshape or a dup of x.value reads the mask of x again (and takes UNDEF
+   into it), and a reshape of a broadcast view becomes writable. */
+void
+ca_keep_chain_flags (CArray *view, CArray *src)
+{
+  if ( ca_is_value_array(src) ) {
+    if ( view->mask ) {
+      ca_free(view->mask);
+      view->mask = NULL;
+    }
+    ca_set_flag(view, CA_FLAG_VALUE_ARRAY);
+  }
+  if ( ca_is_readonly(src) ) {
+    ca_set_flag(view, CA_FLAG_READ_ONLY);
+    if ( view->mask ) {
+      ca_set_flag(view->mask, CA_FLAG_READ_ONLY);
+    }
+  }
+  if ( ca_is_mask_array(src) ) {
+    ca_set_flag(view, CA_FLAG_MASK_ARRAY);
+  }
+}
+
 static int
 ca_reshape_try_strides (CArray *parent,
                         const ca_size_t *new_dim,
@@ -401,8 +456,11 @@ ca_reshape_try_strides (CArray *parent,
   return 1;
 }
 
+/* `refer` with its options given apart from argv, for callers in C that
+   build the options themselves (a Hash at the end of argv is read as
+   options only when the Ruby caller passed keywords). */
 static VALUE
-rb_ca_refer (int argc, VALUE *argv, VALUE self)
+rb_ca_refer_kw (int argc, VALUE *argv, VALUE ropt, VALUE self)
 {
   volatile VALUE obj = Qnil;
   CArray *ca;
@@ -415,7 +473,7 @@ rb_ca_refer (int argc, VALUE *argv, VALUE self)
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
-  if (argc == 0) {
+  if (argc == 0 && NIL_P(ropt)) {
     data_type = ca->data_type;
     bytes     = ca->bytes;
     ndim      = ca->ndim;
@@ -425,39 +483,57 @@ rb_ca_refer (int argc, VALUE *argv, VALUE self)
     rb_ca_set_parent(obj, self);
   }
   else {
-    volatile VALUE rtype, rdim, ropt, rbytes = Qnil, roffset = Qnil;
-    ropt = rb_pop_options(&argc, &argv);
+    volatile VALUE rtype, rdim, rbytes = Qnil, roffset = Qnil;
     rb_scan_args(argc, argv, "11", (VALUE *) &rtype, (VALUE *) &rdim);
     rb_scan_options(ropt, "bytes,offset", &rbytes, &roffset);
     if (NIL_P(rbytes)) rbytes = rb_ca_bytes(self);
     rb_ca_guess_type_and_bytes(rtype, rbytes, &data_type, &bytes);
     if (NIL_P(rdim)) {
       if (ca->bytes != bytes) {
-        rb_raise(rb_eRuntimeError,
+        rb_raise(rb_eArgError,
                  "specify dimension shape for different byte size");
       } else {
         rdim = rb_ca_dim(self);
       }
     }
     Check_Type(rdim, T_ARRAY);
+    CA_CHECK_RANK_GIVEN(RARRAY_LEN(rdim));   /* before dim[] is filled */
     ndim = RARRAY_LEN(rdim);
     for (i = 0; i < ndim; i++) dim[i] = NUM2SIZE(rb_ary_entry(rdim, i));
     if (! NIL_P(roffset)) offset = NUM2SIZE(roffset);
+    /* When rtype is a data_class the result is a record array.  It is
+       built on the storage, never on a Face, so that a Face stays on top
+       of the chain: re-reading a record array as its own data_class lifts
+       it (keeping its class), any other data_class wraps a new CARecord. */
+    if ( rb_obj_is_data_class(rtype) ) {
+      volatile VALUE base = rb_ca_strip_face_value(self);
+      CArray *base_ca;
+      TypedData_Get_Struct(base, CArray, &carray_data_type, base_ca);
+      cr = ca_refer_new(base_ca, data_type, ndim, dim, bytes, offset);
+      obj = ca_wrap_struct(cr);
+      rb_ca_set_parent(obj, base);
+      if ( ca->obj_type == CA_OBJ_RECORD
+           && rb_ca_data_class(self) == rtype ) {
+        return ca_face_lift(obj, self);
+      }
+      return rb_funcall(rb_const_get(rb_cObject, rb_intern("CARecord")),
+                        rb_intern("wrap"), 2, obj, rtype);
+    }
     cr = ca_refer_new((CArray *) ca, data_type, ndim, dim, bytes, offset);
     obj = ca_wrap_struct(cr);
     rb_ca_set_parent(obj, self);
-    /* When rtype is a data_class, wrap the result in CARecord so
-       the data_class is carried even if self is not itself a Face. */
-    if ( rb_obj_is_data_class(rtype) ) {
-      obj = rb_funcall(rb_const_get(rb_cObject, rb_intern("CARecord")),
-                       rb_intern("wrap"), 2, obj, rtype);
-      return obj;
-    }
   }
   CA_WRAPPER_LIFT(obj, self, ca);
   return obj;
 }
 
+static VALUE
+rb_ca_refer (int argc, VALUE *argv, VALUE self)
+{
+  volatile VALUE ropt = rb_pop_options(&argc, &argv);
+  return rb_ca_refer_kw(argc, argv, ropt, self);
+}
+
 VALUE
 rb_ca_refer_new (VALUE self,
                  int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes,
@@ -483,7 +559,7 @@ rb_ca_refer_new (VALUE self,
   rb_ary_store(list, 2, ropt);
 
   {
-    volatile VALUE obj = rb_ca_refer(3, (VALUE *) RARRAY_CONST_PTR(list), self);
+    volatile VALUE obj = rb_ca_refer_kw(2, (VALUE *) RARRAY_CONST_PTR(list), ropt, self);
     CArray *co;
 
     /* CAREFUL: this is the internal builder -- some fifteen call sites want
@@ -535,6 +611,7 @@ rb_ca_reshape (int argc, VALUE *argv, VALUE self)
   CARefer *cr;
   ca_size_t new_dim[CA_RANK_MAX];
   ca_size_t prod = 1;
+  int overflow = 0, zero = 0;
   int placeholder_idx = -1;     /* axis with `-1` or `:~` infer placeholder */
   int i;
   volatile VALUE obj;
@@ -542,9 +619,7 @@ rb_ca_reshape (int argc, VALUE *argv, VALUE self)
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
-  if (argc < 0 || argc > CA_RANK_MAX) {
-    rb_raise(rb_eArgError, "reshape: invalid number of dims (%d)", argc);
-  }
+  ca_check_rank_fits(argc, "reshape");
 
   /* Locate the (at most one) auto-infer placeholder.  `-1` is the
      conventional spelling; `:~` is the unified auto-fill sigil
@@ -553,7 +628,7 @@ rb_ca_reshape (int argc, VALUE *argv, VALUE self)
     if ( (FIXNUM_P(argv[i]) && FIX2LONG(argv[i]) == -1)
          || argv[i] == sym_tilde ) {
       if (placeholder_idx >= 0) {
-        rb_raise(rb_eRuntimeError,
+        rb_raise(rb_eArgError,
                  "reshape: only one auto-infer placeholder (-1 / :~) allowed");
       }
       placeholder_idx = i;
@@ -578,7 +653,7 @@ rb_ca_reshape (int argc, VALUE *argv, VALUE self)
         src = (i < ca->ndim) ? i : ca->ndim - (argc - i);
       }
       if (src < 0 || src >= ca->ndim) {
-        rb_raise(rb_eRuntimeError,
+        rb_raise(rb_eArgError,
                  "reshape: nil at axis %d has no source dim", i);
       }
       new_dim[i] = ca->dim[src];
@@ -586,13 +661,27 @@ rb_ca_reshape (int argc, VALUE *argv, VALUE self)
     else {
       new_dim[i] = NUM2SIZE(argv[i]);
     }
-    prod *= new_dim[i];
+    /* A product too large to count cannot equal the element count; an
+       extent of zero anywhere makes it zero whatever it overflowed to. */
+    if ( __builtin_mul_overflow(prod, new_dim[i], &prod) ) {
+      overflow = 1;
+    }
+    if ( new_dim[i] == 0 ) {
+      zero = 1;
+    }
+  }
+  if ( zero ) {
+    prod = 0;
+  }
+  else if ( overflow ) {
+    rb_raise(rb_eArgError,
+             "reshape: the shape has more elements than an array can hold");
   }
 
   /* Resolve placeholder dim from the leftover total. */
   if (placeholder_idx >= 0) {
     if (prod == 0 || ca->elements % prod != 0) {
-      rb_raise(rb_eRuntimeError,
+      rb_raise(rb_eArgError,
                "reshape: cannot infer dim for `-1` placeholder");
     }
     new_dim[placeholder_idx] = ca->elements / prod;
@@ -604,7 +693,7 @@ rb_ca_reshape (int argc, VALUE *argv, VALUE self)
        a subset), and on non-contiguous parents the compose-fold
        path corrupts data outright — hence the raise. */
     if (prod != ca->elements) {
-      rb_raise(rb_eRuntimeError,
+      rb_raise(rb_eArgError,
                "reshape: cannot reshape array of %lld elements into a shape "
                "of %lld elements (use -1 / :~ to infer a dim)",
                (long long) ca->elements, (long long) prod);
@@ -627,6 +716,7 @@ rb_ca_reshape (int argc, VALUE *argv, VALUE self)
                                    ca->data_type, ca->bytes,
                                    (int8_t) argc, new_dim,
                                    out_strides, out_base);
+      ca_keep_chain_flags((CArray *) cs, ca);
       obj = ca_wrap_struct(cs);
       rb_ca_set_parent(obj, self);
       CA_WRAPPER_LIFT(obj, self, ca);
@@ -664,6 +754,7 @@ rb_ca_flatten (VALUE self)
       CAStride *cs = ca_stride_new(CA_OBJ_STRIDE, out_root,
                                    ca->data_type, ca->bytes,
                                    1, dim, out_strides, out_base);
+      ca_keep_chain_flags((CArray *) cs, ca);
       obj = ca_wrap_struct(cs);
       rb_ca_set_parent(obj, self);
       CA_WRAPPER_LIFT(obj, self, ca);
@@ -691,7 +782,7 @@ rb_ca_flatten (VALUE self)
      before axis 0 twice              -> [1, 1, 2, 3]
 
    Returns a CARefer view (zero-copy alias to +self+'s data, via reshape).
-   Bound to the internal name __insert_axis_size1__; the user-facing
+   Bound to the private method insert_size_one_axes; the user-facing
    insert_axis (with the repeat: keyword) is the Ruby method in
    lib/carray/basics.rb, which builds on this primitive.
 
@@ -711,11 +802,7 @@ rb_ca_insert_axis (int argc, VALUE *argv, VALUE self)
 
   ndim     = (int) ca->ndim;
   new_ndim = ndim + argc;
-  if (new_ndim > CA_RANK_MAX) {
-    rb_raise(rb_eArgError,
-             "insert_axis: resulting ndim %d exceeds CA_RANK_MAX %d",
-             new_ndim, CA_RANK_MAX);
-  }
+  ca_check_rank_fits(new_ndim, "insert_axis");
 
   ngap = ndim + 1;   /* gaps live in [0, ndim] (ndim = the end gap) */
 
@@ -725,12 +812,7 @@ rb_ca_insert_axis (int argc, VALUE *argv, VALUE self)
     gap_count[i] = 0;
   }
   for (i = 0; i < argc; i++) {
-    int raw = NUM2INT(argv[i]);
-    int g   = (raw < 0) ? raw + ngap : raw;
-    if (g < 0 || g >= ngap) {
-      rb_raise(rb_eArgError,
-               "insert_axis: axis %d out of range for ndim %d", raw, ndim);
-    }
+    int g = ca_normalize_axis_arg(argv[i], ngap, "insert_axis");
     gap_count[g]++;
   }
 
@@ -774,7 +856,7 @@ Init_ca_obj_refer (void)
   /* The bare size-1 primitive.  The user-facing `insert_axis` (with its
      `repeat:` keyword) is the Ruby method in lib/carray/basics.rb, which
      owns the name and calls this primitive. */
-  rb_define_method(rb_cCArray, "__insert_axis_size1__", rb_ca_insert_axis, -1);
+  rb_define_private_method(rb_cCArray, "insert_size_one_axes", rb_ca_insert_axis, -1);
   rb_define_alloc_func(rb_cCARefer, rb_ca_refer_s_allocate);
   rb_define_method(rb_cCARefer, "initialize_copy",
                                        rb_ca_refer_initialize_copy, 1);

data/ext/ca_obj_remap.c

@@ -7,9 +7,9 @@
   Constraints:
   - ref.dim == idx.dim (same shape, same ndim, per-axis dim match)
   - idx.data_type == CA_SIZE (caller responsible)
-  - No public constructor — there is no `CArray#remap(idx)` or
-    `CARemap.new` surface; the class is only reachable via internal
-    helpers and the `ca[idx]` same-shape indexer fast path.
+  - No public constructor — there is no `CArray#remap(idx)` surface; a
+    view is built by internal helpers and the `ca[idx]` same-shape
+    indexer fast path.  `dup` / `clone` copy an existing one.
   - The CARemap Ruby class IS rb_define_class'd: visibility lets users
     see "this view came from a same-shape gather" when they inspect
     `.class`.  CA_OBJ_REMAP integer remains unexported as a Ruby
@@ -18,6 +18,7 @@
 ---------------------------------------------------------------------------- */
 
 #include "carray.h"
+#include "carray_internal.h"
 
 typedef struct {
   int16_t   obj_type;
@@ -128,6 +129,12 @@ ca_remap_setup (CARemap *ca, CArray *ref, CArray *idx)
 {
   ca_remap_check_constraints(ref, idx);
 
+  /* ca == NULL asks for the checks above only, so that a constructor can
+     run them before it allocates. */
+  if ( ca == NULL ) {
+    return 0;
+  }
+
   ca->obj_type  = CA_OBJ_REMAP;
   ca->data_type = ref->data_type;
   ca->flags     = 0;
@@ -146,9 +153,6 @@ ca_remap_setup (CARemap *ca, CArray *ref, CArray *idx)
   ca->nosync    = 0;
   ca->idx       = idx;
 
-  if ( ca_has_mask(ref) ) {
-    ca_create_mask(ca);
-  }
 
   if ( ca_is_scalar(ref) ) {
     ca_set_flag(ca, CA_FLAG_SCALAR);
@@ -160,8 +164,11 @@ ca_remap_setup (CARemap *ca, CArray *ref, CArray *idx)
 CARemap *
 ca_remap_new (CArray *ref, CArray *idx)
 {
-  CARemap *ca = (CARemap *) ca_array_alloc(CA_OBJ_REMAP, ref->ndim);
+  CARemap *ca;
+  ca_remap_setup(NULL, ref, idx);
+  ca = (CARemap *) ca_array_alloc(CA_OBJ_REMAP, ref->ndim);
   ca_remap_setup(ca, ref, idx);
+  ca_fill_or_free((CArray *) ca, ca_view_inherit_mask, (VALUE) ca);
   return ca;
 }
 
@@ -210,15 +217,13 @@ static void
 ca_remap_func_allocate (void *ap)
 {
   CARemap *ca = (CARemap *) ap;
-  ca->ptr = xmalloc(ca_length(ca));
+  ca->ptr = ca_alloc_cells((CArray *) ca);
 }
 
 static void
 ca_remap_func_attach (void *ap)
 {
-  CARemap *ca = (CARemap *) ap;
-  ca->ptr = xmalloc(ca_length(ca));
-  ca_remap_func_xfer_all(ca, ca->ptr, CA_XFER_GET);
+  ca_axis_view_attach_owned(ap);
 }
 
 static void
@@ -265,10 +270,7 @@ static void
 ca_remap_func_create_mask (void *ap)
 {
   CARemap *ca = (CARemap *) ap;
-  ca_update_mask(ca->parent);
-  if ( ! ca->parent->mask ) {
-    ca_create_mask(ca->parent);
-  }
+  ca_create_mask(ca->parent);
   /* Mask is a CARemap over (parent->mask, idx) — same shape, boolean. */
   ca->mask = (CArray *) ca_remap_new(ca->parent->mask, ca->idx);
 }
@@ -282,7 +284,7 @@ ca_remap_func_create_mask (void *ap)
      2. ca_xfer_addrs(ca->idx, n, addrs, paddrs, GET)  — one batched
         read of the parent flat addresses through ca->idx's own
         xfer_addrs dispatcher (entity, view, view chain — all
-        transparent).
+        transparent), each address then checked against the parent.
      3. ca_xfer_addrs(ca->parent, n, paddrs, data, dir) — one batched
         gather/scatter of the user payload against parent.
 
@@ -295,13 +297,20 @@ ca_remap_func_xfer_addrs (void *ap, ca_size_t n, ca_size_t *addrs,
 {
   CARemap   *ca = (CARemap *) ap;
   ca_size_t *paddrs;
+  ca_size_t  i;
   volatile VALUE holder;
 
   if ( n == 0 ) return;
 
   paddrs = ALLOCV_N(ca_size_t, holder, n);
-  ca_xfer_addrs(ca->idx,    n, addrs,  paddrs, CA_XFER_GET);
-  ca_xfer_addrs(ca->parent, n, paddrs, data,   dir);
+  ca_xfer_addrs(ca->idx, n, addrs, paddrs, CA_XFER_GET);
+  /* idx is read live, so its values are checked here, not at
+     construction: negative counts from the end, out of range raises
+     before the parent is touched. */
+  for ( i = 0; i < n; i++ ) {
+    CA_CHECK_INDEX(paddrs[i], ca->parent->elements);
+  }
+  ca_xfer_addrs(ca->parent, n, paddrs, data, dir);
   ALLOCV_END(holder);
 }
 
@@ -329,6 +338,7 @@ static void
 ca_remap_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
                            ca_size_t *strides, void *data, int dir)
 {
+  if ( ca_region_is_empty(((CArray *) ap)->ndim, counts) ) return;
   CARemap   *ca = (CARemap *) ap;
   int8_t     ndim = ca->ndim;
   ca_size_t  native[CA_RANK_MAX], idx[CA_RANK_MAX];
@@ -431,8 +441,9 @@ rb_ca_remap_new (VALUE cary, VALUE rmapper)
 }
 
 /* Read-only accessor for the per-cell index CArray that defines this
-   CARemap's mapping.  Returns the same CArray VALUE the caller passed
-   to ca[mapper] (= shared reference, not a copy).  Companion to
+   CARemap's mapping: the array the view reads.  For ca[mapper] it is a
+   copy of mapper taken at the call, so a later change to mapper does
+   not reach the view.  Companion to
    CABlock#start / CAStride#strides / CAWindow#count etc. — the view
    hierarchy is preserved so each named view class exposes its own
    defining semantic state. */
@@ -443,18 +454,68 @@ rb_ca_remap_mapper (VALUE self)
 }
 
 
+/* `dup` / `clone`.  CARemap has no allocator (Ruby cannot build one), so
+   Object#dup cannot copy it; these build the copy the way the indexer
+   does: a new view over the same parent and the same index array. */
+static VALUE
+rb_ca_remap_dup (VALUE self)
+{
+  volatile VALUE rmapper = rb_ivar_get(self, rb_intern("remap_idx"));
+  if ( NIL_P(rmapper) ) {
+    /* The mask of a CARemap (it holds no index array of its own): another
+       remap over the same parent mask and index.  The array it is the mask
+       of keeps both alive, so the copy holds that array too. */
+    volatile VALUE obj;
+    CArray *ca, *cp;
+    TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
+    cp = (CArray *) ca_remap_func_clone(ca);
+    ca_keep_chain_flags(cp, ca);
+    obj = TypedData_Wrap_Struct(rb_obj_class(self), &caremap_data_type, cp);
+    rb_ivar_set(obj, rb_intern("masked_array"),
+                rb_ivar_get(self, rb_intern("masked_array")));
+    return obj;
+  }
+  return rb_ca_remap_new(rb_ca_parent(self), rmapper);
+}
+
+static VALUE
+rb_ca_remap_clone (int argc, VALUE *argv, VALUE self)
+{
+  VALUE opts = Qnil, vfreeze = Qnil;
+  volatile VALUE obj;
+  rb_scan_args(argc, argv, "0:", &opts);
+  if ( ! NIL_P(opts) ) {
+    /* rb_get_kwargs refuses any key but freeze:, as Kernel#clone does. */
+    ID kw[1];
+    VALUE val[1];
+    kw[0] = rb_intern("freeze");
+    rb_get_kwargs(opts, kw, 0, 1, val);
+    if ( val[0] != Qundef ) {
+      vfreeze = val[0];
+    }
+  }
+  obj = rb_ca_remap_dup(self);
+  if ( RTEST(vfreeze) || ( NIL_P(vfreeze) && OBJ_FROZEN(self) ) ) {
+    rb_obj_freeze(obj);
+  }
+  return obj;
+}
+
 void
 Init_ca_obj_remap (void)
 {
   /* CARemap is a proper Ruby class so users can see "this view is a
-     per-element gather" on .class.  No allocator, no initialize, no
-     `new` reachable from Ruby — construction is C-internal only.
-     CA_OBJ_REMAP integer remains unexported (it's an internal type
-     tag, not user-meaningful). */
+     per-element gather" on .class.  A view is built from C only (the
+     indexer and sort / partition): there is no allocator, and `dup` /
+     `clone` are defined here instead of going through one.  CA_OBJ_REMAP
+     integer remains unexported (it's an internal type tag, not
+     user-meaningful). */
   rb_cCARemap     = rb_define_class("CARemap",     rb_cCAView);
   rb_cCARemapMask = rb_define_class("CARemapMask", rb_cCARemap);
   rb_undef_alloc_func(rb_cCARemap);
   rb_undef_alloc_func(rb_cCARemapMask);
+  rb_define_method(rb_cCARemap, "dup",   rb_ca_remap_dup,    0);
+  rb_define_method(rb_cCARemap, "clone", rb_ca_remap_clone, -1);
 
   ca_remap_func.struct_size = sizeof(CARemap);
   ca_remap_func.pool_bytes  = ca_remap_pool_bytes;