carray 3.0.3 → 3.0.4

data/ext/carray_cast.c

@@ -496,6 +496,7 @@ ca_decimal_object_integer (VALUE v, int *negative, uint64_t *magnitude)
     /* truncate raises for a NaN or infinite BigDecimal, which reads as
        nothing an integer can hold. */
     int state = 0;
+    /* protect: a BigDecimal that is not finite reads as no integer; nothing is held */
     VALUE whole = rb_protect(ca_decimal_truncate, v, &state);
     if ( state ) {
       rb_set_errinfo(Qnil);
@@ -589,11 +590,11 @@ ca_decimal_string_store (VALUE str, int8_t data_type, void *out)
   case CA_DECIMAL_OK:
     return;
   case CA_DECIMAL_OUT_OF_RANGE:
-    rb_raise(rb_eRangeError, "%+"PRIsVALUE" is out of range for %s",
-             str, ca_type_name[data_type]);
+    rb_raise(rb_eRangeError, "%s: %+"PRIsVALUE" is out of range for %s",
+             ca_calling_method_name(), str, ca_type_name[data_type]);
   default:
-    rb_raise(rb_eArgError, "%+"PRIsVALUE" cannot be read as %s",
-             str, ca_type_name[data_type]);
+    rb_raise(rb_eArgError, "%s: %+"PRIsVALUE" cannot be read as %s",
+             ca_calling_method_name(), str, ca_type_name[data_type]);
   }
 }
 
