carray 3.0.3 → 3.0.4

data/yard-stubs/carray_mask.rb

@@ -27,6 +27,9 @@ class CArray
   #   mask (`value_array? == true`).
   #
   #   Use this to read or write the data slot of masked elements.
+  #   Nothing in a value array is masked, so `unmask` on it does nothing,
+  #   while a write that would mask a cell (`UNDEF`, `mask=`,
+  #   `invert_mask`) raises TypeError.
   #   @return [CArray]
   def value; end
 
@@ -35,6 +38,11 @@ class CArray
   #   element is `1` where `self` is masked and `0` where it is not.
   #   The returned view itself cannot carry a mask.
   #
+  #   The mask of a view is a view over its parent's mask: it follows
+  #   later changes to the parent's mask, and so does its `dup` or
+  #   `clone`, which is another view onto the same parent mask (a write
+  #   to it lands in the parent's mask). Use `copy` for a mask of its own.
+  #
   #   Returns `0` (Integer) if `self` has no mask array attached.
   #   @return [CArray, Integer]
   def mask; end
@@ -43,6 +51,12 @@ class CArray
   #   Sets the mask array of `self` to `new_mask`. Allocates the mask
   #   array first if `self` does not yet have one. Cannot be called on
   #   a value array or a mask array.
+  #
+  #   `mask=` replaces the whole mask with `new_mask`. A masked cell of
+  #   `new_mask` makes the cell masked, as a masked value does in any
+  #   store. To mask the cells where a condition holds, prefer
+  #   `self[cond] = UNDEF`. There a masked cell of `cond` selects nothing,
+  #   as it does in any index.
   #   @param new_mask [CArray, Boolean, Integer] mask values. A
   #     non-CArray value is broadcast and stored elementwise; a CArray
   #     of any type is coerced to boolean.
@@ -91,7 +105,11 @@ class CArray
   #     linearly by index from the two bracketing valid cells (numeric
   #     data_type, or a time Face — `CATime` / `CATimedelta` interpolate
   #     through their own `linear_fetch`, so the filled values stay on the
-  #     array's unit and are rounded to it).
+  #     array's unit and are rounded to it). An integer array takes the
+  #     nearest integer, half away from zero (`[190, _, _, 341]` fills
+  #     `240, 291`). The interpolation runs in float64, so in an int64
+  #     array with values beyond 2**53 the filled cells may be off by the
+  #     float64 spacing there; the valid cells are not touched.
   #   @param axis [Integer, nil] scan axis (single axis). `nil` flattens.
   #   @return [self]
   def unmask(*, method: nil, axis: nil); end
@@ -164,6 +182,8 @@ class CArray
   #   @param others [Array<CArray>] arrays whose mask states are
   #     OR-ed into `self`. Non-CArray arguments are ignored.
   #   @return [self]
+  #   @raise [ArgumentError] if an array in `others` other than a scalar
+  #     has fewer elements than `self`.
   def inherit_mask(*others); end
 
   # @overload inherit_mask_replace(*others)
@@ -173,6 +193,8 @@ class CArray
   #   @param others [Array<CArray>] arrays whose mask states form the
   #     new mask of `self`.
   #   @return [self]
+  #   @raise [ArgumentError] if an array in `others` other than a scalar
+  #     has fewer elements than `self`.
   def inherit_mask_replace(*others); end
 
   # @overload count_masked
@@ -226,7 +248,9 @@ class CArray
   #   In-place equivalent: `ca[:eq, v] = UNDEF`.
   #
   #   Replaces the removed `maskout(v)` from 2.x.
-  #   @param v [Object] value to mask. Cast to `self.data_type`.
+  #   `v` is compared as {#eq} compares it, by value: `1.5` masks nothing
+  #   in an integer array, and `-1` does not mask `255` in a `uint8` one.
+  #   @param v [Object] value to mask.
   #   @return [CArray]
   def mask_eq(v); end
 

data/yard-stubs/carray_math.rb

