carray 3.0.1 → 3.0.3

data/yard-stubs/carray_math.rb

@@ -1,8 +1,17 @@
 # DOCUMENTATION ONLY — DO NOT REQUIRE.
 # Stubs for the elementwise arithmetic generated by ext/mkkernel.rb --
-# the division and modulo binops and the rounding monops.  These
-# generated kernels carry no C docstring, so the documentation lives
-# here.  See yard-stubs/README.md and yard-stubs/STYLE.md.
+# the arithmetic, bitwise and logical operators, the comparison and
+# predicate forms, the transcendental and angle functions, and the
+# destructive counterpart of each.  These generated kernels carry no C
+# docstring, and lib/carray/lazy.rb redefines many of them through
+# define_method for lazy dispatch, so neither side is visible to YARD
+# and the documentation lives here.
+#
+# Every method below dispatches lazily: applied to a lazy view it
+# builds a node in the expression tree instead of evaluating, and the
+# eager and lazy paths are required to agree element for element.
+#
+# See yard-stubs/README.md and yard-stubs/STYLE.md.
 
 class CArray
   # @!group Elementwise math
@@ -16,12 +25,15 @@ class CArray
   #   division is true division, as Ruby's `Float#/` is, so that
   #   identity is an integer one. Boolean arrays participate as their
   #   0/1 storage. Masked elements stay masked, and a masked cell is
-  #   never divided.
+  #   never divided. The signed minimum divided by `-1` does not fit and
+  #   is answered as the wrapped negation: `MIN / -1` is `MIN`.
   #   @param other [CArray, Numeric] divisor, broadcast to `self.shape`.
   #   @return [CArray] result of the promoted `data_type` of the two
   #     operands.
   #   @raise [ZeroDivisionError] when an integer divisor is `0`. Float
   #     division returns `Infinity` or `NaN` instead.
+  #   @raise [RangeError] when an Integer `other` does not fit the
+  #     integer `data_type` of `self`.
   #   @example
   #     CA_INT32([-7, -1, 7]) / 3      # => [ -3, -1, 2 ]
   #     CA_DOUBLE([-7.0]) / 3.0        # => [ -2.3333333333333335 ]
@@ -128,5 +140,1488 @@ class CArray
   #   @return [CArray] same `data_type` as `self`.
   def frac; end
 
