carray 3.0.5 → 3.0.6

data/ext/carray_test.c

@@ -274,10 +274,23 @@ eql_## type (const char *a, const char *b, ca_size_t bytes) \
   return ( *(const type*)a == *(const type*)b ); \
 }
 
+/* == 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. */
+static int
+ca_object_cells_equal (VALUE x, VALUE y)
+{
+  if ( RB_FLOAT_TYPE_P(x) && RB_FLOAT_TYPE_P(y) &&
+       isnan(RFLOAT_VALUE(x)) && isnan(RFLOAT_VALUE(y)) ) {
+    return 1;
+  }
+  return RTEST(rb_funcall(x, id_equal, 1, y)) ? 1 : 0;
+}
+
 static int
 eql_VALUE (const char *a, const char *b, ca_size_t bytes)
 {
-  return RTEST(rb_funcall(*(const VALUE*)a, id_equal, 1, *(const VALUE*)b)) ? 1 : 0;
+  return ca_object_cells_equal(*(const VALUE*)a, *(const VALUE*)b);
 }
 
 static int
@@ -295,10 +308,28 @@ eql_type(int32_t)
 eql_type(uint32_t)
 eql_type(int64_t)
 eql_type(uint64_t)
-eql_type(float32_t)
-eql_type(float64_t)
-eql_type(cmplx64_t)
-eql_type(cmplx128_t)
+#define eql_float(type)        \
+static int                      \
+eql_## type (const char *a, const char *b, ca_size_t bytes) \
+{                               \
+  type x = *(const type*)a, y = *(const type*)b; \
+  return ( x == y ) || ( isnan(x) && isnan(y) ); \
+}
+
+#define eql_cmplx(type, part)   \
+static int                      \
+eql_## type (const char *a, const char *b, ca_size_t bytes) \
+{                               \
+  type x = *(const type*)a, y = *(const type*)b; \
+  part xr = creal(x), xi = cimag(x), yr = creal(y), yi = cimag(y); \
+  return ( ( xr == yr ) || ( isnan(xr) && isnan(yr) ) ) && \
+         ( ( xi == yi ) || ( isnan(xi) && isnan(yi) ) ); \
+}
+
+eql_float(float32_t)
+eql_float(float64_t)
+eql_cmplx(cmplx64_t, float)
+eql_cmplx(cmplx128_t, double)
 
 /* Placeholder for CA_FLOAT128 / CA_CMPLX256 slots (ca_valid[12] =
    ca_valid[15] = 0, so never invoked). */
@@ -371,8 +402,8 @@ ca_compare_body (VALUE arg)
      comparison is bitwise (= NaN.eql?(NaN) yields true since their bit
      patterns match), so memcmp gives the right semantics. For non-strict
      (==) of numeric data_types, type-equality is byte-equality EXCEPT for
-     floats where -0.0 == +0.0 (different bit pattern, same value) and
-     NaN != NaN (same bit pattern, unequal value) -- so we must keep the
+     floats where -0.0 == +0.0 (different bit pattern, same value) and any
+     NaN equals any NaN (payloads may differ) -- so we must keep the
      per-element comparator there.
 
      Integer / bool / fixlen data_types are byte-exact, so memcmp matches both
