carray 3.0.4 → 3.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2edeb545754cf31d330c667913471c1a0035c97de72dabad7e7b2afb4fe272b
-  data.tar.gz: 8b34390fcabbb04c5e1f0926ae103052345196112ec3a6a16f244fb310df5583
+  metadata.gz: ccd30e8ea5b53c3a2654a86a0ab7473b3073f7feffa7db7be0e5c9aef5bc17c8
+  data.tar.gz: ffcd91fe93ca10b4b12dbff035ffc25533699472b364482a59bf2aa635296032
 SHA512:
-  metadata.gz: 0f7430ff0556faf7b609673fb8cf9ef08279e226192995ea58a5dd203e5285733582c5cff0405fc753c39cad7056acd9194f55ba26ce9eb1d1a27cf1de8e37f0
-  data.tar.gz: 48d35829402ba2949e865712d8aa89dd9d4228f0ca4abf62719d3b2d32280541d1c6b7b01dba3e2a68927a89e258e0d6b474a20fc6177415154e1ab57f2b380d
+  metadata.gz: 53c08f4ccf6a4c25219cef4e8f27e7de9740dc8c69ee493ff8e3631c87499cd15ed121d5f7707bd1017f77e0309dc1be2628fa3611b9b3c979e0e075008842d6
+  data.tar.gz: 2200b047a456603d6274d9dfaf8f93c011ce1cc1eb457c454fa7f9cdc9c75ea4b96c9bbe1dab0b37710f8b872ac5e8b630db5c0dacae12a9012b1b34d4c7f1ec

data/CHANGELOG.md

@@ -34,6 +34,211 @@ and a newer one. The 1.x history, up to the 2.0.0 release, is in
      neighbour ("as well", "the producer above") or leave unnamed the
      method, class or keyword it is about. -->
 
