класс Integer

VALUE
rb_int_modulo(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_mod(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_modulo(x, y);
    }
    return num_modulo(x, y);
}

Возвращает остаток от деления self на other как действительное число.

Для целого числа n и действительного числа r, эти выражения эквивалентны:

n % r
n-r*(n/r).floor
n.divmod(r)[1]

См. Numeric#divmod.

Примеры:

10 % 2              # => 0
10 % 3              # => 1
10 % 4              # => 2

10 % -2             # => 0
10 % -3             # => -2
10 % -4             # => -2

10 % 3.0            # => 1.0
10 % Rational(3, 1) # => (1/1)

Integer#modulo — псевдоним для Integer#%.

VALUE
rb_int_and(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_and(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_and(x, y);
    }
    return Qnil;
}

Побитовое И; каждый бит результата равен 1, если соответствующие биты в self и other равны 1, в противном случае 0:

"%04b" % (0b0101 & 0b0110) # => "0100"

Вызывает исключение, если other не является целым числом.

Связанные: Integer#| (побитовое ИЛИ), Integer#^ (побитовое ИСКЛЮЧАЮЩЕЕ ИЛИ).

VALUE
rb_int_mul(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_mul(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_mul(x, y);
    }
    return rb_num_coerce_bin(x, y, '*');
}

Выполняет умножение:

4 * 2              # => 8
4 * -2             # => -8
-4 * 2             # => -8
4 * 2.0            # => 8.0
4 * Rational(1, 3) # => (4/3)
4 * Complex(2, 0)  # => (8+0i)

VALUE
rb_int_pow(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_pow(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_pow(x, y);
    }
    return Qnil;
}

Возводит self в степень numeric:

2 ** 3              # => 8
2 ** -3             # => (1/8)
-2 ** 3             # => -8
-2 ** -3            # => (-1/8)
2 ** 3.3            # => 9.849155306759329
2 ** Rational(3, 1) # => (8/1)
2 ** Complex(3, 0)  # => (8+0i)

VALUE
rb_int_plus(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_plus(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_plus(x, y);
    }
    return rb_num_coerce_bin(x, y, '+');
}

Выполняет сложение:

2 + 2              # => 4
-2 + 2             # => 0
-2 + -2            # => -4
2 + 2.0            # => 4.0
2 + Rational(2, 1) # => (4/1)
2 + Complex(2, 0)  # => (4+0i)

VALUE
rb_int_minus(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_minus(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_minus(x, y);
    }
    return rb_num_coerce_bin(x, y, '-');
}

Выполняет вычитание:

4 - 2              # => 2
-4 - 2             # => -6
-4 - -2            # => -2
4 - 2.0            # => 2.0
4 - Rational(2, 1) # => (2/1)
4 - Complex(2, 0)  # => (2+0i)

# File numeric.rb, line 52
def -@
  Primitive.attr! 'inline'
  Primitive.cexpr! 'rb_int_uminus(self)'
end

Возвращает int, с противоположным знаком.

VALUE
rb_int_div(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_div(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_div(x, y);
    }
    return Qnil;
}

Выполняет деление; для целого числа numeric, результат усекается до целого числа:

 4 / 3              # => 1
 4 / -3             # => -2
 -4 / 3             # => -2
 -4 / -3            # => 1

For other +numeric+, returns non-integer result:

 4 / 3.0            # => 1.3333333333333333
 4 / Rational(3, 1) # => (4/3)
 4 / Complex(3, 0)  # => ((4/3)+0i)

static VALUE
int_lt(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_lt(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_lt(x, y);
    }
    return Qnil;
}

Возвращает true если значение self меньше значения other:

  1 < 0              # => false
  1 < 1              # => false
  1 < 2              # => true
  1 < 0.5            # => false
  1 < Rational(1, 2) # => false

Raises an exception if the comparison cannot be made.

VALUE
rb_int_lshift(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return rb_fix_lshift(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_lshift(x, y);
    }
    return Qnil;
}

Возвращает self с битами, сдвинутыми влево на count позиций, или вправо, если count отрицательно:

