steep 0.14.0 → 0.16.3

data/vendor/ruby-signature/stdlib/builtin/integer.rbs

@@ -1,710 +0,0 @@
-# Holds Integer values.  You cannot add a singleton method to an Integer object,
-# any attempt to do so will raise a TypeError.
-#
-class Integer < Numeric
-  # Returns the integer square root of the non-negative integer `n`, i.e. the
-  # largest non-negative integer less than or equal to the square root of `n`.
-  #
-  #     Integer.sqrt(0)        #=> 0
-  #     Integer.sqrt(1)        #=> 1
-  #     Integer.sqrt(24)       #=> 4
-  #     Integer.sqrt(25)       #=> 5
-  #     Integer.sqrt(10**400)  #=> 10**200
-  #
-  # Equivalent to `Math.sqrt(n).floor`, 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 (!)
-  #
-  # If `n` is not an Integer, it is converted to an Integer first. If `n` is
-  # negative, a Math::DomainError is raised.
-  #
-  def self.sqrt: (int n) -> Integer
-
-  public
-
-  # Returns `int` modulo `other`.
-  #
-  # See Numeric#divmod for more information.
-  #
-  def %: (Float) -> Float
-       | (Rational) -> Rational
-       | (Integer) -> Integer
-       | (Numeric) -> Numeric
-
-  # Bitwise AND.
-  #
-  def &: (Integer) -> Integer
-
-  # Performs multiplication: the class of the resulting object depends on the
-  # class of `numeric`.
-  #
-  def *: (Float) -> Float
-       | (Rational) -> Rational
-       | (Complex) -> Complex
-       | (Integer) -> Integer
-       | (Numeric) -> Numeric
-
-  # Raises `int` to the power of `numeric`, which may be negative or fractional.
-  # The result may be an Integer, a Float, a Rational, or a complex number.
-  #
-  #     2 ** 3        #=> 8
-  #     2 ** -1       #=> (1/2)
-  #     2 ** 0.5      #=> 1.4142135623730951
-  #     (-1) ** 0.5   #=> (0.0+1.0i)
-  #
-  #     123456789 ** 2     #=> 15241578750190521
-  #     123456789 ** 1.2   #=> 5126464716.0993185
-  #     123456789 ** -2    #=> (1/15241578750190521)
-  #
-  def **: (Integer) -> Numeric
-        | (Float) -> Numeric
-        | (Rational) -> Numeric
-        | (Complex) -> Complex
-        | (Numeric) -> Numeric
-
-  # Performs addition: the class of the resulting object depends on the class of
-  # `numeric`.
-  #
-  def +: (Integer) -> Integer
-       | (Float) -> Float
-       | (Rational) -> Rational
-       | (Complex) -> Complex
-       | (Numeric) -> Numeric
-
-  def +@: () -> Integer
-
-  # Performs subtraction: the class of the resulting object depends on the class
-  # of `numeric`.
-  #
-  def -: (Integer) -> Integer
-       | (Float) -> Float
-       | (Rational) -> Rational
-       | (Complex) -> Complex
-       | (Numeric) -> Numeric
-
-  # Returns `int`, negated.
-  #
-  def -@: () -> Integer
-
-  # Performs division: the class of the resulting object depends on the class of
-  # `numeric`.
-  #
-  def /: (Integer) -> Integer
-       | (Float) -> Float
-       | (Rational) -> Rational
-       | (Complex) -> Complex
-       | (Numeric) -> Numeric
-
-  # Returns `true` if the value of `int` is less than that of `real`.
-  #
-  def <: (Numeric) -> bool
-
-  # Returns `int` shifted left `count` positions, or right if `count` is negative.
-  #
-  def <<: (int) -> Integer
-
-  # Returns `true` if the value of `int` is less than or equal to that of `real`.
-  #
-  def <=: (Numeric) -> bool
-
-  # Comparison---Returns -1, 0, or +1 depending on whether `int` is less than,
-  # equal to, or greater than `numeric`.
-  #
-  # This is the basis for the tests in the Comparable module.
-  #
-  # `nil` is returned if the two values are incomparable.
-  #
-  def <=>: (Numeric) -> Integer?
-
-  # Returns `true` if `int` equals `other` numerically. Contrast this with
-  # Integer#eql?, which requires `other` to be an Integer.
-  #
-  #     1 == 2     #=> false
-  #     1 == 1.0   #=> true
-  #
-  def ==: (untyped) -> bool
-
-  # Returns `true` if `int` equals `other` numerically. Contrast this with
-  # Integer#eql?, which requires `other` to be an Integer.
-  #
-  #     1 == 2     #=> false
-  #     1 == 1.0   #=> true
-  #
-  def ===: (untyped) -> bool
-
-  # Returns `true` if the value of `int` is greater than that of `real`.
-  #
-  def >: (Numeric) -> bool
-
-  # Returns `true` if the value of `int` is greater than or equal to that of
-  # `real`.
-  #
-  def >=: (Numeric) -> bool
-
-  # Returns `int` shifted right `count` positions, or left if `count` is negative.
-  #
-  def >>: (int) -> Integer
-
-  # Bit Reference---Returns the `n`th bit in the binary representation of `int`,
-  # where `int[0]` is the least significant bit.
-  #
-  #     a = 0b11001100101010
-  #     30.downto(0) {|n| print a[n] }
-  #     #=> 0000000000000000011001100101010
-  #
-  #     a = 9**15
-  #     50.downto(0) {|n| print a[n] }
-  #     #=> 000101110110100000111000011110010100111100010111001
-  #
-  # In principle, `n[i]` is equivalent to `(n >> i) & 1`. Thus, any negative index
-  # always returns zero:
-  #
-  #     p 255[-1] #=> 0
-  #
-  # Range operations `n[i, len]` and `n[i..j]` are naturally extended.
-  #
-  # *   `n[i, len]` equals to `(n >> i) & ((1 << len) - 1)`.
-  # *   `n[i..j]` equals to `(n >> i) & ((1 << (j - i + 1)) - 1)`.
-  # *   `n[i...j]` equals to `(n >> i) & ((1 << (j - i)) - 1)`.
-  # *   `n[i..]` equals to `(n >> i)`.
-  # *   `n[..j]` is zero if `n & ((1 << (j + 1)) - 1)` is zero.  Otherwise, raises
-  #     an ArgumentError.
-  # *   `n[...j]` is zero if `n & ((1 << j) - 1)` is zero.  Otherwise, raises an
-  #     ArgumentError.
-  #
-  #
-  # Note that range operation may exhaust memory. For example, `-1[0,
-  # 1000000000000]` will raise NoMemoryError.
-  #
-  def []: (int) -> Integer
-        | (int i, int len) -> Integer
-        | (Range[int]) -> Integer
-
-  # Bitwise EXCLUSIVE OR.
-  #
-  def ^: (Integer) -> Integer
-
-  # Returns the absolute value of `int`.
-  #
-  #     (-12345).abs   #=> 12345
-  #     -12345.abs     #=> 12345
-  #     12345.abs      #=> 12345
-  #
-  # Integer#magnitude is an alias for Integer#abs.
-  #
-  def abs: () -> Integer
-
-  def abs2: () -> Integer
-
-  # Returns `true` if all bits of `int & mask` are 1.
-  #
-  def allbits?: (int mask) -> bool
-
-  def angle: () -> (Integer | Float)
-
-  # Returns `true` if any bits of `int & mask` are 1.
-  #
-  def anybits?: (int mask) -> bool
-
-  alias arg angle
-
-  # Returns the number of bits of the value of `int`.
-  #
-  # "Number of bits" means the bit position of the highest bit which 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), zero is returned.
-  #
-  # I.e. this method returns *ceil(log2(int < 0 ? -int : int+1))*.
-  #
-  #     (-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
-  #
-  # This method can be used to detect overflow in Array#pack as follows:
-  #
-  #     if n.bit_length < 32
-  #       [n].pack("l") # no overflow
-  #     else
-  #       raise "overflow"
-  #     end
-  #
-  def bit_length: () -> Integer
-
-  # Returns the smallest number greater than or equal to `int` with a precision of
-  # `ndigits` decimal digits (default: 0).
-  #
-  # When the precision is negative, the returned value is an integer with at least
-  # `ndigits.abs` trailing zeros.
-  #
-  # Returns `self` when `ndigits` is zero or positive.
-  #
-  #     1.ceil           #=> 1
-  #     1.ceil(2)        #=> 1
-  #     18.ceil(-1)      #=> 20
-  #     (-18).ceil(-1)   #=> -10
-  #
-  def ceil: () -> Integer
-          | (int digits) -> (Integer | Float)
-
-  # Returns a string containing the character represented by the `int`'s value
-  # according to `encoding`.
-  #
-  #     65.chr    #=> "A"
-  #     230.chr   #=> "\xE6"
-  #     255.chr(Encoding::UTF_8)   #=> "\u00FF"
-  #
-  def chr: (?Encoding | string) -> String
-
-  def clone: (?freeze: bool) -> self
-
-  # Returns an array with both a `numeric` and a `big` represented as Bignum
-  # objects.
-  #
-  # This is achieved by converting `numeric` to a Bignum.
-  #
-  # A TypeError is raised if the `numeric` is not a Fixnum or Bignum type.
-  #
-  #     (0x3FFFFFFFFFFFFFFF+1).coerce(42)   #=> [42, 4611686018427387904]
-  #
-  def coerce: (Numeric) -> [Numeric, Numeric]
-
-  def conj: () -> Integer
-
-  def conjugate: () -> Integer
-
-  # Returns 1.
-  #
-  def denominator: () -> Integer
-
-  # Returns the digits of `int`'s place-value representation with radix `base`
-  # (default: 10). The digits are returned as an array with the least significant
-  # digit as the first array element.
-  #
-  # `base` must be greater than or equal to 2.
-  #
-  #     12345.digits      #=> [5, 4, 3, 2, 1]
-  #     12345.digits(7)   #=> [4, 6, 6, 0, 5]
-  #     12345.digits(100) #=> [45, 23, 1]
-  #
-  #     -12345.digits(7)  #=> Math::DomainError
-  #
-  def digits: (?int base) -> ::Array[Integer]
-
-  # Performs integer division: returns the integer result of dividing `int` by
-  # `numeric`.
-  #
-  def div: (Numeric) -> Integer
-
-  # See Numeric#divmod.
-  #
-  def divmod: (Integer) -> [Integer, Integer]
-            | (Float) -> [Float, Float]
-            | (Numeric) -> [Numeric, Numeric]
-
-  # Iterates the given block, passing in decreasing values from `int` down to and
-  # including `limit`.
-  #
-  # If no block is given, an Enumerator is returned instead.
-  #
-  #     5.downto(1) { |n| print n, ".. " }
-  #     puts "Liftoff!"
-  #     #=> "5.. 4.. 3.. 2.. 1.. Liftoff!"
-  #
-  def downto: (Integer limit) { (Integer) -> void } -> Integer
-            | (Integer limit) -> ::Enumerator[Integer, self]
-
-  def dup: () -> self
-
-  def eql?: (untyped) -> bool
-
-  # Returns `true` if `int` is an even number.
-  #
-  def even?: () -> bool
-
-  # Returns the floating point result of dividing `int` by `numeric`.
-  #
-  #     654321.fdiv(13731)      #=> 47.652829364212366
-  #     654321.fdiv(13731.24)   #=> 47.65199646936475
-  #     -654321.fdiv(13731)     #=> -47.652829364212366
-  #
-  def fdiv: (Numeric) -> Float
-
-  def finite?: () -> bool
-
-  # Returns the largest number less than or equal to `int` with a precision of
-  # `ndigits` decimal digits (default: 0).
-  #
-  # When the precision is negative, the returned value is an integer with at least
-  # `ndigits.abs` trailing zeros.
-  #
-  # Returns `self` when `ndigits` is zero or positive.
-  #
-  #     1.floor           #=> 1
-  #     1.floor(2)        #=> 1
-  #     18.floor(-1)      #=> 10
-  #     (-18).floor(-1)   #=> -20
-  #
-  def floor: () -> Integer
-           | (int digits) -> (Integer | Float)
-
-  # 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) -> Integer
-
-  # 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) -> [ Integer, Integer ]
-
-  def i: () -> Complex
-
-  def imag: () -> Integer
-
-  def imaginary: () -> Integer
-
-  def infinite?: () -> Integer?
-
-  alias inspect to_s
-
-  # Since `int` is already an Integer, this always returns `true`.
-  #
-  def integer?: () -> true
-
-  # 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) -> Integer
-
-  # Returns the absolute value of `int`.
-  #
-  #     (-12345).abs   #=> 12345
-  #     -12345.abs     #=> 12345
-  #     12345.abs      #=> 12345
-  #
-  # Integer#magnitude is an alias for Integer#abs.
-  #
-  def magnitude: () -> Integer
-
-  # Returns `int` modulo `other`.
-  #
-  # See Numeric#divmod for more information.
-  #
-  alias modulo `%`
-
-  def negative?: () -> bool
-
-  # Returns the successor of `int`, i.e. the Integer equal to `int+1`.
-  #
-  #     1.next      #=> 2
-  #     (-1).next   #=> 0
-  #     1.succ      #=> 2
-  #     (-1).succ   #=> 0
-  #
-  def next: () -> Integer
-
-  # Returns `true` if no bits of `int & mask` are 1.
-  #
-  def nobits?: (int mask) -> bool
-
-  def nonzero?: () -> self?
-
-  # Returns self.
-  #
-  def numerator: () -> Integer
-
-  # Returns `true` if `int` is an odd number.
-  #
-  def odd?: () -> bool
-
-  # Returns the `int` itself.
-  #
-  #     97.ord   #=> 97
-  #
-  # This method is intended for compatibility to character literals in Ruby 1.9.
-  #
-  # For example, `?a.ord` returns 97 both in 1.8 and 1.9.
-  #
-  def ord: () -> Integer
-
-  alias phase angle
-
-  def polar: () -> [ Integer, Integer | Float ]
-
-  def positive?: () -> bool
-
-  # 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 modulo) -> Integer
-         | (Numeric numeric) -> Numeric
-
-  # Returns the predecessor of `int`, i.e. the Integer equal to `int-1`.
-  #
-  #     1.pred      #=> 0
-  #     (-1).pred   #=> -2
-  #
-  def pred: () -> Integer
-
-  def quo: (Integer) -> Rational
-         | (Float) -> Float
-         | (Rational) -> Rational
-         | (Complex) -> Complex
-         | (Numeric) -> Numeric
-
-  # Returns the value as a rational.  The optional argument `eps` is always
-  # ignored.
-  #
-  def rationalize: (?Numeric eps) -> Rational
-
-  def real: () -> self
-
-  def real?: () -> true
-
-  def rect: () -> [ Integer, Numeric ]
-
-  alias rectangular rect
-
-  # Returns the remainder after dividing `int` by `numeric`.
-  #
-  # `x.remainder(y)` means `x-y*(x/y).truncate`.
-  #
-  #     5.remainder(3)     #=> 2
-  #     -5.remainder(3)    #=> -2
-  #     5.remainder(-3)    #=> 2
-  #     -5.remainder(-3)   #=> -2
-  #     5.remainder(1.5)   #=> 0.5
-  #
-  # See Numeric#divmod.
-  #
-  def remainder: (Integer) -> Integer
-               | (Float) -> Float
-               | (Rational) -> Rational
-               | (Numeric) -> Numeric
-
-  # Returns `int` rounded to the nearest value with a precision of `ndigits`
-  # decimal digits (default: 0).
-  #
-  # When the precision is negative, the returned value is an integer with at least
-  # `ndigits.abs` trailing zeros.
-  #
-  # Returns `self` when `ndigits` is zero or positive.
-  #
-  #     1.round           #=> 1
-  #     1.round(2)        #=> 1
-  #     15.round(-1)      #=> 20
-  #     (-15).round(-1)   #=> -20
-  #
-  # The optional `half` keyword argument is available similar to Float#round.
-  #
-  #     25.round(-1, half: :up)      #=> 30
-  #     25.round(-1, half: :down)    #=> 20
-  #     25.round(-1, half: :even)    #=> 20
-  #     35.round(-1, half: :up)      #=> 40
-  #     35.round(-1, half: :down)    #=> 30
-  #     35.round(-1, half: :even)    #=> 40
-  #     (-25).round(-1, half: :up)   #=> -30
-  #     (-25).round(-1, half: :down) #=> -20
-  #     (-25).round(-1, half: :even) #=> -20
-  #
-  def round: (?half: :up | :down | :even) -> Integer
-           | (int digits, ?half: :up | :down | :even) -> (Integer | Float)
-
-  # Returns the number of bytes in the machine representation of `int` (machine
-  # 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
-
-  def step: () { (Integer) -> void } -> void
-          | (Numeric limit, ?Integer step) { (Integer) -> void } -> void
-          | (Numeric limit, ?Numeric step) { (Numeric) -> void } -> void
-          | (to: Numeric, ?by: Integer) { (Integer) -> void } -> void
-          | (?to: Numeric, by: Numeric) { (Numeric) -> void } -> void
-          | () -> Enumerator[Integer, bot]
-          | (Numeric limit, ?Integer step) -> Enumerator[Integer, void]
-          | (Numeric limit, ?Numeric step) -> Enumerator[Numeric, void]
-          | (to: Numeric, ?by: Integer) -> Enumerator[Integer, void]
-          | (?to: Numeric, by: Numeric) -> Enumerator[Numeric, void]
-
-  # Returns the successor of `int`, i.e. the Integer equal to `int+1`.
-  #
-  #     1.next      #=> 2
-  #     (-1).next   #=> 0
-  #     1.succ      #=> 2
-  #     (-1).succ   #=> 0
-  #
-  def succ: () -> Integer
-
-  # Iterates the given block `int` times, passing in values from zero to `int -
-  # 1`.
-  #
-  # If no block is given, an Enumerator is returned instead.
-  #
-  #     5.times {|i| print i, " " }   #=> 0 1 2 3 4
-  #
-  def times: () { (Integer) -> void } -> self
-           | () -> ::Enumerator[Integer, self]
-
-  def to_c: () -> Complex
-
-  # Converts `int` to a Float.  If `int` doesn't fit in a Float, the result is
-  # infinity.
-  #
-  def to_f: () -> Float
-
-  # Since `int` is already an Integer, returns `self`.
-  #
-  # #to_int is an alias for #to_i.
-  #
-  def to_i: () -> Integer
-
-  # Since `int` is already an Integer, returns `self`.
-  #
-  # #to_int is an alias for #to_i.
-  #
-  alias to_int to_i
-
-  # Returns the value as a rational.
-  #
-  #     1.to_r        #=> (1/1)
-  #     (1<<64).to_r  #=> (18446744073709551616/1)
-  #
-  def to_r: () -> Rational
-
-  # Returns a string containing the place-value representation of `int` with radix
-  # `base` (between 2 and 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"
-  #
-  def to_s: () -> String
-          | (2) -> String
-          | (3) -> String
-          | (4) -> String
-          | (5) -> String
-          | (6) -> String
-          | (7) -> String
-          | (8) -> String
-          | (9) -> String
-          | (10) -> String
-          | (11) -> String
-          | (12) -> String
-          | (13) -> String
-          | (14) -> String
-          | (15) -> String
-          | (16) -> String
-          | (17) -> String
-          | (18) -> String
-          | (19) -> String
-          | (20) -> String
-          | (21) -> String
-          | (22) -> String
-          | (23) -> String
-          | (24) -> String
-          | (25) -> String
-          | (26) -> String
-          | (27) -> String
-          | (28) -> String
-          | (29) -> String
-          | (30) -> String
-          | (31) -> String
-          | (32) -> String
-          | (33) -> String
-          | (34) -> String
-          | (35) -> String
-          | (36) -> String
-          | (int base) -> String
-
-  # Returns `int` truncated (toward zero) to a precision of `ndigits` decimal
-  # digits (default: 0).
-  #
-  # When the precision is negative, the returned value is an integer with at least
-  # `ndigits.abs` trailing zeros.
-  #
-  # Returns `self` when `ndigits` is zero or positive.
-  #
-  #     1.truncate           #=> 1
-  #     1.truncate(2)        #=> 1
-  #     18.truncate(-1)      #=> 10
-  #     (-18).truncate(-1)   #=> -10
-  #
-  def truncate: () -> Integer
-              | (int ndigits) -> Integer
-
-  # Iterates the given block, passing in integer values from `int` up to and
-  # including `limit`.
-  #
-  # If no block is given, an Enumerator is returned instead.
-  #
-  #     5.upto(10) {|i| print i, " " }   #=> 5 6 7 8 9 10
-  #
-  def upto: (Integer limit) { (Integer) -> void } -> Integer
-          | (Integer limit) -> ::Enumerator[Integer, self]
-
-  def zero?: () -> bool
-
-  # Bitwise OR.
-  #
-  def |: (Integer) -> Integer
-
-  # One's complement: returns a number where each bit is flipped.
-  #
-  # Inverts the bits in an Integer. As integers are 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