carray 3.0.4 → 3.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2edeb545754cf31d330c667913471c1a0035c97de72dabad7e7b2afb4fe272b
-  data.tar.gz: 8b34390fcabbb04c5e1f0926ae103052345196112ec3a6a16f244fb310df5583
+  metadata.gz: 7012a2c73c33e52e9b5dd18d5fd0e7c02b4c741bb650a41cefbfea117449da2f
+  data.tar.gz: 5731ca96689f1d87d9c4e1e6a4764893eac0e39f8126f91695b2042581ae198f
 SHA512:
-  metadata.gz: 0f7430ff0556faf7b609673fb8cf9ef08279e226192995ea58a5dd203e5285733582c5cff0405fc753c39cad7056acd9194f55ba26ce9eb1d1a27cf1de8e37f0
-  data.tar.gz: 48d35829402ba2949e865712d8aa89dd9d4228f0ca4abf62719d3b2d32280541d1c6b7b01dba3e2a68927a89e258e0d6b474a20fc6177415154e1ab57f2b380d
+  metadata.gz: 1e05efbfc29639882cc08753c9394400abb707df063025a7ae5bfed6c006979721d8b0030ae17a4eab1397c89c7c3803bf9fa2ec62fa7aa9d8c56e1adb38bd79
+  data.tar.gz: 21baa2d1fac6d2c45a1ed47b4235e9f1832beb4063e93491743470ac77805c266210139d7af834ca1d014ec410ae43191228679a72004c14af6c2fa91eb88eba

data/CHANGELOG.md