n = 0b11110000
"%08b" % (n << 1)  # => "111100000"
"%08b" % (n << 3)  # => "11110000000"
"%08b" % (n << -1) # => "01111000"
"%08b" % (n << -3) # => "00011110"

Связанные: Integer#>>.

static VALUE
int_le(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_le(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_le(x, y);
    }
    return Qnil;
}

Возвращает true если значение self меньше или равно значению other:

1 <= 0              # => false
1 <= 1              # => true
1 <= 2              # => true
1 <= 0.5            # => false
1 <= Rational(1, 2) # => false

Вызывает исключение, если сравнение невозможно.

VALUE
rb_int_cmp(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_cmp(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_cmp(x, y);
    }
    else {
        rb_raise(rb_eNotImpError, "need to define `<=>' in %s", rb_obj_classname(x));
    }
}

Возвращает:

• -1, если self меньше other.

• 0, если self равно other.

• 1, если self больше other.

• nil, если self и other несравнимы.

Примеры:

1 <=> 2              # => -1
1 <=> 1              # => 0
1 <=> 0              # => 1
1 <=> 'foo'          # => nil

1 <=> 1.0            # => 0
1 <=> Rational(1, 1) # => 0
1 <=> Complex(1, 0)  # => 0

Этот метод является основой для сравнений в модуле Comparable.

VALUE
rb_int_equal(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_equal(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_eq(x, y);
    }
    return Qnil;
}

Возвращает true если self численно равно other; false в противном случае.

1 == 2     #=> false
1 == 1.0   #=> true

Связанные: Integer#eql? (требует, чтобы other был целым числом).

Integer#=== — псевдоним для Integer#==.

VALUE
rb_int_gt(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_gt(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_gt(x, y);
    }
    return Qnil;
}

Возвращает true если значение self больше значения other:

  1 > 0              # => true
  1 > 1              # => false
  1 > 2              # => false
  1 > 0.5            # => true
  1 > Rational(1, 2) # => true

Raises an exception if the comparison cannot be made.

VALUE
rb_int_ge(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_ge(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_ge(x, y);
    }
    return Qnil;
}

Возвращает true если значение self больше или равно значению other:

1 >= 0              # => true
1 >= 1              # => true
1 >= 2              # => false
1 >= 0.5            # => true
1 >= Rational(1, 2) # => true

Вызывает исключение, если сравнение невозможно.

static VALUE
rb_int_rshift(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return rb_fix_rshift(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_rshift(x, y);
    }
    return Qnil;
}

Возвращает self с битами, сдвинутыми вправо на count позиций, или влево, если count отрицательно:

n = 0b11110000
"%08b" % (n >> 1)  # => "01111000"
"%08b" % (n >> 3)  # => "00011110"
"%08b" % (n >> -1) # => "111100000"
"%08b" % (n >> -3) # => "11110000000"

Связанные: Integer#<<.

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

Возвращает срез битов из self.

При аргументе offset, возвращает бит по заданному смещению, где смещение 0 относится к наименее значащему биту:

n = 0b10 # => 2
n[0]     # => 0
n[1]     # => 1
n[2]     # => 0
n[3]     # => 0

По сути, n[i] эквивалентно (n >> i) & 1. Таким образом, отрицательный индекс всегда возвращает ноль:

255[-1] # => 0

С аргументами offset и size, возвращает size битов из self, начиная с offset и включая биты большей значимости:

n = 0b111000       # => 56
"%010b" % n[0, 10] # => "0000111000"
"%010b" % n[4, 10] # => "0000000011"

С аргументом range, возвращает range.size битов из self, начиная с range.begin и включая биты большей значимости:

n = 0b111000      # => 56
"%010b" % n[0..9] # => "0000111000"
"%010b" % n[4..9] # => "0000000011"

Вызывает исключение, если срез нельзя создать.

static VALUE
int_xor(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_xor(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_xor(x, y);
    }
    return Qnil;
}

