class Integer

Parent:
Numeric

Holds Integer values. You cannot add a singleton method to an Integer object, any attempt to do so will raise a TypeError.

Constants

GMP_VERSION

The version of loaded GMP.

Public Class Methods

each_prime(ubound) { |prime| ... } Show source 
# File lib/prime.rb, line 49
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 22
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.

sqrt(n) → integer Show source 
static VALUE
rb_int_s_isqrt(VALUE self, VALUE num)
{
    unsigned long n, sq;
    num = rb_to_int(num);
    if (FIXNUM_P(num)) {
        if (FIXNUM_NEGATIVE_P(num)) {
            domain_error("isqrt");
        }
        n = FIX2ULONG(num);
        sq = rb_ulong_isqrt(n);
        return LONG2FIX(sq);
    }
    else {
        size_t biglen;
        if (RBIGNUM_NEGATIVE_P(num)) {
            domain_error("isqrt");
        }
        biglen = BIGNUM_LEN(num);
        if (biglen == 0) return INT2FIX(0);
#if SIZEOF_BDIGIT <= SIZEOF_LONG
        /* short-circuit */
        if (biglen == 1) {
            n = BIGNUM_DIGITS(num)[0];
            sq = rb_ulong_isqrt(n);
            return ULONG2NUM(sq);
        }
#endif
        return rb_big_isqrt(num);
    }
}

Returns the integer square root of the non-negative integer n, i.e. the largest non-negative integer less than or equal to the square root of n.

Integer.sqrt(0)        #=> 0
Integer.sqrt(1)        #=> 1
Integer.sqrt(24)       #=> 4
Integer.sqrt(25)       #=> 5
Integer.sqrt(10**400)  #=> 10**200

Equivalent to Math.sqrt(n).floor, except that the result of the latter code may differ from the true value due to the limited precision of floating point arithmetic.

Integer.sqrt(10**46)     #=> 100000000000000000000000
Math.sqrt(10**46).floor  #=>  99999999999999991611392 (!)

If n is not an Integer, it is converted to an Integer first. If n is negative, a Math::DomainError is raised.

Public Instance Methods

int % other → real Show source 
VALUE
rb_int_modulo(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_mod(x, y);
    }
    else if (RB_TYPE_P(x, T_BIGNUM)) {
        return rb_big_modulo(x, y);
    }
    return num_modulo(x, y);
}

Returns int modulo other.

See Numeric#divmod for more information.

int & other_int → integer Show source 
VALUE
rb_int_and(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_and(x, y);
    }
    else if (RB_TYPE_P(x, T_BIGNUM)) {
        return rb_big_and(x, y);
    }
    return Qnil;
}

Bitwise AND.

int * numeric → numeric_result Show source 
VALUE
rb_int_mul(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_mul(x, y);
    }
    else if (RB_TYPE_P(x, T_BIGNUM)) {
        return rb_big_mul(x, y);
    }
    return rb_num_coerce_bin(x, y, '*');
}

Performs multiplication: the class of the resulting object depends on the class of numeric.

int ** numeric → numeric_result Show source 
VALUE
rb_int_pow(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_pow(x, y);
    }
    else if (RB_TYPE_P(x, T_BIGNUM)) {
        return rb_big_pow(x, y);
    }
    return Qnil;
}

Raises int to the power of numeric, which may be negative or fractional. The result may be an Integer, a Float, a Rational, or a complex number.

2 ** 3        #=> 8
2 ** -1       #=> (1/2)
2 ** 0.5      #=> 1.4142135623730951
(-1) ** 0.5   #=> (0.0+1.0i)

123456789 ** 2     #=> 15241578750190521
123456789 ** 1.2   #=> 5126464716.0993185
123456789 ** -2    #=> (1/15241578750190521)
int + numeric → numeric_result Show source 
VALUE
rb_int_plus(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_plus(x, y);
    }
    else if (RB_TYPE_P(x, T_BIGNUM)) {
        return rb_big_plus(x, y);
    }
    return rb_num_coerce_bin(x, y, '+');
}