@@ -380,13 +411,14 @@ ca_compare_body (VALUE arg)
      the comparator. */
   if ( ! masked_a && ! masked_b ) {
     if ( is_object ) {
-      ID id = strict ? id_eql : id_equal;
       VALUE *va = (VALUE *) pa;
       VALUE *vb = (VALUE *) pb;
       for (i=0; i<ca->elements; i++) {
         volatile VALUE x = va[i];
         volatile VALUE y = vb[i];
-        if ( ! RTEST(rb_funcall(x, id, 1, y)) ) {
+        int eq = strict ? RTEST(rb_funcall(x, id_eql, 1, y))
+                        : ca_object_cells_equal(x, y);
+        if ( ! eq ) {
           flag = 0;
           break;
         }
@@ -427,8 +459,8 @@ ca_compare_body (VALUE arg)
         if ( is_object ) {
           volatile VALUE x = *(VALUE *) pa;
           volatile VALUE y = *(VALUE *) pb;
-          ID id = strict ? id_eql : id_equal;
-          eq = RTEST(rb_funcall(x, id, 1, y));
+          eq = strict ? RTEST(rb_funcall(x, id_eql, 1, y))
+                      : ca_object_cells_equal(x, y);
         }
         else if ( strict
                   || ca->data_type <= CA_UINT64
@@ -451,6 +483,19 @@ ca_compare_body (VALUE arg)
   return Qnil;
 }
 
+typedef struct {
+  CArray           **list;
+  ca_compare_ctx_t  *c;
+} ca_compare_run_t;
+
+static VALUE
+ca_compare_run (VALUE arg)
+{
+  ca_compare_run_t *r = (ca_compare_run_t *) arg;
+  ca_attach_window(2, r->list, "rr", ca_compare_body, (VALUE) r->c);
+  return Qnil;
+}
+
 /* ca_compare_common(a, b, strict) — shared body of ca_equal (==) and
  * ca_eql_strict (eql?).  Returns 1 if arrays match under the selected
  * semantics, else 0.
@@ -461,7 +506,7 @@ ca_compare_body (VALUE arg)
  * four masked/unmasked combinations.
  *
  * The only difference is the per-element comparator:
- *   == : ca_eql[data_type] (type-specific, so float NaN != NaN)
+ *   == : ca_eql[data_type] (by value: NaN equals NaN, -0.0 equals 0.0)
  *   eql?: memcmp for numeric, rb_funcall(:eql?) for CA_OBJECT
  *
  * The unmasked-unmasked branch takes a bulk memcmp or per-cell
@@ -503,8 +548,14 @@ ca_compare_common (void *ap, void *bp, int strict)
     c.flag   = 1;
     list[0]  = ca;
     list[1]  = cb;
-    /* The object lane calls #== / #eql? with both arrays attached. */
-    ca_attach_window(2, list, "rr", ca_compare_body, (VALUE) &c);
+    /* The object lane calls #== / #eql? with both arrays attached, and
+       recorded as compared over (ca_computing_run), so a cell holding one
+       of them is refused as cyclic rather than compared again without
+       end. */
+    ca_compare_run_t r;
+    r.list = list;
+    r.c    = &c;
+    ca_computing_run(2, list, ca_compare_run, (VALUE) &r);
     return c.flag;
   }
 }
@@ -522,9 +573,10 @@ ca_eql_storage (void *ap, void *bp)
 }
 
 /* CArray#==(other) — elementwise equality returning true / false.
- * data_class, data_type, shape, and mask state must all match; NaN
- * compares unequal per IEEE semantics.  Non-CArray other returns
- * false. */
+ * data_class, data_type, shape, and mask state must all match.  It asks
+ * whether the contents are the same, so a NaN equals a NaN and -0.0
+ * equals 0.0; the IEEE comparison of each element is #eq.  Non-CArray
+ * other returns false. */
 static VALUE
 rb_ca_equal (VALUE self, VALUE other)
 {
@@ -795,7 +847,8 @@ without_read_only_ensure (VALUE arg)
  * the bridge owns.
  *
  * Mechanics: clears CA_FLAG_READ_ONLY on self and on its mask for the
- * duration of the block; rb_ensure restores both on normal return AND on
+ * duration of the block, except on a mask that is a wrap: that mask borrows
+ * its bits from a producer (wrap_memory_view's mask:), which set the flag; rb_ensure restores both on normal return AND on
  * raise, setting the flag on whatever mask self has by then.  (A read-only
  * array's mask carries the flag once CArray#mask has handed it out.)  Frozen
  * objects still raise FrozenError.  Does not walk parent chains.
@@ -822,7 +875,9 @@ rb_ca_without_read_only_flag (VALUE self)
   s.was_readonly = ca_test_flag(ca, CA_FLAG_READ_ONLY);
   if (s.was_readonly) {
     ca_unset_flag(ca, CA_FLAG_READ_ONLY);
-    if (ca->mask) {
+    /* A mask that is a wrap borrows its bits (the mask: of
+       wrap_memory_view); its flag is the lender's and stays. */
+    if (ca->mask && ca->mask->obj_type != CA_OBJ_ARRAY_WRAP) {
       ca_unset_flag(ca->mask, CA_FLAG_READ_ONLY);
     }
   }

data/ext/carray_time_text.c

@@ -383,7 +383,7 @@ rb_ca_parse_time_text (int argc, VALUE *argv, VALUE self)
   if ( ca->data_type != CA_OBJECT ) {
     rb_raise(rb_eArgError, "time text reading needs an object array");
   }
-  if ( ! ca_is_entity(ca) ) {
+  if ( ! ca_is_entity(ca) || ! ca->ptr ) {
     src = rb_ca_copy(src);
     TypedData_Get_Struct(src, CArray, &carray_data_type, ca);
   }
@@ -1077,7 +1077,7 @@ rb_ca_strptime_fields (VALUE self, VALUE rformat, VALUE rstrict)
   if ( ca->data_type != CA_OBJECT ) {
     rb_raise(rb_eArgError, "strptime reading needs an object array");
   }
-  if ( ! ca_is_entity(ca) ) {
+  if ( ! ca_is_entity(ca) || ! ca->ptr ) {
     src = rb_ca_copy(src);
     TypedData_Get_Struct(src, CArray, &carray_data_type, ca);
   }

data/ext/extconf.rb

@@ -118,6 +118,17 @@ if try_compile("int main(void) { return 0; }", "-fwrapv")
   $carray_build_flags << "-fwrapv"
 end
 
+# --- math functions do not set errno (`-fno-math-errno`)
+#
+# Nothing in carray reads errno after a math call.  With errno kept, GCC
+# must call sqrt() for every cell instead of using the vector square root,
+# so `sqrt` ran 2-4x slower than it could.  The values do not change.
+# Apple clang already defaults to this.
+if try_compile("int main(void) { return 0; }", "-fno-math-errno")
+  $CFLAGS += " -fno-math-errno"
+  $carray_build_flags << "-fno-math-errno"
+end
+
 # --- probe for `-fopenmp-simd` (SL.1.0, PROPOSAL_REDUCTION_SIMD_LICENSE)
 #
 # `-fopenmp-simd` enables `#pragma omp simd` (and its `reduction(+:acc)`