Class: Integer

Since int is already an Integer, this always returns true.

Returns true if int is an odd number.

Bitwise AND.

Performs multiplication: the class of the resulting object depends on the class of numeric and on the magnitude of the result. It may return a Bignum.

Raises integer to the power of numeric, which may be negative or fractional. The result may be an Integer, or a ::Float

2 ** 3      #=> 8
2 ** -1     #=> (1/2)
2 ** 0.5    #=> 1.4142135623731

123456789 ** 2      #=> 15241578750190521
123456789 ** 1.2    #=> 5126464716.09932
123456789 ** -2     #=> (1/15241578750190521)

Performs addition: the class of the resulting object depends on the class of numeric and on the magnitude of the result. It may return a Bignum.

Performs subtraction: the class of the resulting object depends on the class of numeric and on the magnitude of the result. It may return a Bignum.

Negates int. (returns an integer whose value is 0-int)

Performs division: the class of the resulting object depends on the class of numeric and on the magnitude of the result. It may return a Bignum.

Returns true if the value of int is less than that of real.

Shifts int left count positions, or right if count is negative.

Returns true if the value of int is less than or equal to that of real.

Comparison—Returns -1, 0, +1 or nil 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.

Alias for #==.

Returns true if the value of int is greater than that of real.

Returns true if the value of int is greater than or equal to that of real.

Shifts int right count positions, or left if count is negative.

Bit Reference—Returns the nth bit in the binary representation of int, where int[0] is the least significant bit.

For example:

a = 0b11001100101010
30.downto(0) do |n| print a[n] end
#=> 0000000000000000011001100101010

a = 9**15
50.downto(0) do |n|
  print a[n]
end
#=> 000101110110100000111000011110010100111100010111001

Bitwise EXCLUSIVE OR.

Returns the absolute value of int.

-12345.abs   #=> 12345
12345.abs    #=> 12345
-1234567890987654321.abs   #=> 1234567890987654321

Returns the number of bits of the value of int.

“the number of bits” means that the bit position of the highest bit which is different to the sign bit. (The bit position of the bit 2**n is n+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**10000-1).bit_length  #=> 10001
(-2**10000).bit_length    #=> 10000
(-2**10000+1).bit_length  #=> 10000
(-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
(2**10000-1).bit_length   #=> 10000
(2**10000).bit_length     #=> 10001
(2**10000+1).bit_length   #=> 10001

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

Returns the smallest number than or equal to int in decimal digits (default 0 digits).

Precision may be negative. Returns a floating point number when ndigits is positive, self for zero, and ceil up for negative.

1.ceil        #=> 1
1.ceil(2)     #=> 1.0
15.ceil(-1)   #=> 20

Returns a string containing the character represented by the int's value according to encoding.

65.chr    #=> "A"
230.chr   #=> "\346"
255.chr(Encoding::UTF_8)   #=> "\303\277"

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]

Returns 1.

Returns the array including the digits extracted by place-value notation with radix base of int.

base should 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

Performs integer division: returns integer result of dividing int by numeric.

See Numeric#divmod.

Iterates the given block, passing 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, ".. " }
print "  Liftoff!\n"
#=> "5.. 4.. 3.. 2.. 1..   Liftoff!"

Returns the floating point result of dividing integer by numeric.

654321.fdiv(13731)      #=> 47.6528293642124
654321.fdiv(13731.24)   #=> 47.6519964693647

-1234567890987654321.fdiv(13731)      #=> -89910996357705.5
-1234567890987654321.fdiv(13731.24)   #=> -89909424858035.7

Returns the largest number less than or equal to int in decimal digits (default 0 digits).

Precision may be negative. Returns a floating point number when ndigits is positive, self for zero, and floor down for negative.

1.floor        #=> 1
1.floor(2)     #=> 1.0
15.floor(-1)   #=> 10

Returns the greatest common divisor (always positive). 0.gcd(x) and x.gcd(0) return abs(x).

2.gcd(2)                    #=> 2
3.gcd(-7)                   #=> 1
((1<<31)-1).gcd((1<<61)-1)  #=> 1

Returns an array; [int.gcd(int2), int.lcm(int2)].

2.gcdlcm(2)                    #=> [2, 2]
3.gcdlcm(-7)                   #=> [1, 21]
((1<<31)-1).gcdlcm((1<<61)-1)  #=> [1, 4951760154835678088235319297]

Alias for #to_s.

Returns the least common multiple (always positive). 0.lcm(x) and x.lcm(0) return zero.

2.lcm(2)                    #=> 2
3.lcm(-7)                   #=> 21
((1<<31)-1).lcm((1<<61)-1)  #=> 4951760154835678088235319297

Alias for #abs.

Alias for #%.

Returns the Integer equal to int + 1.

1.next      #=> 2
(-1).next   #=> 0
1.succ      #=> 2
(-1).succ   #=> 0

Returns self.

Returns the int itself.

?a.ord    #=> 97

This method is intended for compatibility to character constant in Ruby 1.9.

For example, ?a.ord returns 97 both in 1.8 and 1.9.

Returns the Integer equal to int - 1.

1.pred      #=> 0
(-1).pred   #=> -2

Returns the value as a rational. The optional argument eps is always ignored.

Returns the remainder after dividing big by numeric as:

x.remainder(y) means x-y*(x/y).truncate

Examples

5.remainder(3)    #=> 2
-5.remainder(3)   #=> -2
5.remainder(-3)   #=> 2
-5.remainder(-3)  #=> -2

-1234567890987654321.remainder(13731)      #=> -6966
-1234567890987654321.remainder(13731.24)   #=> -9906.22531493148

See Numeric#divmod.

Rounds int to a given precision in decimal digits (default 0 digits).

Precision may be negative. Returns a floating point number when ndigits is positive, self for zero, and round down for negative.

1.round        #=> 1
1.round(2)     #=> 1.0
15.round(-1)   #=> 20

Returns the number of bytes in the machine representation of int.

1.size            #=> 4
-1.size           #=> 4
2147483647.size   #=> 4
(256**10 - 1).size   #=> 12
(256**20 - 1).size   #=> 20
(256**40 - 1).size   #=> 40

Alias for #next.

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 do |i|
  print i, " "
end
#=> 0 1 2 3 4

Converts int to a ::Float. If int doesn't fit in a ::Float, the result is infinity.

As int is already an Integer, all these methods simply return the receiver.

Synonyms is #to_int

Alias for #to_i.

Returns the value as a rational.

1.to_r        #=> (1/1)
(1<<64).to_r  #=> (18446744073709551616/1)

Returns a string containing the representation of int 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"

Returns the smallest number than or equal to int in decimal digits (default 0 digits).

Precision may be negative. Returns a floating point number when ndigits is positive, self for zero, and truncate up for negative.

1.truncate        #=> 1
1.truncate(2)     #=> 1.0
15.truncate(-1)   #=> 10

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.

For example:

5.upto(10) { |i| print i, " " }
#=> 5 6 7 8 9 10

Bitwise OR.

One's complement: returns a number where each bit is flipped.

Inverts the bits in an integer. As Integers are conceptually 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"