@@ -125,7 +125,33 @@ class CArray
   #   keeps its sign.  Masked elements stay masked.  An `:object`
   #   array delegates to each element's `#round`.
   #   @return [CArray] same `data_type` as `self`.
-  def round; end
+  # @overload round(ndigits)
+  #   Returns a new array with each element rounded to `ndigits` decimal
+  #   digits, to the value Ruby's `Float#round(ndigits)` gives for a float
+  #   element and `Integer#round(ndigits)` for an integer one, half away
+  #   from zero: `CA_FLOAT64([1.005, 2.675]).round(2)` is `[1.01, 2.68]`,
+  #   as `1.005.round(2)` and `2.675.round(2)` are.  A negative `ndigits`
+  #   rounds to tens, hundreds, ...: `CA_INT32([125, -125]).round(-1)` is
+  #   `[130, -130]`.  The result keeps `self`'s `data_type`, so a float
+  #   array stays float for every `ndigits`, and a `:float32` element is
+  #   rounded from its own value.  `NaN` and the infinities are left as
+  #   they are.  Masked elements stay masked.  An `:object` array calls
+  #   each element's `round(ndigits)`.  `round(0)` is `round`.
+  #   @param ndigits [Integer] decimal digits to keep; negative rounds to
+  #     the left of the decimal point.
+  #   @return [CArray] same `data_type` as `self`.
+  #   @raise [TypeError] if `ndigits` is not an Integer.
+  #   @raise [RangeError] if a rounded integer does not fit the
+  #     `data_type` (`CA_INT8([125]).round(-1)`).
+  #   @raise [CArray::DataTypeError] for a complex or fixed-length array.
+  def round(ndigits = nil); end
+
+  # @overload round!(ndigits = nil)
+  #   Rounds `self` in place, as {#round} does.  A boolean array can not
+  #   hold the rounded values and raises when `ndigits` is given.
+  #   @param ndigits [Integer, nil] decimal digits to keep.
+  #   @return [self]
+  def round!(ndigits = nil); end
 
   # @overload frac
   #   Returns a new array of the fractional part of each element:

data/yard-stubs/carray_median_percentile.rb

@@ -27,7 +27,9 @@ class CArray
   #   `UNDEF` when `fill_value` is `nil`).
   #
   #   With `keep_axis: true`, the reduced axis is retained with
-  #   length 1 rather than dropped.
+  #   length 1 rather than dropped. Along the only axis of a 1-D array
+  #   the result is a bare value, as `sum(axis: 0)` is (a one-cell array
+  #   with `keep_axis: true`).
   #   @param axis [Integer, nil]
   #   @param min_count [Integer] minimum not-masked count required.
   #   @param fill_value [Object, nil] replacement when the not-masked
@@ -47,7 +49,8 @@ class CArray
   #   `p` may be given as individual positional arguments, a single
   #   `Array<Numeric>`, or a single 1-D `CArray`. When the effective
   #   `p` count (after flattening) is 1, the result is unwrapped:
-  #   flat form returns a `Float`, per-axis form returns a `CArray`.
+  #   flat form returns a `Float`, per-axis form returns a `CArray`
+  #   (a bare value along the only axis of a 1-D array, as {#median}).
   #   With 2 or more `p` values the result is an `Array` whose length
   #   matches the number of requested `p` values.
   #

data/yard-stubs/carray_memory_view.rb

@@ -7,13 +7,14 @@ class CArray
     # @!group MemoryView interop
 
     # @overload memory_view_available?(obj)
-    #   Returns `true` if `obj` exposes the Ruby `rb_memory_view`
-    #   protocol and a view can be acquired from it. Lightweight probe
-    #   used to gate {.from_memory_view} / {.wrap_memory_view} calls.
+    #   Returns `true` if `obj` is a MemoryView producer (Ruby's
+    #   `rb_memory_view_available_p`). Lightweight probe used to gate
+    #   {.from_memory_view} / {.wrap_memory_view} calls; it does not
+    #   acquire a view.
     #
