carray 3.0.4 → 3.0.6

data/yard-stubs/carray_cast.rb

@@ -202,10 +202,13 @@ class CArray
   # -- as_type: reinterpreting view (no copy) ---------------------------
 
   # @overload as_type(data_type, bytes: nil)
-  #   Returns a {CAFake} view of `self` reinterpreted as `data_type`
-  #   (with `bytes:` for `:fixlen`). Reads and writes cast on the fly
-  #   through the shared parent storage; no copy is made. For an eager
-  #   copy use `arr.as_type(...).to_ca` or {#to_type}.
+  #   Returns a view of `self` reinterpreted as `data_type` (with
+  #   `bytes:` for `:fixlen`): a {CAMonOp} for a numeric type, a {CAFake}
+  #   otherwise. Reads and writes cast on the fly through the shared
+  #   parent storage; no copy is made. The view is a new array also when
+  #   `data_type` is `self`'s own, so an attribute set on it or a freeze
+  #   of it does not reach `self`. For an eager copy use
+  #   `arr.as_type(...).copy` or {#to_type}.
   #
   #   Note: for an `:object` source the on-the-fly cast to a numeric type
   #   uses the lenient path and does NOT mask parse failures — a
@@ -225,7 +228,7 @@ class CArray
   #   @param data_type [Symbol, Integer, Class, String] target element type.
   #   @param bytes [Integer, nil] element width in bytes, required for
   #     `:fixlen`.
-  #   @return [CAFake]
+  #   @return [CAMonOp, CAFake]
   #   @raise [TypeError] when `self` is a Face and the request would read its
   #     storage under another type.
   #   @raise [FloatDomainError] when a NaN cell that is not masked is read
@@ -472,6 +475,8 @@ class CArray
   #
   #   - CArray instance -> its `data_type`
   #   - Symbol / String / Class -> data_type representation (name lookup)
+  #   - MemoryView producer -> the data_type its format names; one whose
+  #     format carray cannot read is refused, as an operator refuses it
   #   - Integer / Float / Complex / true / false / nil / Object -> *value*,
   #     data_type inferred (3 -> `:int64`, 3.14 -> `:float64`,
   #     1+2i -> `:cmplx128`, ...)

data/yard-stubs/carray_conversion.rb

@@ -63,7 +63,11 @@ class CArray
 
   # @overload to_s
   #   Equivalent to `dump_binary` with no arguments. Returns the raw
-  #   element bytes of `self` as a binary String.
+  #   element bytes of `self` as a binary String. Ruby uses `to_s` where
+  #   it puts an object into text, so such text holds the bytes: a
+  #   `Ractor.make_shareable` refusal of a view, for one, raises
+  #   `ArgumentError: string contains null byte` in place of its own
+  #   message. Use `inspect` for a readable form.
   #   @return [String]
   def to_s; end
 
@@ -77,10 +81,16 @@ class CArray
   #   `String` of the exact size, or any object responding to
   #   `read(n, buf = nil)`. Into a boolean array, a non-zero byte is
   #   read as 1 (true).
+  #   From an IO into an array that owns its memory, the bytes are written
+  #   as they are read, so that no second copy of the data is held; when the
+  #   IO runs out before the array is full, what the array holds afterwards
+  #   is not defined (the part read so far may already be in it).  Into a
+  #   view the whole data is read first and nothing is written on a short
+  #   read.
   #   @param io [String, IO, #read]
   #   @return [self]
-  #   @raise [RuntimeError] on a short read.
-  #   @raise [ArgumentError] when a String source is not the array's size.
+  #   @raise [ArgumentError] on a short read, and when a String source is
+  #     not the array's size.
   #   @raise [CArray::DataTypeError] if `self.data_type` is
   #     `:object`.
   def load_binary(io); end

data/yard-stubs/carray_element.rb

@@ -5,12 +5,13 @@
 class CArray
   # @!group Element access
   #