@@ -767,6 +768,7 @@ ca_obj2dbl_ok (VALUE val, double *out)
   }
   {
     int state = 0;
+    /* protect: converts the caller's value and reports failure; nothing is held */
     volatile VALUE r = rb_protect(ca_kernel_float, val, &state);
     if ( state ) {
       rb_set_errinfo(Qnil);
@@ -795,6 +797,7 @@ ca_obj2cmplx_ok (VALUE val, double complex *out)
   if ( NIL_P(val) ) {
     return 0;
   }
+  /* protect: converts the caller's value and reports failure; nothing is held */
   r = rb_protect(ca_cmplx_cell_body, val, &state);
   if ( state ) {
     rb_set_errinfo(Qnil);
@@ -819,6 +822,7 @@ ca_obj2integer_ok (VALUE val, int8_t wide_type, void *wide, VALUE *integer)
   if ( RB_TYPE_P(val, T_STRING) ) {
     return ca_decimal_string_to(val, wide_type, wide);
   }
+  /* protect: converts the caller's value and reports failure; nothing is held */
   *integer = rb_protect(ca_kernel_integer, val, &state);
   if ( state ) {
     rb_set_errinfo(Qnil);
@@ -1052,7 +1056,7 @@ ca_ptr2val (void *ap1, void *ptr1, int8_t data_type, void *ptr2)
 {
   CArray *ca1 = (CArray *)ap1;
   static CArray dummy;
-  CA_CHECK_DATA_TYPE(data_type);
+  CA_CHECK_DATA_TYPE_GIVEN(data_type);
   dummy.data_type = data_type;
   ca_cast_func_table[ca1->data_type][data_type](1, ca1, ptr1, &dummy, ptr2, NULL);
   return;
@@ -1063,7 +1067,7 @@ ca_val2ptr (int8_t data_type, void *ptr1, void *ap2, void *ptr2)
 {
   CArray *ca2 = (CArray *)ap2;
   static CArray dummy;
-  CA_CHECK_DATA_TYPE(data_type);
+  CA_CHECK_DATA_TYPE_GIVEN(data_type);
   dummy.data_type = data_type;
   ca_cast_func_table[data_type][ca2->data_type](1, &dummy, ptr1, ca2, ptr2, NULL);
   return;
@@ -1073,8 +1077,8 @@ void
 ca_val2val (int8_t data_type1, void *ptr1, int8_t data_type2, void *ptr2)
 {
   static CArray dummy1, dummy2;
-  CA_CHECK_DATA_TYPE(data_type1);
-  CA_CHECK_DATA_TYPE(data_type2);
+  CA_CHECK_DATA_TYPE_GIVEN(data_type1);
+  CA_CHECK_DATA_TYPE_GIVEN(data_type2);
   dummy1.data_type = data_type1;
   dummy2.data_type = data_type2;
   ca_cast_func_table[data_type1][data_type2](1, &dummy1, ptr1, &dummy2, ptr2, NULL);
@@ -1767,8 +1771,11 @@ rb_ca_ptr2ptr (VALUE ra1, void *ptr1, VALUE ra2, void *ptr2)
 }
 
 
+/* A cell's bytes as the value of self's data type before the last two
+   steps of ca[i]: a boolean is 0 or 1 and a Face cell is its storage
+   value.  The element readers call this, check the mask, then decode. */
 VALUE
-rb_ca_ptr2obj (VALUE self, void *ptr)
+rb_ca_ptr2obj_storage (VALUE self, void *ptr)
 {
   volatile VALUE obj;
   static CArray dummy;
@@ -1784,6 +1791,20 @@ rb_ca_ptr2obj (VALUE self, void *ptr)
   }
 }
 
+VALUE
+rb_ca_ptr2obj (VALUE self, void *ptr)
+{
+  CArray *ca;
+  VALUE obj = rb_ca_ptr2obj_storage(self, ptr);
+  TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
+  CA_FACE_STORAGE_TO_ELEMENT_IF_FACE(obj, self, ca);
+  if ( ca->data_type == CA_BOOLEAN &&
+       ( obj == INT2FIX(0) || obj == INT2FIX(1) ) ) {
+    obj = ( obj == INT2FIX(1) ) ? Qtrue : Qfalse;
+  }
+  return obj;
+}
+
 /* Surface -> storage-domain conversion for a Face store (mirror of the
    storage_to_element read hook).  Non-Face `ca` returns `obj` unchanged, so
    the non-Face store path is untouched.  For a Face, the per-obj_type C
@@ -1853,7 +1874,7 @@ rb_ca_wrap_writable (VALUE arg, VALUE rtype)
   if ( rb_obj_is_carray(obj) ) {                    /* obj == carray */
     TypedData_Get_Struct(obj, CArray, &carray_data_type, ca);
     if ( ca_is_readonly(ca) ) {
-      rb_raise(rb_eRuntimeError, "can not modify read-only array");
+      ca_refuse_read_only();
     }
     if ( NIL_P(rtype) ) {
       data_type = ca->data_type;
@@ -1891,7 +1912,7 @@ rb_ca_wrap_writable (VALUE arg, VALUE rtype)
     }
     TypedData_Get_Struct(obj, CArray, &carray_data_type, ca);
     if ( ca_is_readonly(ca) ) {
-      rb_raise(rb_eRuntimeError, "can not modify read-only array");
+      ca_refuse_read_only();
     }
     if ( NIL_P(rtype) ) {
       data_type = ca->data_type;
@@ -1905,12 +1926,9 @@ rb_ca_wrap_writable (VALUE arg, VALUE rtype)
     }
   }
   else if ( rb_memory_view_available_p(obj) ) {     /* MemoryView producer */
-    obj = rb_funcall(rb_cCArray, rb_intern("wrap_memory_view"), 1, obj);
+    obj = ca_mv_wrap(obj, Qnil, rb_cCAWrap, -1,
+                     NIL_P(rtype) ? -1 : rb_ca_guess_type(rtype), 1);
     TypedData_Get_Struct(obj, CArray, &carray_data_type, ca);
-    if ( ca_is_readonly(ca) ) {
-      rb_raise(rb_eRuntimeError,
-               "MemoryView source is read-only; can't wrap as writable");
-    }
     if ( NIL_P(rtype) ) {
       data_type = ca->data_type;
     }
@@ -2029,7 +2047,8 @@ rb_ca_wrap_readonly (VALUE arg, VALUE rtype)
     }
   }
   else if ( rb_memory_view_available_p(obj) ) {     /* MemoryView producer */
-    obj = rb_funcall(rb_cCArray, rb_intern("wrap_memory_view"), 1, obj);
+    obj = ca_mv_wrap(obj, Qnil, rb_cCAWrap, -1,
+                     NIL_P(rtype) ? -1 : rb_ca_guess_type(rtype), 0);
     TypedData_Get_Struct(obj, CArray, &carray_data_type, ca);
     if ( NIL_P(rtype) ) {
       data_type = ca->data_type;
@@ -2171,6 +2190,36 @@ ca_check_integer_fits (VALUE v, int8_t dt)
   }
 }
 
+/* The store reader for an integer cell: the value as an Integer, refused
+   when it does not fit the cell's type, as an operator refuses it.  A
+   store raises where an array cast (to_type) keeps the C conversion.  A
+   non-Integer goes through Integer() (1.5 is 1; nil and NaN raise). */
+VALUE
+ca_obj2integer_fitting (VALUE v, int8_t data_type)
+{
+  VALUE integer = RB_INTEGER_TYPE_P(v) ? v : rb_Integer(v);
+  if ( FIXNUM_P(integer) ) {
+    long x = FIX2LONG(integer);
+    int fits;
+    switch ( data_type ) {
+    case CA_INT8:   fits = ( x >= INT8_MIN  && x <= INT8_MAX );   break;
+    case CA_UINT8:  fits = ( x >= 0         && x <= UINT8_MAX );  break;
+    case CA_INT16:  fits = ( x >= INT16_MIN && x <= INT16_MAX );  break;
+    case CA_UINT16: fits = ( x >= 0         && x <= UINT16_MAX ); break;
+    case CA_INT32:  fits = ( x >= INT32_MIN && x <= INT32_MAX );  break;
+    case CA_UINT32: fits = ( x >= 0         && (unsigned long) x <= UINT32_MAX ); break;
+    case CA_INT64:  fits = 1;                                     break;
+    case CA_UINT64: fits = ( x >= 0 );                            break;
+    default:        fits = 1;                                     break;
+    }
+    if ( fits ) {
+      return integer;
+    }
+  }
+  ca_check_integer_fits(integer, data_type);
+  return integer;
+}
+
 /* A Ruby Integer operand against an integer array is taken in the array's
    own data type, refused when it does not fit (ca_check_integer_fits).
    Widening instead would make the result's type depend on a scalar's
@@ -2425,7 +2474,7 @@ ca_arg_to_data_type (VALUE obj)
   else {
     data_type = ca_value_to_data_type(obj);
   }
-  CA_CHECK_DATA_TYPE(data_type);
+  CA_CHECK_DATA_TYPE_GIVEN(data_type);
   if ( ! ca_valid[data_type] ) {
     rb_raise(rb_eArgError,
              "data type '%s' is not valid in this build",
@@ -2465,6 +2514,9 @@ int8_t
 ca_promote_type (int8_t a, int8_t b)
 {
   int test;
+  if ( a <= CA_NONE || a >= CA_NTYPE || b <= CA_NONE || b >= CA_NTYPE ) {
+    rb_raise(rb_eArgError, "invalid data_type id (%i, %i)", (int) a, (int) b);
+  }
   if ( a == b ) {
     return a;
   }
@@ -2521,6 +2573,49 @@ ca_value_match_type (int8_t t, int8_t a, int8_t b)
   }
 }
 
+/* The type a value query and a reference of type `ref` are compared in,
+   by equality or order, as `eq` compares them: the reference is read
+   through a view of that type, so the query is never cut to the
+   reference's type (3.9 does not match 3, -1 does not read as 255).
+   A Float query takes the type the operators give it beside the
+   reference; an Integer query keeps the reference's type when it fits and
+   otherwise the type its value needs, where it matches nothing; a CArray
+   query takes the type the two arrays match in (the common type, widened
+   by ca_value_match_type).  Beside a reference that is not a number, a
+   scalar query keeps the reference's type. */
+int8_t
+ca_query_match_type (int8_t ref, VALUE query)
+{
+  int ref_int   = ( ref >= CA_INT8 && ref <= CA_UINT64 );
+  int ref_float = ( ref == CA_FLOAT32 || ref == CA_FLOAT64 );
+  if ( rb_obj_is_carray(query) ) {
+    CArray *q;
+    TypedData_Get_Struct(query, CArray, &carray_data_type, q);
+    return ca_value_match_type(ca_promote_type(ref, q->data_type), ref,
+                               q->data_type);
+  }
+  if ( ! ref_int && ! ref_float && ref != CA_BOOLEAN ) {
+    return ref;
+  }
+  if ( RB_FLOAT_TYPE_P(query) ) {
+    return ca_promote_scalar_type(ref, query, CA_FLOAT64);
+  }
+  if ( RB_INTEGER_TYPE_P(query) ) {
+    return ref_int ? ca_promote_scalar_type(ref, query, CA_INT64) : ref;
+  }
+  return ref;
+}
+
+/* ca.query_match_type(query) -- ca_query_match_type with self as the
+   reference, for the set family and locate_addr. */
+static VALUE
+rb_ca_query_match_type (VALUE self, VALUE query)
+{
+  CArray *ca;
+  GetCArray(self, ca);
+  return rb_ca_data_type_to_sym(ca_query_match_type(ca->data_type, query));
+}
+
 /* ca.value_match_type(t, other_type) -- ca_value_match_type with self's
    data type as the first operand, for the set family and locate_addr. */
 static VALUE
@@ -2553,13 +2648,23 @@ ca_arg_is_scalar (VALUE obj)
    by the rule the operators apply: a scalar of the same kind takes the
    array's type (0.1 beside float32 is float32, 1 beside int8 is int8); one
    of another kind promotes (1.5 beside int32 is float64).  An Integer that
-   does not fit the array's integer type takes the type of its value, where
-   an operator would raise RangeError. */
+   does not fit the array's integer type takes a type that holds it and the
+   array's values (int64, or object where no integer type does), where an
+   operator would raise RangeError. */
 int8_t
 ca_promote_scalar_type (int8_t at, VALUE obj, int8_t st)
 {
   if ( RB_INTEGER_TYPE_P(obj) && at >= CA_INT8 && at <= CA_UINT64 ) {
-    return ( ca_integer_range_side(obj, at) == 0 ) ? at : ca_promote_type(at, st);
+    int8_t vt;
+    if ( ca_integer_range_side(obj, at) == 0 ) {
+      return at;
+    }
+    /* The type the value needs, widened so that the array's values are
+       kept beside it (a uint64 array and -1 meet in object). */
+    vt = ( ca_integer_range_side(obj, CA_INT64) == 0 )  ? CA_INT64
+       : ( ca_integer_range_side(obj, CA_UINT64) == 0 ) ? CA_UINT64
+       : CA_OBJECT;
+    return ca_value_match_type(ca_promote_type(at, vt), at, vt);
   }
   if ( ca_cast_table2[st][at] >= 0 ) {
     return at;
@@ -2606,6 +2711,8 @@ rb_ca_s_result_type (int argc, VALUE *argv, VALUE klass)
       cur = ( cur < 0 ) ? t : ca_promote_scalar_type(cur, argv[i], t);
     }
   }
+  /* argv points into rest, and classifying an argument can allocate */
+  RB_GC_GUARD(rest);
   /* Return Symbol for family consistency with
      CArray.value_to_data_type and ca.data_type. */
   return rb_ca_data_type_to_sym(cur);
@@ -2859,14 +2966,23 @@ rb_ca_clip_uint64 (VALUE self)
     uint64_t *op = (uint64_t *) out->ptr;
     ca_size_t n = ca->elements;
     const double LIMIT = 18446744073709551616.0; /* 2^64, exact in f64 */
+    boolean8_t *m = ca_has_mask(src) ? (boolean8_t *) src->mask->ptr : NULL;  /* attached with src */
+    int found_nan = 0;
     for ( ca_size_t i = 0; i < n; i++ ) {
       double v = sp[i];
-      if ( v != v )         op[i] = 0;              /* NaN -> 0 */
+      if ( v != v ) {                 /* NaN has no integer: refused below */
+        op[i] = 0;
+        if ( ! m || ! m[i] ) found_nan = 1;
+      }
       else if ( v >= LIMIT ) op[i] = UINT64_MAX;
       else if ( v <= 0.0 )   op[i] = 0;
       else                   op[i] = (uint64_t) v;
     }
     ca_detach(src);
+    if ( found_nan ) {
+      rb_raise(rb_eFloatDomainError, "%s: NaN cannot be converted to uint64",
+               ca_calling_method_name());
+    }
     if ( ca_has_mask(ca) ) {
       ca_copy_mask(out, ca);
     }
@@ -2889,7 +3005,7 @@ rb_ca_clip_uint64 (VALUE self)
      Numeric  -> CScalar, or #to_ca when the object answers it
      String   -> the whitespace / `,` / `;` / `_`->UNDEF parser, which reads
                  far more naturally in Ruby and so is the one branch that
-                 calls back out to it (CArray.__cast_string__ in
+                 calls back out to it (CArray.cast_string in
                  carray/basics.rb, eager-loaded).  It receives the data_type
                  as a Symbol.
 
@@ -3541,6 +3657,8 @@ Init_carray_cast (void)
            "result_type", rb_ca_s_result_type, -1);
   rb_define_private_method(rb_cCArray,
            "value_match_type", rb_ca_value_match_type, 2);
+  rb_define_private_method(rb_cCArray,
+           "query_match_type", rb_ca_query_match_type, 1);
 
   rb_define_singleton_method(rb_cCArray,
            "promote_list", rb_ca_s_promote_list, -1);
@@ -3554,7 +3672,7 @@ Init_carray_cast (void)
      classes registered in ext/carray_data_type.c. */
   id_new_cast               = rb_intern("new");
   id_guess_array_shape_cast = rb_intern("guess_array_shape");
-  id_cast_string            = rb_intern("__cast_string__");
+  id_cast_string            = rb_intern("cast_string");
   id_to_ca_cast             = rb_intern("to_ca");
   id_length_cast            = rb_intern("length");
   id_begin_cast             = rb_intern("begin");

data/ext/carray_cast_func.rb

@@ -1,4 +1,5 @@
 data_type = []
+type_const = {}
 %w[
   CA_FIXLEN
   CA_BOOLEAN
@@ -20,6 +21,7 @@ data_type = []
 ].each_with_index do |name, i|
   eval("#{name} = #{i}")
   data_type.push(i)
+  type_const[i] = name
 end
 
 ctype = {
@@ -300,7 +302,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 +316,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,7 +336,34 @@ 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 has no integer and C leaves its
+    # conversion undefined.  A cell that is not masked refuses it before
+    # anything is written.  #to_type masks NaN cells first (UNDEF), so
+    # only a store, a view and a single cell reach the raise.
+    nan_check = ""
+    if (FLOAT+[CA_CMPLX64, CA_CMPLX128]).include?(type1) && INTEGER.include?(type2)
+      isnan = if [CA_CMPLX64, CA_CMPLX128].include?(type1)
+                "( isnan(creal(q1[k])) || isnan(cimag(q1[k])) )"
+              else
+                "isnan(q1[k])"
+              end
+      nan_check = <<-END_CHECK.gsub(/^ {6}/, '')
+         for (k=0; k<n; k++) {
+           if ( ( ! m || ! m[k] ) && #{isnan} ) {
+             rb_raise(rb_eFloatDomainError, "%s: NaN cannot be converted to %s",
+                      ca_calling_method_name(), 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)
       {
@@ -341,6 +372,7 @@ puts
          #{ctype2} *q2 = ptr2;
          #{ctype2} *p2 = q2;
          ca_size_t k;
+      @@NAN_CHECK@@
          if ( m ) {
            boolean8_t *pm = m;
            for (k=0; k<n; k++) {
@@ -348,7 +380,7 @@ puts
              if ( ! *pm ) { 
                p1 = q1 + k;
                p2 = q2 + k;
-               *p2 = (#{ctype2}) *p1;
+               *p2 = (#{ctype2}) @@VIA@@*p1;
              }
            }
          }
@@ -356,7 +388,7 @@ puts
            for (k=0; k<n; k++) {
              p1 = q1 + k;
              p2 = q2 + k;
-             *p2 = (#{ctype2}) *p1;
+             *p2 = (#{ctype2}) @@VIA@@*p1;
            }
          }
          return;
@@ -478,9 +510,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);"

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

@@ -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;
 }