-    #   Returning `true` does not guarantee acquisition will succeed —
-    #   a producer may still refuse a particular flag combination at
-    #   acquisition time.
+    #   Returning `true` does not guarantee the import succeeds — the
+    #   producer may still refuse the view, or offer a format CArray
+    #   does not read.
     #   @param obj [Object] any object (typically a foreign array such
     #     as `Numo::NArray`, `Arrow::Array`, a `bytearray`, or a
     #     CArray).
@@ -26,6 +27,7 @@ class CArray
     # @overload memory_view_reject_reason(obj)
     #   Returns a String explaining why CArray's MemoryView producer
     #   refuses to export `obj`, or `nil` if no problem is detected.
+    #   For an object that is not a CArray it returns `nil`.
     #
     #   Diagnostic only; useful when {.memory_view_available?} returns
     #   `false` on a CArray and the generic "memory view not available"
@@ -34,8 +36,8 @@ class CArray
     #   (mask propagation, non-contiguous strided view, etc.) call this
     #   to print a human-readable reason.
     #   @param obj [Object]
-    #   @return [String, nil] reason text, or `nil` when acquisition
-    #     would succeed.
+    #   @return [String, nil] reason text, or `nil` when the export
+    #     would succeed or `obj` is not a CArray.
     def memory_view_reject_reason(obj); end
 
     # @overload from_memory_view(src, data_type: nil, mask: nil)
@@ -46,15 +48,20 @@ class CArray
     #
     #   For typeless producers (format `nil`, e.g. byte blobs from
     #   `IO#read`), `data_type:` is required and the byte buffer is
-    #   reinterpreted as that data type with `ndim = 1`. For typed
+    #   reinterpreted as that data type with `ndim = 1`; a typeless
+    #   producer whose own layout is strided is refused. For typed
     #   producers `data_type:` is optional; when given it must match
     #   the producer's format.
     #
     #   `mask:` accepts a paired buffer-protocol source whose shape
-    #   matches `src` and whose item size is 1 (PEP 3118 `?` / `B` /
-    #   `b`). The mask bytes are copied into the canonical
+    #   matches `src` and whose item size is 1 (`?` / `B` / `C` /
+    #   `b` / `c`). The mask bytes are copied into the canonical
     #   `CA_BOOLEAN` mask slot with non-zero coerced to `1`. The copy
-    #   is independent of both buffers after the call.
+    #   is independent of both buffers after the call. A boolean
+    #   producer's bytes other than 0 and 1 are read as true.
+    #
+    #   The result is a plain `CArray` whatever the receiver; a
+    #   receiver other than `CArray` or a `CAWrap` raises `TypeError`.
     #   @param src [Object] any MemoryView producer.
     #   @param data_type [Symbol, Integer, Class, nil] target data
     #     type. Required for typeless producers; optional (must match
@@ -63,7 +70,11 @@ class CArray
     #     source. Must match `src.shape` and use a 1-byte/element
     #     format.
     #   @return [CArray] independent copy; not a `CAWrap`.
+    #   @raise [TypeError] if the receiver is neither `CArray` nor a
+    #     `CAWrap`.
     #   @raise [ArgumentError] if `src` is not a MemoryView producer,
+    #     if its shape is negative, too large, or does not fit in the
+    #     bytes it reports,
     #     if `data_type:` is missing for a typeless source, if
     #     `data_type:` conflicts with the producer's format, or if
     #     the supplied `mask:` fails shape / data type / contiguity
@@ -92,19 +103,23 @@ class CArray
     #   when the wrap is garbage-collected.
     #
     #   Contiguous typed producers return a `CAWrap`. Strided typed
-    #   producers return a `CAStride` layered on an inner `CAWrap` of
-    #   the producer's first byte, preserving the full stride pattern
+    #   producers return a `CAStride` over a byte `CAWrap` of the
+    #   bytes its elements reach, preserving the full stride pattern
     #   (including negative strides where the producer offers them).
     #   Typeless producers (format `nil`) require `data_type:` and are