Побитовое ИСКЛЮЧАЮЩЕЕ ИЛИ; каждый бит результата равен 1, если соответствующие биты в self и other различаются, и 0 в противном случае:

"%04b" % (0b0101 ^ 0b0110) # => "0011"

Вызывает исключение, если other не является целым числом.

Связанные: Integer#& (побитовое И), Integer#| (побитовое ИЛИ).

# File numeric.rb, line 84
def abs
  Primitive.attr! 'inline'
  Primitive.cexpr! 'rb_int_abs(self)'
end

Возвращает абсолютное значение int.

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

Integer#magnitude является псевдонимом для Integer#abs.

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

Возвращает true, если все биты, установленные (=1) в mask, также установлены в self; в противном случае возвращает false.

Примеры значений:

0b1010101  self
0b1010100  mask
0b1010100  self & mask
     true  self.allbits?(mask)

0b1010100  self
0b1010101  mask
0b1010100  self & mask
    false  self.allbits?(mask)

Связанные: Integer#anybits?, Integer#nobits?.

static VALUE
int_anybits_p(VALUE num, VALUE mask)
{
    mask = rb_to_int(mask);
    return int_zero_p(rb_int_and(num, mask)) ? Qfalse : Qtrue;
}

Возвращает true, если любой бит, установленный (=1) в mask, также установлен в self; в противном случае возвращает false.

Примеры значений:

0b10000010  self
0b11111111  mask
0b10000010  self & mask
      true  self.anybits?(mask)

0b00000000  self
0b11111111  mask
0b00000000  self & mask
     false  self.anybits?(mask)

Связанные: Integer#allbits?, Integer#nobits?.

# File numeric.rb, line 130
def bit_length
  Primitive.attr! 'inline'
  Primitive.cexpr! 'rb_int_bit_length(self)'
end

Возвращает количество битов значения int.

«Количество битов» означает позицию бита самого старшего бита, отличного от знака бита (где младший бит имеет позицию 1). Если такого бита нет (ноль или минус один), возвращается ноль.

То есть этот метод возвращает 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

Этот метод можно использовать для обнаружения переполнения в Array#pack следующим образом:

if n.bit_length < 32
  [n].pack("l") # no overflow
else
  raise "overflow"
end

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

Возвращает наименьшее число, большее или равное self с точностью до ndigits десятичных знаков.

Когда точность отрицательная, возвращаемое значение — целое число с как минимум ndigits.abs последующими нулями:

555.ceil(-1)  # => 560
555.ceil(-2)  # => 600
-555.ceil(-2) # => -500
555.ceil(-3)  # => 1000

Возвращает self, когда ndigits равно нулю или положительно.

555.ceil     # => 555
555.ceil(50) # => 555

Связанные: Integer#floor.

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, "%u 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);
}

Возвращает строку из 1 символа, содержащую символ, представленный значением self, в соответствии с заданной encoding.

65.chr                   # => "A"
0..chr                   # => "\x00"
255.chr                  # => "\xFF"
string = 255.chr(Encoding::UTF_8)
string.encoding          # => Encoding::UTF_8

Вызывает исключение, если self отрицательное.

Связанные: Integer#ord.

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

Возвращает массив, содержащий как numeric, так и big, представленные как объекты Bignum.

Это достигается путем преобразования numeric в Bignum.

Исключение TypeError генерируется, если numeric не является типом Fixnum или Bignum.

(0x3FFFFFFFFFFFFFFF+1).coerce(42)   #=> [42, 4611686018427387904]

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

Возвращает 1.

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_BIGNUM_TYPE_P(base_value))
            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_BIGNUM_TYPE_P(num))
        return rb_int_digits_bigbase(num, LONG2FIX(base));

    return Qnil;
}

Возвращает массив целых чисел, представляющих base-ричные цифры self; первый элемент массива представляет наименее значащую цифру:

12345.digits      # => [5, 4, 3, 2, 1]
12345.digits(7)   # => [4, 6, 6, 0, 5]
12345.digits(100) # => [45, 23, 1]

Вызывает исключение, если self отрицательное или base меньше 2.

