Integer

Parent:Numeric

BigDecimal扩展了本地Integer类以提供to_d方法。

当您在应用程序中需要BigDecimal库时，此方法将在Integer对象上可用。

Add double dispatch to Integer

当需要mathn时，Integer的划分被增强以从数学表达式返回更精确的值。

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

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

保持整数值。您不能将单例方法添加到整数。任何将单例方法添加到Integer对象的尝试都会引发TypeError。

常量

GMP_VERSION

加载的GMP的版本。

Public Class Methods

each_prime(ubound) { |prime| ... } Show source

遍历所有素数的给定块。

有关Prime更多详细信息，请参阅#each。

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

from_prime_division(pd) Show source

重新构成素数分解并返回产品。

有关更多详细信息，请参阅Prime＃int_from_prime_division。

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

公共实例方法

int % other → real Show source

返回int模数other。

有关更多信息，请参阅Numeric#divmod。

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

integer & integer → integer_result Show source

Bitwise AND.

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

执行乘法运算：结果对象的类取决于结果的等级numeric和等级。它可能会返回一个Bignum。

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

integer ** numeric → numeric_result Show source

提高integer到numeric可能是负数或分数的力量。结果可能是一个整数或浮点数

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

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

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

执行加法：结果对象的类取决于结果大小的类别numeric和大小。它可能会返回一个Bignum。

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

int - numeric → numeric_result Show source

执行减法：结果对象的类取决于结果的等级numeric和等级。它可能会返回一个Bignum。

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

-int → integer Show source

否定int。（返回值为0-int的整数）

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 / numeric → numeric_result Show source

执行除法：结果对象的类取决于结果的等级numeric和等级。它可能会返回一个Bignum。

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

int < real → true or false Show source

如果值int小于real，则返回true。

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

int << count → integer Show source

转换int离开count位置，或者权利，如果count是负的。

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 <= real → true or false Show source

返回true值int如果小于或等于real。

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

int <=> numeric → -1, 0, +1 or nil Show source

Comparison - 返回-1，，0+ 1或nil取决于是否int小于，等于或大于numeric。

这是可比模块中测试的基础。

如果两个值无法比较，则返回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));
    }
}

int == other → true or false Show source

如果数值int和other相等则返回true。与此相反Integer#eql?，这需要其他人成为一个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;
}

===(p1) 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;
}

int > real → true or false Show source

如果值int大于real，则返回true。

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

int >= real → true or false Show source

返回true值，int如果大于或等于real。

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

int >> count → integer Show source

转移int正确的count位置，或者如果count是负值则离开。

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

intn → 0, 1 Show source

位参考 - 返回二进制表示中的第+ 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

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

integer ^ integer → integer_result 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

返回int的绝对值。

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

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

bit_length → integer Show source

返回int值的位数。

“比特数”意味着与符号比特不同的最高比特的比特位置。（位2 ** n的位位置是n + 1。）如果没有这样的位（零或负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＃包中的溢出，如下所示。

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

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

ceil(ndigits) → integer or float Show source

返回小于或等于int十进制数字的最小数字（默认为0位）。

精度可能是负面的。返回一个浮点数，当ndigits为正值时，self为零，并且为负值返回一个浮点数。

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

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

chr(encoding) → string Show source

返回一个字符串，其中包含由int值根据的字符表示的字符encoding。

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

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

coerce(numeric) → array Show source

返回一个数组，其中numeric和big表示为Bignum对象。

这是通过转换numeric成一个Bignum 来实现的。

如果numeric不是Fixnum或Bignum类型，则会引发TypeError 。

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

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

dclone() Show source

提供了一个统一的clone操作，用于REXML::XPathParser跨多个对象类型使用

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

denominator → 1 Show source

返回1。

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

digits → int()

digits(base) → int

返回数组，其中包含通过基数base为place-value的符号提取的数字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

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

div(numeric) → integer Show source

进行整数除法：返回除以整数结果int通过numeric。

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

divmod(numeric) → array Show source

请查阅Numeric#divmod。

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

