# Class: Integer

Inherits:
Numeric
show all
Defined in:
numeric.c

## Overview

`Integer` is the basis for the two concrete classes that hold whole numbers, `Bignum` and `Fixnum`.

## Instance Method Summary collapse

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

• Returns a string containing the character represented by the receiver's value according to `encoding`.

• Returns 1.

• Iterates block, passing decreasing values from int down to and including limit.

• Returns `true` if int is an even number.

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

• Returns the greatest common divisor (always positive).

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

• Always returns `true`.

• Returns the least common multiple (always positive).

• Returns the `Integer` equal to int + 1.

• Returns self.

• Returns `true` if int is an odd number.

• Returns the int itself.

• Returns the `Integer` equal to int - 1.

• Returns the value as a rational.

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

• Returns the `Integer` equal to int + 1.

• Iterates block int times, passing in values from zero to int - 1.

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

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

• Returns the value as a rational.

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

• Iterates block, passing in integer values from int up to and including limit.

## Instance Method Details

### #to_i ⇒ Integer #to_int ⇒ Integer #floor ⇒ Integer #ceil ⇒ Integer #truncate ⇒ Integer

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

 ``` ``` ```# File 'numeric.c' static VALUE int_to_i(VALUE num) { return num; }```

### #chr([encoding]) ⇒ String

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

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

Returns:

 ``` ``` ```# File 'numeric.c' static VALUE int_chr(int argc, VALUE *argv, VALUE num) { char c; unsigned int i; rb_encoding *enc; if (rb_num_to_uint(num, &i) == 0) { }```

### #denominator ⇒ 1

Returns 1.

Returns:

• (1)
 ``` ``` ```# File 'rational.c' static VALUE integer_denominator(VALUE self) { return INT2FIX(1); }```

### #downto(limit) {|i| ... } ⇒ Integer #downto(limit) ⇒ Object

Iterates 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"
``````

produces:

``````5.. 4.. 3.. 2.. 1..   Liftoff!
``````

 ``` ``` ```# File 'numeric.c' static VALUE int_downto(VALUE from, VALUE to) { RETURN_ENUMERATOR(from, 1, &to); if (FIXNUM_P(from) && FIXNUM_P(to)) { long i, end; end = FIX2LONG(to); for (i=FIX2LONG(from); i >= end; i--) { rb_yield(LONG2FIX(i)); }```

### #even? ⇒ Boolean

Returns `true` if int is an even number.

Returns:

• (Boolean)
 ``` ``` ```# File 'numeric.c' static VALUE int_even_p(VALUE num) { if (rb_funcall(num, '%', 1, INT2FIX(2)) == INT2FIX(0)) { return Qtrue; }```

### #to_i ⇒ Integer #to_int ⇒ Integer #floor ⇒ Integer #ceil ⇒ Integer #truncate ⇒ Integer

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

 ``` ``` ```# File 'numeric.c' static VALUE int_to_i(VALUE num) { return num; }```

### #gcd(int2) ⇒ Integer

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

For example:

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

Returns:

 ``` ``` ```# File 'rational.c' VALUE rb_gcd(VALUE self, VALUE other) { other = nurat_int_value(other); return f_gcd(self, other); }```

### #gcdlcm(int2) ⇒ Array

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

For example:

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

Returns:

 ``` ``` ```# File 'rational.c' VALUE rb_gcdlcm(VALUE self, VALUE other) { other = nurat_int_value(other); return rb_assoc_new(f_gcd(self, other), f_lcm(self, other)); }```

### #integer? ⇒ true

Always returns `true`.

Returns:

• (true)
 ``` ``` ```# File 'numeric.c' static VALUE int_int_p(VALUE num) { return Qtrue; }```

### #lcm(int2) ⇒ Integer

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

For example:

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

Returns:

 ``` ``` ```# File 'rational.c' VALUE rb_lcm(VALUE self, VALUE other) { other = nurat_int_value(other); return f_lcm(self, other); }```

### #next ⇒ Integer #succ ⇒ Integer

