carray 3.0.1 → 3.0.2

data/ext/carray_kernels_scan.c

@@ -1810,7 +1810,7 @@ cummax_ki_native_f32 (VALUE self, CArray *ca, int axis)
             ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(float, float, st_in, pi, mi,
-                         st_out, po, mo_fiber, -INFINITY, if (v > acc) acc = v; r = acc);
+                         st_out, po, mo_fiber, NAN, acc = fmax(acc, v); r = acc);
     ca_iter_state_sync_slab(&st_out);
   }
   ca_iter_state_finish(&st_in);
@@ -1862,7 +1862,7 @@ cummax_ki_native_f64 (VALUE self, CArray *ca, int axis)
             ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(double, double, st_in, pi, mi,
-                         st_out, po, mo_fiber, -INFINITY, if (v > acc) acc = v; r = acc);
+                         st_out, po, mo_fiber, NAN, acc = fmax(acc, v); r = acc);
     ca_iter_state_sync_slab(&st_out);
   }
   ca_iter_state_finish(&st_in);
@@ -2498,7 +2498,7 @@ cummin_ki_native_f32 (VALUE self, CArray *ca, int axis)
             ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(float, float, st_in, pi, mi,
-                         st_out, po, mo_fiber, INFINITY, if (v < acc) acc = v; r = acc);
+                         st_out, po, mo_fiber, NAN, acc = fmin(acc, v); r = acc);
     ca_iter_state_sync_slab(&st_out);
   }
   ca_iter_state_finish(&st_in);
@@ -2550,7 +2550,7 @@ cummin_ki_native_f64 (VALUE self, CArray *ca, int axis)
             ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(double, double, st_in, pi, mi,
-                         st_out, po, mo_fiber, INFINITY, if (v < acc) acc = v; r = acc);
+                         st_out, po, mo_fiber, NAN, acc = fmin(acc, v); r = acc);
     ca_iter_state_sync_slab(&st_out);
   }
   ca_iter_state_finish(&st_in);

data/ext/carray_kernels_search.c

