frozen_string_literal: false

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

Methods
#
A
B
C
D
E
F
G
I
L
M
N
O
P
R
S
T
U
#
Constants
 GMP_VERSION = rb_sprintf("GMP %s", gmp_version) The version of loaded GMP.
Class Public methods
each_prime(ubound)

Iterates the given block over all prime numbers.

See `Prime`#each for more details.

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

Re-composes a prime factorization and returns the product.

See Prime#int_from_prime_division for more details.

```# File lib/prime.rb, line 22
def Integer.from_prime_division(pd)
Prime.int_from_prime_division(pd)
end```
Integer.sqrt(n) → integer

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.

```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);
}
}```
Instance Public methods
int % other → real

Returns `int` modulo `other`.

```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);
}```
int & other_int → integer

Bitwise AND.

```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;
}```
int * numeric → numeric_result

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

```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, '*');
}```
int ** numeric → numeric_result

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)
``````
```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;
}```
int + numeric → numeric_result

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

```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, '+');
}```
int - numeric → numeric_result

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

```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, '-');
}```
-int → integer

Returns `int`, negated.

```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);
}```
int / numeric → numeric_result

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

```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;
}```
int < real → true or false

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

```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;
}```
int << count → integer

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

```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;
}```
int <= real → true or false

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

```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;
}```
int <=> numeric → -1, 0, +1, or nil

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.

```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));
}
}```
int == other → true or false

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

``````1 == 2     #=> false
1 == 1.0   #=> true
``````
```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;
}```
int == other → true or false

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

``````1 == 2     #=> false
1 == 1.0   #=> true
``````
```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;
}```
int > real → true or false

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

```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;
}```
int >= real → true or false

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

```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;
}```
int >> count → integer

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

```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;
}```
int[n] → 0, 1

Bit Reference—Returns the `n`th 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
``````
```static VALUE
int_aref(VALUE num, VALUE idx)
{
if (FIXNUM_P(num)) {
return fix_aref(num, idx);
}
else if (RB_TYPE_P(num, T_BIGNUM)) {
return rb_big_aref(num, idx);
}
return Qnil;
}```
int ^ other_int → integer

Bitwise EXCLUSIVE OR.

```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;
}```
int.abs → integer

Returns the absolute value of `int`.

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

#magnitude is an alias for #abs.

```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 `true` if all bits of `int & mask` are 1.

```static VALUE
{
}```

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

```static VALUE
{
return num_zero_p(rb_int_and(num, mask)) ? Qfalse : Qtrue;
}```
int.bit_length → integer

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
``````
```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;
}```
int.ceil([ndigits]) → integer or float

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
``````
```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);
}```
int.chr([encoding]) → string

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"
``````
```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);
}```
big.coerce(numeric) → array

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]
``````
```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);
}
}```
dclone()

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

```# File lib/rexml/xpath_parser.rb, line 23
def dclone ; self ; end```
int.denominator → 1

Returns 1.

```static VALUE
integer_denominator(VALUE self)
{
return INT2FIX(1);
}```
int.digits → array
int.digits(base) → array

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
``````
```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)
else if (base < 2)
}
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;
}```
int.div(numeric) → integer

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

```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);
}```
int.divmod(numeric) → array
```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;
}```
int.downto(limit) {|i| block } → self
int.downto(limit) → an_enumerator

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!"
``````
```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;
}```
int.even? → true or false

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

```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;
}```
int.fdiv(numeric) → float

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
``````
```VALUE
rb_int_fdiv(VALUE x, VALUE y)
{
if (RB_INTEGER_TYPE_P(x)) {
return DBL2NUM(rb_int_fdiv_double(x, y));
}
return Qnil;
}```
int.floor([ndigits]) → integer or float

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
``````
```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);
}```
int.gcd(other_int) → integer

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
``````
```VALUE
rb_gcd(VALUE self, VALUE other)
{
other = nurat_int_value(other);
return f_gcd(self, other);
}```
int.gcdlcm(other_int) → array

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]
``````
```VALUE
rb_gcdlcm(VALUE self, VALUE other)
{
other = nurat_int_value(other);
return rb_assoc_new(f_gcd(self, other), f_lcm(self, other));
}```
inspect(*args)
Alias for: to_s
int.integer? → true

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

```static VALUE
int_int_p(VALUE num)
{
return Qtrue;
}```
int.lcm(other_int) → integer

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
``````
```VALUE
rb_lcm(VALUE self, VALUE other)
{
other = nurat_int_value(other);
return f_lcm(self, other);
}```
int.magnitude → integer

Returns the absolute value of `int`.

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

#magnitude is an alias for #abs.

```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;
}```
int.modulo(other) → real

Returns `int` modulo `other`.

```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);
}```
int.next → integer

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
``````
```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 `true` if no bits of `int & mask` are 1.