VALUE
rb_int_idiv(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_idiv(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_idiv(x, y);
    }
    return num_div(x, y);
}

Выполняет целочисленное деление; возвращает результат целочисленного деления self на numeric:

  4.div(3)      # => 1
  4.div(-3)      # => -2
  -4.div(3)      # => -2
  -4.div(-3)      # => 1
  4.div(3.0)      # => 1
  4.div(Rational(3, 1))      # => 1

Raises an exception if +numeric+ does not have method +div+.

VALUE
rb_int_divmod(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_divmod(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_divmod(x, y);
    }
    return Qnil;
}

Возвращает массив из 2 элементов [q, r], где

q = (self/other).floor    # Quotient
r = self % other          # Remainder

Примеры:

11.divmod(4)              # => [2, 3]
11.divmod(-4)             # => [-3, -1]
-11.divmod(4)             # => [-3, 1]
-11.divmod(-4)            # => [2, -3]

12.divmod(4)              # => [3, 0]
12.divmod(-4)             # => [-3, 0]
-12.divmod(4)             # => [-3, 0]
-12.divmod(-4)            # => [3, 0]

13.divmod(4.0)            # => [3, 1.0]
13.divmod(Rational(4, 1)) # => [3, (1/1)]

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

Вызывает заданный блок с каждым целочисленным значением от self до limit; возвращает self:

a = []
10.downto(5) {|i| a << i }              # => 10
a                                       # => [10, 9, 8, 7, 6, 5]
a = []
0.downto(-5) {|i| a << i }              # => 0
a                                       # => [0, -1, -2, -3, -4, -5]
4.downto(5) {|i| fail 'Cannot happen' } # => 4

Без заданного блока возвращает Enumerator.

# File numeric.rb, line 139
def even?
  Primitive.attr! 'inline'
  Primitive.cexpr! 'rb_int_even_p(self)'
end

Возвращает true, если int — чётное число.

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

Возвращает результат деления self на numeric как число с плавающей точкой Float:

4.fdiv(2)      # => 2.0
4.fdiv(-2)      # => -2.0
-4.fdiv(2)      # => -2.0
4.fdiv(2.0)      # => 2.0
4.fdiv(Rational(3, 4))      # => 5.333333333333333

Вызывает исключение, если numeric нельзя преобразовать в Float.

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

Возвращает наибольшее число, меньшее или равное self с точностью до ndigits десятичных знаков.

Когда ndigits отрицательное, возвращаемое значение имеет как минимум ndigits.abs последующих нулей:

555.floor(-1)  # => 550
555.floor(-2)  # => 500
-555.floor(-2) # => -600
555.floor(-3)  # => 0

Возвращает self, когда ndigits равно нулю или положительно.

555.floor     # => 555
555.floor(50) # => 555

Связанные: Integer#ceil.

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

Возвращает наибольший общий делитель двух целых чисел. Результат всегда положительный. 0.gcd(x) и x.gcd(0) возвращают x.abs.

36.gcd(60)                  #=> 12
2.gcd(2)                    #=> 2
3.gcd(-7)                   #=> 1
((1<<31)-1).gcd((1<<61)-1)  #=> 1

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

Возвращает массив с наибольшим общим делителем и наименьшим общим кратным двух целых чисел, [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]

# File numeric.rb, line 148
def integer?
  return true
end

Так как int уже является Integer, это всегда возвращает true.

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

Возвращает наименьшее общее кратное двух целых чисел. Результат всегда положительный. 0.lcm(x) и x.lcm(0) возвращают ноль.

36.lcm(60)                  #=> 180
2.lcm(2)                    #=> 2
3.lcm(-7)                   #=> 21
((1<<31)-1).lcm((1<<61)-1)  #=> 4951760154835678088235319297

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

Возвращает true, если ни один бит, установленный (=1) в mask, не установлен в self; в противном случае возвращает false.

Примеры значений:

0b11110000  self
0b00001111  mask
0b00000000  self & mask
      true  self.nobits?(mask)