Performs addition: the class of the resulting object depends on the class of numeric.

int - numeric → numeric_result Show source 
VALUE
rb_int_minus(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_minus(x, y);
    }
    else if (RB_TYPE_P(x, T_BIGNUM)) {
        return rb_big_minus(x, y);
    }
    return rb_num_coerce_bin(x, y, '-');
}

Performs subtraction: the class of the resulting object depends on the class of numeric.

-int → integer Show source 
VALUE
rb_int_uminus(VALUE num)
{
    if (FIXNUM_P(num)) {
        return fix_uminus(num);
    }
    else if (RB_TYPE_P(num, T_BIGNUM)) {
        return rb_big_uminus(num);
    }
    return num_funcall0(num, idUMinus);
}

Returns int, negated.

int / numeric → numeric_result Show source 
VALUE
rb_int_div(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_div(x, y);
    }
    else if (RB_TYPE_P(x, T_BIGNUM)) {
        return rb_big_div(x, y);
    }
    return Qnil;
}

Performs division: the class of the resulting object depends on the class of numeric.

int < real → true or false Show source 
static VALUE
int_lt(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_lt(x, y);
    }
    else if (RB_TYPE_P(x, T_BIGNUM)) {
        return rb_big_lt(x, y);
    }
    return Qnil;
}

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

int << count → integer Show source 
VALUE
rb_int_lshift(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return rb_fix_lshift(x, y);
    }
    else if (RB_TYPE_P(x, T_BIGNUM)) {
        return rb_big_lshift(x, y);
    }
    return Qnil;
}

Returns int shifted left count positions, or right if count is negative.

int <= real → true or false Show source 
static VALUE
int_le(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_le(x, y);
    }
    else if (RB_TYPE_P(x, T_BIGNUM)) {
        return rb_big_le(x, y);
    }
    return Qnil;
}

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

int <=> numeric → -1, 0, +1, or nil Show source 
VALUE
rb_int_cmp(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_cmp(x, y);
    }
    else if (RB_TYPE_P(x, T_BIGNUM)) {
        return rb_big_cmp(x, y);
    }
    else {
        rb_raise(rb_eNotImpError, "need to define `<=>' in %s", rb_obj_classname(x));
    }
}

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

int == other → true or false Show source 
VALUE
rb_int_equal(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_equal(x, y);
    }
    else if (RB_TYPE_P(x, T_BIGNUM)) {
        return rb_big_eq(x, y);
    }
    return Qnil;
}

Returns true if int equals other numerically. Contrast this with Integer#eql?, which requires other to be an Integer.

1 == 2     #=> false
1 == 1.0   #=> true
int == other → true or false Show source 
VALUE
rb_int_equal(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_equal(x, y);
    }
    else if (RB_TYPE_P(x, T_BIGNUM)) {
        return rb_big_eq(x, y);
    }
    return Qnil;
}

Returns true if int equals other numerically. Contrast this with Integer#eql?, which requires other to be an Integer.

1 == 2     #=> false
1 == 1.0   #=> true
int > real → true or false Show source 
VALUE
rb_int_gt(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_gt(x, y);
    }
    else if (RB_TYPE_P(x, T_BIGNUM)) {
        return rb_big_gt(x, y);
    }
    return Qnil;
}

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

int >= real → true or false Show source 
VALUE
rb_int_ge(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_ge(x, y);
    }
    else if (RB_TYPE_P(x, T_BIGNUM)) {
        return rb_big_ge(x, y);
    }
    return Qnil;
}

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

int >> count → integer Show source 
static VALUE
rb_int_rshift(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return rb_fix_rshift(x, y);
    }
    else if (RB_TYPE_P(x, T_BIGNUM)) {
        return rb_big_rshift(x, y);
    }
    return Qnil;
}

Returns int shifted right count positions, or left if count is negative.

