carray 3.0.4 → 3.0.6

data/ext/carray_count.c

@@ -252,8 +252,10 @@ rb_ca_count (int argc, VALUE *argv, VALUE self)
     int8_t  slab_axes[CA_RANK_MAX];
     int8_t  naxes;
     VALUE   axis_val = Qnil;
+    int     keep_axis = 0;
     if ( ! NIL_P(opt_hash) ) {
       axis_val = rb_hash_lookup2(opt_hash, ID2SYM(rb_intern("axis")), Qnil);
+      keep_axis = RTEST(rb_hash_lookup2(opt_hash, ID2SYM(rb_intern("keep_axis")), Qfalse));
     }
     naxes = rb_ca_parse_reduce_axes_kw(axis_val, src, slab_axes);
     (void) inner_axes;  /* axes no longer parsed from inner_axes */
@@ -270,6 +272,9 @@ rb_ca_count (int argc, VALUE *argv, VALUE self)
           out_dim[out_ndim++] = src->dim[k];
           base_elements *= src->dim[k];
         }
+        else if ( keep_axis ) {
+          out_dim[out_ndim++] = 1;   /* the reduced axis kept at length 1 */
+        }
       }
       /* Full reduction (naxes == ndim): base_elements = 1, no base axes. */
       /* Append v.shape. */
@@ -377,6 +382,7 @@ rb_ca_count (int argc, VALUE *argv, VALUE self)
         self = rb_ca_wrap_readonly(self, INT2NUM(qt));
       }
     }
+    self = ca_fixlen_widen_for_query(self, rval);
     /* 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

@@ -20,17 +20,22 @@
 #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. */