+## 3.0.5
+
+- New: `GroupedFrame#aggregate` takes a block instead of a spec. The block
+  is given the grouping once and returns a Hash of output name => a
+  CArray with one value per group, built from `g["col"]` iterators and
+  CArray arithmetic (`g["temp"].max - g["temp"].min`). `grp[array]`
+  groups any CArray with one entry per row, such as a value computed
+  from columns or a column with cells masked.
+
+- New: a `CAFrame` grouped reduction takes a Hash of column name => value
+  as `fill_value:`, filling only the named columns. A single
+  `fill_value:` still goes to every column and has to suit each.
+
+- New: `CArray.meld` brings pieces of different data types to a common
+  one, as `CArray.stack` does, and takes `data_type:`. `CAFrame.meld` and
+  a frame splice still refuse a column whose pieces differ in data type;
+  cast the column first, or use `concatenate`.
+
+- New: `scatter_replace!` takes an object or fixed-length array, as
+  `put_nd` and `put_along_axis` do. The accumulating members
+  (`scatter_add!` and the others) still take numeric arrays only.
+
+- New: `CAConstString#count` and `CACategorical#count` with no argument
+  count the cells that are not masked, as `CArray#count` does.
+
+- New: `CAFixlenString` answers `minmax`, `cummax` and `cummin`, as
+  `CAString` does.
+
+- New (C extensions): `carray.h` defines `ca_u_<type>` cell types and
+  `CA_U(type)`, of the same size and value as the plain types but with no
+  alignment requirement, for reading cells that need not be aligned (a
+  refer with a byte offset, a struct member, a wrapped buffer). The slab
+  macros in `ca_kernel_iterator.h` use them for their pointers.
+
+- Change: `CACategorical#sort_addr` is renamed `group_addr`, the order of
+  the cells by category. `sort_addr` on a categorical now raises, as
+  `sort_index` does, since a categorical has no order of values.
+
+- Change: a Face's `parent` (of a `CATime`, `CARecord`, ...) is a
+  read-only view of its storage. Write the storage of a time through
+  `CATime#ticks`.
+
+- Change: an operator that cannot bring two data types together raises
+  `CArray::DataTypeError` instead of `TypeError`. `DataTypeError` is a
+  `TypeError`, so `rescue TypeError` still catches it.
+
+- Change: a float cell with no integer of the target type -- an infinity,
+  or a value out of the type's range -- is now treated the way NaN
+  already was. `to_type` (`int32`, `as_int64`, ...) masks it to `UNDEF`;
+  storing it into an integer array raises `RangeError`
+  (`FloatDomainError` for an infinity). Before, it became whatever the
+  machine's C conversion gave, which differed between x86 and ARM.
+  `clip_int64` and the other `clip_<type>` methods saturate a float
+  source to the type's limits on every machine; integer `linspace` raises
+  `RangeError` for a span the type cannot hold.
+
+- Change: a Ruby Array operand of a numeric or boolean array is read as
+  its cells: `a.eq([1, 5, 3])` compares cell by cell (it compared every
+  cell with the whole Array), and `a + [1, 2, 3]` adds (it raised).
+  Nested Arrays give the axes. An object array still takes an Array as
+  one value.
+
+- Change: `window`'s `bounds:` is a policy named by a Symbol or String,
+  matched whole; an Integer and an abbreviation raise. A `fill_value:`
+  given with a policy that does not use it (`:nearest`, `:strict`, ...)
+  raises instead of being dropped.
+
+- Change: a length, count, offset or shift given to a view
+  (`sliding_windows`, `block_view`, `tile`, `roll`, `shift`, `field`,
+  `diagonal`) must be an Integer; a Float raises `TypeError` instead of
+  being truncated. `transpose` reads its axes as the other axis arguments
+  are read: negative from the end, an Integer only.
+
+- Change: `drop_axis` on an array whose every axis has size 1 keeps one
+  axis of size 1, and `reshape` with no axes raises.
+
+- Change: in an index of one key per axis, an index array of more than
+  one axis on one axis raises `ArgumentError`; it was read flat. Pass
+  `idx.flatten` for the old reading.
+
+- Change: `elem_fetch`, `elem_store` and the other `elem_*` methods read
+  an index as `[]` reads a key: a Float with no fraction is an index, a
+  Float with a fraction raises `IndexError`.
+
+- Change: two string arrays of different kinds (`CAString`,
+  `CAFixlenString`, `CAConstString`) or of different widths compare by
+  their strings. A String query longer than a fixed-width cell matches
+  no cell in `eq`, `count`, `search`, `bsearch` and `is_in`; it was cut
+  to the cell's width.
+
+- Change: `str_index` and `rindex` give `UNDEF` for a cell that does not
+  hold the substring; they raised for the whole array.
+
+- Change: `bsearch` and `bsearch_addr` answer the first of several equal
+  cells.
+
+- Change: `search` and `search_addr` raise `ArgumentError` for a negative
+  or NaN `eps`, which acted as an exact match.
+
+- Change: `inherit_mask` and `inherit_mask_replace` raise `ArgumentError`
+  for a source whose number of cells differs from the receiver's (a
+  scalar source still applies to every cell).
+
+- Change: a reduction's `fill_value:` that its result cannot hold raises
+  even when no cell needs it, and `fill` on an empty array checks its
+  value as an assignment does.
+
+- Change: rounding a `:M` or `:Y` `CATime` to a calendar bucket
+  (`round(unit: :Y)`, `"3 months"`) measures the distance by the instant,
+  so it agrees with the same dates on `:D`.
+
+- Change: a `CATime` reduction (`mean`, `median`, ...) sends a tie to the
+  later tick on both sides of 1970; before 1970 it went to the earlier
+  one.
+
+- Change: a duration String added to or subtracted from a `CATime` is
+  one step of its own resolution, so `"15 minutes"` on a `"10 minutes"`
+  grid raises, as the same duration as a `CATimedelta` does. It was read
+  as fifteen one-minute steps and cut to the grid.
+
+- Change: of `-0.0` and `0.0`, `pmax` gives `0.0` and `pmin` gives
+  `-0.0`, in either order and on every platform, as `maximum` and
+  `minimum` do. Which zero `min` and `max` answer is not specified.
+
+- Change: a one-sided `clip` passes a NaN cell through, as a two-sided
+  `clip` does.
+
+- Change: a categorical's `fill_value:` (of `shift`, `window`, `project`)
+  is a label; a `CAConstString` takes only `UNDEF` as a fill value.
+
+- Change: a lazy operator with a Face operand (a categorical, a time, a
+  string array) answers as the eager operator does; it read the Face's
+  storage. `CAConstString#eq` with another array compares cell by cell.
+
+- Change: a boolean member of a record (or `field(offset, :boolean)` of a
+  fixed-length array) raises `RangeError` when read as a byte that is not
+  0 or 1, instead of answering differently in each method.
+
+- Change: unmasking a cell of a `CAString` that holds no String gives an
+  empty String.
+
+- Change: `swap_bytes` keeps the attributes, as `refer` and `bitfield`
+  do. An array with no cells has no say in the attributes a `meld`,
+  `stack` or `concatenate` keeps.
+
+- Change: `dim_view` keeps a Face, as `transpose` does.
+
+- Change: `CArray.string(n)` without a block, and `CArray.string("ab")`,
+  raise; `fixlen_string` and `to_fixlen_string` raise for `bytes:` below 1.
+  `project` raises for a keyword argument, `paste` into a frozen array
+  raises `FrozenError`, and `CArray.result_type` refuses a MemoryView
+  operand whose format carray cannot read, as the operators do.
+
+- Change: `CArray.sort_addr` with numeric keys is two to three times as fast, and
+  `nlargest` / `nsmallest` read each fiber once with a work area of a
+  few times n.
+
+- Fix: x86-64 Linux. Inputs that reached an integer division by zero
+  inside the library stopped the process with SIGFPE there (on ARM they
+  were refused later or gave a wrong answer): a sum over a view with a
+  zero-length axis, `wsum` / `wmean` with 1-D weights over a zero-length
+  axis, a view of a stack of empty arrays, `window` with a step of 0, and
+  `wrap_readonly(String, CA_FIXLEN)`. Each now answers or raises
+  `ArgumentError`. The extension builds with GCC 14 without warnings.
+
+- Fix: big-endian hosts. `bitfield` read 0 and lost writes, a struct's
+  bit members overwrote each other, and an element-wise operation applied
+  in place could give a wrong cell.
+
+- Fix: `save` and `dump` with `endian: :little` or `:big` wrote the other
+  byte order. `load` reads the marker, so files written so far still load
+  correctly.
+
+- Fix: running out of memory inside a kernel left a view attached, lost
+  the keywords of the call (`a.sum(axis: 1)` returned the total), or
+  leaked the array being built.
+
+- Fix: an array with 16 axes (the maximum) given to `bitarray`, `field`,
+  a narrowing `refer` or a `:_` index wrote past an internal array.
+
+- Fix: a lazy chain whose step narrows the cells (`a.lazy.abs` of a
+  complex array) overran the heap; `seq` on an empty object array wrote
+  past its end.
+
+- Fix: a CAObject's copy and sync hooks: a view the hook kept of the
+  array it was lent, or the lent array's mask, pointed at freed memory
+  after the hook returned.
+
+- Fix: `CArray.fuse` crashed when several Ractors ran a fuse block for the
+  first time at once.
+
+- Fix: a grouped `variancep` / `stddevp` matches `CArray#variancep` to the
+  last bit.
+
+- Fix: `count` with an array of values honours `keep_axis:`.
+
+- Fix: `CARecord.wrap` of a record array wraps its storage, not the
+  record array.
+
+- Fix: an unnamed struct's `order_by` survives `save` / `load` and
+  Marshal.
+
+- Fix: `CAFrame.from_csv` and `cast(name => :time)` read a leap second
+  (`23:59:60`) as `CArray.time` does, into the next minute.
+
 ## 3.0.4
 
 - New: `CAFrame#verify(rules)` judges every row against named rules (each

data/carray.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = "carray"
-  s.version     = "3.0.4"
+  s.version     = "3.0.5"
   s.authors      = ["himotoyoshi"]
   s.email       = ["himotoyoshi@users.noreply.github.com"]
   s.summary     = "Multi-dimensional numerical array class for Ruby"

data/ext/ca_array_pool.c

@@ -43,18 +43,42 @@
 ---------------------------------------------------------------------------- */
 
 #include "carray.h"
+#include "carray_internal.h"
 #include <string.h>
 
 /* Allocate struct + pool in one shot, then run pool_init.
  *
  * Called by per-class C `*_new` constructors. */
+typedef struct {
+  CArray *ca;
+  int8_t  obj_type;
+  int8_t  ndim;
+} ca_array_alloc_arg;
+
+static VALUE
+ca_array_alloc_pool (VALUE varg)
+{
+  ca_array_alloc_arg *a = (ca_array_alloc_arg *) varg;
+  ca_array_pool_alloc(a->ca, a->obj_type, a->ndim);
+  return Qnil;
+}
+
 void *
 ca_array_alloc (int8_t obj_type, int8_t ndim)
 {
   ca_operation_function_t *func = &ca_func[obj_type];
   CArray *ca = xmalloc(func->struct_size);
+  ca_array_alloc_arg a;
   memset(ca, 0, func->struct_size);
-  ca_array_pool_alloc(ca, obj_type, ndim);
+  /* The type is set now so that a constructor whose setup raises can hand
+     the struct to ca_free, which dispatches on it.  The setup sets it
+     again. */
+  ca->obj_type = obj_type;
+  /* The pool is a second allocation; when it fails, the struct goes too. */
+  a.ca = ca;
+  a.obj_type = obj_type;
+  a.ndim = ndim;
+  ca_fill_or_xfree(ca, ca_array_alloc_pool, (VALUE) &a);
   return ca;
 }
 

data/ext/ca_axis_dispatch.c

@@ -647,15 +647,15 @@ ca_axis_dispatch_percell_gather (CArray          *parent,
             break;
           case 2:
             for (j = 0; j < inner_count; j++)
-              *(uint16_t *)(row_dst + j*2)   = *(uint16_t *)(src + j*inner_step);
+              __builtin_memcpy(row_dst + j*2, src + j*inner_step, 2);
             break;
           case 4:
             for (j = 0; j < inner_count; j++)
-              *(uint32_t *)(row_dst + j*4)   = *(uint32_t *)(src + j*inner_step);
+              __builtin_memcpy(row_dst + j*4, src + j*inner_step, 4);
             break;
           case 8:
             for (j = 0; j < inner_count; j++)
-              *(uint64_t *)(row_dst + j*8)   = *(uint64_t *)(src + j*inner_step);
+              __builtin_memcpy(row_dst + j*8, src + j*inner_step, 8);
             break;
           default:
             for (j = 0; j < inner_count; j++)
@@ -672,18 +672,15 @@ ca_axis_dispatch_percell_gather (CArray          *parent,
             break;
           case 2:
             for (j = 0; j < inner_count; j++)
-              *(uint16_t *)(row_dst + j*2) =
-                *(uint16_t *)(row_src_base + inner_indices[j]*inner_pstride);
+              __builtin_memcpy(row_dst + j*2, row_src_base + inner_indices[j]*inner_pstride, 2);
             break;
           case 4:
             for (j = 0; j < inner_count; j++)
-              *(uint32_t *)(row_dst + j*4) =
-                *(uint32_t *)(row_src_base + inner_indices[j]*inner_pstride);
+              __builtin_memcpy(row_dst + j*4, row_src_base + inner_indices[j]*inner_pstride, 4);
             break;
           case 8:
             for (j = 0; j < inner_count; j++)
-              *(uint64_t *)(row_dst + j*8) =
-                *(uint64_t *)(row_src_base + inner_indices[j]*inner_pstride);
+              __builtin_memcpy(row_dst + j*8, row_src_base + inner_indices[j]*inner_pstride, 8);
             break;
           default:
             for (j = 0; j < inner_count; j++)
@@ -761,8 +758,7 @@ ca_axis_dispatch_gather (CArray          *parent,
        so clang lowers to NEON ldp/stp directly (no libc memcpy call). */
     if ( sbytes == 8 ) {
       for ( i = 0; i < n; i++ ) {
-        *(uint64_t *)(out_buf + i*8) =
-          *(uint64_t *)(base + indices[i] * pstride);
+        __builtin_memcpy(out_buf + i*8, base + indices[i] * pstride, 8);
       }
     } else if ( sbytes == 16 ) {
       for ( i = 0; i < n; i++ ) {
@@ -887,15 +883,15 @@ ca_axis_dispatch_percell_scatter (CArray          *parent,
             break;
           case 2:
             for (j = 0; j < inner_count; j++)
-              *(uint16_t *)(dst + j*inner_step) = *(uint16_t *)(row_src + j*2);
+              __builtin_memcpy(dst + j*inner_step, row_src + j*2, 2);
             break;
           case 4:
             for (j = 0; j < inner_count; j++)
-              *(uint32_t *)(dst + j*inner_step) = *(uint32_t *)(row_src + j*4);
+              __builtin_memcpy(dst + j*inner_step, row_src + j*4, 4);
             break;
           case 8:
             for (j = 0; j < inner_count; j++)
-              *(uint64_t *)(dst + j*inner_step) = *(uint64_t *)(row_src + j*8);
+              __builtin_memcpy(dst + j*inner_step, row_src + j*8, 8);
             break;
           default:
             for (j = 0; j < inner_count; j++)
@@ -912,18 +908,15 @@ ca_axis_dispatch_percell_scatter (CArray          *parent,
             break;
           case 2:
             for (j = 0; j < inner_count; j++)
-              *(uint16_t *)(row_dst_base + inner_indices[j]*inner_pstride) =
-                *(uint16_t *)(row_src + j*2);
+              __builtin_memcpy(row_dst_base + inner_indices[j]*inner_pstride, row_src + j*2, 2);
             break;
           case 4:
             for (j = 0; j < inner_count; j++)
-              *(uint32_t *)(row_dst_base + inner_indices[j]*inner_pstride) =
-                *(uint32_t *)(row_src + j*4);
+              __builtin_memcpy(row_dst_base + inner_indices[j]*inner_pstride, row_src + j*4, 4);
             break;
           case 8:
             for (j = 0; j < inner_count; j++)
-              *(uint64_t *)(row_dst_base + inner_indices[j]*inner_pstride) =
-                *(uint64_t *)(row_src + j*8);
+              __builtin_memcpy(row_dst_base + inner_indices[j]*inner_pstride, row_src + j*8, 8);
             break;
           default:
             for (j = 0; j < inner_count; j++)

data/ext/ca_categorical_iterator.c

@@ -457,20 +457,23 @@ rb_ca_reduceat_percentile (VALUE self, VALUE roffsets, VALUE rp, VALUE rout)
 
 /* ---------------------------------------------------------------------------
 
-  __reduceat_variance__ — centred two-pass SAMPLE variance (ddof=1) reduceat.
-  The means (from the cached moments: sum/count) drive a second walk that
-  accumulates the per-segment centred sum of squares; variance = SS / (n-1).
-  Centred (not the one-pass sum-of-squares) so the ε-close contract holds — a
-  one-pass formula cancels catastrophically.  Matches CArray#variance per group:
-  count 0 or 1 -> masked (the sample variance is undefined), count >= 2 ->
-  SS / (count-1).
-
-  Surface (private): grouped.__reduceat_variance__(offsets, means, counts, out)
+  __reduceat_variance__ — centred two-pass variance reduceat, sample (ddof=1)
+  or population (ddof=0).  The means (from the cached moments: sum/count)
+  drive a second walk that accumulates the per-segment centred sum of
+  squares; variance = SS / (n - ddof).  Centred (not the one-pass
+  sum-of-squares) so the ε-close contract holds — a one-pass formula cancels
+  catastrophically.  Matches CArray#variance / #variancep per group: count
+  <= ddof (or 0) -> masked, otherwise SS / (count - ddof), divided once as
+  the core does.
+
+  Surface (private):
+    grouped.__reduceat_variance__(offsets, means, counts, out, ddof)
     self    = grouped  (numeric value data type, may carry a mask)
     offsets = int64[k] segment STARTS
     means   = float64[k] per-segment mean (ignored where count < 2)
     counts  = int64[k]   per-segment present count
-    out     = float64[k] output: variance; count 0 or 1 masked
+    out     = float64[k] output: variance; count <= ddof masked
+    ddof    = 1 (sample) or 0 (population)
 
 --------------------------------------------------------------------------- */
 
@@ -479,7 +482,7 @@ rb_ca_reduceat_percentile (VALUE self, VALUE roffsets, VALUE rp, VALUE rout)
     const T *gp = (const T *) grouped->ptr;                                     \
     for ( c = 0; c < k; c++ ) {                                                 \
       int64_t cnt = countp[c];                                                  \
-      if ( cnt < 2 ) { outp[c] = 0.0; outm[c] = 1; continue; }  /* undefined */ \
+      if ( cnt <= ddof || cnt < 1 ) { outp[c] = 0.0; outm[c] = 1; continue; }   \
       { double mean = meanp[c], ss = 0.0;                                       \
         ca_size_t lo = (ca_size_t) offs[c];                                     \
         ca_size_t hi = (c + 1 < k) ? (ca_size_t) offs[c+1] : n, j;              \
@@ -494,14 +497,15 @@ rb_ca_reduceat_percentile (VALUE self, VALUE roffsets, VALUE rp, VALUE rout)
             double d = (double) gp[j] - mean; ss += d * d;                      \
           }                                                                     \
         }                                                                       \
-        outp[c] = ss / (double) (cnt - 1); }                                    \
+        outp[c] = ss / (double) (cnt - ddof); }                                 \
     }                                                                           \
   } while (0)
 
 static VALUE
 rb_ca_reduceat_variance (VALUE self, VALUE roffsets, VALUE rmeans,
-                         VALUE rcounts, VALUE rout)
+                         VALUE rcounts, VALUE rout, VALUE rddof)
 {
+  int64_t     ddof = NUM2LL(rddof);
   CArray     *grouped, *offsets, *means, *counts, *out;
   int64_t     k, *offs, *countp;
   ca_size_t   n, c;
@@ -518,8 +522,9 @@ rb_ca_reduceat_variance (VALUE self, VALUE roffsets, VALUE rmeans,
   n = grouped->elements;
   if ( offsets->data_type != CA_INT64 || counts->data_type != CA_INT64 ||
        means->data_type != CA_FLOAT64 || out->data_type != CA_FLOAT64 ||
-       means->elements != k || counts->elements != k || out->elements != k ) {
-    rb_raise(rb_eArgError, "__reduceat_variance__: offsets/counts int64, means/out float64[k]");
+       means->elements != k || counts->elements != k || out->elements != k ||
+       ( ddof != 0 && ddof != 1 ) ) {
+    rb_raise(rb_eArgError, "__reduceat_variance__: offsets/counts int64, means/out float64[k], ddof 0 or 1");
   }
 
   offs   = (int64_t *) offsets->ptr;
@@ -1104,8 +1109,13 @@ rb_ca_fiber_scatter_moments (VALUE self, VALUE rcodes, VALUE raxis, VALUE rk,
              h->data_type);
   }
 
+  ca_detach(h);
+  ca_detach(codes);
+
   /* Mask empty (count == 0) cells in mins/maxs: value slot is 0 but meaningless.
-     Matches __reduceat_moments__ contract for empty segments. */
+     Matches __reduceat_moments__ contract for empty segments.  After the
+     detach: creating a mask allocates, and a raise must not leave h and
+     codes attached. */
   ca_create_mask(mins);
   ca_create_mask(maxs);
   minm = (boolean8_t *) mins->mask->ptr;
@@ -1113,9 +1123,6 @@ rb_ca_fiber_scatter_moments (VALUE self, VALUE rcodes, VALUE raxis, VALUE rk,
   for ( cell = 0; cell < total; cell++ ) {
     if ( countp[cell] == 0 ) { minm[cell] = 1; maxm[cell] = 1; }
   }
-
-  ca_detach(h);
-  ca_detach(codes);
   return Qnil;
 }
 
@@ -1481,7 +1488,7 @@ Init_ca_categorical_iterator (void)
   rb_define_private_method(rb_cCArray, "__reduceat_percentile__",
                            rb_ca_reduceat_percentile, 3);
   rb_define_private_method(rb_cCArray, "__reduceat_variance__",
-                           rb_ca_reduceat_variance, 4);
+                           rb_ca_reduceat_variance, 5);
   rb_define_private_method(rb_cCArray, "__reduceat_prod__",
                            rb_ca_reduceat_prod, 2);
   rb_define_private_method(rb_cCArray, "__reduceat_argminmax__",

data/ext/ca_compare.c

@@ -21,8 +21,8 @@
 static int                                             \
 elem_cmp_## type (const void *va, const void *vb)      \
 {                                                      \
-  const type *a = (const type *) va;                   \
-  const type *b = (const type *) vb;                   \
+  const CA_U(type) *a = (const CA_U(type) *) va;       \
+  const CA_U(type) *b = (const CA_U(type) *) vb;       \
   if ( *a > *b ) return  1;                            \
   if ( *a < *b ) return -1;                            \
   return 0;                                            \
@@ -33,8 +33,8 @@ elem_cmp_## type (const void *va, const void *vb)      \
 static int                                             \
 elem_cmp_## type (const void *va, const void *vb)      \
 {                                                      \
-  const type a = *(const type *) va;                   \
-  const type b = *(const type *) vb;                   \
+  const type a = *(const CA_U(type) *) va;             \
+  const type b = *(const CA_U(type) *) vb;             \
   return CA_FLOAT_ORDER_CMP(a, b);                     \
 }
 

data/ext/ca_composite_dispatch.c

@@ -32,29 +32,29 @@ ca_fill_typed (char *dst, const char *val, ca_size_t bytes, ca_size_t n)
       break;
     }
     case 2: {
-      uint16_t  v = *(const uint16_t *)val;
-      uint16_t *p = (uint16_t *)dst;
+      uint16_t  v = *(const ca_u_uint16_t *)val;
+      ca_u_uint16_t *p = (ca_u_uint16_t *)dst;
       for ( i = 0; i < n; i++ ) p[i] = v;
       break;
     }
     case 4: {
-      uint32_t  v = *(const uint32_t *)val;
-      uint32_t *p = (uint32_t *)dst;
+      uint32_t  v = *(const ca_u_uint32_t *)val;
+      ca_u_uint32_t *p = (ca_u_uint32_t *)dst;
       for ( i = 0; i < n; i++ ) p[i] = v;
       break;
     }
     case 8: {
-      uint64_t  v = *(const uint64_t *)val;
-      uint64_t *p = (uint64_t *)dst;
+      uint64_t  v = *(const ca_u_uint64_t *)val;
+      ca_u_uint64_t *p = (ca_u_uint64_t *)dst;
       for ( i = 0; i < n; i++ ) p[i] = v;
       break;
     }
     case 16: {
       /* complex128 etc.  Two uint64_t stores per element.  Compiler
          pairs them into a NEON 128-bit or SSE2 store. */
-      uint64_t v0 = ((const uint64_t *)val)[0];
-      uint64_t v1 = ((const uint64_t *)val)[1];
-      uint64_t *p = (uint64_t *)dst;
+      uint64_t v0 = ((const ca_u_uint64_t *)val)[0];
+      uint64_t v1 = ((const ca_u_uint64_t *)val)[1];
+      ca_u_uint64_t *p = (ca_u_uint64_t *)dst;
       for ( i = 0; i < n; i++ ) {
         p[2*i]     = v0;
         p[2*i + 1] = v1;

data/ext/ca_kernel_iterator.c

@@ -1964,20 +1964,20 @@ ca_iter_state_next_slab_axes_unprotected (ca_iter_state *st,
         /* f64 / i64 hot path: store one cell per inner iter, compiler
            can keep `src` in a vector reg and stream cleanly. */
         for ( int32_t kk = 0; kk < K; kk++ ) {
-          const uint64_t *src = (const uint64_t *)
+          const ca_u_uint64_t *src = (const ca_u_uint64_t *)
                                 (pptrs[kk] + parent_off);
-          uint64_t *dst = (uint64_t *) (cache + (ca_size_t) kk * bytes);
+          ca_u_uint64_t *dst = (ca_u_uint64_t *) (cache + (ca_size_t) kk * bytes);
           for ( ca_size_t t = 0; t < want; t++ ) {
-            *(uint64_t *)((char *) dst + t * stride_t) = src[t];
+            *(ca_u_uint64_t *)((char *) dst + t * stride_t) = src[t];
           }
         }
       } else if ( bytes == 4 ) {
         for ( int32_t kk = 0; kk < K; kk++ ) {
-          const uint32_t *src = (const uint32_t *)
+          const ca_u_uint32_t *src = (const ca_u_uint32_t *)
                                 (pptrs[kk] + parent_off);
-          uint32_t *dst = (uint32_t *) (cache + (ca_size_t) kk * bytes);
+          ca_u_uint32_t *dst = (ca_u_uint32_t *) (cache + (ca_size_t) kk * bytes);
           for ( ca_size_t t = 0; t < want; t++ ) {
-            *(uint32_t *)((char *) dst + t * stride_t) = src[t];
+            *(ca_u_uint32_t *)((char *) dst + t * stride_t) = src[t];
           }
         }
       } else {