carray 3.0.0 → 3.0.2

data/ext/carray_access.c

@@ -19,7 +19,7 @@ static ID id_begin, id_end, id_excl_end;
 #define RANGE_EXCL(r) (rb_funcall(r, id_excl_end, 0))
 
 static ID id_to_ca;
-static VALUE sym_star, sym_perc, sym_under, sym_gt, sym_tilde;
+static VALUE sym_perc, sym_under, sym_gt, sym_tilde;
 static VALUE S_CAInfo;
 
 VALUE
@@ -492,6 +492,14 @@ rb_ca_ref_all (VALUE self, CAIndexInfo *info)
   return rb_funcall(self, rb_intern("refer"), 0);
 }
 
+static ID
+ca_id_expression_evaluator (void)
+{
+  static ID id = 0;
+  if ( ! id ) id = rb_intern("@expression_evaluator");
+  return id;
+}
+
 VALUE
 rb_ca_store_all (VALUE self, VALUE rval)
 {
@@ -515,16 +523,34 @@ rb_ca_store_all (VALUE self, VALUE rval)
     CArray *cv;
     TypedData_Get_Struct(rval, CArray, &carray_data_type, cv);
 
-    if ( cv->obj_type == CA_OBJ_UNBOUND_REPEAT ) {
-      rval = ca_ubrep_bind_with(rval, self);
-      TypedData_Get_Struct(rval, CArray, &carray_data_type, cv);
+    /* Where something is registered to compute an expression, and this is
+       one, it is asked before the walk below -- it fills the destination
+       directly, which is the whole of the saving; making an array and
+       copying it over is most of the work once the expression itself is
+       fast.  It may decline, and then the walk does it.  Narrow on purpose:
+       the same shape and data type, so nothing here has to broadcast or
+       cast on the way. */
+    if ( ca_is_lazy_view(cv)
+         && ca->data_type == cv->data_type
+         && ca->ndim == cv->ndim
+         && ca->elements == cv->elements
+         && RTEST(rb_attr_get(rb_cCArray, ca_id_expression_evaluator())) ) {
+      int8_t k;
+      int    same = 1;
+      for ( k = 0; k < ca->ndim; k++ ) {
+        if ( ca->dim[k] != cv->dim[k] ) { same = 0; break; }
+      }
+      if ( same ) {
+        VALUE fusion = rb_const_get(rb_cCArray, rb_intern("Fusion"));
+        if ( RTEST(rb_funcall(fusion, rb_intern("evaluate_into"), 2, rval, self)) ) {
+          return rval;
+        }
+      }
     }
 
-    if ( ca->elements != cv->elements ) {
-      rb_raise(rb_eRuntimeError,
-               "mismatch in data size (%" PRId64 " <-> %" PRId64 ") for storing to carray", 
-               (ca_size_t) ca->elements, (ca_size_t) cv->elements);
-    }
+    /* The destination owns the shape; see ca_broadcast_to_destination. */
+    ca_broadcast_to_destination(self, &rval);
+    TypedData_Get_Struct(rval, CArray, &carray_data_type, cv);
 
     /* Source delivery via ca_xfer_all into a local scratch instead of
        ca_attach(cv).  This routes through ca_*_func_xfer_all's per-region
@@ -985,7 +1011,16 @@ rb_ca_fetch_method (int argc, VALUE *argv, VALUE self)
 
   switch ( info.type ) {
   case CA_REG_ADDRESS_COMPLEX:
+    /* Re-enter against a flattened view of self.  rb_ca_refer_new_flatten
+       is an internal builder and hands back a bare refer, so a marker
+       receiver would be dropped here and the result would never be lifted
+       at the tail.  Put it back on before the re-entry.  (A Face survives
+       on its own -- the internal builder still lifts those.) */
     self = rb_ca_refer_new_flatten(self);
+    if ( ca_is_lazy_marker(ca) ) {
+      extern VALUE rb_ca_lazy_marker_new (VALUE cary);
+      self = rb_ca_lazy_marker_new(self);
+    }
     goto retry;
   case CA_REG_ADDRESS:
     obj = rb_ca_ref_address(self, &info);
@@ -1011,9 +1046,6 @@ rb_ca_fetch_method (int argc, VALUE *argv, VALUE self)
   case CA_REG_REPEAT:
     obj = rb_ca_repeat(argc, argv, self);
     break;
-  case CA_REG_UNBOUND_REPEAT:
-    obj = rb_funcall2(self, rb_intern("unbound_repeat"), (int) argc, argv);
-    break;
   case CA_REG_MAPPING:
     obj = rb_ca_fancy_index_chain(self, argv[0]);
     break;
@@ -1050,19 +1082,16 @@ rb_ca_fetch_method (int argc, VALUE *argv, VALUE self)
     rb_raise(rb_eIndexError, "invalid index specified");
   }
 
-  /* Face lift at the read touch point: if `self` is a Face, re-wrap the
-     view result as a Face (ca_face_lift).  Guards: lift only when the result
-     is a CArray instance (excludes Hash / iterator / scalar), and only when
-     it is not ALREADY a Face -- some builders (select / repeat / ...) lift
-     their own result, so re-lifting here would double-wrap and leave `.parent`
-     pointing at a Face instead of the storage. */
-  if ( ca_is_face(ca) && rb_obj_is_kind_of(obj, rb_cCArray) ) {
-    CArray *obj_ca;
-    TypedData_Get_Struct(obj, CArray, &carray_data_type, obj_ca);
-    if ( ! ca_is_face(obj_ca) ) {
-      obj = ca_face_lift(obj, self);
-    }
-  }
+  /* Wrapper lift at the read touch point: if `self` is a Face or a
+     CALazyMarker, re-wrap the view result so the wrapper stays on top.
+     Guarded to CArray results, which drops the scalar / CASlabIterator /
+     CAGroupIterator / Hash cases the switch above can produce.  The
+     already-a-Face case (some builders lift their own result) is handled
+     inside ca_wrapper_lift.
+
+     Every CA_REG_* branch converges here, so this one line covers every
+     index form that returns a CArray. */
+  CA_WRAPPER_LIFT(obj, self, ca);
 
   return obj;
 }