-  # `elem_*` methods are low-level single-cell operations. They
-  # accept `idx` as either an Integer (flat address into the
-  # row-major element sequence) or an `Array<Integer>` (one index
-  # per axis). They bypass the broadcasting and view-construction
-  # paths used by `[]` / `[]=`, and are the right tool for
-  # tight per-cell loops where allocation matters.
+  # `elem_*` methods are the fastest way to reach one cell when you
+  # hold its per-axis index. They accept `idx` as an `Array<Integer>`
+  # (one index per axis) or an Integer (flat address into the
+  # row-major element sequence). An index is read as `[]` reads one:
+  # an Integer, or a Float with no fraction. The result is the same as `[]` /
+  # `[]=` for that cell; the key parsing and view construction of
+  # the general indexer are skipped.
 
   # @overload elem_swap(idx1, idx2)
   #   Exchanges the values (and mask states, if any) at positions

data/yard-stubs/carray_mask.rb

@@ -26,10 +26,27 @@ class CArray
   #   bypassing the mask. The returned view itself cannot carry a
   #   mask (`value_array? == true`).
   #
-  #   Use this to read or write the data slot of masked elements.
+  #   This is a method for peeking at the internal state of an array, and
+  #   nothing more. What a masked cell holds is not defined: a computation
+  #   leaves there whatever it happens to. Use it on the spot, as in
+  #   `a.value.copy`, `a.value[nil, 1].copy` or `a.value[nil, 1] = 2`; do
+  #   not keep the view to carry around (`b = a.value`,
+  #   `b = a.value[nil, 1]`), do not compute with it, and do not mix it
+  #   with other arrays (as an operand, or as a part of {CArray.stack} or
+  #   {CArray.meld}). To take the mask off, use {#unmask} or
+  #   {#strip_mask} and give the masked cells a value.
+  #
+  #   A library that handles the mask itself may use `value` on the spot
+  #   to hand the stored cells on together with {#mask}, as long as it
+  #   reads nothing from the masked ones.
+  #
   #   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.
+  #
+  #   On a Face the data slot is read through the Face. A {CACategorical}
+  #   cell excluded by the sentinel code has no label, so its value reads
+  #   as `nil` (the codes are in `codes`).
   #   @return [CArray]
   def value; end
 
@@ -80,6 +97,12 @@ class CArray
   # that derives values from neighbouring valid cells (mask gap-fill).
   # The two are mutually exclusive: passing both raises `ArgumentError`.
   #
+  # On a view, the values are written through to the cells it views. A
+  # position with no cell behind it -- the place of a masked cell of an
+  # index array (`a[i]`), as a join with `view: :full` gives for an
+  # unmatched row -- takes no write and stays masked, without an error.
+  # `strip_mask` gives a new array, where every masked cell takes a value.
+  #
   # @overload unmask
   #   Clears the mask state of every element of `self`, leaving the
   #   stored data values untouched. Mutates `self`.
@@ -180,10 +203,11 @@ class CArray
   #   of `self` and the masks of each array in `others`. Mutates
   #   `self`.
   #   @param others [Array<CArray>] arrays whose mask states are
-  #     OR-ed into `self`. Non-CArray arguments are ignored.
+  #     OR-ed into `self`.
   #   @return [self]
   #   @raise [ArgumentError] if an array in `others` other than a scalar
-  #     has fewer elements than `self`.
+  #     has a different number of elements from `self`.
+  #   @raise [TypeError] if an argument is not a CArray.
   def inherit_mask(*others); end
 
   # @overload inherit_mask_replace(*others)
@@ -194,7 +218,7 @@ class CArray
   #     new mask of `self`.
   #   @return [self]
   #   @raise [ArgumentError] if an array in `others` other than a scalar
-  #     has fewer elements than `self`.
+  #     has a different number of elements from `self`.
   def inherit_mask_replace(*others); end
 
   # @overload count_masked

data/yard-stubs/carray_math.rb

@@ -11,6 +11,11 @@
 # builds a node in the expression tree instead of evaluating, and the
 # eager and lazy paths are required to agree element for element.
 #
+# The transcendental functions call the platform's C math library, so
+# their last bits, and the complex functions' answers at special values
+# (signed zeros, infinities, NaN), follow that library and can differ
+# between operating systems.
+#
 # See yard-stubs/README.md and yard-stubs/STYLE.md.
 
 class CArray
@@ -226,6 +231,13 @@ class CArray
   #   integer base with a negative integer exponent truncates toward
   #   zero rather than producing a fraction (`2 ** -1` is `0`). Cast to
   #   a float `data_type` first when a fractional power is wanted.
