carray 3.0.3 → 3.0.5

data/ext/carray_sort.c

@@ -103,16 +103,207 @@ sort_addr_merge (struct sort_addr_key *a, struct sort_addr_key *aux,
                  ca_size_t n, int (*cmp)(const void *, const void *))
 CA_SORT_MERGE_BY_CMP(struct sort_addr_key)
 
+/* -------------------------------------------------------------------
+
+  Multi-key sort by refinement (MSD), for keys of the numeric data types.
+
+  The first key is sorted whole by the typed pair kernel
+  (ca_sort_quick_pair_*); then only the runs of rows that tie on it are
+  sorted by the second key, and so on, until no run is left or the keys
+  run out.  The answer is the one sort_addr_cmp gives:
+
+  - a pair sorts by (value, row), so rows that tie on every key stay in
+    row order (the stable tie-break of sort_addr_cmp);
+  - each run is split into numbers, NaN and masked cells, in the order
+    sort_addr_cmp puts them (numbers, NaN, masked for masked_last;
+    masked, numbers, NaN otherwise).  The NaN and the masked cells of a
+    run tie among themselves (CA_FLOAT_ORDER_CMP / sort_addr_cmp), so
+    each is a run for the next key.  The split is a stable one done in
+    the load, not ca_partition_nan_pair_*, which allocates on every call
+    and is called here once per run;
+  - -0.0 and 0.0 tie, by == as by CA_FLOAT_ORDER_CMP.
+
+  A run is (lo, n): the rows perm[lo..lo+n).  Within a run the rows are
+  in row order, since they tie on every key before it, so the stable
+  split keeps them so.
+
+------------------------------------------------------------------- */
+
+typedef struct {
+  ca_size_t lo;
+  ca_size_t n;
+} msd_run_t;
+
+typedef struct {
+  msd_run_t *runs;
+  ca_size_t  count;
+} msd_runs_t;
+
+static void
+msd_add_run (msd_runs_t *out, ca_size_t lo, ca_size_t n)
+{
+  if ( out && n > 1 ) {
+    out->runs[out->count].lo = lo;
+    out->runs[out->count].n  = n;
+    out->count++;
+  }
+}
+
+/* Sort each run of +in+ by +key+, writing the new order into perm, and
+   add the runs that still tie to +out+ (NULL for the last key). */
+#define DEFINE_MSD_REFINE(TYPE, SUFFIX, IS_FLOAT)                             \
+static void                                                                   \
+msd_refine_##SUFFIX (CArray *key, ca_size_t *perm, void *vbuf,                \
+                     msd_runs_t *in, msd_runs_t *out, int masked_last)        \
+{                                                                             \
+  const TYPE *ptr = (const TYPE *) key->ptr;                                  \
+  const boolean8_t *m = ( key->mask ) ? (boolean8_t *) key->mask->ptr : NULL; \
+  ca_pair_##SUFFIX *buf = (ca_pair_##SUFFIX *) vbuf;                          \
+  ca_size_t r;                                                                \
+                                                                              \
+  for (r=0; r<in->count; r++) {                                               \
+    ca_size_t lo = in->runs[r].lo;                                            \
+    ca_size_t n  = in->runs[r].n;                                             \
+    ca_size_t *p = perm + lo;                                                 \
+    ca_size_t n_num = 0, n_nan = 0, n_mask = 0;                               \
+    ca_size_t o_num, o_nan, o_mask;                                           \
+    ca_size_t k, s;                                                           \
+                                                                              \
+    for (k=0; k<n; k++) {                                                     \
+      ca_size_t row = p[k];                                                   \
+      if ( m && m[row] )                 n_mask++;                            \
+      else if ( IS_FLOAT && isnan((double) ptr[row]) ) n_nan++;               \
+      else                               n_num++;                             \
+    }                                                                         \
+    o_mask = masked_last ? n_num + n_nan : 0;                                 \
+    o_num  = masked_last ? 0 : n_mask;                                        \
+    o_nan  = o_num + n_num;                                                   \
+    {                                                                         \
+      ca_size_t i_num = o_num, i_nan = o_nan, i_mask = o_mask;                \
+      for (k=0; k<n; k++) {                                                   \
+        ca_size_t row = p[k];                                                 \
+        TYPE v = ptr[row];                                                    \
+        ca_size_t at;                                                         \
+        if ( m && m[row] )             at = i_mask++;                         \
+        else if ( IS_FLOAT && isnan((double) v) ) at = i_nan++;               \
+        else                           at = i_num++;                          \
+        buf[at].v = v;                                                        \
+        buf[at].i = row;                                                      \
+      }                                                                       \
+    }                                                                         \
+    ca_sort_quick_pair_##SUFFIX(buf + o_num, n_num);                          \
+    for (k=0; k<n; k++) {                                                     \
+      p[k] = buf[k].i;                                                        \
+    }                                                                         \
+    if ( ! out ) continue;                                                    \
+    for (s=0, k=1; k<=n_num; k++) {                                           \
+      if ( k == n_num || buf[o_num + k].v != buf[o_num + s].v ) {             \
+        msd_add_run(out, lo + o_num + s, k - s);                              \
+        s = k;                                                                \
+      }                                                                       \
+    }                                                                         \
+    msd_add_run(out, lo + o_nan,  n_nan);                                     \
+    msd_add_run(out, lo + o_mask, n_mask);                                    \
+  }                                                                           \
+}
+
+DEFINE_MSD_REFINE(int8_t,    i8,  0)
+DEFINE_MSD_REFINE(uint8_t,   u8,  0)
+DEFINE_MSD_REFINE(int16_t,   i16, 0)
+DEFINE_MSD_REFINE(uint16_t,  u16, 0)
+DEFINE_MSD_REFINE(int32_t,   i32, 0)
+DEFINE_MSD_REFINE(uint32_t,  u32, 0)
+DEFINE_MSD_REFINE(int64_t,   i64, 0)
+DEFINE_MSD_REFINE(uint64_t,  u64, 0)
+DEFINE_MSD_REFINE(float32_t, f32, 1)
+DEFINE_MSD_REFINE(double,    f64, 1)
+
+/* Whether every key has a typed pair kernel, so that MSD can sort them. */
+static int
+msd_is_sortable (struct cmp_base *base)
+{
+  int j;
+  for (j=0; j<base->n; j++) {
+    switch ( base->ca[j]->data_type ) {
+    case CA_BOOLEAN: case CA_INT8:  case CA_UINT8:
+    case CA_INT16:   case CA_UINT16:
+    case CA_INT32:   case CA_UINT32:
+    case CA_INT64:   case CA_UINT64:
+    case CA_FLOAT32: case CA_FLOAT64:
+      break;
+    default:
+      return 0;
+    }
+  }
+  return 1;
+}
+
+typedef struct {
+  struct cmp_base *base;
+  ca_size_t       *perm;      /* elements rows, the answer */
+  void            *buf;       /* elements pairs of 16 bytes */
+  msd_run_t       *runs[2];   /* elements / 2 + 1 runs each */
+  ca_size_t        elements;
+} msd_sort_t;
+
+static void
+msd_sort (msd_sort_t *s)
+{
+  struct cmp_base *base = s->base;
+  msd_runs_t a, b, *in = &a, *out = &b;
+  ca_size_t i;
+  int j;
+
+  for (i=0; i<s->elements; i++) {
+    s->perm[i] = i;
+  }
+  a.runs = s->runs[0];  a.count = 0;
+  b.runs = s->runs[1];  b.count = 0;
+  msd_add_run(in, 0, s->elements);
+
+  for (j=0; j<base->n && in->count > 0; j++) {
+    CArray *key = base->ca[j];
+    msd_runs_t *next = ( j < base->n - 1 ) ? out : NULL;
+    msd_runs_t *t;
+    if ( next ) next->count = 0;
+    switch ( key->data_type ) {
+    case CA_BOOLEAN:
+    case CA_INT8:    msd_refine_i8 (key, s->perm, s->buf, in, next, base->masked_last); break;
+    case CA_UINT8:   msd_refine_u8 (key, s->perm, s->buf, in, next, base->masked_last); break;
+    case CA_INT16:   msd_refine_i16(key, s->perm, s->buf, in, next, base->masked_last); break;
+    case CA_UINT16:  msd_refine_u16(key, s->perm, s->buf, in, next, base->masked_last); break;
+    case CA_INT32:   msd_refine_i32(key, s->perm, s->buf, in, next, base->masked_last); break;
+    case CA_UINT32:  msd_refine_u32(key, s->perm, s->buf, in, next, base->masked_last); break;
+    case CA_INT64:   msd_refine_i64(key, s->perm, s->buf, in, next, base->masked_last); break;
+    case CA_UINT64:  msd_refine_u64(key, s->perm, s->buf, in, next, base->masked_last); break;
+    case CA_FLOAT32: msd_refine_f32(key, s->perm, s->buf, in, next, base->masked_last); break;
+    case CA_FLOAT64: msd_refine_f64(key, s->perm, s->buf, in, next, base->masked_last); break;
+    default:
+      rb_raise(rb_eRuntimeError, "%s: [BUG] data type %d has no pair kernel",
+               ca_calling_method_name(), (int) key->data_type);
+    }
+    if ( ! next ) break;
+    t = in; in = out; out = t;
+  }
+}
+
+/* ----------------------------------------------------------------- */
+
 typedef struct {
   struct sort_addr_key *data;
   struct sort_addr_key *aux;     /* NULL: no object key, libc sorts */
   ca_size_t             elements;
+  msd_sort_t           *msd;     /* non-NULL: every key is numeric, sort by MSD */
 } sort_addr_run_t;
 
 static VALUE
 sort_addr_run (VALUE arg)
 {
   sort_addr_run_t *r = (sort_addr_run_t *) arg;
+  if ( r->msd ) {
+    msd_sort(r->msd);
+    return Qnil;
+  }
   if ( r->aux ) {
     sort_addr_merge(r->data, r->aux, r->elements,
                     (int (*)(const void*,const void*)) sort_addr_cmp);
@@ -145,8 +336,9 @@ rb_ca_s_sort_addr_kw (int argc, VALUE *argv, VALUE ropt, VALUE self)
   CArray *co;
   struct cmp_base base_s, *base = &base_s;
   struct sort_addr_key *data;
-  volatile VALUE hlist = 0, hdata = 0, haux = 0, hmodes = 0;
+  volatile VALUE hlist = 0, hdata = 0, haux = 0, hmodes = 0, hruns0 = 0, hruns1 = 0;
   sort_addr_run_t run;
+  msd_sort_t msd;
   char *modes;
   int has_object = 0;
   ca_size_t elements;
@@ -172,31 +364,10 @@ rb_ca_s_sort_addr_kw (int argc, VALUE *argv, VALUE ropt, VALUE self)
     if ( elements != NUM2SIZE(rb_ca_elements(argv[j])) ) {
       rb_raise(rb_eArgError, "elements mismatch");
     }
-    /* Face gate: an ORDERABLE Face sorts by its storage, so it descends to
-       it (attach / comparator / template output then run on plain storage,
-       which also avoids a face-lifted NULL-ptr index output).  A fixlen
-       storage that is not ORDERABLE (CAConstString's offsets, a record's
-       bytes) has no order in its bytes; the Face's own order stands in for
-       it, as a dense rank, so ties stay ties for the next key.  A Face that
-       has no order (CARecord without order_by:) raises there.  Any other
-       storage raises here. */
     TypedData_Get_Struct(argv[j], CArray, &carray_data_type, ca_j);
     if ( ca_is_face(ca_j) ) {
-      int orderable = ca_test_flag(ca_j, CA_FLAG_FACE_ORDERABLE_STORAGE);
-      VALUE stripped = rb_ca_strip_face_value(argv[j]);
-      CArray *sc;
-      TypedData_Get_Struct(stripped, CArray, &carray_data_type, sc);
-      if ( sc->data_type == CA_FIXLEN && ! orderable ) {
-        VALUE opts = rb_hash_new();
-        rb_hash_aset(opts, ID2SYM(rb_intern("method")), ID2SYM(rb_intern("dense")));
-        argv[j] = rb_funcallv_kw(argv[j], rb_intern("order"), 1, &opts,
-                                 RB_PASS_KEYWORDS);
-        continue;
-      }
-      if ( ! orderable ) {
-        ca_face_refuse_order("sort_addr", argv[j], "order");
-      }
-      argv[j] = stripped;
+      argv[j] = ca_order_key(argv[j], "sort_addr");
+      continue;
     }
     {
       CArray *k;
@@ -224,26 +395,42 @@ rb_ca_s_sort_addr_kw (int argc, VALUE *argv, VALUE ropt, VALUE self)
   }
   modes[argc] = '\0';
 
-  data = ALLOCV_N(struct sort_addr_key, hdata, elements);
-  for (i=0; i<elements; i++) {
-    data[i].i = i;
-    data[i].base = base;
-  }
-
-  run.data     = data;
-  run.aux      = has_object ? ALLOCV_N(struct sort_addr_key, haux, elements) : NULL;
-  run.elements = elements;
-  ca_attach_window(argc, base->ca, modes, sort_addr_run, (VALUE) &run);
-
   out = rb_ca_template_with_type(argv[0], INT2NUM(CA_SIZE), INT2NUM(0));
   TypedData_Get_Struct(out, CArray, &carray_data_type, co);
   q = (ca_size_t *) co->ptr;
-  
-  for (i=0; i<elements; i++) {
-    *q = data[i].i;
-    q++;
+
+  run.data     = NULL;
+  run.aux      = NULL;
+  run.elements = elements;
+  run.msd      = NULL;
+
+  if ( msd_is_sortable(base) ) {
+    ca_size_t nruns = elements / 2 + 1;
+    msd.base     = base;
+    msd.perm     = q;
+    msd.buf      = ALLOCV(hdata, (size_t) elements * sizeof(ca_pair_f64));
+    msd.runs[0]  = ALLOCV_N(msd_run_t, hruns0, nruns);
+    msd.runs[1]  = ( argc > 1 ) ? ALLOCV_N(msd_run_t, hruns1, nruns) : NULL;
+    msd.elements = elements;
+    run.msd      = &msd;
+    ca_attach_window(argc, base->ca, modes, sort_addr_run, (VALUE) &run);
+  }
+  else {
+    data = ALLOCV_N(struct sort_addr_key, hdata, elements);
+    for (i=0; i<elements; i++) {
+      data[i].i = i;
+      data[i].base = base;
+    }
+    run.data = data;
+    run.aux  = has_object ? ALLOCV_N(struct sort_addr_key, haux, elements) : NULL;
+    ca_attach_window(argc, base->ca, modes, sort_addr_run, (VALUE) &run);
+    for (i=0; i<elements; i++) {
+      q[i] = data[i].i;
+    }
   }
 
+  ALLOCV_END(hruns1);
+  ALLOCV_END(hruns0);
   ALLOCV_END(haux);
   ALLOCV_END(hdata);
   ALLOCV_END(hmodes);
@@ -442,14 +629,9 @@ rb_ca_axis2addr_c (VALUE self, VALUE vindices, VALUE vaxis)
   TypedData_Get_Struct(self,     CArray, &carray_data_type, ca);
   TypedData_Get_Struct(vindices, CArray, &carray_data_type, idx_ca);
 
-  /* axis normalization + range check. */
-  int axis_raw = NIL_P(vaxis) ? 0 : (int) ca_axis_integer(vaxis, NULL);
-  int axis = (axis_raw < 0) ? ((int) ca->ndim + axis_raw) : axis_raw;
-  if ( axis < 0 || axis >= ca->ndim ) {
-    rb_raise(rb_eArgError,
-             "%s: axis %d out of range for ndim %d",
-             ca_calling_method_name(), axis_raw, (int) ca->ndim);
-  }
+  long axis_l = ca_normalize_axis_arg(NIL_P(vaxis) ? INT2FIX(0) : vaxis,
+                                      (int) ca->ndim, NULL);
+  int axis = (int) axis_l;
 
   /* Shape rule: indices.ndim == self.ndim, dims match except at axis. */
   if ( idx_ca->ndim != ca->ndim ) {
@@ -470,10 +652,11 @@ rb_ca_axis2addr_c (VALUE self, VALUE vindices, VALUE vaxis)
 
   /* indices data_type: integer kind accepted; cast to CA_SIZE if needed
      (zero-copy when already CA_SIZE via to_type identity). */
+  ca_check_index_array(vindices);
   if ( ! ca_is_integer_type(idx_ca) ) {
     rb_raise(rb_eArgError,
-             "%s: indices data_type must be integer kind (got %d)",
-             ca_calling_method_name(), (int) idx_ca->data_type);
+             "%s: indices data_type must be integer kind (got %s)",
+             ca_calling_method_name(), ca_type_name[idx_ca->data_type]);
   }
   volatile VALUE vidx_cast = vindices;
   CArray         *idx_cast = idx_ca;
@@ -535,6 +718,31 @@ rb_ca_axis2addr (int argc, VALUE *argv, VALUE self)
 }
 
 
+/* The array the order of v is read from, for a method that orders v's
+   cells (a sort, a selection, a ranking, an extremum by key).  A plain
+   array is its own key.  An ORDERABLE Face orders by its storage, so the
+   key is the storage.  A Face that is not ORDERABLE but defines its own
+   #order (CAConstString, whose cells are offsets; CARecord, whose bytes
+   are no order) is keyed by that order, as a dense rank, so ties stay ties
+   and a masked cell stays masked.  A Face that has no order (a CARecord
+   without order_by:) raises in that order; any other Face raises here. */
+VALUE
+ca_order_key (VALUE v, const char *name)
+{
+  CArray *ca;
+  TypedData_Get_Struct(v, CArray, &carray_data_type, ca);
+  if ( ! ca_is_face(ca) ) {
+    return v;
+  }
+  if ( ca_face_orders_by_itself(v) ) {
+    VALUE opts = rb_hash_new();
+    rb_hash_aset(opts, ID2SYM(rb_intern("method")), ID2SYM(rb_intern("dense")));
+    return rb_funcallv_kw(v, rb_intern("order"), 1, &opts, RB_PASS_KEYWORDS);
+  }
+  ca_face_require_orderable(v, name, "order");
+  return rb_ca_strip_face_value(v);
+}
+
 /* ===== sort / sort_copy (value & view surface, sibling of the
    sort_addr / axis2addr block above). =============== */
 
@@ -717,8 +925,7 @@ rb_ca_sort_copy (int argc, VALUE *argv, VALUE self)
   TypedData_Get_Struct(target, CArray, &carray_data_type, cat);
 
   /* Normalize axis (negative -> +ndim, range check). */
-  int axis = rb_ca_normalize_axis_for_ndim(ca_axis_integer(vaxis_use, NULL),
-                                           cat->ndim, NULL);
+  int axis = ca_normalize_axis_arg(vaxis_use, cat->ndim, NULL);
 
   /* Allocate output: same shape and data_type as target
      (bytes=0 = preserve native bytes). */
@@ -805,6 +1012,7 @@ rb_ca_sort_copy (int argc, VALUE *argv, VALUE self)
   ALLOCV_END(aux_holder);
 
   RB_GC_GUARD(target);
+  rb_ca_inherit_attr(vout, self);
   return vout;
 }
 

data/ext/carray_sort_kernel.c

@@ -453,16 +453,15 @@ DEFINE_PARTITION_NAN(double,    f64);
    preserved), so argsort on NaN-containing input keeps NaN indices
    in ascending order.
 
