carray 3.0.3 → 3.0.5

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);
@@ -1211,26 +1215,48 @@ typedef struct {
   boolean8_t *scratch;
 } ca_to_type_ctx_t;
 
-/* Marks in `m` the cells of a float or complex array that hold NaN (in
-   either part).  A NaN has no integer, and C leaves its conversion
-   undefined. */
+/* Whether a double truncates into integer type `dt`: not NaN, not an
+   infinity, and inside the open interval of values whose integer part `dt`
+   holds (closed below for int64: -2**63-1 rounds to -2**63 in double).
+   The same bounds as the generated casts in carray_cast_func.rb. */
+static int
+ca_double_fits_integer (double v, int8_t dt)
+{
+  switch ( dt ) {
+  case CA_INT8:   return v > -129.0                 && v < 128.0;
+  case CA_UINT8:  return v > -1.0                   && v < 256.0;
+  case CA_INT16:  return v > -32769.0               && v < 32768.0;
+  case CA_UINT16: return v > -1.0                   && v < 65536.0;
+  case CA_INT32:  return v > -2147483649.0          && v < 2147483648.0;
+  case CA_UINT32: return v > -1.0                   && v < 4294967296.0;
+  case CA_INT64:  return v >= -9223372036854775808.0 && v < 9223372036854775808.0;
+  case CA_UINT64: return v > -1.0                   && v < 18446744073709551616.0;
+  default:        return 1;
+  }
+}
+
+/* Marks in `m` the cells of a float or complex array that have no integer
+   of type `dt`: NaN (in either part), an infinity, or a value out of
+   range.  C leaves their conversion undefined, and machines differ. */
 static void
