carray 3.0.0 → 3.0.2

data/yard-stubs/carray_math.rb

@@ -0,0 +1,1615 @@
+# DOCUMENTATION ONLY — DO NOT REQUIRE.
+# Stubs for the elementwise arithmetic generated by ext/mkkernel.rb --
+# 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
+
+  # @overload /(other)
+  #   Returns the element-wise quotient of `self` and `other`.
+  #
+  #   Integer division floors toward negative infinity, so that
+  #   `(a / b) * b + a % b == a` holds for every combination of signs
+  #   -- the same convention as Ruby's `Integer#/`. Float and complex
+  #   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.
+  #   @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.
+  #   @example
+  #     CA_INT32([-7, -1, 7]) / 3      # => [ -3, -1, 2 ]
+  #     CA_DOUBLE([-7.0]) / 3.0        # => [ -2.3333333333333335 ]
+  def /(other); end
+
+  # @overload div(other)
+  #   Alias of {#/}.
+  #   @param other [CArray, Numeric] divisor.
+  #   @return [CArray]
+  def div(other); end
+
+  # @overload div!(other)
+  #   Divides `self` by `other` in place, keeping `self`'s `data_type`.
+  #   @param other [CArray, Numeric] divisor.
+  #   @return [self]
+  def div!(other); end
+
+  # @overload %(other)
+  #   Returns the element-wise remainder of `self` divided by `other`,
+  #   carrying the sign of the divisor.
+  #
+  #   This is the floored modulo, the pair of the floored `/` above and
+  #   the same convention as Ruby's `%`: `-7 % 3` is `2`, and `7 % -3`
+  #   is `-2`. A float remainder of zero takes the divisor's sign, so
+  #   the rule holds without exception. For the truncated form that C
+  #   gives -- the sign of the dividend -- use {#fmod}. Complex arrays
+  #   have no modulo. Masked elements stay masked.
+  #   @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`. A float
+  #     divisor of `0.0` yields `NaN`.
+  #   @raise [CArray::DataTypeError] for a complex array.
+  #   @example
+  #     CA_INT32([-7, -1, 7]) % 3      # => [ 2, 2, 1 ]
+  #     CA_INT32([7]) % -3             # => [ -2 ]
+  #     CA_DOUBLE([-0.4]) % 1.0        # => [ 0.6 ]
+  def %(other); end
+
+  # @overload mod(other)
+  #   Alias of {#%}.
+  #   @param other [CArray, Numeric] divisor.
+  #   @return [CArray]
+  def mod(other); end
+
+  # @overload mod!(other)
+  #   Replaces `self` with the remainder in place, keeping `self`'s
+  #   `data_type`.
+  #   @param other [CArray, Numeric] divisor.
+  #   @return [self]
+  def mod!(other); end
+
+  # @overload fmod(other)
+  #   Returns the element-wise truncated remainder of `self` divided by
+  #   `other`, carrying the sign of the dividend.
+  #
+  #   This is C's `fmod` and `%`: the quotient is truncated toward zero
+  #   rather than floored, so `fmod(-7, 3)` is `-1` where `-7 % 3` is
+  #   `2`. Integer arrays are accepted as well as floats. Complex
+  #   arrays have no remainder. An `:object` array delegates to each
+  #   element's `#remainder`, so an Integer element yields an Integer.
+  #   Masked elements stay masked.
+  #   @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`. A float
+  #     divisor of `0.0` yields `NaN`.
+  #   @raise [CArray::DataTypeError] for a complex array.
+  #   @example
+  #     CA_INT32([-7, -1, 7]).fmod(3)  # => [ -1, -1, 1 ]
+  #     CA_DOUBLE([-0.4]).fmod(1.0)    # => [ -0.4 ]
+  def fmod(other); end
+
+  # @overload fmod!(other)
+  #   Replaces `self` with the truncated remainder in place, keeping
+  #   `self`'s `data_type`.
+  #   @param other [CArray, Numeric] divisor.
+  #   @return [self]
+  def fmod!(other); end
+
+  # @overload round
+  #   Returns a new array with each element rounded to the nearest
+  #   integer value, half rounded away from zero (`2.5` -> `3.0`,
+  #   `-2.5` -> `-3.0`).  The result keeps `self`'s `data_type`.
+  #
+  #   Integer arrays are returned unchanged.  For a `:float64` /
+  #   `:float32` array the value stays floating-point (e.g. `1.4` ->
+  #   `1.0`); a `NaN` element is passed through as `NaN`, and `-0.0`
+  #   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 frac
+  #   Returns a new array of the fractional part of each element:
+  #   `self - self.truncated_toward_zero`, so the result keeps the
+  #   sign of the input (`1.25` -> `0.25`, `-1.25` -> `-0.25`).  The
+  #   result keeps `self`'s `data_type`.
+  #
+  #   Integer arrays yield all zeros.  For a floating-point array a
+  #   `NaN` element is passed through as `NaN`, and `±0.0` keeps its
+  #   sign.  Masked elements stay masked.  An `:object` array
+  #   delegates to each element's `#frac`.
+  #   @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.
+  #   @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. For the form
+  #   that keeps a complex array complex (magnitude with a zero
+  #   imaginary part) use {#abs_i}, which also accepts `:object`.
+  #   @return [CArray] `self`'s `data_type` for numeric input; the real
+  #     component type for complex input.
+  #   @raise [CArray::DataTypeError] for a boolean or `:object` 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).
+  #   @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.
+  #   @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.
+  #   @raise [NoMethodError] for an `:object` array whose elements do
+  #     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 [RuntimeError] 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 [RuntimeError] 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