carray 3.0.3 → 3.0.5

data/ext/carray_cast_func.rb

@@ -1,4 +1,5 @@
 data_type = []
+type_const = {}
 %w[
   CA_FIXLEN
   CA_BOOLEAN
@@ -20,8 +21,22 @@ data_type = []
 ].each_with_index do |name, i|
   eval("#{name} = #{i}")
   data_type.push(i)
+  type_const[i] = name
 end
 
+# The open interval (lo, hi) of doubles whose integer part a type holds:
+# a cast truncates toward zero, so -128.5 still fits int8.
+INTEGER_TRUNC_RANGE = {
+  CA_INT8   => ["-129.0",                  "128.0"],
+  CA_UINT8  => ["-1.0",                    "256.0"],
+  CA_INT16  => ["-32769.0",                "32768.0"],
+  CA_UINT16 => ["-1.0",                    "65536.0"],
+  CA_INT32  => ["-2147483649.0",           "2147483648.0"],
+  CA_UINT32 => ["-1.0",                    "4294967296.0"],
+  CA_INT64  => ["-9223372036854775808.0",  "9223372036854775808.0"],
+  CA_UINT64 => ["-1.0",                    "18446744073709551616.0"],
+}
+
 ctype = {
   CA_FIXLEN   => "fixlen",
   CA_BOOLEAN  => "boolean8_t",
@@ -40,6 +55,12 @@ ctype = {
   CA_OBJECT   => "VALUE"
 }
 
+# The type a cast reads and writes a cell through.  A view's cells need not
+# be aligned to their size (a struct member at offset 1, a refer with a
+# byte offset), so a pointer to a multi-byte cell is the unaligned typedef
+# from carray.h; ctype stays the plain name the functions are called by.
+utype = Hash.new { |h, c| h[c] = %w[fixlen boolean8_t int8_t uint8_t].include?(c) ? c : "ca_u_#{c}" }
+
 obj2cval = {
   CA_FIXLEN   => nil,
   CA_BOOLEAN  => "OBJ2BOOL",
@@ -254,7 +275,7 @@ FIXLEN.each do |type1|
       {
          char  *p1 = ptr1;
          ca_size_t bytes;
-         VALUE *p2 = ptr2;
+         ca_u_VALUE *p2 = ptr2;
          if ( a1 == NULL ) {
            rb_raise(rb_eRuntimeError, "[BUG] failed to cast fixlen -> object");
          }
@@ -289,8 +310,8 @@ puts
       static void
       ca_cast_#{ctype1}_#{ctype2}(ca_size_t n, CArray *a1, void *ptr1, CArray *a2, void *ptr2, boolean8_t *m)
       {
-         #{ctype1} *p1 = ptr1;
-         #{ctype2} *p2 = ptr2;
+         #{utype[ctype1]} *p1 = ptr1;
+         #{utype[ctype2]} *p2 = ptr2;
          #{ctype1} q;
          if ( m ) {
            while ( n-- ) { 
@@ -300,7 +321,8 @@ puts
                  *p2 = q;
                }
                else {
-                 rb_raise(rb_eRangeError, "out of range to cast to boolean (0 or 1)");
+                 rb_raise(rb_eRangeError, "%s: out of range to cast to boolean (0 or 1)",
+                          ca_calling_method_name());
                }
              }
              p1++; p2++; m++;
@@ -313,7 +335,8 @@ puts
                *p2 = q;
              }
              else {
-               rb_raise(rb_eRangeError, "out of range to cast to boolean (0 or 1)");
+               rb_raise(rb_eRangeError, "%s: out of range to cast to boolean (0 or 1)",
+                          ca_calling_method_name());
              }
              p1++; p2++; 
            }
@@ -332,15 +355,54 @@ puts
     ctype1 = ctype[type1]
     ctype2 = ctype[type2]
     CA_CAST_TABLE[type1][type2] = "ca_cast_#{ctype1}_#{ctype2}"
-    puts <<-END_DEF  .gsub(/^ {6}/, '')
+    # float / complex -> integer: a NaN, an infinity, or a value whose
+    # integer part the type cannot hold has no integer, and C leaves its
+    # conversion undefined (x86 gives the type's minimum, ARM saturates).  A
+    # cell that is not masked refuses it before anything is written.
+    # #to_type masks such cells first (UNDEF), so only a store, a view and a
+    # single cell reach the raise.  The range is the open interval of values
+    # that truncate into the type, in double; for int64 the lower end is
+    # taken as closed, since -2**63-1 rounds to -2**63 in double.
+    nan_check = ""
+    if (FLOAT+[CA_CMPLX64, CA_CMPLX128]).include?(type1) && INTEGER.include?(type2)
+      complex = [CA_CMPLX64, CA_CMPLX128].include?(type1)
+      real = complex ? "creal(q1[k])" : "q1[k]"
+      lo, hi = INTEGER_TRUNC_RANGE[type2]
+      lo_cmp = ( type2 == CA_INT64 ) ? ">=" : ">"
+      fits = "( v #{lo_cmp} #{lo} && v < #{hi} )"
+      fits = "( #{fits} && ! isnan(cimag(q1[k])) )" if complex
+      nan_check = <<-END_CHECK.gsub(/^ {6}/, '')
+         for (k=0; k<n; k++) {
+           double v = (double) #{real};
+           if ( ( ! m || ! m[k] ) && ! #{fits} ) {
+             if ( isfinite(v)#{complex ? " && ! isnan(cimag(q1[k]))" : ""} ) {
+               rb_raise(rb_eRangeError, "%s: %.17g is out of range for %s",
+                        ca_calling_method_name(), v, ca_type_name[#{type_const[type2]}]);
+             }
+             rb_raise(rb_eFloatDomainError, "%s: %s cannot be converted to %s",
+                      ca_calling_method_name(), isinf(v) ? "an infinity" : "NaN",
+                      ca_type_name[#{type_const[type2]}]);
+           }
+         }
+      END_CHECK
+    end
+    # int64 / uint64 -> float32 / cmplx64 goes through double, as a Ruby
+    # Integer stored into a float32 cell does (Integer#to_f).  Converting in
+    # one step rounds once where the compiler keeps the loop scalar and twice
+    # where it vectorises it through double, so the answer for a value past
+    # 2**53 would depend on its place in the array.
+    via = ( [CA_INT64, CA_UINT64].include?(type1) &&
+            [CA_FLOAT32, CA_CMPLX64].include?(type2) ) ? "(double) " : ""
+    puts <<-END_DEF.gsub(/^ {6}/, '').sub("@@NAN_CHECK@@\n", nan_check).gsub("@@VIA@@", via)
       static void
       ca_cast_#{ctype1}_#{ctype2}(ca_size_t n, CArray *a1, void *ptr1, CArray *a2, void *ptr2, boolean8_t *m)
       {
-         #{ctype1} *q1 = ptr1;
-         #{ctype1} *p1 = q1;
-         #{ctype2} *q2 = ptr2;
-         #{ctype2} *p2 = q2;
+         #{utype[ctype1]} *q1 = ptr1;
+         #{utype[ctype1]} *p1 = q1;
+         #{utype[ctype2]} *q2 = ptr2;
+         #{utype[ctype2]} *p2 = q2;
          ca_size_t k;
+      @@NAN_CHECK@@
          if ( m ) {
            boolean8_t *pm = m;
            for (k=0; k<n; k++) {
@@ -348,7 +410,7 @@ puts
              if ( ! *pm ) { 
                p1 = q1 + k;
                p2 = q2 + k;
-               *p2 = (#{ctype2}) *p1;
+               *p2 = (#{ctype2}) @@VIA@@*p1;
              }
            }
          }
@@ -356,7 +418,7 @@ puts
            for (k=0; k<n; k++) {
              p1 = q1 + k;
              p2 = q2 + k;
-             *p2 = (#{ctype2}) *p1;
+             *p2 = (#{ctype2}) @@VIA@@*p1;
            }
          }
          return;
@@ -380,8 +442,8 @@ puts
       static void
       ca_cast_#{ctype1}_#{ctype2}(ca_size_t n, CArray *a1, void *ptr1, CArray *a2, void *ptr2, boolean8_t *m)
       {
-         #{ctype1} *p1 = ptr1;
-         VALUE *p2 = ptr2;
+         #{utype[ctype1]} *p1 = ptr1;
+         ca_u_VALUE *p2 = ptr2;
          if ( m ) {
            while ( n-- ) { 
              if ( !*m ) { *p2 = (VALUE) #{conv}(*p1); } 
@@ -409,7 +471,7 @@ OBJECT.each do |type1|
       static void
       ca_cast_#{ctype1}_#{ctype2}(ca_size_t n, CArray *a1, void *ptr1, CArray *a2, void *ptr2, boolean8_t *m)
       {
-         VALUE *p1 = ptr1;
+         ca_u_VALUE *p1 = ptr1;
          char *p2 = ptr2;
          ca_size_t bytes;
          if ( a2 == NULL ) {
@@ -478,9 +540,17 @@ OBJECT.each do |type1|
         read_ok   = "( RB_TYPE_P(*p1, T_STRING) ? " \
                     "ca_decimal_string_to(*p1, #{type_name}, p2) : " \
                     "( #{conv_ok}(*p1, &tmp) ? ( *p2 = (#{ctype2}) tmp, 1 ) : 0 ) )"
+        # A store refuses an integer the cell cannot hold
+        # (ca_obj2integer_fitting); to_type, above, keeps the C conversion.
+        store_conv = if INTEGER.include?(type2)
+                       num = [CA_UINT8, CA_UINT16, CA_UINT32, CA_UINT64].include?(type2) ? "rb_num2ull" : "NUM2LL"
+                       "#{num}(ca_obj2integer_fitting(*p1, #{type_name}))"
+                     else
+                       "#{conv}(*p1)"
+                     end
         read      = "if ( RB_TYPE_P(*p1, T_STRING) ) { " \
                     "ca_decimal_string_store(*p1, #{type_name}, p2); } " \
-                    "else { *p2 = (#{ctype2}) #{conv}(*p1); }"
+                    "else { *p2 = (#{ctype2}) #{store_conv}; }"
       else
         read_ok   = "( #{conv_ok}(*p1, &tmp) ? ( *p2 = (#{ctype2}) tmp, 1 ) : 0 )"
         read      = "*p2 = (#{ctype2}) #{conv}(*p1);"
@@ -489,8 +559,8 @@ OBJECT.each do |type1|
         static void
         ca_cast_#{ctype1}_#{ctype2}(ca_size_t n, CArray *a1, void *ptr1, CArray *a2, void *ptr2, boolean8_t *m)
         {
-           VALUE *p1 = ptr1;
-           #{ctype2} *p2 = ptr2;
+           ca_u_VALUE *p1 = ptr1;
+           #{utype[ctype2]} *p2 = ptr2;
            #{oktype2} tmp;
            if ( m ) {
              while ( n-- ) {
@@ -517,8 +587,8 @@ OBJECT.each do |type1|
       static void
       ca_cast_#{ctype1}_#{ctype2}(ca_size_t n, CArray *a1, void *ptr1, CArray *a2, void *ptr2, boolean8_t *m)
       {
-         VALUE *p1 = ptr1;
-         #{ctype2} *p2 = ptr2;
+         ca_u_VALUE *p1 = ptr1;
+         #{utype[ctype2]} *p2 = ptr2;
          if ( m ) {
            while ( n-- ) {
              if ( !*m ) { *p2 = (#{ctype2}) #{conv}(*p1); }

data/ext/carray_class.c

@@ -6,6 +6,7 @@
 ---------------------------------------------------------------------------- */
 
 #include "carray.h"
+#include "carray_internal.h"   /* CA_CHECK_*_GIVEN */
 
 /* ------------------------------------------------------------------- */
 /* Symbol cache for data_type code → Symbol lookup.
@@ -25,7 +26,7 @@ ID ca_data_type_sym[CA_NTYPE];
 VALUE
 rb_ca_data_type_to_sym (int8_t data_type)
 {
-  CA_CHECK_DATA_TYPE(data_type);
+  CA_CHECK_DATA_TYPE_GIVEN(data_type);
   return ID2SYM(ca_data_type_sym[data_type]);
 }
 
@@ -69,7 +70,7 @@ static VALUE
 rb_ca_s_data_type_name (VALUE klass, VALUE type)
 {
   int8_t data_type = rb_ca_guess_type(type);
-  CA_CHECK_DATA_TYPE(data_type);
+  CA_CHECK_DATA_TYPE_GIVEN(data_type);
   return rb_str_new2(ca_type_name[data_type]);
 }
 
@@ -84,7 +85,7 @@ static VALUE
 rb_ca_s_data_type_code (VALUE klass, VALUE type)
 {
   int8_t data_type = rb_ca_guess_type(type);
-  CA_CHECK_DATA_TYPE(data_type);
+  CA_CHECK_DATA_TYPE_GIVEN(data_type);
   return INT2NUM(data_type);
 }
 

data/ext/carray_config.h

@@ -0,0 +1,28 @@
+#ifndef CARRAY_CONFIG_H
+#define CARRAY_CONFIG_H
+#define HAVE_SYS_TYPES_H 1
+#define HAVE_STDINT_H 1
+#define HAVE_TYPE_INT8_T 1
+#define HAVE_TYPE_UINT8_T 1
+#define HAVE_TYPE_INT16_T 1
+#define HAVE_TYPE_UINT16_T 1
+#define HAVE_TYPE_INT32_T 1
+#define HAVE_TYPE_UINT32_T 1
+#define HAVE_TYPE_INT64_T 1
+#define HAVE_TYPE_UINT64_T 1
+#define HAVE_TYPE_LONG_LONG 1
+#define HAVE_TYPE_FLOAT 1
+#define HAVE_TYPE_DOUBLE 1
+#define HAVE_COMPLEX_H 1
+#define HAVE_TYPE_FLOAT_COMPLEX 1
+#define HAVE_TYPE_DOUBLE_COMPLEX 1
+#define HAVE_TGMATH_H 1
+#define HAVE_ATAN2 1
+#define HAVE_HYPOT 1
+#define HAVE_LGAMMA 1
+#define HAVE_EXPM1 1
+#define HAVE_MERGESORT 1
+#define HAVE_STRPTIME 1
+#define HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT 1
+#define HAVE_RUBY_MEMORY_VIEW_H 1
+#endif

data/ext/carray_conversion.c

@@ -30,14 +30,14 @@
 /* Leaf macro: data type-specialized inner loop.  Produces `n` VALUE objects
    from a contig ptr base + element width, storing into `dst` (Ruby Array). */
 #define TO_A_LEAF_LOOP(T, TO_VALUE) do { \
-  const T *src = (const T *) base; \
+  const CA_U(T) *src = (const CA_U(T) *) base; \
   for (li = 0; li < n; li++) { \
     rb_ary_store(dst, li, TO_VALUE(src[li])); \
   } \
 } while (0)
 
 #define TO_A_LEAF_LOOP_MASKED(T, TO_VALUE) do { \
-  const T *src = (const T *) base; \
+  const CA_U(T) *src = (const CA_U(T) *) base; \
   for (li = 0; li < n; li++) { \
     rb_ary_store(dst, li, mask[li] ? CA_UNDEF : TO_VALUE(src[li])); \
   } \
@@ -480,10 +480,16 @@ rb_ca_load_binary (VALUE self, VALUE io)
   case T_STRING:
     if ( ca_length(ca) != RSTRING_LEN(io) ) {
       rb_raise(rb_eArgError,
-               "data size mismatch (got %" PRId64 " bytes, expected %" PRId64 ")",
-               (ca_size_t) RSTRING_LEN(io), (ca_size_t) ca_length(ca));
+               "%s: data size mismatch (got %" PRId64 " bytes, expected %" PRId64 ")",
+               ca_calling_method_name(), (ca_size_t) RSTRING_LEN(io), (ca_size_t) ca_length(ca));
+    }
+    if ( ca->data_type == CA_BOOLEAN ) {
+      io = rb_str_dup(io);
+      rb_str_modify(io);
+      ca_boolean_normalize_bytes(RSTRING_PTR(io), ca->elements);
     }
     ca_sync_data(ca, RSTRING_PTR(io));
+    RB_GC_GUARD(io);
     return self;
     break;
   default:
@@ -511,6 +517,9 @@ rb_ca_load_binary (VALUE self, VALUE io)
           memcpy(ca->ptr + off, RSTRING_PTR(r), want);
           off += want;
         }
+        if ( ca->data_type == CA_BOOLEAN ) {
+          ca_boolean_normalize_bytes(ca->ptr, ca->elements);
+        }
         ca_sync_detach(ca);
       }
       else {
@@ -540,7 +549,7 @@ rb_ca_load_binary (VALUE self, VALUE io)
    to float.  Its digits are those of the decimal (at most 9, which a double
    holds), so Float#to_s writes them. */
 static double
-ca_float32_shortest (float x)
+ca_double_of_shortest_decimal_of_float32 (float x)
 {
   char buf[32];
   int lo = 1, hi = 9;
@@ -576,7 +585,7 @@ ca_float32_shortest (float x)
    double its shortest decimal reads as, for to_csv to write that decimal.
    The mask is kept. */
 static VALUE
-rb_ca_shortest_float64 (VALUE self)
+rb_ca_widen_keeping_shortest_decimal (VALUE self)
 {
   volatile VALUE out, holder = 0;
   CArray *ca, *co;
@@ -591,7 +600,7 @@ rb_ca_shortest_float64 (VALUE self)
     type = CA_CMPLX128;
   }
   else {
-    rb_raise(rb_eCADataTypeError, "__shortest_float64__ takes float32 or cmplx64");
+    rb_raise(rb_eCADataTypeError, "__widen_keeping_shortest_decimal__ takes float32 or cmplx64");
   }
   n = ca->elements * (ca->data_type == CA_CMPLX64 ? 2 : 1);
   out = rb_carray_new_safe(type, ca->ndim, ca->dim, 0, NULL);
@@ -601,7 +610,7 @@ rb_ca_shortest_float64 (VALUE self)
     double *dst = (double *) co->ptr;
     ca_copy_data(ca, (char *) src);
     for (i = 0; i < n; i++) {
-      dst[i] = ca_float32_shortest(src[i]);
+      dst[i] = ca_double_of_shortest_decimal_of_float32(src[i]);
     }
     ALLOCV_END(holder);
   }
@@ -627,7 +636,7 @@ Init_carray_conversion (void)
   rb_define_method(rb_cCArray, "dump_binary", rb_ca_dump_binary, -1);
   rb_define_method(rb_cCArray, "to_s", rb_ca_to_s, 0);
   rb_define_method(rb_cCArray, "load_binary", rb_ca_load_binary, 1);
-  rb_define_method(rb_cCArray, "__shortest_float64__", rb_ca_shortest_float64, 0);
+  rb_define_method(rb_cCArray, "__widen_keeping_shortest_decimal__", rb_ca_widen_keeping_shortest_decimal, 0);
 
   /* CAREFUL: do not bind #to_ary — implicit array coercion in Ruby core
      (splat / multiple assignment / Array()) then triggers on any CArray

data/ext/carray_copy.c

@@ -36,6 +36,42 @@ ca_fill_or_free (CArray *co, VALUE (*fill)(VALUE), VALUE arg)
   }
 }
 
+void
+ca_fill_or_xfree (void *buf, VALUE (*fill)(VALUE), VALUE arg)
+{
+  int tag = 0;
+  rb_protect(fill, arg, &tag);
+  if ( tag ) {
+    xfree(buf);
+    rb_jump_tag(tag);
+  }
+}
+
+void
+ca_fill_or_detach (int n, CArray **list, VALUE (*fill)(VALUE), VALUE arg)
+{
+  int tag = 0;
+  int k;
+  rb_protect(fill, arg, &tag);
+  if ( tag ) {
+    for ( k = 0; k < n; k++ ) {
+      ca_detach(list[k]);
+    }
+    rb_jump_tag(tag);
+  }
+}
+
+VALUE
+ca_view_inherit_mask (VALUE view)
+{
+  CArray *ca     = (CArray *) view;
+  CArray *parent = ((CAView *) ca)->parent;
+  if ( parent && ca_has_mask(parent) ) {
+    ca_create_mask(ca);
+  }
+  return Qnil;
+}
+
 static VALUE
 ca_copy_fill (VALUE arg)
 {
@@ -173,7 +209,7 @@ rb_ca_to_ca (int argc, VALUE *argv, VALUE self)
     CArray *ca;
     TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
     if ( ca_is_readonly(ca) ) {
-      rb_raise(rb_eRuntimeError, "can not modify read-only array");
+      ca_refuse_read_only();
     }
   }
   return self;
@@ -220,7 +256,7 @@ CArray *
 ca_template_safe2 (void *ap, int8_t data_type, ca_size_t bytes)
 {
   CArray *ca = (CArray *) ap;
-  CA_CHECK_DATA_TYPE(data_type);
+  CA_CHECK_DATA_TYPE_GIVEN(data_type);
   if ( ca_is_scalar(ca) ) {
     return (CArray*) cscalar_new(data_type, bytes, NULL);
   }
@@ -261,6 +297,19 @@ rb_ca_template_kw (int argc, VALUE *argv, VALUE ropt, VALUE self)
     obj = ca_wrap_struct(co);
   }
 
+  /* Preserve the Face identity only for a same-type template (no explicit
+   * retype).  A retype (template(:boolean)) is a different-typed buffer and
+   * must not be re-wrapped as the Face.  A same-type template of a Face with
+   * a valid blank form (CARecord carries its data_class through the struct
+   * tail; identity Faces alias same-type storage) is lifted so the class is
+   * preserved.  A Face with no valid blank form (CAConstString's content-
+   * defined offset+buffer) overrides `template` in Ruby to return a plain
+   * array instead of a broken same-class shell.  The lift comes before the
+   * block initialiser so its values are stored through the Face. */
+  if ( NIL_P(rtype) ) {
+    CA_FACE_LIFT_IF_FACE(obj, self, ca);
+  }
+
   if ( rb_block_given_p() ) {
     if ( rb_proc_arity(rb_block_proc()) == 0 ) {
       volatile VALUE rval = rb_yield_values2(0, NULL);
@@ -283,18 +332,6 @@ rb_ca_template_kw (int argc, VALUE *argv, VALUE ropt, VALUE self)
     }
   }
 
-  /* Preserve the Face identity only for a same-type template (no explicit
-   * retype).  A retype (template(:boolean)) is a different-typed buffer and
-   * must not be re-wrapped as the Face.  A same-type template of a Face with
-   * a valid blank form (CARecord carries its data_class through the struct
-   * tail; identity Faces alias same-type storage) is lifted so the class is
-   * preserved.  A Face with no valid blank form (CAConstString's content-
-   * defined offset+buffer) overrides `template` in Ruby to return a plain
-   * array instead of a broken same-class shell. */
-  if ( NIL_P(rtype) ) {
-    CA_FACE_LIFT_IF_FACE(obj, self, ca);
-  }
-
   return obj;
 }