123456789_123456789_123456789_123456789_123456789_

Class: Integer

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Class Chain:
self, ::Numeric
Instance Chain:
self, ::Numeric, ::Comparable
Inherits: Numeric
Defined in: numeric.c,
bignum.c,
rational.c

Overview

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

Constant Summary

Class Method Summary

  • .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.

Instance Attribute Summary

::Numeric - Inherited

#finite?

Returns true if num is a finite number, otherwise returns false.
#infinite?

Returns nil, -1, or 1 depending on whether the value is finite, -Infinity, or +Infinity.
#integer?

Returns true if num is an Integer.
#negative?

Returns true if num is less than 0.
#nonzero?

Returns self if num is not zero, nil otherwise.
#positive?

Returns true if num is greater than 0.
#real

Returns self.
#real?

Returns true if num is a real number (i.e.
#zero?

Returns true if num has a zero value.

Instance Method Summary

::Numeric - Inherited

#%

x.modulo(y) means x-y*(x/y).floor.
#+@

Unary Plus—Returns the receiver.
#-@

Unary Minus—Returns the receiver, negated.
#<=>

Returns zero if number equals other, otherwise returns nil.
#abs

Returns the absolute value of num.
#abs2

Returns square of self.
#angle

Alias for Numeric#arg.
#arg

Returns 0 if the value is positive, pi otherwise.
#ceil

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

Returns the receiver.
#coerce

If numeric is the same type as num, returns an array [numeric, num].
#conj

Returns self.
#conjugate

Alias for Numeric#conj.
#denominator

Returns the denominator (always positive).
#div

Uses / to perform division, then converts the result to an integer.
#divmod

Returns an array containing the quotient and modulus obtained by dividing num by numeric.
#dup

Returns the receiver.
#eql?

Returns true if num and numeric are the same type and have equal values.
#fdiv

Returns float division.
#floor

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

Returns the corresponding imaginary number.
#imag

Returns zero.
#imaginary

Alias for Numeric#imag.
#magnitude

Alias for Numeric#abs.
#modulo

Alias for Numeric#%.
#numerator

Returns the numerator.
#phase

Alias for Numeric#arg.
#polar

Returns an array; [num.abs, num.arg].
#quo

Returns the most exact division (rational for integers, float for floats).
#rect

Returns an array; [num, 0].
#rectangular

Alias for Numeric#rect.
#remainder

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

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

Invokes the given block with the sequence of numbers starting at num, incremented by step (defaulted to 1) on each call.
#to_c

Returns the value as a complex.
#to_int

Invokes the child class’s #to_i method to convert num to an integer.
#truncate

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

Trap attempts to add methods to ::Numeric objects.

::Comparable - Included

#<

Compares two objects based on the receiver’s #<=> method, returning true if it returns a value less than 0.
#<=

Compares two objects based on the receiver’s #<=> method, returning true if it returns a value less than or equal to 0.
#==

Compares two objects based on the receiver’s #<=> method, returning true if it returns 0.
#>

Compares two objects based on the receiver’s #<=> method, returning true if it returns a value greater than 0.
#>=

Compares two objects based on the receiver’s #<=> method, returning true if it returns a value greater than or equal to 0.
#between?

Returns false if obj #<=> min is less than zero or if obj #<=> max is greater than zero, true otherwise.
#clamp

In (min, max) form, returns min if obj #<=> min is less than zero, max if obj #<=> max is greater than zero, and obj otherwise.

Class Method Details

.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.

[ GitHub ] 

  


# File 'numeric.c', line 5436



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 Attribute Details



  

    #even?  ⇒ Boolean  (readonly)  



  

    

Returns true if int is an even number.


  



  [ GitHub ]


  

  


# File 'numeric.c', line 3250



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


  








  

    #integer?  ⇒ Boolean  (readonly)  



  

    

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


  



  [ GitHub ]


  

  


# File 'numeric.c', line 3213



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


  








  

    #odd?  ⇒ Boolean  (readonly)  



  

    

Returns true if int is an odd number.


  



  [ GitHub ]


  

  


# File 'numeric.c', line 3226



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


  







Instance Method Details



  

    

      #%(other)  ⇒ Numeric 
      #modulo(other)  ⇒ Numeric 
    

    Also known as: #modulo
  



  

    

Returns int modulo other.



See Numeric#divmod for more information.


  





  


  [ GitHub ]


  

  


# File 'numeric.c', line 3890



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


  








  

    #&(other_int)  ⇒ Integer   



  

    

Bitwise AND.


  



  [ GitHub ]


  

  


# File 'numeric.c', line 4471



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


  








  

    #*(numeric)  ⇒ numeric_result   



  

    

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


  



  [ GitHub ]


  

  


# File 'numeric.c', line 3703



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, '*');
}


  








  

    #**(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)


  



  [ GitHub ]


  

  


# File 'numeric.c', line 4110



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


  








  

    #+(numeric)  ⇒ numeric_result   



  

    

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


  



  [ GitHub ]


  

  


