carray 3.0.4 → 3.0.6

data/ext/ca_obj_stride.c

@@ -183,6 +183,9 @@ free_ca_stride (void *ap)
 {
   CAStride *ca = (CAStride *) ap;
   if (ca == NULL) return;
+  if ( ca_test_flag(ca, CA_FLAG_FOLDED) ) {
+    ca_fold_forget((CArray *) ca);
+  }
   ca_free(ca->mask);
   if (ca->_pool) {
     /* Pool path: one xfree covers dim/strides via the pool buffer,
@@ -247,6 +250,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
@@ -274,11 +281,15 @@ ca_stride_compose_through (CAStride *leaf, CAStride *parent,
 
   /* Compose each leaf dim's stride.
      Validity rule: leaf dim k must advance exactly one parent dim
-     (not cross multiple parent dims) AND stay within that parent
-     dim's bounds across leaf's full extent *given the base position*.
-     Otherwise the leaf's traversal would wrap across parent dim
-     boundaries, which is a non-strided access pattern that cannot
-     be folded. */
+     (not cross multiple parent dims), and every parent dim must stay
+     within its bounds across the leaf's full extent *given the base
+     position*.  Several leaf dims can advance the same parent dim (a block
+     of a reshape: rows step 4 parent columns, columns step 1), so the
+     bound is on the sum of their extents, kept in lo[] / hi[].  Otherwise
+     the leaf's traversal would wrap across parent dim boundaries, which
+     is a non-strided access pattern that cannot be folded. */
+  ca_size_t lo[CA_RANK_MAX], hi[CA_RANK_MAX];
+  for (m = 0; m < parent->ndim; m++) lo[m] = hi[m] = base_idx[m];
   for (k = 0; k < leaf->ndim; k++) {
     if (leaf->strides[k] % parent->bytes != 0) return 0;
     ca_size_t advance = leaf->strides[k] / parent->bytes;
@@ -298,20 +309,15 @@ ca_stride_compose_through (CAStride *leaf, CAStride *parent,
     }
     if (advance != 0) return 0;
     if (nonzero_count > 1) return 0;   /* crosses parent dims */
-    if (nonzero_count == 1) {
-      /* Final position in parent dim after the full leaf extent.
-         For a forward step it must stay strictly below dim; for a
-         backward step it must stay at or above 0. */
-      ca_size_t final_pos =
-        base_idx[nonzero_dim] + (leaf->dim[k] - 1) * nonzero_step;
-      if (nonzero_step > 0) {
-        if (final_pos >= parent->dim[nonzero_dim]) return 0;
-      } else {
-        if (final_pos < 0) return 0;
-      }
+    if (nonzero_count == 1 && leaf->dim[k] > 1) {
+      ca_size_t extent = (leaf->dim[k] - 1) * nonzero_step;
+      if (extent > 0) hi[nonzero_dim] += extent;
+      else            lo[nonzero_dim] += extent;
     }
     out_strides[k] = composed;
   }
+  for (m = 0; m < parent->ndim; m++)
+    if (lo[m] < 0 || hi[m] >= parent->dim[m]) return 0;
 
   /* A leaf cell wider than the remainder of its first parent element
      (CARefer reinterpreting two float64 as one complex128) covers several
@@ -675,14 +681,20 @@ ca_stride_func_xfer_addrs (void *ap, ca_size_t n, ca_size_t *addrs,
       }
     }
     else {
+      /* Peel the axes from the innermost: a % dim[k] is the index on
+         axis k and a / dim[k] carries the rest outward.  The outermost
+         axis takes whatever is left, so ndim-1 divisions per address. */
+      ca_size_t *dim = ca->dim;
+      int8_t     ndim = ca->ndim;
       for ( i = 0; i < n; i++ ) {
-        ca_size_t idx[CA_RANK_MAX];
+        ca_size_t a = addrs[i];
         ca_size_t off = ebase;
-        ca_addr2index((CArray *) ca, addrs[i], idx);
-        for ( k = 0; k < ca->ndim; k++ ) {
-          off += idx[k] * esteps[k];
+        for ( k = ndim - 1; k > 0; k-- ) {
+          ca_size_t q = a / dim[k];
+          off += ( a - q * dim[k] ) * esteps[k];
+          a = q;
         }
-        paddrs[i] = off;
+        paddrs[i] = off + a * esteps[0];
       }
     }
     ca_xfer_addrs(root, n, paddrs, data, dir);
@@ -817,9 +829,12 @@ ca_stride_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
 
   /* A reshape over a 1-D cold root (ndim != root->ndim): the request has no
      box in the root's single axis, but the root cells it touches lie in one
-     flat span.  Ask the root for that span once and walk the request over
-     it, as xfer_all does for the whole view.  A PUT reads the span first so
-     the cells between the requested ones go back unchanged. */
+     flat span.  A GET asks the root for that span once and walks the
+     request over it, as xfer_all does for the whole view.  A PUT hands the
+     root the list of the requested cells' addresses instead: sending the
+     span back would write the cells between them too, and a root that
+     repeats its cells (CATile) would have a stale copy land after the
+     written one. */
   if (aligned && !root->ptr && ca_func[root->obj_type].xfer_stride
        && ca->bytes == root->bytes && root->ndim == 1
        && root_base % root->bytes == 0) {
@@ -832,15 +847,33 @@ ca_stride_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
     }
     if ( span_lo >= 0 && span_hi <= root->elements * root->bytes ) {
       volatile VALUE holder;
-      ca_size_t rlo    = span_lo / root->bytes;
-      ca_size_t rcount = (span_hi - span_lo) / root->bytes;
-      ca_size_t rstep  = root->bytes;
-      char     *scratch = ALLOCV_N(char, holder, rcount * root->bytes);
-      ca_xfer_stride(root, &rlo, &rcount, &rstep, scratch, CA_XFER_GET);
-      ca_xfer_strided_walk(scratch + (root_base - span_lo), ca->bytes, ndim,
-                           counts, root_stride, d, dir);
       if ( dir == CA_XFER_PUT ) {
-        ca_xfer_stride(root, &rlo, &rcount, &rstep, scratch, CA_XFER_PUT);
+        ca_size_t  n = 1, m = 0, idx[CA_RANK_MAX];
+        ca_size_t *addrs;
+        for (k = 0; k < ndim; k++) {
+          n *= counts[k];
+          idx[k] = 0;
+        }
+        addrs = ALLOCV_N(ca_size_t, holder, n);
+        /* empty: the slot returns on an empty region at its entry */
+        while (1) {
+          ca_size_t off = root_base;
+          for (k = 0; k < ndim; k++) off += idx[k] * root_stride[k];
+          addrs[m++] = off / root->bytes;
+          k = ndim - 1;
+          while (k >= 0) { if (++idx[k] < counts[k]) break; idx[k] = 0; k--; }
+          if (k < 0) break;
+        }
+        ca_xfer_addrs(root, n, addrs, d, CA_XFER_PUT);
+      }
+      else {
+        ca_size_t rlo    = span_lo / root->bytes;
+        ca_size_t rcount = (span_hi - span_lo) / root->bytes;
+        ca_size_t rstep  = root->bytes;
+        char     *scratch = ALLOCV_N(char, holder, rcount * root->bytes);
+        ca_xfer_stride(root, &rlo, &rcount, &rstep, scratch, CA_XFER_GET);
+        ca_xfer_strided_walk(scratch + (root_base - span_lo), ca->bytes, ndim,
+                             counts, root_stride, d, dir);
       }
       ALLOCV_END(holder);
       return;
@@ -1114,10 +1147,12 @@ static int ca_layout_is_contiguous (int8_t ndim, const ca_size_t *dim,
    folds onward from itself, so the answer is the one for the root it folds
    to.  What is left is the
    boundary views that compute or fetch their contents -- CAObject, the lazy
-   per-element transforms, whatever a companion gem installed -- and of those,
-   only the ones with an xfer_stride slot can answer a region request at all.
-   The rest have nothing better than materialising, so they keep doing it once
-   under attach rather than once per transfer. */
+   per-element transforms, whatever a companion gem installed.  All of them
+   answer a region request: through their xfer_stride slot, or, when a type
+   leaves it out, through the dispatcher's default, which hands the cells'
+   addresses to xfer_addrs.  Attaching one instead would produce all of it
+   and write all of it back, so a cell nobody touched would go through the
+   view's conversion both ways. */
 int
 ca_root_lends_no_memory (void *ap)
 {
@@ -1135,7 +1170,7 @@ ca_root_lends_no_memory (void *ap)
     ca_stride_compose_to_root((CAStride *) root, &below, cs, &base);
     return ca_root_lends_no_memory(below);
   }
-  return ca_func[root->obj_type].xfer_stride != NULL;
+  return 1;
 }
 
 /* The same question for the parent of a view that is not itself in the
@@ -1431,8 +1466,10 @@ ca_stride_func_xfer_all (void *ap, void *data, int dir)
          the request is exact) and ca->bytes == root->bytes (no byte
          reinterpret, so the span endpoints are whole root elements).  A wider
          lazy root has no single strided box to ask for, so it takes the
-         whole-root fallback below -- correct, just not partial. */
-      if ( root->ndim == 1 && ca->bytes == root->bytes ) {
+         whole-root fallback below -- correct, just not partial.  Reads only:
+         a write goes to the root as the list of its cells below, since
+         sending the span back would write the cells between them too. */
+      if ( dir == CA_XFER_GET && root->ndim == 1 && ca->bytes == root->bytes ) {
         ca_size_t span_lo = composed_base;
         ca_size_t span_hi = composed_base + ca->bytes;
         int8_t k;
@@ -1449,13 +1486,10 @@ ca_stride_func_xfer_all (void *ap, void *data, int dir)
           char     *scratch = ALLOCV_N(char, holder, rcount * root->bytes);
           ca_xfer_stride(root, &rlo, &rcount, &rstep, scratch, CA_XFER_GET);
           ca->ptr = ptr;
-          ca_stride_xfer_with_layout(ca, (dir == CA_XFER_PUT) ? 1 : 0,
+          ca_stride_xfer_with_layout(ca, 0,
                                      scratch + (composed_base - span_lo),
                                      composed_strides);
           ca->ptr = ptr0;
-          if ( dir == CA_XFER_PUT ) {
-            ca_xfer_stride(root, &rlo, &rcount, &rstep, scratch, CA_XFER_PUT);
-          }
           ALLOCV_END(holder);
         }
         return;
@@ -1581,6 +1615,51 @@ ca_stride_func_xfer_all (void *ap, void *data, int dir)
   }
 }
 
+/* Whether a layout of `ndim` axes (dims, byte strides, byte base) addresses
+   each cell of a packed array of the same number of cells exactly once:
+   ordered by the size of their strides, the axes longer than one must be
+   packed (the smallest stride is `bytes`, each next one the previous times
+   its axis length), and the lowest address must be 0.  Equal counts alone
+   do not say this: a zero or repeated stride covers fewer cells. */
+static int
+ca_stride_layout_is_permutation (int8_t ndim, const ca_size_t *dim,
+                                 const ca_size_t *strides, ca_size_t base,
+                                 ca_size_t bytes)
+{
+  int8_t    order[CA_RANK_MAX];
+  int8_t    n = 0, i, j;
+  ca_size_t lowest = base, expect = bytes;
+
+  for (i=0; i<ndim; i++) {
+    if ( dim[i] <= 1 ) {
+      continue;
+    }
+    if ( strides[i] < 0 ) {
+      lowest += (dim[i] - 1) * strides[i];
+    }
+    for (j=n; j>0; j--) {
+      ca_size_t a = strides[order[j-1]], b = strides[i];
+      if ( (a < 0 ? -a : a) <= (b < 0 ? -b : b) ) {
+        break;
+      }
+      order[j] = order[j-1];
+    }
+    order[j] = i;
+    n++;
+  }
+  if ( lowest != 0 ) {
+    return 0;
+  }
+  for (i=0; i<n; i++) {
+    ca_size_t s = strides[order[i]];
+    if ( (s < 0 ? -s : s) != expect ) {
+      return 0;
+    }
+    expect *= dim[order[i]];
+  }
+  return 1;
+}
+
 static void
 ca_stride_func_fill_data (void *ap, void *ptr)
 {
@@ -1616,7 +1695,9 @@ ca_stride_func_fill_data (void *ap, void *ptr)
      into scratch only to overwrite every byte with *ptr -- wasted
      work.  Delegate to root.fill_data instead.
      Safety gates:
-       (1) elements match -- our view covers every root cell;
+       (1) elements match and the composed layout addresses each root cell
+           exactly once -- our view covers every root cell (a zero or
+           repeated stride has as many cells but covers fewer);
        (2) bytes match -- our cell width equals root's cell width.
      Without (2), a type-reinterpreting CAStride (CAField over a
      complex entity for `.real`/`.imag`) would corrupt root: root
@@ -1628,7 +1709,9 @@ ca_stride_func_fill_data (void *ap, void *ptr)
   if ( ca_func[root->obj_type].attach != ca_stride_func.attach &&
        ca_func[root->obj_type].attach != ca_window_func.attach &&
        ca->elements == root->elements &&
-       ca->bytes    == root->bytes ) {
+       ca->bytes    == root->bytes &&
+       ca_stride_layout_is_permutation(ca->ndim, ca->dim, composed_strides,
+                                       composed_base, bytes) ) {
     ca_func[root->obj_type].fill_data(root, ptr);
     return;
   }
@@ -1686,19 +1769,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;
       }
@@ -2090,6 +2173,13 @@ rb_cs_initialize_copy (VALUE self, VALUE other)
   ca_stride_setup(ca, cs->obj_type, cs->parent, cs->data_type, cs->bytes,
                   cs->ndim, cs->dim, cs->strides, cs->base_offset);
   rb_ca_set_parent(self, rb_ca_parent(other));
+  if ( ca_test_flag(cs, CA_FLAG_FOLDED) ) {
+    /* the copy has the same @parent, so it answers to the same source */
+    CArray *src = ca_fold_source((CArray *) cs);
+    if ( src ) {
+      ca_fold_note_source((CArray *) ca, src);
+    }
+  }
   return self;
 }
 
@@ -2164,11 +2254,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 +2305,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 +2329,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 +2416,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 +2445,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 +2531,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 +2661,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 +2835,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,11 @@ 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 a parent 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.  A view is written through its
+   value array, which leaves the mask as it is. */
 static void
 ca_string_check_cells (VALUE parent_val, CArray *parent)
 {
@@ -226,8 +230,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);
@@ -238,6 +248,7 @@ ca_string_check_cells (VALUE parent_val, CArray *parent)
     volatile VALUE list =
       rb_funcall(rb_funcall(parent_val, rb_intern("flatten"), 0),
                  rb_intern("to_a"), 0);
+    volatile VALUE values = Qnil, raw = Qnil;
     long n = RARRAY_LEN(list), j;
     for (j = 0; j < n; j++) {
       VALUE v = rb_ary_entry(list, j);
@@ -247,6 +258,20 @@ ca_string_check_cells (VALUE parent_val, CArray *parent)
         ca_string_refuse_cell(v, where);
       }
     }
+    if ( ! ca_is_readonly(parent) ) {
+      for (j = 0; j < n; j++) {
+        if ( rb_ary_entry(list, j) != CA_UNDEF ) continue;
+        if ( NIL_P(values) ) {
+          values = rb_funcall(rb_funcall(parent_val, rb_intern("value"), 0),
+                              rb_intern("flatten"), 0);
+          raw    = rb_funcall(values, rb_intern("to_a"), 0);
+        }
+        if ( ! RB_TYPE_P(rb_ary_entry(raw, j), T_STRING) ) {
+          rb_funcall(values, rb_intern("[]="), 2, LONG2NUM(j),
+                     rb_utf8_str_new("", 0));
+        }
+      }
+    }
   }
 }
 