-ca_mark_nan (CArray *ca, boolean8_t *m)
+ca_mark_unconvertible (CArray *ca, boolean8_t *m, int8_t dt)
 {
   ca_size_t i, n = ca->elements;
   switch ( ca->data_type ) {
-  case CA_FLOAT32: { float32_t *p = (float32_t *) ca->ptr;
-    for (i=0; i<n; i++) if ( isnan(p[i]) ) m[i] = 1;
+  case CA_FLOAT32: { ca_u_float32_t *p = (ca_u_float32_t *) ca->ptr;
+    for (i=0; i<n; i++) if ( ! ca_double_fits_integer(p[i], dt) ) m[i] = 1;
     break; }
-  case CA_FLOAT64: { float64_t *p = (float64_t *) ca->ptr;
-    for (i=0; i<n; i++) if ( isnan(p[i]) ) m[i] = 1;
+  case CA_FLOAT64: { ca_u_float64_t *p = (ca_u_float64_t *) ca->ptr;
+    for (i=0; i<n; i++) if ( ! ca_double_fits_integer(p[i], dt) ) m[i] = 1;
     break; }
 #ifdef HAVE_COMPLEX_H
-  case CA_CMPLX64: { cmplx64_t *p = (cmplx64_t *) ca->ptr;
-    for (i=0; i<n; i++) if ( isnan(crealf(p[i])) || isnan(cimagf(p[i])) ) m[i] = 1;
+  case CA_CMPLX64: { ca_u_cmplx64_t *p = (ca_u_cmplx64_t *) ca->ptr;
+    for (i=0; i<n; i++)
+      if ( ! ca_double_fits_integer(crealf(p[i]), dt) || isnan(cimagf(p[i])) ) m[i] = 1;
     break; }
-  case CA_CMPLX128: { cmplx128_t *p = (cmplx128_t *) ca->ptr;
-    for (i=0; i<n; i++) if ( isnan(creal(p[i])) || isnan(cimag(p[i])) ) m[i] = 1;
+  case CA_CMPLX128: { ca_u_cmplx128_t *p = (ca_u_cmplx128_t *) ca->ptr;
+    for (i=0; i<n; i++)
+      if ( ! ca_double_fits_integer(creal(p[i]), dt) || isnan(cimag(p[i])) ) m[i] = 1;
     break; }
 #endif
   default:
@@ -1270,11 +1296,11 @@ ca_to_type_cast (VALUE arg)
     else {
       memset(scratch, 0, ne);
     }
-    /* float -> integer: a NaN cell becomes UNDEF, as an unparseable object
-       cell does.  A finite value outside the integer type is converted the
-       way the machine's C converts it, which differs between machines. */
+    /* float -> integer: a cell with no integer of the type (NaN, an
+       infinity, a value out of range) becomes UNDEF, as an unparseable
+       object cell does. */
     if ( from_float ) {
-      ca_mark_nan(ca, scratch);
+      ca_mark_unconvertible(ca, scratch, cb->data_type);
       memset(cb->ptr, 0, ne * cb->bytes);
     }
     ca_cast_block_with_mask(ne, ca, ca->ptr, cb, cb->ptr, scratch);
@@ -1767,8 +1793,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 +1813,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 +1896,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 +1934,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 +1948,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;
     }
@@ -1999,7 +2039,9 @@ rb_ca_wrap_readonly (VALUE arg, VALUE rtype)
     else {
       CArray *ca_tmp;
       volatile VALUE ref = obj;
-      ca_size_t dim = RSTRING_LEN(ref)/ca_sizeof[data_type];
+      ca_size_t bytes = ca_sizeof[data_type];
+      CA_CHECK_BYTES_GIVEN(data_type, bytes);
+      ca_size_t dim = RSTRING_LEN(ref)/bytes;
       obj = rb_carray_new(data_type, 1, &dim, 0, NULL);
       TypedData_Get_Struct(obj, CArray, &carray_data_type, ca_tmp);
       memcpy(ca_tmp->ptr, RSTRING_PTR(ref), dim * ca_sizeof[data_type]);
@@ -2029,7 +2071,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;
@@ -2131,7 +2174,15 @@ ca_fixlen_scalar_operand (volatile VALUE *scalar, VALUE reference)
   if ( cr->data_type != CA_FIXLEN ) {
     return 0;
   }
-  *scalar = rb_cscalar_new_with_value(CA_FIXLEN, cr->bytes, *scalar);
+  /* A String longer than the cell keeps its length: cut to the cell, it
+     would equal a cell it does not (a two-byte "ab" equal to "abX").  The
+     wider scalar is then compared as two fixlen widths are. */
+  {
+    ca_size_t len = (ca_size_t) RSTRING_LEN(*scalar);
+    *scalar = rb_cscalar_new_with_value(CA_FIXLEN,
+                                        len > cr->bytes ? len : cr->bytes,
+                                        *scalar);
+  }
   return 1;
 }
 
@@ -2171,6 +2222,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
@@ -2191,6 +2272,69 @@ ca_integer_scalar_operand (volatile VALUE *scalar, VALUE reference)
   return 1;
 }
 
+/* A Ruby Array operand against a numeric or boolean array is read as its
+   cells, as the array CArray.wrap_readonly makes of it (nested Arrays give
+   its axes).  Its data type is the
+   one the cells would take one at a time as scalar operands of the same
+   operation (an Integer
+   against an integer array takes the array's type and has to fit it),
+   promoted together.  Against an object array, a Face or a fixlen array an
+   Array stays one value. */
+static int
+ca_array_operand (volatile VALUE *ary, VALUE reference, int both)
+{
+  CArray *cr;
+  volatile VALUE flat, probe_self, probe;
+  long i, n;
+  int8_t type = -1, seen_fix = -1, seen_big = -1, seen_flo = -1, seen_cpx = -1,
+         seen_bool = -1;
+
+  if ( ! RB_TYPE_P(*ary, T_ARRAY) || ! rb_obj_is_carray(reference) ) {
+    return 0;
+  }
+  TypedData_Get_Struct(reference, CArray, &carray_data_type, cr);
+  if ( ca_is_face(cr) || ca_is_object_type(cr) || ca_is_fixlen_type(cr) ) {
+    return 0;
+  }
+
+  flat = rb_funcall(*ary, rb_intern("flatten"), 0);
+  n = RARRAY_LEN(flat);
+  for (i = 0; i < n; i++) {
+    VALUE e = RARRAY_AREF(flat, i);
+    int8_t *seen, t;
+    CArray *cp;
+    if      ( FIXNUM_P(e) )               seen = &seen_fix;
+    else if ( RB_TYPE_P(e, T_BIGNUM) )    seen = &seen_big;
+    else if ( RB_FLOAT_TYPE_P(e) )        seen = &seen_flo;
+    else if ( RB_TYPE_P(e, T_COMPLEX) )   seen = &seen_cpx;
+    else if ( e == Qtrue || e == Qfalse ) seen = &seen_bool;
+    else                                  seen = NULL;
+    if ( RB_INTEGER_TYPE_P(e) && ca_is_integer_type(cr) ) {
+      ca_check_integer_fits(e, cr->data_type);
+    }
+    if ( seen && *seen >= 0 ) {
+      continue;
+    }
+    probe_self = reference;
+    probe      = e;
+    if ( both ) {
+      rb_ca_cast_self_or_other(&probe_self, &probe);
+    }
+    else {
+      rb_ca_cast_other((VALUE *) &probe_self, (volatile VALUE *) &probe);
+    }
+    TypedData_Get_Struct(probe, CArray, &carray_data_type, cp);
+    t = cp->data_type;
+    if ( seen ) *seen = t;
+    type = ( type < 0 ) ? t : ca_promote_type(type, t);
+  }
+  if ( type < 0 ) {
+    type = cr->data_type;
+  }
+  *ary = rb_ca_wrap_readonly(*ary, INT2NUM(type));
+  return 1;
+}
+
 /* CArray.cast(value) -- singleton entry delegating to rb_ca_cast, which
    returns a CArray unchanged and coerces a Ruby value to a CScalar / CArray.
    User doc lives in yard-stubs/carray_cast.rb. */
@@ -2255,6 +2399,10 @@ rb_ca_cast_self_or_other (volatile VALUE *self, volatile VALUE *other)
     *other = ca_operand_from_memory_view(*other);
   }
 
+  if ( ! ca_array_operand(other, *self, 1) ) {
+    ca_array_operand(self, *other, 1);
+  }
+
   if ( ! rb_obj_is_carray(*self) ) {
     self_is_object = 1;
     if ( rb_ca_is_object_type(*other) ) {
@@ -2378,12 +2526,32 @@ rb_ca_cast_self_or_other (volatile VALUE *self, volatile VALUE *other)
     return;
   }
 
-  rb_raise(rb_eTypeError,
+  /* A data type the operation does not take, as `sqrt!` on an integer
+     array is refused (CArray::DataTypeError is a TypeError). */
+  rb_raise(rb_eCADataTypeError,
            "can't coerce carray with data_types of '%s' and '%s'",
            ca_coerce_operand_name(*self, ca),
            ca_coerce_operand_name(*other, cb));
 }
 
+/* Refuses a pair of arrays with no common data_type in the words of
+   rb_ca_cast_self_or_other (the eager operators'), and returns otherwise
+   without casting either.  A lazy builder calls it before it works out
+   the kernel's data_types, so that a pair the eager operator refuses is
+   refused the same way. */
+void
+ca_refuse_without_common_type (VALUE self, VALUE other)
+{
+  CArray *ca, *cb;
+  TypedData_Get_Struct(self,  CArray, &carray_data_type, ca);
+  TypedData_Get_Struct(other, CArray, &carray_data_type, cb);
+  if ( ca->data_type != cb->data_type
+       && ca_cast_table[cb->data_type][ca->data_type] < 0
+       && ca_cast_table[ca->data_type][cb->data_type] < 0 ) {
+    rb_ca_cast_self_or_other(&self, &other);   /* raises */
+  }
+}
+
 /* CArray.cast_self_or_other(self, other) — promote self and other
  * to a common data_type and return [self', other'].  Wraps the
  * void rb_ca_cast_self_or_other above into a class method.
@@ -2422,10 +2590,19 @@ ca_arg_to_data_type (VALUE obj)
     /* MemoryView producer -> its format's data_type (T_STRING excluded above,
        so a String never reaches here).  data_type already assigned. */
   }
+  else if ( rb_memory_view_available_p(obj) ) {
+    /* A MemoryView producer whose format says nothing usable (typeless, the
+       other byte order) is read as the operators read it, and refused in
+       the same words. */
+    VALUE ca_obj = ca_operand_from_memory_view(obj);
+    CArray *ca;
+    TypedData_Get_Struct(ca_obj, CArray, &carray_data_type, ca);
+    data_type = ca->data_type;
+  }
   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 +2642,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 +2701,67 @@ 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;
+}
+
+/* A fixlen array searched or counted for a String longer than its cells
+   is read as cells of the String's width (NUL-padded), so the query is not
+   cut to the cell: "abX" matches no two-byte cell, as a wider scalar does
+   not in `eq`.  Anything else is returned as given. */
+VALUE
+ca_fixlen_widen_for_query (VALUE self, VALUE query)
+{
+  CArray *ca;
+  if ( ! RB_TYPE_P(query, T_STRING) || ! rb_obj_is_carray(self) ) {
+    return self;
+  }
+  TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
+  if ( ca->data_type != CA_FIXLEN || RSTRING_LEN(query) <= ca->bytes ) {
+    return self;
+  }
+  return rb_ca_to_type(self, INT2NUM(CA_FIXLEN), SIZE2NUM(RSTRING_LEN(query)));
+}
+
+/* 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
@@ -2546,20 +2787,30 @@ ca_arg_is_scalar (VALUE obj)
   if ( TYPE(obj) == T_SYMBOL || TYPE(obj) == T_STRING || TYPE(obj) == T_CLASS ) {
     return 0;
   }
-  return ca_mv_probe_data_type(obj) < 0;
+  return ! rb_memory_view_available_p(obj);
 }
 
 /* The type a scalar `obj` (of type `st`) and an array of type `at` share,
    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 +2857,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);
@@ -2745,6 +2998,8 @@ rb_ca_cast_other (VALUE *self, volatile VALUE *other)
     *other = ca_operand_from_memory_view(*other);
   }
 
+  ca_array_operand(other, *self, 0);
+
   if ( ! rb_obj_is_carray(*other) ) {
     if ( rb_ca_is_object_type(*self) ) {
       *other = rb_cscalar_new_with_value(CA_OBJECT, 0, *other);
@@ -2787,7 +3042,9 @@ rb_ca_cast_other (VALUE *self, volatile VALUE *other)
     return;
   }
 
-  rb_raise(rb_eTypeError,
+  /* A data type the operation does not take, as `sqrt!` on an integer
+     array is refused (CArray::DataTypeError is a TypeError). */
+  rb_raise(rb_eCADataTypeError,
            "can't coerce carray with data_types of '%s' and '%s'",
            ca_coerce_operand_name(*self, ca),
            ca_coerce_operand_name(*other, cb));
@@ -2813,69 +3070,89 @@ rb_ca_cast_with (VALUE self, VALUE other)
 /* -----------------------------------------------------------------------
    clip_<type> family — clip into the target data type's representable
    range, then cast.  Sugar for `clip(lo, hi).as_<type>`.
+
+   A float source takes a saturating path instead.  The type's maximum is
+   not always exact in the source float (INT64_MAX and UINT64_MAX round up
+   in float64, INT32_MAX and UINT32_MAX in float32), so clip-then-cast
+   would hand the cast a value just past the range.  Instead each cell is
+   compared in double against the range the cast truncates into
+   (ca_double_fits_integer) and saturates to the type's minimum or maximum
+   outside it.  A NaN that is not masked is refused.
 ----------------------------------------------------------------------- */
 
-#define CLIP_CAST_FUNC(name, lo_expr, hi_expr, cast_func) \
+static VALUE
+ca_clip_float_to_integer (VALUE self, int8_t to_dt)
+{
+  CArray *ca;
+  GetCArray(self, ca);
+  volatile VALUE vsrc = ( ca->data_type == CA_FLOAT64 ) ? self : rb_ca_as_float64(self);
+  CArray *src;
+  GetCArray(vsrc, src);
+  volatile VALUE vout = rb_carray_new(to_dt, ca->ndim, ca->dim, 0, NULL);
+  CArray *out;
+  GetCArray(vout, out);
+  ca_attach(src);   /* window: nothing raises inside */
+  double *sp = (double *) src->ptr;
+  char   *op = out->ptr;
+  ca_size_t n = ca->elements;
+  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];
+    int fits = ca_double_fits_integer(v, to_dt);
+    if ( v != v ) {                 /* NaN has no integer: refused below */
+      v = 0.0;
+      fits = 1;
+      if ( ! m || ! m[i] ) found_nan = 1;
+    }
+#define CLIP_STORE(type, lo, hi) \
+    ((type *) op)[i] = fits ? (type) v : ( v > 0 ? (hi) : (lo) )
+    switch ( to_dt ) {
+    case CA_INT8:   CLIP_STORE(int8_t,   INT8_MIN,  INT8_MAX);   break;
+    case CA_UINT8:  CLIP_STORE(uint8_t,  0,         UINT8_MAX);  break;
+    case CA_INT16:  CLIP_STORE(int16_t,  INT16_MIN, INT16_MAX);  break;
+    case CA_UINT16: CLIP_STORE(uint16_t, 0,         UINT16_MAX); break;
+    case CA_INT32:  CLIP_STORE(int32_t,  INT32_MIN, INT32_MAX);  break;
+    case CA_UINT32: CLIP_STORE(uint32_t, 0,         UINT32_MAX); break;
+    case CA_INT64:  CLIP_STORE(int64_t,  INT64_MIN, INT64_MAX);  break;
+    case CA_UINT64: CLIP_STORE(uint64_t, 0,         UINT64_MAX); break;
+    }
+#undef CLIP_STORE
+  }
+  ca_detach(src);
+  if ( found_nan ) {
+    rb_raise(rb_eFloatDomainError, "%s: NaN cannot be converted to %s",
+             ca_calling_method_name(), ca_type_name[to_dt]);
+  }
+  if ( ca_has_mask(ca) ) {
+    ca_copy_mask(out, ca);
+  }
+  return vout;
+}
+
+#define CLIP_CAST_FUNC(name, to_dt, lo_expr, hi_expr, cast_func) \
 static VALUE \
 rb_ca_##name (VALUE self) \
 { \
+  CArray *ca; \
+  GetCArray(self, ca); \
+  if ( ca->data_type == CA_FLOAT32 || ca->data_type == CA_FLOAT64 ) { \
+    return ca_clip_float_to_integer(self, to_dt); \
+  } \
   return cast_func(rb_ca_clip(self, lo_expr, hi_expr)); \
 }
 
