类 Integer

Integer 对象表示一个整数值。

您可以使用以下方法显式创建 Integer 对象：

整数字面量。

您可以使用以下方法将某些对象转换为 Integer：

方法 Integer。

尝试向此类的实例添加单例方法会导致引发异常。

内容¶ ↑

首先，了解一下其他地方的内容。类 Integer

继承自类 Numeric。

这里，类 Integer 提供了以下方法：

查询¶ ↑

allbits?: 返回 self 中的所有位是否都已设置。
anybits?: 返回 self 中的任何位是否已设置。
nobits?: 返回 self 中的任何位是否都未设置。

比较¶ ↑

#<: 返回 self 是否小于给定值。
#<=: 返回 self 是否小于或等于给定值。
#<=>: 返回一个数字，指示 `self` 是否小于、等于或大于给定值。
== (别名为 ===): 返回 `self` 是否等于给定值。
```
value.
```
#>: 返回 `self` 是否大于给定值。
#>=: 返回 `self` 是否大于或等于给定值。

转换¶ ↑

::sqrt: 返回给定值的整数平方根。
::try_convert: 返回转换为整数的给定值。
% (别名为 modulo): 返回 `self` 对给定值的模。
#&: 返回 `self` 和给定值的按位与。
*: 返回 `self` 和给定值的乘积。
**: 返回 `self` 的给定次幂的值。
+: 返回 `self` 和给定值的和。
-: 返回 `self` 和给定值的差。
#/: 返回 `self` 和给定值的商。
<<: 返回 `self` 左移后的值。
>>: 返回 `self` 右移后的值。
[]: 返回 `self` 中的位切片。
#^: 返回 `self` 和给定值的按位异或。
ceil: 返回大于或等于 `self` 的最小数。
chr: 返回一个包含 `self` 值所代表的字符的 1 个字符字符串。
digits: 返回一个整数数组，表示 `self` 的基数为 radix 的数字。
div: 返回将self除以给定值的整数结果。
divmod: 返回一个包含将self除以给定值的商和余数结果的 2 元素数组。
fdiv: 返回将self除以给定值的Float结果。
floor: 返回小于或等于self的最大数字。
pow: 返回self的模幂运算结果。
pred: 返回self的整数前驱。
remainder: 返回将self除以给定值的余数。
round: 返回self四舍五入到具有给定精度的最接近的值。
succ (别名为 next): 返回self的整数后继。
to_f: 返回转换为Float的self。
to_s (别名为 inspect): 返回一个包含给定基数中self的位值表示的字符串。
truncate: 返回截断到给定精度的self。
#|: 返回self和给定值的按位或运算结果。

其他¶ ↑

downto: 使用从self到给定值的每个整数值调用给定块。
times: 使用(0..self-1)中的每个整数，self次调用给定块。
upto: 使用从self到给定值的每个整数值调用给定块。

常量

GMP_VERSION: 加载的 GMP 的版本。

公共类方法

sqrt(numeric) → integer click to toggle source

返回非负整数n的整数平方根，它是小于或等于numeric的平方根的最大非负整数。

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

如果numeric不是整数，则将其转换为整数

Integer.sqrt(Complex(4, 0))  # => 2
Integer.sqrt(Rational(4, 1)) # => 2
Integer.sqrt(4.0)            # => 2
Integer.sqrt(3.14159)        # => 1

此方法等效于 Math.sqrt(numeric).floor，但由于浮点运算的精度限制，后者代码的结果可能与真实值不同。

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

如果 numeric 为负数，则引发异常。

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

try_convert(object) → object, integer, 或 nil 点击切换源代码

如果 object 是一个 Integer 对象，则返回 object。

Integer.try_convert(1) # => 1

否则，如果 object 响应 :to_int，则调用 object.to_int 并返回结果。

Integer.try_convert(1.25) # => 1

如果 object 不响应 :to_int，则返回 nil。

Integer.try_convert([]) # => nil

除非 object.to_int 返回一个 Integer 对象，否则引发异常。

static VALUE
int_s_try_convert(VALUE self, VALUE num)
{
    return rb_check_integer_type(num);
}

公共实例方法

self % other → real_number 点击切换源代码

返回 self 模 other 的结果，结果为实数。

对于整数 n 和实数 r，以下表达式是等效的

n % r
n-r*(n/r).floor
n.divmod(r)[1]

参见 Numeric#divmod.

示例