data/ext/ca_obj_tile.c

@@ -108,6 +108,8 @@ ca_tile_setup (CATile *ca, CArray *parent, ca_size_t *reps)
   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);
   ca->dim       = ALLOC_N(ca_size_t, ndim);
 
@@ -120,15 +122,33 @@ ca_tile_setup (CATile *ca, CArray *parent, ca_size_t *reps)
   return 0;
 }
 
+typedef struct {
+  CATile    *ca;
+  CArray    *parent;
+  ca_size_t *reps;
+} ca_tile_new_arg;
+
+static VALUE
+ca_tile_new_setup (VALUE varg)
+{
+  ca_tile_new_arg *a = (ca_tile_new_arg *) varg;
+  ca_tile_setup(a->ca, a->parent, a->reps);
+  return Qnil;
+}
+
+/* The setup allocates reps and dim after the struct: when either fails,
+   the struct goes too. */
 CATile *
 ca_tile_new (CArray *parent, ca_size_t *reps)
 {
-  CATile *ca;
+  ca_tile_new_arg a;
   ca_tile_setup(NULL, parent, reps);
-  ca = ALLOC(CATile);
-  ca_tile_setup(ca, parent, reps);
-  ca_fill_or_free((CArray *) ca, ca_view_inherit_mask, (VALUE) ca);
-  return ca;
+  a.ca     = ALLOC(CATile);
+  a.parent = parent;
+  a.reps = reps;
+  ca_fill_or_free((CArray *) a.ca, ca_tile_new_setup, (VALUE) &a);
+  ca_fill_or_free((CArray *) a.ca, ca_view_inherit_mask, (VALUE) a.ca);
+  return a.ca;
 }
 
 static void