+  # @overload +(other)
+  #   Returns the element-wise sum of `self` and `other`.
+  #
+  #   Works on every numeric and complex `data_type`, and on `:object`
+  #   (where each element receives Ruby `+`, so `Rational` and
+  #   `BigDecimal` stay exact). Boolean arrays participate as their 0/1
+  #   storage and promote to `:int64`, so a difference can reach `-1`.
+  #   Masked elements stay masked.
+  #   @param other [CArray, Numeric] addend, broadcast to `self.shape`.
+  #   @return [CArray] result of the promoted `data_type` of the two
+  #     operands.
+  #   @example
+  #     CA_INT32([1, 2]) + 10          # => [ 11, 12 ]
+  def +(other); end
+
+  # @overload add(other)
+  #   Alias of {#+}.
+  #   @param other [CArray, Numeric] addend.
+  #   @return [CArray]
+  def add(other); end
+
+  # @overload -(other)
+  #   Returns the element-wise difference of `self` and `other`.
+  #   Follows {#+} in every respect.
+  #   @param other [CArray, Numeric] subtrahend, broadcast to `self.shape`.
+  #   @return [CArray] result of the promoted `data_type` of the two
+  #     operands.
+  def -(other); end
+
+  # @overload sub(other)
+  #   Alias of {#-}.
+  #   @param other [CArray, Numeric] subtrahend.
+  #   @return [CArray]
+  def sub(other); end
+
+  # @overload *(other)
+  #   Returns the element-wise product of `self` and `other`.
+  #
+  #   A `:cmplx64` product is formed in double precision before being
+  #   rounded back, because the two products a complex multiply
+  #   subtracts can cancel; the extra width is spent on accuracy, not
+  #   speed. Otherwise as {#+}.
+  #   @param other [CArray, Numeric] multiplier, broadcast to `self.shape`.
+  #   @return [CArray] result of the promoted `data_type` of the two
+  #     operands.
+  def *(other); end
+
+  # @overload mul(other)
+  #   Alias of {#*}.
+  #   @param other [CArray, Numeric] multiplier.
+  #   @return [CArray]
+  def mul(other); end
+
+  # @overload **(other)
+  #   Returns `self` raised element-wise to the power `other`.
+  #
+  #   The result keeps the promoted `data_type` of the operands, so an
+  #   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.
+  #   Masked elements stay masked.
+  #   @param other [CArray, Numeric] exponent, broadcast to `self.shape`.
+  #   @return [CArray] result of the promoted `data_type` of the two
+  #     operands.
+  #   @example
+  #     CA_INT32([2, 3]) ** 3          # => [ 8, 27 ]
+  #     CA_INT32([2]) ** -1            # => [ 0 ]
+  def **(other); end
+
+  # @overload power(other)
+  #   Alias of {#**}.
+  #   @param other [CArray, Numeric] exponent.
+  #   @return [CArray]
+  def power(other); end
+
+  # @overload rcp_mul(other)
+  #   Returns `other` divided element-wise by `self` -- the reciprocal
+  #   of {#/} in operand order, so that scaling a constant by an array
+  #   needs no temporary. Integer division floors, as {#/} does.
+  #   @param other [CArray, Numeric] dividend, broadcast to `self.shape`.
+  #   @return [CArray] result of the promoted `data_type` of the two
+  #     operands.
+  #   @raise [ZeroDivisionError] when an integer element of `self` is `0`.
+  #   @example
+  #     CA_DOUBLE([1.0, 2.0, 4.0]).rcp_mul(2.0)   # => [ 2.0, 1.0, 0.5 ]
+  def rcp_mul(other); end
+
+  # @overload -@
+  #   Returns the element-wise negation of `self`, keeping `self`'s
+  #   `data_type`. A boolean array promotes to `:int64`. An `:object`
+  #   array delegates to each element's `#-@`.
+  #   @return [CArray]
+  def -@; end
+
+  # @overload neg
+  #   Alias of {#-@}.
+  #   @return [CArray]
+  def neg; end
+
+  # @overload abs
+  #   Returns the element-wise magnitude of `self`.
+  #
+  #   A numeric array keeps its `data_type`; a complex array returns the
+  #   real magnitude at that complex type's own width, so a `:cmplx64`
+  #   yields `:float32` just as {#real} and {#imag} do. An `:object`
+  #   array calls each cell's `abs`. For the form that keeps a complex
+  #   array complex (magnitude with a zero imaginary part) use {#abs_i}.
+  #   @return [CArray] `self`'s `data_type` for numeric and `:object`
+  #     input; the real component type for complex input.
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  #   @example
+  #     CA_CMPLX64([Complex(3, 4)]).abs      # => [ 5.0 ]  (:float32)
+  def abs; end
+
+  # @overload abs_i
+  #   Returns the element-wise magnitude of `self`, keeping `self`'s
+  #   `data_type` -- a complex array stays complex (imaginary part
+  #   zero), a boolean promotes to `:int64`, and an `:object` array
+  #   delegates to each element's `#abs`. See {#abs} for the form that
+  #   returns a real magnitude from a complex array.
+  #   @return [CArray] same `data_type` as `self` (`:int64` for boolean).
+  def abs_i; end
+
+  # @overload square
+  #   Returns `self * self` element-wise, keeping `self`'s `data_type`
+  #   (a boolean promotes to `:int64`).
+  #   @return [CArray]
+  def square; end
+
+  # @overload rcp
+  #   Returns the element-wise reciprocal `1 / self`, keeping `self`'s
+  #   `data_type`. On an integer array the quotient is an integer, so
+  #   every element but `±1` becomes `0`; cast first when that is not
+  #   wanted.
+  #   @return [CArray] same `data_type` as `self`.
+  #   @raise [ZeroDivisionError] when an integer element is `0`.
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def rcp; end
+
+  # @overload rsqrt
+  #   Returns the element-wise reciprocal square root `1 / sqrt(self)`.
+  #   A float array keeps its width and a complex array stays complex;
+  #   an integer array promotes to `:float64`.
+  #   @return [CArray] `:float64`, or `self`'s own float/complex type.
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  #   @example
+  #     CA_DOUBLE([4.0, 16.0]).rsqrt   # => [ 0.5, 0.25 ]
+  def rsqrt; end
+
+  # @overload sign
+  #   Returns `-1`, `0`, or `1` element-wise according to the sign of
+  #   each element, keeping `self`'s `data_type` (so a float array
+  #   yields `-1.0` / `0.0` / `1.0`).
+  #   @return [CArray] same `data_type` as `self`.
+  #   @raise [CArray::DataTypeError] for an `:object` array.
+  #   @example
+  #     CA_DOUBLE([-3.0, 0.0, 2.0]).sign   # => [ -1.0, 0.0, 1.0 ]
+  def sign; end
+
+  # @overload zero
+  #   Returns an array of the same shape and `data_type` as `self` with
+  #   every element set to zero. The mask is carried over.
+  #   @return [CArray]
+  def zero; end
+
+  # @overload one
+  #   Returns an array of the same shape and `data_type` as `self` with
+  #   every element set to one. The mask is carried over.
+  #   @return [CArray]
+  def one; end
+
+  # @overload conj
+  #   Returns the element-wise complex conjugate. A real array is
+  #   returned with its values unchanged (a boolean promotes to
+  #   `:int64`), so the operation is safe to apply without testing for
+  #   a complex `data_type`.
+  #   @return [CArray] same `data_type` as `self`.
+  def conj; end
+
+  # @overload arg
+  #   Returns the element-wise argument (phase angle, in radians) of
+  #   `self`, in `(-pi, pi]`.
+  #
+  #   A complex array yields its real component type (`:cmplx64` ->
+  #   `:float32`); a float array keeps its width; an integer array
+  #   promotes to `:float64`, because a negative element has argument
+  #   `pi` and would otherwise be truncated.
+  #   @return [CArray] `:float64` for integer input, otherwise the real
+  #     component type of `self`.
+  #   @raise [CArray::DataTypeError] for a boolean or `:object` array.
+  #   @example
+  #     CA_DOUBLE([-1.0, 1.0]).arg     # => [ 3.141592653589793, 0.0 ]
+  def arg; end
+
+  # @overload imag_i
+  #   Returns the element-wise imaginary part, keeping `self`'s
+  #   `data_type` -- a complex array stays complex (real part zero) and
+  #   a real array yields zeros. See {#imag} for the real-valued form.
+  #   @return [CArray] same `data_type` as `self` (`:int64` for boolean).
+  def imag_i; end
+
+  # @overload floor
+  #   Returns the element-wise largest integral value not greater than
+  #   each element, keeping `self`'s `data_type` (a `:float64` stays
+  #   `:float64`). Integer arrays are returned unchanged; an `:object`
+  #   array delegates to each element's `#floor`.
+  #   @return [CArray] same `data_type` as `self`.
+  #   @raise [CArray::DataTypeError] for a complex array.
+  def floor; end
+
+  # @overload ceil
+  #   Returns the element-wise smallest integral value not less than
+  #   each element, keeping `self`'s `data_type`. Otherwise as {#floor}.
+  #   @return [CArray] same `data_type` as `self`.
+  #   @raise [CArray::DataTypeError] for a complex array.
+  def ceil; end
+
+  # @overload trunc
+  #   Returns each element with its fractional part removed (rounded
+  #   toward zero), keeping `self`'s `data_type`. This is the companion
+  #   of {#frac}: `self.trunc + self.frac == self`.
+  #   @return [CArray] same `data_type` as `self`.
+  #   @raise [CArray::DataTypeError] for a complex array.
+  def trunc; end
+
+  # @overload sqrt
+  #   Returns the element-wise square root.
+  #
+  #   A float array keeps its width (a `:float32` is computed and
+  #   returned in single precision), a complex array stays complex, and
+  #   an integer array promotes to `:float64`. A negative element of a
+  #   real array yields `NaN`; take `.to_type(:cmplx128)` first to get
+  #   the complex root instead.
+  #   @return [CArray] `:float64` for integer input, otherwise `self`'s
+  #     own float or complex type.
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def sqrt; end
+
+  # @overload exp
+  #   Returns `e` raised element-wise to each element of `self`.
+  #   Type behaviour as {#sqrt}.
+  #   @return [CArray]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def exp; end
+
+  # @overload exp2
+  #   Returns `2` raised element-wise to each element of `self`.
+  #   Type behaviour as {#sqrt}.
+  #   @return [CArray]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def exp2; end
+
+  # @overload exp10
+  #   Returns `10` raised element-wise to each element of `self`.
+  #   Type behaviour as {#sqrt}.
+  #   @return [CArray]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def exp10; end
+
+  # @overload expm1
+  #   Returns `exp(self) - 1` element-wise, accurate for elements near
+  #   zero where computing the subtraction directly would cancel.
+  #   Real `data_type`s only.
+  #   @return [CArray] `:float64` for integer input, otherwise `self`'s
+  #     own float type.
+  #   @raise [CArray::DataTypeError] for a boolean or complex array.
+  def expm1; end
+
+  # @overload log
+  #   Returns the element-wise natural logarithm. Type behaviour as
+  #   {#sqrt}. A negative element of a real array yields `NaN` and a
+  #   zero element yields `-Infinity`.
+  #
+  #   The complex branch is computed in double precision even for
+  #   `:cmplx64`: the real part of `log(z)` is `log|z|`, which vanishes
+  #   on the unit circle, so measuring `|z|` at the narrower width
+  #   would round away what the logarithm then needs.
+  #   @return [CArray]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def log; end
+
+  # @overload log2
+  #   Returns the element-wise base-2 logarithm. Real `data_type`s only.
+  #   @return [CArray] `:float64` for integer input, otherwise `self`'s
+  #     own float type.
+  #   @raise [CArray::DataTypeError] for a boolean or complex array.
+  def log2; end
+
+  # @overload log10
+  #   Returns the element-wise base-10 logarithm. Real `data_type`s only.
+  #   @return [CArray] `:float64` for integer input, otherwise `self`'s
+  #     own float type.
+  #   @raise [CArray::DataTypeError] for a boolean or complex array.
+  def log10; end
+
+  # @overload log1p
+  #   Returns `log(1 + self)` element-wise, accurate for elements near
+  #   zero. Real `data_type`s only.
+  #   @return [CArray] `:float64` for integer input, otherwise `self`'s
+  #     own float type.
+  #   @raise [CArray::DataTypeError] for a boolean or complex array.
+  def log1p; end
+
+  # @overload logb
+  #   Returns the exponent of each element in the floating-point radix,
+  #   as a floating-point value: `8.0` yields `3.0` and `0.5` yields
+  #   `-1.0`. Real `data_type`s only.
+  #   @return [CArray] `:float64` for integer input, otherwise `self`'s
+  #     own float type.
+  #   @raise [CArray::DataTypeError] for a boolean or complex array.
+  #   @example
+  #     CA_DOUBLE([8.0, 1.0, 0.5]).logb    # => [ 3.0, 0.0, -1.0 ]
+  def logb; end
+
+  # @overload sin
+  #   Returns the element-wise sine, the argument taken in radians.
+  #   Type behaviour as {#sqrt}.
+  #   @return [CArray]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def sin; end
+
+  # @overload cos
+  #   Returns the element-wise cosine, the argument taken in radians.
+  #   Type behaviour as {#sqrt}.
+  #   @return [CArray]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def cos; end
+
+  # @overload tan
+  #   Returns the element-wise tangent, the argument taken in radians.
+  #   Type behaviour as {#sqrt}.
+  #   @return [CArray]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def tan; end
+
+  # @overload asin
+  #   Returns the element-wise arc sine, in radians. Type behaviour as
+  #   {#sqrt}. An element of a real array outside `[-1, 1]` yields
+  #   `NaN`; a complex array has no such restriction.
+  #   @return [CArray]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def asin; end
+
+  # @overload acos
+  #   Returns the element-wise arc cosine, in radians. Otherwise as
+  #   {#asin}.
+  #   @return [CArray]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def acos; end
+
+  # @overload atan
+  #   Returns the element-wise arc tangent, in radians, in
+  #   `(-pi/2, pi/2)`. For the two-argument form that resolves the
+  #   quadrant see {#atan2}.
+  #   @return [CArray]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def atan; end
+
+  # @overload sinh
+  #   Returns the element-wise hyperbolic sine. Type behaviour as
+  #   {#sqrt}.
+  #   @return [CArray]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def sinh; end
+
+  # @overload cosh
+  #   Returns the element-wise hyperbolic cosine. Type behaviour as
+  #   {#sqrt}.
+  #   @return [CArray]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def cosh; end
+
+  # @overload tanh
+  #   Returns the element-wise hyperbolic tangent. Type behaviour as
+  #   {#sqrt}.
+  #   @return [CArray]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def tanh; end
+
+  # @overload asinh
+  #   Returns the element-wise inverse hyperbolic sine. Type behaviour
+  #   as {#sqrt}.
+  #   @return [CArray]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def asinh; end
+
+  # @overload acosh
+  #   Returns the element-wise inverse hyperbolic cosine. Type
+  #   behaviour as {#sqrt}. An element of a real array below `1` yields
+  #   `NaN`.
+  #   @return [CArray]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def acosh; end
+
+  # @overload atanh
+  #   Returns the element-wise inverse hyperbolic tangent. Type
+  #   behaviour as {#sqrt}. An element of a real array outside
+  #   `(-1, 1)` yields `NaN` or `±Infinity`.
+  #   @return [CArray]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def atanh; end
+
+  # @overload atan2(other)
+  #   Returns the element-wise arc tangent of `self / other` in
+  #   radians, using the signs of both to place the result in the
+  #   correct quadrant, in `(-pi, pi]`. `self` is the ordinate.
+  #
+  #   Unlike the one-argument transcendentals, the two-argument float
+  #   functions do not promote integers: they accept float and
+  #   `:object` arrays only.
+  #   @param other [CArray, Numeric] the abscissa, broadcast to
+  #     `self.shape`.
+  #   @return [CArray] `self`'s own float type.
+  #   @raise [CArray::DataTypeError] for an integer, boolean, or
+  #     complex array.
+  def atan2(other); end
+
+  # @overload hypot(other)
+  #   Returns `sqrt(self ** 2 + other ** 2)` element-wise, computed
+  #   without the overflow that squaring the operands directly would
+  #   cause. Accepts float and `:object` arrays only, as {#atan2}.
+  #   @param other [CArray, Numeric] the other leg, broadcast to
+  #     `self.shape`.
+  #   @return [CArray] `self`'s own float type.
+  #   @raise [CArray::DataTypeError] for an integer, boolean, or
+  #     complex array.
+  def hypot(other); end
+
+  # @overload copysign(other)
+  #   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`.
+  #   Accepts float and `:object` arrays only, as {#atan2}.
+  #   @param other [CArray, Numeric] sign source, broadcast to
+  #     `self.shape`.
+  #   @return [CArray] `self`'s own float type.
+  #   @raise [CArray::DataTypeError] for an integer, boolean, or
+  #     complex array.
+  def copysign(other); end
+
+  # @overload nextafter(other)
+  #   Returns the next representable value after each element of `self`
+  #   in the direction of `other`, stepping by one unit in the last
+  #   place of `self`'s own float type. Accepts float and `:object`
+  #   arrays only, as {#atan2}.
+  #   @param other [CArray, Numeric] direction, broadcast to
+  #     `self.shape`.
+  #   @return [CArray] `self`'s own float type.
+  #   @raise [CArray::DataTypeError] for an integer, boolean, or
+  #     complex array.
+  def nextafter(other); end
+
+  # @overload logaddexp(other)
+  #   Returns `log(exp(self) + exp(other))` element-wise, computed
+  #   without the overflow that exponentiating large elements directly
+  #   would cause -- the usual way to add probabilities held as
+  #   logarithms. Accepts float and `:object` arrays only, as {#atan2}.
+  #   @param other [CArray, Numeric] the other log-value, broadcast to
+  #     `self.shape`.
+  #   @return [CArray] `self`'s own float type.
+  #   @raise [CArray::DataTypeError] for an integer, boolean, or
+  #     complex array.
+  def logaddexp(other); end
+
+  # @overload deg
+  #   Returns each element converted from radians to degrees.
+  #   @return [CArray] `:float64` for integer input, otherwise `self`'s
+  #     own float type.
+  #   @raise [CArray::DataTypeError] for a boolean or complex array.
+  def deg; end
+
+  # @overload rad
+  #   Returns each element converted from degrees to radians.
+  #   @return [CArray] `:float64` for integer input, otherwise `self`'s
+  #     own float type.
+  #   @raise [CArray::DataTypeError] for a boolean or complex array.
+  def rad; end
+
+  # @overload deg_180
+  #   Returns each element, taken in degrees, wrapped into the interval
+  #   `(-180, 180]`.
+  #   @return [CArray] `:float64` for integer input, otherwise `self`'s
+  #     own float type.
+  #   @raise [CArray::DataTypeError] for a boolean or complex array.
+  #   @example
+  #     CA_DOUBLE([270.0]).deg_180     # => [ -90.0 ]
+  def deg_180; end
+
+  # @overload deg_360
+  #   Returns each element, taken in degrees, wrapped into the interval
+  #   `[0, 360)`.
+  #   @return [CArray] `:float64` for integer input, otherwise `self`'s
+  #     own float type.
+  #   @raise [CArray::DataTypeError] for a boolean or complex array.
+  #   @example
+  #     CA_DOUBLE([-10.0]).deg_360     # => [ 350.0 ]
+  def deg_360; end
+
+  # @overload rad_pi
+  #   Returns each element, taken in radians, wrapped into the interval
+  #   `(-pi, pi]` -- the radian counterpart of {#deg_180}.
+  #   @return [CArray] `:float64` for integer input, otherwise `self`'s
+  #     own float type.
+  #   @raise [CArray::DataTypeError] for a boolean or complex array.
+  def rad_pi; end
+
+  # @overload rad_2pi
+  #   Returns each element, taken in radians, wrapped into the interval
+  #   `[0, 2*pi)` -- the radian counterpart of {#deg_360}.
+  #   @return [CArray] `:float64` for integer input, otherwise `self`'s
+  #     own float type.
+  #   @raise [CArray::DataTypeError] for a boolean or complex array.
+  def rad_2pi; end
+
+  # @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}.
+  #   @param other [CArray, Numeric] the other operand, broadcast to
+  #     `self.shape`.
+  #   @return [CArray] result of the promoted `data_type` of the two
+  #     operands (`:int64` for boolean).
+  #   @raise [CArray::DataTypeError] for a complex array, which has no
+  #     ordering.
+  #   @example
+  #     CA_DOUBLE([Float::NAN]).pmax(1.0)      # => [ 1.0 ]
+  def pmax(other); end
+
+  # @overload pmin(other)
+  #   Returns the element-wise smaller of `self` and `other`, ignoring
+  #   `NaN`. The counterpart of {#pmax}.
+  #   @param other [CArray, Numeric] the other operand.
+  #   @return [CArray]
+  #   @raise [CArray::DataTypeError] for a complex array.
+  def pmin(other); end
+
+  # @overload fmax(other)
+  #   Alias of {#pmax}, under the name C gives it.
+  #   @param other [CArray, Numeric] the other operand.
+  #   @return [CArray]
+  def fmax(other); end
+
+  # @overload fmin(other)
+  #   Alias of {#pmin}, under the name C gives it.
+  #   @param other [CArray, Numeric] the other operand.
+  #   @return [CArray]
+  def fmin(other); end
+
+  # @overload maximum(other)
+  #   Returns the element-wise larger of `self` and `other`,
+  #   propagating `NaN`: where either element is `NaN` the result is
+  #   `NaN`. Use this when a `NaN` must not be silently dropped, and
+  #   {#pmax} when it should be skipped.
+  #   @param other [CArray, Numeric] the other operand, broadcast to
+  #     `self.shape`.
+  #   @return [CArray] result of the promoted `data_type` of the two
+  #     operands (`:int64` for boolean).
+  #   @raise [CArray::DataTypeError] for a complex array.
+  #   @example
+  #     CA_DOUBLE([Float::NAN]).maximum(1.0)   # => [ NaN ]
+  def maximum(other); end
+
+  # @overload minimum(other)
+  #   Returns the element-wise smaller of `self` and `other`,
+  #   propagating `NaN`. The counterpart of {#maximum}.
+  #   @param other [CArray, Numeric] the other operand.
+  #   @return [CArray]
+  #   @raise [CArray::DataTypeError] for a complex array.
+  def minimum(other); end
+
+  # @overload fma(a, b)
+  #   Returns `self * a + b` element-wise, evaluated as one fused
+  #   operation so no temporary array is built for the product.
+  #   @param a [CArray, Numeric] multiplier, broadcast to `self.shape`.
+  #   @param b [CArray, Numeric] addend, broadcast to `self.shape`.
+  #   @return [CArray] result of the promoted `data_type` of the three
+  #     operands.
+  #   @example
+  #     CA_DOUBLE([2.0]).fma(3.0, 4.0)   # => [ 10.0 ]
+  def fma(a, b); end
+
+  # @overload fms(a, b)
+  #   Returns `self * a - b` element-wise, the subtracting counterpart
+  #   of {#fma}.
+  #   @param a [CArray, Numeric] multiplier.
+  #   @param b [CArray, Numeric] subtrahend.
+  #   @return [CArray]
+  #   @example
+  #     CA_DOUBLE([2.0]).fms(3.0, 4.0)   # => [ 2.0 ]
+  def fms(a, b); end
+
+  # @overload eq(other)
+  #   Returns a boolean array that is true where `self` and `other` are
+  #   equal element-wise. Distinct from {#==}, which compares two
+  #   arrays as wholes and returns a single `true` or `false`.
+  #
+  #   Accepts every numeric, complex, boolean, `:fixlen` (byte
+  #   comparison) and `:object` (Ruby `==`) `data_type`. A masked
+  #   element yields a masked result rather than `false`. Floating
+  #   point equality is exact here; for a tolerant comparison see
+  #   {#is_close} (absolute) or {#is_equiv} (relative). Integers compare
+  #   by value, as for {#<}.
+  #   @param other [CArray, Numeric, Object] comparand, broadcast to
+  #     `self.shape`.
+  #   @return [CArray] `:boolean`, same shape as `self`.
+  #   @example
+  #     CA_DOUBLE([1.0, 2.0]).eq(2.0)    # => [ false, true ]
+  def eq(other); end
+
+  # @overload ne(other)
+  #   Returns a boolean array that is true where `self` and `other`
+  #   differ element-wise. The negation of {#eq}.
+  #   @param other [CArray, Numeric, Object] comparand.
+  #   @return [CArray] `:boolean`.
+  def ne(other); end
+
+  # @overload <(other)
+  #   Returns a boolean array that is true where each element of `self`
+  #   is less than the matching element of `other`.
+  #
+  #   Accepts numeric, boolean, `:fixlen` (byte order, shorter first on
+  #   a common prefix) and `:object` (Ruby `<`) `data_type`s. Complex
+  #   arrays have no ordering and raise.
+  #
+  #   Integers compare by value: an unsigned array against a signed one
+  #   answers as the Integers would (`CA_UINT64([7]) < CA_INT64([-7])`
+  #   is false), and so does an Integer the array's type cannot hold
+  #   (`CA_UINT8([0]) > -1` is true).
+  #   @param other [CArray, Numeric, Object] comparand, broadcast to
+  #     `self.shape`.
+  #   @return [CArray] `:boolean`, same shape as `self`.
+  #   @raise [TypeError] for a complex array.
+  def <(other); end
+
+  # @overload lt(other)
+  #   Alias of {#<}.
+  #   @param other [CArray, Numeric, Object] comparand.
+  #   @return [CArray] `:boolean`.
+  def lt(other); end
+
+  # @overload <=(other)
+  #   Returns a boolean array that is true where each element of `self`
+  #   is less than or equal to the matching element of `other`.
+  #   Otherwise as {#<}.
+  #   @param other [CArray, Numeric, Object] comparand.
+  #   @return [CArray] `:boolean`.
+  #   @raise [TypeError] for a complex array.
+  def <=(other); end
+
+  # @overload le(other)
+  #   Alias of {#<=}.
+  #   @param other [CArray, Numeric, Object] comparand.
+  #   @return [CArray] `:boolean`.
+  def le(other); end
+
+  # @overload >(other)
+  #   Returns a boolean array that is true where each element of `self`
+  #   is greater than the matching element of `other`. Otherwise as
+  #   {#<}.
+  #   @param other [CArray, Numeric, Object] comparand.
+  #   @return [CArray] `:boolean`.
+  #   @raise [TypeError] for a complex array.
+  def >(other); end
+
+  # @overload gt(other)
+  #   Alias of {#>}.
+  #   @param other [CArray, Numeric, Object] comparand.
+  #   @return [CArray] `:boolean`.
+  def gt(other); end
+
+  # @overload >=(other)
+  #   Returns a boolean array that is true where each element of `self`
+  #   is greater than or equal to the matching element of `other`.
+  #   Otherwise as {#<}.
+  #   @param other [CArray, Numeric, Object] comparand.
+  #   @return [CArray] `:boolean`.
+  #   @raise [TypeError] for a complex array.
+  def >=(other); end
+
+  # @overload ge(other)
+  #   Alias of {#>=}.
+  #   @param other [CArray, Numeric, Object] comparand.
+  #   @return [CArray] `:boolean`.
+  def ge(other); end
+
+  # @overload feq(other)
+  #   Returns a boolean array that is true where `self` and `other`
+  #   agree element-wise to within the machine epsilon of `self`'s
+  #   float type, scaled by the larger of the two magnitudes. Use it
+  #   instead of {#eq} when comparing computed floating-point values.
+  #   For an explicit tolerance see {#is_close} and {#is_equiv}.
+  #   @param other [CArray, Numeric] comparand, broadcast to
+  #     `self.shape`.
+  #   @return [CArray] `:boolean`.
+  #   @raise [TypeError] for any non-float `data_type`.
+  def feq(other); end
+
+  # @overload is_close(other, tolerance)
+  #   Returns a boolean array that is true where `self` and `other`
+  #   agree element-wise within an **absolute** tolerance:
+  #   `|self - other| <= tolerance`. Complex arrays compare by the
+  #   magnitude of the difference.
+  #   @param other [CArray, Numeric] comparand, broadcast to
+  #     `self.shape`.
+  #   @param tolerance [Numeric] largest accepted absolute difference.
+  #   @return [CArray] `:boolean`.
+  #   @example
+  #     CA_DOUBLE([1000.0]).is_close(1001.0, 1.0)    # => [ true ]
+  def is_close(other, tolerance); end
+
+  # @overload is_equiv(other, tolerance)
+  #   Returns a boolean array that is true where `self` and `other`
+  #   agree element-wise within a **relative** tolerance:
+  #   `|self - other| / max(|self|, |other|) <= tolerance`, with
+  #   exactly equal elements always true. Prefer this to {#is_close}
+  #   when the elements span several orders of magnitude.
+  #   @param other [CArray, Numeric] comparand, broadcast to
+  #     `self.shape`.
+  #   @param tolerance [Numeric] largest accepted relative difference.
+  #   @return [CArray] `:boolean`.
+  #   @example
+  #     CA_DOUBLE([1000.0]).is_equiv(1001.0, 0.01)   # => [ true ]
+  #     CA_DOUBLE([0.001]).is_equiv(0.002, 0.01)     # => [ false ]
+  def is_equiv(other, tolerance); end
+
+  # @overload is_nan
+  #   Returns a boolean array that is true where an element is `NaN`.
+  #   @return [CArray] `:boolean`, same shape as `self`.
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  #   On an `:object` array an Integer or a Rational element is never
+  #   `NaN`; other elements answer through `#nan?`.
+  #   @raise [NoMethodError] for an `:object` array with an element that
+  #     is not an Integer, a Rational or a Float and does not respond to
+  #     `#nan?`.
+  def is_nan; end
+
+  # @overload is_inf
+  #   Returns a boolean array that is true where an element is
+  #   positive or negative infinity.
+  #   @return [CArray] `:boolean`.
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def is_inf; end
+
+  # @overload is_finite
+  #   Returns a boolean array that is true where an element is neither
+  #   `NaN` nor infinite.
+  #   @return [CArray] `:boolean`.
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def is_finite; end
+
+  # @overload is_invalid
+  #   Returns a boolean array that is true where an element is `NaN` or
+  #   infinite -- the negation of {#is_finite}, in one pass. Pair it
+  #   with {#mask_where} to mask the elements a computation cannot use.
+  #   @return [CArray] `:boolean`.
+  #   @example
+  #     CA_DOUBLE([Float::NAN, 1.0/0, 1.0]).is_invalid  # => [ true, true, false ]
+  def is_invalid; end
+
+  # @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.
+  #   @return [CArray] `:boolean`.
+  #   @raise [CArray::DataTypeError] for a complex array.
+  #   @example
+  #     CA_DOUBLE([-1.0, 0.0, -0.0]).signbit   # => [ true, false, true ]
+  def signbit; end
+
+  # @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 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.
+  #   @param other [CArray, Integer, true, false] the other operand,
+  #     broadcast to `self.shape`.
+  #   @return [CArray] `:boolean` for boolean operands, otherwise the
+  #     promoted integer `data_type`.
+  #   @raise [CArray::DataTypeError] for a float or complex array.
+  def &(other); end
+
+  # @overload bit_and(other)
+  #   Alias of {#&}.
+  #   @param other [CArray, Integer, true, false] the other operand.
+  #   @return [CArray]
+  def bit_and(other); end
+
+  # @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`.
+  #   @param other [CArray, Integer, true, false] the other operand,
+  #     broadcast to `self.shape`.
+  #   @return [CArray] `:boolean` for boolean operands, otherwise the
+  #     promoted integer `data_type`.
+  #   @raise [CArray::DataTypeError] for a float or complex array.
+  def |(other); end
+
+  # @overload bit_or(other)
+  #   Alias of {#|}.
+  #   @param other [CArray, Integer, true, false] the other operand.
+  #   @return [CArray]
+  def bit_or(other); end
+
+  # @overload ^(other)
+  #   Returns the element-wise exclusive disjunction of `self` and
+  #   `other`: a bitwise `XOR` on integer arrays, a logical `XOR` on
+  #   boolean ones.
+  #
+  #   Unlike {#&} and {#|} this has no Kleene shortcut -- an exclusive
+  #   or always depends on both operands -- so a masked element always
+  #   gives a masked result.
+  #   @param other [CArray, Integer, true, false] the other operand,
+  #     broadcast to `self.shape`.
+  #   @return [CArray] `:boolean` for boolean operands, otherwise the
+  #     promoted integer `data_type`.
+  #   @raise [CArray::DataTypeError] for a float or complex array.
+  def ^(other); end
+
+  # @overload bit_xor(other)
+  #   Alias of {#^}.
+  #   @param other [CArray, Integer, true, false] the other operand.
+  #   @return [CArray]
+  def bit_xor(other); end
+
+  # @overload <<(other)
+  #   Returns each element of `self` shifted left by the matching
+  #   number of bits in `other`. Integer `data_type`s only (a boolean
+  #   promotes to `:int64`).
+  #   @param other [CArray, Integer] shift counts, broadcast to
+  #     `self.shape`.
+  #   @return [CArray] the promoted integer `data_type`.
+  #   @raise [CArray::DataTypeError] for a float or complex array.
+  def <<(other); end
+
+  # @overload bit_lshift(other)
+  #   Alias of {#<<}.
+  #   @param other [CArray, Integer] shift counts.
+  #   @return [CArray]
+  def bit_lshift(other); end
+
+  # @overload >>(other)
+  #   Returns each element of `self` shifted right by the matching
+  #   number of bits in `other`. Otherwise as {#<<}.
+  #   @param other [CArray, Integer] shift counts.
+  #   @return [CArray] the promoted integer `data_type`.
+  #   @raise [CArray::DataTypeError] for a float or complex array.
+  def >>(other); end
+
+  # @overload bit_rshift(other)
+  #   Alias of {#>>}.
+  #   @param other [CArray, Integer] shift counts.
+  #   @return [CArray]
+  def bit_rshift(other); end
+
+  # @overload bit_neg
+  #   Returns the element-wise complement: a bitwise `NOT` on integer
+  #   arrays, a logical negation on boolean ones. Aliased as `~`.
+  #   @return [CArray] same `data_type` as `self`.
+  #   @raise [CArray::DataTypeError] for a float or complex array.
+  def bit_neg; end
+
+  # @overload not
+  #   Returns the element-wise logical negation of a boolean array.
+  #   Masked elements stay masked -- the negation of an unknown is
+  #   still unknown.
+  #   @return [CArray] `:boolean`.
+  #   @raise [CArray::DataTypeError] for any `data_type` other than
+  #     `:boolean` or `:object`.
+  def not; end
+
+  # @overload and(other)
+  #   Returns the two-valued logical `AND` of two boolean arrays.
+  #
+  #   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.
+  #   @param other [CArray, true, false] the other operand, broadcast
+  #     to `self.shape`.
+  #   @return [CArray] `:boolean`.
+  #   @raise [CArray::DataTypeError] for any `data_type` other than
+  #     `:boolean` or `:object`.
+  def and(other); end
+
+  # @overload or(other)
+  #   Returns the two-valued logical `OR` of two boolean arrays,
+  #   propagating the mask unconditionally as {#and} does.
+  #   @param other [CArray, true, false] the other operand.
+  #   @return [CArray] `:boolean`.
+  #   @raise [CArray::DataTypeError] for any `data_type` other than
+  #     `:boolean` or `:object`.
+  def or(other); end
+
+  # @overload xor(other)
+  #   Returns the logical exclusive `OR` of two boolean arrays,
+  #   propagating the mask as {#and} does.
+  #   @param other [CArray, true, false] the other operand.
+  #   @return [CArray] `:boolean`.
+  #   @raise [CArray::DataTypeError] for any `data_type` other than
+  #     `:boolean` or `:object`.
+  def xor(other); end
+
+  # @overload abs!
+  #   Applies {#abs} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def abs!; end
+
+  # @overload abs_i!
+  #   Applies {#abs_i} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def abs_i!; end
+
+  # @overload acos!
+  #   Applies {#acos} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#acos} promotes
+  #     it instead of raising.
+  def acos!; end
+
+  # @overload acosh!
+  #   Applies {#acosh} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#acosh}
+  #     promotes it instead of raising.
+  def acosh!; end
+
+  # @overload add!(other)
+  #   Applies {#add} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @param other [CArray, Numeric] the other operand, broadcast to
+  #     `self.shape`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def add!(other); end
+
+  # @overload and!(other)
+  #   Applies {#and} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @param other [CArray, true, false] the other operand, broadcast
+  #     to `self.shape`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or float array.
+  def and!(other); end
+
+  # @overload arg!
+  #   Applies {#arg} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array, whose
+  #     `data_type` cannot hold the widened result -- {#arg} promotes it
+  #     instead of raising.
+  def arg!; end
+
+  # @overload asin!
+  #   Applies {#asin} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#asin} promotes
+  #     it instead of raising.
+  def asin!; end
+
+  # @overload asinh!
+  #   Applies {#asinh} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#asinh}
+  #     promotes it instead of raising.
+  def asinh!; end
+
+  # @overload atan!
+  #   Applies {#atan} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#atan} promotes
+  #     it instead of raising.
+  def atan!; end
+
+  # @overload atan2!(other)
+  #   Applies {#atan2} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @param other [CArray, Numeric] the other operand, broadcast to
+  #     `self.shape`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#atan2}
+  #     promotes it instead of raising.
+  def atan2!(other); end
+
+  # @overload atanh!
+  #   Applies {#atanh} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#atanh}
+  #     promotes it instead of raising.
+  def atanh!; end
+
+  # @overload bit_lshift!(other)
+  #   Applies {#bit_lshift} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @param other [CArray, Numeric] the other operand, broadcast to
+  #     `self.shape`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for a float or boolean array.
+  def bit_lshift!(other); end
+
+  # @overload bit_neg!
+  #   Applies {#bit_neg} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for a float array.
+  def bit_neg!; end
+
+  # @overload bit_rshift!(other)
+  #   Applies {#bit_rshift} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @param other [CArray, Numeric] the other operand, broadcast to
+  #     `self.shape`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for a float or boolean array.
+  def bit_rshift!(other); end
+
+  # @overload ceil!
+  #   Applies {#ceil} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def ceil!; end
+
+  # @overload conj!
+  #   Applies {#conj} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def conj!; end
+
+  # @overload copysign!(other)
+  #   Applies {#copysign} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @param other [CArray, Numeric] the other operand, broadcast to
+  #     `self.shape`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#copysign}
+  #     promotes it instead of raising.
+  def copysign!(other); end
+
+  # @overload cos!
+  #   Applies {#cos} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#cos} promotes
+  #     it instead of raising.
+  def cos!; end
+
+  # @overload cosh!
+  #   Applies {#cosh} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#cosh} promotes
+  #     it instead of raising.
+  def cosh!; end
+
+  # @overload deg!
+  #   Applies {#deg} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#deg} promotes
+  #     it instead of raising.
+  def deg!; end
+
+  # @overload deg_180!
+  #   Applies {#deg_180} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#deg_180}
+  #     promotes it instead of raising.
+  def deg_180!; end
+
+  # @overload deg_360!
+  #   Applies {#deg_360} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#deg_360}
+  #     promotes it instead of raising.
+  def deg_360!; end
+
+  # @overload exp!
+  #   Applies {#exp} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#exp} promotes
+  #     it instead of raising.
+  def exp!; end
+
+  # @overload exp10!
+  #   Applies {#exp10} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#exp10}
+  #     promotes it instead of raising.
+  def exp10!; end
+
+  # @overload exp2!
+  #   Applies {#exp2} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#exp2} promotes
+  #     it instead of raising.
+  def exp2!; end
+
+  # @overload expm1!
+  #   Applies {#expm1} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#expm1}
+  #     promotes it instead of raising.
+  def expm1!; end
+
+  # @overload floor!
+  #   Applies {#floor} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def floor!; end
+
+  # @overload fma!(a, b)
+  #   Applies {#fma} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @param a [CArray, Numeric] first operand, broadcast to `self.shape`.
+  #   @param b [CArray, Numeric] second operand, broadcast to `self.shape`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def fma!(a, b); end
+
+  # @overload fms!(a, b)
+  #   Applies {#fms} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @param a [CArray, Numeric] first operand, broadcast to `self.shape`.
+  #   @param b [CArray, Numeric] second operand, broadcast to `self.shape`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def fms!(a, b); end
+
+  # @overload hypot!(other)
+  #   Applies {#hypot} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @param other [CArray, Numeric] the other operand, broadcast to
+  #     `self.shape`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#hypot}
+  #     promotes it instead of raising.
+  def hypot!(other); end
+
+  # @overload imag_i!
+  #   Applies {#imag_i} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def imag_i!; end
+
+  # @overload log!
+  #   Applies {#log} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#log} promotes
+  #     it instead of raising.
+  def log!; end
+
+  # @overload log10!
+  #   Applies {#log10} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#log10}
+  #     promotes it instead of raising.
+  def log10!; end
+
+  # @overload log1p!
+  #   Applies {#log1p} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#log1p}
+  #     promotes it instead of raising.
+  def log1p!; end
+
+  # @overload log2!
+  #   Applies {#log2} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#log2} promotes
+  #     it instead of raising.
+  def log2!; end
+
+  # @overload logaddexp!(other)
+  #   Applies {#logaddexp} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @param other [CArray, Numeric] the other operand, broadcast to
+  #     `self.shape`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#logaddexp}
+  #     promotes it instead of raising.
+  def logaddexp!(other); end
+
+  # @overload logb!
+  #   Applies {#logb} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#logb} promotes
+  #     it instead of raising.
+  def logb!; end
+
+  # @overload maximum!(other)
+  #   Applies {#maximum} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @param other [CArray, Numeric] the other operand, broadcast to
+  #     `self.shape`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def maximum!(other); end
+
+  # @overload minimum!(other)
+  #   Applies {#minimum} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @param other [CArray, Numeric] the other operand, broadcast to
+  #     `self.shape`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def minimum!(other); end
+
+  # @overload mul!(other)
+  #   Applies {#mul} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @param other [CArray, Numeric] the other operand, broadcast to
+  #     `self.shape`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def mul!(other); end
+
+  # @overload neg!
+  #   Applies {#neg} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def neg!; end
+
+  # @overload nextafter!(other)
+  #   Applies {#nextafter} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @param other [CArray, Numeric] the other operand, broadcast to
+  #     `self.shape`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#nextafter}
+  #     promotes it instead of raising.
+  def nextafter!(other); end
+
+  # @overload not!
+  #   Applies {#not} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or float array.
+  def not!; end
+
+  # @overload one!
+  #   Applies {#one} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  def one!; end
+
+  # @overload or!(other)
+  #   Applies {#or} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @param other [CArray, true, false] the other operand, broadcast
+  #     to `self.shape`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or float array.
+  def or!(other); end
+
+  # @overload pmax!(other)
+  #   Applies {#pmax} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @param other [CArray, Numeric] the other operand, broadcast to
+  #     `self.shape`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def pmax!(other); end
+
+  # @overload pmin!(other)
+  #   Applies {#pmin} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @param other [CArray, Numeric] the other operand, broadcast to
+  #     `self.shape`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def pmin!(other); end
+
+  # @overload power!(other)
+  #   Applies {#power} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @param other [CArray, Numeric] the other operand, broadcast to
+  #     `self.shape`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def power!(other); end
+
+  # @overload rad!
+  #   Applies {#rad} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#rad} promotes
+  #     it instead of raising.
+  def rad!; end
+
+  # @overload rad_2pi!
+  #   Applies {#rad_2pi} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#rad_2pi}
+  #     promotes it instead of raising.
+  def rad_2pi!; end
+
+  # @overload rad_pi!
+  #   Applies {#rad_pi} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#rad_pi}
+  #     promotes it instead of raising.
+  def rad_pi!; end
+
+  # @overload rcp!
+  #   Applies {#rcp} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def rcp!; end
+
+  # @overload rcp_mul!(other)
+  #   Applies {#rcp_mul} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @param other [CArray, Numeric] the other operand, broadcast to
+  #     `self.shape`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def rcp_mul!(other); end
+
+  # @overload rsqrt!
+  #   Applies {#rsqrt} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#rsqrt}
+  #     promotes it instead of raising.
+  def rsqrt!; end
+
+  # @overload sign!
+  #   Applies {#sign} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  def sign!; end
+
+  # @overload sin!
+  #   Applies {#sin} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#sin} promotes
+  #     it instead of raising.
+  def sin!; end
+
+  # @overload sinh!
+  #   Applies {#sinh} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#sinh} promotes
+  #     it instead of raising.
+  def sinh!; end
+
+  # @overload sqrt!
+  #   Applies {#sqrt} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#sqrt} promotes
+  #     it instead of raising.
+  def sqrt!; end
+
+  # @overload square!
+  #   Applies {#square} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def square!; end
+
+  # @overload sub!(other)
+  #   Applies {#sub} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @param other [CArray, Numeric] the other operand, broadcast to
+  #     `self.shape`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def sub!(other); end
+
+  # @overload tan!
+  #   Applies {#tan} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#tan} promotes
+  #     it instead of raising.
+  def tan!; end
+
+  # @overload tanh!
+  #   Applies {#tanh} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or boolean array,
+  #     whose `data_type` cannot hold the widened result -- {#tanh} promotes
+  #     it instead of raising.
+  def tanh!; end
+
+  # @overload trunc!
+  #   Applies {#trunc} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for a boolean array.
+  def trunc!; end
+
+  # @overload xor!(other)
+  #   Applies {#xor} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @param other [CArray, true, false] the other operand, broadcast
+  #     to `self.shape`.
+  #   @return [self]
+  #   @raise [CArray::DataTypeError] for an integer or float array.
+  def xor!(other); end
+
+  # @overload zero!
+  #   Applies {#zero} to `self` in place, keeping `self`'s
+  #   `data_type`.
+  #   @return [self]
+  def zero!; end
+
+
   # @!endgroup
 end