10 % 2              # => 0
10 % 3              # => 1
10 % 4              # => 2

10 % -2             # => 0
10 % -3             # => -2
10 % -4             # => -2

10 % 3.0            # => 1.0
10 % Rational(3, 1) # => (1/1)

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

也称为：modulo

self & other → integer 点击切换源代码

按位与运算；结果中的每一位如果 self 和 other 中的对应位都为 1，则为 1，否则为 0。

"%04b" % (0b0101 & 0b0110) # => "0100"

如果 other 不是一个 Integer，则引发异常。

相关：Integer#|（按位或运算），Integer#^（按位异或运算）。

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

self * numeric → numeric_result 点击切换源代码

执行乘法运算。

4 * 2              # => 8
4 * -2             # => -8
-4 * 2             # => -8
4 * 2.0            # => 8.0
4 * Rational(1, 3) # => (4/3)
4 * Complex(2, 0)  # => (8+0i)

VALUE
rb_int_mul(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_mul(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_mul(x, y);
    }
    return rb_num_coerce_bin(x, y, '*');
}

self ** numeric → numeric_result 点击切换源代码

将 self 提升到 numeric 的幂。

2 ** 3              # => 8
2 ** -3             # => (1/8)
-2 ** 3             # => -8
-2 ** -3            # => (-1/8)
2 ** 3.3            # => 9.849155306759329
2 ** Rational(3, 1) # => (8/1)
2 ** Complex(3, 0)  # => (8+0i)

VALUE
rb_int_pow(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_pow(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_pow(x, y);
    }
    return Qnil;
}

self + numeric → numeric_result 点击切换源代码

执行加法运算。

2 + 2              # => 4
-2 + 2             # => 0
-2 + -2            # => -4
2 + 2.0            # => 4.0
2 + Rational(2, 1) # => (4/1)
2 + Complex(2, 0)  # => (4+0i)

VALUE
rb_int_plus(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_plus(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_plus(x, y);
    }
    return rb_num_coerce_bin(x, y, '+');
}

self - numeric → numeric_result 点击切换源代码

执行减法运算。

4 - 2              # => 2
-4 - 2             # => -6
-4 - -2            # => -2
4 - 2.0            # => 2.0
4 - Rational(2, 1) # => (2/1)
4 - Complex(2, 0)  # => (2+0i)

VALUE
rb_int_minus(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_minus(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_minus(x, y);
    }
    return rb_num_coerce_bin(x, y, '-');
}

-int → integer 点击切换源代码

返回 self 的相反数。

# File ruby_3_3_0/numeric.rb, line 80
def -@
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_int_uminus(self)'
end

self / numeric → numeric_result 点击切换源代码

执行除法运算；对于整数 numeric，将结果截断为整数。

 4 / 3              # => 1
 4 / -3             # => -2
 -4 / 3             # => -2
 -4 / -3            # => 1

For other +numeric+, returns non-integer result:

 4 / 3.0            # => 1.3333333333333333
 4 / Rational(3, 1) # => (4/3)
 4 / Complex(3, 0)  # => ((4/3)+0i)

VALUE
rb_int_div(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_div(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_div(x, y);
    }
    return Qnil;
}

self < other → true 或 false 点击切换源代码

如果 self 的值小于 other 的值，则返回 true。

  1 < 0              # => false
  1 < 1              # => false
  1 < 2              # => true
  1 < 0.5            # => false
  1 < Rational(1, 2) # => false

Raises an exception if the comparison cannot be made.

static VALUE
int_lt(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_lt(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_lt(x, y);
    }
    return Qnil;
}

self << count → integer 点击切换源代码

返回 self，其位向左移动 count 个位置，如果 count 为负数，则向右移动。

n = 0b11110000
"%08b" % (n << 1)  # => "111100000"
"%08b" % (n << 3)  # => "11110000000"
"%08b" % (n << -1) # => "01111000"
"%08b" % (n << -3) # => "00011110"

相关：Integer#ceil。

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

gcd(other_int) → integer 点击切换源代码

返回两个整数的最大公约数。结果始终为正数。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

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

gcdlcm(other_int) → array 点击切换源代码

返回一个数组，其中包含两个整数的最大公约数和最小公倍数，[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]

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)

返回一个字符串，其中包含 self 在基数 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"

如果 base 超出范围，则引发异常。

别名：to_s

integer? → true 点击切换源代码

由于 self 已经是整数，因此始终返回 true。

