carray 3.0.6 → 3.0.7

data/ext/carray_order.c

@@ -169,7 +169,7 @@ ca_project (CArray *ca, CArray *ci, char *lfill, char *ufill)
   else             CA_COUNT_BELOW_LOOP(T, <)
 
 static VALUE
-rb_ca_count_below (VALUE self, VALUE vq, VALUE vinclusive)
+rb_ca_count_below (VALUE self, volatile VALUE vq, VALUE vinclusive)
 {
   volatile VALUE vout;
   CArray *cr, *cq, *co;
@@ -387,7 +387,7 @@ extern VALUE rb_ca_rank_index_ki_kind_dense (VALUE self, VALUE vaxis, int stable
  * search_kw / search_nearest_kw and their _addr siblings) on the
  * no-axis path. */
 static VALUE
-ca_reshape_search_result (VALUE query, VALUE rraw)
+ca_reshape_search_result (volatile VALUE query, VALUE rraw)
 {
   CArray *cq;
   GetCArray(query, cq);
@@ -441,6 +441,28 @@ rb_ca_bsearch_addr_kw (int argc, VALUE *argv, VALUE self)
   return rb_ca_bsearch_addr_ki(self, argv[0], raxis);
 }
 
+/* The query of search as the array reads it.  true and false are 1 and 0
+   to a numeric array.  A value the array can not hold (nil, a String)
+   finds nothing, as an Integer outside the array's type does.  The query is asked of the
+   cells that matched (none), in the type that holds the answer.  A Face that
+   can not be searched is refused as for any query, and a complex array,
+   which search does not take, goes on to its refusal. */
+static void
+ca_search_query_read (VALUE *pself, VALUE *pquery)
+{
+  CArray *ca;
+  GetCArray(*pself, ca);
+  *pquery = ca_truth_as_number(ca, *pquery);
+  if ( ! ca_query_matches_nothing(ca, *pquery) || ca_is_complex_type(ca) ) {
+    return;
+  }
+  if ( ca_is_face(ca) ) {
+    ca_face_require_orderable(*pself, "search", "search");
+  }
+  *pself  = rb_funcall(*pself, rb_intern("eq"), 1, *pquery);
+  *pquery = Qtrue;
+}
+
 static VALUE
 rb_ca_search_kw (int argc, VALUE *argv, VALUE self)
 {
@@ -448,10 +470,12 @@ rb_ca_search_kw (int argc, VALUE *argv, VALUE self)
   VALUE raxis = Qnil;
   rb_scan_options(ropt, "axis", &raxis);
   rb_check_arity(argc, 1, 2);
+  VALUE rquery = argv[0];
+  ca_search_query_read(&self, &rquery);
 
   if ( NIL_P(raxis) ) {
     VALUE flat = rb_ca_flatten(self);
-    VALUE q    = rb_obj_is_carray(argv[0]) ? rb_ca_flatten(argv[0]) : argv[0];
+    VALUE q    = rb_obj_is_carray(rquery) ? rb_ca_flatten(rquery) : rquery;
     VALUE r;
     VALUE ki_argv[3] = { q, INT2FIX(0), argv[1] };
     if ( argc >= 2 ) {
@@ -460,10 +484,10 @@ rb_ca_search_kw (int argc, VALUE *argv, VALUE self)
     else {
       r = rb_ca_search_ki(2, ki_argv, flat);
     }
-    return rb_obj_is_carray(argv[0]) ? ca_reshape_search_result(argv[0], r) : r;
+    return rb_obj_is_carray(rquery) ? ca_reshape_search_result(rquery, r) : r;
   }
   /* search_ki(val, axis, eps) -- argc=2 (val,axis) or 3 (val,axis,eps) */
-  VALUE ki_argv[3] = { argv[0], raxis, argv[1] };
+  VALUE ki_argv[3] = { rquery, raxis, argv[1] };
   if ( argc >= 2 ) {
     return rb_ca_search_ki(3, ki_argv, self);
   }
@@ -477,11 +501,13 @@ rb_ca_search_addr_kw (int argc, VALUE *argv, VALUE self)
   VALUE raxis = Qnil;
   rb_scan_options(ropt, "axis", &raxis);
   rb_check_arity(argc, 1, 2);
+  VALUE rquery = argv[0];
+  ca_search_query_read(&self, &rquery);
 
   if ( NIL_P(raxis) ) {
     /* 1-D self: addr == index reuses _ki (not _addr_ki). */
     VALUE flat = rb_ca_flatten(self);
-    VALUE q    = rb_obj_is_carray(argv[0]) ? rb_ca_flatten(argv[0]) : argv[0];
+    VALUE q    = rb_obj_is_carray(rquery) ? rb_ca_flatten(rquery) : rquery;
     VALUE r;
     VALUE ki_argv[3] = { q, INT2FIX(0), argv[1] };
     if ( argc >= 2 ) {
@@ -490,9 +516,9 @@ rb_ca_search_addr_kw (int argc, VALUE *argv, VALUE self)
     else {
       r = rb_ca_search_ki(2, ki_argv, flat);
     }
-    return rb_obj_is_carray(argv[0]) ? ca_reshape_search_result(argv[0], r) : r;
+    return rb_obj_is_carray(rquery) ? ca_reshape_search_result(rquery, r) : r;
   }
-  VALUE ki_argv[3] = { argv[0], raxis, argv[1] };
+  VALUE ki_argv[3] = { rquery, raxis, argv[1] };
   if ( argc >= 2 ) {
     return rb_ca_search_addr_ki(3, ki_argv, self);
   }
@@ -597,6 +623,21 @@ rb_ca_sort_by_key (int argc, VALUE *argv, VALUE self)
   return rb_ca_fetch(self, addrs);
 }
 
+/* The extreme kernels have no fixlen lane: a fixlen key is read through the
+   rank of its cells, which keeps ties and masked cells. */
+static VALUE
+ca_by_key_comparable (VALUE key)
+{
+  CArray *ca;
+  TypedData_Get_Struct(key, CArray, &carray_data_type, ca);
+  if ( ca->data_type == CA_FIXLEN ) {
+    VALUE opts = rb_hash_new();
+    rb_hash_aset(opts, ID2SYM(rb_intern("method")), ID2SYM(rb_intern("dense")));
+    return rb_funcallv_kw(key, rb_intern("order"), 1, &opts, RB_PASS_KEYWORDS);
+  }
+  return key;
+}
+
 /* max_by_key(key, axis: nil) -- self[key.max_addr(axis:)] (or UNDEF if empty). */
 static VALUE
 rb_ca_max_by_key (int argc, VALUE *argv, VALUE self)
@@ -609,6 +650,7 @@ rb_ca_max_by_key (int argc, VALUE *argv, VALUE self)
     return CA_UNDEF;
   }
   rkey = ca_order_key(rkey, "max_by_key");
+  rkey = ca_by_key_comparable(rkey);
 
   VALUE addrs;
 
@@ -636,6 +678,7 @@ rb_ca_min_by_key (int argc, VALUE *argv, VALUE self)
     return CA_UNDEF;
   }
   rkey = ca_order_key(rkey, "min_by_key");
+  rkey = ca_by_key_comparable(rkey);
 
   VALUE addrs;
 
@@ -1100,7 +1143,7 @@ ca_topk_buf_fiber (const ca_topk_fiber_t *f, ca_size_t len, ca_size_t cap,
    filled with the axis last and moved into place at the end (cap cells
    per fiber). */
 static VALUE
-ca_topk_buffered_positions (VALUE key, long cap, long axis, int desc)
+ca_topk_buffered_positions (volatile VALUE key, long cap, long axis, int desc)
 {
   volatile VALUE holder = 0, out;
   VALUE perm[CA_RANK_MAX];

data/ext/carray_partition.c

@@ -141,7 +141,7 @@ VALUE
 rb_ca_partition_copy_c (VALUE self, VALUE vkth, VALUE vaxis)
 {
   /* Mask handling (= same as partition view). */
-  VALUE target = self;
+  volatile VALUE target = self;   /* cat points into it; the walk can run a GC */
   CArray *cat;
   TypedData_Get_Struct(target, CArray, &carray_data_type, cat);
   if ( ca_has_mask(cat) ) {

data/ext/carray_random.c

@@ -791,7 +791,7 @@ static CArray *
 ca_rng_cells (VALUE self, int64_t **cells)
 {
   CArray *ca;
-  VALUE state = rb_ivar_get(self, rb_intern("@state"));
+  volatile VALUE state = rb_ivar_get(self, rb_intern("@state"));
   TypedData_Get_Struct(state, CArray, &carray_data_type, ca);
   ca_attach(ca);   /* window: the state is an entity, whose attach holds nothing */
   *cells = (int64_t *) ca->ptr;

data/ext/carray_round.c

@@ -196,6 +196,21 @@ ca_round_entity (CArray *ca, long ndigits)
   }
 }
 
+typedef struct {
+  CArray *ca;
+  long    ndigits;
+} ca_round_call_t;
+
+/* The cells of an object array are asked in turn, and a cell that is an
+   array asks its own (ca_computing_run). */
+static VALUE
+ca_round_cells (VALUE arg)
+{
+  ca_round_call_t *c = (ca_round_call_t *) arg;
+  ca_round_entity(c->ca, c->ndigits);
+  return Qnil;
+}
+
 /* The array to round: a boolean is rounded as its 0/1 int64 values, as
    round without digits does. */
 static VALUE
@@ -228,7 +243,15 @@ ca_round_copy (VALUE src, long ndigits)
   if ( ndigits > 0 && ca_is_integer_type(co) ) {
     return out;
   }
-  ca_round_entity(co, ndigits);
+  if ( ca_is_object_type(co) ) {
+    ca_round_call_t c;
+    c.ca      = co;
+    c.ndigits = ndigits;
+    ca_computing_run(1, &co, ca_round_cells, (VALUE) &c);
+  }
+  else {
+    ca_round_entity(co, ndigits);
+  }
   return out;
 }
 

data/ext/carray_scatter.c

@@ -266,6 +266,10 @@ ca_scatter_is_scalar (VALUE v)
     } \
   } \
   else { \
+    if ( rb_obj_is_carray(rvals) ) { \
+      TypedData_Get_Struct(rvals, CArray, &carray_data_type, cv); \
+      ca_refuse_complex_into_real(ca, cv); \
+    } \
     /* coerce: a store into the receiver */ \
     rvals = rb_ca_wrap_readonly(rvals, INT2NUM(ca->data_type)); \
     TypedData_Get_Struct(rvals, CArray, &carray_data_type, cv); \

data/ext/carray_segment.c

@@ -34,7 +34,7 @@ static ID id_lengths, id_offsets;
    data type and masked cells, since neither names a count or a
    position. */
 static VALUE
-segment_read_int64 (VALUE v, const char *name, int is_lengths,
+segment_read_int64 (volatile VALUE v, const char *name, int is_lengths,
                     ca_size_t pad_front, CArray **out_ca, ca_size_t *out_k)
 {
   CArray *src, *dst;

data/ext/carray_slab.c

@@ -117,7 +117,7 @@ ca_slab_parse_axes (ca_slab_iter_state_t *st, VALUE axis_arg, int8_t src_ndim)
      init_val   : VALUE — REDUCE_FIBER initial accumulator, or Qundef
                   if not applicable.  Stored as Qnil if Qundef.       */
 static void
-slab_state_init (ca_slab_iter_state_t *st, VALUE source, int8_t form,
+slab_state_init (ca_slab_iter_state_t *st, volatile VALUE source, int8_t form,
                  VALUE axis_arg, VALUE data_type, VALUE init_val)
 {
   CArray *src;
@@ -422,8 +422,9 @@ ca_slab_setup_input_slab_view (ca_slab_iter_state_t *st, CArray *src,
       ca_size_t exp = src->bytes;
       int8_t k;
       st->own_scratch_elements = elements;
-      st->own_data_scratch     = (char *) xmalloc(elements * src->bytes);
+      st->own_data_scratch     = ca_alloc_cells_of(src->data_type, elements, src->bytes);
       if ( has_mask ) {
+        /* cells: boolean, which the collector does not read */
         st->own_mask_scratch   = (boolean8_t *) xmalloc(elements);
       }
       /* Carrier wraps our own scratch.  Direct field assignment of
@@ -516,6 +517,14 @@ ca_slab_advance_slab_view (ca_slab_iter_state_t *st,
                            CArray *src, char *p_in, boolean8_t *m_in,
                            int in_alias)
 {
+  /* A fiber of no cells has no address, but the view and its mask must
+     still read as attached. */
+  static char no_cells;
+  if ( st->t1->slab_elements == 0 ) {
+    if ( p_in == NULL ) p_in = &no_cells;
+    if ( m_in == NULL ) m_in = (boolean8_t *) &no_cells;
+  }
+
   if ( in_alias ) {
     /* ALIAS — single-axis OR multi-axis contig.  ptr fast path uses
        ca_index2addr * bytes + ptr (= safe since slab is row-major
@@ -751,7 +760,7 @@ ca_slab_run_map (ca_slab_iter_state_t *st)
                                                    st->t1->slab_dims);
   if ( st->own_data_scratch != NULL ) {
     st->own_out_scratch =
-      (char *) xmalloc(st->own_scratch_elements * st->out_bytes);
+      ca_alloc_cells_of(st->out_data_type, st->own_scratch_elements, st->out_bytes);
   }
 
   /* Step 4: per-slab loop.
@@ -779,7 +788,7 @@ ca_slab_run_map (ca_slab_iter_state_t *st)
     piece = ca_slab_piece(st);
     while ( ca_iter_state_next_slab_axes(st->t1,     &p_in,  &m_in) &&
             ca_iter_state_next_slab_axes(st->t1_out, &p_out, &m_out) ) {
-      VALUE result;
+      volatile VALUE result;
 
       ca_slab_advance_slab_view(st, slab_cs, carrier_cw,
                                 src, p_in, m_in, in_alias);

data/ext/carray_sort.c

@@ -621,7 +621,7 @@ axis2addr_body (void *user_data, void *ptr, ca_size_t n)
  * by rb_ca_take_along_axis_c / rb_ca_put_along_axis in
  * carray_order.c. */
 VALUE
-rb_ca_axis2addr_c (VALUE self, VALUE vindices, VALUE vaxis)
+rb_ca_axis2addr_c (VALUE self, volatile VALUE vindices, VALUE vaxis)
 {
   rb_check_carray_object(vindices);
 
@@ -958,6 +958,9 @@ rb_ca_sort_copy (int argc, VALUE *argv, VALUE self)
   CA_FOR_EACH_FIBER_INOUT(st_in, st_out, cat, cao, (int8_t) axis,
                           CA_KERNEL_NO_MASK, pi, po, n) {
     (void) fiber_n_for_check;
+    if ( n == 0 ) {             /* an empty array's one fiber has no buffer */
+      continue;
+    }
     memcpy(po, pi, (size_t) n * (size_t) bytes);
     if ( do_stable ) {
       switch ( cat->data_type ) {
@@ -970,12 +973,12 @@ rb_ca_sort_copy (int argc, VALUE *argv, VALUE self)
         case CA_INT64:   ca_sort_merge_i64((int64_t   *) po, (int64_t   *) aux, n); break;
         case CA_UINT64:  ca_sort_merge_u64((uint64_t  *) po, (uint64_t  *) aux, n); break;
         case CA_FLOAT32: {
-          ca_size_t fin = ca_partition_nan_f32((float32_t *) po, n);
+          ca_size_t fin = ca_partition_nan_stable_f32((float32_t *) po, n, (float32_t *) aux);
           ca_sort_merge_f32((float32_t *) po, (float32_t *) aux, fin);
           break;
         }
         case CA_FLOAT64: {
-          ca_size_t fin = ca_partition_nan_f64((double *) po, n);
+          ca_size_t fin = ca_partition_nan_stable_f64((double *) po, n, (double *) aux);
           ca_sort_merge_f64((double *) po, (double *) aux, fin);
           break;
         }

data/ext/carray_sort_kernel.c

@@ -446,6 +446,30 @@ struct ca_partition_nan_##SUFFIX##_eat_semicolon
 DEFINE_PARTITION_NAN(float32_t, f32);
 DEFINE_PARTITION_NAN(double,    f64);
 
+/* Stable variant for a stable value sort: the finite values, then the
+   NaNs, each in their original order.  scratch holds n values, taken by
+   the caller before it opens its walks. */
+#define DEFINE_PARTITION_NAN_STABLE(TYPE, SUFFIX)                          \
+ca_size_t                                                                  \
+ca_partition_nan_stable_##SUFFIX (TYPE *a, ca_size_t n, TYPE *scratch)     \
+{                                                                          \
+  ca_size_t fin = 0, k;                                                    \
+  for ( k = 0; k < n; k++ ) {                                              \
+    if ( !isnan(a[k]) ) scratch[fin++] = a[k];                             \
+  }                                                                        \
+  if ( fin == n ) return n;                                                \
+  ca_size_t m = fin;                                                       \
+  for ( k = 0; k < n; k++ ) {                                              \
+    if ( isnan(a[k]) ) scratch[m++] = a[k];                                \
+  }                                                                        \
+  memcpy(a, scratch, (size_t) n * sizeof(TYPE));                           \
+  return fin;                                                              \
+}                                                                          \
+struct ca_partition_nan_stable_##SUFFIX##_eat_semicolon
+
+DEFINE_PARTITION_NAN_STABLE(float32_t, f32);
+DEFINE_PARTITION_NAN_STABLE(double,    f64);
+
 /* Pair variant for argsort: separates ca_pair_<type> by
    isnan(v.value).  Returns the finite count.
 

data/ext/carray_struct.c

@@ -113,9 +113,15 @@ ca_struct_read_primitive_fast (const char *p, int type_code)
   }
 }
 
+/* A String is read as a decimal number, as a store into the member's
+   field view reads it. */
 static void
 ca_struct_write_primitive_fast (char *p, int type_code, VALUE val)
 {
+  if ( type_code != CA_BOOLEAN && RB_TYPE_P(val, T_STRING) ) {
+    ca_decimal_string_store(val, (int8_t) type_code, p);
+    return;
+  }
   switch (type_code) {
   case CA_BOOLEAN: {
     /* The values a boolean array takes: true / false / 1 / 0. */
@@ -259,7 +265,7 @@ ca_struct_write_bitfield_fast (char *p, int view_bytes,
     }
   }
   else {
-    v = NUM2ULL(val);
+    v = NUM2ULL(ca_integer_wrap_bits(val, bits, 0));
   }
   uint64_t mask = (bits >= 64) ? ~(uint64_t)0
                                : ((uint64_t)1 << bits) - 1;
@@ -324,6 +330,15 @@ ca_struct_read_endian_swapped_fast (const char *p, int type_code)
 static void
 ca_struct_write_endian_swapped_fast (char *p, int type_code, VALUE val)
 {
+  if ( RB_TYPE_P(val, T_STRING) ) {
+    char host[8];
+    ca_decimal_string_store(val, (int8_t) type_code, host);
+    switch ( ca_sizeof[type_code] ) {
+    case 2: { uint16_t v; memcpy(&v, host, 2); v = CA_BSWAP16(v); memcpy(p, &v, 2); return; }
+    case 4: { uint32_t v; memcpy(&v, host, 4); v = CA_BSWAP32(v); memcpy(p, &v, 4); return; }
+    case 8: { uint64_t v; memcpy(&v, host, 8); v = CA_BSWAP64(v); memcpy(p, &v, 8); return; }
+    }
+  }
   switch (type_code) {
   case CA_INT16: {
     uint16_t v = (uint16_t) NUM2LL(ca_obj2integer_fitting(val, CA_INT16));
@@ -425,7 +440,7 @@ ca_struct_member_name (VALUE klass, VALUE name)
   if ( ! RB_TYPE_P(name, T_STRING) && ! RB_TYPE_P(name, T_FIXNUM) ) {
     rb_raise(rb_eTypeError,
              "a struct member is named by a String or an Integer position "
-             "(got %s)", rb_obj_classname(name));
+             "(got %"PRIsVALUE")", rb_obj_class(name));
   }
   name_s = ca_struct_resolve_name(klass, name);
   if ( NIL_P(name_s)
@@ -708,8 +723,8 @@ rb_ca_struct_initialize (int argc, VALUE *argv, VALUE self)
       VALUE unknown_inspect = rb_inspect(state.unknown_keys);
       VALUE known_inspect   = rb_inspect(members);
       rb_raise(rb_eArgError,
-               "unknown member(s) for %s: %s (known: %s)",
-               rb_class2name(klass),
+               "unknown member(s) for %"PRIsVALUE": %s (known: %s)",
+               klass,
                StringValueCStr(unknown_inspect),
                StringValueCStr(known_inspect));
     }
@@ -721,8 +736,8 @@ rb_ca_struct_initialize (int argc, VALUE *argv, VALUE self)
   long mems_size = RARRAY_LEN(members);
   if (argc > mems_size) {
     rb_raise(rb_eArgError,
-             "too many arguments for %s.new (<%d> for <%ld>)",
-             rb_class2name(klass), argc, mems_size);
+             "too many arguments for %"PRIsVALUE".new (<%d> for <%ld>)",
+             klass, argc, mems_size);
   }
   for (int i = 0; i < argc; i++) {
     VALUE name_s = rb_ary_entry(members, i);

data/ext/carray_test.c

@@ -201,6 +201,23 @@ rb_ca_is_type (VALUE arg, int type)
    live in ca_obj_record.c; signatures stay in carray.h for cross-file
    extern use. */
 
+/* Whether v, an index along a length of n, names a position: a negative one
+ * counts from the end.  An Integer too large for ca_size_t is out of any
+ * range; what is not an Integer is not an index. */
+static int
+ca_index_arg_in_range (VALUE v, ca_size_t n, const char *arg)
+{
+  ca_size_t idx;
+  if ( RB_TYPE_P(v, T_BIGNUM) ) {
+    return 0;
+  }
+  idx = ca_integer_arg(v, arg, NULL);
+  if ( idx < 0 ) {
+    idx += n;
+  }
+  return idx >= 0 && idx < n;
+}
+
 /* CArray#valid_index?(*idx) -- whether self[*idx] names a cell: a negative
  * index counts from the end of its axis, as it does at every door.  The
  * number of indices must equal ndim (raises otherwise). */
@@ -208,7 +225,6 @@ static VALUE
 rb_ca_is_valid_index (int argc, VALUE *argv, VALUE self)
 {
   CArray *ca;
-  ca_size_t idx;
   int i;
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
@@ -218,11 +234,7 @@ rb_ca_is_valid_index (int argc, VALUE *argv, VALUE self)
              "invalid # of arguments (%i for %i)", argc, ca->ndim);
   }
   for (i=0; i<ca->ndim; i++) {
-    idx = NUM2SIZE(argv[i]);
-    if ( idx < 0 ) {
-      idx += ca->dim[i];
-    }
-    if ( idx < 0 || idx >= ca->dim[i] ) {
+    if ( ! ca_index_arg_in_range(argv[i], ca->dim[i], "an index") ) {
       return Qfalse;
     }
   }
@@ -236,30 +248,26 @@ static VALUE
 rb_ca_is_valid_addr (VALUE self, VALUE raddr)
 {
   CArray *ca;
-  ca_size_t addr;
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
-  addr = NUM2SIZE(raddr);
-  if ( addr < 0 ) {
-    addr += ca->elements;
-  }
-  if ( addr < 0 || addr >= ca->elements ) {
-    return Qfalse;
-  }
-  else {
-    return Qtrue;
-  }
+  return ca_index_arg_in_range(raddr, ca->elements, "an address") ? Qtrue : Qfalse;
 }
 
-/* CArray#same_shape?(other) — 1 if self and other share ndim and dim[].
- * Scalars compare true against any array (see ca_has_same_shape). */
+/* CArray#same_shape?(other) — whether self and other share ndim and dim[].
+ * Scalars compare true against any array (see ca_has_same_shape).  Only the
+ * shape is compared, so no value is converted: other that is not a CArray
+ * takes the shape it has as an object array. */
 static VALUE
 rb_ca_has_same_shape (VALUE self, VALUE other)
 {
   CArray *ca, *cb;
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
-  /* coerce: only the shape is compared */
-  cb = ca_wrap_readonly(other, ca->data_type);
+  if ( rb_obj_is_carray(other) ) {
+    TypedData_Get_Struct(other, CArray, &carray_data_type, cb);
+  }
+  else {
+    cb = ca_wrap_readonly(other, CA_OBJECT);
+  }
   return ca_has_same_shape(ca, cb) ? Qtrue : Qfalse;
 }
 
@@ -276,10 +284,22 @@ eql_## type (const char *a, const char *b, ca_size_t bytes) \
 
 /* == compares contents: a NaN equals a NaN (whatever its payload), as the
    same array read back or copied holds the same NaN; -0.0 equals 0.0 as
-   values do.  eql? stays bitwise. */
+   values do.  eql? stays bitwise.  An object cell equals itself first, as
+   in Array#== and Array#eql?, so a copy of an array holding any NaN object
+   equals it.  A cell holding a CArray is asked all the same, so an array
+   that holds itself is refused as cyclic. */
+static int
+ca_object_cells_identical (VALUE x, VALUE y)
+{
+  return x == y && ! rb_obj_is_carray(x);
+}
+
 static int
 ca_object_cells_equal (VALUE x, VALUE y)
 {
+  if ( ca_object_cells_identical(x, y) ) {
+    return 1;
+  }
   if ( RB_FLOAT_TYPE_P(x) && RB_FLOAT_TYPE_P(y) &&
        isnan(RFLOAT_VALUE(x)) && isnan(RFLOAT_VALUE(y)) ) {
     return 1;
@@ -287,6 +307,13 @@ ca_object_cells_equal (VALUE x, VALUE y)
   return RTEST(rb_funcall(x, id_equal, 1, y)) ? 1 : 0;
 }
 
+static int
+ca_object_cells_eql (VALUE x, VALUE y)
+{
+  return ca_object_cells_identical(x, y)
+         || RTEST(rb_funcall(x, id_eql, 1, y));
+}
+
 static int
 eql_VALUE (const char *a, const char *b, ca_size_t bytes)
 {
@@ -416,8 +443,7 @@ ca_compare_body (VALUE arg)
       for (i=0; i<ca->elements; i++) {
         volatile VALUE x = va[i];
         volatile VALUE y = vb[i];
-        int eq = strict ? RTEST(rb_funcall(x, id_eql, 1, y))
-                        : ca_object_cells_equal(x, y);
+        int eq = strict ? ca_object_cells_eql(x, y) : ca_object_cells_equal(x, y);
         if ( ! eq ) {
           flag = 0;
           break;
@@ -459,8 +485,7 @@ ca_compare_body (VALUE arg)
         if ( is_object ) {
           volatile VALUE x = *(VALUE *) pa;
           volatile VALUE y = *(VALUE *) pb;
-          eq = strict ? RTEST(rb_funcall(x, id_eql, 1, y))
-                      : ca_object_cells_equal(x, y);
+          eq = strict ? ca_object_cells_eql(x, y) : ca_object_cells_equal(x, y);
         }
         else if ( strict
                   || ca->data_type <= CA_UINT64
@@ -507,7 +532,7 @@ ca_compare_run (VALUE arg)
  *
  * The only difference is the per-element comparator:
  *   == : ca_eql[data_type] (by value: NaN equals NaN, -0.0 equals 0.0)
- *   eql?: memcmp for numeric, rb_funcall(:eql?) for CA_OBJECT
+ *   eql?: memcmp for numeric, ca_object_cells_eql for CA_OBJECT
  *
  * The unmasked-unmasked branch takes a bulk memcmp or per-cell
  * shortcut to amortise per-element function pointer dispatch. */
@@ -659,6 +684,24 @@ rb_ca_eql (VALUE self, VALUE other)
 
 #define CA_HASH_SAMPLE_BYTES 64
 
+typedef struct {
+  st_index_t   h;
+  ca_size_t    n;
+  const VALUE *cells;
+} ca_hash_cells_t;
+
+static VALUE
+ca_hash_cells (VALUE arg)
+{
+  ca_hash_cells_t *hc = (ca_hash_cells_t *) arg;
+  ca_size_t i;
+
+  for (i = 0; i < hc->n; i++) {
+    hc->h = rb_hash_uint(hc->h, (st_index_t) NUM2LONG(rb_hash(hc->cells[i])));
+  }
+  return Qnil;
+}
+
 static st_index_t
 ca_hash (CArray *ca)
 {
@@ -668,19 +711,21 @@ ca_hash (CArray *ca)
   ca_size_t data_len = ca_length(ca);
   ca_size_t sample = (data_len < CA_HASH_SAMPLE_BYTES) ? data_len : CA_HASH_SAMPLE_BYTES;
 
-  h  = rb_memhash(&ca->data_type, sizeof(ca->data_type));
-  h ^= rb_memhash(&ca->ndim,      sizeof(ca->ndim));
-  h ^= rb_memhash(&ca->bytes,     sizeof(ca->bytes));
-  h ^= rb_memhash(&ca->elements,  sizeof(ca->elements));
-  h ^= rb_memhash(&scalar_flag,   sizeof(scalar_flag));
+  /* Mixed in order: XOR would cancel equal fields, as a 1-D array's dim
+     and elements are. */
+  h = rb_hash_start(ca->data_type);
+  h = rb_hash_uint(h, (st_index_t) ca->ndim);
+  h = rb_hash_uint(h, (st_index_t) ca->bytes);
+  h = rb_hash_uint(h, (st_index_t) ca->elements);
+  h = rb_hash_uint(h, (st_index_t) scalar_flag);
   if ( ca->ndim > 0 ) {
-    h ^= rb_memhash(ca->dim, sizeof(ca_size_t) * ca->ndim);
+    h = rb_hash_uint(h, rb_memhash(ca->dim, sizeof(ca_size_t) * ca->ndim));
   }
 
   /* ca_is_any_masked() attaches/detaches the mask internally and returns
      only a boolean, so we never touch ca->mask->ptr here. */
   masked_flag = ca_is_any_masked(ca) ? 1 : 0;
-  h ^= rb_memhash(&masked_flag, sizeof(masked_flag));
+  h = rb_hash_uint(h, (st_index_t) masked_flag);
 
   if ( ! masked_flag && sample > 0 ) {
     ca_size_t addrs[CA_HASH_SAMPLE_BYTES];
@@ -700,22 +745,23 @@ ca_hash (CArray *ca)
          #hash, not the VALUE bits.  The cells sit on the stack, where the
          GC sees them while #hash runs. */
       VALUE cells[CA_HASH_SAMPLE_BYTES / sizeof(VALUE)];
+      ca_hash_cells_t hc;
       ca_xfer_addrs(ca, ncell, addrs, cells, CA_XFER_GET);
-      for (i = 0; i < ncell; i++) {
-        h = rb_hash_uint(h, (st_index_t) NUM2LONG(rb_hash(cells[i])));
-      }
+      hc.h = h; hc.n = ncell; hc.cells = cells;
+      ca_cell_walk_run(ca_hash_cells, (VALUE) &hc);
+      h = hc.h;
       RB_GC_GUARD(cells[0]);
     }
     else {
       volatile VALUE holder;
       char *buf = ALLOCV_N(char, holder, ncell * ca->bytes);
       ca_xfer_addrs(ca, ncell, addrs, buf, CA_XFER_GET);
-      h ^= rb_memhash(buf, ncell * ca->bytes);
+      h = rb_hash_uint(h, rb_memhash(buf, ncell * ca->bytes));
       ALLOCV_END(holder);
     }
   }
 
-  return h;
+  return rb_hash_end(h);
 }
 
 /* CArray#hash — Hash key value; wraps ca_hash into a Ruby Integer. */

data/ext/carray_time_text.c

@@ -602,6 +602,12 @@ rb_ca_s_time_ticks_from_fields (VALUE klass,
    other than Z, UTC and GMT, an offset written another way) is deferred to
    Date._strptime for that cell.
 
+   Three inputs read differently from Date._strptime.  A format with both
+   a two-digit year and a four-digit year takes the four-digit year, where
+   Date._strptime adds the century to it.  %Z ends at the zone's name, so
+   digits directly after it go to the next directive.  A NUL in the text
+   is text, so it is left over.
+
    Strict reading, used to find the format a column is written in, holds
    the text to the shape of the format: %Y is four digits and %y two, %N
    one to nine digits, the other numbers one or two digits (two when a