класс Integer

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

Возвращает целочисленный квадратный корень неотрицательного целого числа n — наибольшее неотрицательное целое число, меньшее или равное квадратному корню из numeric.

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

Если numeric не является объектом Integer, оно преобразуется в Integer:

Integer.sqrt(Complex(4, 0))  # => 2
Integer.sqrt(Rational(4, 1)) # => 2
Integer.sqrt(4.0)            # => 2
Integer.sqrt(3.14159)        # => 1

Этот метод эквивалентен Math.sqrt(numeric).floor, однако результат выполнения последнего кода может отличаться от точного значения из-за ограниченной точности арифметики с плавающей точкой.

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

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

static VALUE
int_s_try_convert(VALUE self, VALUE num)
{
    return rb_check_integer_type(num);
}

Если object является объектом Integer, возвращает object.

Integer.try_convert(1) # => 1

В противном случае, если object поддерживает :to_int, вызывает object.to_int и возвращает результат.

Integer.try_convert(1.25) # => 1

Возвращает nil, если object не поддерживает :to_int

Integer.try_convert([]) # => nil

Вызывает исключение, если object.to_int не возвращает объект 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)

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#| (побитовое ИЛИ), 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 99
def -@
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_int_uminus(self)'
end

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

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

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

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#& (побитовое И), Integer#| (побитовое ИЛИ).

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#& (побитовое И), Integer#^ (побитовое исключающее ИЛИ).

# File numeric.rb, line 118
def ~
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_int_comp(self)'
end

Дополнение до единицы: возвращает значение self, инвертируя каждый бит.

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

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

# File numeric.rb, line 132
def abs
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_int_abs(self)'
end

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

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

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 RBOOL(!int_zero_p(rb_int_and(num, mask)));
}

Возвращает 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 179
def bit_length
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_int_bit_length(self)'
end

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

Этот метод возвращает ceil(log2(self < 0 ? -self : self + 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

Для Integer n этот метод можно использовать для обнаружения переполнения в 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, которое должно быть объектом, преобразуемым в целое число.

• Если self равно нулю, возвращает ноль (независимо от значения ndigits):

  0.ceil(2)  # => 0
  0.ceil(-2) # => 0
  

• Если self не равно нулю, а ndigits неотрицательно, возвращает self:

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

• Если self не равно нулю, а ndigits отрицательно, возвращает значение, определяемое вычисленной точностью:

  • Точность равна 10 ** ndigits.abs.

  • Возвращаемое значение — наименьшее кратное точности, которое больше или равно self.

  Примеры с положительным self:

  ndigits	Точность	1234.ceil(ndigits)
  -1	10	1240
  -2	100	1300
  -3	1000	2000
  -4	10000	10000
  -5	100000	100000

  Примеры с отрицательным self:

  ndigits	Точность	-1234.ceil(ndigits)
  -1	10	-1230
  -2	100	-1200
  -3	1000	-1000
  -4	10000	0
  -5	100000	0

Связанный метод: Integer#floor.

# File numeric.rb, line 303
def ceildiv(other)
  -div(0 - other)
end

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

3.ceildiv(3)   # => 1
4.ceildiv(3)   # => 2

4.ceildiv(-3)  # => -1
-4.ceildiv(3)  # => -1
-4.ceildiv(-3) # => 2

3.ceildiv(1.2) # => 3

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

Возвращает строку из одного символа, представленного значением 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, и int представлены объектами Integer или Float.

Для этого numeric преобразуется в Integer или Float.

Вызывается исключение TypeError, если numeric не относится к типу Integer или Float.

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

# File numeric.rb, line 321
def denominator
  1
end

Возвращает 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

Вызывает исключение, если у numeric нет метода 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;
}

Возвращает массив из двух элементов [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 188
def even?
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_int_even_p(self)'
end

Возвращает true, если self является чётным числом, и false в противном случае.

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, которое должно быть объектом, преобразуемым в целое число.

• Если self равно нулю, возвращает ноль (независимо от значения ndigits):

  0.floor(2)  # => 0
  0.floor(-2) # => 0
  

• Если self не равно нулю, а ndigits неотрицательно, возвращает self:

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

• Если self не равно нулю, а ndigits отрицательно, возвращает значение, определяемое вычисленной точностью:

  • Точность равна 10 ** ndigits.abs.

  • Возвращаемое значение — наибольшее кратное точности, которое меньше или равно self.

  Примеры с положительным self:

  ndigits	Точность	1234.floor(ndigits)
  -1	10	1230
  -2	100	1200
  -3	1000	1000
  -4	10000	0
  -5	100000	0

  Примеры с отрицательным self:

  ndigits	Точность	-1234.floor(ndigits)
  -1	10	-1240
  -2	100	-1300
  -3	1000	-2000
  -4	10000	-10000
  -5	100000	-100000

Связанный метод: 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 197
def integer?
  true
end

Поскольку self уже является целым числом, всегда возвращает 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 RBOOL(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?.

# File numeric.rb, line 313
def numerator
  self
end

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

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

Возвращает true, если self является нечётным числом, и false в противном случае.

# File numeric.rb, line 217
def ord
  self
end

Возвращает self; предназначен для совместимости с символьными литералами в Ruby 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)) {
        if (FIXNUM_P(y)) {
            VALUE z = fix_mod(x, y);
            RUBY_ASSERT(FIXNUM_P(z));
            if (z != INT2FIX(0) && (SIGNED_VALUE)(x ^ y) < 0)
                z = fix_minus(z, y);
            return z;
        }
        else if (!RB_BIGNUM_TYPE_P(y)) {
            return num_remainder(x, y);
        }
        x = rb_int2big(FIX2LONG(x));
    }
    else if (!RB_BIGNUM_TYPE_P(x)) {
        return Qnil;
    }
    return rb_big_remainder(x, y);
}

Возвращает остаток от деления 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 234
def size
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_int_size(self)'
end

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

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#pred (предыдущее значение).

# File numeric.rb, line 250
def times
  Primitive.attr! :inline_block
  unless defined?(yield)
    return Primitive.cexpr! 'SIZED_ENUMERATOR(self, 0, 0, int_dotimes_size)'
  end
  i = 0
  while i < self
    yield i
    i = i.succ
  end
  self
end

Вызывает переданный блок 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`.

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 в число с плавающей запятой:

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 267
def to_i
  self
end

Возвращает self (которое уже является целым числом).

# File numeric.rb, line 275
def to_int
  self
end

Возвращает self (которое уже является целым числом).

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

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

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

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 выходит за допустимый диапазон.

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 283
def zero?
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_int_zero_p(self)'
end

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