# File ruby_3_3_0/numeric.rb, line 178
def integer?
  true
end

lcm(other_int) → integer 点击切换源代码

返回两个整数的最小公倍数。结果始终为正数。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

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

magnitude()

别名：abs

modulo(p1)

返回 self 模 other 的结果，结果为实数。

对于整数 n 和实数 r，以下表达式是等效的

n % r
n-r*(n/r).floor
n.divmod(r)[1]

参见 Numeric#divmod.

示例

10 % 2              # => 0
10 % 3              # => 1
10 % 4              # => 2

10 % -2             # => 0
10 % -3             # => -2
10 % -4             # => -2

10 % 3.0            # => 1.0
10 % Rational(3, 1) # => (1/1)

别名：%

next()

返回 self 的后继整数（等效于 self + 1）

1.succ  #=> 2
-1.succ #=> 0

相关：Integer#pred（前驱值）。

别名：succ

nobits?(mask) → true 或 false 点击切换源代码

如果 mask 中设置的位 (=1) 在 self 中没有设置，则返回 true；否则返回 false。

示例值

0b11110000  self
0b00001111  mask
0b00000000  self & mask
      true  self.nobits?(mask)

0b00000001  self
0b11111111  mask
0b00000001  self & mask
     false  self.nobits?(mask)

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

numerator → self 点击切换源代码

返回 self。

# File ruby_3_3_0/numeric.rb, line 293
def numerator
  self
end

odd? → true 或 false 点击切换源代码

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

# File ruby_3_3_0/numeric.rb, line 188
def odd?
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_int_odd_p(self)'
end

ord → self 点击切换源代码

返回 self；旨在与 Ruby 1.9 中的字符字面量兼容。

# File ruby_3_3_0/numeric.rb, line 198
def ord
  self
end

pow(numeric) → numeric 点击切换源代码

pow(integer, integer) → integer

返回（模）指数运算，如

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

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

pred → next_integer 点击切换源代码

返回 self 的前驱（等效于 self - 1）

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

相关：Integer#succ（后继值）。

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

rationalize([eps]) → rational 点击切换源代码

将值作为有理数返回。可选参数 eps 始终被忽略。

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

remainder(other) → real_number 点击切换源代码

返回 self 除以 other 后的余数。

示例

11.remainder(4)              # => 3
11.remainder(-4)             # => 3
-11.remainder(4)             # => -3
-11.remainder(-4)            # => -3

12.remainder(4)              # => 0
12.remainder(-4)             # => 0
-12.remainder(4)             # => 0
-12.remainder(-4)            # => 0

13.remainder(4.0)            # => 1.0
13.remainder(Rational(4, 1)) # => (1/1)

static VALUE
int_remainder(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        if (FIXNUM_P(y)) {
            VALUE z = fix_mod(x, y);
            assert(FIXNUM_P(z));
            if (z != INT2FIX(0) && (SIGNED_VALUE)(x ^ y) < 0)
                z = fix_minus(z, y);
            return z;
        }
        else if (!RB_BIGNUM_TYPE_P(y)) {
            return num_remainder(x, y);
        }
        x = rb_int2big(FIX2LONG(x));
    }
    else if (!RB_BIGNUM_TYPE_P(x)) {
        return Qnil;
    }
    return rb_big_remainder(x, y);
}

round(ndigits= 0, half: :up) → integer 点击切换源代码

返回 self 四舍五入到最接近的值，精度为 ndigits 个小数位。

当 ndigits 为负数时，返回值至少有 ndigits.abs 个尾随零

555.round(-1)      # => 560
555.round(-2)      # => 600
555.round(-3)      # => 1000
-555.round(-2)     # => -600
555.round(-4)      # => 0

当 ndigits 为零或正数时，返回 self。

555.round     # => 555
555.round(1)  # => 555
555.round(50) # => 555

如果给出关键字参数 half，并且 self 与两个候选值等距，则舍入将根据给定的 half 值进行

:up 或 nil：远离零舍入

25.round(-1, half: :up)      # => 30
(-25).round(-1, half: :up)   # => -30

:down：向零舍入

25.round(-1, half: :down)    # => 20
(-25).round(-1, half: :down) # => -20

:even: 向最后一位非零数字为偶数的候选者舍入

25.round(-1, half: :even)    # => 20
15.round(-1, half: :even)    # => 20
(-25).round(-1, half: :even) # => -20

如果 half 的值无效，则引发异常。