0b00000001  self
0b11111111  mask
0b00000001  self & mask
     false  self.nobits?(mask)

Связанно с: Integer#allbits?, Integer#anybits?.

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

Возвращает self.

# File numeric.rb, line 164
def odd?
  Primitive.attr! 'inline'
  Primitive.cexpr! 'rb_int_odd_p(self)'
end

Возвращает true, если int — нечётное число.

# File numeric.rb, line 180
def ord
  return self
end

Возвращает само int.

97.ord   #=> 97

Этот метод предназначен для совместимости с литералами символов в Ruby 1.9.

Например, ?a.ord возвращает 97 как в 1.8, так и в 1.9.

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 == 1) return INT2FIX(0);
            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();
	    if (bignorm(m) == INT2FIX(1)) return INT2FIX(0);
            return int_pow_tmp3(rb_int_modulo(a, m), b, m, nega_flg);
        }
    }
    UNREACHABLE_RETURN(Qnil);
}

Возвращает (модулярное) возведение в степень, как:

a.pow(b)     #=> same as a**b
a.pow(b, m)  #=> same as (a**b) % m, but avoids huge temporary values

static VALUE
rb_int_pred(VALUE num)
{
    if (FIXNUM_P(num)) {
        long i = FIX2LONG(num) - 1;
        return LONG2NUM(i);
    }
    if (RB_BIGNUM_TYPE_P(num)) {
        return rb_big_minus(num, INT2FIX(1));
    }
    return num_funcall1(num, '-', INT2FIX(1));
}

Возвращает предшествующее целое число для self (эквивалентно self - 1):

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

Связанно с: Integer#succ (последующее значение).

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

Возвращает значение в виде рационального числа. Необязательный аргумент eps всегда игнорируется.

static VALUE
int_remainder(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return num_remainder(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_remainder(x, y);
    }
    return Qnil;
}

Возвращает остаток от деления self на other.

Примеры:

11.remainder(4)              # => 3
11.remainder(-4)             # => 3
-11.remainder(4)             # => -3
-11.remainder(-4)            # => -3

12.remainder(4)              # => 0
12.remainder(-4)             # => 0
-12.remainder(4)             # => 0
-12.remainder(-4)            # => 0

13.remainder(4.0)            # => 1.0
13.remainder(Rational(4, 1)) # => (1/1)

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

Возвращает self, округлённое до ближайшего значения с точностью до ndigits десятичных знаков.

Когда ndigits отрицательно, возвращаемое значение содержит как минимум ndigits.abs последующих нулей:

555.round(-1)      # => 560
555.round(-2)      # => 600
555.round(-3)      # => 1000
-555.round(-2)     # => -600
555.round(-4)      # => 0

Возвращает self когда ndigits равно нулю или положительно.

555.round     # => 555
555.round(1)  # => 555
555.round(50) # => 555

Если задан ключевой аргумент half и self равноудалено от двух кандидатных значений, округление производится согласно заданному значению half:

• :up или nil: округление от нуля:

  25.round(-1, half: :up)      # => 30
  (-25).round(-1, half: :up)   # => -30
  

• :down: округление к нулю:

  25.round(-1, half: :down)    # => 20
  (-25).round(-1, half: :down) # => -20
  

• :even: округление к кандидату, чья последняя ненулевая цифра чётная:

  25.round(-1, half: :even)    # => 20
  15.round(-1, half: :even)    # => 20
  (-25).round(-1, half: :even) # => -20
  

Вызывает исключение, если значение для half некорректно.

Связанно с: Integer#truncate.

# File numeric.rb, line 199
def size
  Primitive.attr! 'inline'
  Primitive.cexpr! 'rb_int_size(self)'
end

Метод документации: Integer#size

Возвращает количество байтов в машинном представлении int (зависит от машины).

1.size               #=> 8
-1.size              #=> 8
2147483647.size      #=> 8
(256**10 - 1).size   #=> 10
(256**20 - 1).size   #=> 20
(256**40 - 1).size   #=> 40

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