@@ -548,7 +568,7 @@ rb_ca_tile (int argc, VALUE *argv, VALUE self)
                len, ca->ndim);
     }
     for ( i = 0; i < ca->ndim; i++ ) {
-      reps[i] = NUM2SIZE(rb_ary_entry(ary, i));
+      reps[i] = ca_integer_arg(rb_ary_entry(ary, i), "a repeat count", NULL);
     }
   }
   else {
@@ -559,7 +579,7 @@ rb_ca_tile (int argc, VALUE *argv, VALUE self)
                ca->ndim, argc);
     }
     for ( i = 0; i < ca->ndim; i++ ) {
-      reps[i] = NUM2SIZE(argv[i]);
+      reps[i] = ca_integer_arg(argv[i], "a repeat count", NULL);
     }
   }
 
@@ -623,6 +643,7 @@ Init_ca_obj_tile (void)
                                     &catile_data_type,
                                     rb_cCATileMask,
                                     &catile_mask_data_type, &ca_tile_func, sizeof(ca_tile_func));
+  ca_register_cell_moving_view(CA_OBJ_TILE);
   rb_define_const(rb_cObject, "CA_OBJ_TILE", INT2NUM(CA_OBJ_TILE));
 
   rb_define_method(rb_cCArray, "tile", rb_ca_tile, -1);