+/* An element index is read as `[]` reads a key: an Integer, or a Float
+   with no fraction. */
 static inline ca_size_t
 elem_index_value (VALUE v)
 {
+  ca_size_t k;
   if ( FIXNUM_P(v) ) return (ca_size_t) FIX2LONG(v);
-  if ( ! RB_INTEGER_TYPE_P(v) ) {
+  switch ( ca_index_key_position(v, &k) ) {
+  case 1:
+    return k;
+  case 2:
+    return CA_LENGTH_MAX;   /* past int64: past every axis, refused as out of range */
+  default:
     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.
@@ -77,8 +82,9 @@ elem_probe_mask (CArray *ca)
 
 /* Entity-array fast path: compute flat addr from idx[] and access ptr directly.
    Bypasses ca_func[ARRAY].xfer_index function-pointer dispatch.
-   Caller must ensure ca_is_entity(ca) and ca->ptr is attached (= entity
-   arrays are always attached by definition). */
+   Caller must ensure ca_is_entity(ca) and ca->ptr != NULL: an entity can
+   leave ptr NULL at rest (a CASource), and then the dispatched path is
+   the way in. */
 static inline ca_size_t
 elem_entity_addr (CArray *ca, ca_size_t *idx)
 {
@@ -268,7 +274,7 @@ rb_ca_elem_store (VALUE self, VALUE ridx, VALUE obj)
      Bypasses rb_ca_store_index/addr -> ca_update_mask + rb_ca_obj2ptr ->
      cast_table dispatch.  Falls through to general path for: views,
      existing mask, non-numeric data type, UNDEF, or non-Numeric obj. */
-  if ( ca_is_entity(ca) && ! ca->mask && obj != CA_UNDEF ) {
+  if ( ca_is_entity(ca) && ca->ptr && ! ca->mask && obj != CA_UNDEF ) {
     int8_t dt = ca->data_type;
     if ( dt == CA_FLOAT64 || dt == CA_FLOAT32 ||
          dt == CA_INT64   || dt == CA_INT32  ||
@@ -378,7 +384,7 @@ rb_ca_elem_fetch (VALUE self, VALUE ridx)
     /* Super-hot path: entity + common numeric data type + no mask.
        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 ) {
+    if ( ca_is_entity(ca) && ca->ptr && ! ca->mask ) {
       ca_size_t addr = elem_entity_addr(ca, idx);
       char *p = ca->ptr + ca->bytes * addr;
       switch ( ca->data_type ) {
@@ -401,7 +407,7 @@ rb_ca_elem_fetch (VALUE self, VALUE ridx)
        TypedData_Get_Struct).  Semantics identical to rb_ca_fetch_index. */
     if ( ca->bytes <= 64 ) {
       char v[64];
-      if ( ca_is_entity(ca) ) {
+      if ( ca_is_entity(ca) && ca->ptr ) {
         ca_size_t addr = elem_entity_addr(ca, idx);
         memcpy(v, ca->ptr + ca->bytes * addr, ca->bytes);
       }
@@ -434,12 +440,15 @@ rb_ca_elem_fetch (VALUE self, VALUE ridx)
     }
 
     CA_FACE_STORAGE_TO_ELEMENT_IF_FACE(out, self, ca);
+    if ( ca->data_type == CA_BOOLEAN ) {
+      out = RTEST(out) && out != INT2FIX(0) ? Qtrue : Qfalse;
+    }
     return out;
   }
   else {
     ca_size_t addr = elem_parse_idx_scalar(ca, ridx);
     /* Super-hot flat-addr path: entity + numeric + no mask. */
-    if ( ca_is_entity(ca) && ! ca->mask ) {
+    if ( ca_is_entity(ca) && ca->ptr && ! ca->mask ) {
       char *p = ca->ptr + ca->bytes * addr;
       switch ( ca->data_type ) {
       case CA_FLOAT64: return rb_float_new(*(double *)p);
@@ -488,7 +497,7 @@ rb_ca_elem_incr (VALUE self, VALUE ridx1)
 
   /* Super-hot path: entity + no mask + integer data type.
      Reads p directly, modifies in place — no separate fetch/store dispatch. */
-  if ( ca_is_entity(ca) && ! has_mask ) {
+  if ( ca_is_entity(ca) && ca->ptr && ! has_mask ) {
     ca_size_t addr;
     if ( TYPE(ridx1) == T_ARRAY ) {
       elem_parse_idx_array(ca, ridx1, idx1);
@@ -578,7 +587,7 @@ rb_ca_elem_decr (VALUE self, VALUE ridx1)
   has_mask = elem_probe_mask(ca);
 
   /* Super-hot path: mirror of elem_incr. */
-  if ( ca_is_entity(ca) && ! has_mask ) {
+  if ( ca_is_entity(ca) && ca->ptr && ! has_mask ) {
     ca_size_t addr;
     if ( TYPE(ridx1) == T_ARRAY ) {
       elem_parse_idx_array(ca, ridx1, idx1);
@@ -793,7 +802,7 @@ rb_ca_elem_unmask (VALUE self, VALUE ridx)
    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) ) { \
+  if ( ca_is_entity(ca) && ca->ptr ) { \
     ca_size_t addr; \
     if ( TYPE(ridx) == T_ARRAY ) { \
       elem_parse_idx_array(ca, ridx, idx); \

data/ext/carray_factorize.c

@@ -865,7 +865,7 @@ fz_factorize_appearance_body (VALUE arg)
      element to a 64-bit key; equality within one data type is preserved. */
   #define FZ_LOOP(T, WIDEN)                                                  \
     do {                                                                     \
-      const T  *ip = (const T *) p_in;                                       \
+      const CA_U(T)  *ip = (const CA_U(T) *) p_in;                                       \
       uint32_t *op = (uint32_t *) p_out;                                     \
       for ( ca_size_t i = 0; i < n; i++ ) {                                  \
         if ( m && m[i] ) { op[i] = 0xFFFFFFFFu; continue; }                  \
@@ -884,7 +884,7 @@ fz_factorize_appearance_body (VALUE arg)
      kept as-is), so masked source cells store the sentinel. */
   #define FZ_LOOP_FLOAT(T)                                     \
     do {                                                                     \
-      const T  *ip = (const T *) p_in;                                       \
+      const CA_U(T)  *ip = (const CA_U(T) *) p_in;                                       \
       uint32_t *op = (uint32_t *) p_out;                                     \
       for ( ca_size_t i = 0; i < n; i++ ) {                                  \
         if ( m && m[i] ) { op[i] = 0xFFFFFFFFu; continue; }                  \
@@ -1073,7 +1073,7 @@ fz_mask_duplicates_body (VALUE arg)
      interns first appearances, so is_new == 0 flags a duplicate. */
   #define MD_LOOP(T, WIDEN)                                                   \
     do {                                                                      \
-      const T    *ip = (const T *) p_in;                                      \
+      const CA_U(T)    *ip = (const CA_U(T) *) p_in;                                      \
       boolean8_t *op = (boolean8_t *) p_out;                                  \
       for ( ca_size_t i = 0; i < n; i++ ) {                                   \
         if ( m && m[i] ) { op[i] = 0; continue; }                            \
@@ -1091,7 +1091,7 @@ fz_mask_duplicates_body (VALUE arg)
      before the bitwise key. */
   #define MD_LOOP_FLOAT(T)                                      \
     do {                                                                      \
-      const T    *ip = (const T *) p_in;                                      \
+      const CA_U(T)    *ip = (const CA_U(T) *) p_in;                                      \
       boolean8_t *op = (boolean8_t *) p_out;                                  \
       for ( ca_size_t i = 0; i < n; i++ ) {                                   \
         if ( m && m[i] ) { op[i] = 0; continue; }                            \
@@ -1225,7 +1225,7 @@ fz_unique_flat_body (VALUE arg)
 
   #define UQ_LOOP(T, WIDEN)                                                   \
     do {                                                                      \
-      const T *ip = (const T *) p_in;                                         \
+      const CA_U(T) *ip = (const CA_U(T) *) p_in;                                         \
       for ( ca_size_t i = 0; i < n; i++ ) {                                   \
         if ( m && m[i] ) { continue; }                                        \
         uint64_t key = (uint64_t) (WIDEN ip[i]);                              \
@@ -1239,7 +1239,7 @@ fz_unique_flat_body (VALUE arg)
      pushed level is the raw first-seen element. */
   #define UQ_LOOP_FLOAT(T)                                      \
     do {                                                                      \
-      const T *ip = (const T *) p_in;                                         \
+      const CA_U(T) *ip = (const CA_U(T) *) p_in;                                         \
       for ( ca_size_t i = 0; i < n; i++ ) {                                   \
         if ( m && m[i] ) { continue; }                                        \
         T v = ip[i];                                                          \
@@ -1340,7 +1340,7 @@ fz_intern_all (ca_iter_state *st_v, fz_hash *h, CArray *cv, fz_levels *lv)
 
   #define FZ_IA(T, WIDEN)                                                      \
     do {                                                                       \
-      const T *ip = (const T *) p_v;                                           \
+      const CA_U(T) *ip = (const CA_U(T) *) p_v;                                           \
       for ( ca_size_t i = 0; i < nv; i++ ) {                                   \
         if ( mv && mv[i] ) { continue; }                                       \
         uint64_t key = (uint64_t) (WIDEN ip[i]);                             \
@@ -1352,7 +1352,7 @@ fz_intern_all (ca_iter_state *st_v, fz_hash *h, CArray *cv, fz_levels *lv)
 
   #define FZ_IA_FLOAT(T)                                         \
     do {                                                                       \
-      const T *ip = (const T *) p_v;                                           \
+      const CA_U(T) *ip = (const CA_U(T) *) p_v;                                           \
       for ( ca_size_t i = 0; i < nv; i++ ) {                                   \
         if ( mv && mv[i] ) { continue; }                                       \
         T v = ip[i];                                                           \
@@ -1493,7 +1493,7 @@ fz_is_in_body (VALUE arg)
 
     #define IN_PROBE(T, WIDEN)                                                  \
       do {                                                                      \
-        const T    *ip = (const T *) p_in;                                      \
+        const CA_U(T)    *ip = (const CA_U(T) *) p_in;                                      \
         boolean8_t *op = (boolean8_t *) p_out;                                  \
         for ( ca_size_t i = 0; i < n; i++ ) {                                   \
           if ( m && m[i] ) { op[i] = 0; continue; }                            \
@@ -1504,7 +1504,7 @@ fz_is_in_body (VALUE arg)
 
     #define IN_PROBE_FLOAT(T)                                     \
       do {                                                                      \
-        const T    *ip = (const T *) p_in;                                      \
+        const CA_U(T)    *ip = (const CA_U(T) *) p_in;                                      \
         boolean8_t *op = (boolean8_t *) p_out;                                  \
         for ( ca_size_t i = 0; i < n; i++ ) {                                   \
           if ( m && m[i] ) { op[i] = 0; continue; }                            \
@@ -1661,7 +1661,7 @@ fz_locate_addr_body (VALUE arg)
 
     #define LOC_BUILD(T, WIDEN)                                                 \
       do {                                                                      \
-        const T *ip = (const T *) p_r;                                          \
+        const CA_U(T) *ip = (const CA_U(T) *) p_r;                                          \
         for ( ca_size_t i = 0; i < nr; i++ ) {                                  \
           if ( mr && mr[i] ) { continue; }                                     \
           uint64_t key = (uint64_t) (WIDEN ip[i]);                            \
@@ -1674,7 +1674,7 @@ fz_locate_addr_body (VALUE arg)
 
     #define LOC_BUILD_FLOAT(T)                                    \
       do {                                                                      \
-        const T *ip = (const T *) p_r;                                          \
+        const CA_U(T) *ip = (const CA_U(T) *) p_r;                                          \
         for ( ca_size_t i = 0; i < nr; i++ ) {                                  \
           if ( mr && mr[i] ) { continue; }                                     \
           T v = ip[i];                                                          \
@@ -1751,7 +1751,7 @@ fz_locate_addr_body (VALUE arg)
 
     #define LOC_PROBE(T, WIDEN)                                                 \
       do {                                                                      \
-        const T *ip = (const T *) p_in;                                         \
+        const CA_U(T) *ip = (const CA_U(T) *) p_in;                                         \
         const int64_t *ab = (const int64_t *) addr.p;                           \
         for ( ca_size_t i = 0; i < n; i++ ) {                                   \
           ca_size_t o = base + i;                                               \
@@ -1765,7 +1765,7 @@ fz_locate_addr_body (VALUE arg)
 
     #define LOC_PROBE_FLOAT(T)                                    \
       do {                                                                      \
-        const T *ip = (const T *) p_in;                                         \
+        const CA_U(T) *ip = (const CA_U(T) *) p_in;                                         \
         const int64_t *ab = (const int64_t *) addr.p;                           \
         for ( ca_size_t i = 0; i < n; i++ ) {                                   \
           ca_size_t o = base + i;                                               \
@@ -1929,7 +1929,7 @@ fz_set_relation_body (VALUE arg)
 
   #define SR(T, WIDEN)                                                         \
     do {                                                                       \
-      const T *ip = (const T *) p;                                             \
+      const CA_U(T) *ip = (const CA_U(T) *) p;                                             \
       for ( ca_size_t i = 0; i < n; i++ ) {                                    \
         if ( m && m[i] ) { continue; }                                         \
         uint64_t key = (uint64_t) (WIDEN ip[i]);                             \
@@ -1943,7 +1943,7 @@ fz_set_relation_body (VALUE arg)
 
   #define SR_FLOAT(T)                                            \
     do {                                                                       \
-      const T *ip = (const T *) p;                                             \
+      const CA_U(T) *ip = (const CA_U(T) *) p;                                             \
       for ( ca_size_t i = 0; i < n; i++ ) {                                    \
         if ( m && m[i] ) { continue; }                                         \
         T v = ip[i];                                                           \
@@ -2188,7 +2188,7 @@ fz_value_counts_flat_body (VALUE arg)
 
   #define VC_LOOP(T, WIDEN)                                                   \
     do {                                                                      \
-      const T *ip = (const T *) p_in;                                         \
+      const CA_U(T) *ip = (const CA_U(T) *) p_in;                                         \
       for ( ca_size_t i = 0; i < n; i++ ) {                                   \
         if ( m && m[i] ) { continue; }                                        \
         uint64_t key = (uint64_t) (WIDEN ip[i]);                              \
@@ -2206,7 +2206,7 @@ fz_value_counts_flat_body (VALUE arg)
 
   #define VC_LOOP_FLOAT(T)                                      \
     do {                                                                      \
-      const T *ip = (const T *) p_in;                                         \
+      const CA_U(T) *ip = (const CA_U(T) *) p_in;                                         \
       for ( ca_size_t i = 0; i < n; i++ ) {                                   \
         if ( m && m[i] ) { continue; }                                        \
         T v = ip[i];                                                          \
@@ -2516,7 +2516,7 @@ fz_is_mode_body (VALUE arg)
   /* Integer: WIDEN gives the key directly.  Two passes over the fiber. */
   #define IM_BODY(T, WIDEN)                                                   \
     do {                                                                      \
-      const T    *ip = (const T *) p_in;                                      \
+      const CA_U(T)    *ip = (const CA_U(T) *) p_in;                                      \
       boolean8_t *op = (boolean8_t *) p_out;                                  \
       for ( ca_size_t i = 0; i < n; i++ ) {                                   \
         if ( m && m[i] ) { continue; }                                        \
@@ -2543,7 +2543,7 @@ fz_is_mode_body (VALUE arg)
   /* Float: NaN collapses to one canonical key; -0.0 / +0.0 share a key. */
   #define IM_BODY_FLOAT(T)                                      \
     do {                                                                      \
-      const T    *ip = (const T *) p_in;                                      \
+      const CA_U(T)    *ip = (const CA_U(T) *) p_in;                                      \
       boolean8_t *op = (boolean8_t *) p_out;                                  \
       for ( int pass = 0; pass < 2; pass++ ) {                                \
         int64_t mx = 0;                                                       \

data/ext/carray_generate.c

@@ -117,7 +117,7 @@ ca_seq_is_real (VALUE v)
 /* Fill the whole array in row-major order with `step*i + offset`. */
 #define proc_seq_bang(type, from, to)       \
   {                                         \
-    type *p = (type *)ca->ptr;              \
+    CA_U(type) *p = (CA_U(type) *)ca->ptr;              \
     ca_size_t i;                              \
     if ( NIL_P(roffset) && NIL_P(rstep) ) { \
       for (i=0; i<ca->elements; i++) {    \
@@ -149,7 +149,7 @@ ca_seq_is_real (VALUE v)
    `outer_size` come from the enclosing scope (ca_seq_geometry). */
 #define proc_seq_bang_axis(type, from, to)                              \
   {                                                                     \
-    type *p = (type *)ca->ptr;                                          \
+    CA_U(type) *p = (CA_U(type) *)ca->ptr;                                          \
     ca_size_t o, k, in;                                                 \
     if ( ca_seq_is_real(rstep) || ca_seq_is_real(roffset) ) {           \
       double offset = (NIL_P(roffset)) ? 0 : NUM2DBL(roffset);          \
@@ -289,6 +289,9 @@ ca_seq_bang_object_body (VALUE arg)
     }
     else if ( ! NIL_P(rmethod) ) {                /* a.seq(obj, :method) */
       ID id_method = SYM2ID(rmethod);
+      if ( ca->elements == 0 ) {                  /* no first cell to write */
+        return Qnil;
+      }
       *p++ = ca_seq_cell(c, rval = roffset);
       for (i=1; i<ca->elements; i++) {
         *p++ = ca_seq_cell(c, rval = rb_funcall(rval, id_method, 0));
@@ -297,6 +300,9 @@ ca_seq_bang_object_body (VALUE arg)
     else {                                        /* a.seq(obj, step) */
       ID id_plus = rb_intern("+");
       rstep   = ( NIL_P(rstep) ) ? INT2NUM(1) : rstep;
+      if ( ca->elements == 0 ) {                  /* no first cell to write */
+        return Qnil;
+      }
       *p++ = ca_seq_cell(c, rval = roffset);
       for (i=1; i<ca->elements; i++) {
         *p++ = ca_seq_cell(c, rval = rb_funcall(rval, id_plus, 1, rstep));

data/ext/carray_histogram.c

@@ -25,6 +25,7 @@
 #include "carray.h"
 #include "carray_internal.h"   /* ca_attach_window */
 #include <math.h>
+#include <float.h>
 
 /* Edges are the bin boundaries and must read as such: no masked edge (its
    stored value is no boundary), no NaN, and no edge below the one before
@@ -88,6 +89,8 @@ typedef struct {
   const double *ep;
   ca_size_t     n;            /* number of bins */
   double        lo, hi, inv_dx;
+  double        window;       /* fraction of a bin within which the
+                                 linearised floor is checked */
   int           uniform;
   int           include_max;
 } histbin_axis_t;
@@ -115,7 +118,7 @@ histbin_index (const histbin_axis_t *ax, double v)
        Interior values (the bulk) skip the data-dependent edge loads, keeping
        the fast path vectorisable. */
     frac = pos - (double) k;
-    if ( frac < 1e-9 || frac > 1.0 - 1e-9 ) {
+    if ( frac < ax->window || frac > 1.0 - ax->window ) {
       while ( k + 1 < ax->n && v >= ax->ep[k + 1] ) k++;
       while ( k > 0       && v <  ax->ep[k]     ) k--;
     }
@@ -136,7 +139,7 @@ histbin_axis_setup (histbin_axis_t *ax, const double *ep, ca_size_t ne,
                     int include_max)
 {
   ca_size_t kk;
-  double    dx, tol;
+  double    dx, tol, maxdev;
 
   ax->ep = ep;
   ax->n  = ne - 1;
@@ -149,8 +152,27 @@ histbin_axis_setup (histbin_axis_t *ax, const double *ep, ca_size_t ne,
      width infinite, and a subnormal width makes the reciprocal infinite.
      Either turns the position into NaN, which has no integer. */
   ax->uniform = isfinite(dx) && dx != 0.0 && isfinite(1.0 / dx);
+  maxdev      = 0.0;
   for ( kk = 0; ax->uniform && kk <= ax->n; kk++ ) {
-    if ( fabs(ax->ep[kk] - (ax->lo + (double) kk * dx)) > tol ) { ax->uniform = 0; break; }
+    double dev = fabs(ax->ep[kk] - (ax->lo + (double) kk * dx));
+    if ( dev > tol ) { ax->uniform = 0; break; }
+    if ( dev > maxdev ) maxdev = dev;
+  }
+  /* A value can land on the wrong side of the linearised floor by as much
+     as an edge strays from the straight line, plus the rounding of the
+     position itself: v - lo is rounded at the scale of the edges' magnitude
+     (an ulp of lo or hi, which can be most of a bin when the edges are
+     close together far from zero), and the product grows with the number
+     of bins.  Values within that much of a boundary are checked against the
+     stored edges.  When the window covers a good part of a bin, the binary
+     search is cheaper. */
+  ax->window = ( ax->uniform )
+             ? maxdev / fabs(dx)
+               + 4.0 * DBL_EPSILON * (fabs(ax->lo) + fabs(ax->hi)) / fabs(dx)
+               + (double) (ax->n + 2) * 8.0 * DBL_EPSILON + 1e-9
+             : 0.0;
+  if ( ax->window > 0.25 ) {
+    ax->uniform = 0;
   }
   ax->inv_dx      = (dx != 0.0) ? 1.0 / dx : 0.0;
   ax->include_max = include_max;
@@ -312,7 +334,7 @@ histogram_scatter_walk (VALUE arg)
       ca_size_t off = fiber_base;
       int       masked = 0;
       for ( kk = 0; kk < (ca_size_t) M; kk++ ) {
-        double v = *(const double *)(p + a * ss + kk * cs);
+        double v = *(const ca_u_float64_t *)(p + a * ss + kk * cs);
         if ( (m && m[a * sms + kk * cms]) || isnan(v) ) { masked = 1; break; }
         off += histbin_index(&axes[kk], v) * ext_stride[kk];
       }

data/ext/carray_index_classifier.c

@@ -164,8 +164,8 @@ ca_classifier_key_too_large (VALUE v, const char *where)
    Returns 1 with the position in *out, 2 for an Integer past int64 (past
    every axis, which is no longer than int64), and 0 for anything else (a
    Float with a fraction or past 2**53, NaN, Inf, a Rational, a String). */
-static int
-ca_classifier_key_position (VALUE v, ca_size_t *out)
+int
+ca_index_key_position (VALUE v, ca_size_t *out)
 {
   if ( FIXNUM_P(v) ) {
     *out = (ca_size_t) FIX2LONG(v);
@@ -201,7 +201,7 @@ static ca_size_t
 ca_classifier_key_int_where (VALUE v, int axis, const char *where)
 {
   ca_size_t k;
-  switch ( ca_classifier_key_position(v, &k) ) {
+  switch ( ca_index_key_position(v, &k) ) {
   case 1:
     return k;
   case 2:
@@ -232,7 +232,7 @@ static ca_size_t
 ca_classifier_key_step (VALUE v, int axis)
 {
   ca_size_t k;
-  if ( ca_classifier_key_position(v, &k) == 2 ) {
+  if ( ca_index_key_position(v, &k) == 2 ) {
     return rb_big_sign(v) ? (ca_size_t) INT64_MAX : (ca_size_t) INT64_MIN;
   }
   return ca_classifier_key_int(v, axis);