-    #   reinterpreted with `ndim = 1`.
+    #   reinterpreted with `ndim = 1`; a strided typeless producer is
+    #   refused. A boolean producer must hold 0 or 1 in every byte.
     #
     #   `mask:` accepts a paired buffer-protocol source whose shape
-    #   matches `src` and whose item size is 1 (PEP 3118 `?` / `B` /
-    #   `b`). The mask buffer is borrowed; writes to either side
-    #   propagate, and the mask MemoryView is released when the wrap
-    #   is collected. In this release, `mask:` requires a row-major
-    #   contiguous data source and a row-major contiguous mask
-    #   buffer.
+    #   matches `src` and whose item size is 1 (`?` / `B` / `C` /
+    #   `b` / `c`), holding 0 or 1 in every byte. The mask buffer is
+    #   borrowed; writes to either side propagate, and the mask
+    #   MemoryView is released when the wrap is collected. In this
+    #   release, `mask:` requires a row-major contiguous data source
+    #   and a row-major contiguous mask buffer that shares no bytes
+    #   with the data. A read-only mask makes the whole array
+    #   read-only, since a store writes the mask cell of each element
+    #   it stores.
     #
     #   The receiver picks the class of the result. Called on `CArray`
     #   it builds a `CAWrap`; called on a subclass of `CAWrap` it
@@ -132,10 +147,12 @@ class CArray
     #   @raise [TypeError] if the receiver is neither `CArray` nor a
     #     subclass of `CAWrap`.
     #   @raise [ArgumentError] if `src` is not a MemoryView producer,
-    #     if `data_type:` is missing for a typeless source, if
+    #     if its shape is negative, too large, or does not fit in the
+    #     bytes it reports, if a boolean buffer holds a byte other than
+    #     0 and 1, if `data_type:` is missing for a typeless source, if
     #     `data_type:` conflicts with the producer's format, or if
     #     the supplied `mask:` fails validation (shape / ndim /
-    #     data type / item_size / contiguity). Also raises when `mask:`
+    #     data type / item_size / contiguity / overlap with the data). Also raises when `mask:`
     #     is combined with a strided data source — that combination
     #     is not supported in this release.
     #   @example Zero-copy write propagation

data/yard-stubs/carray_order.rb

@@ -12,16 +12,15 @@ class CArray
   #
   #   Out-of-range positions are filled with `lval` (below-range) and
   #   `uval` (above-range); when `lval` is given alone, it fills
-  #   both. Without either, out-of-range positions are masked.
+  #   both. Without either, out-of-range positions are masked, and so
+  #   they are with a fill of `UNDEF`.
   #
   #   When `self` is a Face (CATime / CATimedelta / CACategorical),
-  #   the result is the same Face type, carrying the unit / labels; the
-  #   gather runs on the underlying storage and misses become UNDEF. Fill
-  #   (`lval` / `uval`) is not supported for a Face and raises ArgumentError
-  #   — omit the fill args to get UNDEF at misses.
+  #   the result is the same Face type, carrying the unit / labels, and a
+  #   fill is one of its values (a time for a CATime).
   #   @param idx [CArray] flat addresses, of any shape.
-  #   @param lval [Object, nil] fill for indices `< 0` (non-Face only).
-  #   @param uval [Object, nil] fill for indices `>= self.elements` (non-Face only).
+  #   @param lval [Object, nil] fill for indices `< 0`.
+  #   @param uval [Object, nil] fill for indices `>= self.elements`.
   #   @return [CArray] a fresh array shaped like `idx`; a Face of the same
   #     type when `self` is a Face.
   #   @raise [ArgumentError] if `lval` / `uval` is given and `self` is a Face.
@@ -97,17 +96,19 @@ class CArray
   #   `method:` selects how ties are ranked:
   #
   #   - `:ordinal` (default) — every cell gets a distinct rank; ties