downto(limit) {|i| block } → self Show source

downto(limit) → an_enumerator

迭代给定的块，将递减值从int下往上并包括在内limit。

如果没有给出块，则返回一个枚举器。

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

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

even? → true or false Show source

如果int是偶数，则返回true。

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

fdiv(numeric) → float Show source

返回划分的浮点结果integer通过numeric。

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

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

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

floor(ndigits) → integer or float Show source

返回小于或等于int十进制数字的最大数字（默认为0位数字）。

精度可能是负面的。返回一个浮点数，当ndigits为正数时，self为零，底层为负数。

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

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

gcd(int2) → integer Show source

返回最大公约数（总是正数）。0.gcd(x)和x.gcd(0)返回abs(x)。

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

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

gcdlcm(int2) → array Show source

返回一个数组；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]

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

inspect(*args)

别名为：to_s

integer? → true Show source

既然int已经是一个整数，这总是返回true。

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

lcm(int2) → integer Show source

返回最小公倍数（总是正值）。0.lcm(x)和x.lcm(0)返回零。

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

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

magnitude → integer Show source

返回的绝对值int。

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

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

modulo(other) → real Show source

返回int模数other。

有关更多信息，请参阅Numeric＃divmod。

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

next → integer Show source

返回等于int+ 1 的整数。

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

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

numerator → self Show source

返回self。

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

odd? → true or false Show source

如果int是奇数则返回true。

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

ord → self Show source

返回int自己。

?a.ord    #=> 97

该方法旨在兼容Ruby 1.9中的字符常量。

例如，？a.ord在1.8和1.9中都返回97。

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

pred → integer Show source

返回等于int-1 的整数。

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

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

prime?() Show source

如果self是素数，则返回true，否则返回false。

# 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

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

返回的因式分解self。

有关更多详情，请参阅Prime＃prime_division。

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

rationalize(eps) → rational Show source

将该值作为理性返回。可选参数eps总是被忽略。

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

remainder(numeric) → real Show source

返回后，将剩余大的数字为：

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。

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

round(ndigits) → integer or float Show source

以十进制数字的形式舍入int到给定的精度（默认为0位）。

精度可能是负面的。返回一个浮点数，当ndigits为正数时，self为零，向下舍入为负数。

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

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

size → int Show source

返回机器表示中的字节数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

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

succ → integer Show source

返回等于int+ 1 的整数。

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

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

times {|i| block } → self Show source

times → an_enumerator

迭代给定的块int时间，将值从零传递到int - 1。

如果没有给出块，则返回一个枚举器。

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

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

to_bn() Show source

将整型转换为OpenSSL::BN

查看man bn更多信息。

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

to_d → bigdecimal Show source

转换int为BigDecimal并返回。

require 'bigdecimal'
require 'bigdecimal/util'

42.to_d
# => 0.42e2

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

to_f → float Show source

转换int为Float。如果int不适合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);
}

to_i → integer Show source

由于int已经是一个整数，所有这些方法只是返回接收器。

同义词是to_int

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

to_i → integer Show source

由于int已经是一个整数，所有这些方法只是返回接收器。

同义词是to_int

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

to_r → rational Show source

将该值作为理性返回。

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

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

to_s(base=10) → string Show source

返回包含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"

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

还有别名：inspect

truncate(ndigits) → integer or float Show source

返回小于或等于int十进制数字的最小数字（默认为0位）。

精度可能是负面的。返回一个浮点数，当ndigits为正数时，self为零，截断为负数。

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

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

upto(limit) {|i| block } → self Show source

upto(limit) → an_enumerator

迭代给定的块，传递整数值，从小int到大包括limit。

如果没有给出块，则返回一个枚举器。

例如：

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

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

integer | integer → integer_result Show source

按位OR。

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

补码：返回每一位翻转的数字。

颠倒整数中的位。由于整数在概念上是无限的长度，所以结果就好像它的左边有一个无限的位。在十六进制表示中，这显示为数字左侧的两个句点。

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

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

	Integer