# File 'numeric.c', line 3614



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, '+');
}


  








  

    #-(numeric)  ⇒ numeric_result   



  

    

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


  



  [ GitHub ]


  

  


# File 'numeric.c', line 3653



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


  








  

    #-  ⇒ Integer   



  

    

Returns int, negated.


  



  [ GitHub ]


  

  


# File 'numeric.c', line 3483



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


  








  

    #/(numeric)  ⇒ numeric_result   



  

    

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


  



  [ GitHub ]


  

  


# File 'numeric.c', line 3820



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


  








  

    #<(real)  ⇒ Boolean   



  

    

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


  



  [ GitHub ]


  

  


# File 'numeric.c', line 4334



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


  








  

    #<<(count)  ⇒ Integer   



  

    

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


  



  [ GitHub ]


  

  


# File 'numeric.c', line 4588



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


  








  

    #<=(real)  ⇒ Boolean   



  

    

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


  



  [ GitHub ]


  

  


# File 'numeric.c', line 4374



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


  








  

    #<=>(numeric)  ⇒ 1, ...   



  

    

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.


  



  [ GitHub ]


  

  


# File 'numeric.c', line 4216



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


  








  

    #==(other)  ⇒ Boolean     Also known as: #===
  



  

    

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


  



  [ GitHub ]


  

  


# File 'numeric.c', line 4167



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


  








  

    

      #==(other)  ⇒ Boolean 
      #===(other)  ⇒ Boolean 
    

  



  

    

Alias for #==.


  





  








  

    #>(real)  ⇒ Boolean   



  

    

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


  



  [ GitHub ]


  

  


# File 'numeric.c', line 4256



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


  








  

    #>=(real)  ⇒ Boolean   



  

    

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


  



  [ GitHub ]


  

  


# File 'numeric.c', line 4296



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


  








  

    #>>(count)  ⇒ Integer   



  

    

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


  



  [ GitHub ]


  

  


# File 'numeric.c', line 4636



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


  








  

    

      #[](n)  ⇒ 0, 1 
      #[](n, m)  ⇒ Numeric 
      #[](range)  ⇒ Numeric 
    

  



  

    

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.


  





  


  [ GitHub ]


  

  


# File 'numeric.c', line 4796



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


  








  

    #^(other_int)  ⇒ Integer   



  

    

Bitwise EXCLUSIVE OR.


  



  [ GitHub ]


  

  


# File 'numeric.c', line 4541



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


  








  

    

      #abs  ⇒ Integer 
      #magnitude  ⇒ Integer 
    

    Also known as: #magnitude
  



  

    

Returns the absolute value of int.



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



#magnitude is an alias for abs.


  





  


  [ GitHub ]


  

  


# File 'numeric.c', line 4861



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


  








  

    #allbits?(mask)  ⇒ Boolean   



  

    

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


  



  [ GitHub ]


  

  


# File 'numeric.c', line 3274



static VALUE
int_allbits_p(VALUE num, VALUE mask)
{
    mask = rb_to_int(mask);
    return rb_int_equal(rb_int_and(num, mask), mask);
}


  








  

    #anybits?(mask)  ⇒ Boolean   



  

    

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


  



  [ GitHub ]


  

  


# File 'numeric.c', line 3288



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


  








  

    #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


  



  [ GitHub ]


  

  


# File 'numeric.c', line 4961



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


  








  

    #ceil([ndigits])  ⇒ Integer, 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


  



  [ GitHub ]


  

  


# File 'numeric.c', line 5322



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


  








  

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


  



  [ GitHub ]


  

  


# File 'numeric.c', line 3401



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


  








  

    #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]


  



  [ GitHub ]


  

  


# File 'bignum.c', line 6748



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


  








  

    #denominator  ⇒ 1   



  

    

Returns 1.


  



  [ GitHub ]


  

  


# File 'rational.c', line 2073



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


  








  

    

      #digits  ⇒ Array 
      #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


  





  


  [ GitHub ]


  

  


# File 'numeric.c', line 5048



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


  








  

    #div(numeric)  ⇒ Integer   



  

    

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


  



  [ GitHub ]


  

  


# File 'numeric.c', line 3847



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


  








  

    #divmod(numeric)  ⇒ Array   



  

    

See Numeric#divmod.


  



  [ GitHub ]


  

  


# File 'numeric.c', line 3967



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


  








  

    

      #downto(limit) {|i| ... } ⇒ self 
      #downto(limit)  ⇒ 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!"


  





  


  [ GitHub ]


  

  


# File 'numeric.c', line 5148



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


  








  

    #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


  



  [ GitHub ]


  

  


# File 'numeric.c', line 3765



VALUE
rb_int_fdiv(VALUE x, VALUE y)
{
    if (RB_INTEGER_TYPE_P(x)) {
        return DBL2NUM(rb_int_fdiv_double(x, y));
    }
    return Qnil;
}


  








  

    #floor([ndigits])  ⇒ Integer, 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


  



  [ GitHub ]


  

  