-  #     are broken by original position (stable). This is a total
-  #     order: no two cells ever compare equal.
-  #   - `:dense` — tied values share one rank (no gaps). Useful as a
-  #     `sort_addr` priority key: an `:ordinal` key never ties, so a
-  #     lower-priority key after it is never consulted; a `:dense` key
+  #     are broken by original position (stable), the earlier cell first
+  #     in both directions. This is a total order: no two cells ever
+  #     compare equal.
+  #   - `:dense` — tied values share one rank (no gaps). Every NaN is
+  #     one value and shares one rank, placed after the numbers. Useful
+  #     as a `sort_addr` priority key: an `:ordinal` key never ties, so
+  #     a lower-priority key after it is never consulted; a `:dense` key
   #     preserves the tie so it is.
   #
-  #   `descending:` negates the rank order (`(n-1) - rank`, `n` =
-  #   fiber element count minus masked cells). This composes correctly
-  #   with `method: :dense`: ties stay tied after the transform, and
-  #   group-to-group order still reverses.
+  #   `descending:` ranks the largest value `0`; NaN comes after the
+  #   numbers in both directions. Tied cells keep their
+  #   original order under `:ordinal` and share a rank under `:dense`, so
+  #   dense ranks stay without gaps.
   #
   #   Masked cells are excluded from ranking (own cell becomes UNDEF,
   #   like `rank_index`); `descending:`/`method:` apply to the
@@ -162,12 +163,22 @@ class CArray
   #
   #   `val` is compared in the type both share, as `self.eq(val)`
   #   compares: an integer array searched with a Float is compared in
-  #   float64 (so `3.9` does not match `3`, and `eps` applies), and an
-  #   Integer that does not fit an integer array raises `RangeError`.
+  #   float64 (so `3.9` does not match `3`, and `eps` applies), a pair of
+  #   mixed sign is compared by value (`-1` does not find `255`), and an
+  #   Integer an integer array cannot hold matches nothing.
   #   The same holds for {#bsearch} and {#search_nearest}. On an
   #   `:object` array a cell matches when it is `==` to `val`, as {#eq}
   #   compares (so `1` matches `1.0`, which {#is_in} does not).
   #
+  #   An `UNDEF` `val`, or a masked cell of a CArray `val`, finds
+  #   nothing: `nil`, or `UNDEF` in that cell of the result.  The same
+  #   holds for {#bsearch} and {#search_nearest}.
+  #
+  #   A time array (`CATime`, `CATimedelta`) takes a value of another
+  #   unit, a `Time` or a String: when it is off the array's grid the
+  #   two are compared in the finer unit, so it matches nothing (and
+  #   {#search_nearest} finds the nearest cell).
+  #
   #   `self` need not be sorted; this is a linear scan. For sorted
   #   data prefer {#bsearch}.
   #   @param val [Object]

data/yard-stubs/carray_random.rb

@@ -24,7 +24,10 @@ class CArray
   #   Fills `self` with uniform random numbers in-place and returns
   #   `self`.  Boolean arrays fill 0/1 at 50% probability, ignoring
   #   any range argument.  Complex arrays sample real and imaginary
-  #   parts independently from the same range.
+  #   parts independently from the same range.  An integer array takes
+  #   Integer bounds whose every value fits its type (the whole range
+  #   of the type included); a float array takes finite bounds.  Every
+  #   cell gets a value, so the mask is cleared, as by `seq!` or `fill`.
   #
   #   @param low [Numeric] lower bound (inclusive).
   #   @param high [Numeric] upper bound (exclusive).
@@ -35,7 +38,11 @@ class CArray
   #   @raise [CArray::DataTypeError] for `:object` / `:fixlen` arrays.
   #   @raise [ArgumentError] when an integer array is called with no
   #     range, when `low >= high`, when a Range is combined with a
