carray 3.0.0 → 3.0.1

data/ext/carray_access.c

@@ -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,19 @@ 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 all of
+     them -- but not every index form: `a[:*, nil]` builds a CAUnboundRepeat,
+     whose shape stays open until an operand binds it, and a marker copies
+     shape at construction.  ca_wrapper_lift refuses that one, in one place,
+     because `unbound_repeat` reaches it by a second route. */
+  CA_WRAPPER_LIFT(obj, self, ca);
 
   return obj;
 }
@@ -1305,9 +1337,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 +1520,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 +1694,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;
@@ -2094,8 +2118,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));
 

data/ext/carray_bincount.c

@@ -3,11 +3,11 @@
   carray_bincount.c — dedicated bincount kernels (count-only + weighted)
 
   Tight per-element scatter into a pre-sized 1-D output buffer.  The
-  inner loop reads labels in their native integer dtype (no cast to
+  inner loop reads labels in their native integer data type (no cast to
   int64), skips per-iteration bounds checking (caller validates label
-  range), and emits the output dtype directly.
+  range), and emits the output data type directly.
 
-  Output dtype:
+  Output data type:
     - count-only:   UInt32 if length < 2^32, else UInt64.
     - weighted:     weights.data_type.
 
@@ -15,7 +15,7 @@
   weight is also skipped (its label contributes 0).
 
   Caller contract (= lib/carray/methods/bincount.rb's CArray#bincount):
-    - self is integer dtype.
+    - self is integer data type.
     - length is the output size, pre-sized to max(length, label_max+1)
       with label_min >= 0 already verified.
 
@@ -30,8 +30,8 @@
 
 #include "carray.h"
 
-/* Tight inner loop: 2 mask-aware variants × 8 label dtypes × 2 output
-   dtypes = 32 specializations.  Generated via macro expansion.
+/* Tight inner loop: 2 mask-aware variants × 8 label data types × 2 output
+   data types = 32 specializations.  Generated via macro expansion.
 
    Layout:
      COUNT_KERNEL(LABEL_T, OUT_T)
@@ -91,7 +91,7 @@ rb_ca_bincount_count_kernel (VALUE self, VALUE rlength)
     rb_raise(rb_eArgError, "bincount: length must be non-negative");
   }
 
-  /* Output dtype: UInt32 default; UInt64 if length doesn't fit. */
+  /* Output data type: UInt32 default; UInt64 if length doesn't fit. */
   out_type = (length > 0xFFFFFFFFLL) ? CA_UINT64 : CA_UINT32;
   shape_out[0] = length;
   vout = rb_carray_new(out_type, 1, shape_out, 0, NULL);
@@ -125,7 +125,7 @@ rb_ca_bincount_count_kernel (VALUE self, VALUE rlength)
 
 /* --------------------------------------------------------------- */
 
-/* Weighted variant: output dtype = weights dtype.
+/* Weighted variant: output data type = weights data type.
    Inner: out[label[i]] += weight[i].
    Mask: skip if label[i] masked OR weight[i] masked. */
 

data/ext/carray_broadcast.c

@@ -12,10 +12,12 @@
     ca_broadcast_pair (&self, &other)
         Two-sided expansion for binary ops (case A only: same ndim,
         size-1 axes broadcast pairwise).  Leaves both operands
-        unchanged when shapes are already equal or when they are
-        incompatible (the caller's existing elements-mismatch raise
-        path then handles the error).  Called by carray_cast.c's
-        coercion path and by the binop dispatcher.
+        unchanged when shapes are already equal, and raises when they
+        cannot be paired: both operands of a binary operation are
+        equally authoritative, so a shape conflict has no resolution.
+        Called by carray_cast.c's coercion path and by the binop,
+        bincmp and triop builders, which is every place two operands
+        are brought together.
 
     rb_ca_broadcast_to -- backs the public CArray#broadcast_to method
         (right-to-left axis pairing; see the docstring at the function).
@@ -29,6 +31,75 @@
 
 #include "carray.h"
 
+NORETURN(static void ca_broadcast_refuse_write (VALUE dst, VALUE src));
+
+/* Report a source that cannot be brought to the destination's shape. */
+static void
+ca_broadcast_refuse_write (VALUE dst, VALUE src)
+{
+  volatile VALUE dst_s = rb_inspect(rb_funcall(dst, rb_intern("shape"), 0));
+  volatile VALUE src_s = rb_inspect(rb_funcall(src, rb_intern("shape"), 0));
+  rb_raise(rb_eRuntimeError,
+           "shape mismatch writing to carray (%s <- %s); shapes must agree "
+           "once size-1 axes are dropped, or one side must be 1-D, or the "
+           "source must be smaller and broadcastable -- use .flatten to "
+           "write the values in the order they lie",
+           StringValueCStr(dst_s), StringValueCStr(src_s));
+}
+
+/* Bring `*src` to `dst`'s shape for a write into `dst` (assignment, and
+   the in-place operators, whose result shape is the destination's by
+   definition).  The destination owns the shape and the source only
+   supplies values, so what is allowed here is wider than what two
+   operands of a binary operation may do -- but only where nothing is
+   duplicated.  When the counts already agree the values land in the
+   order they lie and the shape is merely a reading of them: shapes that
+   both sides claim must agree once size-1 axes are dropped, since such
+   an axis moves no element, and a 1-D side claims no shape at all,
+   whether it is the flat source or the flat container.  When the source
+   is smaller it is repeated instead, and that is held to same-ndim
+   size-1 and is one-sided: the destination never grows.  Raises when
+   neither reading applies. */
+void
+ca_broadcast_to_destination (VALUE dst, volatile VALUE *src)
+{
+  CArray *cd, *cs;
+
+  TypedData_Get_Struct(dst,   CArray, &carray_data_type, cd);
+  TypedData_Get_Struct(*src,  CArray, &carray_data_type, cs);
+
+  if ( cs->elements == cd->elements ) {
+    ca_size_t dst_dim[CA_RANK_MAX], src_dim[CA_RANK_MAX];
+    int dst_ndim = 0, src_ndim = 0, i, agree;
+    if ( cd->ndim <= 1 || cs->ndim <= 1 ) return;
+    for ( i = 0; i < cd->ndim; i++ ) {
+      if ( cd->dim[i] != 1 ) dst_dim[dst_ndim++] = cd->dim[i];
+    }
+    for ( i = 0; i < cs->ndim; i++ ) {
+      if ( cs->dim[i] != 1 ) src_dim[src_ndim++] = cs->dim[i];
+    }
+    agree = ( dst_ndim == src_ndim );
+    for ( i = 0; agree && i < dst_ndim; i++ ) {
+      if ( dst_dim[i] != src_dim[i] ) agree = 0;
+    }
+    if ( ! agree ) ca_broadcast_refuse_write(dst, *src);
+    return;
+  }
+
+  if ( cs->elements < cd->elements && cs->ndim == cd->ndim ) {
+    int i;
+    for ( i = 0; i < cd->ndim; i++ ) {
+      if ( cs->dim[i] != cd->dim[i] && cs->dim[i] != 1 ) break;
+    }
+    if ( i == cd->ndim ) {
+      *src = ca_broadcast_view(*src, cd->ndim, cd->dim);
+      return;
+    }
+  }
+
+  ca_broadcast_refuse_write(dst, *src);
+}
+
 /* Build a CAStride view of `src` with shape `target_dim`.  For each
    axis where src.dim[i] == target_dim[i], inherit the row-major byte
    stride; for src.dim[i] == 1 and target_dim[i] > 1, use stride 0.
@@ -99,6 +170,24 @@ ca_broadcast_view (VALUE src, int8_t ndim, ca_size_t *target_dim)
    pairwise equal, no-op.  If any axis pair is incompatible (neither
    side is 1 nor equal), no-op (caller's existing element-count check
    raises). */
+NORETURN(static void ca_broadcast_refuse (VALUE self, VALUE other));
+
+/* Report a pair that cannot be brought to a common shape.  Naming both
+   shapes is the point of the message: the caller wrote two arrays that
+   cannot be combined, and the only remedy is to say which two. */
+static void
+ca_broadcast_refuse (VALUE self, VALUE other)
+{
+  volatile VALUE self_s  = rb_inspect(rb_funcall(self,  rb_intern("shape"), 0));
+  volatile VALUE other_s = rb_inspect(rb_funcall(other, rb_intern("shape"), 0));
+  rb_raise(rb_eArgError,
+           "shape mismatch between operands (%s and %s); shapes must "
+           "agree, or differ only in size-1 axes with equal ndim -- use "
+           ".flatten on both sides to operate on the values in the order "
+           "they lie",
+           StringValueCStr(self_s), StringValueCStr(other_s));
+}
+
 void
 ca_broadcast_pair (volatile VALUE *self, volatile VALUE *other)
 {
@@ -111,8 +200,11 @@ ca_broadcast_pair (volatile VALUE *self, volatile VALUE *other)
   TypedData_Get_Struct(*self,  CArray, &carray_data_type, ca);
   TypedData_Get_Struct(*other, CArray, &carray_data_type, cb);
 
+  /* A scalar carries no shape and reaches every cell; leave the pair to
+     the caller's own scalar handling.  A one-element array is not a
+     scalar: it states a shape, and is held to it. */
   if (ca_is_scalar(ca) || ca_is_scalar(cb)) return;
-  if (ca->ndim != cb->ndim) return;
+  if (ca->ndim != cb->ndim) ca_broadcast_refuse(*self, *other);
   if (ca->ndim == 0) return;
 
   for (i = 0; i < ca->ndim; i++) {
@@ -133,7 +225,8 @@ ca_broadcast_pair (volatile VALUE *self, volatile VALUE *other)
     }
   }
 
-  if (!can_broadcast || !needs_broadcast) return;
+  if (!can_broadcast) ca_broadcast_refuse(*self, *other);
+  if (!needs_broadcast) return;
 
   *self  = ca_broadcast_view(*self,  ca->ndim, target_dim);
   *other = ca_broadcast_view(*other, ca->ndim, target_dim);

data/ext/carray_build_flags.h

@@ -0,0 +1,3 @@
+/* GENERATED by extconf.rb: the flags this build's arithmetic
+   was compiled with.  See CArray::BUILD_FLAGS. */
+#define CA_BUILD_FLAGS "-O3 -fno-fast-math -fopenmp-simd -march=native"