@@ -34,6 +34,444 @@ 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.6
+
+- New: `CAFrame` answers the column reductions itself, as a frame of one
+  row (`df.mean`, `df.sum("rain", "temp")`), and the running values down
+  all its rows (`df.cumsum("rain")`, `order`), as a grouped frame does
+  down each group. `percentile(p, *names)` and `quantile` (a column per
+  quartile, `"rain_p0"` ... `"rain_p100"`) are added to the frame, groups
+  and windows.
+
+- New: `CAFrame` row picks: `nlargest` / `nsmallest` (also on
+  `GroupedFrame`), `drop_masked` for the rows with no masked cell,
+  `GroupedFrame#head` / `#tail` for the first and last rows of each group,
+  and `filter` given a boolean selector directly (`df.filter(df["n"] > 3)`).
+
+- New: `CAFrame#transform` computes columns with a block, keeping their
+  names and the index. `select`, `drop`, `transform` and `describe` pick
+  columns by a Range of names, a Regexp, a kind (`:float`, `:integer`,
+  `:complex`, `:timedelta`, ...) or a data type.
+
+- New: `CAFrame#value_counts` (how many rows hold each value, as a
+  frame), `#strip_mask` (the masked cells filled, in a new frame), `#to_a`
+  (the rows as Arrays, masked cells `UNDEF`), `#shape`, `#empty?`, and
+  `GroupedFrame#each` and `#size`. `CAFrame#==` compares two frames by
+  their table: names, columns, index and row axis name.
+
+- New: `CAFrame#lag` and `GroupedFrame#lag` take a distance of the key,
+  `before: "1 hour"` or `after:`, giving each row the value of the row at
+  exactly that distance (`UNDEF` where there is none). The key is the
+  index or the column `on:` names: a time, a duration or a number.
+
+- New: `join` and `join_asof` take a key named differently on the two
+  sides, and `view: :full`, which gives every column of the result as a
+  view, with holes for the unmatched rows, so a write reaches either
+  frame.
+
+- New: `df[name] = value` with a single value repeats it on every row.
+  `fill` takes several columns, an Array of names or a Hash of column =>
+  value; `rename` takes a block, can exchange two names, and renames the
+  index under its name. `sort_by_key` and `sort_by` take `descending:`.
+
+- New: `CAFrame#set_column_attrs` gives columns their names and common
+  attributes; `CArray#attrs_symkey` and `CAFrame#attrs_symkey` return the
+  attributes with Symbol keys. `CAFrame#to_csv` takes `precision:`.
+
+- New: `GroupedFrame#fill(name, :linear)` interpolates within each group.
+  On a frame, `:linear` reads an index that is not in order as one series
+  in index order.
+
+- New: `melt` brings number columns of different types (an `int64` and a
+  `float64` column) to their common type, still as a view. A mixture no
+  type holds without changing a value (`int64` beside `uint64`), or one
+  with text or time, is refused; cast the columns first.
+
+- New: `wsum` and `wmean` take weights shaped as the reduced axes, matched
+  in ascending axis order, besides a scalar and weights of the receiver's
+  shape.
+
+- New (C extensions and carray-jit): `CArray::AddressBasis.sweep(function,
+  fsync, arrays, *parts)` runs a chunked element-wise sweep
+  (`ca_call_cslab_N_r`, arities 1 to 7) from Ruby, handing the slab
+  pointers to the parts' own String bytes. An `fsync` character other than
+  `0` or `1` is refused.
+
+- Change: CArray requires Ruby 3.2 or later, up from 3.0. On an older
+  Ruby, `gem install carray` does not offer this release; install a
+  newer Ruby with a version manager such as rbenv or mise, or stay on
+  3.0.5.
+
+- Change: CSV reading and writing are split by what they take.
+  `CAFrame.read_csv` and `#write_csv` take a path or an IO;
+  `CAFrame.from_csv` takes CSV text as a String and `#to_csv` returns it.
+  Code that gave `from_csv` a path or an IO calls `read_csv`, and
+  `to_csv(path)` becomes `write_csv(path)`. No aliases are kept.
+
+- Change: `read_csv` and `from_csv` infer the column types by default
+  (`int64`, `float64`, `boolean`, `time`, otherwise text); `types:` names
+  some columns and the rest are still inferred. Pass `types: :string` to
+  read every column as text, as before. A column with a blank but present
+  value (a quoted `""`) stays text.
+
+- Change: `CAFrame#set_index`, `#reset_index`, `#cast`, `#promote`,
+  `#parse_to_time` and `#to_time` return a new frame and leave the
+  receiver as it is (the two share their columns). Assign the result:
+  `df = df.set_index("time")`.
+
+- Change: a `GroupedFrame` reduction given column names returns a frame of
+  those columns, one row per group, labelled as without names; it
+  returned the `CArray` (one name) or an `Array` of them. Take the column
+  (`grp.mean("temp")["temp"]`) or reduce the group iterator
+  (`grp["temp"].mean`) for the values alone.
+
+- Change: a `GroupedFrame` or window value on the frame's rows given
+  several column names (`keep_rows: true`, the running values, `lag`,
+  `w.mean("a", "b")`) returns a frame of them on the frame's rows and
+  index, instead of an `Array`. One name still gives the `CArray`.
+
+- Change: `CAFrame#filter` no longer takes `keep_masked:`, so every row
+  selection is a view. To keep the rows whose condition is undetermined,
+  say so in the selector: `df.filter(cond.is_masked)` or
+  `df.filter(cond.strip_mask(true))`.
+
+- Change: `df[sel] = ...` refuses a Ruby Array as the row selector, as
+  `df[]` does; the column indexer would read `[0, 2]` as two rows from
+  row 0. Write `df[CA_INT64([0, 2])]` for rows 0 and 2.
+
+- Change: a group key named in a `GroupedFrame` reduction, and the index's
+  name given to a verb that reads or changes columns (`df[...]`,
+  `select`, `fill`, `cast`, the reductions), raise and point at `size`
+  or `df.index`. A key argument (`group_by`, `sort_by_key`, `join(on:)`)
+  still names the index.
+
+- Change: an `:inner` or `:right` `join` gives the other frame's columns
+  as views picked by row, not copies, so a write to them reaches that
+  frame. Call `copy` on the result to keep it apart.
+
+- Change: a `CScalar` takes only `s[]` and `s[0]`, reading or writing its
+  one cell; any other index (`s[3]`, a range, `nil`, an index array)
+  raises. A view such as `s.refer(s.data_type, [1])` takes the usual
+  indexes.
+
+- Change: `CArray.stack` and `CArray.meld` refuse a value array
+  (`a.value`) or a mask array (`a.mask`) as a part. Pass a copy
+  (`a.value.copy`), or `a.is_masked` for the mask's values.
+
+- Change: `CArray#==` finds a NaN equal to a NaN, so an array holding NaN
+  equals its copy and the array read back from a file. The cell-by-cell
+  IEEE comparison is `eq`; `eql?` still compares bits.
+
+- Change: `CARemap#mapper` returns a read-only array; writing it raises.
+  The index array given to `a[idx]` is not affected.
+
+- Change: `Marshal.dump` of a `CAWrap` (from `CArray.wrap_memory_view`)
+  writes its values, and the load gives a plain array owning a copy of
+  them, as for a view of the wrap; it raised `TypeError`.
+
+- Change: `as_type` returns a view also when the data type is the
+  receiver's own, and `CATime#to_unit` / `CATimedelta#to_unit` return a
+  new array when the unit does not change, so an attribute set on, or a
+  freeze of, the result does not reach the receiver.
+
+- Change: `wmean` gives `UNDEF` where the weights sum to zero, on every
+  path; numeric arrays gave NaN or an infinity. A weight array with one
+  element is no longer read as a scalar: give a Ruby number or a
+  `CScalar`.
+
+- Change: a computation over an object array that comes back into the
+  array (a cell holding the array, or a view of it) raises, as reading
+  such a cell does; it recursed until the process died. A lazy
+  expression over such an array (a cell holding `x + 1` for the array `x`)
+  raises the same way instead of overflowing the stack or not ending, and
+  so does `Marshal.dump` of an object view whose cells lead back to its
+  root.
+
+- Change (CAObject authors): a `CAObject` without `create_mask` raises
+  `TypeError` when its `copy_data` writes `UNDEF`, as it does when a
+  fetcher answers `UNDEF`; the `UNDEF` was dropped and read as a value.
+
+- Change (C extensions): `ca_install_obj_type` refuses an operation table
+  without `allocate`, `attach`, `sync` and `detach` slots;
+  `ca_iter_register_source_kind` refuses carray's own types; and the
+  kernel iterator's `FIBER_PAIR` forms refuse `CA_KERNEL_WRITE`.
+
+- Fix: `require "carray"` works on Ruby 4.0; it raised
+  `Ractor::IsolationError` since 3.0.4.
+
+- Fix: `CArray.fuse` works on Ruby 3.2 and 3.3. The gem now depends on
+  prism 1.0 or later, which `gem install` and Bundler bring in on Ruby
+  3.2, which ships none, and 3.3, whose own prism is too old; Ruby 3.4
+  and later already ship it.
+
+- Fix: a block of a reshape over a strided view
+  (`a[1..2, 1..3].reshape(3, 2)[0..1, nil]`) read and wrote past the end
+  of a row, outside the buffer at the edges.
+
+- Fix: a frozen object array shared between Ractors can be computed over
+  in several at once; it was refused as cyclic. A cell holding a view of
+  other cells of the same array is no longer refused.
+
+- Fix: a record array (`CARecord`) exports through MemoryView from a
+  Ractor other than the main one; it raised `Ractor::IsolationError`.
+
+- Fix: `Marshal.dump` of a view no longer writes its whole parent (a
+  one-cell view of a 100,000-cell array dumped about 400 KB), and an
+  array's mask marshals as a plain boolean array.
+
+- Fix: an `each_slab` Enumerator stopped part way with `next` leaves no
+  array attached once its Fiber is collected.
+
+- Fix: a window or block iterator reads its source afresh on each call;
+  after the source changed, a later reduction mixed new sums with old
+  counts.
+
+- Fix: a frozen or read-only `CArray.meld` refuses writes through a meld
+  of it (`CArray.meld(m, m)` wrote into the frozen root).
+
+- Fix: a write to a `CArray.stack` or `CArray.meld` whose parts share
+  cells (`CArray.meld(a, a)`) gives those cells the value, or the mask, of
+  the last part; `add!` could leave an earlier part's result, and a mask
+  write masked the cells of every part.
+
+- Fix: a write to a `CArray.stack` or `CArray.meld` that one part refuses
+  (a value outside a part's data type) writes nothing; the parts before
+  it were written.
+
+- Fix: `blocks(...).sort_addr` works when the source holds more than one
+  tile; it failed with `IndexError`.
+
+- Fix: `elem_fetch` answers a boolean cell with `true` or `false` when given
+  an index array over a view, as `[]` does; it answered `0` or `1`.
+
+- Fix: `CAFrame#fill(:linear)` leaves a row with no coordinate out of the
+  interpolation; it was filled with 0.
+
+- Fix: `bin_to` and `histogram1d` put a value next to an edge in the bin
+  that edge bounds when the edges are nearly but not exactly equally
+  spaced.
+
+- Fix: `float ** Integer` takes any exponent that fits 64 bits, eagerly
+  as lazily, and `x.lazy.pow(k)` answers as `x.pow(k)`. A lazy array
+  compared with `UNDEF` (`eq`, `ne`) answers as the eager one does.
+
+- Fix: writing `UNDEF` through a widening `refer` (`r.refer(:float64,
+  ...)`) no longer masks parent cells outside the written cells, and a
+  mask written onto a `CAObject` without mask hooks survives the next
+  read of its values.
+
+- Fix: a masked cell that is not a String reads as `""` when a `CAString`
+  wraps a view, as it does over an entity.
+
+- Fix (CASource authors): a source that leaves its `ptr` NULL at rest no
+  longer crashes `elem_*`, `dump_binary` to a File or `nlargest` over a
+  whole axis.
+
+## 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/README.md

@@ -30,7 +30,7 @@ Or add it to your `Gemfile`:
 gem "carray"
 ```
 
-Requires Ruby 3.0 or later.
+Requires Ruby 3.2 or later.
 
 On a multi-core machine, parallel `make` cuts install time noticeably:
 

data/carray.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = "carray"
-  s.version     = "3.0.4"
+  s.version     = "3.0.6"
   s.authors      = ["himotoyoshi"]
   s.email       = ["himotoyoshi@users.noreply.github.com"]
   s.summary     = "Multi-dimensional numerical array class for Ruby"
@@ -17,7 +17,8 @@ Gem::Specification.new do |s|
   s.homepage    = "https://github.com/himotoyoshi/carray"
   s.license     = "MIT"
   s.platform    = Gem::Platform::RUBY
-  s.required_ruby_version = ">= 3.0"
+  s.required_ruby_version = ">= 3.2"
+  s.add_dependency "prism", ">= 1.0"
   s.files       = [
     *Dir.glob("lib/**/*.rb"),
     *Dir.glob("yard-stubs/**/*.rb"),

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++)
@@ -1108,6 +1101,12 @@ ca_axis_view_xfer_all (void *ap, ca_axis_view_fast_t fast, int region_ok,
   if ( ca_attach_is_alias(parent) ) {
     ca_attach(parent);   /* window: an alias attach, cannot raise */
     fast(ca, (char *) data, dir);
+    /* An entity that keeps no buffer at rest (the mask of a CAObject, a
+       CASource) attaches a copy, which only its sync writes back; for
+       memory it lends, the sync does nothing. */
+    if ( dir == CA_XFER_PUT ) {
+      ca_sync(parent);
+    }
     ca_detach(parent);
     return;
   }

data/ext/ca_axis_group.c

@@ -25,7 +25,7 @@
       (see the section comment above `rb_ca_axis_group_scan`).
 
   Group codes outside [0, k) at any bundle mark the slab element unassigned
-  (skipped, contributing to no group) — mirrors digitize OOB.
+  (skipped, contributing to no group) — mirrors bin_to OOB.
 
   Float reductions carry the CArray ε-close contract: relative error bounded,
   not bit-exact.