-   Implementation: 2-pass stable filter via xmalloc scratch (single
-   xmalloc + xfree per fiber; negligible overhead vs the sort
-   itself). */
+   Implementation: 2-pass stable filter through scratch, n pairs that
+   the caller provides.  The caller takes it before it opens its walks:
+   an allocation here, inside the walk, would raise past their finish. */
 #define DEFINE_PARTITION_NAN_PAIR(TYPE, SUFFIX)                            \
 ca_size_t                                                                  \
-ca_partition_nan_pair_##SUFFIX (ca_pair_##SUFFIX *a, ca_size_t n)          \
+ca_partition_nan_pair_##SUFFIX (ca_pair_##SUFFIX *a, ca_size_t n,          \
+                                ca_pair_##SUFFIX *scratch)                 \
 {                                                                          \
   if ( n == 0 ) return 0;                                                  \
-  ca_pair_##SUFFIX *scratch =                                              \
-    (ca_pair_##SUFFIX *) xmalloc((size_t) n * sizeof(ca_pair_##SUFFIX));   \
   ca_size_t fin = 0, nan_pos = 0;                                          \
   for ( ca_size_t k = 0; k < n; k++ ) {                                    \
     if ( !isnan(a[k].v) ) scratch[fin++] = a[k];                           \
@@ -472,7 +471,6 @@ ca_partition_nan_pair_##SUFFIX (ca_pair_##SUFFIX *a, ca_size_t n)          \
     if ( isnan(a[k].v) ) scratch[finite_count + nan_pos++] = a[k];         \
   }                                                                        \
   memcpy(a, scratch, (size_t) n * sizeof(ca_pair_##SUFFIX));               \
-  xfree(scratch);                                                          \
   return finite_count;                                                     \
 }                                                                          \
 struct ca_partition_nan_pair_##SUFFIX##_eat_semicolon

data/ext/carray_struct.c

@@ -2,7 +2,7 @@
 
   C-native member access for CAStruct subclasses.  The hooked
   methods (`[]`, `[]=`, `initialize`) are installed on a subclass by
-  `CArray.__install_castruct_methods__(klass)` — called from the
+  `CArray.install_struct_methods(klass)` — called from the
   bottom of lib/carray/struct.rb once CAStruct is defined, so this
   ext can load before that file.
 
@@ -22,6 +22,7 @@
 ---------------------------------------------------------------------------- */
 
 #include "carray.h"
+#include "carray_internal.h"   /* ca_obj2integer_fitting */
 #include <string.h>
 
 /* ---------------------------------------------------------------------
@@ -130,42 +131,42 @@ ca_struct_write_primitive_fast (char *p, int type_code, VALUE val)
     return;
   }
   case CA_INT8: {
-    int8_t v = (int8_t) NUM2INT(val);
+    int8_t v = (int8_t) NUM2LL(ca_obj2integer_fitting(val, CA_INT8));
     memcpy(p, &v, 1);
     return;
   }
   case CA_UINT8: {
-    uint8_t v = (uint8_t) NUM2UINT(val);
+    uint8_t v = (uint8_t) rb_num2ull(ca_obj2integer_fitting(val, CA_UINT8));
     memcpy(p, &v, 1);
     return;
   }
   case CA_INT16: {
-    int16_t v = (int16_t) NUM2INT(val);
+    int16_t v = (int16_t) NUM2LL(ca_obj2integer_fitting(val, CA_INT16));
     memcpy(p, &v, 2);
     return;
   }
   case CA_UINT16: {
-    uint16_t v = (uint16_t) NUM2UINT(val);
+    uint16_t v = (uint16_t) rb_num2ull(ca_obj2integer_fitting(val, CA_UINT16));
     memcpy(p, &v, 2);
     return;
   }
   case CA_INT32: {
-    int32_t v = (int32_t) NUM2LONG(val);
+    int32_t v = (int32_t) NUM2LL(ca_obj2integer_fitting(val, CA_INT32));
     memcpy(p, &v, 4);
     return;
   }
   case CA_UINT32: {
-    uint32_t v = (uint32_t) NUM2ULONG(val);
+    uint32_t v = (uint32_t) rb_num2ull(ca_obj2integer_fitting(val, CA_UINT32));
     memcpy(p, &v, 4);
     return;
   }
   case CA_INT64: {
-    int64_t v = (int64_t) NUM2LL(val);
+    int64_t v = (int64_t) NUM2LL(ca_obj2integer_fitting(val, CA_INT64));
     memcpy(p, &v, 8);
     return;
   }
   case CA_UINT64: {
-    uint64_t v = (uint64_t) NUM2ULL(val);
+    uint64_t v = (uint64_t) rb_num2ull(ca_obj2integer_fitting(val, CA_UINT64));
     memcpy(p, &v, 8);
     return;
   }
@@ -193,20 +194,40 @@ ca_struct_write_primitive_fast (char *p, int type_code, VALUE val)
    to keep neighbouring bits untouched.
    --------------------------------------------------------------------- */
 
+/* The word's bytes are read and written least significant first on
+   every host: the layout numbers the bits byte by byte from the record's
+   start, so a field read through a wider word than its neighbour still
+   sees the same bits. */
+static uint64_t
+ca_struct_load_le (const char *p, int n)
+{
+  uint64_t word = 0;
+  int i;
+  for (i = 0; i < n; i++) {
+    word |= (uint64_t) (uint8_t) p[i] << (8 * i);
+  }
+  return word;
+}
+
+static void
+ca_struct_store_le (char *p, int n, uint64_t word)
+{
+  int i;
+  for (i = 0; i < n; i++) {
+    p[i] = (char) (word >> (8 * i));
+  }
+}
+
 static VALUE
 ca_struct_read_bitfield_fast (const char *p, int view_bytes,
                               int bit_in_word, int bits)
 {
-  uint64_t word = 0;
-  switch (view_bytes) {
-  case 1: { uint8_t  v; memcpy(&v, p, 1); word = v; break; }
-  case 2: { uint16_t v; memcpy(&v, p, 2); word = v; break; }
-  case 4: { uint32_t v; memcpy(&v, p, 4); word = v; break; }
-  case 8: { uint64_t v; memcpy(&v, p, 8); word = v; break; }
-  default:
+  uint64_t word;
+  if ( view_bytes != 1 && view_bytes != 2 && view_bytes != 4 && view_bytes != 8 ) {
     rb_raise(rb_eRuntimeError,
              "[BUG] bitfield view_bytes %d not in {1,2,4,8}", view_bytes);
   }
+  word = ca_struct_load_le(p, view_bytes);
   uint64_t mask = (bits >= 64) ? ~(uint64_t)0
                                : ((uint64_t)1 << bits) - 1;
   uint64_t val  = (word >> bit_in_word) & mask;
@@ -223,7 +244,11 @@ static void
 ca_struct_write_bitfield_fast (char *p, int view_bytes,
                                int bit_in_word, int bits, VALUE val)
 {
-  uint64_t v;
+  uint64_t v, word;
+  if ( view_bytes != 1 && view_bytes != 2 && view_bytes != 4 && view_bytes != 8 ) {
+    rb_raise(rb_eRuntimeError,
+             "[BUG] bitfield view_bytes %d not in {1,2,4,8}", view_bytes);
+  }
   if ( bits == 1 ) {
     if      ( val == Qtrue  || val == INT2FIX(1) ) v = 1;
     else if ( val == Qfalse || val == INT2FIX(0) ) v = 0;
@@ -239,41 +264,9 @@ ca_struct_write_bitfield_fast (char *p, int view_bytes,
   uint64_t mask = (bits >= 64) ? ~(uint64_t)0
                                : ((uint64_t)1 << bits) - 1;
   v &= mask;
-  uint64_t shifted_mask = mask << bit_in_word;
-  uint64_t shifted_val  = v    << bit_in_word;
-  switch (view_bytes) {
-  case 1: {
-    uint8_t word;
-    memcpy(&word, p, 1);
-    word = (uint8_t)((word & ~(uint8_t)shifted_mask) | (uint8_t)shifted_val);
-    memcpy(p, &word, 1);
-    return;
-  }
-  case 2: {
-    uint16_t word;
-    memcpy(&word, p, 2);
-    word = (uint16_t)((word & ~(uint16_t)shifted_mask) | (uint16_t)shifted_val);
-    memcpy(p, &word, 2);
-    return;
-  }
-  case 4: {
-    uint32_t word;
-    memcpy(&word, p, 4);
-    word = (uint32_t)((word & ~(uint32_t)shifted_mask) | (uint32_t)shifted_val);
-    memcpy(p, &word, 4);
-    return;
-  }
-  case 8: {
-    uint64_t word;
-    memcpy(&word, p, 8);
-    word = (word & ~shifted_mask) | shifted_val;
-    memcpy(p, &word, 8);
-    return;
-  }
-  default:
-    rb_raise(rb_eRuntimeError,
-             "[BUG] bitfield view_bytes %d not in {1,2,4,8}", view_bytes);
-  }
+  word = ca_struct_load_le(p, view_bytes);
+  word = (word & ~(mask << bit_in_word)) | (v << bit_in_word);
+  ca_struct_store_le(p, view_bytes, word);
 }
 
 /* ---------------------------------------------------------------------
@@ -333,32 +326,32 @@ ca_struct_write_endian_swapped_fast (char *p, int type_code, VALUE val)
 {
   switch (type_code) {
   case CA_INT16: {
-    uint16_t v = (uint16_t) NUM2INT(val);
+    uint16_t v = (uint16_t) NUM2LL(ca_obj2integer_fitting(val, CA_INT16));
     v = CA_BSWAP16(v); memcpy(p, &v, 2);
     return;
   }
   case CA_UINT16: {
-    uint16_t v = (uint16_t) NUM2UINT(val);
+    uint16_t v = (uint16_t) rb_num2ull(ca_obj2integer_fitting(val, CA_UINT16));
     v = CA_BSWAP16(v); memcpy(p, &v, 2);
     return;
   }
   case CA_INT32: {
-    uint32_t v = (uint32_t) NUM2LONG(val);
+    uint32_t v = (uint32_t) NUM2LL(ca_obj2integer_fitting(val, CA_INT32));
     v = CA_BSWAP32(v); memcpy(p, &v, 4);
     return;
   }
   case CA_UINT32: {
-    uint32_t v = (uint32_t) NUM2ULONG(val);
+    uint32_t v = (uint32_t) rb_num2ull(ca_obj2integer_fitting(val, CA_UINT32));
     v = CA_BSWAP32(v); memcpy(p, &v, 4);
     return;
   }
   case CA_INT64: {
-    uint64_t v = (uint64_t) NUM2LL(val);
+    uint64_t v = (uint64_t) NUM2LL(ca_obj2integer_fitting(val, CA_INT64));
     v = CA_BSWAP64(v); memcpy(p, &v, 8);
     return;
   }
   case CA_UINT64: {
-    uint64_t v = NUM2ULL(val);
+    uint64_t v = (uint64_t) rb_num2ull(ca_obj2integer_fitting(val, CA_UINT64));
     v = CA_BSWAP64(v); memcpy(p, &v, 8);
     return;
   }
@@ -767,7 +760,7 @@ void
 Init_carray_struct (void)
 {
   /* Singleton on rb_cCArray so lib/carray/struct.rb can call it as
-     `CArray.__install_castruct_methods__(klass)`. */
-  rb_define_singleton_method(rb_cCArray, "__install_castruct_methods__",
-                             rb_carray_install_castruct_methods, 1);
+     `CArray.install_struct_methods(klass)`. */
+  rb_define_private_method(rb_singleton_class(rb_cCArray), "install_struct_methods",
+                           rb_carray_install_castruct_methods, 1);
 }