123456789_123456789_123456789_123456789_123456789_

Class: Integer

Relationships & Source Files
Extension / Inclusion / Inheritance Descendants
Subclasses:
Super Chains via Extension / Inclusion / Inheritance
Class Chain:
self, ::Numeric
Instance Chain:
Inherits: Numeric
Defined in: numeric.c,
rational.c

Overview

This class is the basis for the two concrete classes that hold whole numbers, ::Bignum and ::Fixnum.

Instance Attribute Summary

::Numeric - Inherited

#integer?

Returns true if num is an Integer (including ::Fixnum and ::Bignum).

#nonzero?

Returns self if num is not zero, nil otherwise.

#real

Returns self.

#real?

Returns true if num is a Real number.

#zero?

Returns true if num has a zero value.

Instance Method Summary

::Numeric - Inherited

#%

x.modulo(y) means x-y*(x/y).floor.

#+@

Unary Plus—Returns the receiver's value.

#-@

Unary Minus—Returns the receiver's value, negated.

#<=>

Returns zero if number equals other, otherwise nil is returned if the two values are incomparable.

#abs

Returns the absolute value of num.

#abs2

Returns square of self.

#angle

Alias for Numeric#arg.

#arg

Returns 0 if the value is positive, pi otherwise.

#ceil

Returns the smallest possible Integer that is greater than or equal to num.

#coerce

If a +numeric is the same type as num, returns an array containing numeric and num.

#conj

Returns self.

#conjugate

Alias for Numeric#conj.

#denominator

Returns the denominator (always positive).

#div

Uses / to perform division, then converts the result to an integer.

#divmod

Returns an array containing the quotient and modulus obtained by dividing num by numeric.

#eql?

Returns true if num and numeric are the same type and have equal values.

#fdiv

Returns float division.

#floor

Returns the largest integer less than or equal to num.

#i

Returns the corresponding imaginary number.

#imag

Returns zero.

#imaginary

Alias for Numeric#imag.

#initialize_copy

Numerics are immutable values, which should not be copied.

#magnitude

Alias for Numeric#abs.

#modulo

Alias for Numeric#%.

#numerator

Returns the numerator.

#phase

Alias for Numeric#arg.

#polar

Returns an array; [num.abs, num.arg].

#quo

Returns most exact division (rational for integers, float for floats).

#rect

Returns an array; [num, 0].

#rectangular

Alias for Numeric#rect.

#remainder

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

#round

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

#singleton_method_added

Trap attempts to add methods to ::Numeric objects.

#step

Invokes the given block with the sequence of numbers starting at num, incremented by step (defaulted to 1) on each call.

#to_c

Returns the value as a complex.

#to_int

Invokes the child class's #to_i method to convert num to an integer.

#truncate

Returns num truncated to an Integer.

::Comparable - Included

#<

Compares two objects based on the receiver's <=> method, returning true if it returns -1.

#<=

Compares two objects based on the receiver's <=> method, returning true if it returns -1 or 0.

#==

Compares two objects based on the receiver's <=> method, returning true if it returns 0.

#>

Compares two objects based on the receiver's <=> method, returning true if it returns 1.

#>=

Compares two objects based on the receiver's <=> method, returning true if it returns 0 or 1.

#between?

Returns false if obj <=> min is less than zero or if anObject <=> max is greater than zero, true otherwise.

Instance Attribute Details

#even?Boolean (readonly)

Returns true if int is an even number.

#integer?Boolean (readonly)

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

#odd?Boolean (readonly)

Returns true if int is an odd number.

Instance Method Details

#to_iInteger #ceilInteger

Alias for #to_i.

#chr([encoding]) ⇒ String

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"

#denominator1

Returns 1.

#downto(limit) {|i| ... } ⇒ self #downto(limit) ⇒ Enumerator

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!"

#to_iInteger #floorInteger

Alias for #to_i.

#gcd(int2) ⇒ Integer

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

#gcdlcm(int2) ⇒ Array

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]

#lcm(int2) ⇒ Integer

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

#nextInteger #succInteger
Also known as: #succ

Returns the Integer equal to int + 1, same as Fixnum#next.

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

#numeratorself

Returns self.

#ordself

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.

#predInteger

Returns the Integer equal to int - 1.

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

#rationalize([eps]) ⇒ Rational

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

#round([ndigits]) ⇒ Integer, Float

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

#nextInteger #succInteger

Alias for #next.

#times {|i| ... } ⇒ self #timesEnumerator

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

#to_iInteger Also known as: #to_int, #floor, #ceil, #truncate

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

Synonyms are #to_int, #floor, #ceil, #truncate.

#to_iInteger #to_intInteger

Alias for #to_i.

#to_rRational

Returns the value as a rational.

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

#to_iInteger #truncateInteger

Alias for #to_i.

#upto(limit) {|i| ... } ⇒ self #upto(limit) ⇒ Enumerator

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