класс Integer

Родитель:: Numeric

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

sqrt(n) → целое Показать исходный код

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 не является целым, оно преобразуется в целое в первую очередь. Если n отрицательно, генерируется исключение Math::DomainError.

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

int % other → real Show source

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

int & other_int → integer Show source

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

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

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

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

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

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, взятое с обратным знаком.

int / numeric → numeric_result Show source

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

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

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

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

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

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.

Сравните это с Numeric#eql?, который требует, чтобы other был Integer.

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

int == other → true or false Show source

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.

Сравните это с Numeric#eql?, который требует, чтобы other был Integer.

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

int > real → true or false Show source

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

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

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

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) {|n| print a[n] }
#=> 0000000000000000011001100101010

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

int ^ other_int → integer Show source

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

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
12345.abs      #=> 12345

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

allbits?(mask) → true or false Show source

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

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

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

bit_length → integer Show source

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.

«Количество битов» означает позицию бита самого старшего бита, который отличается от знакового бита (где наименее значимый бит имеет позицию бита 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 Show source

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

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   #=> "\xE6"
255.chr(Encoding::UTF_8)   #=> "\u00FF"

coerce(numeric) → array Show source

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]

dclone() Show source

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

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

denominator → 1 Show source

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

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

digits → array Show source

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

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

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

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

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

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

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

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

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]

inspect(*args)

Alias for: to_s

integer? → true Show source

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

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

lcm(other_int) → integer Show source

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

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
12345.abs      #=> 12345

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

modulo(other) → real Show source

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

nobits?(mask) → true or false Show source

static VALUE
int_nobits_p(VALUE num, VALUE mask)
{
    mask = rb_to_int(mask);
    return num_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

VALUE
rb_int_odd_p(VALUE num)
{
    if (FIXNUM_P(num)) {
        if (num & 2) {
            return Qtrue;
        }
    }
    else if (RB_TYPE_P(num, T_BIGNUM)) {
        return rb_big_odd_p(num);
    }
    else if (rb_funcall(num, '%', 1, INT2FIX(2)) != INT2FIX(0)) {
        return Qtrue;
    }
    return Qfalse;
}

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

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

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

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

97.ord   #=> 97

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

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

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

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_funcall(num, rb_intern("**"), 1, argv[0]);
    }
    else {
        VALUE const a = num;
        VALUE const b = argv[0];
        VALUE m = argv[1];
        int nega_flg = 0;
        if ( ! RB_INTEGER_TYPE_P(b)) {
            rb_raise(rb_eTypeError, "Integer#pow() 2nd argument not allowed unless a 1st argument is integer");
        }
        if (rb_num_negative_int_p(b)) {
            rb_raise(rb_eRangeError, "Integer#pow() 1st argument cannot be negative when 2nd argument specified");
        }
        if (!RB_INTEGER_TYPE_P(m)) {
            rb_raise(rb_eTypeError, "Integer#pow() 2nd argument not allowed unless all arguments are integers");
        }

        if (rb_num_negative_int_p(m)) {
            m = rb_funcall(m, idUMinus, 0);
            nega_flg = 1;
        }

        if (!rb_num_positive_int_p(m)) {
            rb_num_zerodiv();
        }
        if (FIXNUM_P(m)) {
            long const half_val = (long)HALF_LONG_MSB;
            long const mm = FIX2LONG(m);
            if (mm <= half_val) {
                return int_pow_tmp1(rb_int_modulo(a, m), b, mm, nega_flg);
            } else {
                return int_pow_tmp2(rb_int_modulo(a, m), b, mm, nega_flg);
            }
        } else if (RB_TYPE_P(m, T_BIGNUM)) {
            return int_pow_tmp3(rb_int_modulo(a, m), b, m, nega_flg);
        }
    }
    UNREACHABLE;
}

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

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

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, т.е. целое число, равное int-1.

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

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

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

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 всегда игнорируется.

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

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

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

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

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, т.е. целое число, равное 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 {|i| print i, " " }   #=> 0 1 2 3 4

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

# File ext/openssl/lib/openssl/bn.rb, line 36
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 → integer

to_int → integer

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

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

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

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

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

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

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

to_r → rational Показать исходный код

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

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

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

При отрицательной точности возвращаемое значение — целое число с как минимум ndigits.abs нулями в конце.

Возвращает 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));
        }
        if (NIL_P(c)) rb_cmperr(i, to);
    }
    return from;
}

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

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

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

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

Битовое ИЛИ.

END_OF_DOCUMENT_MARKER

~int → 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.