Файловый менеджер

……&&*……%@#￥……%&*（（））*&……%￥#% Файловый менеджер

Файловый менеджер - Редактировать - /opt/puppetlabs/puppet/lib/ruby/gems/3.2.0/gems/rbs-2.8.2/core/integer.rbs

Назад
# <!-- rdoc-file=numeric.c --> # An Integer object represents an integer value. # # You can create an Integer object explicitly with: # # * An [integer # literal](doc/syntax/literals_rdoc.html#label-Integer+Literals). # # # You can convert certain objects to Integers with: # # * Method [Integer](Kernel.html#method-i-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](Numeric.html#class-Numeric-label-What-27s+Here). # # # Here, class Integer provides methods for: # # * [Querying](#class-Integer-label-Querying) # * [Comparing](#class-Integer-label-Comparing) # * [Converting](#class-Integer-label-Converting) # * [Other](#class-Integer-label-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 # # [<](#method-i-3C) # : Returns whether `self` is less than the given value. # # [<=](#method-i-3C-3D) # : Returns whether `self` is less than or equal to the given value. # # [<=>](#method-i-3C-3D-3E) # : Returns a number indicating whether `self` is less than, equal to, or # greater than the given value. # # [==](#method-i-3D-3D) (aliased as #===) # : Returns whether `self` is equal to the given value. # # [>](#method-i-3E) # : Returns whether `self` is greater than the given value. # # [>=](#method-i-3E-3D) # : 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. # # [&](#method-i-26) # : Returns the bitwise AND of `self` and the given value. # # #* # : Returns the product of `self` and the given value. # # [](#method-i-2A-2A) # : 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. # # [/](#method-i-2F) # : 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`. # # [^](#method-i-5E) # : Returns the bitwise EXCLUSIVE 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. # # [/](#method-i-7C) # : Returns the bitwise OR of `self` and the given value. # # # # ### 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 `(0..self-1)`. # # #upto # : Calls the given block with each integer value from `self` up to the # given value. # class Integer < Numeric # <!-- # 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(10400) # => 10200 # # 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 `Math.sqrt(numeric).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(1046) # => 100000000000000000000000 # Math.sqrt(10*46).floor # => 99999999999999991611392 # # Raises an exception if `numeric` is negative. # def self.sqrt: (int n) -> Integer # <!-- # rdoc-file=numeric.rb # - 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 `:to_int`, calls `object.to_int` and returns # the result. # Integer.try_convert(1.25) # => 1 # # Returns `nil` if `object` does not respond to `:to_int` # Integer.try_convert([]) # => nil # # Raises an exception unless `object.to_int` returns an Integer object. # def self.try_convert: (int) -> Integer \| (untyped) -> Integer? public # <!-- # rdoc-file=numeric.c # - self % other -> real_number # --> # Returns `self` modulo `other` as a real number. # # 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) # # Integer#modulo is an alias for Integer#%. # 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 * numeric -> numeric_result # --> # Performs multiplication: # # 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 * numeric -> numeric_result # --> # Raises `self` to the power of `numeric`: # # 2 3 # => 8 # 2 -3 # => (1/8) # -2 3 # => -8 # -2 -3 # => (-1/8) # 2 3.3 # => 9.849155306759329 # 2 Rational(3, 1) # => (8/1) # 2 Complex(3, 0) # => (8+0i) # def : (Integer) -> Numeric \| (Float) -> Numeric \| (Rational) -> Numeric \| (Complex) -> Complex # <!-- # rdoc-file=numeric.c # - self + numeric -> numeric_result # --> # Performs addition: # # 2 + 2 # => 4 # -2 + 2 # => 0 # -2 + -2 # => -4 # 2 + 2.0 # => 4.0 # 2 + Rational(2, 1) # => (4/1) # 2 + Complex(2, 0) # => (4+0i) # def +: (Integer) -> Integer \| (Float) -> Float \| (Rational) -> Rational \| (Complex) -> Complex def +@: () -> Integer # <!-- # rdoc-file=numeric.c # - self - numeric -> numeric_result # --> # Performs subtraction: # # 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 # - -int -> integer # --> # Returns `int`, negated. # def -@: () -> Integer # <!-- # rdoc-file=numeric.c # - self / numeric -> numeric_result # --> # Performs division; for integer `numeric`, truncates the result to an integer: # # 4 / 3 # => 1 # 4 / -3 # => -2 # -4 / 3 # => -2 # -4 / -3 # => 1 # # For other +numeric+, returns 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 `true` if the value of `self` is less than that of `other`: # # 1 < 0 # => false # 1 < 1 # => false # 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 << 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 <= real -> true or false # --> # Returns `true` if the value of `self` is less than or equal to that of # `other`: # # 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 # --> # Returns: # # * -1, 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 <=> 0 # => 1 # 1 <=> 'foo' # => nil # # 1 <=> 1.0 # => 0 # 1 <=> Rational(1, 1) # => 0 # 1 <=> Complex(1, 0) # => 0 # # This method is the basis for comparisons in module Comparable. # 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). # # Integer#=== is an alias for Integer#==. # def ==: (untyped) -> 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). # # Integer#=== is an alias for Integer#==. # def ===: (untyped) -> bool # <!-- # 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, `n[i]` is equivalent to `(n >> i) & 1`. 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 `range.size` bits from `self`, beginning at # `range.begin` 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 # - int.abs -> integer # - int.magnitude -> 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 # <!-- # 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 def angle: () -> (Integer \| Float) # <!-- # 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 # - int.bit_length -> integer # --> # 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)). # # (-21000-1).bit_length #=> 1001 # (-21000).bit_length #=> 1000 # (-21000+1).bit_length #=> 1000 # (-212-1).bit_length #=> 13 # (-212).bit_length #=> 12 # (-212+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 # (212-1).bit_length #=> 12 # (212).bit_length #=> 13 # (212+1).bit_length #=> 13 # (21000-1).bit_length #=> 1000 # (21000).bit_length #=> 1001 # (21000+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 # <!-- # rdoc-file=numeric.c # - ceil(ndigits = 0) -> integer # --> # Returns the smallest number greater than or equal to `self` with a precision # of `ndigits` decimal digits. # # When the precision is negative, the returned value is an integer with at least # `ndigits.abs` trailing zeros: # # 555.ceil(-1) # => 560 # 555.ceil(-2) # => 600 # -555.ceil(-2) # => -500 # 555.ceil(-3) # => 1000 # # Returns `self` when `ndigits` is zero or positive. # # 555.ceil # => 555 # 555.ceil(50) # => 555 # # Related: Integer#floor. # def ceil: () -> Integer \| (int digits) -> (Integer \| Float) # <!-- # 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) -> String # <!-- # rdoc-file=bignum.c # - big.coerce(numeric) -> array # --> # 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 # <!-- # rdoc-file=rational.c # - int.denominator -> 1 # --> # Returns 1. # def denominator: () -> Integer # <!-- # 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 `[q, r]`, 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) -> [ Float, Float ] \| (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] def dup: () -> self def eql?: (untyped) -> bool # <!-- # rdoc-file=numeric.rb # - int.even? -> true or false # --> # Returns `true` if `int` is an even number. # 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 def finite?: () -> bool # <!-- # rdoc-file=numeric.c # - floor(ndigits = 0) -> integer # --> # Returns the largest number less than or equal to `self` with a precision of # `ndigits` decimal digits. # # When `ndigits` is negative, the returned value has at least `ndigits.abs` # trailing zeros: # # 555.floor(-1) # => 550 # 555.floor(-2) # => 500 # -555.floor(-2) # => -600 # 555.floor(-3) # => 0 # # Returns `self` when `ndigits` is zero or positive. # # 555.floor # => 555 # 555.floor(50) # => 555 # # 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) -> 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) -> [ Integer, Integer ] def i: () -> Complex def imag: () -> Integer def imaginary: () -> Integer def infinite?: () -> 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. # # Integer#inspect is an alias for Integer#to_s. # alias inspect to_s # <!-- # rdoc-file=numeric.rb # - int.integer? -> true # --> # Since `int` is already an Integer, this 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) -> Integer # <!-- # rdoc-file=numeric.rb # - magnitude() # --> # def magnitude: () -> Integer # <!-- rdoc-file=numeric.c --> # Returns `self` modulo `other` as a real number. # # 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) # # Integer#modulo is an alias for Integer#%. # alias modulo % def negative?: () -> bool # <!-- rdoc-file=numeric.c --> # Returns the successor integer of `self` (equivalent to `self + 1`): # # 1.succ #=> 2 # -1.succ #=> 0 # # Integer#next is an alias for Integer#succ. # # Related: Integer#pred (predecessor value). # def next: () -> Integer # <!-- # 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 def nonzero?: () -> self? # <!-- # rdoc-file=rational.c # - int.numerator -> self # --> # Returns self. # def numerator: () -> Integer # <!-- # rdoc-file=numeric.rb # - int.odd? -> true or false # --> # Returns `true` if `int` is an odd number. # def odd?: () -> bool # <!-- # rdoc-file=numeric.rb # - int.ord -> self # --> # 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 # <!-- # rdoc-file=numeric.c # - integer.pow(numeric) -> numeric # - integer.pow(integer, integer) -> integer # --> # Returns (modular) exponentiation as: # # a.pow(b) #=> same as ab # a.pow(b, m) #=> same as (ab) % m, but avoids huge temporary values # def pow: (Integer other, ?Integer modulo) -> Integer \| (Float) -> Float \| (Rational) -> Rational \| (Complex) -> Complex # <!-- # rdoc-file=numeric.c # - pred -> next_integer # --> # Returns the predecessor of `self` (equivalent to `self - 1`): # # 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 real: () -> self def real?: () -> true def rect: () -> [ Integer, Numeric ] alias rectangular rect # <!-- # 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 `ndigits.abs` # 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: # # `:up` or `nil`: round away from zero: # # 25.round(-1, half: :up) # => 30 # (-25).round(-1, half: :up) # => -30 # # * `:down`: round toward zero: # # 25.round(-1, half: :down) # => 20 # (-25).round(-1, half: :down) # => -20 # # * `:even`: 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: (?half: :up \| :down \| :even) -> Integer \| (int digits, ?half: :up \| :down \| :even) -> (Integer \| Float) # <!-- # rdoc-file=numeric.rb # - int.size -> int # --> # Document-method: Integer#size # # Returns the number of bytes in the machine representation of `int` (machine # dependent). # # 1.size #=> 8 # -1.size #=> 8 # 2147483647.size #=> 8 # (25610 - 1).size #=> 10 # (25620 - 1).size #=> 20 # (25640 - 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 \| (by: Numeric, ?to: 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] \| (by: Numeric, ?to: Numeric) -> Enumerator[Numeric, void] # <!-- # rdoc-file=numeric.c # - succ -> next_integer # --> # Returns the successor integer of `self` (equivalent to `self + 1`): # # 1.succ #=> 2 # -1.succ #=> 0 # # Integer#next is an alias for Integer#succ. # # Related: Integer#pred (predecessor value). # def succ: () -> Integer # <!-- # rdoc-file=numeric.c # - times {\|i\| ... } -> self # - times -> enumerator # --> # Calls the given block `self` times with each integer in `(0..self-1)`: # # a = [] # 5.times {\|i\| a.push(i) } # => 5 # a # => [0, 1, 2, 3, 4] # # With no block given, returns an Enumerator. # def times: () { (Integer) -> void } -> self \| () -> ::Enumerator[Integer, self] def to_c: () -> Complex # <!-- # 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: # # (10400).to_f # => Infinity # (-10**400).to_f # => -Infinity # def to_f: () -> Float # <!-- # rdoc-file=numeric.rb # - int.to_i -> integer # --> # Since `int` is already an Integer, returns `self`. # # #to_int is an alias for #to_i. # def to_i: () -> Integer # <!-- # rdoc-file=numeric.rb # - int.to_int -> integer # --> # Since `int` is already an Integer, returns `self`. # 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. # # Integer#inspect is an alias for Integer#to_s. # 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 # <!-- # 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 `ndigits.abs` # 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: () -> Integer \| (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 # - int.zero? -> true or false # --> # Returns `true` if `int` has a zero value. # 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 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