класс Integer

Родитель:: Numeric

Добавляет двойную отправку для Integer

Когда требуется mathn, деление Integer расширяется, чтобы возвращать более точные значения из математических выражений.

2/3*3  # => 0
require 'mathn'
2/3*3  # => 2

(2**72) / ((2**70) * 3)  # => 4/3

Содержит значения Integer. Вы не можете добавить метод-синглтон к Integer. Любая попытка добавить метод-синглтон к объекту Integer вызовет TypeError.

Константы

GMP_VERSION: Версия загруженного GMP.

Публичные методы класса

each_prime(ubound) { |prime| ... } Показать исходный код

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

Итерирует указанный блок по всем простым числам.

См. Prime#each для получения более подробной информации.

from_prime_division(pd) Показать исходный код

# File lib/prime.rb, line 21
def Integer.from_prime_division(pd)
  Prime.int_from_prime_division(pd)
end

Пересоставляет разложение на простые множители и возвращает произведение.

См. Prime#int_from_prime_division для получения более подробной информации.

Публичные методы экземпляра

int % other → real Показать исходный код

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

Возвращает int по модулю other.

См. Numeric#divmod для получения дополнительной информации.

integer & integer → integer_result Показать исходный код

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

Побитовое И.

int * numeric → numeric_result Показать исходный код

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 и от величины результата. Он может вернуть Bignum.

integer ** numeric → numeric_result Показать исходный код

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

Возводит integer в степень numeric, которая может быть отрицательной или дробной. Результатом может быть Integer или Float

2 ** 3      #=> 8
2 ** -1     #=> (1/2)
2 ** 0.5    #=> 1.4142135623731

123456789 ** 2      #=> 15241578750190521
123456789 ** 1.2    #=> 5126464716.09932
123456789 ** -2     #=> (1/15241578750190521)

int + numeric → numeric_result Показать исходный код

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 и от величины результата. Он может вернуть Bignum.

int - numeric → numeric_result Показать исходный код

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

Выполняет вычитание: класс результирующего объекта зависит от класса numeric и от величины результата. Он может вернуть Bignum.

-int → integer Показать исходный код

VALUE
rb_int_uminus(VALUE num)
{
    if (FIXNUM_P(num)) {
        return fix_uminus(num);
    }
    else if (RB_TYPE_P(num, T_BIGNUM)) {
        return rb_big_uminus(num);
    }
    return num_funcall0(num, idUMinus);
}

Изменяет знак int (возвращает целое число со значением 0-int).

int / numeric → numeric_result Показать исходный код

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

Выполняет деление: класс результирующего объекта зависит от класса numeric и от величины результата. Он может вернуть Bignum.

int < real → true or false Показать исходный код

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

Возвращает true, если значение int меньше значения real.

int << count → integer Показать исходный код

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

Сдвигает int влево на count позиций, или вправо, если count отрицателен.

int <= real → true or false Показать исходный код

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

Возвращает true, если значение int меньше или равно значению real.

int <=> numeric → -1, 0, +1 or nil Показать исходный код

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

Сравнение — Возвращает -1, 0, +1 или nil в зависимости от того, меньше ли, равно или больше int чем numeric.

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

nil возвращается, если два значения несравнимы.

int == other → true or false Показать исходный код

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

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

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

===(p1) Показать исходный код

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

int > real → true or false Показать исходный код

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

Возвращает true, если значение int больше значения real.

int >= real → true or false Показать исходный код

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

Возвращает true, если значение int больше или равно значению real.

int >> count → integer Показать исходный код

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

Сдвигает int вправо на count позиций, или влево, если count отрицателен.

int[n] → 0, 1 Показать исходный код

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

Битовая ссылка — Возвращает +n+-ый бит в двоичном представлении int, где int[0] — наименее значимый бит.

Например:

a = 0b11001100101010
30.downto(0) do |n| print a[n] end
#=> 0000000000000000011001100101010

a = 9**15
50.downto(0) do |n|
  print a[n]
end
#=> 000101110110100000111000011110010100111100010111001

integer ^ integer → integer_result Показать исходный код

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 Показать исходный код

VALUE
rb_int_abs(VALUE num)
{
    if (FIXNUM_P(num)) {
        return fix_abs(num);
    }
    else if (RB_TYPE_P(num, T_BIGNUM)) {
        return rb_big_abs(num);
    }
    return Qnil;
}

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

-12345.abs   #=> 12345
12345.abs    #=> 12345
-1234567890987654321.abs   #=> 1234567890987654321

bit_length → integer Показать исходный код

static VALUE
rb_int_bit_length(VALUE num)
{
    if (FIXNUM_P(num)) {
        return rb_fix_bit_length(num);
    }
    else if (RB_TYPE_P(num, T_BIGNUM)) {
        return rb_big_bit_length(num);
    }
    return Qnil;
}

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

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

То есть этот метод возвращает ceil(log2(int < 0 ? -int : int+1)).