int[n] → 0, 1 Show source
int[n, m] → num
int[range] → num 
static VALUE
int_aref(int const argc, VALUE * const argv, VALUE const num)
{
    rb_check_arity(argc, 1, 2);
    if (argc == 2) {
        return int_aref2(num, argv[0], argv[1]);
    }
    return int_aref1(num, argv[0]);

    return Qnil;
}

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

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

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

In principle, n[i] is equivalent to (n >> i) & 1. Thus, any negative index always returns zero:

p 255[-1] #=> 0

Range operations n[i, len] and n[i..j] are naturally extended.

  • n[i, len] equals to (n >> i) & ((1 << len) - 1).

  • n[i..j] equals to (n >> i) & ((1 << (j - i + 1)) - 1).

  • n[i...j] equals to (n >> i) & ((1 << (j - i)) - 1).

  • n[i..] equals to (n >> i).

  • n[..j] is zero if n & ((1 << (j + 1)) - 1) is zero. Otherwise, raises an ArgumentError.

  • n[...j] is zero if n & ((1 << j) - 1) is zero. Otherwise, raises an ArgumentError.

Note that range operation may exhaust memory. For example, -1[0, 1000000000000] will raise NoMemoryError.

int ^ other_int → integer Show source 
static VALUE
int_xor(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_xor(x, y);
    }
    else if (RB_TYPE_P(x, T_BIGNUM)) {
        return rb_big_xor(x, y);
    }
    return Qnil;
}

Bitwise EXCLUSIVE OR.

abs → integer Show source 
VALUE
rb_int_abs(VALUE num)
{
    if (FIXNUM_P(num)) {
        return fix_abs(num);
    }
    else if (RB_TYPE_P(num, T_BIGNUM)) {
        return rb_big_abs(num);
    }
    return Qnil;
}

Returns the absolute value of int.

(-12345).abs   #=> 12345
-12345.abs     #=> 12345
12345.abs      #=> 12345

Integer#magnitude is an alias for Integer#abs.

allbits?(mask) → true or false Show source 
static VALUE
int_allbits_p(VALUE num, VALUE mask)
{
    mask = rb_to_int(mask);
    return rb_int_equal(rb_int_and(num, mask), mask);
}

Returns true if all bits of int & mask are 1.

anybits?(mask) → true or false Show source 
static VALUE
int_anybits_p(VALUE num, VALUE mask)
{
    mask = rb_to_int(mask);
    return num_zero_p(rb_int_and(num, mask)) ? Qfalse : Qtrue;
}

Returns true if any bits of int & mask are 1.

bit_length → integer Show source 
static VALUE
rb_int_bit_length(VALUE num)
{
    if (FIXNUM_P(num)) {
        return rb_fix_bit_length(num);
    }
    else if (RB_TYPE_P(num, T_BIGNUM)) {
        return rb_big_bit_length(num);
    }
    return Qnil;
}

Returns the number of bits of the value of int.

“Number of bits” means the bit position of the highest bit which is different from the sign bit (where the least significant bit has bit position 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**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

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
ceil([ndigits]) → integer or float Show source 
static VALUE
int_ceil(int argc, VALUE* argv, VALUE num)
{
    int ndigits;

    if (!rb_check_arity(argc, 0, 1)) return num;
    ndigits = NUM2INT(argv[0]);
    if (ndigits >= 0) {
        return num;
    }
    return rb_int_ceil(num, ndigits);
}

Returns the smallest number greater than or equal to int with a precision of ndigits decimal digits (default: 0).

When the precision is negative, the returned value is an integer with at least ndigits.abs trailing zeros.

Returns self when ndigits is zero or positive.

1.ceil           #=> 1
1.ceil(2)        #=> 1
18.ceil(-1)      #=> 20
(-18).ceil(-1)   #=> -10
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_error_arity(argc, 0, 1);
    }
    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   #=> "\xE6"