+  #   A float or complex array raised to an Integer is computed by
+  #   repeated multiplication rather than by `pow`.  Its rounding error
+  #   grows roughly in proportion to the exponent (tens of ulps at 100,
+  #   hundreds of thousands at a million), where `Float#**` and the same
+  #   exponent given as a Float are within an ulp or so; give the exponent
+  #   as a Float when a large one needs full precision.  The exponent can
+  #   be any Integer that fits 64 bits.
   #   Masked elements stay masked.
   #   @param other [CArray, Numeric] exponent, broadcast to `self.shape`.
   #   @return [CArray] result of the promoted `data_type` of the two
@@ -598,6 +610,8 @@ class CArray
   #   Returns each element of `self` with the magnitude it already has
   #   and the sign of the matching element of `other`. The sign of a
   #   zero is respected, so `copysign` distinguishes `-0.0` from `0.0`.
+  #   The sign of a NaN that a computation produced (`sqrt(-1)`,
+  #   `Inf * 0`) depends on the CPU: x86 sets it, ARM does not.
   #   Accepts float and `:object` arrays only, as {#atan2}.
   #   @param other [CArray, Numeric] sign source, broadcast to
   #     `self.shape`.
@@ -683,8 +697,8 @@ class CArray
   # @overload pmax(other)
   #   Returns the element-wise larger of `self` and `other`, ignoring
   #   `NaN`: where one element is `NaN` the other is returned, and only
-  #   two `NaN`s give `NaN`. This is C's `fmax`. For the form that lets
-  #   a `NaN` win see {#maximum}.
+  #   two `NaN`s give `NaN`. Of `-0.0` and `0.0` the result is `0.0`,
+  #   in either order. For the form that lets a `NaN` win see {#maximum}.
   #   @param other [CArray, Numeric] the other operand, broadcast to
   #     `self.shape`.
   #   @return [CArray] result of the promoted `data_type` of the two
@@ -697,7 +711,8 @@ class CArray
 
   # @overload pmin(other)
   #   Returns the element-wise smaller of `self` and `other`, ignoring
-  #   `NaN`. The counterpart of {#pmax}.
+  #   `NaN`. Of `-0.0` and `0.0` the result is `-0.0`, in either order.
+  #   The counterpart of {#pmax}.
   #   @param other [CArray, Numeric] the other operand.
   #   @return [CArray]
   #   @raise [CArray::DataTypeError] for a complex array.
@@ -929,7 +944,9 @@ class CArray
   # @overload signbit
   #   Returns a boolean array that is true where an element carries a
   #   negative sign bit. A negative zero is true, which distinguishes
-  #   `-0.0` from `0.0` where a `< 0` comparison cannot.
+  #   `-0.0` from `0.0` where a `< 0` comparison cannot. On a NaN that a
+  #   computation produced (`sqrt(-1)`, `Inf * 0`) the answer depends on
+  #   the CPU: x86 sets the sign bit, ARM does not.
   #   @return [CArray] `:boolean`.
   #   @raise [CArray::DataTypeError] for a complex array.
   #   @example
@@ -939,13 +956,15 @@ class CArray
   # @overload &(other)
   #   Returns the element-wise conjunction of `self` and `other`: a
   #   bitwise `AND` on integer arrays, a logical `AND` on boolean ones.
+  #   **On boolean arrays it is three-valued (Kleene); {#and} is the
+  #   two-valued form.** The two give different answers where one side
+  #   is masked.
   #
-  #   On boolean arrays the masked elements follow three-valued
-  #   (Kleene) logic rather than propagating blindly: an unknown
-  #   element `AND` `false` is `false`, because the answer does not
-  #   depend on the unknown. Only where the result genuinely depends on
-  #   a masked element is the result masked. {#and} is the two-valued
-  #   form that always propagates.
+  #   An unknown (masked) element `AND` `false` is `false`, because the
+  #   answer does not depend on the unknown; only where the result
+  #   genuinely depends on a masked element is the result masked. So
+  #   `(a & b).not` is `true` where `a` is `false`, whatever `b` is,
+  #   while `a.and(b).not` stays masked where `b` is.
   #   @param other [CArray, Integer, true, false] the other operand,
   #     broadcast to `self.shape`.
   #   @return [CArray] `:boolean` for boolean operands, otherwise the
@@ -962,8 +981,9 @@ class CArray
   # @overload |(other)
   #   Returns the element-wise disjunction of `self` and `other`: a
   #   bitwise `OR` on integer arrays, a logical `OR` on boolean ones.
