class Integer

Parent:: Numeric

BigDecimal extends the native Integer class to provide the to_d method.

When you require the BigDecimal library in your application, this methodwill be available on Integer objects.

Add double dispatch to Integer

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

Public Class Methods

each_prime(ubound) { |prime| ... } Show source

# File lib/prime.rb, line 40
def Integer.each_prime(ubound, &block) # :yields: prime
  Prime.each(ubound, &block)
end

Iterates the given block over all prime numbers.

See Prime#each for more details.

from_prime_division(pd) Show source

# File lib/prime.rb, line 21
def Integer.from_prime_division(pd)
  Prime.int_from_prime_division(pd)
end

Re-composes a prime factorization and returns the product.

See Prime#int_from_prime_division for more details.

Public Instance Methods

to_i → integer Show source

static VALUE
int_to_i(VALUE num)
{
    return num;
}

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

Synonyms are to_int, floor, ceil, truncate.

chr([encoding]) → string Show source

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);
}

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"

denominator → 1 Show source

static VALUE
integer_denominator(VALUE self)
{
    return INT2FIX(1);
}

Returns 1.

downto(limit) {|i| block } → self Show source

downto(limit) → an_enumerator

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;
}

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

even? → true or false Show source

static VALUE
int_even_p(VALUE num)
{
    if (rb_funcall(num, '%', 1, INT2FIX(2)) == INT2FIX(0)) {
        return Qtrue;
    }
    return Qfalse;
}

Returns true if int is an even number.

to_i → integer Show source

static VALUE
int_to_i(VALUE num)
{
    return num;
}

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

Synonyms are to_int, floor, ceil, truncate.

gcd(int2) → integer Show source

VALUE
rb_gcd(VALUE self, VALUE other)
{
    other = nurat_int_value(other);
    return f_gcd(self, other);
}

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 Show source

VALUE
rb_gcdlcm(VALUE self, VALUE other)
{
    other = nurat_int_value(other);
    return rb_assoc_new(f_gcd(self, other), f_lcm(self, other));
}

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]

integer? → true Show source

static VALUE
int_int_p(VALUE num)
{
    return Qtrue;
}

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

lcm(int2) → integer Show source

VALUE
rb_lcm(VALUE self, VALUE other)
{
    other = nurat_int_value(other);
    return f_lcm(self, other);
}

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

next → integer Show source

VALUE
rb_int_succ(VALUE num)
{
    if (FIXNUM_P(num)) {
        long i = FIX2LONG(num) + 1;
        return LONG2NUM(i);
    }
    if (RB_TYPE_P(num, T_BIGNUM)) {
        return rb_big_plus(num, INT2FIX(1));
    }
    return rb_funcall(num, '+', 1, INT2FIX(1));
}

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

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

numerator → self Show source

static VALUE
integer_numerator(VALUE self)
{
    return self;
}

Returns self.

odd? → true or false Show source

static VALUE
int_odd_p(VALUE num)
{
    if (rb_funcall(num, '%', 1, INT2FIX(2)) != INT2FIX(0)) {
        return Qtrue;
    }
    return Qfalse;
}

Returns true if int is an odd number.

ord → self Show source

static VALUE
int_ord(VALUE num)
{
    return num;
}

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.

pred → integer Show source

VALUE
rb_int_pred(VALUE num)
{
    if (FIXNUM_P(num)) {
        long i = FIX2LONG(num) - 1;
        return LONG2NUM(i);
    }
    if (RB_TYPE_P(num, T_BIGNUM)) {
        return rb_big_minus(num, INT2FIX(1));
    }
    return rb_funcall(num, '-', 1, INT2FIX(1));
}

Returns the Integer equal to int - 1.

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

prime?() Show source

# File lib/prime.rb, line 33
def prime?
  Prime.prime?(self)
end

Returns true if self is a prime number, else returns false.

prime_division(generator = Prime::Generator23.new) Show source

# File lib/prime.rb, line 28
def prime_division(generator = Prime::Generator23.new)
  Prime.prime_division(self, generator)
end

Returns the factorization of self.

See Prime#prime_division for more details.

rationalize([eps]) → rational Show source

static VALUE
integer_rationalize(int argc, VALUE *argv, VALUE self)
{
    rb_scan_args(argc, argv, "01", NULL);
    return integer_to_r(self);
}

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

round([ndigits]) → integer or float Show source

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);
}

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

succ → integer Show source

VALUE
rb_int_succ(VALUE num)
{
    if (FIXNUM_P(num)) {
        long i = FIX2LONG(num) + 1;
        return LONG2NUM(i);
    }
    if (RB_TYPE_P(num, T_BIGNUM)) {
        return rb_big_plus(num, INT2FIX(1));
    }
    return rb_funcall(num, '+', 1, INT2FIX(1));
}

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

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

times {|i| block } → self Show source

times → an_enumerator

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;
}

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_bn() Show source

# File ext/openssl/lib/openssl/bn.rb, line 41
def to_bn
  OpenSSL::BN::new(self)
end

Casts an Integer as an OpenSSL::BN

See `man bn` for more info.

to_d → bigdecimal Show source

# File ext/bigdecimal/lib/bigdecimal/util.rb, line 17
def to_d
  BigDecimal(self)
end

Convert int to a BigDecimal and return it.

require 'bigdecimal'
require 'bigdecimal/util'

42.to_d
# => #<BigDecimal:1008ef070,'0.42E2',9(36)>

to_i → integer Show source

static VALUE
int_to_i(VALUE num)
{
    return num;
}

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

Synonyms are to_int, floor, ceil, truncate.

to_i → integer Show source

static VALUE
int_to_i(VALUE num)
{
    return num;
}

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

Synonyms are to_int, floor, ceil, truncate.

to_r → rational Show source

static VALUE
integer_to_r(VALUE self)
{
    return rb_rational_new1(self);
}

Returns the value as a rational.

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

to_i → integer Show source

static VALUE
int_to_i(VALUE num)
{
    return num;
}

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

Synonyms are to_int, floor, ceil, truncate.

upto(limit) {|i| block } → self Show source

upto(limit) → an_enumerator

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;
}

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

Ruby Core © 1993–2017 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.

Docs

Docs4dev

Title here

class Integer

Public Class Methods

Public Instance Methods