255.chr(Encoding::UTF_8)   #=> "\u00FF"
coerce(numeric) → array Show source 
static VALUE
rb_int_coerce(VALUE x, VALUE y)
{
    if (RB_INTEGER_TYPE_P(y)) {
        return rb_assoc_new(y, x);
    }
    else {
        x = rb_Float(x);
        y = rb_Float(y);
        return rb_assoc_new(y, x);
    }
}

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]
dclone() Show source 
# File lib/rexml/xpath_parser.rb, line 25
def dclone ; self ; end

provides a unified clone operation, for REXML::XPathParser to use across multiple Object types

denominator → 1 Show source 
static VALUE
integer_denominator(VALUE self)
{
    return INT2FIX(1);
}

Returns 1.

digits → array Show source
digits(base) → array 
static VALUE
rb_int_digits(int argc, VALUE *argv, VALUE num)
{
    VALUE base_value;
    long base;

    if (rb_num_negative_p(num))
        rb_raise(rb_eMathDomainError, "out of domain");

    if (rb_check_arity(argc, 0, 1)) {
        base_value = rb_to_int(argv[0]);
        if (!RB_INTEGER_TYPE_P(base_value))
            rb_raise(rb_eTypeError, "wrong argument type %s (expected Integer)",
                     rb_obj_classname(argv[0]));
        if (RB_TYPE_P(base_value, T_BIGNUM))
            return rb_int_digits_bigbase(num, base_value);

        base = FIX2LONG(base_value);
        if (base < 0)
            rb_raise(rb_eArgError, "negative radix");
        else if (base < 2)
            rb_raise(rb_eArgError, "invalid radix %ld", base);
    }
    else
        base = 10;

    if (FIXNUM_P(num))
        return rb_fix_digits(num, base);
    else if (RB_TYPE_P(num, T_BIGNUM))
        return rb_int_digits_bigbase(num, LONG2FIX(base));

    return Qnil;
}

Returns the digits of int's place-value representation with radix base (default: 10). The digits are returned as an array with the least significant digit as the first array element.

base must 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
div(numeric) → integer Show source 
VALUE
rb_int_idiv(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_idiv(x, y);
    }
    else if (RB_TYPE_P(x, T_BIGNUM)) {
        return rb_big_idiv(x, y);
    }
    return num_div(x, y);
}

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

divmod(numeric) → array Show source 
VALUE
rb_int_divmod(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_divmod(x, y);
    }
    else if (RB_TYPE_P(x, T_BIGNUM)) {
        return rb_big_divmod(x, y);
    }
    return Qnil;
}

See Numeric#divmod.

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 in 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, ".. " }
puts "Liftoff!"
#=> "5.. 4.. 3.. 2.. 1.. Liftoff!"
even? → true or false Show source 
static VALUE
int_even_p(VALUE num)
{
    if (FIXNUM_P(num)) {
        if ((num & 2) == 0) {
            return Qtrue;
        }
    }
    else if (RB_TYPE_P(num, T_BIGNUM)) {
        return rb_big_even_p(num);
    }
    else if (rb_funcall(num, '%', 1, INT2FIX(2)) == INT2FIX(0)) {
        return Qtrue;
    }
    return Qfalse;
}

Returns true if int is an even number.

fdiv(numeric) → float Show source 
VALUE
rb_int_fdiv(VALUE x, VALUE y)
{
    if (RB_INTEGER_TYPE_P(x)) {
        return DBL2NUM(rb_int_fdiv_double(x, y));
    }
    return Qnil;
}

Returns the floating point result of dividing int by numeric.

654321.fdiv(13731)      #=> 47.652829364212366
654321.fdiv(13731.24)   #=> 47.65199646936475
-654321.fdiv(13731)     #=> -47.652829364212366
floor([ndigits]) → integer or float Show source 
static VALUE
int_floor(int argc, VALUE* argv, VALUE num)
{
    int ndigits;

    if (!rb_check_arity(argc, 0, 1)) return num;
    ndigits = NUM2INT(argv[0]);
    if (ndigits >= 0) {
        return num;
    }
    return rb_int_floor(num, ndigits);
}