-  #     second positional argument, or when a Range endpoint is nil.
+  #     second positional argument, when a Range endpoint is nil, or
+  #     when a float bound is NaN or infinite.
+  #   @raise [TypeError] when an integer array is given a non-Integer
+  #     bound.
+  #   @raise [RangeError] when the integer range does not fit the type.
   def random!(*args, rng: nil); end
 
   # @overload random(rng: nil)
@@ -51,7 +58,7 @@ class CArray
   #   Fills `self` with standard normal `N(0, 1)` samples via
   #   Box-Muller and returns `self`. Restricted to float / complex
   #   data types; complex fills real and imaginary parts as two
-  #   independent normals per cell.
+  #   independent normals per cell.  The mask is cleared.
   #   @param rng [Random, nil] RNG instance; nil uses the per-ractor
   #     default RNG.
   #   @return [self]
@@ -72,7 +79,9 @@ class CArray
   #   Fisher-Yates permutes `self` in-place and returns `self`.
   #   Without `axis:`, shuffles all cells as if flattened. With
   #   `axis:`, permutes slices along that axis (the trailing
-  #   sub-slab is treated as a byte chunk and swapped whole).
+  #   sub-slab is treated as a byte chunk and swapped whole). The mask
+  #   moves with the values: a masked cell stays masked wherever it
+  #   lands.
   #   @param axis [Integer, nil] axis to permute along; nil = flat.
   #   @param rng [Random, nil] RNG instance; nil uses the per-ractor
   #     default RNG.

data/yard-stubs/carray_scatter.rb

@@ -16,13 +16,17 @@ class CArray
   # Shared contract:
   #
   # - `addrs` is a CArray of any integer type (coerced to
-  #   `CA_SIZE`) or a Ruby Array.
+  #   `CA_SIZE`) or a Ruby Array. A float or complex CArray is
+  #   refused with `IndexError`, as `self[addrs]` refuses it.
   # - `vals` is a CArray of length matching `addrs` (coerced to
-  #   `self.data_type`), or a Numeric scalar broadcast to all
-  #   addresses. A complex `self` also takes a Complex scalar.
-  # - Out-of-range `addrs[i]` (`< 0` or `>= self.elements`) raises
-  #   `IndexError`.  The pairs before it stay applied, through a view
-  #   as well.
+  #   `self.data_type`), or a scalar broadcast to all addresses: any
+  #   Numeric, `true` / `false`, or `UNDEF`. The scalar is converted as
+  #   `self[i] = v` converts it, so a value that does not fit the type
+  #   raises (`RangeError`, `FloatDomainError` for NaN into an integer
+  #   type). A scalar `UNDEF` is a masked value.
+  # - A negative `addrs[i]` counts from the end. One out of range
+  #   raises `IndexError`; the pairs before it stay applied, through a
+  #   view as well.
   # - `self.data_type` must be numeric. Complex is accepted by
   #   every variant except {#scatter_min!} and {#scatter_max!},
   #   since complex values have no order.
@@ -101,11 +105,12 @@ class CArray
   #   result is written back many times.
   #
   #   Unlike the arithmetic `scatter_*!` family, `self` may be
-  #   **boolean** (assignment does not widen), and `true` / `false`
-  #   are accepted as scalar `vals` alongside numeric scalars.
+  #   **boolean** (assignment does not widen); `true` / `false` (or
+  #   `1` / `0`) are its scalar values. A scalar `UNDEF` masks every
+  #   addressed cell.
   #
   #   @param addrs [CArray, Array<Integer>]
-  #   @param vals [CArray, Numeric, true, false]
+  #   @param vals [CArray, Numeric, true, false, UNDEF]
   #   @return [self]
   def scatter_replace!(addrs, vals); end
 

data/yard-stubs/carray_slab.rb

@@ -14,7 +14,8 @@ class CArray
   #   duration of the block — capturing it across iterations sees the last
   #   slab's data — and it is read-only: writing through it raises.  To
   #   produce values per slab use `map_slab` or `reduce_slab`; to write in
