File Manager
# 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
# 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
# Performs addition: the class of the resulting object depends on the class of
# `numeric`.
#
def +: (Integer) -> Integer
| (Float) -> Float
| (Rational) -> Rational
| (Complex) -> Complex
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
# 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
# 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
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
| (Float) -> Float
| (Rational) -> Rational
| (Complex) -> Complex
# 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
File Manager Version 1.0, Coded By Lucas
Email: hehe@yahoo.com