Returns the largest number less than or equal to int with a precision of ndigits decimal digits (default: 0).

When the precision is negative, the returned value is an integer with at least ndigits.abs trailing zeros.

Returns self when ndigits is zero or positive.

1.floor           #=> 1
1.floor(2)        #=> 1
18.floor(-1)      #=> 10
(-18).floor(-1)   #=> -20
gcd(other_int) → 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 of the two integers. The result is always positive. 0.gcd(x) and x.gcd(0) return x.abs.

36.gcd(60)                  #=> 12
2.gcd(2)                    #=> 2
3.gcd(-7)                   #=> 1
((1<<31)-1).gcd((1<<61)-1)  #=> 1
gcdlcm(other_int) → 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 with the greatest common divisor and the least common multiple of the two integers, [gcd, lcm].

36.gcdlcm(60)                  #=> [12, 180]
2.gcdlcm(2)                    #=> [2, 2]
3.gcdlcm(-7)                   #=> [1, 21]
((1<<31)-1).gcdlcm((1<<61)-1)  #=> [1, 4951760154835678088235319297]
inspect(*args)
Alias for: to_s
integer? → true Show source 
static VALUE
int_int_p(VALUE num)
{
    return Qtrue;
}

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

lcm(other_int) → 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 of the two integers. The result is always positive. 0.lcm(x) and x.lcm(0) return zero.

36.lcm(60)                  #=> 180
2.lcm(2)                    #=> 2
3.lcm(-7)                   #=> 21
((1<<31)-1).lcm((1<<61)-1)  #=> 4951760154835678088235319297
magnitude → integer Show source 
VALUE
rb_int_abs(VALUE num)
{
    if (FIXNUM_P(num)) {
        return fix_abs(num);
    }
    else if (RB_TYPE_P(num, T_BIGNUM)) {
        return rb_big_abs(num);
    }
    return Qnil;
}

Returns the absolute value of int.

(-12345).abs   #=> 12345
-12345.abs     #=> 12345
12345.abs      #=> 12345

Integer#magnitude is an alias for Integer#abs.

modulo(other) → real Show source 
VALUE
rb_int_modulo(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_mod(x, y);
    }
    else if (RB_TYPE_P(x, T_BIGNUM)) {
        return rb_big_modulo(x, y);
    }
    return num_modulo(x, y);
}

Returns int modulo other.

See Numeric#divmod for more information.

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 num_funcall1(num, '+', INT2FIX(1));
}

Returns the successor of int, i.e. the Integer equal to int+1.

1.next      #=> 2
(-1).next   #=> 0
1.succ      #=> 2
(-1).succ   #=> 0
nobits?(mask) → true or false Show source 
static VALUE
int_nobits_p(VALUE num, VALUE mask)
{
    mask = rb_to_int(mask);
    return num_zero_p(rb_int_and(num, mask));
}

Returns true if no bits of int & mask are 1.

numerator → self Show source 
static VALUE
integer_numerator(VALUE self)
{
    return self;
}

Returns self.