(-2**10000-1).bit_length  #=> 10001
(-2**10000).bit_length    #=> 10000
(-2**10000+1).bit_length  #=> 10000
(-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
(2**10000-1).bit_length   #=> 10000
(2**10000).bit_length     #=> 10001
(2**10000+1).bit_length   #=> 10001

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

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

ceil([ndigits]) → integer or float Показать исходный код

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 rb_Float(num);
    }
    if (ndigits == 0) {
        return num;
    }
    return rb_int_ceil(num, ndigits);
}

Возвращает наименьшее число, большее или равное int, в десятичных разрядах (по умолчанию 0 разрядов).

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

1.ceil        #=> 1
1.ceil(2)     #=> 1.0
15.ceil(-1)   #=> 20

chr([encoding]) → string Показать исходный код

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

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

65.chr    #=> "A"
230.chr   #=> "\346"
255.chr(Encoding::UTF_8)   #=> "\303\277"

coerce(numeric) → array Показать исходный код

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.

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

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

dclone() Показать исходный код

# File lib/rexml/xpath_parser.rb, line 22
def dclone ; self ; end

предоставляет унифицированную clone операцию для REXML::XPathParser для использования с несколькими типами Object

denominator → 1 Показать исходный код

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

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

digits → [int] Показать исходный код

digits(base) → [int]

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

Возвращает массив, содержащий цифры, извлеченные с помощью записи по разрядам с основанием base числа int.

base должно быть больше или равно 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

div(numeric) → integer Показать исходный код

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

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

divmod(numeric) → array Показать исходный код

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

См. Numeric#divmod.

downto(limit) {|i| block } → self Показать исходный код

downto(limit) → an_enumerator

static VALUE
int_downto(VALUE from, VALUE to)
{
    RETURN_SIZED_ENUMERATOR(from, 1, &to, int_downto_size);
    if (FIXNUM_P(from) && FIXNUM_P(to)) {
        long i, end;

        end = FIX2LONG(to);
        for (i=FIX2LONG(from); i >= end; i--) {
            rb_yield(LONG2FIX(i));
        }
    }
    else {
        VALUE i = from, c;

        while (!(c = rb_funcall(i, '<', 1, to))) {
            rb_yield(i);
            i = rb_funcall(i, '-', 1, INT2FIX(1));
        }
        if (NIL_P(c)) rb_cmperr(i, to);
    }
    return from;
}

Итерирует заданный блок, передавая уменьшающиеся значения от int до и включая limit.

Если блок не задан, вместо этого возвращается Enumerator.

5.downto(1) { |n| print n, ".. " }
print "  Liftoff!\n"
#=> "5.. 4.. 3.. 2.. 1..   Liftoff!"

even? → true or false Показать исходный код

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

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

fdiv(numeric) → float Показать исходный код

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

Возвращает значение с плавающей запятой от деления integer на numeric.

654321.fdiv(13731)      #=> 47.6528293642124
654321.fdiv(13731.24)   #=> 47.6519964693647

-1234567890987654321.fdiv(13731)      #=> -89910996357705.5
-1234567890987654321.fdiv(13731.24)   #=> -89909424858035.7

floor([ndigits]) → integer or 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 rb_Float(num);
    }
    if (ndigits == 0) {
        return num;
    }
    return rb_int_floor(num, ndigits);
}

Возвращает наибольшее число, меньшее или равное int в десятичных разрядах (по умолчанию 0 разрядов).

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

1.floor        #=> 1
1.floor(2)     #=> 1.0
15.floor(-1)   #=> 10

gcd(int2) → integer Показать исходный код

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

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

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

gcdlcm(int2) → array Показать исходный код

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

Возвращает массив; [int.gcd(int2), int.lcm(int2)].

2.gcdlcm(2)                    #=> [2, 2]
3.gcdlcm(-7)                   #=> [1, 21]
((1<<31)-1).gcdlcm((1<<61)-1)  #=> [1, 4951760154835678088235319297]

inspect(*args)

Псевдоним для: to_s

integer? → true Показать исходный код

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

Поскольку int уже является целым числом, эта функция всегда возвращает true.

lcm(int2) → integer Показать исходный код

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

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

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

magnitude → integer Показать исходный код

VALUE
rb_int_abs(VALUE num)
{
    if (FIXNUM_P(num)) {
        return fix_abs(num);
    }
    else if (RB_TYPE_P(num, T_BIGNUM)) {
        return rb_big_abs(num);
    }
    return Qnil;
}

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

-12345.abs   #=> 12345
12345.abs    #=> 12345
-1234567890987654321.abs   #=> 1234567890987654321

modulo(other) → real Показать исходный код

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

Возвращает int по модулю other.

См. Numeric#divmod для получения дополнительной информации.

next → integer Показать исходный код

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

Возвращает целое число, равное int + 1.

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

numerator → self Показать исходный код

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

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

odd? → true or false Показать исходный код

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

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

ord → self Показать исходный код

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

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

?a.ord    #=> 97

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

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

pred → integer Показать исходный код

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

Возвращает целое число, равное int - 1.

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

prime?() Показать исходный код

