Class: Integer
Overview
This class is the basis for the two concrete classes that hold whole
numbers, Bignum and Fixnum.
Instance Method Summary collapse
-
#to_i ⇒ Integer
As
int
is already an Integer, all these methods simply return the receiver. -
#chr([encoding]) ⇒ String
Returns a string containing the character represented by the
int
‘s value according toencoding
. -
#denominator ⇒ 1
Returns 1.
-
#downto ⇒ Object
Iterates the given block, passing decreasing values from
int
down to and includinglimit
. -
#even? ⇒ Boolean
Returns
true
ifint
is an even number. -
#to_i ⇒ Integer
As
int
is already an Integer, all these methods simply return the receiver. -
#gcd(int2) ⇒ Integer
Returns the greatest common divisor (always positive).
-
#gcdlcm(int2) ⇒ Array
Returns an array; [int.gcd(int2), int.lcm(int2)].
-
#integer? ⇒ true
Since
int
is already an Integer, this always returnstrue
. -
#lcm(int2) ⇒ Integer
Returns the least common multiple (always positive).
- #next ⇒ Object
-
#numerator ⇒ self
Returns self.
-
#odd? ⇒ Boolean
Returns
true
ifint
is an odd number. -
#ord ⇒ self
Returns the
int
itself. - #pred ⇒ Object
-
#rationalize([eps]) ⇒ Object
Returns the value as a rational.
-
#round([ndigits]) ⇒ Integer, Float
Rounds
int
to a given precision in decimal digits (default 0 digits). - #succ ⇒ Object
-
#times ⇒ Object
Iterates the given block
int
times, passing in values from zero toint - 1
. -
#to_i ⇒ Integer
As
int
is already an Integer, all these methods simply return the receiver. -
#to_i ⇒ Integer
As
int
is already an Integer, all these methods simply return the receiver. -
#to_r ⇒ Object
Returns the value as a rational.
-
#to_i ⇒ Integer
As
int
is already an Integer, all these methods simply return the receiver. -
#upto ⇒ Object
Iterates the given block, passing in integer values from
int
up to and includinglimit
.
Methods inherited from Numeric
#%, #+@, #-@, #<=>, #abs, #abs2, #angle, #arg, #coerce, #conj, #conjugate, #div, #divmod, #eql?, #fdiv, #i, #imag, #imaginary, #initialize_copy, #magnitude, #modulo, #nonzero?, #phase, #polar, #quo, #real, #real?, #rect, #rectangular, #remainder, #singleton_method_added, #step, #to_c, #zero?
Methods included from Comparable
#<, #<=, #==, #>, #>=, #between?
Instance Method Details
#to_i ⇒ Integer
As int
is already an Integer, all these methods simply return the receiver.
Synonyms are #to_int, #floor, #ceil, #truncate.
2351 2352 2353 2354 2355 |
# File 'numeric.c', line 2351
static VALUE
int_to_i(VALUE num)
{
return num;
}
|
#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"
2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 |
# File 'numeric.c', line 2505
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) {
}
else if (FIXNUM_P(num)) {
rb_raise(rb_eRangeError, "%ld out of char range", FIX2LONG(num));
}
else {
rb_raise(rb_eRangeError, "bignum out of char range");
}
switch (argc) {
case 0:
if (0xff < i) {
enc = rb_default_internal_encoding();
if (!enc) {
rb_raise(rb_eRangeError, "%d out of char range", i);
}
goto decode;
}
c = (char)i;
if (i < 0x80) {
return rb_usascii_str_new(&c, 1);
}
else {
return rb_str_new(&c, 1);
}
case 1:
break;
default:
rb_check_arity(argc, 0, 1);
break;
}
enc = rb_to_encoding(argv[0]);
if (!enc) enc = rb_ascii8bit_encoding();
decode:
return rb_enc_uint_chr(i, enc);
}
|
#denominator ⇒ 1
Returns 1.
1889 1890 1891 1892 1893 |
# File 'rational.c', line 1889
static VALUE
integer_denominator(VALUE self)
{
return INT2FIX(1);
}
|
#downto(limit) {|i| ... } ⇒ self #downto(limit) ⇒ Object
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!"
3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 |
# File 'numeric.c', line 3620
static VALUE
int_downto(VALUE from, VALUE to)
{
RETURN_SIZED_ENUMERATOR(from, 1, &to, int_downto_size);
if (FIXNUM_P(from) && FIXNUM_P(to)) {
long i, end;
end = FIX2LONG(to);
for (i=FIX2LONG(from); i >= end; i--) {
rb_yield(LONG2FIX(i));
}
}
else {
VALUE i = from, c;
while (!(c = rb_funcall(i, '<', 1, to))) {
rb_yield(i);
i = rb_funcall(i, '-', 1, INT2FIX(1));
}
if (NIL_P(c)) rb_cmperr(i, to);
}
return from;
}
|
#even? ⇒ Boolean
Returns true
if int
is an even number.
2393 2394 2395 2396 2397 2398 2399 2400 |
# File 'numeric.c', line 2393
static VALUE
int_even_p(VALUE num)
{
if (rb_funcall(num, '%', 1, INT2FIX(2)) == INT2FIX(0)) {
return Qtrue;
}
return Qfalse;
}
|
#to_i ⇒ Integer
As int
is already an Integer, all these methods simply return the receiver.
Synonyms are #to_int, #floor, #ceil, #truncate.
2351 2352 2353 2354 2355 |
# File 'numeric.c', line 2351
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).
2.gcd(2) #=> 2
3.gcd(-7) #=> 1
((1<<31)-1).gcd((1<<61)-1) #=> 1
1744 1745 1746 1747 1748 1749 |
# File 'rational.c', line 1744
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)].
2.gcdlcm(2) #=> [2, 2]
3.gcdlcm(-7) #=> [1, 21]
((1<<31)-1).gcdlcm((1<<61)-1) #=> [1, 4951760154835678088235319297]
1779 1780 1781 1782 1783 1784 |
# File 'rational.c', line 1779
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
Since int
is already an Integer, this always returns true
.
2364 2365 2366 2367 2368 |
# File 'numeric.c', line 2364
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.
2.lcm(2) #=> 2
3.lcm(-7) #=> 21
((1<<31)-1).lcm((1<<61)-1) #=> 4951760154835678088235319297
1762 1763 1764 1765 1766 1767 |
# File 'rational.c', line 1762
VALUE
rb_lcm(VALUE self, VALUE other)
{
other = nurat_int_value(other);
return f_lcm(self, other);
}
|
#next ⇒ Object
#numerator ⇒ self
Returns self.
1877 1878 1879 1880 1881 |
# File 'rational.c', line 1877
static VALUE
integer_numerator(VALUE self)
{
return self;
}
|
#odd? ⇒ Boolean
Returns true
if int
is an odd number.
2377 2378 2379 2380 2381 2382 2383 2384 |
# File 'numeric.c', line 2377
static VALUE
int_odd_p(VALUE num)
{
if (rb_funcall(num, '%', 1, INT2FIX(2)) != INT2FIX(0)) {
return Qtrue;
}
return Qfalse;
}
|
#ord ⇒ 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.
2563 2564 2565 2566 2567 |
# File 'numeric.c', line 2563
static VALUE
int_ord(VALUE num)
{
return num;
}
|
#pred ⇒ Object
#rationalize([eps]) ⇒ Object
Returns the value as a rational. The optional argument eps is always ignored.
1980 1981 1982 1983 1984 1985 |
# File 'rational.c', line 1980
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 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
3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 |
# File 'numeric.c', line 3711
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);
}
if (ndigits == 0) {
return num;
}
return int_round_0(num, ndigits);
}
|
#succ ⇒ Object
#times {|i| ... } ⇒ self #times ⇒ Object
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
3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 |
# File 'numeric.c', line 3672
static VALUE
int_dotimes(VALUE num)
{
RETURN_SIZED_ENUMERATOR(num, 0, 0, int_dotimes_size);
if (FIXNUM_P(num)) {
long i, end;
end = FIX2LONG(num);
for (i=0; i<end; i++) {
rb_yield(LONG2FIX(i));
}
}
else {
VALUE i = INT2FIX(0);
for (;;) {
if (!RTEST(rb_funcall(i, '<', 1, num))) break;
rb_yield(i);
i = rb_funcall(i, '+', 1, INT2FIX(1));
}
}
return num;
}
|
#to_i ⇒ Integer
As int
is already an Integer, all these methods simply return the receiver.
Synonyms are #to_int, #floor, #ceil, #truncate.
2351 2352 2353 2354 2355 |
# File 'numeric.c', line 2351
static VALUE
int_to_i(VALUE num)
{
return num;
}
|
#to_i ⇒ Integer
As int
is already an Integer, all these methods simply return the receiver.
Synonyms are #to_int, #floor, #ceil, #truncate.
2351 2352 2353 2354 2355 |
# File 'numeric.c', line 2351
static VALUE
int_to_i(VALUE num)
{
return num;
}
|
#to_r ⇒ Object
Returns the value as a rational.
1.to_r #=> (1/1)
(1<<64).to_r #=> (18446744073709551616/1)
1967 1968 1969 1970 1971 |
# File 'rational.c', line 1967
static VALUE
integer_to_r(VALUE self)
{
return rb_rational_new1(self);
}
|
#to_i ⇒ Integer
As int
is already an Integer, all these methods simply return the receiver.
Synonyms are #to_int, #floor, #ceil, #truncate.
2351 2352 2353 2354 2355 |
# File 'numeric.c', line 2351
static VALUE
int_to_i(VALUE num)
{
return num;
}
|
#upto(limit) {|i| ... } ⇒ self #upto(limit) ⇒ Object
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
3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 |
# File 'numeric.c', line 3575
static VALUE
int_upto(VALUE from, VALUE to)
{
RETURN_SIZED_ENUMERATOR(from, 1, &to, int_upto_size);
if (FIXNUM_P(from) && FIXNUM_P(to)) {
long i, end;
end = FIX2LONG(to);
for (i = FIX2LONG(from); i <= end; i++) {
rb_yield(LONG2FIX(i));
}
}
else {
VALUE i = from, c;
while (!(c = rb_funcall(i, '>', 1, to))) {
rb_yield(i);
i = rb_funcall(i, '+', 1, INT2FIX(1));
}
if (NIL_P(c)) rb_cmperr(i, to);
}
return from;
}
|