-CLIP_CAST_FUNC(clip_int8,   INT2NUM(-128),                    INT2NUM(127),                    rb_ca_as_int8)
-CLIP_CAST_FUNC(clip_int16,  INT2NUM(-32768),                  INT2NUM(32767),                  rb_ca_as_int16)
-CLIP_CAST_FUNC(clip_int32,  INT2NUM(-2147483648),             INT2NUM(2147483647),             rb_ca_as_int32)
-CLIP_CAST_FUNC(clip_int64,  LL2NUM(-9223372036854775807-1),   LL2NUM(9223372036854775807),     rb_ca_as_int64)
-CLIP_CAST_FUNC(clip_uint8,  INT2NUM(0),                       INT2NUM(255),                    rb_ca_as_uint8)
-CLIP_CAST_FUNC(clip_uint16, INT2NUM(0),                       INT2NUM(65535),                  rb_ca_as_uint16)
-CLIP_CAST_FUNC(clip_uint32, INT2NUM(0),                       UINT2NUM(4294967295U),           rb_ca_as_uint32)
+CLIP_CAST_FUNC(clip_int8,   CA_INT8,   INT2NUM(-128),                  INT2NUM(127),                  rb_ca_as_int8)
+CLIP_CAST_FUNC(clip_int16,  CA_INT16,  INT2NUM(-32768),                INT2NUM(32767),                rb_ca_as_int16)
+CLIP_CAST_FUNC(clip_int32,  CA_INT32,  INT2NUM(-2147483648),           INT2NUM(2147483647),           rb_ca_as_int32)
+CLIP_CAST_FUNC(clip_int64,  CA_INT64,  LL2NUM(-9223372036854775807-1), LL2NUM(9223372036854775807),   rb_ca_as_int64)
+CLIP_CAST_FUNC(clip_uint8,  CA_UINT8,  INT2NUM(0),                     INT2NUM(255),                  rb_ca_as_uint8)
+CLIP_CAST_FUNC(clip_uint16, CA_UINT16, INT2NUM(0),                     INT2NUM(65535),                rb_ca_as_uint16)
+CLIP_CAST_FUNC(clip_uint32, CA_UINT32, INT2NUM(0),                     UINT2NUM(4294967295U),         rb_ca_as_uint32)
+CLIP_CAST_FUNC(clip_uint64, CA_UINT64, INT2NUM(0),                     ULL2NUM(18446744073709551615ULL), rb_ca_as_uint64)
 
 #undef CLIP_CAST_FUNC
 