data/ext/ca_obj_transpose.c

@@ -42,8 +42,8 @@ ca_trans_setup (CAStride *ca, CArray *parent, ca_size_t *imap)
                "specified %i-th dimension number out of range", i);
     }
     if (map[idim] != -1) {
-      rb_raise(rb_eArgError,
-               "specified %i-th dimension number is duplicated", i);
+      rb_raise(rb_eArgError, "%s: axis %" PRId64 " is given twice",
+               ca_calling_method_name(), (int64_t) idim);
     }
     map[idim] = i;
     newdim[i] = dim0[idim];
@@ -120,10 +120,14 @@ rb_ca_trans (int argc, VALUE *argv, VALUE self)
     for (i = 0; i < ca->ndim; i++) imap[i] = ca->ndim - i - 1;
   }
   else if (argc == ca->ndim) {
-    for (i = 0; i < ca->ndim; i++) imap[i] = NUM2SIZE(argv[i]);
+    /* Each axis read as every axis argument is: negative from the end. */
+    for (i = 0; i < ca->ndim; i++) {
+      imap[i] = ca_normalize_axis_arg(argv[i], ca->ndim, NULL);
+    }
   }
   else {
-    rb_raise(rb_eArgError, "# of arguments should be equal to ndim");
+    rb_raise(rb_eArgError, "%s: %d axes given for ndim %d",
+             ca_calling_method_name(), argc, (int) ca->ndim);
   }
 
   obj = rb_ca_trans_new(self, imap);