Возвращает следующее целое число после self (эквивалентно self + 1):

1.succ  #=> 2
-1.succ #=> 0

Integer#next — псевдоним для Integer#succ.

Связанно с: Integer#pred (предыдущее значение).

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(int_le(i, num))) break;
            rb_yield(i);
            i = rb_int_plus(i, INT2FIX(1));
        }
    }
    return num;
}

Вызывает заданный блок self раз с каждым целым числом в (0..self-1):

a = []
5.times {|i| a.push(i) } # => 5
a                        # => [0, 1, 2, 3, 4]

Без блока возвращает Enumerator.

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

Преобразует Integer в OpenSSL::BN.

См. ‘man bn` для получения дополнительной информации.

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

Возвращает значение int в виде BigDecimal.

require 'bigdecimal'
require 'bigdecimal/util'

42.to_d   # => 0.42e2

См. также BigDecimal::new.

static VALUE
int_to_f(VALUE num)
{
    double val;

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

    return DBL2NUM(val);
}

Преобразует self в Float:

1.to_f  # => 1.0
-1.to_f # => -1.0

Если значение self не помещается в Float, результат равен бесконечности:

(10**400).to_f  # => Infinity
(-10**400).to_f # => -Infinity

# File numeric.rb, line 210
def to_i
  return self
end

Поскольку int уже является Integer, возвращает self.

to_int является псевдонимом для to_i.

# File numeric.rb, line 218
def to_int
  return self
end

Поскольку int уже является Integer, возвращает self.

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

Возвращает значение в виде рационального числа.

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

MJIT_FUNC_EXPORTED VALUE
rb_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);
}

Возвращает строку, содержащую представление self в системе счисления base (в диапазоне от 2 до 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"

Вызывает исключение, если base находится вне допустимого диапазона.

Integer#inspect является псевдонимом для Integer#to_s.

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

Возвращает self, усечённое (к нулю) до точности ndigits десятичных знаков.

Когда ndigits отрицательно, возвращаемое значение имеет как минимум ndigits.abs конечных нулей:

555.truncate(-1)  # => 550
555.truncate(-2)  # => 500
-555.truncate(-2) # => -500

Возвращает self, когда ndigits равно нулю или положительно.

555.truncate     # => 555
555.truncate(50) # => 555

Связанно с: Integer#round.

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));
        }
        ensure_cmp(c, i, to);
    }
    return from;
}

Вызывает переданный блок для каждого целого значения от self до limit; возвращает self:

a = []
5.upto(10) {|i| a << i }              # => 5
a                                     # => [5, 6, 7, 8, 9, 10]
a = []
-5.upto(0) {|i| a << i }              # => -5
a                                     # => [-5, -4, -3, -2, -1, 0]
5.upto(4) {|i| fail 'Cannot happen' } # => 5

Без блока возвращает Enumerator.

# File numeric.rb, line 226
def zero?
  Primitive.attr! 'inline'
  Primitive.cexpr! 'rb_int_zero_p(self)'
end

Возвращает true, если int имеет нулевое значение.

static VALUE
int_or(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_or(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_or(x, y);
    }
    return Qnil;
}

Битовое ИЛИ; каждый бит результата равен 1, если соответствующий бит в self или other равен 1, иначе 0:

"%04b" % (0b0101 | 0b0110) # => "0111"

Вызывает исключение, если other не является целым числом.

Связанные: Integer#& (битовое И), Integer#^ (битовое ИСКЛЮЧАЮЩЕЕ ИЛИ).

# File numeric.rb, line 68
def ~
  Primitive.attr! 'inline'
  Primitive.cexpr! 'rb_int_comp(self)'
end

Однодополнительный код: возвращает число, где каждый бит инвертирован.

Инвертирует биты в Integer. Поскольку целые числа концептуально бесконечны, результат ведет себя так, как будто у него бесконечное количество единиц слева. В шестнадцатеричном представлении это отображается двумя точками слева от цифр.

sprintf("%X", ~0x1122334455)    #=> "..FEEDDCCBBAA"