odd? → true or false Show source 
VALUE
rb_int_odd_p(VALUE num)
{
    if (FIXNUM_P(num)) {
        if (num & 2) {
            return Qtrue;
        }
    }
    else if (RB_TYPE_P(num, T_BIGNUM)) {
        return rb_big_odd_p(num);
    }
    else 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.

97.ord   #=> 97

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

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

pow(numeric) → numeric Show source
pow(integer, integer) → integer 
VALUE
rb_int_powm(int const argc, VALUE * const argv, VALUE const num)
{
    rb_check_arity(argc, 1, 2);

    if (argc == 1) {
        return rb_int_pow(num, argv[0]);
    }
    else {
        VALUE const a = num;
        VALUE const b = argv[0];
        VALUE m = argv[1];
        int nega_flg = 0;
        if ( ! RB_INTEGER_TYPE_P(b)) {
            rb_raise(rb_eTypeError, "Integer#pow() 2nd argument not allowed unless a 1st argument is integer");
        }
        if (rb_int_negative_p(b)) {
            rb_raise(rb_eRangeError, "Integer#pow() 1st argument cannot be negative when 2nd argument specified");
        }
        if (!RB_INTEGER_TYPE_P(m)) {
            rb_raise(rb_eTypeError, "Integer#pow() 2nd argument not allowed unless all arguments are integers");
        }

        if (rb_int_negative_p(m)) {
            m = rb_int_uminus(m);
            nega_flg = 1;
        }

        if (FIXNUM_P(m)) {
            long const half_val = (long)HALF_LONG_MSB;
            long const mm = FIX2LONG(m);
            if (!mm) rb_num_zerodiv();
            if (mm <= half_val) {
                return int_pow_tmp1(rb_int_modulo(a, m), b, mm, nega_flg);
            }
            else {
                return int_pow_tmp2(rb_int_modulo(a, m), b, mm, nega_flg);
            }
        }
        else {
            if (rb_bigzero_p(m)) rb_num_zerodiv();
            return int_pow_tmp3(rb_int_modulo(a, m), b, m, nega_flg);
        }
    }
    UNREACHABLE_RETURN(Qnil);
}

Returns (modular) exponentiation as:

a.pow(b)     #=> same as a**b
a.pow(b, m)  #=> same as (a**b) % m, but avoids huge temporary values
pred → integer Show source 
static 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 num_funcall1(num, '-', INT2FIX(1));
}

Returns the predecessor of int, i.e. the Integer equal to int-1.

1.pred      #=> 0
(-1).pred   #=> -2
prime?() Show source 
# File lib/prime.rb, line 34
def prime?
  return self >= 2 if self <= 3
  return true if self == 5
  return false unless 30.gcd(self) == 1
  (7..Integer.sqrt(self)).step(30) do |p|
    return false if
      self%(p)    == 0 || self%(p+4)  == 0 || self%(p+6)  == 0 || self%(p+10) == 0 ||
      self%(p+12) == 0 || self%(p+16) == 0 || self%(p+22) == 0 || self%(p+24) == 0
  end
  true
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 29
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_check_arity(argc, 0, 1);
    return integer_to_r(self);
}

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

remainder(numeric) → real Show source 
static VALUE
int_remainder(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return num_remainder(x, y);
    }
    else if (RB_TYPE_P(x, T_BIGNUM)) {
        return rb_big_remainder(x, y);
    }
    return Qnil;
}

Returns the remainder after dividing int by numeric.

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

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

See Numeric#divmod.

round([ndigits] [, half: mode]) → integer or float Show source 
static VALUE
int_round(int argc, VALUE* argv, VALUE num)
{
    int ndigits;
    int mode;
    VALUE nd, opt;

    if (!rb_scan_args(argc, argv, "01:", &nd, &opt)) return num;
    ndigits = NUM2INT(nd);
    mode = rb_num_get_rounding_option(opt);
    if (ndigits >= 0) {
        return num;
    }
    return rb_int_round(num, ndigits, mode);
}

Returns int rounded to the nearest value with a precision of ndigits decimal digits (default: 0).

When the precision is negative, the returned value is an integer with at least ndigits.abs trailing zeros.

Returns self when ndigits is zero or positive.

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

The optional half keyword argument is available similar to Float#round.

25.round(-1, half: :up)      #=> 30
25.round(-1, half: :down)    #=> 20
25.round(-1, half: :even)    #=> 20
35.round(-1, half: :up)      #=> 40
35.round(-1, half: :down)    #=> 30
35.round(-1, half: :even)    #=> 40
(-25).round(-1, half: :up)   #=> -30
(-25).round(-1, half: :down) #=> -20
(-25).round(-1, half: :even) #=> -20
size → int Show source 
static VALUE
int_size(VALUE num)
{
    if (FIXNUM_P(num)) {
        return fix_size(num);
    }
    else if (RB_TYPE_P(num, T_BIGNUM)) {
        return rb_big_size_m(num);
    }
    return Qnil;
}

