carray 3.0.3 → 3.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76ca6c2983cbd1e07acc64daeedc7328bee9239369f56f3af661ed1cc41e0bfb
-  data.tar.gz: 1506fa95c68148469451631fb375826e2599a979b4593db8c7508cf16d3c7545
+  metadata.gz: d2edeb545754cf31d330c667913471c1a0035c97de72dabad7e7b2afb4fe272b
+  data.tar.gz: 8b34390fcabbb04c5e1f0926ae103052345196112ec3a6a16f244fb310df5583
 SHA512:
-  metadata.gz: 66a3078a1bdd6459ab0c7526a588cc81191a4e043a17028b769b87b5d32874a9fd20c2b4828217dfa573457871f476155d005db518da600bbef38baca5551eb8
-  data.tar.gz: 23479b0a9b229489ff5ed1afa7fdc0a30150b9d3ba32803b089f1f9e5d7a955cd556c478c7cb5346e516830632a4ba35cb54d186f54a783b589d7cabec9498d5
+  metadata.gz: 0f7430ff0556faf7b609673fb8cf9ef08279e226192995ea58a5dd203e5285733582c5cff0405fc753c39cad7056acd9194f55ba26ce9eb1d1a27cf1de8e37f0
+  data.tar.gz: 48d35829402ba2949e865712d8aa89dd9d4228f0ca4abf62719d3b2d32280541d1c6b7b01dba3e2a68927a89e258e0d6b474a20fc6177415154e1ab57f2b380d

data/CHANGELOG.md

