carray 3.0.5 → 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,
@@ -278,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;
@@ -302,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
@@ -679,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);
@@ -821,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) {
@@ -836,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;
@@ -1118,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)
 {
@@ -1139,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
@@ -1435,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;
@@ -1453,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;
@@ -1585,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)
 {
@@ -1620,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
@@ -1632,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;
   }
@@ -2094,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;
 }
 

data/ext/ca_obj_string.c

@@ -217,9 +217,10 @@ ca_string_refuse_cell (VALUE v, const char *where)
 }
 
 /* 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
+   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. */
+   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)
 {
@@ -247,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);
@@ -256,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

@@ -643,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_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)

data/ext/ca_obj_window.c

@@ -1982,6 +1982,7 @@ Init_ca_obj_window (void)
   		                      &cawindow_data_type, 
 				      rb_cCAWindowMask,
 				      &cawindow_mask_data_type, &ca_window_func, sizeof(ca_window_func));
+  ca_register_cell_moving_view(CA_OBJ_WINDOW);
   rb_define_const(rb_cObject, "CA_OBJ_WINDOW", INT2NUM(CA_OBJ_WINDOW));
 
   rb_define_method(rb_cCArray, "window", rb_ca_window, -1);

data/ext/ca_op_ipower.c

@@ -110,7 +110,7 @@ ca_binop_func_t ca_binop_ipower[CA_NTYPE] = {
 
 static void
 ca_ipower_float32_t (ca_size_t n, boolean8_t *m,
-                     char *ptr1, int32_t ipow, char *ptr2)
+                     char *ptr1, int64_t ipow, char *ptr2)
 {
   ca_u_float32_t *p1 = (ca_u_float32_t *) ptr1, *p2 = (ca_u_float32_t *) ptr2;
   if ( m ) {
@@ -125,7 +125,7 @@ ca_ipower_float32_t (ca_size_t n, boolean8_t *m,
 
 static void
 ca_ipower_float64_t (ca_size_t n, boolean8_t *m,
-                     char *ptr1, int32_t ipow, char *ptr2)
+                     char *ptr1, int64_t ipow, char *ptr2)
 {
   ca_u_float64_t *p1 = (ca_u_float64_t *) ptr1, *p2 = (ca_u_float64_t *) ptr2;
   if ( m ) {
@@ -140,7 +140,7 @@ ca_ipower_float64_t (ca_size_t n, boolean8_t *m,
 
 static void
 ca_ipower_cmplx64_t (ca_size_t n, boolean8_t *m,
-                     char *ptr1, int32_t ipow, char *ptr2)
+                     char *ptr1, int64_t ipow, char *ptr2)
 {
   ca_u_cmplx64_t *p1 = (ca_u_cmplx64_t *) ptr1, *p2 = (ca_u_cmplx64_t *) ptr2;
   if ( m ) {
@@ -155,7 +155,7 @@ ca_ipower_cmplx64_t (ca_size_t n, boolean8_t *m,
 
 static void
 ca_ipower_cmplx128_t (ca_size_t n, boolean8_t *m,
-                     char *ptr1, int32_t ipow, char *ptr2)
+                     char *ptr1, int64_t ipow, char *ptr2)
 {
   ca_u_cmplx128_t *p1 = (ca_u_cmplx128_t *) ptr1, *p2 = (ca_u_cmplx128_t *) ptr2;
   if ( m ) {
@@ -195,10 +195,10 @@ rb_ca_ipower (VALUE self, VALUE other)
 {
   volatile VALUE obj;
   CArray *ca, *co;
-  int32_t ipow;
+  int64_t ipow;
   boolean8_t *m;
 
-  ipow = NUM2INT(other);
+  ipow = NUM2LL(other);
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
@@ -252,10 +252,10 @@ static VALUE
 rb_ca_ipower_bang (VALUE self, VALUE other)
 {
   CArray *ca;
-  int32_t ipow;
+  int64_t ipow;
   boolean8_t *m;
 
-  ipow = NUM2INT(other);
+  ipow = NUM2LL(other);
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 

data/ext/caframe_csv_reader.c

@@ -1,4 +1,4 @@
-/* CSV body reader for CAFrame.from_csv.
+/* CSV body reader for CAFrame.read_csv.
 
    CArray.__csv_read_body_as_string_cells__(text, sep, quote, ncol, keep)
      -> [ncol, cells, records]

data/ext/carray.h

@@ -237,7 +237,8 @@ typedef ca_u_float64_t ca_u_double;
    routines that walk a single ->parent test this flag and instead fold over
    the parents[] exposed by the CAMultiParent layout convention. */
 #define CA_FLAG_MULTI_PARENTS   32
-#define CA_FLAG_CYCLE_CHECK     64
+/* bit 64 (formerly CA_FLAG_CYCLE_CHECK) is free: a cyclic read is found
+   without writing to the array (ca_test_cyclic_check). */
 #define CA_FLAG_IS_FACE        128
 /* Face opt-in ordering/search flags.
    A Face declares that its numeric storage may be descended to for kernel

data/ext/carray_access.c

@@ -1554,75 +1554,37 @@ rb_ca_fetch_slab_sigil (int argc, VALUE *argv, VALUE self)
   return rb_funcall(klass, rb_intern("new"), 2, base, slab_axes);
 }
 
+/* A CScalar is one cell and takes no index: s[] and s[0] name that cell,
+   anything else is refused. */
+
+static void
+rb_cs_check_index (int argc, VALUE *argv, const char *op)
+{
+  if ( argc == 0 ) {
+    return;
+  }
+  if ( argc == 1 && FIXNUM_P(argv[0]) && FIX2LONG(argv[0]) == 0 ) {
+    return;
+  }
+  rb_raise(rb_eArgError,
+           "CScalar%s takes no index other than [] or [0]", op);
+}
+
 static VALUE
 rb_cs_fetch_method (int argc, VALUE *argv, VALUE self)
 {
-  volatile VALUE obj = Qnil;
-  CArray *ca;
-  CAIndexInfo info;
-
-  TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
+  rb_cs_check_index(argc, argv, "#[]");
+  return rb_ca_fetch_addr(self, 0);
+}
 
-  info.range_check = 0;
-  rb_ca_scan_index(ca->ndim, ca->dim, ca->elements, argc, argv, &info);
+static VALUE rb_ca_store_method (int argc, VALUE *argv, VALUE self);
 
-  switch ( info.type ) {
-  case CA_REG_ADDRESS_COMPLEX:
-    obj = rb_ca_fetch_addr(self, 0);
-    break;
-  case CA_REG_ADDRESS:
-    obj = rb_ca_fetch_addr(self, 0);
-    break;
-  case CA_REG_FLATTEN:
-    obj = self; /* rb_funcall(self, rb_intern("refer"), 0); */
-    break;
-  case CA_REG_POINT:
-    obj = rb_ca_fetch_addr(self, 0);
-    break;
-  case CA_REG_ALL:
-    obj = self; /* rb_funcall(self, rb_intern("refer"), 0); */
-    break;
-  case CA_REG_BLOCK:
-    obj = self; /* rb_funcall(self, rb_intern("refer"), 0); */
-    break;
-  case CA_REG_SELECT:
-    obj = rb_ca_select_new(self, argv[0]);
-    break;
-  case CA_REG_ITERATOR:
-    obj = rb_ca_slab_iter_new(self, &info);
-    break;
-  case CA_REG_REPEAT:
-    obj = rb_ca_repeat(argc, argv, self);
-    break;
-  case CA_REG_MAPPING:
-    obj = rb_ca_fancy_index_chain(self, argv[0]);
-    break;
-  case CA_REG_GRID:
-    obj = rb_ca_grid(argc, argv, self);
-    break;
-  case CA_REG_METHOD_CALL: {
-    volatile VALUE idx;
-    idx = rb_funcallv_public(self, SYM2ID(info.symbol), argc-1, argv+1);
-    obj = rb_ca_fetch(self, idx);
-    break;
-  }
-  case CA_REG_MEMBER: {
-    volatile VALUE data_class = rb_ca_data_class(self);
-    if ( ! NIL_P(data_class) ) {
-      obj = rb_ca_face_field(self, info.symbol);
-      break;
-    }
-    else {
-      rb_raise(rb_eIndexError, 
-               "can't refer member of carray doesn't have data_class");
-    }
-    break;
-  }
-  default:
-    rb_raise(rb_eIndexError, "invalid index specified");
-  }
-
-  return obj;
+static VALUE
+rb_cs_store_method (int argc, VALUE *argv, VALUE self)
+{
+  rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
+  rb_cs_check_index(argc - 1, argv, "#[]=");
+  return rb_ca_store_method(argc, argv, self);
 }
 
 /* Recursively convert a store rvalue's surface value objects into
@@ -2443,6 +2405,7 @@ Init_carray_access (void)
   rb_define_method(rb_cCArray, "[]=", rb_ca_store_method, -1);
 
   rb_define_method(rb_cCScalar, "[]", rb_cs_fetch_method, -1);
+  rb_define_method(rb_cCScalar, "[]=", rb_cs_store_method, -1);
 
   rb_define_method(rb_cCArray, "fill", rb_ca_fill, 1);
   rb_define_method(rb_cCArray, "fill_copy", rb_ca_fill_copy, 1);