Returns the number of bytes in the machine representation of int (machine dependent).

1.size               #=> 8
-1.size              #=> 8
2147483647.size      #=> 8
(256**10 - 1).size   #=> 10
(256**20 - 1).size   #=> 20
(256**40 - 1).size   #=> 40
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 num_funcall1(num, '+', INT2FIX(1));
}

Returns the successor of int, i.e. the Integer equal to int+1.

1.next      #=> 2
(-1).next   #=> 0
1.succ      #=> 2
(-1).succ   #=> 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_1(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 {|i| print i, " " }   #=> 0 1 2 3 4
to_bn() Show source 
# File ext/openssl/lib/openssl/bn.rb, line 37
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 23
def to_d
  BigDecimal(self)
end

Returns the value of int as a BigDecimal.

require 'bigdecimal'
require 'bigdecimal/util'

42.to_d   # => 0.42e2

See also BigDecimal::new.

to_f → float Show source 
static VALUE
int_to_f(VALUE num)
{
    double val;

    if (FIXNUM_P(num)) {
        val = (double)FIX2LONG(num);
    }
    else if (RB_TYPE_P(num, T_BIGNUM)) {
        val = rb_big2dbl(num);
    }
    else {
        rb_raise(rb_eNotImpError, "Unknown subclass for to_f: %s", rb_obj_classname(num));
    }

    return DBL2NUM(val);
}

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

to_i → integer Show source
to_int → integer 
static VALUE
int_to_i(VALUE num)
{
    return num;
}

Since int is already an Integer, returns self.

to_int is an alias for to_i.

to_int → integer Show source 
static VALUE
int_to_i(VALUE num)
{
    return num;
}

Since int is already an Integer, returns self.

to_int is an alias for to_i.

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_s(base=10) → string Show source 
static VALUE
int_to_s(int argc, VALUE *argv, VALUE x)
{
    int base;

    if (rb_check_arity(argc, 0, 1))
        base = NUM2INT(argv[0]);
    else
        base = 10;
    return rb_int2str(x, base);
}

Returns a string containing the place-value representation of int with 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"
Also aliased as: inspect
truncate([ndigits]) → integer or float Show source 
static VALUE
int_truncate(int argc, VALUE* argv, VALUE num)
{
    int ndigits;

    if (!rb_check_arity(argc, 0, 1)) return num;
    ndigits = NUM2INT(argv[0]);
    if (ndigits >= 0) {
        return num;
    }
    return rb_int_truncate(num, ndigits);
}

Returns int truncated (toward zero) to a precision of ndigits decimal digits (default: 0).

When the precision is negative, the returned value is an integer with at least ndigits.abs trailing zeros.

Returns self when ndigits is zero or positive.

1.truncate           #=> 1
1.truncate(2)        #=> 1
18.truncate(-1)      #=> 10
(-18).truncate(-1)   #=> -10
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.

5.upto(10) {|i| print i, " " }   #=> 5 6 7 8 9 10
int | other_int → integer Show source 
static VALUE
int_or(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_or(x, y);
    }
    else if (RB_TYPE_P(x, T_BIGNUM)) {
        return rb_big_or(x, y);
    }
    return Qnil;
}

Bitwise OR.

~int → integer Show source 
static VALUE
int_comp(VALUE num)
{
    if (FIXNUM_P(num)) {
        return fix_comp(num);
    }
    else if (RB_TYPE_P(num, T_BIGNUM)) {
        return rb_big_comp(num);
    }
    return Qnil;
}

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

Inverts the bits in an Integer. As integers are conceptually of 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"

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