@@ -34,6 +34,270 @@ 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.4
+
+- New: `CAFrame#verify(rules)` judges every row against named rules (each
+  a callable that returns a boolean CArray) and returns the verdicts as a
+  frame, one column per rule; a row whose rule read a masked value is
+  `UNDEF`, so `count(false)` counts the rows that break it.
+
+- New: `CAFrame#join` takes `how: :semi` and `:anti` (the left rows that
+  have, or have no, match), several key columns (`on: ["station",
+  "date"]`), and the index as a key by the row axis name.
+  `CAFrame#join_asof` takes the index too, and `by:` columns that must
+  match exactly before the nearest key is taken.
+
+- New: a `CAFrame` grouping has more verbs. The short form of `prod`,
+  `accumulate`, `median`, `variance`, `stddev`, `variancep`, `stddevp`,
+  `first`, `last`, `nunique`, `count`, `all` and `any`, beside `sum` /
+  `mean` / `min` / `max`; `filter` (keep the groups a block chooses);
+  `lag`, `order`, `cumsum` and the other running values, and
+  `fill(name, :ffill)` / `:bfill`, all kept on the frame's rows; and
+  `to_frame`. The reductions take column names (`grp.mean("temp")` is a
+  CArray) and `keep_rows: true`, which gives each row its own group's
+  result.
+
+- New: `CAFrame#resample` takes `by:`, columns whose groups are binned
+  apart: `df.resample("time", "1 day", by: "station").max("temp")`.
+
+- New: `CArray#windows(on:, before:, after:)` bounds each window by a
+  width of a key (a time, a duration or a number) instead of a count of
+  cells, with `by:`, `exclude:`, `interval:` and `at:` (windows placed at
+  given points, which may overlap). The key need not be sorted, and the
+  value may have several columns (shape `(N, ...)`). `CAFrame#windows(on:
+  "time", ...)` does the same for a frame's columns.
+
+- New: `CArray#lag(n = 1, axis:)` is the value `n` steps earlier along an
+  axis, `UNDEF` where there is none, so `x - x.lag` starts with `UNDEF`.
+
+- New: the slab, block, segment, categorical and axis-group iterators
+  have `lag`, `order` (each cell's rank within its piece) and
+  `strip_mask(method: :ffill / :bfill)`; each of them works within one
+  piece and never takes a value from another. Every iterator has `first`,
+  `last` and `nunique`.
+
+- New: `CArray#is_between(lo, hi, exclude:)` (or a Range) is true where a
+  value lies between two bounds; `exclude: :lower`, `:upper` or `:both`
+  leaves bounds out, and `nil` or an open end leaves a side unbounded.
+
+- New: `CArray#round(ndigits)` rounds each element to `ndigits` decimal
+  places (negative for tens, hundreds, ...), as `Float#round` and
+  `Integer#round` do.
+
+- New: `CArray#to_frame(*names, axis: -1)` shows an array as a CAFrame
+  whose columns are views of it, one per position along `axis`.
+
+- New: `CACategorical#contrast(base:, full:)` gives one int8 column per
+  category (1 in the cell's category, the base left out unless `full:
+  true`), and `CAFrame#contrast_columns(name, ...)` puts those columns in
+  the frame in place of the categorical.
+
+- New: `CAFrame#is_duplicate(*names, except:)` is true for the rows that
+  repeat an earlier row in the named columns; `except: :last` or `:none`
+  chooses which occurrence stays unmarked.
+
+- New: `CAFrame#append(name, col, before:, after:)` puts the column next
+  to another one.
+
+- New: a `CAFrame` carries attributes of the frame as a whole (`attr`,
+  `set_attr`, `attrs`, ..., and `CAFrame.new(..., attrs:)`), separate from
+  each column's. A row selection or a change of columns keeps them; a
+  summary, a join or a reshape does not.
+
+- New: `CAFrame#to_csv(attrs: [:units, ...])` writes one line per
+  attribute key below the names, and `CAFrame.from_csv(attrs: [...])`
+  reads them back as column attributes; in a reading block,
+  `r.header(:units)` does the same for a line anywhere in the header.
+
+- New: `CAFrame.from_csv` `columns:` takes a Hash that selects and names
+  columns, and the names `c0`, `c1`, ... of a file without a header;
+  `cast` and `from_csv` `types:` take `:categorical`. `CAFrame.new` takes
+  `types:` and `on_error:`, as `from_records` does.
+
+- New: `CArray#delete_attr(key)` removes an attribute and returns its
+  value.
+
+- New: `CATime#end_of(unit:, origin:)` (the last tick of each time's
+  bucket), `days_in_month`, `quarter`, and the ISO 8601 week `iso_week`
+  with its year `iso_year`.
+
+- New: a time or duration array takes a single value in `+` and `-`
+  (`t + "3 days"`, `t - t.min`, `t - Time.utc(2024, 1, 1)`), and a month
+  or year duration moves a time on a day or finer grid as `Date#>>` does
+  (`2024-01-31 + 1 month` is `2024-02-29`). A bare number is still
+  refused.
+
+- New: a time array compares with a value off its grid (`days.eq(
+  "2024-01-03T05:00")`, `<`, `search_nearest`, `is_in`, ...) in the finer
+  unit the two share, where it raised `ArgumentError`. An assignment
+  still raises.
+
+- New: `CATime#pmax` / `pmin` (and `maximum` / `minimum` / `fmax` /
+  `fmin`) give the later / earlier time cell by cell.
+
+- New: CArray can be used in a Ractor other than the main one, `fuse`
+  included, and a frozen array is shared between Ractors without
+  copying. See `docs/topics/Ractor.md`.
+
+- New: C extensions: `CA_FOR_EACH_WHOLE` and `CA_FOR_EACH_WHOLE_MASKED`
+  hand a kernel the whole array as one contiguous run.
+
+- Change: `CArray#rank` is removed; use `#ndim`.
+
+- Change: `CArray::TableMethods` (`column_names=`, `column`, `row`, `rows`
+  and `select` on a 2-D array) is removed; use `a.to_frame("x", "y")`,
+  then `df["x"]` for a column or `df.to_records[i]` for a row.
+
+- Change: `CArray.load_arrow_tensor`, `CArray#save_arrow_tensor` and
+  `CArray::ArrowTensor`, the experimental Arrow tensor IPC reader and
+  writer, are removed.
+
+- Change: methods whose names start and end with `__` that were public
+  internals are now private, renamed or removed. Call the public method
+  they served instead.
+
+- Change: CAFrame takes column names as Strings only. A Symbol name
+  (`df.drop(:a)`, `join(on: :a)`, `CAFrame.new(axis_name: :row)`) raises
+  `TypeError`; write `"a"`. Record keys given to `from_records` may still
+  be Symbols, and `df[:x]` stays the predicate syntax.
+
+- Change: a masked cell of an integer index array keeps its place:
+  `x[i]`, the grid forms and `CAFrame` row selection `df[i]` give a
+  result shaped like `i`, `UNDEF` where `i` is masked, where they dropped
+  those positions. To drop them as before, index by
+  `i[i.is_not_masked]`.
+
+- Change: an index beside a CArray key is read as it is without one: a
+  range ending before its start reads backwards (`a[i, -1..1]`), and an
+  Integer key drops its axis (`a[i, 1]` has the shape of `i`; add `:_`
+  or use `1..1` to keep it).
+
+- Change: an index with a Float that has a fraction (`a[1.5..3]`, a step
+  of `0.5`) raises `IndexError`; it was cut to an integer. Convert with
+  `to_i` or `round` first. A Float that holds an integer, such as a count
+  from `sum`, is still that position.
+
+- Change: an index step says the direction, as in Ruby: a step pointing
+  away from the end reads nothing (`a[(0..4).step(-1)]` read `a[0]`).
+
+- Change: a boolean selector of more than one axis must have the array's
+  shape; it picked cells by flat position. Flatten both sides to keep the
+  old reading.
+
+- Change: storing an integer a cell cannot hold raises `RangeError`
+  (`CA_INT8([300])`, `a[0] = 300`, `fill`, `scatter_add!`, a record
+  member); it wrapped (`300` into int8 was `44`). Storing or reading a
+  NaN into an integer cell (`ints[] = floats`, `as_type`, `fake`) raises
+  `FloatDomainError`. To keep C's conversion, use `to_type`, which is
+  unchanged.
+
+- Change: `CArray.time` reads an Integer as a count of ticks of `unit:`
+  (`CArray.time(CA_INT64([0, 10]), unit: :m)` is 00:00 and 00:10); it
+  read Unix seconds. To read Unix seconds onto another unit, write
+  `CArray.time(secs).to_unit(:m)`.
+
+- Change: `CArray.time` without `unit:`, and `CAFrame#parse_to_time` with
+  a format or `:mixed`, read the values in the finest unit they show
+  (dates alone `:D`, fractions of a second `:ms` / `:us` / `:ns`); it was
+  always `:s`. Pass `unit: :s` to keep the old unit.
+
+- Change: adding a duration that is coarser than a time's unit and not a
+  whole number of its ticks (`"1 day"` on a `"7 hours"` time) raises, and
+  so does `CArray#time(origin:)` between two ticks of `unit:`; both were
+  cut to the grid. Convert the time to a unit both share first.
+
+- Change: `order(descending: true)` puts NaN last and keeps tied cells in
+  their original order (`[5, 3, 5, 1, 5]` gives `[0, 3, 1, 4, 2]`, was
+  `[2, 3, 1, 4, 0]`); with `method: :dense` the largest value is 0 and
+  the ranks have no gaps. Code that used `(n - 1) - order` for the
+  descending rank needs that formula written out. `nlargest` no longer
+  returns NaN or masked cells first, and `nsmallest` / `nlargest` and
+  their `_index` forms break ties by position.
+
+- Change: a CAFrame column built from Ruby values is typed by them:
+  Integers `int64`, numbers `float64`, Strings a text column (`CAString`),
+  arrays of one shape an N-D column, anything else `:object`; it was
+  `:object`. This holds for `CAFrame.new("x" => [...])`, `df["x"] = [...]`,
+  a group's `table` block and a Proc in `aggregate`. Wrap the values in
+  `CA_OBJECT(...)` to keep an object column. A returned array is read
+  from the N-D column as `col[i, nil]`.
+
+- Change: `CAFrame#melt` names each row's source in a text column
+  (`CAString`); it was an object column.
+
+- Change: `CAFrame#group_by` on several keys gives a result with no
+  index: each key is a column, before the reduced columns. Read the keys
+  with `result["station"]` and so on, where the index held tuples.
+
+- Change: `CAFrame#data_types`, `describe` and `p df` name a Face column
+  by its class (`CATime[D]`, `CAString`) where they gave its storage
+  `data_type` (`:fixlen` for most). Read the storage through the Face's
+  accessor (`ticks`, `codes`, ...).
+
+- Change: a CAFrame verb that takes a list of columns refuses a name
+  given twice (`select("a", "a")`, `group_by("a", "a")`) with
+  `ArgumentError`. `df["a", "a"]` still gives the column twice.
+
+- Change: a CAFrame group or window reduction over a column whose type
+  lacks it raises `CArray::DataTypeError`; it raised `ArgumentError`.
+
+- Change: a `CAString` holds only Strings: storing `nil`, a number or an
+  Array into it raises (use `UNDEF` to mask a cell). A selection among
+  Strings (`then_else`, `choose`, `select`, `conditional`) and a
+  `CAString`'s String operators give a `CAString`, where they gave an
+  object array.
+
+- Change: attributes follow conversions, views and copies but not
+  reductions: `categorize`, `cast`, `parse_to_time`, `dup`, Marshal and a
+  Face's views keep them, and `first` / `last` of a grouping no longer
+  carry them. A joined or concatenated array shows the keys every piece
+  shows with the same value. An attribute value is stored frozen; change
+  it by setting it again.
+
+- Change: an error names the method you called, and the common refusals
+  open with it ("+: shape mismatch between operands ...", "fill: can not
+  modify read-only array"). The exception classes are unchanged; code
+  that matches a message needs the new text.
+
+- Change: `clip` refuses `UNDEF` or a masked cell as a bound with
+  `ArgumentError`. To mask the cells out of range, pass `UNDEF` as the
+  fill (`clip(0, 10, UNDEF)`).
+
+- Change: `is_in`, `intersection`, `difference` and `union` refuse a
+  Range; pass an Array (`(1..3).to_a`), or use `is_between` for an
+  interval.
+
+- Change: `median`, `percentile` and `quantile` along the only axis of a
+  1-D array give a bare value, as `sum` does. `nunique(axis:)` naming
+  every axis gives an Integer; pass `keep_axis: true` to keep an array.
+
+- Change: `valid_index?` and `valid_addr?` count a negative index from
+  the end, as `[]` does. `elem_fetch` on an empty array raises
+  `IndexError`; it returned `nil`.
+
+- Change: `seq` / `seq!` on an integer array take a Float or Rational
+  start or step as `init_val + step*i` cut toward zero
+  (`int32.seq(0.5, 0.5)` is `[0, 1, 1, 2]`, was `[0, 0, 1, 1]`), and
+  raise `RangeError` for a start or Integer step the type cannot hold.
+
+- Change: `random!` on an integer array raises for bounds the type
+  cannot hold or a Float bound, and clears the mask. `bin`, `bincount`,
+  `bincount_nd` and the histograms raise for a non-Integer count and for
+  edges that decrease.
+
+- Change: MemoryView: `wrap_memory_view` refuses a boolean buffer (any
+  byte other than 0 or 1 cannot be told apart; use `from_memory_view`,
+  which reads it as true), and a wrap with a read-only `mask:` is
+  read-only. `CArray.memory_view_reject_reason` returns `nil` for an
+  object that is not a CArray.
+
+- Change: C extensions: fifteen kernel iterator shorthand macros
+  (`CA_SLAB_REDUCE_F64`, `CA_SLAB_REDUCE_T_PLUS`,
+  `CA_L2_FOR_EACH_UNMASKED` and others) are removed; write the macro they
+  stood for (`CA_SLAB_REDUCE_T` with `double`, ...).
+  `ca_iter_state_next_slab_strided` is removed, and
+  `ca_iter_state_init_l2` takes `CA_SLAB_AXES` only.
+
 ## 3.0.3
 
 - New: `CAFrame.from_csv` reads messy tables: `types: :infer` (numbers,

data/README.md

@@ -10,11 +10,11 @@ Ruby/CArray is an extension library for the multi-dimensional array class. It pr
 
 * Every array carries a per-element mask for missing values, respected by reductions and statistics
 * Views compose without copying — a write through the outermost view reaches the source data
-* MemoryView protocol on both sides: share buffers with other numerical libraries without copying
+* [MemoryView protocol](guides/users/15_memory_view.md) on both sides: share buffers with other numerical libraries without copying
 * Define your own array class in pure Ruby while keeping the full CArray interface
 * Kernel-style iteration: run a Ruby block over each sub-array spanning the axes you choose
 * Faces: array types for time, strings and categories, with methods of their own on top of everything CArray does
-* Comes with a DataFrame (`CAFrame`) whose columns are plain CArrays, so masks and views keep working on them
+* Comes with a DataFrame ([`CAFrame`](guides/dataframe/README.md)) whose columns are plain CArrays, so masks and views keep working on them
 
 Each of these is shown, briefly and with a runnable example, in [A tour of the features](docs/FeatureTour.md).
 
@@ -119,6 +119,7 @@ b.strip_mask(Float::NAN).sum(axis: 0)
 * [Views](guides/users/06_views.md) — referring to data without copying
 * [Reduction and statistics](guides/users/04_reduction_and_statistics.md) — summaries, whole or per axis
 * [Masks and missing values](guides/users/05_masks.md) — undefined elements, and how calculations treat them
+* [Data frames](guides/dataframe/README.md) — tables of named columns, each column a CArray
 
 ## Contributing
 

data/carray.gemspec

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

data/ext/ca_axis_descriptor.h

@@ -2,13 +2,10 @@
 
   ca_axis_descriptor.h
 
-  Per-axis descriptor framework (D1 + D2 + D3) — shared C-level vocabulary
-  that lets CSA, CAGrid, CASelectAxis, CAWindow, CAShift, and future
+  Per-axis descriptor framework — shared C-level vocabulary that lets
+  CASelectAxis, CAGrid, CASelect, CAWindow, CAShift, and future
   per-axis-mixed views describe each axis the same way so a common
-  attach dispatch engine (D3, ca_axis_dispatch.c) can drive them
-  uniformly.
-
-  See devel/PROPOSAL_AXIS_DESCRIPTOR_FRAMEWORK.md for the design.
+  attach dispatch engine (ca_axis_dispatch.c) can drive them uniformly.
 
   Status: TWO-TIER FREEZE CONTRACT (3.0 onward), the same split
   ca_kernel_iterator.h declares, for the same reason: this header is
@@ -50,14 +47,14 @@
    When this header is included from carray.h mid-file, those typedefs
    are already in scope by the time we reach the include site. */
 
-/* ---- D1: per-axis descriptor types ----------------------------------------
+/* ---- per-axis descriptor types --------------------------------------------
 
    STRIDE = linear stride axis: parent index = start + i*step,
             i in [0, count).  Subsumes nil / Integer / Range index args.
    INDEX  = integer index axis:  parent index = indices[i],
             i in [0, count).  Subsumes integer-array (CAGrid)
             and boolean-mask-after-snapshot (CASelectAxis) axes.
-   SHIFT  = bound-aware stride axis (CAWindow/CAShift, Tier 2.B):
+   SHIFT  = bound-aware stride axis (CAWindow/CAShift):
             parent index = start + i*step normalised by `policy`
             (CA_BOUNDS_FILL / PERIODIC / REFLECT / NEAREST / ...)
             against `size0` (= parent dim along this axis).  When
@@ -86,16 +83,17 @@ typedef struct {
   uint8_t         policy;    /* CA_BOUNDS_FILL / PERIODIC / REFLECT / ... */
 } ca_axis_desc_t;
 
-/* ---- D2: producer interface ----------------------------------------------
+/* ---- producer interface --------------------------------------------------
 
-   Both implementations write ndim entries into `out` (caller-allocated)
-   and `out_parent_dims` (caller-allocated, sized CA_RANK_MAX).  See
-   devel/PROPOSAL_AXIS_DESCRIPTOR_FRAMEWORK.md §5 Framework Phase 1 and
-   devel/PROPOSAL_FLAT_INDEX_VIEWS.md §2.3 for rationale.
+   A producer writes one entry per descriptor axis into `out`
+   (caller-allocated) and `out_parent_dims` (caller-allocated, sized
+   CA_RANK_MAX).  The producers declared here are CASelectAxis and CAGrid;
+   CASelect and CAWindow have their own (ca_select_describe_axes /
+   ca_window_describe_axes).
 
    `out_parent_dims[k]` is the **effective** parent dim along descriptor
-   axis k — for CSA / CAGrid this is just `parent->dim[k]`, but for
-   flat-index views (CASelect / CAMapping, Tier 2.A.3+) it is
+   axis k — for CASelectAxis / CAGrid this is just `parent->dim[k]`, but
+   for a flat-index view (CASelect) it is
    `{parent->elements}` (a single-axis flat view of parent).  This
    decouples descriptor.ndim from parent.ndim so the engine can drive
    views whose iteration axes don't match the parent's physical shape.
@@ -103,13 +101,17 @@ typedef struct {
    Pointer arguments are typed `void *` here to avoid pulling the
    private CASelectAxis / CAGrid struct definitions (which live in
    their respective .c files) into this header.  Each implementation
-   casts to its concrete type inside the .c file. */
+   casts to its concrete type inside the .c file.
+
+   An INDEX axis has no way to say "no cell": a CAGrid index that is
+   masked (a hole) is written as index 0, so a caller driving a holed grid
+   through the engine reads and writes parent cell 0 there. */
 void ca_select_axis_describe_axes (void *ca, ca_axis_desc_t *out,
                                    ca_size_t *out_parent_dims);
 void ca_grid_describe_axes        (void *ca, ca_axis_desc_t *out,
                                    ca_size_t *out_parent_dims);
 
-/* ---- D3: common attach engine --------------------------------------------
+/* ---- common attach engine -------------------------------------------------
 
    Drives gather from `parent` into an output buffer driven by the
    per-axis descriptor array.  Caller must have parent attached before
@@ -119,14 +121,15 @@ void ca_grid_describe_axes        (void *ca, ca_axis_desc_t *out,
    descriptor axis (see producer interface above).  The engine never
    reads `parent->dim` directly — it only reads `parent->ptr` for
    data access — which is what allows flat-index views to lie about
-   parent's apparent shape (Tier 2.A, PROPOSAL_FLAT_INDEX_VIEWS.md).
+   parent's apparent shape.
 
    `bound_fill` is the bytes-wide value written into gather output
-   cells whose SHIFT axes resolve to an out-of-bounds parent index
-   (Tier 2.B, PROPOSAL_BOUND_AWARE_VIEWS.md).  Pass NULL when no
-   SHIFT axis is present (CSA / CAGrid / CASelect / CAMapping); the
-   engine ignores it.  On scatter, the engine simply skips parent
-   writes for OOB cells regardless of bound_fill.
+   cells whose SHIFT axes resolve to an out-of-bounds parent index.
+   Pass NULL when no SHIFT axis is present (CASelectAxis / CAGrid /
+   CASelect); the engine ignores it.  On scatter, the engine simply skips
+   parent writes for OOB cells regardless of bound_fill.  A SHIFT axis
+   under the RUBY or STRICT policy raises IndexError part way through the
+   walk for an index outside the parent.
 
    _gather — caller provides out_buf (must be sized total_elements*bytes)
    _attach — wrapper that mallocs the buffer; caller xfrees
@@ -160,7 +163,7 @@ void  ca_axis_dispatch_scatter (struct _CArray  *parent,
                                 ca_size_t        total_elements,
                                 const char      *in_buf);
 /* Broadcast scatter: write the single value `val` (bytes wide) into
-   every selected parent cell.  See D6 of the framework piece.
+   every selected parent cell.
    (SHIFT axis OOB cells are skipped — fill semantics aren't
    meaningful for broadcast-write since the destination value already
    IS the broadcast value.) */

data/ext/ca_axis_dispatch.c

@@ -1158,15 +1158,10 @@ ca_axis_view_attach_owned (void *ap)
   CArray *ca  = (CArray *) ap;
   char   *buf = xmalloc(ca_length(ca) > 0 ? ca_length(ca) : 1);
   void   *args[2];
-  int     tag = 0;
 
   args[0] = ca;
   args[1] = buf;
-  rb_protect(ca_axis_view_fill_owned, (VALUE) args, &tag);
-  if ( tag ) {
-    xfree(buf);
-    rb_jump_tag(tag);
-  }
+  ca_fill_or_xfree(buf, ca_axis_view_fill_owned, (VALUE) args);
   ca->ptr = buf;
 }
 

data/ext/ca_axis_group.c

@@ -283,7 +283,7 @@ group_op_code (VALUE vop)
 #define GACC_XOR \
   ( ((boolean8_t *) co->ptr)[o] ^= (*(boolean8_t *)(p + gw_doff[e]) ? 1 : 0) )
 
-/* __axis_group_reduce__(group_axes, bundles, op) — group-reduces self along
+/* __reduce_by_axis_groups__(group_axes, bundles, op) — group-reduces self along
  * the union of `group_axes` (ascending source-axis indices = the slab) into
  * composite groups described by `bundles`, preserving the band (= non-grouped)
  * axes.  Internal: the Ruby surface is CAGroupIterator.
@@ -352,7 +352,7 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   /* --- bundles: small per-group code tables (metadata, kept alive) --- */
   Check_Type(vbundles, T_ARRAY);
   int  n_bundles = (int) RARRAY_LEN(vbundles);
-  if ( n_bundles <= 0 || n_bundles > CA_RANK_MAX ) {
+  if ( n_bundles <= 0 || n_bundles > CA_RANK_MAX ) {   /* rank-check: a count of key bundles */
     rb_raise(rb_eArgError, "axis_group_reduce: bad bundle count %d", n_bundles);
   }
   int32_t  *bundle_codes[CA_RANK_MAX];
@@ -362,7 +362,8 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   int       bundle_slot[CA_RANK_MAX][CA_RANK_MAX];
   ca_size_t bundle_cstride[CA_RANK_MAX][CA_RANK_MAX];
   CArray   *bundle_ca[CA_RANK_MAX];
-  volatile VALUE keep = rb_ary_new();   /* GC-pin int32 code views */
+  volatile VALUE keep = rb_ary_new();   /* keeps the int32 code views alive */
+  volatile VALUE h_codes[CA_RANK_MAX];  /* holders of the copied code tables */
 
   ca_size_t K_total = 1;
   long consumed_total = 0;
@@ -385,18 +386,16 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
        and the end of the walk can raise -- a validation just below, a gather
        that cannot convert a cell, an object-lane callback into Ruby -- and a
        raise jumps over every detach, leaving the source materialised with
-       nothing left to release it. The copy rides a temporary buffer that the
-       unwind collects. */
+       nothing left to release it. The copy rides ALLOCV, a temporary buffer
+       that the unwind collects. Not a String: a String held only by `keep`
+       can be moved by compaction, taking the bytes under bundle_codes with
+       it. */
     VALUE v32 = rb_ca_wrap_readonly(vcodes, INT2NUM(CA_INT32));
     rb_ary_push((VALUE) keep, v32);
     GetCArray(v32, bundle_ca[bi]);
-    {
-      size_t nbytes = (size_t) bundle_ca[bi]->elements * sizeof(int32_t);
-      VALUE  vbuf   = rb_str_tmp_new((long) nbytes);
-      rb_ary_push((VALUE) keep, vbuf);
-      ca_copy_data(bundle_ca[bi], RSTRING_PTR(vbuf));
-      bundle_codes[bi] = (int32_t *) RSTRING_PTR(vbuf);
-    }
+    h_codes[bi] = 0;
+    bundle_codes[bi] = ALLOCV_N(int32_t, h_codes[bi], bundle_ca[bi]->elements);
+    ca_copy_data(bundle_ca[bi], (char *) bundle_codes[bi]);
 
     int nb = (int) RARRAY_LEN(vbaxes);
     if ( nb <= 0 || nb > src->ndim ) {
@@ -682,6 +681,7 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   ALLOCV_END(h_prod);   ALLOCV_END(h_seen);   ALLOCV_END(h_xbuf);
   ALLOCV_END(h_nz);     ALLOCV_END(h_mnaddr); ALLOCV_END(h_mxaddr);
   ALLOCV_END(h_band);
+  for ( int bi = 0; bi < n_bundles; bi++ ) ALLOCV_END(h_codes[bi]);
 
   RB_GC_GUARD(keep);
   return vout;
@@ -983,7 +983,7 @@ group_scan_build_plan (ca_iter_state *st, boolean8_t *m,
     omask[o] = 1;                                \
   } while (0)
 
-/* The CA_OBJECT lane of __axis_group_scan__.  Every cell calls into Ruby,
+/* The CA_OBJECT lane of __scan_by_axis_groups__.  Every cell calls into Ruby,
    so the walk can raise part way; its state lives in the caller's frame, in
    c->st, and ca_iter_ensure finishes it however this body leaves.  The
    buffers are ALLOCV-backed, so the unwind collects them. */
@@ -1115,9 +1115,9 @@ group_scan_op_code (VALUE vop)
   rb_raise(rb_eArgError, "axis_group_scan: unsupported op :%"PRIsVALUE, rb_id2str(id));
 }
 
-/* __axis_group_scan__(group_axes, bundles, op) — group-keyed segment scan of
+/* __scan_by_axis_groups__(group_axes, bundles, op) — group-keyed segment scan of
  * self over the union of `group_axes` into composite groups described by
- * `bundles` (same argument shape as __axis_group_reduce__).  Internal.
+ * `bundles` (same argument shape as __reduce_by_axis_groups__).  Internal.
  *
  * Unlike the reduce the grouped axes are not collapsed: the result is a new
  * CArray of the same shape as self, each cell holding the running statistic of
@@ -1187,7 +1187,7 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   /* --- bundles: small per-group code tables (same as reduce) --- */
   Check_Type(vbundles, T_ARRAY);
   int  n_bundles = (int) RARRAY_LEN(vbundles);
-  if ( n_bundles <= 0 || n_bundles > CA_RANK_MAX ) {
+  if ( n_bundles <= 0 || n_bundles > CA_RANK_MAX ) {   /* rank-check: a count of key bundles */
     rb_raise(rb_eArgError, "axis_group_scan: bad bundle count %d", n_bundles);
   }
   int32_t  *bundle_codes[CA_RANK_MAX];
@@ -1198,6 +1198,7 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   ca_size_t bundle_cstride[CA_RANK_MAX][CA_RANK_MAX];
   CArray   *bundle_ca[CA_RANK_MAX];
   volatile VALUE keep = rb_ary_new();
+  volatile VALUE h_codes[CA_RANK_MAX];
 
   ca_size_t K_total = 1;
   long consumed_total = 0;
@@ -1220,18 +1221,16 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
        and the end of the walk can raise -- a validation just below, a gather
        that cannot convert a cell, an object-lane callback into Ruby -- and a
        raise jumps over every detach, leaving the source materialised with
-       nothing left to release it. The copy rides a temporary buffer that the
-       unwind collects. */
+       nothing left to release it. The copy rides ALLOCV, a temporary buffer
+       that the unwind collects. Not a String: a String held only by `keep`
+       can be moved by compaction, taking the bytes under bundle_codes with
+       it. */
     VALUE v32 = rb_ca_wrap_readonly(vcodes, INT2NUM(CA_INT32));
     rb_ary_push((VALUE) keep, v32);
     GetCArray(v32, bundle_ca[bi]);
-    {
-      size_t nbytes = (size_t) bundle_ca[bi]->elements * sizeof(int32_t);
-      VALUE  vbuf   = rb_str_tmp_new((long) nbytes);
-      rb_ary_push((VALUE) keep, vbuf);
-      ca_copy_data(bundle_ca[bi], RSTRING_PTR(vbuf));
-      bundle_codes[bi] = (int32_t *) RSTRING_PTR(vbuf);
-    }
+    h_codes[bi] = 0;
+    bundle_codes[bi] = ALLOCV_N(int32_t, h_codes[bi], bundle_ca[bi]->elements);
+    ca_copy_data(bundle_ca[bi], (char *) bundle_codes[bi]);
 
     int nb = (int) RARRAY_LEN(vbaxes);
     if ( nb <= 0 || nb > src->ndim ) {
@@ -1413,6 +1412,7 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   ALLOCV_END(h_band2); ALLOCV_END(h_code);  ALLOCV_END(h_doff);
   ALLOCV_END(h_moff);  ALLOCV_END(h_addr);  ALLOCV_END(h_accd);
   ALLOCV_END(h_accn);  ALLOCV_END(h_seen);  ALLOCV_END(h_acco);
+  for ( int bi = 0; bi < n_bundles; bi++ ) ALLOCV_END(h_codes[bi]);
 
   RB_GC_GUARD(keep);
   return vout;
@@ -1421,8 +1421,8 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
 void
 Init_ca_axis_group (void)
 {
-  rb_define_method(rb_cCArray, "__axis_group_reduce__",
+  rb_define_method(rb_cCArray, "__reduce_by_axis_groups__",
                    rb_ca_axis_group_reduce, 3);
-  rb_define_method(rb_cCArray, "__axis_group_scan__",
+  rb_define_method(rb_cCArray, "__scan_by_axis_groups__",
                    rb_ca_axis_group_scan, 3);
 }

data/ext/ca_binop_dispatch.c

@@ -29,7 +29,7 @@
 
 /* The kernel table of each op id.  The eager operators hold the tables
    themselves; ca_binop_op_id_of_table maps one back to its op id, so that
-   both ask ca_binop_is_trapping the same question. */
+   both ask ca_op_raises_on_cell the same question. */
 static ca_binop_func_t * const ca_binop_tables[CA_BINOP_COUNT] = {
   [CA_BINOP_ADD]       = ca_binop_add,
   [CA_BINOP_SUB]       = ca_binop_sub,
@@ -116,31 +116,3 @@ ca_binop_kernel_input_data_types (uint16_t op_id, int8_t l_dt, int8_t r_dt,
   if ( out_r_in_dt ) *out_r_in_dt = common;
 }
 
-/* ------------------------------------------------------------------- */
-/* trapping-op predicate                                                */
-/* ------------------------------------------------------------------- */
-
-int
-ca_binop_is_trapping (uint16_t op_id, int8_t common_dt)
-{
-  /* An object cell calls Ruby, which can raise for any op.  Integer
-     DIV / MOD / QUO / FMOD / RCP_MUL raise on a zero divisor, and POW /
-     IPOWER on zero to a negative power.  Float division returns NaN/Inf
-     and does not trap.                                                 */
-  int is_integer = ( common_dt >= CA_INT8 && common_dt <= CA_UINT64 );
-  if ( common_dt == CA_OBJECT ) return 1;
-  if ( ! is_integer ) return 0;
-
-  switch (op_id) {
-    case CA_BINOP_DIV:
-    case CA_BINOP_MOD:
-    case CA_BINOP_QUO:
-    case CA_BINOP_FMOD:
-    case CA_BINOP_RCP_MUL:
-    case CA_BINOP_POW:
-    case CA_BINOP_IPOWER:
-      return 1;
-    default:
-      return 0;
-  }
-}

data/ext/ca_binop_dispatch.h

@@ -147,7 +147,6 @@ void ca_binop_kernel_input_data_types (uint16_t op_id, int8_t l_dt, int8_t r_dt,
    When trapping AND either operand has a mask, xfer_stride must pass
    a slab mask to the kernel so masked cells are skipped (otherwise
    masked-zero divisors crash with SIGFPE).  See §3.4 rev3.            */
-int ca_binop_is_trapping (uint16_t op_id, int8_t common_dt);
 int ca_binop_op_id_of_table (ca_binop_func_t table[]);
 
 #endif /* CA_BINOP_DISPATCH_H */