класс Integer

Родитель:: Numeric

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

Константы

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

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

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

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

Проходит по блоку со всеми простыми числами.

См. Prime#each для получения дополнительных сведений.

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

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

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

См. Prime#int_from_prime_division для получения дополнительных сведений.

sqrt(n) → 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, то есть наибольшее неотрицательное целое число, меньшее или равное квадратного корня n.

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

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

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

Если n не является Integer, оно преобразуется в Integer сначала. Если n отрицательно, генерируется Math::DomainError.

Методы экземпляра класса

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 для получения дополнительной информации.

Также алиас: modulo

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

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.

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

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

2 ** 3        #=> 8
2 ** -1       #=> (1/2)
2 ** 0.5      #=> 1.4142135623730951
(-1) ** 0.5   #=> (0.0+1.0i)

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

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.

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.

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

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

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

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 в зависимости от того, меньше ли, равно или больше ли int значения numeric.

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

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

int == other → true or false

Возвращает true, если int численно равно other. Противопоставьте это Integer#eql?, которое требует other быть целым числом Integer.

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

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

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

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

Также алиас: ==

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

int[n, m] → num

int[range] → num

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

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

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

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

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

p 255[-1] #=> 0

Range операции n[i, len] и n[i..j] естественным образом расширяются.

n[i, len] равно (n >> i) & ((1 << len) - 1).
n[i..j] равно (n >> i) & ((1 << (j - i + 1)) - 1).
n[i...j] равно (n >> i) & ((1 << (j - i)) - 1).
n[i..] равно (n >> i).
n[..j] равно нулю, если n & ((1 << (j + 1)) - 1) равно нулю. В противном случае, возбуждает ArgumentError.
n[...j] равно нулю, если n & ((1 << j) - 1) равно нулю. В противном случае, возбуждает ArgumentError.

Обратите внимание, что операции с диапазоном могут исчерпать память. Например, -1[0, 1000000000000] приведет к возбуждению NoMemoryError.

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

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

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

allbits?(mask) → true or false Показать исходный код

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, если все биты int & mask равны 1.

anybits?(mask) → true or false Показать исходный код

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, если хотя бы один бит int & mask равен 1.

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

# File integer.rb, line 73
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

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 num;
    }
    return rb_int_ceil(num, ndigits);
}

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

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

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

1.ceil           #=> 1
1.ceil(2)        #=> 1
18.ceil(-1)      #=> 20
(-18).ceil(-1)   #=> -10

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

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

65.chr    #=> "A"
230.chr   #=> "\xE6"
255.chr(Encoding::UTF_8)   #=> "\u00FF"

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.

Исключение TypeError возникает, если numeric не имеет тип Fixnum или Bignum.

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

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

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

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

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

digits(base) → array

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

Возвращает цифры позиционного представления int с основанием base (по умолчанию: 10). Цифры возвращаются в виде массива, где наименее значащая цифра является первым элементом массива.

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, ".. " }
puts "Liftoff!"
#=> "5.. 4.. 3.. 2.. 1.. Liftoff!"

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

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

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

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

654321.fdiv(13731)      #=> 47.652829364212366
654321.fdiv(13731.24)   #=> 47.65199646936475
-654321.fdiv(13731)     #=> -47.652829364212366

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 num;
    }
    return rb_int_floor(num, ndigits);
}

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

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

1.floor           #=> 1
1.floor(2)        #=> 1
18.floor(-1)      #=> 10
(-18).floor(-1)   #=> -20

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

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

gcdlcm(other_int) → 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));
}

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

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

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

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

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

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

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

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

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

# File integer.rb, line 95
def magnitude
  Primitive.attr! 'inline'
  Primitive.cexpr! 'rb_int_abs(self)'
end

modulo(other) → real

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

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

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

next → integer

Возвращает следующий за int элемент, то есть Integer, равный int+1.

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

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

nobits?(mask) → true or false Показать исходный код

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

Возвращает true, если ни один бит int & mask не равен 1.

numerator → self Show source

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

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

odd? → true or false Show source

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

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

ord → self Show source

# File integer.rb, line 120
def ord
  return self
end

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

97.ord   #=> 97

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

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

pow(numeric) → numeric Show source