-  #   Boolean operands follow Kleene logic as in {#&}, so an unknown
-  #   element `OR` `true` is `true`.
+  #   **On boolean arrays it is three-valued (Kleene) as {#&} is; {#or}
+  #   is the two-valued form.** An unknown element `OR` `true` is
+  #   `true`.
   #   @param other [CArray, Integer, true, false] the other operand,
   #     broadcast to `self.shape`.
   #   @return [CArray] `:boolean` for boolean operands, otherwise the
@@ -1045,13 +1065,16 @@ class CArray
   def not; end
 
   # @overload and(other)
-  #   Returns the two-valued logical `AND` of two boolean arrays.
+  #   Returns the logical `AND` of two boolean arrays, **two-valued: a
+  #   masked element on either side makes the result masked**, even
+  #   where the other side alone would settle the answer. {#&} is the
+  #   three-valued form, and the two differ exactly there: `false & U`
+  #   is `false`, `false.and(U)` is `U`.
   #
-  #   Where {#&} applies Kleene logic, this form propagates the mask
-  #   unconditionally: if either element is masked the result is
-  #   masked, even when the unmasked element alone would settle the
-  #   answer. Use it when an unknown operand should make the result
-  #   unknown regardless.
+  #   Use it when the answer should be given only where both inputs are
+  #   known -- the element-wise counterpart of keeping only complete
+  #   records -- and {#&} when an answer the known side settles should
+  #   stand.
   #   @param other [CArray, true, false] the other operand, broadcast
   #     to `self.shape`.
   #   @return [CArray] `:boolean`.
@@ -1060,8 +1083,10 @@ class CArray
   def and(other); end
 
   # @overload or(other)
-  #   Returns the two-valued logical `OR` of two boolean arrays,
-  #   propagating the mask unconditionally as {#and} does.
+  #   Returns the logical `OR` of two boolean arrays, **two-valued: a
+  #   masked element on either side makes the result masked**, as
+  #   {#and} does. {#|} is the three-valued form: `true | U` is `true`,
+  #   `true.or(U)` is `U`.
   #   @param other [CArray, true, false] the other operand.
   #   @return [CArray] `:boolean`.
   #   @raise [CArray::DataTypeError] for any `data_type` other than

data/yard-stubs/carray_memory_view.rb

@@ -102,6 +102,13 @@ class CArray
     #   returned object via internal ivars; the source is released
     #   when the wrap is garbage-collected.
     #
+    #   Views made from the wrap keep it reachable too, so the view is
+    #   given back only once all of them are collected. A producer that
+    #   locks while it is borrowed (`IO::Buffer` refuses `resize` and
+    #   `free`) stays locked until then; import with
+    #   {.from_memory_view} to hold no view at all. See
+    #   {file:docs/interop/MemoryView.md MemoryView} §9.
+    #
     #   Contiguous typed producers return a `CAWrap`. Strided typed
     #   producers return a `CAStride` over a byte `CAWrap` of the
     #   bytes its elements reach, preserving the full stride pattern

data/yard-stubs/carray_order.rb

@@ -128,7 +128,8 @@ class CArray
 
   # @overload bsearch(val)
   #   Returns the flat address of `val` in `self` via binary search.
-  #   `self` must be sorted along its single (flat) axis. Returns
+  #   `self` must be sorted along its single (flat) axis. Of several
+  #   equal cells, the first one's address is returned. Returns
   #   `nil` if `val` is not present. When `val` is a CArray, returns
   #   a CArray of `:int64` addresses (one per element of `val`),
   #   with `UNDEF` at positions where the value is not present.
@@ -159,7 +160,8 @@ class CArray
   # @overload search(val, eps = nil)
   #   Returns the flat address of the first element of `self` equal
   #   to `val`. For float types, `eps` (default machine epsilon)
-  #   sets the tolerance. Returns `nil` if no match.
+  #   sets the tolerance; a negative or NaN `eps` raises
+  #   `ArgumentError`. Returns `nil` if no match.
   #
   #   `val` is compared in the type both share, as `self.eq(val)`
   #   compares: an integer array searched with a Float is compared in
@@ -201,7 +203,10 @@ class CArray
 
   # @overload search_nearest(val)
   #   Returns the flat address of the element of `self` whose value
