Holds Integer
values. You cannot add a singleton method to an Integer
object, any attempt to do so will raise a TypeError
.
The version of loaded GMP.
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); } }
Returns int
modulo other
.
See Numeric#divmod
for more information.
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); }
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; }
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, '*'); }
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; }
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, '+'); }
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, '-'); }
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); }
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; }
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; }
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; }
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; }
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)); } }
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
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
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 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; }
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; }
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; }
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; }
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; }
Returns the absolute value of int
.
(-12345).abs #=> 12345 -12345.abs #=> 12345 12345.abs #=> 12345
Integer#magnitude
is an alias for Integer#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 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 any bits of int & mask
are 1.
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 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; }
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); }
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); }
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); } }
Returns 1.
static VALUE integer_denominator(VALUE self) { return INT2FIX(1); }
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) 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; }
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); }
See Numeric#divmod
.
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; }
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; }
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; }
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; }
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); }
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); }
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)); }
Since int
is already an Integer
, this always returns true
.
static VALUE int_int_p(VALUE num) { return Qtrue; }
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); }
Returns the absolute value of int
.
(-12345).abs #=> 12345 -12345.abs #=> 12345 12345.abs #=> 12345
Integer#magnitude
is an alias for Integer#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 int
modulo other
.
See Numeric#divmod
for more information.
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 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_nobits_p(VALUE num, VALUE mask) { mask = rb_to_int(mask); return num_zero_p(rb_int_and(num, mask)); }
Returns self.
static VALUE integer_numerator(VALUE self) { return self; }
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; }
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; }
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; }
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)); }
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); }
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; }
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); }
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; }
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)); }
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; }
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); }
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); }
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"
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 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); }
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; }
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; }
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; }