@@ -4247,7 +4247,7 @@ rb_ca_find_value_index_ki (VALUE self, VALUE rval, VALUE raxis)
     }
     if ( self_face_comparable ) {
       if ( rval_is_face ) {
-        rval = rb_ca_strip_face_value(rval);
+        rval = ca_face_operand_descend(rval, "find_value_index_ki");
       }
     } else if ( self_was_face ) {
       if ( rb_respond_to(self_ref, rb_intern("to_comparable")) ) {
@@ -8724,7 +8724,7 @@ rb_ca_bsearch_ki (VALUE self, VALUE rval, VALUE raxis)
     }
     if ( self_face_comparable ) {
       if ( rval_is_face ) {
-        rval = rb_ca_strip_face_value(rval);
+        rval = ca_face_operand_descend(rval, "bsearch_ki");
       }
     } else if ( self_was_face ) {
       if ( rb_respond_to(self_ref, rb_intern("to_comparable")) ) {
@@ -13046,7 +13046,7 @@ rb_ca_search_ki (int argc, VALUE *argv, VALUE self)
     }
     if ( self_face_comparable ) {
       if ( rval_is_face ) {
-        rval = rb_ca_strip_face_value(rval);
+        rval = ca_face_operand_descend(rval, "search_ki");
       }
     } else if ( self_was_face ) {
       if ( rb_respond_to(self_ref, rb_intern("to_comparable")) ) {
@@ -16724,12 +16724,32 @@ search_nearest_ki_native_object (VALUE self, CArray *ca, VALUE rval, int axis)
       {
         /* CA_OBJECT nearest: minimum of query_val.distance(cell), compared
            with `<` (matches the legacy flat proc_nearest_addr_VALUE). */
+        /* Nearest needs a metric.  #distance is the protocol the 2.0 flat
+           kernel used, back when Numeric#distance was a monkey patch; it
+           is an opt-in refinement now, and a refinement does not reach an
+           rb_funcall from C -- so a number reaching here answers no more
+           than a String does.  Measure a number the way #distance itself
+           does, keep #distance for anything that defines a real one, and
+           refuse the rest by name rather than let a bare NoMethodError out
+           of the loop below. */
+        ID nearest_id = rb_intern("distance");
+        int nearest_by_distance = rb_respond_to(query_val, nearest_id);
+        if ( ! nearest_by_distance && ! rb_obj_is_kind_of(query_val, rb_cNumeric) ) {
+          rb_raise(rb_eCADataTypeError,
+                   "search_nearest: nearest needs a distance, and %s is neither a "
+                   "number nor answers #distance (define one on the stored "
+                   "objects, or use search / bsearch for an exact match)",
+                   rb_obj_classname(query_val));
+        }
         result = (ca_size_t) -1;
         VALUE best = Qnil;
         for ( ca_size_t i = 0; i < slab_n; i++ ) {
           if ( mask_in && mask_in[i * slab_mask_stride] ) continue;
           VALUE v = *(VALUE *)(slab_ptr + i * slab_stride);
-          VALUE dist = rb_funcall(query_val, rb_intern("distance"), 1, v);
+          VALUE dist = nearest_by_distance
+                     ? rb_funcall(query_val, nearest_id, 1, v)
+                     : rb_funcall(rb_funcall(query_val, '-', 1, v),
+                                  rb_intern("abs"), 0);
           if ( NIL_P(best) || RTEST(rb_funcall(dist, rb_intern("<"), 1, best)) ) {
             best = dist; result = i;
           }
@@ -16975,12 +16995,32 @@ search_nearest_ki_native_object (VALUE self, CArray *ca, VALUE rval, int axis)
     {
           /* CA_OBJECT nearest: minimum of query_val.distance(cell), compared
              with `<` (matches the legacy flat proc_nearest_addr_VALUE). */
+          /* Nearest needs a metric.  #distance is the protocol the 2.0 flat
+             kernel used, back when Numeric#distance was a monkey patch; it
+             is an opt-in refinement now, and a refinement does not reach an
+             rb_funcall from C -- so a number reaching here answers no more
+             than a String does.  Measure a number the way #distance itself
+             does, keep #distance for anything that defines a real one, and
+             refuse the rest by name rather than let a bare NoMethodError out
+             of the loop below. */
+          ID nearest_id = rb_intern("distance");
+          int nearest_by_distance = rb_respond_to(query_val, nearest_id);
+          if ( ! nearest_by_distance && ! rb_obj_is_kind_of(query_val, rb_cNumeric) ) {
+            rb_raise(rb_eCADataTypeError,
+                     "search_nearest: nearest needs a distance, and %s is neither a "
+                     "number nor answers #distance (define one on the stored "
+                     "objects, or use search / bsearch for an exact match)",
+                     rb_obj_classname(query_val));
+          }
           result = (ca_size_t) -1;
           VALUE best = Qnil;
           for ( ca_size_t i = 0; i < slab_n; i++ ) {
             if ( mask_in && mask_in[i * slab_mask_stride] ) continue;
             VALUE v = *(VALUE *)(slab_ptr + i * slab_stride);
-            VALUE dist = rb_funcall(query_val, rb_intern("distance"), 1, v);
+            VALUE dist = nearest_by_distance
+                       ? rb_funcall(query_val, nearest_id, 1, v)
+                       : rb_funcall(rb_funcall(query_val, '-', 1, v),
+                                    rb_intern("abs"), 0);
             if ( NIL_P(best) || RTEST(rb_funcall(dist, rb_intern("<"), 1, best)) ) {
               best = dist; result = i;
             }
@@ -17055,7 +17095,7 @@ rb_ca_search_nearest_ki (VALUE self, VALUE rval, VALUE raxis)
     }
     if ( self_face_comparable ) {
       if ( rval_is_face ) {
-        rval = rb_ca_strip_face_value(rval);
+        rval = ca_face_operand_descend(rval, "search_nearest_ki");
       }
     } else if ( self_was_face ) {
       if ( rb_respond_to(self_ref, rb_intern("to_comparable")) ) {
@@ -21801,7 +21841,7 @@ rb_ca_bsearch_addr_ki (VALUE self, VALUE rval, VALUE raxis)
     }
     if ( self_face_comparable ) {
       if ( rval_is_face ) {
-        rval = rb_ca_strip_face_value(rval);
+        rval = ca_face_operand_descend(rval, "bsearch_addr_ki");
       }
     } else if ( self_was_face ) {
       if ( rb_respond_to(self_ref, rb_intern("to_comparable")) ) {
@@ -26403,7 +26443,7 @@ rb_ca_search_addr_ki (int argc, VALUE *argv, VALUE self)
     }
     if ( self_face_comparable ) {
       if ( rval_is_face ) {
-        rval = rb_ca_strip_face_value(rval);
+        rval = ca_face_operand_descend(rval, "search_addr_ki");
       }
     } else if ( self_was_face ) {
       if ( rb_respond_to(self_ref, rb_intern("to_comparable")) ) {
@@ -30338,12 +30378,32 @@ for ( int8_t mm = 0; mm < st.outer_ndim; mm++ ) {
       {
         /* CA_OBJECT nearest (view_flat addr): minimum of
            query_val.distance(cell), compared with `<`. */
+        /* Nearest needs a metric.  #distance is the protocol the 2.0 flat
+           kernel used, back when Numeric#distance was a monkey patch; it
+           is an opt-in refinement now, and a refinement does not reach an
+           rb_funcall from C -- so a number reaching here answers no more
+           than a String does.  Measure a number the way #distance itself
+           does, keep #distance for anything that defines a real one, and
+           refuse the rest by name rather than let a bare NoMethodError out
+           of the loop below. */
+        ID nearest_id = rb_intern("distance");
+        int nearest_by_distance = rb_respond_to(query_val, nearest_id);
+        if ( ! nearest_by_distance && ! rb_obj_is_kind_of(query_val, rb_cNumeric) ) {
+          rb_raise(rb_eCADataTypeError,
+                   "search_nearest_addr: nearest needs a distance, and %s is neither a "
+                   "number nor answers #distance (define one on the stored "
+                   "objects, or use search / bsearch for an exact match)",
+                   rb_obj_classname(query_val));
+        }
         result = (ca_size_t) -1;
         VALUE best = Qnil;
         for ( ca_size_t i = 0; i < slab_n; i++ ) {
           if ( mask_in && mask_in[i * slab_mask_stride] ) continue;
           VALUE v = *(VALUE *)(slab_ptr + i * slab_stride);
-          VALUE dist = rb_funcall(query_val, rb_intern("distance"), 1, v);
+          VALUE dist = nearest_by_distance
+                     ? rb_funcall(query_val, nearest_id, 1, v)
+                     : rb_funcall(rb_funcall(query_val, '-', 1, v),
+                                  rb_intern("abs"), 0);
           if ( NIL_P(best) || RTEST(rb_funcall(dist, rb_intern("<"), 1, best)) ) {
             best = dist; result = i;
           }
@@ -30596,12 +30656,32 @@ rb_raise(rb_eNotImpError, "search_nearest_addr_ki: view_flat semantics with CArr
     {
           /* CA_OBJECT nearest (view_flat addr): minimum of
              query_val.distance(cell), compared with `<`. */
+          /* Nearest needs a metric.  #distance is the protocol the 2.0 flat
+             kernel used, back when Numeric#distance was a monkey patch; it
+             is an opt-in refinement now, and a refinement does not reach an
+             rb_funcall from C -- so a number reaching here answers no more
+             than a String does.  Measure a number the way #distance itself
+             does, keep #distance for anything that defines a real one, and
+             refuse the rest by name rather than let a bare NoMethodError out
+             of the loop below. */
+          ID nearest_id = rb_intern("distance");
+          int nearest_by_distance = rb_respond_to(query_val, nearest_id);
+          if ( ! nearest_by_distance && ! rb_obj_is_kind_of(query_val, rb_cNumeric) ) {
+            rb_raise(rb_eCADataTypeError,
+                     "search_nearest_addr: nearest needs a distance, and %s is neither a "
+                     "number nor answers #distance (define one on the stored "
+                     "objects, or use search / bsearch for an exact match)",
+                     rb_obj_classname(query_val));
+          }
           result = (ca_size_t) -1;
           VALUE best = Qnil;
           for ( ca_size_t i = 0; i < slab_n; i++ ) {
             if ( mask_in && mask_in[i * slab_mask_stride] ) continue;
             VALUE v = *(VALUE *)(slab_ptr + i * slab_stride);
-            VALUE dist = rb_funcall(query_val, rb_intern("distance"), 1, v);
+            VALUE dist = nearest_by_distance
+                       ? rb_funcall(query_val, nearest_id, 1, v)
+                       : rb_funcall(rb_funcall(query_val, '-', 1, v),
+                                    rb_intern("abs"), 0);
             if ( NIL_P(best) || RTEST(rb_funcall(dist, rb_intern("<"), 1, best)) ) {
               best = dist; result = i;
             }
@@ -30676,7 +30756,7 @@ rb_ca_search_nearest_addr_ki (VALUE self, VALUE rval, VALUE raxis)
     }
     if ( self_face_comparable ) {
       if ( rval_is_face ) {
-        rval = rb_ca_strip_face_value(rval);
+        rval = ca_face_operand_descend(rval, "search_nearest_addr_ki");
       }
     } else if ( self_was_face ) {
       if ( rb_respond_to(self_ref, rb_intern("to_comparable")) ) {
@@ -31230,7 +31310,7 @@ rb_ca_linear_section_binary_ki (VALUE self, VALUE rval, VALUE raxis)
     }
     if ( self_face_comparable ) {
       if ( rval_is_face ) {
-        rval = rb_ca_strip_face_value(rval);
+        rval = ca_face_operand_descend(rval, "linear_section_binary_ki");
       }
     } else if ( self_was_face ) {
       if ( rb_respond_to(self_ref, rb_intern("to_comparable")) ) {
@@ -31679,7 +31759,7 @@ rb_ca_linear_section_linear_ki (VALUE self, VALUE rval, VALUE raxis)
     }
     if ( self_face_comparable ) {
       if ( rval_is_face ) {
-        rval = rb_ca_strip_face_value(rval);
+        rval = ca_face_operand_descend(rval, "linear_section_linear_ki");
       }
     } else if ( self_was_face ) {
       if ( rb_respond_to(self_ref, rb_intern("to_comparable")) ) {
@@ -32090,7 +32170,7 @@ rb_ca_linear_fetch_ki (VALUE self, VALUE rval, VALUE raxis)
     }
     if ( self_face_comparable ) {
       if ( rval_is_face ) {
-        rval = rb_ca_strip_face_value(rval);
+        rval = ca_face_operand_descend(rval, "linear_fetch_ki");
       }
     } else if ( self_was_face ) {
       if ( rb_respond_to(self_ref, rb_intern("to_comparable")) ) {

data/ext/carray_loop.c

@@ -120,6 +120,13 @@ rb_ca_index_walk (VALUE self, CArray *ca, int8_t level,
   volatile VALUE ret = Qnil;
   ca_size_t i;
   if ( level == ca->ndim - 1 ) {
+    /* One value-yield buffer for the whole innermost run.  It was once an
+       ALLOCA_N inside the loop, which never releases per iteration: the C
+       stack grew by (ndim + 1) VALUEs per cell and a long enough axis
+       raised SystemStackError (a 1-D each_with_index / map_with_index!
+       died around a million cells on the main stack, and far earlier on a
+       Thread's smaller one). */
+    VALUE argv[CA_RANK_MAX + 1];
     for (i=0; i<ca->dim[level]; i++) {
       volatile VALUE obj;
       idx[level] = i;
@@ -132,7 +139,6 @@ rb_ca_index_walk (VALUE self, CArray *ca, int8_t level,
          that want the whole subscript should write |*idx|. */
       if ( mode & CA_LOOP_WITH_VALUE ) {
         int argc = (int)ca->ndim + 1;
-        VALUE *argv = ALLOCA_N(VALUE, argc);
         argv[0] = rb_ca_fetch_index(self, idx);
         MEMCPY(argv + 1, RARRAY_CONST_PTR(ridx), VALUE, ca->ndim);
         obj = rb_yield_values2(argc, argv);

data/ext/carray_mask.c

@@ -660,32 +660,47 @@ ca_unmask (void *ap, char *fill_value)
   }
 }
 
-CArray *
-ca_unmask_copy (void *ap, char *fill_value)
-{
-  CArray *ca = (CArray *) ap;
+typedef struct {
+  CArray *ca;
   CArray *co;
+  char   *fill_value;
+} ca_unmask_copy_args_t;
+
+static VALUE
+ca_unmask_copy_fill (VALUE arg)
+{
+  ca_unmask_copy_args_t *a = (ca_unmask_copy_args_t *) arg;
+  CArray *ca = a->ca, *co = a->co;
   char *q;
   boolean8_t *m;
   ca_size_t i;
 
-  co = ca_template(ca);
   ca_copy_data(ca, co->ptr);
 
-  if ( fill_value && ca_has_mask(ca) ) {
+  if ( a->fill_value && ca_has_mask(ca) ) {
     ca_attach(ca);
     q = co->ptr;
     m = (boolean8_t *) ca->mask->ptr;
     for (i=0; i<ca->elements; i++) {
       if ( *m ) {
-        memcpy(q, fill_value, ca->bytes);
+        memcpy(q, a->fill_value, ca->bytes);
       }
       m++; q+=co->bytes;
     }
     ca_detach(ca);
   }
+  return Qnil;
+}
 
-  return co;
+CArray *
+ca_unmask_copy (void *ap, char *fill_value)
+{
+  ca_unmask_copy_args_t a;
+  a.ca         = (CArray *) ap;
+  a.co         = ca_template(a.ca);
+  a.fill_value = fill_value;
+  ca_fill_or_free(a.co, ca_unmask_copy_fill, (VALUE) &a);
+  return a.co;
 }
 
 void

data/ext/carray_median_percentile.c

@@ -336,6 +336,48 @@ median_flat (VALUE self, long min_count, VALUE fill_value, int keep_axis)
    Every function in this block (down to the median entry) is [object].
    ===================================================================== */
 
+/* [object] Is this operand's arithmetic the arithmetic interpolation means?
+   `lo` / `hi` are a stored object on the flat path and an object CArray of
+   them on the per-axis one, so look through a CArray to an element.  An
+   empty one has nothing to interpolate and passes. */
+static int
+mp_object_interpolates (VALUE v)
+{
+  if ( rb_obj_is_kind_of(v, rb_cNumeric) ) {
+    return 1;
+  }
+  if ( rb_obj_is_kind_of(v, rb_cCArray) ) {
+    CArray *ca;
+    GetCArray(v, ca);
+    if ( ca->elements == 0 ) {
+      return 1;
+    }
+    return rb_obj_is_kind_of(rb_ca_fetch_addr(v, 0), rb_cNumeric) ? 1 : 0;
+  }
+  return 0;
+}
+
+/* [object] Refuse to interpolate between two elements that have no
+   arithmetic meaning it.  A String has both a `*` and a `+`, and
+   String#* truncates the Float weight to zero -- so :linear quietly
+   returned "" instead of failing, which is the reason this guard is
+   here rather than a rescue.  The three picking methods need no
+   arithmetic and are the way through. */
+static void
+mp_require_interpolable (const char *who, VALUE method, VALUE lo)
+{
+  if ( mp_object_interpolates(lo) ) {
+    return;
+  }
+  rb_raise(rb_eCADataTypeError,
+           "%s: method: :%s interpolates between two elements, which %s "
+           "does not support; use method: :lower, :higher or :nearest to "
+           "pick an element instead",
+           who, rb_id2name(SYM2ID(method)),
+           rb_obj_classname(rb_obj_is_kind_of(lo, rb_cCArray)
+                            ? rb_ca_fetch_addr(lo, 0) : lo));
+}
+
 /* [object] recv.mid(axis: raxis) -- e.g. min/max/sort along an axis. */
 static VALUE
 obj_call_axis (VALUE recv, ID mid, VALUE raxis)
@@ -419,6 +461,17 @@ median_object_axis (VALUE self, long axis, long n, int keep_axis)
     long k = n / 2 - 1;
     VALUE lo, hi;
     obj_kth_pair(self, axis, k, n, &lo, &hi);
+    /* An even count has no middle element, only the average of two -- so
+       a column whose objects have no arithmetic has a median only at odd
+       length.  percentile(50, method: :lower) names one either way. */
+    if ( ! mp_object_interpolates(lo) ) {
+      rb_raise(rb_eCADataTypeError,
+               "median: an even number of elements has no middle one, and "
+               "%s cannot be averaged; use percentile(50, method: :lower) "
+               "(or :higher / :nearest) to pick an element instead",
+               rb_obj_classname(rb_obj_is_kind_of(lo, rb_cCArray)
+                                ? rb_ca_fetch_addr(lo, 0) : lo));
+    }
     result = rb_funcall(rb_funcall(lo, id_plus, 1, hi), id_div, 1, DBL2NUM(2.0));
   } else {
     VALUE kv = obj_kth_one(self, axis, (n - 1) / 2);
@@ -480,12 +533,14 @@ pct_compute_object (VALUE method, long k, double r, long n, VALUE lo, VALUE hi)
   }
   if ( method == sym_linear ) {
     if ( r == 0.0 || k + 1 >= n ) return rb_funcall(lo, id_mul, 1, DBL2NUM(1.0));
+    mp_require_interpolable("percentile", method, lo);
     VALUE a = rb_funcall(lo, id_mul, 1, DBL2NUM(1.0 - r));
     VALUE b = rb_funcall(hi, id_mul, 1, DBL2NUM(r));
     return rb_funcall(a, id_plus, 1, b);
   }
   if ( method == sym_midpoint ) {
     if ( k + 1 >= n ) return rb_funcall(lo, id_mul, 1, DBL2NUM(1.0));
+    mp_require_interpolable("percentile", method, lo);
     return rb_funcall(rb_funcall(lo, id_plus, 1, hi), id_div, 1, DBL2NUM(2.0));
   }
   rb_raise(rb_eArgError, "percentile: invalid method (BUG)");

data/ext/carray_operator.c

@@ -633,7 +633,7 @@ rb_ca_call_binop (volatile VALUE self, volatile VALUE other,
   ca_size_t i1, i2, i3;
   int fast_path;
 
-  /* do implicit casting and resolving unbound repeat array */
+  /* do implicit casting */
   rb_ca_cast_self_or_other(&self, &other);
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca1);
@@ -1030,7 +1030,7 @@ rb_ca_call_binop_bang (VALUE self, VALUE other, ca_binop_func_t func[])
 
   rb_ca_modify(self);
 
-  /* do implicit casting and resolving unbound repeat array */
+  /* do implicit casting */
   rb_ca_cast_other(&self, &other);
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca1);
@@ -1572,7 +1572,7 @@ rb_ca_call_bincmp (volatile VALUE self, volatile VALUE other,
      for fixlen-storage Faces (memcmp is already correct there). */
   ca_face_reconcile_comparison(&self, &other);
 
-  /* do implicit casting and resolving unbound repeat array */
+  /* do implicit casting */
   rb_ca_cast_self_or_other(&self, &other);
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca1);
@@ -1804,7 +1804,7 @@ rb_ca_coerce (VALUE self, VALUE other)
     return rb_ca_coerce(self, rb_funcall(other,rb_intern("to_ca"),0));
   }
   else {
-    /* do implicit casting and resolving unbound repeat array */
+    /* do implicit casting */
     rb_ca_cast_self_or_other(&self, &other);
     return rb_assoc_new(other, self);
   }

data/ext/carray_order.c

@@ -854,7 +854,7 @@ rb_ca_linear_section_m (int argc, VALUE *argv, VALUE self)
     }
     if ( self_comparable ) {
       if ( val_is_face ) {
-        val = rb_ca_strip_face_value(val);
+        val = ca_face_operand_descend(val, "linear_section");
       }
     }
     else if ( self_is_face ) {