pigeonhole-db 1.1.0

data/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/core/integer.rbs

@@ -0,0 +1,1374 @@
+# <!-- rdoc-file=numeric.c -->
+# An Integer object represents an integer value.
+#
+# You can create an Integer object explicitly with:
+#
+# *   An [integer literal](rdoc-ref:syntax/literals.rdoc@Integer+Literals).
+#
+# You can convert certain objects to Integers with:
+#
+# *   Method #Integer.
+#
+# An attempt to add a singleton method to an instance of this class causes an
+# exception to be raised.
+#
+# ## What's Here
+#
+# First, what's elsewhere. Class Integer:
+#
+# *   Inherits from [class Numeric](rdoc-ref:Numeric@What-27s+Here) and [class
+#     Object](rdoc-ref:Object@What-27s+Here).
+# *   Includes [module Comparable](rdoc-ref:Comparable@What-27s+Here).
+#
+# Here, class Integer provides methods for:
+#
+# *   [Querying](rdoc-ref:Integer@Querying)
+# *   [Comparing](rdoc-ref:Integer@Comparing)
+# *   [Converting](rdoc-ref:Integer@Converting)
+# *   [Other](rdoc-ref:Integer@Other)
+#
+# ### Querying
+#
+# *   #allbits?: Returns whether all bits in `self` are set.
+# *   #anybits?: Returns whether any bits in `self` are set.
+# *   #nobits?: Returns whether no bits in `self` are set.
+#
+# ### Comparing
+#
+# *   #<: Returns whether `self` is less than the given value.
+# *   #<=: Returns whether `self` is less than or equal to the given value.
+# *   #<=>: Returns a number indicating whether `self` is less than, equal to,
+#     or greater than the given value.
+# *   #== (aliased as #===): Returns whether `self` is equal to the given
+#         value.
+#
+# *   #>: Returns whether `self` is greater than the given value.
+# *   #>=: Returns whether `self` is greater than or equal to the given value.
+#
+# ### Converting
+#
+# *   ::sqrt: Returns the integer square root of the given value.
+# *   ::try_convert: Returns the given value converted to an Integer.
+# *   #% (aliased as #modulo): Returns `self` modulo the given value.
+# *   #&: Returns the bitwise AND of `self` and the given value.
+# *   #*: Returns the product of `self` and the given value.
+# *   #**: Returns the value of `self` raised to the power of the given value.
+# *   #+: Returns the sum of `self` and the given value.
+# *   #-: Returns the difference of `self` and the given value.
+# *   #/: Returns the quotient of `self` and the given value.
+# *   #<<: Returns the value of `self` after a leftward bit-shift.
+# *   #>>: Returns the value of `self` after a rightward bit-shift.
+# *   #[]: Returns a slice of bits from `self`.
+# *   #^: Returns the bitwise EXCLUSIVE OR of `self` and the given value.
+# *   #|: Returns the bitwise OR of `self` and the given value.
+# *   #ceil: Returns the smallest number greater than or equal to `self`.
+# *   #chr: Returns a 1-character string containing the character represented by
+#     the value of `self`.
+# *   #digits: Returns an array of integers representing the base-radix digits
+#     of `self`.
+# *   #div: Returns the integer result of dividing `self` by the given value.
+# *   #divmod: Returns a 2-element array containing the quotient and remainder
+#     results of dividing `self` by the given value.
+# *   #fdiv: Returns the Float result of dividing `self` by the given value.
+# *   #floor: Returns the greatest number smaller than or equal to `self`.
+# *   #pow: Returns the modular exponentiation of `self`.
+# *   #pred: Returns the integer predecessor of `self`.
+# *   #remainder: Returns the remainder after dividing `self` by the given
+#     value.
+# *   #round: Returns `self` rounded to the nearest value with the given
+#     precision.
+# *   #succ (aliased as #next): Returns the integer successor of `self`.
+# *   #to_f: Returns `self` converted to a Float.
+# *   #to_s (aliased as #inspect): Returns a string containing the place-value
+#     representation of `self` in the given radix.
+# *   #truncate: Returns `self` truncated to the given precision.
+#
+# ### Other
+#
+# *   #downto: Calls the given block with each integer value from `self` down to
+#     the given value.
+# *   #times: Calls the given block `self` times with each integer in
+#     <code>(0..self-1)</code>.
+# *   #upto: Calls the given block with each integer value from `self` up to the
+#     given value.
+#
+class Integer < Numeric
+  # TODO: `undef self.new`
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - Integer.sqrt(numeric) -> integer
+  # -->
+  # Returns the integer square root of the non-negative integer `n`, which is the
+  # largest non-negative integer less than or equal to the square root of
+  # `numeric`.
+  #
+  #     Integer.sqrt(0)       # => 0
+  #     Integer.sqrt(1)       # => 1
+  #     Integer.sqrt(24)      # => 4
+  #     Integer.sqrt(25)      # => 5
+  #     Integer.sqrt(10**400) # => 10**200
+  #
+  # If `numeric` is not an Integer, it is converted to an Integer:
+  #
+  #     Integer.sqrt(Complex(4, 0))  # => 2
+  #     Integer.sqrt(Rational(4, 1)) # => 2
+  #     Integer.sqrt(4.0)            # => 2
+  #     Integer.sqrt(3.14159)        # => 1
+  #
+  # This method is equivalent to <code>Math.sqrt(numeric).floor</code>, except
+  # that the result of the latter code may differ from the true value due to the
+  # limited precision of floating point arithmetic.
+  #
+  #     Integer.sqrt(10**46)    # => 100000000000000000000000
+  #     Math.sqrt(10**46).floor # => 99999999999999991611392
+  #
+  # Raises an exception if `numeric` is negative.
+  #
+  def self.sqrt: (int n) -> Integer
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - Integer.try_convert(object) -> object, integer, or nil
+  # -->
+  # If `object` is an Integer object, returns `object`.
+  #     Integer.try_convert(1) # => 1
+  #
+  # Otherwise if `object` responds to <code>:to_int</code>, calls
+  # <code>object.to_int</code> and returns the result.
+  #     Integer.try_convert(1.25) # => 1
+  #
+  # Returns `nil` if `object` does not respond to <code>:to_int</code>
+  #     Integer.try_convert([]) # => nil
+  #
+  # Raises an exception unless <code>object.to_int</code> returns an Integer
+  # object.
+  #
+  def self.try_convert: (int) -> Integer
+                      | (untyped) -> Integer?
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - self % other -> real_numeric
+  # -->
+  # Returns `self` modulo `other` as a real numeric (Integer, Float, or Rational).
+  #
+  # For integer `n` and real number `r`, these expressions are equivalent:
+  #
+  #     n % r
+  #     n-r*(n/r).floor
+  #     n.divmod(r)[1]
+  #
+  # See Numeric#divmod.
+  #
+  # Examples:
+  #
+  #     10 % 2              # => 0
+  #     10 % 3              # => 1
+  #     10 % 4              # => 2
+  #
+  #     10 % -2             # => 0
+  #     10 % -3             # => -2
+  #     10 % -4             # => -2
+  #
+  #     10 % 3.0            # => 1.0
+  #     10 % Rational(3, 1) # => (1/1)
+  #
+  def %: (Float) -> Float
+       | (Rational) -> Rational
+       | (Integer) -> Integer
+       | (Numeric) -> Numeric
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - self & other ->  integer
+  # -->
+  # Bitwise AND; each bit in the result is 1 if both corresponding bits in `self`
+  # and `other` are 1, 0 otherwise:
+  #
+  #     "%04b" % (0b0101 & 0b0110) # => "0100"
+  #
+  # Raises an exception if `other` is not an Integer.
+  #
+  # Related: Integer#| (bitwise OR), Integer#^ (bitwise EXCLUSIVE OR).
+  #
+  def &: (Integer) -> Integer
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - self * other -> numeric
+  # -->
+  # Returns the numeric product of `self` and `other`:
+  #
+  #     4 * 2              # => 8
+  #     -4 * 2             # => -8
+  #     4 * -2             # => -8
+  #     4 * 2.0            # => 8.0
+  #     4 * Rational(1, 3) # => (4/3)
+  #     4 * Complex(2, 0)  # => (8+0i)
+  #
+  def *: (Float) -> Float
+       | (Rational) -> Rational
+       | (Complex) -> Complex
+       | (Integer) -> Integer
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - self ** exponent -> numeric
+  # -->
+  # Returns `self` raised to the power `exponent`:
+  #
+  #     # Result for non-negative Integer exponent is Integer.
+  #     2 ** 0   # => 1
+  #     2 ** 1   # => 2
+  #     2 ** 2   # => 4
+  #     2 ** 3   # => 8
+  #     -2 ** 3  # => -8
+  #     # Result for negative Integer exponent is Rational, not Float.
+  #     2 ** -3  # => (1/8)
+  #     -2 ** -3 # => (-1/8)
+  #
+  #     # Result for Float exponent is Float.
+  #     2 ** 0.0   # => 1.0
+  #     2 ** 1.0   # => 2.0
+  #     2 ** 2.0   # => 4.0
+  #     2 ** 3.0   # => 8.0
+  #     -2 ** 3.0  # => -8.0
+  #     2 ** -3.0  # => 0.125
+  #     -2 ** -3.0 # => -0.125
+  #
+  #     # Result for non-negative Complex exponent is Complex with Integer parts.
+  #     2 ** Complex(0, 0)   # => (1+0i)
+  #     2 ** Complex(1, 0)   # => (2+0i)
+  #     2 ** Complex(2, 0)   # => (4+0i)
+  #     2 ** Complex(3, 0)   # => (8+0i)
+  #     -2 ** Complex(3, 0) # => (-8+0i)
+  #     # Result for negative Complex exponent is Complex with Rational parts.
+  #     2 ** Complex(-3, 0)  # => ((1/8)+(0/1)*i)
+  #     -2 ** Complex(-3, 0) # => ((-1/8)+(0/1)*i)
+  #
+  #     # Result for Rational exponent is Rational.
+  #     2 ** Rational(0, 1)   # => (1/1)
+  #     2 ** Rational(1, 1)   # => (2/1)
+  #     2 ** Rational(2, 1)   # => (4/1)
+  #     2 ** Rational(3, 1)   # => (8/1)
+  #     -2 ** Rational(3, 1)  # => (-8/1)
+  #     2 ** Rational(-3, 1)  # => (1/8)
+  #     -2 ** Rational(-3, 1) # => (-1/8)
+  #
+  def **: (Integer) -> Numeric
+        | (Float) -> Numeric
+        | (Rational) -> Numeric
+        | (Complex) -> Complex
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - self + other -> numeric
+  # -->
+  # Returns the sum of `self` and `other`:
+  #
+  #     1 + 1               # => 2
+  #     1 + -1             # => 0
+  #     1 + 0              # => 1
+  #     1 + -2             # => -1
+  #     1 + Complex(1, 0)  # => (2+0i)
+  #     1 + Rational(1, 1) # => (2/1)
+  #
+  # For a computation involving Floats, the result may be inexact (see Float#+):
+  #
+  #     1 + 3.14           # => 4.140000000000001
+  #
+  def +: (Integer) -> Integer
+       | (Float) -> Float
+       | (Rational) -> Rational
+       | (Complex) -> Complex
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - self - other -> numeric
+  # -->
+  # Returns the difference of `self` and `other`:
+  #
+  #     4 - 2              # => 2
+  #     -4 - 2             # => -6
+  #     -4 - -2            # => -2
+  #     4 - 2.0            # => 2.0
+  #     4 - Rational(2, 1) # => (2/1)
+  #     4 - Complex(2, 0)  # => (2+0i)
+  #
+  def -: (Integer) -> Integer
+       | (Float) -> Float
+       | (Rational) -> Rational
+       | (Complex) -> Complex
+
+  # <!--
+  #   rdoc-file=numeric.rb
+  #   - -self -> integer
+  # -->
+  # Returns `self`, negated:
+  #
+  #     -1    # => -1
+  #     -(-1) # => 1
+  #     -0    # => 0
+  #
+  def -@: () -> Integer
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - self / other -> numeric
+  # -->
+  # Returns the quotient of `self` and `other`.
+  #
+  # For integer `other`, truncates the result to an integer:
+  #
+  #     4 / 3              # => 1
+  #     4 / -3             # => -2
+  #     -4 / 3             # => -2
+  #     -4 / -3            # => 1
+  #
+  # For non-integer `other`, returns a non-integer result:
+  #
+  #     4 / 3.0            # => 1.3333333333333333
+  #     4 / Rational(3, 1) # => (4/3)
+  #     4 / Complex(3, 0)  # => ((4/3)+0i)
+  #
+  def /: (Integer) -> Integer
+       | (Float) -> Float
+       | (Rational) -> Rational
+       | (Complex) -> Complex
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - self < other -> true or false
+  # -->
+  # Returns whether the value of `self` is less than the value of `other`; `other`
+  # must be numeric, but may not be Complex:
+  #
+  #     1 < 0              # => false
+  #     1 < 1              # => false
+  #     1 < 2              # => true
+  #     1 < 0.5            # => false
+  #     1 < Rational(1, 2) # => false
+  #
+  def <: (Numeric) -> bool
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - self << count -> integer
+  # -->
+  # Returns `self` with bits shifted `count` positions to the left, or to the
+  # right if `count` is negative:
+  #
+  #     n = 0b11110000
+  #     "%08b" % (n << 1)  # => "111100000"
+  #     "%08b" % (n << 3)  # => "11110000000"
+  #     "%08b" % (n << -1) # => "01111000"
+  #     "%08b" % (n << -3) # => "00011110"
+  #
+  # Related: Integer#>>.
+  #
+  def <<: (int) -> Integer
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - self <= other -> true or false
+  # -->
+  # Returns whether the value of `self` is less than or equal to the value of
+  # `other`; `other` must be numeric, but may not be Complex:
+  #
+  #       1 <= 0              # => false
+  #       1 <= 1              # => true
+  #       1 <= 2              # => true
+  #       1 <= 0.5            # => false
+  #       1 <= Rational(1, 2) # => false
+  #
+  #     Raises an exception if the comparison cannot be made.
+  #
+  def <=: (Numeric) -> bool
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - self <=> other -> -1, 0, 1, or nil
+  # -->
+  # Compares `self` and `other`.
+  #
+  # Returns:
+  #
+  # *   <code>-1</code>, if `self` is less than `other`.
+  # *   `0`, if `self` is equal to `other`.
+  # *   `1`, if `self` is greater then `other`.
+  # *   `nil`, if `self` and `other` are incomparable.
+  #
+  # Examples:
+  #
+  #     1 <=> 2              # => -1
+  #     1 <=> 1              # => 0
+  #     1 <=> 1.0            # => 0
+  #     1 <=> Rational(1, 1) # => 0
+  #     1 <=> Complex(1, 0)  # => 0
+  #     1 <=> 0              # => 1
+  #     1 <=> 'foo'          # => nil
+  #
+  # Class Integer includes module Comparable, each of whose methods uses
+  # Integer#<=> for comparison.
+  #
+  def <=>: (Integer | Rational) -> Integer
+         | (untyped) -> Integer?
+
+  # <!-- rdoc-file=numeric.c -->
+  # Returns `true` if `self` is numerically equal to `other`; `false` otherwise.
+  #
+  #     1 == 2     #=> false
+  #     1 == 1.0   #=> true
+  #
+  # Related: Integer#eql? (requires `other` to be an Integer).
+  #
+  def ==: (untyped other) -> bool
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - self == other -> true or false
+  # -->
+  # Returns `true` if `self` is numerically equal to `other`; `false` otherwise.
+  #
+  #     1 == 2     #=> false
+  #     1 == 1.0   #=> true
+  #
+  # Related: Integer#eql? (requires `other` to be an Integer).
+  #
+  alias === ==
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - self > other -> true or false
+  # -->
+  # Returns `true` if the value of `self` is greater than that of `other`:
+  #
+  #       1 > 0              # => true
+  #       1 > 1              # => false
+  #       1 > 2              # => false
+  #       1 > 0.5            # => true
+  #       1 > Rational(1, 2) # => true
+  #
+  #     Raises an exception if the comparison cannot be made.
+  #
+  def >: (Numeric) -> bool
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - self >= real -> true or false
+  # -->
+  # Returns `true` if the value of `self` is greater than or equal to that of
+  # `other`:
+  #
+  #     1 >= 0              # => true
+  #     1 >= 1              # => true
+  #     1 >= 2              # => false
+  #     1 >= 0.5            # => true
+  #     1 >= Rational(1, 2) # => true
+  #
+  # Raises an exception if the comparison cannot be made.
+  #
+  def >=: (Numeric) -> bool
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - self >> count -> integer
+  # -->
+  # Returns `self` with bits shifted `count` positions to the right, or to the
+  # left if `count` is negative:
+  #
+  #     n = 0b11110000
+  #     "%08b" % (n >> 1)  # => "01111000"
+  #     "%08b" % (n >> 3)  # => "00011110"
+  #     "%08b" % (n >> -1) # => "111100000"
+  #     "%08b" % (n >> -3) # => "11110000000"
+  #
+  # Related: Integer#<<.
+  #
+  def >>: (int) -> Integer
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - self[offset]    -> 0 or 1
+  #   - self[offset, size] -> integer
+  #   - self[range] -> integer
+  # -->
+  # Returns a slice of bits from `self`.
+  #
+  # With argument `offset`, returns the bit at the given offset, where offset 0
+  # refers to the least significant bit:
+  #
+  #     n = 0b10 # => 2
+  #     n[0]     # => 0
+  #     n[1]     # => 1
+  #     n[2]     # => 0
+  #     n[3]     # => 0
+  #
+  # In principle, <code>n[i]</code> is equivalent to <code>(n >> i) & 1</code>.
+  # Thus, negative index always returns zero:
+  #
+  #     255[-1] # => 0
+  #
+  # With arguments `offset` and `size`, returns `size` bits from `self`, beginning
+  # at `offset` and including bits of greater significance:
+  #
+  #     n = 0b111000       # => 56
+  #     "%010b" % n[0, 10] # => "0000111000"
+  #     "%010b" % n[4, 10] # => "0000000011"
+  #
+  # With argument `range`, returns <code>range.size</code> bits from `self`,
+  # beginning at <code>range.begin</code> and including bits of greater
+  # significance:
+  #
+  #     n = 0b111000      # => 56
+  #     "%010b" % n[0..9] # => "0000111000"
+  #     "%010b" % n[4..9] # => "0000000011"
+  #
+  # Raises an exception if the slice cannot be constructed.
+  #
+  def []: (int) -> Integer
+        | (int i, int len) -> Integer
+        | (Range[int]) -> Integer
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - self ^ other -> integer
+  # -->
+  # Bitwise EXCLUSIVE OR; each bit in the result is 1 if the corresponding bits in
+  # `self` and `other` are different, 0 otherwise:
+  #
+  #     "%04b" % (0b0101 ^ 0b0110) # => "0011"
+  #
+  # Raises an exception if `other` is not an Integer.
+  #
+  # Related: Integer#& (bitwise AND), Integer#| (bitwise OR).
+  #
+  def ^: (Integer) -> Integer
+
+  # <!--
+  #   rdoc-file=numeric.rb
+  #   - abs -> integer
+  # -->
+  # Returns the absolute value of `self`.
+  #
+  #     (-12345).abs # => 12345
+  #     -12345.abs   # => 12345
+  #     12345.abs    # => 12345
+  #
+  def abs: () -> Integer
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - allbits?(mask) -> true or false
+  # -->
+  # Returns `true` if all bits that are set (=1) in `mask` are also set in `self`;
+  # returns `false` otherwise.
+  #
+  # Example values:
+  #
+  #     0b1010101  self
+  #     0b1010100  mask
+  #     0b1010100  self & mask
+  #          true  self.allbits?(mask)
+  #
+  #     0b1010100  self
+  #     0b1010101  mask
+  #     0b1010100  self & mask
+  #         false  self.allbits?(mask)
+  #
+  # Related: Integer#anybits?, Integer#nobits?.
+  #
+  def allbits?: (int mask) -> bool
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - anybits?(mask) -> true or false
+  # -->
+  # Returns `true` if any bit that is set (=1) in `mask` is also set in `self`;
+  # returns `false` otherwise.
+  #
+  # Example values:
+  #
+  #     0b10000010  self
+  #     0b11111111  mask
+  #     0b10000010  self & mask
+  #           true  self.anybits?(mask)
+  #
+  #     0b00000000  self
+  #     0b11111111  mask
+  #     0b00000000  self & mask
+  #          false  self.anybits?(mask)
+  #
+  # Related: Integer#allbits?, Integer#nobits?.
+  #
+  def anybits?: (int mask) -> bool
+
+  alias arg angle
+
+  # <!--
+  #   rdoc-file=numeric.rb
+  #   - bit_length -> integer
+  # -->
+  # Returns the number of bits of the value of `self`, which is the bit position
+  # of the highest-order bit that is different from the sign bit (where the least
+  # significant bit has bit position 1). If there is no such bit (zero or minus
+  # one), returns zero.
+  #
+  # This method returns <code>ceil(log2(self < 0 ? -self : self + 1))</code>>.
+  #
+  #     (-2**1000-1).bit_length   # => 1001
+  #     (-2**1000).bit_length     # => 1000
+  #     (-2**1000+1).bit_length   # => 1000
+  #     (-2**12-1).bit_length     # => 13
+  #     (-2**12).bit_length       # => 12
+  #     (-2**12+1).bit_length     # => 12
+  #     -0x101.bit_length         # => 9
+  #     -0x100.bit_length         # => 8
+  #     -0xff.bit_length          # => 8
+  #     -2.bit_length             # => 1
+  #     -1.bit_length             # => 0
+  #     0.bit_length              # => 0
+  #     1.bit_length              # => 1
+  #     0xff.bit_length           # => 8
+  #     0x100.bit_length          # => 9
+  #     (2**12-1).bit_length      # => 12
+  #     (2**12).bit_length        # => 13
+  #     (2**12+1).bit_length      # => 13
+  #     (2**1000-1).bit_length    # => 1000
+  #     (2**1000).bit_length      # => 1001
+  #     (2**1000+1).bit_length    # => 1001
+  #
+  # For Integer *n*, this method can be used to detect overflow in Array#pack:
+  #
+  #     if n.bit_length < 32
+  #       [n].pack('l') # No overflow.
+  #     else
+  #       raise 'Overflow'
+  #     end
+  #
+  def bit_length: () -> Integer
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - ceil(ndigits = 0) -> integer
+  # -->
+  # Returns an integer that is a "ceiling" value for `self`,
+  # as specified by the given `ndigits`,
+  # which must be an
+  # [integer-convertible
+  # object](rdoc-ref:implicit_conversion.rdoc@Integer-Convertible+Objects).
+  # *   When `self` is zero, returns zero (regardless of the value of `ndigits`):
+  #         0.ceil(2)  # => 0
+  # 0.ceil(-2) # => 0
+  #
+  # *   When `self` is non-zero and `ndigits` is non-negative, returns `self`:
+  #         555.ceil     # => 555
+  # 555.ceil(50) # => 555
+  #
+  # *   When `self` is non-zero and `ndigits` is negative,
+  #      returns a value based on a computed granularity:
+  #     *   The granularity is <code>10 ** ndigits.abs</code>.
+  #     *   The returned value is the smallest multiple of the granularity
+  #          that is greater than or equal to `self`.
+  #     Examples with positive `self`:
+  # ndigits|Granularity|1234.ceil(ndigits)
+  # -------|-----------|------------------
+  #      -1|         10|              1240
+  #      -2|        100|              1300
+  #      -3|       1000|              2000
+  #      -4|      10000|             10000
+  #      -5|     100000|            100000
+  #     Examples with negative `self`:
+  # ndigits|Granularity|-1234.ceil(ndigits)
+  # -------|-----------|-------------------
+  #      -1|         10|              -1230
+  #      -2|        100|              -1200
+  #      -3|       1000|              -1000
+  #      -4|      10000|                  0
+  #      -5|     100000|                  0
+  # Related: Integer#floor.
+  #
+  def ceil: (?int digits) -> Integer
+
+  # <!--
+  #   rdoc-file=numeric.rb
+  #   - ceildiv(numeric) -> integer
+  # -->
+  # Returns the result of division `self` by `numeric`. rounded up to the nearest
+  # integer.
+  #
+  #     3.ceildiv(3)   # => 1
+  #     4.ceildiv(3)   # => 2
+  #
+  #     4.ceildiv(-3)  # => -1
+  #     -4.ceildiv(3)  # => -1
+  #     -4.ceildiv(-3) # => 2
+  #
+  #     3.ceildiv(1.2) # => 3
+  #
+  def ceildiv: (Numeric other) -> Integer
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - chr           -> string
+  #   - chr(encoding) -> string
+  # -->
+  # Returns a 1-character string containing the character represented by the value
+  # of `self`, according to the given `encoding`.
+  #
+  #     65.chr                   # => "A"
+  #     0.chr                    # => "\x00"
+  #     255.chr                  # => "\xFF"
+  #     string = 255.chr(Encoding::UTF_8)
+  #     string.encoding          # => Encoding::UTF_8
+  #
+  # Raises an exception if `self` is negative.
+  #
+  # Related: Integer#ord.
+  #
+  def chr: (?encoding encoding) -> String
+
+  # <!--
+  #   rdoc-file=bignum.c
+  #   - int.coerce(numeric)  ->  array
+  # -->
+  # Returns an array with both a `numeric` and a `int` represented as Integer
+  # objects or Float objects.
+  #
+  # This is achieved by converting `numeric` to an Integer or a Float.
+  #
+  # A TypeError is raised if the `numeric` is not an Integer or a Float type.
+  #
+  #     (0x3FFFFFFFFFFFFFFF+1).coerce(42)   #=> [42, 4611686018427387904]
+  #
+  def coerce: (Numeric) -> [ Numeric, Numeric ]
+
+  # <!--
+  #   rdoc-file=numeric.rb
+  #   - denominator -> 1
+  # -->
+  # Returns `1`.
+  #
+  def denominator: () -> 1
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - digits(base = 10) -> array_of_integers
+  # -->
+  # Returns an array of integers representing the `base`-radix digits of `self`;
+  # the first element of the array represents the least significant digit:
+  #
+  #     12345.digits      # => [5, 4, 3, 2, 1]
+  #     12345.digits(7)   # => [4, 6, 6, 0, 5]
+  #     12345.digits(100) # => [45, 23, 1]
+  #
+  # Raises an exception if `self` is negative or `base` is less than 2.
+  #
+  def digits: (?int base) -> Array[Integer]
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - div(numeric)  -> integer
+  # -->
+  # Performs integer division; returns the integer result of dividing `self` by
+  # `numeric`:
+  #
+  #     4.div(3)              # => 1
+  #     4.div(-3)             # => -2
+  #     -4.div(3)             # => -2
+  #     -4.div(-3)            # => 1
+  #     4.div(3.0)            # => 1
+  #     4.div(Rational(3, 1)) # => 1
+  #
+  # Raises an exception if `numeric` does not have method `div`.
+  #
+  def div: (Numeric) -> Integer
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - divmod(other) -> array
+  # -->
+  # Returns a 2-element array <code>[q, r]</code>, where
+  #
+  #     q = (self/other).floor    # Quotient
+  #     r = self % other          # Remainder
+  #
+  # Examples:
+  #
+  #     11.divmod(4)              # => [2, 3]
+  #     11.divmod(-4)             # => [-3, -1]
+  #     -11.divmod(4)             # => [-3, 1]
+  #     -11.divmod(-4)            # => [2, -3]
+  #
+  #     12.divmod(4)              # => [3, 0]
+  #     12.divmod(-4)             # => [-3, 0]
+  #     -12.divmod(4)             # => [-3, 0]
+  #     -12.divmod(-4)            # => [3, 0]
+  #
+  #     13.divmod(4.0)            # => [3, 1.0]
+  #     13.divmod(Rational(4, 1)) # => [3, (1/1)]
+  #
+  def divmod: (Integer) -> [ Integer, Integer ]
+            | (Float) -> [ Integer, Float ]
+            | (Rational) -> [ Integer, Rational ]
+            | (Numeric) -> [ Numeric, Numeric ]
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - downto(limit) {|i| ... } -> self
+  #   - downto(limit)            ->  enumerator
+  # -->
+  # Calls the given block with each integer value from `self` down to `limit`;
+  # returns `self`:
+  #
+  #     a = []
+  #     10.downto(5) {|i| a << i }              # => 10
+  #     a                                       # => [10, 9, 8, 7, 6, 5]
+  #     a = []
+  #     0.downto(-5) {|i| a << i }              # => 0
+  #     a                                       # => [0, -1, -2, -3, -4, -5]
+  #     4.downto(5) {|i| fail 'Cannot happen' } # => 4
+  #
+  # With no block given, returns an Enumerator.
+  #
+  def downto: (Numeric limit) { (Integer) -> void } -> Integer
+            | (Numeric limit) -> ::Enumerator[Integer, self]
+
+  # <!--
+  #   rdoc-file=numeric.rb
+  #   - even? -> true or false
+  # -->
+  # Returns `true` if `self` is an even number, `false` otherwise.
+  #
+  def even?: () -> bool
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - fdiv(numeric) -> float
+  # -->
+  # Returns the Float result of dividing `self` by `numeric`:
+  #
+  #     4.fdiv(2)      # => 2.0
+  #     4.fdiv(-2)      # => -2.0
+  #     -4.fdiv(2)      # => -2.0
+  #     4.fdiv(2.0)      # => 2.0
+  #     4.fdiv(Rational(3, 4))      # => 5.333333333333333
+  #
+  # Raises an exception if `numeric` cannot be converted to a Float.
+  #
+  def fdiv: (Numeric) -> Float
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - floor(ndigits = 0) -> integer
+  # -->
+  # Returns an integer that is a "floor" value for `self`,
+  # as specified by the given `ndigits`,
+  # which must be an
+  # [integer-convertible
+  # object](rdoc-ref:implicit_conversion.rdoc@Integer-Convertible+Objects).
+  # *   When `self` is zero, returns zero (regardless of the value of `ndigits`):
+  #         0.floor(2)  # => 0
+  # 0.floor(-2) # => 0
+  #
+  # *   When `self` is non-zero and `ndigits` is non-negative, returns `self`:
+  #         555.floor     # => 555
+  # 555.floor(50) # => 555
+  #
+  # *   When `self` is non-zero and `ndigits` is negative,
+  #      returns a value based on a computed granularity:
+  #     *   The granularity is <code>10 ** ndigits.abs</code>.
+  #     *   The returned value is the largest multiple of the granularity
+  #          that is less than or equal to `self`.
+  #     Examples with positive `self`:
+  # ndigits|Granularity|1234.floor(ndigits)
+  # -------|-----------|-------------------
+  #      -1|         10|               1230
+  #      -2|        100|               1200
+  #      -3|       1000|               1000
+  #      -4|      10000|                  0
+  #      -5|     100000|                  0
+  #     Examples with negative `self`:
+  # ndigits|Granularity|-1234.floor(ndigits)
+  # -------|-----------|--------------------
+  #      -1|         10|               -1240
+  #      -2|        100|               -1300
+  #      -3|       1000|               -2000
+  #      -4|      10000|              -10000
+  #      -5|     100000|             -100000
+  # Related: Integer#ceil.
+  #
+  def floor: (?int digits) -> Integer
+
+  # <!--
+  #   rdoc-file=rational.c
+  #   - int.gcd(other_int)  ->  integer
+  # -->
+  # Returns the greatest common divisor of the two integers. The result is always
+  # positive. 0.gcd(x) and x.gcd(0) return x.abs.
+  #
+  #     36.gcd(60)                  #=> 12
+  #     2.gcd(2)                    #=> 2
+  #     3.gcd(-7)                   #=> 1
+  #     ((1<<31)-1).gcd((1<<61)-1)  #=> 1
+  #
+  def gcd: (Integer other_int) -> Integer
+
+  # <!--
+  #   rdoc-file=rational.c
+  #   - int.gcdlcm(other_int)  ->  array
+  # -->
+  # Returns an array with the greatest common divisor and the least common
+  # multiple of the two integers, [gcd, lcm].
+  #
+  #     36.gcdlcm(60)                  #=> [12, 180]
+  #     2.gcdlcm(2)                    #=> [2, 2]
+  #     3.gcdlcm(-7)                   #=> [1, 21]
+  #     ((1<<31)-1).gcdlcm((1<<61)-1)  #=> [1, 4951760154835678088235319297]
+  #
+  def gcdlcm: (Integer other_int) -> [ Integer, Integer ]
+
+  # <!-- rdoc-file=numeric.c -->
+  # Returns a string containing the place-value representation of `self` in radix
+  # `base` (in 2..36).
+  #
+  #     12345.to_s               # => "12345"
+  #     12345.to_s(2)            # => "11000000111001"
+  #     12345.to_s(8)            # => "30071"
+  #     12345.to_s(10)           # => "12345"
+  #     12345.to_s(16)           # => "3039"
+  #     12345.to_s(36)           # => "9ix"
+  #     78546939656932.to_s(36)  # => "rubyrules"
+  #
+  # Raises an exception if `base` is out of range.
+  #
+  alias inspect to_s
+
+  # <!--
+  #   rdoc-file=numeric.rb
+  #   - integer? -> true
+  # -->
+  # Since `self` is already an Integer, always returns `true`.
+  #
+  def integer?: () -> true
+
+  # <!--
+  #   rdoc-file=rational.c
+  #   - int.lcm(other_int)  ->  integer
+  # -->
+  # Returns the least common multiple of the two integers. The result is always
+  # positive. 0.lcm(x) and x.lcm(0) return zero.
+  #
+  #     36.lcm(60)                  #=> 180
+  #     2.lcm(2)                    #=> 2
+  #     3.lcm(-7)                   #=> 21
+  #     ((1<<31)-1).lcm((1<<61)-1)  #=> 4951760154835678088235319297
+  #
+  def lcm: (Integer other_int) -> Integer
+
+  # <!--
+  #   rdoc-file=numeric.rb
+  #   - magnitude()
+  # -->
+  #
+  alias magnitude abs
+
+  # <!-- rdoc-file=numeric.c -->
+  # Returns `self` modulo `other` as a real numeric (Integer, Float, or Rational).
+  #
+  # For integer `n` and real number `r`, these expressions are equivalent:
+  #
+  #     n % r
+  #     n-r*(n/r).floor
+  #     n.divmod(r)[1]
+  #
+  # See Numeric#divmod.
+  #
+  # Examples:
+  #
+  #     10 % 2              # => 0
+  #     10 % 3              # => 1
+  #     10 % 4              # => 2
+  #
+  #     10 % -2             # => 0
+  #     10 % -3             # => -2
+  #     10 % -4             # => -2
+  #
+  #     10 % 3.0            # => 1.0
+  #     10 % Rational(3, 1) # => (1/1)
+  #
+  alias modulo %
+
+  def negative?: () -> bool
+
+  # <!-- rdoc-file=numeric.c -->
+  # Returns the successor integer of `self` (equivalent to <code>self + 1</code>):
+  #
+  #     1.succ  #=> 2
+  #     -1.succ #=> 0
+  #
+  # Related: Integer#pred (predecessor value).
+  #
+  alias next succ
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - nobits?(mask) -> true or false
+  # -->
+  # Returns `true` if no bit that is set (=1) in `mask` is also set in `self`;
+  # returns `false` otherwise.
+  #
+  # Example values:
+  #
+  #     0b11110000  self
+  #     0b00001111  mask
+  #     0b00000000  self & mask
+  #           true  self.nobits?(mask)
+  #
+  #     0b00000001  self
+  #     0b11111111  mask
+  #     0b00000001  self & mask
+  #          false  self.nobits?(mask)
+  #
+  # Related: Integer#allbits?, Integer#anybits?.
+  #
+  def nobits?: (int mask) -> bool
+
+  # <!--
+  #   rdoc-file=numeric.rb
+  #   - numerator -> self
+  # -->
+  # Returns `self`.
+  #
+  def numerator: () -> self
+
+  # <!--
+  #   rdoc-file=numeric.rb
+  #   - odd? -> true or false
+  # -->
+  # Returns `true` if `self` is an odd number, `false` otherwise.
+  #
+  def odd?: () -> bool
+
+  # <!--
+  #   rdoc-file=numeric.rb
+  #   - ord -> self
+  # -->
+  # Returns `self`; intended for compatibility to character literals in Ruby 1.9.
+  #
+  def ord: () -> self
+
+  def polar: () -> [ Integer, Integer | Float ]
+
+  def positive?: () -> bool
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - integer.pow(numeric)           ->  numeric
+  #   - integer.pow(integer, integer)  ->  integer
+  # -->
+  # Returns (modular) exponentiation as:
+  #
+  #     a.pow(b)     #=> same as a**b
+  #     a.pow(b, m)  #=> same as (a**b) % m, but avoids huge temporary values
+  #
+  def pow: (Integer other) -> (Integer | Rational)
+         | (Integer other, Integer modulo) -> Integer
+         | (Float) -> (Float | Complex)
+         | (Rational) -> (Float | Rational | Complex)
+         | (Complex) -> Complex
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - pred -> next_integer
+  # -->
+  # Returns the predecessor of `self` (equivalent to <code>self - 1</code>):
+  #
+  #     1.pred  #=> 0
+  #     -1.pred #=> -2
+  #
+  # Related: Integer#succ (successor value).
+  #
+  def pred: () -> Integer
+
+  def quo: (Integer) -> Rational
+         | (Float) -> Float
+         | (Rational) -> Rational
+         | (Complex) -> Complex
+         | (Numeric) -> Numeric
+
+  # <!--
+  #   rdoc-file=rational.c
+  #   - int.rationalize([eps])  ->  rational
+  # -->
+  # Returns the value as a rational.  The optional argument `eps` is always
+  # ignored.
+  #
+  def rationalize: (?Numeric eps) -> Rational
+
+  def rect: () -> [ Integer, Numeric ]
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - remainder(other) -> real_number
+  # -->
+  # Returns the remainder after dividing `self` by `other`.
+  #
+  # Examples:
+  #
+  #     11.remainder(4)              # => 3
+  #     11.remainder(-4)             # => 3
+  #     -11.remainder(4)             # => -3
+  #     -11.remainder(-4)            # => -3
+  #
+  #     12.remainder(4)              # => 0
+  #     12.remainder(-4)             # => 0
+  #     -12.remainder(4)             # => 0
+  #     -12.remainder(-4)            # => 0
+  #
+  #     13.remainder(4.0)            # => 1.0
+  #     13.remainder(Rational(4, 1)) # => (1/1)
+  #
+  def remainder: (Integer) -> Integer
+               | (Float) -> Float
+               | (Rational) -> Rational
+               | (Numeric) -> Numeric
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - round(ndigits= 0, half: :up) -> integer
+  # -->
+  # Returns `self` rounded to the nearest value with a precision of `ndigits`
+  # decimal digits.
+  #
+  # When `ndigits` is negative, the returned value has at least
+  # <code>ndigits.abs</code> trailing zeros:
+  #
+  #     555.round(-1)      # => 560
+  #     555.round(-2)      # => 600
+  #     555.round(-3)      # => 1000
+  #     -555.round(-2)     # => -600
+  #     555.round(-4)      # => 0
+  #
+  # Returns `self` when `ndigits` is zero or positive.
+  #
+  #     555.round     # => 555
+  #     555.round(1)  # => 555
+  #     555.round(50) # => 555
+  #
+  # If keyword argument `half` is given, and `self` is equidistant from the two
+  # candidate  values, the rounding is according to the given `half` value:
+  #
+  # *   <code>:up</code> or `nil`: round away from zero:
+  #
+  #         25.round(-1, half: :up)      # => 30
+  #         (-25).round(-1, half: :up)   # => -30
+  #
+  # *   <code>:down</code>: round toward zero:
+  #
+  #         25.round(-1, half: :down)    # => 20
+  #         (-25).round(-1, half: :down) # => -20
+  #
+  # *   <code>:even</code>: round toward the candidate whose last nonzero digit is
+  #     even:
+  #
+  #         25.round(-1, half: :even)    # => 20
+  #         15.round(-1, half: :even)    # => 20
+  #         (-25).round(-1, half: :even) # => -20
+  #
+  # Raises and exception if the value for `half` is invalid.
+  #
+  # Related: Integer#truncate.
+  #
+  def round: (?int digits, ?half: Numeric::round_mode) -> Integer
+
+  # <!--
+  #   rdoc-file=numeric.rb
+  #   - size -> integer
+  # -->
+  # Returns the number of bytes in the machine representation of `self`; the value
+  # is system-dependent:
+  #
+  #     1.size             # => 8
+  #     -1.size            # => 8
+  #     2147483647.size    # => 8
+  #     (256**10 - 1).size # => 10
+  #     (256**20 - 1).size # => 20
+  #     (256**40 - 1).size # => 40
+  #
+  def size: () -> Integer
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - succ -> next_integer
+  # -->
+  # Returns the successor integer of `self` (equivalent to <code>self + 1</code>):
+  #
+  #     1.succ  #=> 2
+  #     -1.succ #=> 0
+  #
+  # Related: Integer#pred (predecessor value).
+  #
+  def succ: () -> Integer
+
+  # <!--
+  #   rdoc-file=numeric.rb
+  #   - times {|i| ... } -> self
+  #   - times            -> enumerator
+  # -->
+  # Calls the given block `self` times with each integer in
+  # <code>(0..self-1)</code>:
+  #
+  #     a = []
+  #     5.times {|i| a.push(i) } # => 5
+  #     a                        # => [0, 1, 2, 3, 4]
+  #
+  # With no block given, returns an Enumerator.
+  #
+  def times: () { (Integer i) -> void } -> self
+           | () -> Enumerator[Integer, self]
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - to_f -> float
+  # -->
+  # Converts `self` to a Float:
+  #
+  #     1.to_f  # => 1.0
+  #     -1.to_f # => -1.0
+  #
+  # If the value of `self` does not fit in a Float, the result is infinity:
+  #
+  #     (10**400).to_f  # => Infinity
+  #     (-10**400).to_f # => -Infinity
+  #
+  def to_f: () -> Float
+
+  # <!--
+  #   rdoc-file=numeric.rb
+  #   - to_i -> self
+  # -->
+  # Returns `self` (which is already an Integer).
+  #
+  def to_i: () -> self
+
+  # <!--
+  #   rdoc-file=numeric.rb
+  #   - to_int -> self
+  # -->
+  # Returns `self` (which is already an Integer).
+  #
+  alias to_int to_i
+
+  # <!--
+  #   rdoc-file=rational.c
+  #   - int.to_r  ->  rational
+  # -->
+  # Returns the value as a rational.
+  #
+  #     1.to_r        #=> (1/1)
+  #     (1<<64).to_r  #=> (18446744073709551616/1)
+  #
+  def to_r: () -> Rational
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - to_s(base = 10)  ->  string
+  # -->
+  # Returns a string containing the place-value representation of `self` in radix
+  # `base` (in 2..36).
+  #
+  #     12345.to_s               # => "12345"
+  #     12345.to_s(2)            # => "11000000111001"
+  #     12345.to_s(8)            # => "30071"
+  #     12345.to_s(10)           # => "12345"
+  #     12345.to_s(16)           # => "3039"
+  #     12345.to_s(36)           # => "9ix"
+  #     78546939656932.to_s(36)  # => "rubyrules"
+  #
+  # Raises an exception if `base` is out of range.
+  #
+  def to_s: (?int base) -> String
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - truncate(ndigits = 0) -> integer
+  # -->
+  # Returns `self` truncated (toward zero) to a precision of `ndigits` decimal
+  # digits.
+  #
+  # When `ndigits` is negative, the returned value has at least
+  # <code>ndigits.abs</code> trailing zeros:
+  #
+  #     555.truncate(-1)  # => 550
+  #     555.truncate(-2)  # => 500
+  #     -555.truncate(-2) # => -500
+  #
+  # Returns `self` when `ndigits` is zero or positive.
+  #
+  #     555.truncate     # => 555
+  #     555.truncate(50) # => 555
+  #
+  # Related: Integer#round.
+  #
+  def truncate: (?int ndigits) -> Integer
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - upto(limit) {|i| ... } -> self
+  #   - upto(limit)            ->  enumerator
+  # -->
+  # Calls the given block with each integer value from `self` up to `limit`;
+  # returns `self`:
+  #
+  #     a = []
+  #     5.upto(10) {|i| a << i }              # => 5
+  #     a                                     # => [5, 6, 7, 8, 9, 10]
+  #     a = []
+  #     -5.upto(0) {|i| a << i }              # => -5
+  #     a                                     # => [-5, -4, -3, -2, -1, 0]
+  #     5.upto(4) {|i| fail 'Cannot happen' } # => 5
+  #
+  # With no block given, returns an Enumerator.
+  #
+  def upto: (Numeric limit) { (Integer) -> void } -> Integer
+          | (Numeric limit) -> ::Enumerator[Integer, self]
+
+  # <!--
+  #   rdoc-file=numeric.rb
+  #   - zero? -> true or false
+  # -->
+  # Returns `true` if `self` has a zero value, `false` otherwise.
+  #
+  def zero?: () -> bool
+
+  # <!--
+  #   rdoc-file=numeric.c
+  #   - self | other -> integer
+  # -->
+  # Bitwise OR; each bit in the result is 1 if either corresponding bit in `self`
+  # or `other` is 1, 0 otherwise:
+  #
+  #     "%04b" % (0b0101 | 0b0110) # => "0111"
+  #
+  # Raises an exception if `other` is not an Integer.
+  #
+  # Related: Integer#& (bitwise AND), Integer#^ (bitwise EXCLUSIVE OR).
+  #
+  def |: (Integer) -> Integer
+
+  # <!--
+  #   rdoc-file=numeric.rb
+  #   - ~int -> integer
+  # -->
+  # One's complement: returns the value of `self` with each bit inverted.
+  #
+  # Because an integer value is conceptually of infinite length, the result acts
+  # as if it had an infinite number of one bits to the left. In hex
+  # representations, this is displayed as two periods to the left of the digits:
+  #
+  #     sprintf("%X", ~0x1122334455)    # => "..FEEDDCCBBAA"
+  #
+  def ~: () -> Integer
+end