# File 'numeric.c', line 5290



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


  








  

    #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


  



  [ GitHub ]


  

  


# File 'rational.c', line 1905



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


  








  

    #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]


  



  [ GitHub ]


  

  


# File 'rational.c', line 1943



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


  








  

    

      #to_s(base = 10)  ⇒ String 
      #inspect(base = 10)  ⇒ String 
    

  



  

    

Alias for #to_s.


  









  

    #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


  



  [ GitHub ]


  

  


# File 'rational.c', line 1924



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


  








  

    

      #abs  ⇒ Integer 
      #magnitude  ⇒ Integer 
    

  



  

    

Alias for #abs. Returns the absolute value of int.



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



magnitude is an alias for #abs.


  





  








  

    

      #%(other)  ⇒ Numeric 
      #modulo(other)  ⇒ Numeric 
    

  



  

    

Alias for #%.


  





  








  

    

      #next  ⇒ Integer 
      #succ  ⇒ Integer 
    

    Also known as: #succ
  



  

    

Returns the successor of int, i.e. the Integer equal to int1</code>.



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


  





  


  [ GitHub ]


  

  


# File 'numeric.c', line 3325



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


  








  

    #nobits?(mask)  ⇒ Boolean   



  

    

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


  



  [ GitHub ]


  

  


# File 'numeric.c', line 3302



static VALUE
int_nobits_p(VALUE num, VALUE mask)
{
    mask = rb_to_int(mask);
    return num_zero_p(rb_int_and(num, mask));
}


  








  

    #numerator  ⇒ self   



  

    

Returns self.


  



  [ GitHub ]


  

  


# File 'rational.c', line 2061



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


  








  

    #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.


  



  [ GitHub ]


  

  


# File 'numeric.c', line 3458



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


  








  

    

      #pow(numeric)  ⇒ Numeric 
      #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


  





  


  [ GitHub ]


  

  


# File 'bignum.c', line 7111



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


  








  

    #pred  ⇒ Integer   



  

    

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



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


  



  [ GitHub ]


  

  


# File 'numeric.c', line 3351



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


  








  

    #rationalize([eps])  ⇒ Rational   



  

    

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


  



  [ GitHub ]


  

  


# File 'rational.c', line 2177



static VALUE
integer_rationalize(int argc, VALUE *argv, VALUE self)
{
    rb_check_arity(argc, 0, 1);
    return integer_to_r(self);
}


  








  

    #remainder(numeric)  ⇒ Numeric   



  

    

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.


  



  [ GitHub ]


  

  


# File 'numeric.c', line 3919



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


  








  

    #round([ndigits] [, half: mode])  ⇒ Integer, 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


  



  [ GitHub ]


  

  


# File 'numeric.c', line 5255



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


  








  

    #size  ⇒ Integer   



  

    

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


  



  [ GitHub ]


  

  


# File 'numeric.c', line 4895



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


  








  

    

      #next  ⇒ Integer 
      #succ  ⇒ Integer 
    

  



  

    

Alias for #next.


  





  








  

    

      #times {|i| ... } ⇒ self 
      #times  ⇒ 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


  





  


  [ GitHub ]


  

  


# File 'numeric.c', line 5198



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_f  ⇒ Float   



  

    

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


  



  [ GitHub ]


  

  


# File 'numeric.c', line 4817



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


  








  

    

      #to_i  ⇒ Integer 
      #to_int  ⇒ Integer 
    

    Also known as: #to_int
  



  

    

Since int is already an Integer, returns self.



#to_int is an alias for #to_i.


  





  


  [ GitHub ]


  

  


# File 'numeric.c', line 3200



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


  








  

    

      #to_i  ⇒ Integer 
      #to_int  ⇒ Integer 
    

  



  

    

Alias for #to_i.


  





  








  

    #to_r  ⇒ Rational   



  

    

Returns the value as a rational.



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


  



  [ GitHub ]


  

  


# File 'rational.c', line 2164



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


  








  

    #to_s(base = 10)  ⇒ String     Also known as: #inspect
  



  

    

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"


  



  [ GitHub ]


  

  


# File 'numeric.c', line 3554



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


  








  

    #truncate([ndigits])  ⇒ Integer, 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


  



  [ GitHub ]


  

  


# File 'numeric.c', line 5354



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


  








  

    

      #upto(limit) {|i| ... } ⇒ self 
      #upto(limit)  ⇒ 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


  





  


  [ GitHub ]


  

  


# File 'numeric.c', line 5102



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


  








  

    #|(other_int)  ⇒ Integer   



  

    

Bitwise OR.


  



  [ GitHub ]


  

  


# File 'numeric.c', line 4506



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


  








  

    #~  ⇒ 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"


  



  [ GitHub ]


  

  


# File 'numeric.c', line 4407



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