# File lib/prime.rb, line 33
def prime?
  return self >= 2 if self <= 3
  return true if self == 5
  return false unless 30.gcd(self) == 1
  (7..Math.sqrt(self).to_i).step(30) do |p|
    return false if
      self%(p)    == 0 || self%(p+4)  == 0 || self%(p+6)  == 0 || self%(p+10) == 0 ||
      self%(p+12) == 0 || self%(p+16) == 0 || self%(p+22) == 0 || self%(p+24) == 0
  end
  true
end

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

prime_division(generator = Prime::Generator23.new) Показать исходный код

# File lib/prime.rb, line 28
def prime_division(generator = Prime::Generator23.new)
  Prime.prime_division(self, generator)
end

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

См. Prime#prime_division для получения дополнительной информации.

rationalize([eps]) → rational Показать исходный код

static VALUE
integer_rationalize(int argc, VALUE *argv, VALUE self)
{
    rb_scan_args(argc, argv, "01", NULL);
    return integer_to_r(self);
}

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

END_OF_DOCUMENT_MARKER

remainder(numeric) → real Показать исходный код

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

Возвращает остаток от деления big на 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

-1234567890987654321.remainder(13731)      #=> -6966
-1234567890987654321.remainder(13731.24)   #=> -9906.22531493148

См. Numeric#divmod.

round([ndigits]) → целое число или число с плавающей точкой Показать исходный код

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 rb_Float(num);
    }
    if (ndigits == 0) {
        return num;
    }
    return rb_int_round(num, ndigits, mode);
}

Округляет int до заданной точности в десятичных разрядах (по умолчанию 0 разрядов).

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

1.round        #=> 1
1.round(2)     #=> 1.0
15.round(-1)   #=> 20

size → int Показать исходный код

static VALUE
int_size(VALUE num)
{
    if (FIXNUM_P(num)) {
        return fix_size(num);
    }
    else if (RB_TYPE_P(num, T_BIGNUM)) {
        return rb_big_size_m(num);
    }
    return Qnil;
}

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

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

succ → целое число Показать исходный код

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

Возвращает Целое число, равное int + 1.

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

times {|i| block } → self Показать исходный код

times → an_enumerator

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

Итерирует заданный блок int раз, передавая значения от нуля до int - 1.

Если блок не задан, вместо него возвращается Итератор.

5.times do |i|
  print i, " "
end
#=> 0 1 2 3 4

to_bn() Показать исходный код

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

Преобразует Целое число в OpenSSL::BN

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

to_d → bigdecimal Показать исходный код

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

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

require 'bigdecimal'
require 'bigdecimal/util'

42.to_d   # => 0.42e2

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

to_f → float Показать исходный код

static VALUE
int_to_f(VALUE num)
{
    double val;

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

    return DBL2NUM(val);
}

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

to_i → целое число Показать исходный код

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

Поскольку int уже является целым числом, все эти методы просто возвращают получатель.

Синонимы: to_int

to_i → целое число Показать исходный код

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

Поскольку int уже является целым числом, все эти методы просто возвращают получатель.

Синонимы: to_int

to_r → рациональное число Показать исходный код

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

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

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

to_s(base=10) → строка Показать исходный код

static VALUE
int_to_s(int argc, VALUE *argv, VALUE x)
{
    int base;

    if (rb_check_arity(argc, 0, 1))
        base = NUM2INT(argv[0]);
    else
        base = 10;
    return rb_int2str(x, base);
}

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

Также алиасируется как: inspect

truncate([ndigits]) → целое число или число с плавающей точкой Показать исходный код

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 rb_Float(num);
    }
    if (ndigits == 0) {
        return num;
    }
    return rb_int_truncate(num, ndigits);
}

Возвращает наименьшее число, которое меньше или равно int в десятичных разрядах (по умолчанию 0 разрядов).

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

1.truncate        #=> 1
1.truncate(2)     #=> 1.0
15.truncate(-1)   #=> 10

upto(limit) {|i| block } → self Показать исходный код

upto(limit) → an_enumerator

static VALUE
int_upto(VALUE from, VALUE to)
{
    RETURN_SIZED_ENUMERATOR(from, 1, &to, int_upto_size);
    if (FIXNUM_P(from) && FIXNUM_P(to)) {
        long i, end;

        end = FIX2LONG(to);
        for (i = FIX2LONG(from); i <= end; i++) {
            rb_yield(LONG2FIX(i));
        }
    }
    else {
        VALUE i = from, c;

        while (!(c = rb_funcall(i, '>', 1, to))) {
            rb_yield(i);
            i = rb_funcall(i, '+', 1, INT2FIX(1));
        }
        if (NIL_P(c)) rb_cmperr(i, to);
    }
    return from;
}

Итерирует заданный блок, передавая целочисленные значения от int до и включая limit.

Если блок не задан, вместо него возвращается Итератор.

Например:

5.upto(10) { |i| print i, " " }
#=> 5 6 7 8 9 10

integer | integer → integer_result Показать исходный код

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 → integer Показать исходный код

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

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

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

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

Ruby Core © 1993–2017 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.