```static VALUE
{
}```
int.numerator → self

Returns self.

```static VALUE
integer_numerator(VALUE self)
{
return self;
}```
int.odd? → true or false

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

```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;
}```
int.ord → self

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.

```static VALUE
int_ord(VALUE num)
{
return num;
}```
integer.pow(numeric) → numeric
integer.pow(integer, integer) → integer

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
``````
```VALUE
rb_int_powm(int const argc, VALUE * const argv, VALUE const num)
{
rb_check_arity(argc, 1, 2);

if (argc == 1) {
return rb_funcall(num, rb_intern("**"), 1, 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_num_negative_int_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_num_negative_int_p(m)) {
m = rb_funcall(m, idUMinus, 0);
nega_flg = 1;
}

if (!rb_num_positive_int_p(m)) {
rb_num_zerodiv();
}
if (FIXNUM_P(m)) {
long const half_val = (long)HALF_LONG_MSB;
long const mm = FIX2LONG(m);
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_TYPE_P(m, T_BIGNUM)) {
return int_pow_tmp3(rb_int_modulo(a, m), b, m, nega_flg);
}
}
UNREACHABLE;
}```
int.pred → integer

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

``````1.pred      #=> 0
(-1).pred   #=> -2
``````
```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));
}```
prime?()

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

```# 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```
prime_division(generator = Prime::Generator23.new)

Returns the factorization of `self`.

See Prime#prime_division for more details.

```# File lib/prime.rb, line 29
def prime_division(generator = Prime::Generator23.new)
Prime.prime_division(self, generator)
end```
int.rationalize([eps]) → rational

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

```static VALUE
integer_rationalize(int argc, VALUE *argv, VALUE self)
{
rb_scan_args(argc, argv, "01", NULL);
return integer_to_r(self);
}```
int.remainder(numeric) → real

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.

```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;
}```
int.round([ndigits] [, half: mode]) → integer or float

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
``````
```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);
}```
int.size → int

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
``````
```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;
}```
int.succ → integer

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
``````
```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));
}```
int.times {|i| block } → self
int.times → an_enumerator

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
``````
```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;
}```
to_bn()

Casts an Integer as an OpenSSL::BN

```# File ext/openssl/lib/openssl/bn.rb, line 37
def to_bn
OpenSSL::BN::new(self)
end```
int.to_d → bigdecimal

Returns the value of `int` as a BigDecimal.

``````require 'bigdecimal'
require 'bigdecimal/util'

42.to_d   # => 0.42e2
``````

```# File ext/bigdecimal/lib/bigdecimal/util.rb, line 22
def to_d
BigDecimal(self)
end```
int.to_f → float

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

```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);
}```
int.to_i → integer
int.to_int → integer

Since `int` is already an Integer, returns `self`.

to_int is an alias for to_i.

```static VALUE
int_to_i(VALUE num)
{
return num;
}```
int.to_int → integer

Since `int` is already an Integer, returns `self`.

to_int is an alias for to_i.

```static VALUE
int_to_i(VALUE num)
{
return num;
}```
int.to_r → rational

Returns the value as a rational.

``````1.to_r        #=> (1/1)
(1<<64).to_r  #=> (18446744073709551616/1)
``````
```static VALUE
integer_to_r(VALUE self)
{
return rb_rational_new1(self);
}```
int.to_s(base=10) → string

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
```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);
}```
int.truncate([ndigits]) → integer or float

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
``````
```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);
}```
int.upto(limit) {|i| block } → self
int.upto(limit) → an_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.

``````5.upto(10) {|i| print i, " " }   #=> 5 6 7 8 9 10
``````
```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;
}```
int | other_int → integer

Bitwise OR.

```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;
}```
~int → integer

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