-  #   is closest to `val`.
+  #   is closest to `val`. Of several equally close elements, the one
+  #   at the lowest address wins, as {#search} answers the first match
+  #   (`[0, 2, 4].search_nearest(1)` is 0). {#locate_nearest_addr}
+  #   rounds a position instead, and answers the larger value on a tie.
   #
   #   In an `:object` array the distance is `val.distance(other)` when
   #   `val` answers `#distance`, and `(val - other).abs` when it is a
@@ -268,7 +273,9 @@ class CArray
   #   `self` is coerced to `:float64` if it is not already. When
   #   `axis: nil`, `self` is flattened to 1-D first.
   #
-  #   Out-of-range `addr` returns NaN.
+  #   A position with no answer -- out of range, or between samples one
+  #   of which is NaN -- gives `nil` for a scalar `addr` and NaN in the
+  #   cell of an array result.
   #
   #   Because this half of the pair returns a *value* rather than a
   #   position, a Face axis gets its Face back: `CATime#linear_fetch` /
@@ -280,5 +287,94 @@ class CArray
   #   @see file:docs/topics/LinearInterpolation.md
   def linear_fetch(addr, axis: nil); end
 
+  # @overload nlargest(n, axis: nil)
+  #   Returns the `n` largest values, largest first. Without `axis:` the
+  #   array is read flat; with it, each fiber along `axis` gives its own
+  #   `n` and the axis keeps length `n`. A NaN and a masked cell lose to
+  #   every value; when fewer cells remain than `n`, the result is
+  #   shorter (or, per fiber, ends in UNDEF).
+  #   @param n [Integer] how many values, 0 or more.
+  #   @param axis [Integer, nil]
+  #   @return [CArray]
+  #   @raise [ArgumentError] when `n` is negative.
+  def nlargest(n, axis: nil); end
+
+  # @overload nsmallest(n, axis: nil)
+  #   Returns the `n` smallest values, smallest first. As {#nlargest}
+  #   otherwise.
+  #   @param n [Integer]
+  #   @param axis [Integer, nil]
+  #   @return [CArray]
+  #   @raise [ArgumentError] when `n` is negative.
+  def nsmallest(n, axis: nil); end
+
+  # @overload nlargest_index(n, axis:)
+  #   Returns, along `axis`, the axis-local positions of each fiber's `n`
+  #   largest values, largest first (`take_along_axis` reads the values
+  #   back). `axis:` is required.
+  #   @param n [Integer]
+  #   @param axis [Integer]
+  #   @return [CArray] `:int64` positions.
+  #   @raise [ArgumentError] when `axis:` is missing or `n` is negative.
+  def nlargest_index(n, axis:); end
+
+  # @overload nsmallest_index(n, axis:)
+  #   As {#nlargest_index}, for the `n` smallest values.
+  #   @param n [Integer]
+  #   @param axis [Integer]
+  #   @return [CArray] `:int64` positions.
+  #   @raise [ArgumentError] when `axis:` is missing or `n` is negative.
+  def nsmallest_index(n, axis:); end
+
+  # @overload sort_by_key(key, axis: 0)
+  #   Returns `self` reordered along `axis` by the order of `key` (an
+  #   array of `self`'s shape): `self[key.sort_addr(axis:)]`.
+  #   @param key [CArray] the values to order by.
+  #   @param axis [Integer]
+  #   @return [CArray]
+  #   @raise [ArgumentError] when `key`'s shape differs from `self`'s.
+  def sort_by_key(key, axis: 0); end
+
+  # @overload max_by_key(key, axis: nil)
+  #   Returns the value of `self` where `key` is largest: one value, or
+  #   one per fiber along `axis`. UNDEF where there is no cell to compare.
+  #   @param key [CArray] the values to compare, of `self`'s shape.
+  #   @param axis [Integer, nil]
+  #   @return [Object, CArray]
+  #   @raise [ArgumentError] when `key`'s shape differs from `self`'s.
+  def max_by_key(key, axis: nil); end
+
+  # @overload min_by_key(key, axis: nil)
+  #   As {#max_by_key}, where `key` is smallest.
+  #   @param key [CArray]
+  #   @param axis [Integer, nil]
+  #   @return [Object, CArray]
+  #   @raise [ArgumentError] when `key`'s shape differs from `self`'s.
+  def min_by_key(key, axis: nil); end
+
+  # @overload take_along_axis(indices, axis: 0)
+  #   Returns the values of `self` at axis-local `indices` along `axis`
+  #   (`indices` has `self`'s shape except along `axis`), as the
+  #   `*_index(axis:)` methods answer them. A masked index reads UNDEF.
+  #   @param indices [CArray] integer positions along `axis`.
+  #   @param axis [Integer]
+  #   @return [CArray]
+  def take_along_axis(indices, axis: 0); end
+
+  # @overload put_along_axis(indices, values, axis: 0)
+  #   Writes `values` into `self` at axis-local `indices` along `axis`,
+  #   the inverse of {#take_along_axis}. A masked index writes nothing.
+  #   @param indices [CArray] integer positions along `axis`.
+  #   @param values [CArray, Object]
+  #   @param axis [Integer]
+  #   @return [self]
+  def put_along_axis(indices, values, axis: 0); end
+
+  # @overload range
+  #   Returns `min..max` of `self` from one pass (`UNDEF..UNDEF` when no
+  #   cell takes part).
+  #   @return [Range]
+  def range; end
+
   # @!endgroup
 end