@@ -1075,6 +1104,8 @@ rb_ca_fetch_newaxis (int argc, VALUE *argv, VALUE self, CArray *ca)
 {
   int i;
   int nclean = 0;
+  int nscalar = 0;
+  int nunder = 0;
   VALUE clean[CA_RANK_MAX];
   volatile VALUE base;
   ca_size_t final_dims[CA_RANK_MAX];
@@ -1086,11 +1117,17 @@ rb_ca_fetch_newaxis (int argc, VALUE *argv, VALUE self, CArray *ca)
   /* Build clean argv (strip :_); reject disjoint sigils + rubber dim. */
   for (i = 0; i < argc; i++) {
     VALUE a = argv[i];
-    if ( a == sym_under ) continue;
-    if ( a == sym_gt || a == sym_star || a == sym_perc
+    if ( a == sym_under ) {
+      nunder++;
+      continue;
+    }
+    if ( FIXNUM_P(a) || RB_TYPE_P(a, T_BIGNUM) ) {
+      nscalar++;
+    }
+    if ( a == sym_gt || a == sym_perc
          || a == Qfalse || a == sym_tilde ) {
       rb_raise(rb_eIndexError,
-               "newaxis (:_) cannot be combined with :>, :*, :%%, "
+               "newaxis (:_) cannot be combined with :>, :%%, "
                "or rubber dim (false / :~)");
     }
     if ( nclean >= CA_RANK_MAX ) {
@@ -1108,18 +1145,26 @@ rb_ca_fetch_newaxis (int argc, VALUE *argv, VALUE self, CArray *ca)
              nclean, (int) ca->ndim);
   }
 
-  base = rb_ca_fetch_method(nclean, clean, self);
-
-  /* Degenerate: all real axes scalar -> base is a scalar element, not a
-     CArray.  Out of scope (rare + degenerate); user indexes the element
-     and reshapes explicitly.  IndexError keeps it catchable + consistent
-     with the other newaxis rejects. */
-  if ( ! rb_obj_is_kind_of(base, rb_cCArray) ) {
-    rb_raise(rb_eIndexError,
-             "newaxis (:_) needs at least one non-scalar axis "
-             "(all-scalar indexing yields a single element)");
+  /* Every real axis indexed by a scalar: fetching `clean` would yield the
+     element itself, and there would be nothing left to reshape.  Ask for a
+     length-1 block on each axis instead, so the base stays a CArray and the
+     result is a view into self.  The result carries exactly the axes :_ asked
+     for, all of length 1 -- an operand that states rank nunder and one
+     element, which is what the shape rules then hold it to. */
+  if ( nscalar == nclean ) {
+    VALUE blocks[CA_RANK_MAX];
+    for (i = 0; i < nclean; i++) {
+      blocks[i] = rb_assoc_new(clean[i], INT2FIX(1));
+    }
+    base = rb_ca_fetch_method(nclean, blocks, self);
+    for (i = 0; i < nunder; i++) {
+      dim_argv[i] = INT2FIX(1);
+    }
+    return rb_ca_reshape(nunder, dim_argv, base);
   }
 
+  base = rb_ca_fetch_method(nclean, clean, self);
+
   TypedData_Get_Struct(base, CArray, &carray_data_type, cb);
 
   /* Reconstruct final shape: walk original argv.  :_ -> size-1, scalar
@@ -1305,9 +1350,6 @@ rb_cs_fetch_method (int argc, VALUE *argv, VALUE self)
   case CA_REG_REPEAT:
     obj = rb_ca_repeat(argc, argv, self);
     break;
-  case CA_REG_UNBOUND_REPEAT:
-    obj = rb_funcall2(self, rb_intern("unbound_repeat"), (int) argc, argv);
-    break;
   case CA_REG_MAPPING:
     obj = rb_ca_fancy_index_chain(self, argv[0]);
     break;
@@ -1491,10 +1533,6 @@ rb_ca_store_method (int argc, VALUE *argv, VALUE self)
     obj = rb_ca_store_all(obj, rval);
     break;
   }
-  case CA_REG_UNBOUND_REPEAT:
-    obj = rb_funcall2(self, rb_intern("unbound_repeat"), (int) argc, argv);
-    obj = rb_ca_store_all(obj, rval);
-    break;
   case CA_REG_MAPPING: {
     obj = rb_ca_fancy_index_chain(self, argv[0]);
     obj = rb_ca_store_all(obj, rval);
@@ -1669,7 +1707,6 @@ rb_ca_s_scan_index (VALUE self, VALUE rdim, VALUE ridx)
   case CA_REG_GRID:
   case CA_REG_MAPPING:
   case CA_REG_METHOD_CALL:
-  case CA_REG_UNBOUND_REPEAT:
   case CA_REG_MEMBER:  
   case CA_REG_ATTRIBUTE:  
     break;
@@ -2052,7 +2089,6 @@ Init_carray_access (void)
   id_excl_end = rb_intern("exclude_end?");
 
   id_to_ca = rb_intern("to_ca");
-  sym_star  = ID2SYM(rb_intern("*"));
   sym_perc  = ID2SYM(rb_intern("%"));
   sym_under = ID2SYM(rb_intern("_"));
   sym_gt    = ID2SYM(rb_intern(">"));
@@ -2094,8 +2130,6 @@ Init_carray_access (void)
   rb_define_const(rb_cObject, "CA_REG_MAPPING",  INT2NUM(CA_REG_MAPPING));
   rb_define_const(rb_cObject, "CA_REG_METHOD_CALL",
                                                  INT2NUM(CA_REG_METHOD_CALL));
-  rb_define_const(rb_cObject, "CA_REG_UNBOUND_REPEAT",
-                                                 INT2NUM(CA_REG_UNBOUND_REPEAT));
   rb_define_const(rb_cObject, "CA_REG_MEMBER",   INT2NUM(CA_REG_MEMBER));
   rb_define_const(rb_cObject, "CA_REG_ATTRIBUTE",   INT2NUM(CA_REG_ATTRIBUTE));