-/* CArray#clip_uint64 -- dedicated implementation.
-
-   UINT64_MAX (= 2^64-1) is not exactly representable in float64; the nearest
-   double rounds up to 2^64.  A generic clip-then-cast path therefore clamps
-   an overflowing float source (e.g. 1e20) to 2^64 and the subsequent cast to
-   uint64 wraps around to 0.  For floating-point sources we take a saturating
-   path: compare in float space against 2^64 (which IS representable) and
-   saturate to UINT64_MAX above it and 0 below zero.  Other source data types use
-   the plain clip-then-cast path. */
-static VALUE
-rb_ca_clip_uint64 (VALUE self)
-{
-  CArray *ca;
-  GetCArray(self, ca);
-  int dt = ca->data_type;
-  if ( dt == CA_FLOAT32 || dt == CA_FLOAT64 ) {
-    volatile VALUE vsrc = ( dt == CA_FLOAT64 ) ? self : rb_ca_as_float64(self);
-    CArray *src;
-    GetCArray(vsrc, src);
-    volatile VALUE vout = rb_carray_new(CA_UINT64, ca->ndim, ca->dim, 0, NULL);
-    CArray *out;
-    GetCArray(vout, out);
-    ca_attach(src);   /* window: nothing raises inside */
-    double  *sp = (double  *) src->ptr;
-    uint64_t *op = (uint64_t *) out->ptr;
-    ca_size_t n = ca->elements;
-    const double LIMIT = 18446744073709551616.0; /* 2^64, exact in f64 */
-    for ( ca_size_t i = 0; i < n; i++ ) {
-      double v = sp[i];
-      if ( v != v )         op[i] = 0;              /* NaN -> 0 */
-      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 ( ca_has_mask(ca) ) {
-      ca_copy_mask(out, ca);
-    }
-    return vout;
-  }
-  return rb_ca_as_uint64(rb_ca_clip(self, INT2NUM(0),
-                                    ULL2NUM(18446744073709551615ULL)));
-}
-
 /* ------------------------------------------------------------------------
    Global cast functions CA_INT32(data) ... CA_OBJECT(data) etc.
 
@@ -2889,7 +3166,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 +3818,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 +3833,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");