Spec-Zone.ru › Ruby 2.2

класс Integer

Родитель:
Числовой

BigDecimal расширяет встроенный класс Integer, чтобы обеспечить метод to_d.

Когда в вашем приложении требуется библиотека BigDecimal, этот метод будет доступен для объектов Integer.

Добавление двойного диспетчера к Integer

Этот класс является основой для двух конкретных классов, хранящих целые числа, Bignum и Fixnum.

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

each_prime(ubound) { |prime| ... } Показать исходный код 
# File lib/prime.rb, line 40
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 для получения дополнительной информации.

Общедоступные методы экземпляров

to_i → целое Показать исходный код 
static VALUE
int_to_i(VALUE num)
{
    return num;
}

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

Синонимами являются to_int, floor, ceil, truncate.

chr([кодировка]) → строка Показать исходный код 
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"
denominator → 1 Показать исходный код 
static VALUE
integer_denominator(VALUE self)
{
    return INT2FIX(1);
}

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

downto(предел) {|i| блок } → self Показать исходный код
downto(предел) → итератор 
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 включительно.

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

5.downto(1) { |n| print n, ".. " }
print "  Liftoff!\n"
#=> "5.. 4.. 3.. 2.. 1..   Liftoff!"
even? → true или false Показать исходный код 
static VALUE
int_even_p(VALUE num)
{
    if (rb_funcall(num, '%', 1, INT2FIX(2)) == INT2FIX(0)) {
        return Qtrue;
    }
    return Qfalse;
}

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

to_i → целое Показать исходный код 
static VALUE
int_to_i(VALUE num)
{
    return num;
}

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

Синонимами являются to_int, floor, ceil, truncate.

gcd(int2) → целое Показать исходный код 
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) → массив Показать исходный код 
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]
integer? → true Показать исходный код 
static VALUE
int_int_p(VALUE num)
{
    return Qtrue;
}

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

lcm(int2) → целое Показать исходный код 
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
next → целое Показать исходный код 
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 rb_funcall(num, '+', 1, INT2FIX(1));
}

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

1.next      #=> 2
(-1).next   #=> 0
numerator → self Показать исходный код 
static VALUE
integer_numerator(VALUE self)
{
    return self;
}

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

odd? → true или false Показать исходный код 
static VALUE
int_odd_p(VALUE num)
{
    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 → целое Показать исходный код 
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 rb_funcall(num, '-', 1, INT2FIX(1));
}

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

1.pred      #=> 0
(-1).pred   #=> -2
prime?() Показать исходный код 
# File lib/prime.rb, line 33
def prime?
  Prime.prime?(self)
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]) → рациональное Показать исходный код 
static VALUE
integer_rationalize(int argc, VALUE *argv, VALUE self)
{
    rb_scan_args(argc, argv, "01", NULL);
    return integer_to_r(self);
}

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

round([ndigits]) → целое или вещественное Показать исходный код 
static VALUE
int_round(int argc, VALUE* argv, VALUE num)
{
    VALUE n;
    int ndigits;

    if (argc == 0) return num;
    rb_scan_args(argc, argv, "1", &n);
    ndigits = NUM2INT(n);
    if (ndigits > 0) {
        return rb_Float(num);
    }
    if (ndigits == 0) {
        return num;
    }
    return int_round_0(num, ndigits);
}

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

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

1.round        #=> 1
1.round(2)     #=> 1.0
15.round(-1)   #=> 20
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 rb_funcall(num, '+', 1, INT2FIX(1));
}

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

1.next      #=> 2
(-1).next   #=> 0
times {|i| блок } → self Показать исходный код
times → итератор 
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(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 41
def to_bn
  OpenSSL::BN::new(self)
end

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

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

to_d → bigdecimal Показать исходный код 
# File ext/bigdecimal/lib/bigdecimal/util.rb, line 17
def to_d
  BigDecimal(self)
end

Преобразует int в BigDecimal и возвращает его.

require 'bigdecimal'
require 'bigdecimal/util'

42.to_d
# => #<BigDecimal:1008ef070,'0.42E2',9(36)>
to_i → целое Показать исходный код 
static VALUE
int_to_i(VALUE num)
{
    return num;
}

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

Синонимы — to_int, floor, ceil, truncate.

to_i → целое Показать исходный код 
static VALUE
int_to_i(VALUE num)
{
    return num;
}

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

Синонимы — to_int, floor, ceil, truncate.

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_i → целое Показать исходный код 
static VALUE
int_to_i(VALUE num)
{
    return num;
}

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

Синонимы — to_int, floor, ceil, truncate.

upto(предел) {|i| блок } → self Показать исходный код
upto(предел) → итератор 
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

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

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API