carray 3.0.2 → 3.0.4

data/ext/carray_count.c

@@ -12,6 +12,7 @@
 
 #include "ruby.h"
 #include "carray.h"
+#include "carray_internal.h"   /* ca_attach_window */
 #include "ca_obj_face.h"
 #include <math.h>
 #include <float.h>
@@ -46,6 +47,91 @@ VALUE rb_ca_count_not_masked (int argc, VALUE *argv, VALUE self);
                                     cell; a short String query is padded
                                     out to the cell width) */
 
+static VALUE rb_ca_count (int argc, VALUE *argv, VALUE self);
+
+/* count(v: CArray): the per-cell counts, run with v attached. */
+
+typedef struct {
+  VALUE          self;
+  VALUE          rval;
+  CArray        *cv;
+  CArray        *cout;
+  ca_size_t      base_elements;
+  int            inner_argc;
+  VALUE         *inner_axes;
+  volatile VALUE opt_hash;
+} ca_count_each_ctx_t;
+
+static VALUE
+ca_count_each_body (VALUE arg)
+{
+  ca_count_each_ctx_t *c = (ca_count_each_ctx_t *) arg;
+  CArray    *cout = c->cout;
+  int64_t   *out_ptr = (int64_t *) cout->ptr;
+  boolean8_t *out_mask = NULL;
+  ca_size_t  v_elements = c->cv->elements;
+  ca_size_t  base_elements = c->base_elements;
+  /* inner_argv layout: [vk_scalar, axis..., axis..., [opt_hash]]
+     inner_call_argc = 1 (vk) + inner_argc (axes) + (opt_hash ? 1 : 0). */
+  int inner_call_argc = 1 + c->inner_argc + (NIL_P(c->opt_hash) ? 0 : 1);
+  VALUE inner_argv[CA_RANK_MAX + 2];
+  for (int j = 0; j < c->inner_argc; j++) inner_argv[1 + j] = c->inner_axes[j];
+  if ( ! NIL_P(c->opt_hash) ) inner_argv[1 + c->inner_argc] = c->opt_hash;
+
+  for (ca_size_t k = 0; k < v_elements; k++) {
+    /* Extract vk as a scalar VALUE via flat addr.  rb_ca_fetch_addr
+       takes a ca_size_t addr (not a Ruby VALUE). */
+    VALUE vk = rb_ca_fetch_addr(c->rval, k);
+    VALUE sub;
+    /* A masked query cell asks nothing: its count is masked.  Passing it
+       on would ask count(UNDEF), the count of self's masked cells. */
+    if ( vk == CA_UNDEF ) {
+      sub = CA_UNDEF;
+    }
+    else {
+      inner_argv[0] = vk;
+      sub = rb_ca_count(inner_call_argc, inner_argv, c->self);
+    }
+
+    /* Place sub into output[..., k] slot.
+       Output stride for v-axis = 1, base stride = v_elements. */
+    if ( sub == CA_UNDEF ) {
+      if ( ! out_mask ) {
+        ca_create_mask(cout);
+        out_mask = (boolean8_t *) cout->mask->ptr;
+      }
+      for (ca_size_t i = 0; i < base_elements; i++) {
+        out_ptr[i * v_elements + k] = 0;
+        out_mask[i * v_elements + k] = 1;
+      }
+    } else if ( rb_obj_is_kind_of(sub, rb_cInteger) ) {
+      /* Full reduction: sub is a single integer. */
+      out_ptr[k] = NUM2LL(sub);
+    } else if ( rb_obj_is_kind_of(sub, rb_cCArray) ) {
+      CArray *csub;
+      GetCArray(sub, csub);
+      ca_attach(csub);   /* window: the inner count answered an entity; nothing raises inside */
+      int64_t *sub_ptr = (int64_t *) csub->ptr;
+      boolean8_t *sub_mask = (csub->mask) ? (boolean8_t *) csub->mask->ptr : NULL;
+      for (ca_size_t i = 0; i < base_elements; i++) {
+        out_ptr[i * v_elements + k] = sub_ptr[i];
+        if ( sub_mask && sub_mask[i] ) {
+          if ( ! out_mask ) {
+            ca_create_mask(cout);
+            out_mask = (boolean8_t *) cout->mask->ptr;
+          }
+          out_mask[i * v_elements + k] = 1;
+        }
+      }
+      ca_detach(csub);
+    } else {
+      rb_raise(rb_eRuntimeError,
+               "count(v: CArray): unexpected sub-result type");
+    }
+  }
+  return Qnil;
+}
+
 static VALUE
 rb_ca_count (int argc, VALUE *argv, VALUE self)
 {
@@ -57,10 +143,11 @@ rb_ca_count (int argc, VALUE *argv, VALUE self)
      ladder.  kwargs reach a -1 C method as a trailing options hash, so a
      bare `count(axis: k)` arrives as argc==1 with argv[0] a Hash; discount
      that trailing hash (same convention as the CArray-broadcast branch
-     below) before deciding there is no positional value.  argv is forwarded
-     verbatim so the axis: kwarg passes through. */
+     below) before deciding there is no positional value.  A Hash passed
+     positionally is the value to count.  argv is forwarded verbatim so the
+     axis: kwarg passes through. */
   {
-    int has_opts = ( argc >= 1 &&
+    int has_opts = ( argc >= 1 && rb_keyword_given_p() &&
                      rb_obj_is_kind_of(argv[argc - 1], rb_cHash) );
     if ( argc - (has_opts ? 1 : 0) < 1 ) {
       return rb_ca_count_not_masked(argc, argv, self);
@@ -78,44 +165,36 @@ rb_ca_count (int argc, VALUE *argv, VALUE self)
   /* Face gate, mirroring the search / linear family (ext/carray_order.c):
      descend an ORDERABLE Face to its storage so the equality runs on the
      numeric storage, and let the reference reconcile the query into its own
-     space -- a COMPARABLE Face compares directly (strip a Face query, take a
-     plain one as-is), a unit-bearing one calls its own to_comparable for any
-     query type (Face CArray, Element, Time, DateTime).  A Face that counts
+     space (ca_face_reconcile_operand).  A Face that counts
      by other means never arrives here: CACategorical / CAConstString define
      their own #count in Ruby.  Placed after the mask-state branches above,
      which read the mask the Face already shares with its storage, and before
      the broadcast branch, so a reconciled query array recurses as storage. */
   if ( ca_is_face(src) ) {
-    volatile VALUE self_ref = self;
     int query_was_scalar = ! rb_obj_is_carray(rval);
-    if ( ! ca_test_flag(src, CA_FLAG_FACE_ORDERABLE_STORAGE) ) {
-      rb_raise(rb_eArgError,
-               "count(v): Face-typed input (%s) is not orderable by storage; "
-               "use ca.parent to count the raw storage",
-               rb_obj_classname(self));
+    if ( src->obj_type == CA_OBJ_RECORD && query_was_scalar ) {
+      /* A record is its bytes: a struct element counts as its encoding. */
+      rval = ca_face_element_to_storage(self, src, rval);
     }
-    if ( ca_test_flag(src, CA_FLAG_FACE_COMPARABLE_STORAGE) ) {
-      if ( ! query_was_scalar ) {
-        rval = ca_face_operand_descend(rval, "count(v)");
+    else {
+      if ( src->obj_type != CA_OBJ_RECORD ) {
+        ca_face_require_orderable(self, "count(v)", "count");
       }
-    }
-    else if ( rb_respond_to(self_ref, rb_intern("to_comparable")) ) {
-      rval = rb_ca_strip_face_value(rb_funcall(self_ref,
-                                               rb_intern("to_comparable"),
-                                               1, rval));
-      /* to_comparable lifts a scalar query to a length-1 array; unwrap it so a
-         scalar query still answers with a count rather than a length-1 array
-         from the broadcast branch below. */
-      if ( query_was_scalar && rb_obj_is_carray(rval) ) {
+      {
+        volatile VALUE ref = self, query = rval;
+        ca_face_reconcile_pair(&ref, &query, "count(v)");
+        self = ref;
+        rval = query;
+      }
+      /* The reconcile lifts a scalar query to a length-1 array; unwrap it so
+         a scalar query still answers with a count rather than a length-1
+         array from the broadcast branch below.  A Ruby Array is a list of
+         queries and stays one, like a CArray query. */
+      if ( query_was_scalar && ! RB_TYPE_P(argv[0], T_ARRAY)
+           && rb_obj_is_carray(rval) ) {
         rval = rb_ca_fetch_addr(rval, 0);
       }
     }
-    else {
-      rb_raise(rb_eArgError,
-               "count(v): non-comparable Face (%s) has no to_comparable to "
-               "reconcile the query; use ca.parent to count the raw storage",
-               rb_obj_classname(self));
-    }
     self = rb_ca_strip_face_value(self);
     GetCArray(self, src);
     /* Hand the reconciled query down in argv (count_equal_ki pops argv[0],
@@ -145,14 +224,25 @@ rb_ca_count (int argc, VALUE *argv, VALUE self)
     CArray *cv;
     GetCArray(rval, cv);
 
+    /* The array is counted in the type it and v match in, as `eq` compares
+       (ca_query_match_type): each v[k] below is then a value of that type,
+       not one cut to the array's. */
+    if ( ca_query_match_applies(src, rval) ) {
+      int8_t qt = ca_query_match_type(src->data_type, rval);
+      if ( qt != src->data_type ) {
+        self = rb_ca_wrap_readonly(self, INT2NUM(qt));
+        GetCArray(self, src);
+      }
+    }
+
     /* Pop trailing options hash (min_count / fill_value) before axes
        parsing so parse_reduce_axes only sees Integer axes.  The opts
        are forwarded verbatim via inner_argv to the recursive count(). */
     int    inner_argc = argc - 1;
     VALUE *inner_axes = argv + 1;
     volatile VALUE opt_hash = Qnil;
-    if ( inner_argc > 0 && rb_obj_is_kind_of(inner_axes[inner_argc - 1],
-                                              rb_cHash) ) {
+    if ( inner_argc > 0 && rb_keyword_given_p() &&
+         rb_obj_is_kind_of(inner_axes[inner_argc - 1], rb_cHash) ) {
       opt_hash = inner_axes[inner_argc - 1];
       inner_argc--;
     }
@@ -199,64 +289,34 @@ rb_ca_count (int argc, VALUE *argv, VALUE self)
     CArray *cout;
     GetCArray(vout, cout);
 
+    /* The options are checked by the recursive count() below, which an
+       empty v never reaches: check them once with a stand-in query, so a
+       misspelt keyword raises whatever v holds. */
+    if ( cv->elements == 0 && ! NIL_P(opt_hash) &&
+         src->data_type != CA_FIXLEN ) {
+      VALUE probe_argv[CA_RANK_MAX + 2];
+      int   j;
+      probe_argv[0] = INT2FIX(0);
+      for (j = 0; j < inner_argc; j++) probe_argv[1 + j] = inner_axes[j];
+      probe_argv[1 + inner_argc] = opt_hash;
+      rb_ca_count(inner_argc + 2, probe_argv, self);
+    }
+
     /* Iterate v in flat order, call self.count(vk, *axes, **opts)
-       recursively, place result at output[..., k]. */
-    ca_attach(cv);
-    int64_t *out_ptr = (int64_t *) cout->ptr;
-    boolean8_t *out_mask = NULL;
-    ca_size_t v_elements = cv->elements;
-    /* inner_argv layout: [vk_scalar, axis..., axis..., [opt_hash]]
-       inner_call_argc = 1 (vk) + inner_argc (axes) + (opt_hash ? 1 : 0). */
-    int inner_call_argc = 1 + inner_argc + (NIL_P(opt_hash) ? 0 : 1);
-    VALUE inner_argv[CA_RANK_MAX + 2];
-    for (int j = 0; j < inner_argc; j++) inner_argv[1 + j] = inner_axes[j];
-    if ( ! NIL_P(opt_hash) ) inner_argv[1 + inner_argc] = opt_hash;
-
-    for (ca_size_t k = 0; k < v_elements; k++) {
-      /* Extract vk as a scalar VALUE via flat addr.  rb_ca_fetch_addr
-         takes a ca_size_t addr (not a Ruby VALUE). */
-      VALUE vk = rb_ca_fetch_addr(rval, k);
-      inner_argv[0] = vk;
-      VALUE sub = rb_ca_count(inner_call_argc, inner_argv, self);
-
-      /* Place sub into output[..., k] slot.
-         Output stride for v-axis = 1, base stride = v_elements. */
-      if ( sub == CA_UNDEF ) {
-        if ( ! out_mask ) {
-          ca_create_mask(cout);
-          out_mask = (boolean8_t *) cout->mask->ptr;
-        }
-        for (ca_size_t i = 0; i < base_elements; i++) {
-          out_ptr[i * v_elements + k] = 0;
-          out_mask[i * v_elements + k] = 1;
-        }
-      } else if ( rb_obj_is_kind_of(sub, rb_cInteger) ) {
-        /* Full reduction: sub is a single integer. */
-        out_ptr[k] = NUM2LL(sub);
-      } else if ( rb_obj_is_kind_of(sub, rb_cCArray) ) {
-        CArray *csub;
-        GetCArray(sub, csub);
-        ca_attach(csub);
-        int64_t *sub_ptr = (int64_t *) csub->ptr;
-        boolean8_t *sub_mask = (csub->mask) ? (boolean8_t *) csub->mask->ptr : NULL;
-        for (ca_size_t i = 0; i < base_elements; i++) {
-          out_ptr[i * v_elements + k] = sub_ptr[i];
-          if ( sub_mask && sub_mask[i] ) {
-            if ( ! out_mask ) {
-              ca_create_mask(cout);
-              out_mask = (boolean8_t *) cout->mask->ptr;
-            }
-            out_mask[i * v_elements + k] = 1;
-          }
-        }
-        ca_detach(csub);
-      } else {
-        ca_detach(cv);
-        rb_raise(rb_eRuntimeError,
-                 "count(v: CArray): unexpected sub-result type");
-      }
+       recursively, place result at output[..., k].  v is held attached
+       for the fetches while Ruby runs, so the loop is a window body. */
+    {
+      ca_count_each_ctx_t c;
+      c.self          = self;
+      c.rval          = rval;
+      c.cv            = cv;
+      c.cout          = cout;
+      c.base_elements = base_elements;
+      c.inner_argc    = inner_argc;
+      c.inner_axes    = inner_axes;
+      c.opt_hash      = opt_hash;
+      ca_attach_window(1, &cv, "r", ca_count_each_body, (VALUE) &c);
     }
-    ca_detach(cv);
     return vout;
   }
 
@@ -294,6 +354,29 @@ rb_ca_count (int argc, VALUE *argv, VALUE self)
                "count(v) on numeric array: v must be numeric, got %s",
                rb_obj_classname(rval));
     }
+    /* The query is compared in the type it and the array match in, as `eq`
+       compares (ca_query_match_type): 1.5 does not match 1, and an Integer
+       the array's type cannot hold matches nothing. */
+    if ( ca_is_integer_type(src) && ! RB_INTEGER_TYPE_P(rval)
+         && ! RB_FLOAT_TYPE_P(rval) && ! RB_TYPE_P(rval, T_COMPLEX)
+         && rb_obj_is_kind_of(rval, rb_cNumeric) ) {
+      /* A Rational or BigDecimal query: an integral one is the Integer it
+         equals; any other is compared as a float, like a Float query,
+         rather than cut to the array's type. */
+      VALUE ival = rb_funcall(rval, rb_intern("to_i"), 0);
+      VALUE *nargv = ALLOCA_N(VALUE, argc);
+      MEMCPY(nargv, argv, VALUE, argc);
+      nargv[0] = RTEST(rb_funcall(rval, rb_intern("=="), 1, ival))
+               ? ival : rb_funcall(rval, rb_intern("to_f"), 0);
+      argv = nargv;
+      rval = nargv[0];
+    }
+    if ( ca_query_match_applies(src, rval) ) {
+      int8_t qt = ca_query_match_type(src->data_type, rval);
+      if ( qt != src->data_type ) {
+        self = rb_ca_wrap_readonly(self, INT2NUM(qt));
+      }
+    }
     /* Pass full argv; count_equal_ki pops argv[0] as value_arg. */
     return rb_ca_count_equal_ki(argc, argv, self);
   }

data/ext/carray_element.c

@@ -18,6 +18,20 @@
 #include "ruby.h"
 #include "carray.h"
 #include "ca_obj_face.h"
+#include "carray_internal.h"   /* ca_obj_extremum_replaces */
+
+/* An element index is an Integer, as it is for `[]`; a Float would be cut
+   to an integer by NUM2SIZE. */
+static inline ca_size_t
+elem_index_value (VALUE v)
+{
+  if ( FIXNUM_P(v) ) return (ca_size_t) FIX2LONG(v);
+  if ( ! RB_INTEGER_TYPE_P(v) ) {
+    rb_raise(rb_eIndexError, "object '%"PRIsVALUE"' is invalid for an index",
+             rb_inspect(v));
+  }
+  return NUM2SIZE(v);
+}
 
 /* T_ARRAY index parser.  ridx is assumed already known to be T_ARRAY.
    Direct VALUE * access + FIXNUM_P fast path eliminates rb_ary_entry
@@ -25,12 +39,16 @@
 static inline void
 elem_parse_idx_array (CArray *ca, VALUE rary, ca_size_t *idx)
 {
-  const VALUE *iarr = RARRAY_CONST_PTR(rary);
+  const VALUE *iarr;
   int8_t ndim = ca->ndim;
   int8_t i;
+  if ( RARRAY_LEN(rary) != ndim ) {
+    rb_raise(rb_eIndexError, "%ld indices given for a carray of ndim %i",
+             (long) RARRAY_LEN(rary), (int) ndim);
+  }
+  iarr = RARRAY_CONST_PTR(rary);
   for (i=0; i<ndim; i++) {
-    VALUE v = iarr[i];
-    ca_size_t k = FIXNUM_P(v) ? (ca_size_t)FIX2LONG(v) : NUM2SIZE(v);
+    ca_size_t k = elem_index_value(iarr[i]);
     CA_CHECK_INDEX(k, ca->dim[i]);
     idx[i] = k;
   }
@@ -40,7 +58,7 @@ elem_parse_idx_array (CArray *ca, VALUE rary, ca_size_t *idx)
 static inline ca_size_t
 elem_parse_idx_scalar (CArray *ca, VALUE ridx)
 {
-  ca_size_t k = FIXNUM_P(ridx) ? (ca_size_t)FIX2LONG(ridx) : NUM2SIZE(ridx);
+  ca_size_t k = elem_index_value(ridx);
   CA_CHECK_INDEX(k, ca->elements);
   return k;
 }
@@ -85,8 +103,8 @@ rb_ca_elem_swap (VALUE self, VALUE ridx1, VALUE ridx2)
   ca_size_t idx1[CA_RANK_MAX], idx2[CA_RANK_MAX];
   ca_size_t addr1 = 0, addr2 = 0;
   int     has_mask, has_index1, has_index2;
-  char   _val1[64], _val2[64];
-  char   *val1 = _val1, *val2 = _val2;
+  volatile VALUE holder1, holder2;
+  char   *val1, *val2;
   boolean8_t m1 = 0, m2 = 0;
 
   rb_ca_modify(self);
@@ -95,10 +113,8 @@ rb_ca_elem_swap (VALUE self, VALUE ridx1, VALUE ridx2)
 
   has_mask = elem_probe_mask(ca);
 
-  if ( ca->bytes > 64 ) {
-    val1 = xmalloc(ca->bytes);
-    val2 = xmalloc(ca->bytes);
-  }
+  val1 = ALLOCV_N(char, holder1, ca->bytes);
+  val2 = ALLOCV_N(char, holder2, ca->bytes);
 
   if ( TYPE(ridx1) == T_ARRAY ) {
     elem_parse_idx_array(ca, ridx1, idx1);
@@ -160,10 +176,8 @@ rb_ca_elem_swap (VALUE self, VALUE ridx1, VALUE ridx2)
     }
   }
 
-  if ( ca->bytes > 64 ) {
-    xfree(val1);
-    xfree(val2);
-  }
+  ALLOCV_END(holder2);
+  ALLOCV_END(holder1);
 
   return self;
 }
@@ -178,8 +192,8 @@ rb_ca_elem_copy (VALUE self, VALUE ridx1, VALUE ridx2)
   ca_size_t idx1[CA_RANK_MAX], idx2[CA_RANK_MAX];
   ca_size_t addr1 = 0, addr2 = 0;
   int     has_mask;
-  char   _val[64];
-  char   *val = _val;
+  volatile VALUE holder;
+  char   *val;
   boolean8_t m = 0;
 
   rb_ca_modify(self);
@@ -188,9 +202,7 @@ rb_ca_elem_copy (VALUE self, VALUE ridx1, VALUE ridx2)
 
   has_mask = elem_probe_mask(ca);
 
-  if ( ca->bytes > 64 ) {
-    val = xmalloc(ca->bytes);
-  }
+  val = ALLOCV_N(char, holder, ca->bytes);
 
   if ( TYPE(ridx1) == T_ARRAY ) {
     elem_parse_idx_array(ca, ridx1, idx1);
@@ -222,9 +234,7 @@ rb_ca_elem_copy (VALUE self, VALUE ridx1, VALUE ridx2)
     }
   }
 
-  if ( ca->bytes > 64 ) {
-    xfree(val);
-  }
+  ALLOCV_END(holder);
 
   return self;
 }
@@ -285,33 +295,56 @@ rb_ca_elem_store (VALUE self, VALUE ridx, VALUE obj)
         if ( FIXNUM_P(obj) )             { *(int64_t *)p = (int64_t)FIX2LONG(obj); return obj; }
         break;
       case CA_INT32:
-        if ( FIXNUM_P(obj) )             { *(int32_t *)p = (int32_t)FIX2LONG(obj); return obj; }
+        if ( FIXNUM_P(obj) && FIX2LONG(obj) >= INT32_MIN && FIX2LONG(obj) <= INT32_MAX ) {
+          /* fits: checked against the type's range above */
+          *(int32_t *)p = (int32_t)FIX2LONG(obj); return obj;
+        }
         break;
       case CA_INT16:
-        if ( FIXNUM_P(obj) )             { *(int16_t *)p = (int16_t)FIX2LONG(obj); return obj; }
+        if ( FIXNUM_P(obj) && FIX2LONG(obj) >= INT16_MIN && FIX2LONG(obj) <= INT16_MAX ) {
+          /* fits: checked against the type's range above */
+          *(int16_t *)p = (int16_t)FIX2LONG(obj); return obj;
+        }
         break;
       case CA_INT8:
-        if ( FIXNUM_P(obj) )             { *(int8_t *)p = (int8_t)FIX2LONG(obj); return obj; }
+        if ( FIXNUM_P(obj) && FIX2LONG(obj) >= INT8_MIN && FIX2LONG(obj) <= INT8_MAX ) {
+          /* fits: checked against the type's range above */
+          *(int8_t *)p = (int8_t)FIX2LONG(obj); return obj;
+        }
         break;
       case CA_UINT64:
-        if ( FIXNUM_P(obj) )             { *(uint64_t *)p = (uint64_t)FIX2LONG(obj); return obj; }
+        if ( FIXNUM_P(obj) && FIX2LONG(obj) >= 0 ) {
+          *(uint64_t *)p = (uint64_t)FIX2LONG(obj); return obj;
+        }
         break;
       case CA_UINT32:
-        if ( FIXNUM_P(obj) )             { *(uint32_t *)p = (uint32_t)FIX2LONG(obj); return obj; }
+        if ( FIXNUM_P(obj) && FIX2LONG(obj) >= 0 && FIX2LONG(obj) <= (long) UINT32_MAX ) {
+          /* fits: checked against the type's range above */
+          *(uint32_t *)p = (uint32_t)FIX2LONG(obj); return obj;
+        }
         break;
       case CA_UINT16:
-        if ( FIXNUM_P(obj) )             { *(uint16_t *)p = (uint16_t)FIX2LONG(obj); return obj; }
+        if ( FIXNUM_P(obj) && FIX2LONG(obj) >= 0 && FIX2LONG(obj) <= (long) UINT16_MAX ) {
+          /* fits: checked against the type's range above */
+          *(uint16_t *)p = (uint16_t)FIX2LONG(obj); return obj;
+        }
         break;
       case CA_UINT8:
-        if ( FIXNUM_P(obj) )             { *(uint8_t *)p = (uint8_t)FIX2LONG(obj); return obj; }
+        if ( FIXNUM_P(obj) && FIX2LONG(obj) >= 0 && FIX2LONG(obj) <= (long) UINT8_MAX ) {
+          /* fits: checked against the type's range above */
+          *(uint8_t *)p = (uint8_t)FIX2LONG(obj); return obj;
+        }
         break;
       case CA_BOOLEAN:
         if ( obj == Qtrue )              { *(uint8_t *)p = 1; return obj; }
         if ( obj == Qfalse )             { *(uint8_t *)p = 0; return obj; }
-        if ( FIXNUM_P(obj) )             { *(uint8_t *)p = (FIX2LONG(obj) != 0); return obj; }
+        if ( obj == INT2FIX(0) || obj == INT2FIX(1) ) {
+          *(uint8_t *)p = (obj == INT2FIX(1)); return obj;
+        }
         break;
       }
-      /* Fall through: data type matches but obj kind needs general coercion. */
+      /* Fall through: the value needs the general coercion, or does not fit
+         the cell, which the general path refuses. */
     }
   }
 
@@ -338,14 +371,12 @@ rb_ca_elem_fetch (VALUE self, VALUE ridx)
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
-  if ( ca_is_empty(ca) ) return Qnil;
-
   if ( TYPE(ridx) == T_ARRAY ) {
     volatile VALUE out;
     elem_parse_idx_array(ca, ridx, idx);
 
     /* Super-hot path: entity + common numeric data type + no mask.
-       Bypass ca_fetch_index dispatch AND rb_ca_ptr2obj cast-table dispatch.
+       Bypass ca_fetch_index dispatch AND rb_ca_ptr2obj_storage cast-table dispatch.
        Covers the bench's float64 / int64 / int32 cases. */
     if ( ca_is_entity(ca) && ! ca->mask ) {
       ca_size_t addr = elem_entity_addr(ca, idx);
@@ -377,13 +408,14 @@ rb_ca_elem_fetch (VALUE self, VALUE ridx)
       else {
         ca_fetch_index(ca, idx, v);
       }
-      out = rb_ca_ptr2obj(self, v);
+      out = rb_ca_ptr2obj_storage(self, v);
     }
     else {
-      char *v = xmalloc(ca->bytes);
+      volatile VALUE holder;
+      char *v = ALLOCV_N(char, holder, ca->bytes);
       ca_fetch_index(ca, idx, v);
-      out = rb_ca_ptr2obj(self, v);
-      xfree(v);
+      out = rb_ca_ptr2obj_storage(self, v);
+      ALLOCV_END(holder);
     }
 
     /* Mask check with inline skip for the entity+no-mask common case. */
@@ -401,7 +433,7 @@ rb_ca_elem_fetch (VALUE self, VALUE ridx)
       }
     }
 
-    CA_FACE_STORAGE_TO_SCALAR_IF_FACE(out, self, ca);
+    CA_FACE_STORAGE_TO_ELEMENT_IF_FACE(out, self, ca);
     return out;
   }
   else {
@@ -690,10 +722,7 @@ rb_ca_elem_mask (VALUE self, VALUE ridx)
   /* General path: view array.  Walk parent chain + dispatch. */
   {
     boolean8_t one = 1;
-    ca_update_mask(ca);
-    if ( ! ca->mask ) {
-      ca_create_mask(ca);
-    }
+    ca_create_mask(ca);
     if ( TYPE(ridx) == T_ARRAY ) {
       elem_parse_idx_array(ca, ridx, idx);
       ca_store_index(ca->mask, idx, &one);
@@ -758,6 +787,11 @@ rb_ca_elem_unmask (VALUE self, VALUE ridx)
  * rule (NaN is treated as missing: `min(NaN, v)` returns `v`,
  * `min(x, NaN)` returns `x`).  Raises for non-numeric data_type. */
 
+/* The entity fast path takes a Float into a float cell and an Integer
+   that fits the cell.  Anything else -- a Float into an integer cell, an
+   Integer out of the type's range, a Bignum or Rational -- goes to the
+   general path, which compares in Ruby and stores as `self[idx] = v`
+   does, so a value that wins but does not fit raises. */
 #define ELEM_MINMAX_BODY(OP) do { \
   if ( ca_is_entity(ca) ) { \
     ca_size_t addr; \
@@ -775,14 +809,6 @@ rb_ca_elem_unmask (VALUE self, VALUE ridx)
       switch ( ca->data_type ) { \
       case CA_FLOAT64: { double *q=(double *)p;  if (v OP *q || *q != *q) *q = v; return self; } \
       case CA_FLOAT32: { float  *q=(float  *)p;  float vf=(float)v; if (vf OP *q || *q != *q) *q = vf; return self; } \
-      case CA_INT64:   { int64_t *q=(int64_t *)p; if ((int64_t)v OP *q) *q = (int64_t)v; return self; } \
-      case CA_INT32:   { int32_t *q=(int32_t *)p; if ((int32_t)v OP *q) *q = (int32_t)v; return self; } \
-      case CA_INT16:   { int16_t *q=(int16_t *)p; if ((int16_t)v OP *q) *q = (int16_t)v; return self; } \
-      case CA_INT8:    { int8_t  *q=(int8_t  *)p; if ((int8_t )v OP *q) *q = (int8_t )v; return self; } \
-      case CA_UINT64:  { uint64_t *q=(uint64_t*)p; if ((uint64_t)v OP *q) *q = (uint64_t)v; return self; } \
-      case CA_UINT32:  { uint32_t *q=(uint32_t*)p; if ((uint32_t)v OP *q) *q = (uint32_t)v; return self; } \
-      case CA_UINT16:  { uint16_t *q=(uint16_t*)p; if ((uint16_t)v OP *q) *q = (uint16_t)v; return self; } \
-      case CA_UINT8:   { uint8_t  *q=(uint8_t *)p; if ((uint8_t )v OP *q) *q = (uint8_t )v; return self; } \
       } \
     } \
     else if ( FIXNUM_P(rval) ) { \
@@ -791,13 +817,13 @@ rb_ca_elem_unmask (VALUE self, VALUE ridx)
       case CA_FLOAT64: { double *q=(double *)p; double vd=(double)v; if (vd OP *q || *q != *q) *q = vd; return self; } \
       case CA_FLOAT32: { float  *q=(float  *)p; float  vf=(float )v; if (vf OP *q || *q != *q) *q = vf; return self; } \
       case CA_INT64:   { int64_t *q=(int64_t *)p; if ((int64_t)v OP *q) *q = (int64_t)v; return self; } \
-      case CA_INT32:   { int32_t *q=(int32_t *)p; if ((int32_t)v OP *q) *q = (int32_t)v; return self; } \
-      case CA_INT16:   { int16_t *q=(int16_t *)p; if ((int16_t)v OP *q) *q = (int16_t)v; return self; } \
-      case CA_INT8:    { int8_t  *q=(int8_t  *)p; if ((int8_t )v OP *q) *q = (int8_t )v; return self; } \
-      case CA_UINT64:  { uint64_t *q=(uint64_t*)p; if ((uint64_t)v OP *q) *q = (uint64_t)v; return self; } \
-      case CA_UINT32:  { uint32_t *q=(uint32_t*)p; if ((uint32_t)v OP *q) *q = (uint32_t)v; return self; } \
-      case CA_UINT16:  { uint16_t *q=(uint16_t*)p; if ((uint16_t)v OP *q) *q = (uint16_t)v; return self; } \
-      case CA_UINT8:   { uint8_t  *q=(uint8_t *)p; if ((uint8_t )v OP *q) *q = (uint8_t )v; return self; } \
+      case CA_INT32:   { if ( ! (v >= INT32_MIN && v <= INT32_MAX) ) break; int32_t *q=(int32_t *)p; if ((int32_t)v OP *q) *q = (int32_t)v; return self; } \
+      case CA_INT16:   { if ( ! (v >= INT16_MIN && v <= INT16_MAX) ) break; int16_t *q=(int16_t *)p; if ((int16_t)v OP *q) *q = (int16_t)v; return self; } \
+      case CA_INT8:    { if ( ! (v >= INT8_MIN && v <= INT8_MAX) ) break; int8_t  *q=(int8_t  *)p; if ((int8_t )v OP *q) *q = (int8_t )v; return self; } \
+      case CA_UINT64:  { if ( ! (v >= 0) ) break; uint64_t *q=(uint64_t*)p; if ((uint64_t)v OP *q) *q = (uint64_t)v; return self; } \
+      case CA_UINT32:  { if ( ! (v >= 0 && v <= (long) UINT32_MAX) ) break; uint32_t *q=(uint32_t*)p; if ((uint32_t)v OP *q) *q = (uint32_t)v; return self; } \
+      case CA_UINT16:  { if ( ! (v >= 0 && v <= (long) UINT16_MAX) ) break; uint16_t *q=(uint16_t*)p; if ((uint16_t)v OP *q) *q = (uint16_t)v; return self; } \
+      case CA_UINT8:   { if ( ! (v >= 0 && v <= (long) UINT8_MAX) ) break; uint8_t  *q=(uint8_t *)p; if ((uint8_t )v OP *q) *q = (uint8_t )v; return self; } \
       } \
     } \
   } \
@@ -817,6 +843,10 @@ rb_ca_elem_min (VALUE self, VALUE ridx, VALUE rval)
     rb_raise(rb_eCADataTypeError,
              "elem_min requires a numeric array");
   }