data/yard-stubs/carray_scatter.rb

@@ -104,13 +104,15 @@ class CArray
   #   allocates view state); useful in hot loops where a scatter
   #   result is written back many times.
   #
-  #   Unlike the arithmetic `scatter_*!` family, `self` may be
-  #   **boolean** (assignment does not widen); `true` / `false` (or
-  #   `1` / `0`) are its scalar values. A scalar `UNDEF` masks every
-  #   addressed cell.
+  #   Unlike the arithmetic `scatter_*!` family, `self` may be of any
+  #   type (assignment does not widen): **boolean**, with `true` /
+  #   `false` (or `1` / `0`) as its scalar values, and **object** or
+  #   **fixlen**, written as `self.flatten[addrs] = vals` writes them
+  #   (as `put_nd` and `put_along_axis` take them). A scalar `UNDEF`
+  #   masks every addressed cell.
   #
   #   @param addrs [CArray, Array<Integer>]
-  #   @param vals [CArray, Numeric, true, false, UNDEF]
+  #   @param vals [CArray, Object, UNDEF]
   #   @return [self]
   def scatter_replace!(addrs, vals); end
 

data/yard-stubs/carray_test.rb

@@ -36,8 +36,11 @@ class CArray
   # @overload ==(other)
   #   Returns `true` if `other` is a CArray with the same shape,
   #   `data_class`, `data_type`, mask state, and elementwise values as
-  #   `self`. NaN values compare unequal (IEEE semantics), so two
-  #   arrays with NaN at the same position are not `==`.
+  #   `self`. It asks whether the contents are the same, so a NaN equals
+  #   a NaN at the same position (whatever its payload, in a float, a
+  #   complex part or an object cell) and -0.0 equals 0.0: an array with
+  #   NaN is `==` to its copy. The IEEE comparison, where NaN equals
+  #   nothing, is {#eq}, cell by cell.
   #
   #   A Face (a time, string or categorical array) equals only a Face of
   #   its own class, and is compared by its values: two time arrays of
@@ -53,8 +56,8 @@ class CArray
   #   Returns `true` under Hash-invariant semantics: `data_class`,
   #   `data_type`, shape, and mask state must all match, and elements
   #   are compared bitwise (for numeric types) or via `Object#eql?`
-  #   (for `:object` arrays). Unlike `==`, `NaN.eql?(NaN)` holds, so
-  #   two mask-free arrays with NaN at the same positions are `eql?`.
+  #   (for `:object` arrays), so -0.0 and 0.0 differ and two NaNs are
+  #   `eql?` only with the same bits.
   #   Two Faces are `eql?` only when they are of the same class, share
   #   their state (a time array's unit, a categorical's labels) and hold
   #   the same storage.

metadata

@@ -1,14 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: carray
 version: !ruby/object:Gem::Version
-  version: 3.0.4
+  version: 3.0.6
 platform: ruby
 authors:
 - himotoyoshi
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: |2
       Ruby/CArray adds multi-dimensional numerical arrays to Ruby. Elements are held
       in a single flat memory block, so whole-array work -- element-wise arithmetic,
@@ -318,14 +332,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.17
+rubygems_version: 4.0.8
 specification_version: 4
 summary: Multi-dimensional numerical array class for Ruby
 test_files: []