Returns the `Integer` equal to int + 1.

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

 ``` ``` ```# File 'numeric.c' static VALUE int_succ(VALUE num) { if (FIXNUM_P(num)) { long i = FIX2LONG(num) + 1; return LONG2NUM(i); }```

### #numerator ⇒ Integer

Returns self.

Returns:

 ``` ``` ```# File 'rational.c' static VALUE integer_numerator(VALUE self) { return self; }```

### #odd? ⇒ Boolean

Returns `true` if int is an odd number.

Returns:

• (Boolean)
 ``` ``` ```# File 'numeric.c' static VALUE int_odd_p(VALUE num) { if (rb_funcall(num, '%', 1, INT2FIX(2)) != INT2FIX(0)) { return Qtrue; }```

### #ord ⇒ Integer

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:

 ``` ``` ```# File 'numeric.c' static VALUE int_ord(VALUE num) { return num; }```

### #pred ⇒ Integer

Returns the `Integer` equal to int - 1.

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

Returns:

 ``` ``` ```# File 'numeric.c' static VALUE int_pred(VALUE num) { if (FIXNUM_P(num)) { long i = FIX2LONG(num) - 1; return LONG2NUM(i); }```

### #rationalize([eps]) ⇒ Object

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

 ``` ``` ```# File 'rational.c' static VALUE integer_rationalize(int argc, VALUE *argv, VALUE self) { rb_scan_args(argc, argv, "01", NULL); return integer_to_r(self); }```

### #round([ndigits]) ⇒ Integer, Float

Rounds flt 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:

 ``` ``` ```# File 'numeric.c' static VALUE int_round(int argc, VALUE* argv, VALUE num) { VALUE n; int ndigits; if (argc == 0) return num; rb_scan_args(argc, argv, "1", &n); ndigits = NUM2INT(n); if (ndigits > 0) { return rb_Float(num); }```

### #next ⇒ Integer #succ ⇒ Integer

Returns the `Integer` equal to int + 1.

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

 ``` ``` ```# File 'numeric.c' static VALUE int_succ(VALUE num) { if (FIXNUM_P(num)) { long i = FIX2LONG(num) + 1; return LONG2NUM(i); }```

### #times {|i| ... } ⇒ Integer #times ⇒ Object

Iterates 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
``````

produces:

``````0 1 2 3 4
``````

 ``` ``` ```# File 'numeric.c' static VALUE int_dotimes(VALUE num) { RETURN_ENUMERATOR(num, 0, 0); if (FIXNUM_P(num)) { long i, end; end = FIX2LONG(num); for (i=0; i

### #to_i ⇒ Integer #to_int ⇒ Integer #floor ⇒ Integer #ceil ⇒ Integer #truncate ⇒ Integer

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

 ``` ``` ```# File 'numeric.c' static VALUE int_to_i(VALUE num) { return num; }```

### #to_i ⇒ Integer #to_int ⇒ Integer #floor ⇒ Integer #ceil ⇒ Integer #truncate ⇒ Integer

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

 ``` ``` ```# File 'numeric.c' static VALUE int_to_i(VALUE num) { return num; }```

### #to_r ⇒ Object

Returns the value as a rational.

For example:

``````1.to_r        #=> (1/1)
(1<<64).to_r  #=> (18446744073709551616/1)
``````
 ``` ``` ```# File 'rational.c' static VALUE integer_to_r(VALUE self) { return rb_rational_new1(self); }```

### #to_i ⇒ Integer #to_int ⇒ Integer #floor ⇒ Integer #ceil ⇒ Integer #truncate ⇒ Integer

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

 ``` ``` ```# File 'numeric.c' static VALUE int_to_i(VALUE num) { return num; }```

### #upto(limit) {|i| ... } ⇒ Integer #upto(limit) ⇒ Object

Iterates 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, " " }
``````

produces:

``````5 6 7 8 9 10
``````

 ``` ``` ```# File 'numeric.c' static VALUE int_upto(VALUE from, VALUE to) { RETURN_ENUMERATOR(from, 1, &to); if (FIXNUM_P(from) && FIXNUM_P(to)) { long i, end; end = FIX2LONG(to); for (i = FIX2LONG(from); i <= end; i++) { rb_yield(LONG2FIX(i)); }```