+  if ( ca_is_complex_type(ca) ) {
+    rb_raise(rb_eCADataTypeError,
+             "elem_min requires a real array (complex values have no order)");
+  }
 
   /* Super-hot path: entity + numeric data type + Fixnum/Float rval. */
   ELEM_MINMAX_BODY(<);
@@ -846,7 +876,7 @@ rb_ca_elem_min (VALUE self, VALUE ridx, VALUE rval)
 
     cur = from_array ? rb_ca_fetch_index(self, idx) : rb_ca_fetch_addr(self, addr);
     if ( cur == CA_UNDEF ) return self;
-    if ( RTEST(rb_funcall(rval, rb_intern("<"), 1, cur)) ) {
+    if ( ca_obj_extremum_replaces(rval, cur, rb_intern("<")) ) {
       if ( from_array ) rb_ca_store_index(self, idx, rval);
       else              rb_ca_store_addr(self, addr, rval);
     }
@@ -873,6 +903,10 @@ rb_ca_elem_max (VALUE self, VALUE ridx, VALUE rval)
     rb_raise(rb_eCADataTypeError,
              "elem_max requires a numeric array");
   }
+  if ( ca_is_complex_type(ca) ) {
+    rb_raise(rb_eCADataTypeError,
+             "elem_max requires a real array (complex values have no order)");
+  }
 
   ELEM_MINMAX_BODY(>);
 
@@ -899,7 +933,7 @@ rb_ca_elem_max (VALUE self, VALUE ridx, VALUE rval)
 
     cur = from_array ? rb_ca_fetch_index(self, idx) : rb_ca_fetch_addr(self, addr);
     if ( cur == CA_UNDEF ) return self;
-    if ( RTEST(rb_funcall(rval, rb_intern(">"), 1, cur)) ) {
+    if ( ca_obj_extremum_replaces(rval, cur, rb_intern(">")) ) {
       if ( from_array ) rb_ca_store_index(self, idx, rval);
       else              rb_ca_store_addr(self, addr, rval);
     }