-  #   place, assign through the array itself.
+  #   place, assign through the array itself.  Over a Face (`CATime`, a
+  #   record type) the slab is that Face.
   # @overload each_slab(axis:)
   #   Returns an Enumerator when no block is given.
   #   @param axis [Integer, Array<Integer>, nil] the slab axis or axes
@@ -29,7 +30,9 @@ class CArray
   #   block's result.  The block receives the slab view and must return a
   #   value of the same shape as the slab (a CArray or scalar); the results
   #   are written into the output at the same positions, and a masked
-  #   cell of the block's result is masked in the output.
+  #   cell of the block's result is masked in the output.  Over a Face the
+  #   slab is that Face, and the output is too unless `data_type:` is
+  #   given; a read-only Face answers in `:object` cells.
   #   @param axis [Integer, Array<Integer>, nil] the slab axis or axes.
   #   @param data_type [Symbol, Integer, Class, nil] output data type
   #     (defaults to `self`'s data type).
@@ -48,6 +51,10 @@ class CArray
   #   Per-element form (`init:` given): the block receives `(acc, x)` for
   #   each element of the slab and returns the new accumulator; the final
   #   accumulator per slab fills the output.
+  #
+  #   `UNDEF` from the block masks that output cell.  Over a Face the slab
+  #   (and each element) is that Face's, and the output is that Face unless
+  #   `data_type:` is given; a read-only Face answers in `:object` cells.
   #   @param axis [Integer, Array<Integer>, nil] the slab axis or axes.
   #   @param init [Object] the initial accumulator (selects the
   #     per-element form).

data/yard-stubs/carray_sort.rb

@@ -179,8 +179,8 @@ class CArray
   #   is a one-liner on top of `flatten[axis2addr(...)]`.
   #
   #   Shape rule: `indices.ndim == self.ndim`, and
-  #   `indices.dim[j] == self.dim[j]` for all `j != axis`;
-  #   `indices.dim[axis]` is free.
+  #   `indices.shape[j] == self.shape[j]` for all `j != axis`;
+  #   `indices.shape[axis]` is free.
   #
   #   `indices` data_type: any integer kind (zero-copy when
   #   already `:int64`). Negative indices: Python-style
@@ -196,9 +196,10 @@ class CArray
   #   @return [CArray] `:int64` view-flat addresses, same shape as
   #     `indices`.
   #   @raise [IndexError] when an index is out of range after
-  #     negative normalization.
-  #   @raise [ArgumentError] for shape / ndim / data_type
-  #     violations.
+  #     negative normalization, or `indices` is a float or complex
+  #     array.
+  #   @raise [ArgumentError] for shape / ndim violations, or a
+  #     boolean / object `indices`.
   def axis2addr(indices, axis: 0); end
 
   # @!endgroup

data/yard-stubs/carray_test.rb

@@ -6,8 +6,9 @@ class CArray
   # @!group Index and address conversion
 
   # @overload valid_index?(*idx)
-  #   Returns `true` if the given index tuple is in range for `self`.
-  #   The number of indices must equal `ndim`.
+  #   Returns `true` if the given index tuple names a cell of `self`,
+  #   that is, if `self[*idx]` would not raise. A negative index counts
+  #   from the end of its axis. The number of indices must equal `ndim`.
   #   @param idx [Array<Integer>] one index per axis.
   #   @return [Boolean]
   #   @raise [ArgumentError] if the number of indices does not match
@@ -15,7 +16,8 @@ class CArray
   def valid_index?(*idx); end
 
   # @overload valid_addr?(addr)
-  #   Returns `true` if `addr` is in range `0...elements` for `self`.
+  #   Returns `true` if `addr` names a cell of `self`: `0...elements`, or
+  #   a negative address counting from the end (`-elements..-1`).
   #   @param addr [Integer] flat address into the contiguous element
   #     sequence.
   #   @return [Boolean]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: carray
 version: !ruby/object:Gem::Version
-  version: 3.0.3
+  version: 3.0.4
 platform: ruby
 authors:
 - himotoyoshi