pow(integer, integer) → integer

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

pred → integer Show source

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

Возвращает предшественника int, то есть Integer, равное int-1.

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

prime?() Show source

# File lib/prime.rb, line 35
def prime?
  return self >= 2 if self <= 3

  if (bases = miller_rabin_bases)
    return miller_rabin_test(bases)
  end

  return true if self == 5
  return false unless 30.gcd(self) == 1
  (7..Integer.sqrt(self)).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. Не рекомендуется для очень больших целых чисел (> 10**23).

prime_division(generator = Prime::Generator23.new) Show source

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

Возвращает факторизацию self.

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

rationalize([eps]) → rational Show source

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

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

remainder(numeric) → real Show source

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

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

x.remainder(y) означает x-y*(x/y).truncate.

5.remainder(3)     #=> 2
-5.remainder(3)    #=> -2
5.remainder(-3)    #=> 2
-5.remainder(-3)   #=> -2
5.remainder(1.5)   #=> 0.5

См. Numeric#divmod.

round([ndigits] [, half: mode]) → integer or float Show source

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

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

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

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

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

Необязательный аргумент ключевого слова half доступен аналогично Float#round.

25.round(-1, half: :up)      #=> 30
25.round(-1, half: :down)    #=> 20
25.round(-1, half: :even)    #=> 20
35.round(-1, half: :up)      #=> 40
35.round(-1, half: :down)    #=> 30
35.round(-1, half: :even)    #=> 40
(-25).round(-1, half: :up)   #=> -30
(-25).round(-1, half: :down) #=> -20
(-25).round(-1, half: :even) #=> -20

size → int Show source

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               #=> 8
-1.size              #=> 8
2147483647.size      #=> 8
(256**10 - 1).size   #=> 10
(256**20 - 1).size   #=> 20
(256**40 - 1).size   #=> 40

succ → integer Show source

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, то есть Integer, равное int+1.

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

Также имеет псевдоним: next

times {|i| block } → self Show source

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.

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

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

to_bn() Show source

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

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

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

to_d → bigdecimal Show source

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

to_f → float Show source

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 → integer Show source

# File integer.rb, line 130
def to_i
  return self
end

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

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

to_int → integer Show source

# File integer.rb, line 138
def to_int
  return self
end

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

to_r → rational Show source

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) → string Show source

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]) → integer or float Show source

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

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

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

1.truncate           #=> 1
1.truncate(2)        #=> 1
18.truncate(-1)      #=> 10
(-18).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));
        }
        ensure_cmp(c, i, to);
    }
    return from;
}

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

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

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

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

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

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

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

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

Побитовое ИЛИ.

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

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

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

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

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

Закрытые методы экземпляров

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

# File lib/prime.rb, line 69
        def miller_rabin_bases
  # Miller-Rabin's complexity is O(k log^3n).
  # So we can reduce the complexity by reducing the number of bases tested.
  # Using values from https://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test
  i = case
  when self < 0xffff                            then
    # For small integers, Miller Rabin can be slower
    # There is no mathematical significance to 0xffff
    return nil
# when self < 2_047                             then 0
  when self < 1_373_653                         then 1
  when self < 9_080_191                         then 2
  when self < 25_326_001                        then 3
  when self < 3_215_031_751                     then 4
  when self < 4_759_123_141                     then 5
  when self < 1_122_004_669_633                 then 6
  when self < 2_152_302_898_747                 then 7
  when self < 3_474_749_660_383                 then 8
  when self < 341_550_071_728_321               then 9
  when self < 3_825_123_056_546_413_051         then 10
  when self < 318_665_857_834_031_151_167_461   then 11
  when self < 3_317_044_064_679_887_385_961_981 then 12
  else return nil
  end
  MILLER_RABIN_BASES[i]
end

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

# File lib/prime.rb, line 96
        def miller_rabin_test(bases)
  return false if even?

  r = 0
  d = self >> 1
  while d.even?
    d >>= 1
    r += 1
  end

  self_minus_1 = self-1
  bases.each do |a|
    x = a.pow(d, self)
    next if x == 1 || x == self_minus_1 || a == self

    return false if r.times do
      x = x.pow(2, self)
      break if x == self_minus_1
    end
  end
  true
end

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