data/ext/ca_obj_triop.c

@@ -267,9 +267,11 @@ pull_operand (CArray *op, int is_scalar, const ca_lazy_req_t *req,
 
 /* Evaluate the cells a request names into `data` (packed, n cells). */
 static void
-ca_triop_eval (CATriOp *to, const ca_lazy_req_t *req, void *data)
+ca_triop_eval_cells (void *node, const ca_lazy_req_t *req, void *data, int dir)
 {
+  CATriOp  *to = (CATriOp *) node;
   ca_size_t slab_n = req->n;
+  (void) dir;
   void     *scratch2, *scratch3;
   ca_size_t op2_step, op3_step;
 
@@ -316,6 +318,12 @@ ca_triop_eval (CATriOp *to, const ca_lazy_req_t *req, void *data)
   ca_lazy_arena_release(scratch2);
 }
 
+static void
+ca_triop_eval (CATriOp *to, const ca_lazy_req_t *req, void *data)
+{
+  ca_lazy_eval_recorded(to, 3, to->operands, 0, NULL, ca_triop_eval_cells, req, data, CA_XFER_GET);
+}
+
 static void
 ca_triop_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
                            ca_size_t *strides, void *data, int dir)
@@ -542,6 +550,9 @@ rb_ca_triop_build (VALUE cary1, VALUE cary2, VALUE cary3, uint16_t op_id)
     r3 = ca_lazy_settle_scalar(r3, r3_scalar);
   }
 
+  ca_refuse_without_common_type(r1, r2);
+  ca_refuse_without_common_type(r1, r3);
+  ca_refuse_without_common_type(r2, r3);
   TypedData_Get_Struct(r1, CArray, &carray_data_type, op1);
   TypedData_Get_Struct(r2, CArray, &carray_data_type, op2);
   TypedData_Get_Struct(r3, CArray, &carray_data_type, op3);