@@ -111,11 +111,13 @@ files:
 - ext/carray_attribute.c
 - ext/carray_bincount.c
 - ext/carray_broadcast.c
+- ext/carray_build_flags.h
 - ext/carray_call_cfunc.c
 - ext/carray_call_cfunc.h
 - ext/carray_cast.c
 - ext/carray_cast_func.rb
 - ext/carray_class.c
+- ext/carray_config.h
 - ext/carray_conversion.c
 - ext/carray_copy.c
 - ext/carray_core.c
@@ -129,6 +131,21 @@ files:
 - ext/carray_index_classifier.c
 - ext/carray_index_classifier.h
 - ext/carray_internal.h
+- ext/carray_kernels_bincmp.c
+- ext/carray_kernels_binop.c
+- ext/carray_kernels_init.c
+- ext/carray_kernels_moncmp.c
+- ext/carray_kernels_monop.c
+- ext/carray_kernels_reduce_aggregate.c
+- ext/carray_kernels_reduce_boolean.c
+- ext/carray_kernels_reduce_cumulative.c
+- ext/carray_kernels_reduce_extreme.c
+- ext/carray_kernels_reduce_variance.c
+- ext/carray_kernels_scan.c
+- ext/carray_kernels_search.c
+- ext/carray_kernels_sort.c
+- ext/carray_kernels_triop.c
+- ext/carray_key_windows.c
 - ext/carray_lazy.c
 - ext/carray_loop.c
 - ext/carray_mask.c
@@ -140,6 +157,7 @@ files:
 - ext/carray_order.c
 - ext/carray_partition.c
 - ext/carray_random.c
+- ext/carray_round.c
 - ext/carray_scatter.c
 - ext/carray_segment.c
 - ext/carray_slab.c
@@ -159,7 +177,6 @@ files:
 - ext/version.h
 - ext/version.rb
 - lib/carray.rb
-- lib/carray/arrow_tensor.rb
 - lib/carray/attribute.rb
 - lib/carray/autoload_carray.rb
 - lib/carray/autoload_method_extension.rb
@@ -177,8 +194,10 @@ files:
 - lib/carray/core_extensions.rb
 - lib/carray/data_type_extension.rb
 - lib/carray/data_type_limits.rb
+- lib/carray/distance_limit.rb
 - lib/carray/fixlen_string.rb
 - lib/carray/frame.rb
+- lib/carray/frame/column_verbs.rb
 - lib/carray/frame/concat.rb
 - lib/carray/frame/convert.rb
 - lib/carray/frame/csv_parser.rb
@@ -191,11 +210,13 @@ files:
 - lib/carray/frame/reshape.rb
 - lib/carray/frame/sort.rb
 - lib/carray/frame/verbs.rb
+- lib/carray/frame/windows.rb
 - lib/carray/fuse_source.rb
 - lib/carray/fusion.rb
 - lib/carray/histogram.rb
 - lib/carray/inspect.rb
 - lib/carray/iterator.rb
+- lib/carray/key_windows.rb
 - lib/carray/lazy.rb
 - lib/carray/mask_gap_fill.rb
 - lib/carray/math.rb
@@ -212,8 +233,10 @@ files:
 - lib/carray/methods/gather_nd.rb
 - lib/carray/methods/index.rb
 - lib/carray/methods/insert_block.rb
+- lib/carray/methods/is_between.rb
 - lib/carray/methods/is_in.rb
 - lib/carray/methods/join.rb
+- lib/carray/methods/lag.rb
 - lib/carray/methods/locate_addr.rb
 - lib/carray/methods/mask_duplicates.rb
 - lib/carray/methods/meshgrid.rb
@@ -237,7 +260,6 @@ files:
 - lib/carray/string_operation_extension.rb
 - lib/carray/struct.rb
 - lib/carray/struct_builder.rb
-- lib/carray/table.rb
 - lib/carray/time.rb
 - lib/carray/window_iterator.rb
 - yard-stubs/ca_obj_array.rb