類別 Integer

Integer 物件表示整數值。

您可以使用以下方式明確建立 Integer 物件

您可以使用以下方式將特定物件轉換為 Integer

嘗試將單例方法新增到此類別的執行個體時,會引發例外狀況。

此處內容

首先,其他位置的內容。類別 Integer

在此,類別 Integer 提供以下方法

查詢

比較

轉換

其他

常數

GMP_VERSION

已載入 GMP 的版本。

公開類別方法

sqrt(numeric) → integer 按一下以切換來源

傳回非負整數 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,則會轉換為 Integer

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 按一下以切換來源

按位元 AND;如果selfother中對應的位元都是 1,則結果中的每個位元為 1,否則為 0

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

如果other不是 Integer,則引發例外。

相關: Integer#| (按位元 OR)、 Integer#^ (按位元 EXCLUSIVE OR)。

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 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 or 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 按一下以切換來源

傳回將位元向左位移 count 個位置的 self,如果 count 為負數,則向右位移

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

相關:Integer#>>

VALUE
rb_int_lshift(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return rb_fix_lshift(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_lshift(x, y);
    }
    return Qnil;
}
self <= real → true 或 false 按一下以切換來源

如果 self 的值小於或等於 other,則傳回 true

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

如果無法進行比較,則會引發例外狀況。

static VALUE
int_le(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_le(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_le(x, y);
    }
    return Qnil;
}
self <=> other → -1、0、+1 或 nil 按一下以切換來源

傳回

  • -1,如果 self 小於 other

  • 0,如果 self 等於 other

  • 1,如果 self 大於 other

  • nil,如果 selfother 無法比較。

範例

1 <=> 2              # => -1
1 <=> 1              # => 0
1 <=> 0              # => 1
1 <=> 'foo'          # => nil

1 <=> 1.0            # => 0
1 <=> Rational(1, 1) # => 0
1 <=> Complex(1, 0)  # => 0

此方法是模組 Comparable 中比較運算的基礎。

VALUE
rb_int_cmp(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_cmp(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_cmp(x, y);
    }
    else {
        rb_raise(rb_eNotImpError, "need to define `<=>' in %s", rb_obj_classname(x));
    }
}
self == other → true 或 false

如果 self 在數值上等於 other,則傳回 true;否則傳回 false

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

相關:Integer#eql?(需要 other 為 Integer)。

別名:===
===
別名:==
self > other → true 或 false 按一下以切換來源

如果 self 的值大於 other,則傳回 true

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

Raises an exception if the comparison cannot be made.
VALUE
rb_int_gt(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_gt(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_gt(x, y);
    }
    return Qnil;
}
self >= real → true 或 false 按一下以切換來源

如果 self 的值大於或等於 other,則傳回 true

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

如果無法進行比較,則會引發例外狀況。

VALUE
rb_int_ge(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_ge(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_ge(x, y);
    }
    return Qnil;
}
self >> count → 整數 按一下以切換來源

傳回將位元向右位移 count 個位置的 self,如果 count 為負數,則向左位移

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

相關:Integer#<<

static VALUE
rb_int_rshift(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return rb_fix_rshift(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_rshift(x, y);
    }
    return Qnil;
}
self[offset] → 0 或 1 按一下以切換來源
self[offset, size] → 整數
self[range] → 整數

傳回 self 的位元切片。

使用引數 offset,傳回給定偏移量處的位元,其中偏移量 0 參照最不重要的位元

n = 0b10 # => 2
n[0]     # => 0
n[1]     # => 1
n[2]     # => 0
n[3]     # => 0

原則上,n[i] 等於 (n >> i) & 1。因此,負數索引值永遠會傳回零

255[-1] # => 0

使用參數 offsetsize,會傳回 self 中從 offset 開始的 size 個位元,包含重要性較高的位元

n = 0b111000       # => 56
"%010b" % n[0, 10] # => "0000111000"
"%010b" % n[4, 10] # => "0000000011"

使用參數 range,會傳回 self 中從 range.begin 開始的 range.size 個位元,包含重要性較高的位元

n = 0b111000      # => 56
"%010b" % n[0..9] # => "0000111000"
"%010b" % n[4..9] # => "0000000011"

如果無法建構切片,會引發例外狀況。

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;
}
self ^ other → integer 按一下以切換來源

位元異或;如果 selfother 中對應的位元不同,則結果中的每個位元為 1,否則為 0

"%04b" % (0b0101 ^ 0b0110) # => "0011"

如果other不是 Integer,則引發例外。

相關:Integer#&(位元 AND),Integer#|(位元 OR)。

static VALUE
int_xor(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_xor(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_xor(x, y);
    }
    return Qnil;
}
abs → integer 按一下以切換來源

傳回 self 的絕對值。

(-12345).abs # => 12345
-12345.abs   # => 12345
12345.abs    # => 12345
# File numeric.rb, line 113
def abs
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_int_abs(self)'
end
別名為:magnitude
allbits?(mask) → true 或 false 按一下以切換來源

如果 mask 中所有設定為 (=1) 的位元也在 self 中設定,則傳回 true;否則傳回 false

範例值

0b1010101  self
0b1010100  mask
0b1010100  self & mask
     true  self.allbits?(mask)

0b1010100  self
0b1010101  mask
0b1010100  self & mask
    false  self.allbits?(mask)

相關:Integer#anybits?Integer#nobits?

static VALUE
int_allbits_p(VALUE num, VALUE mask)
{
    mask = rb_to_int(mask);
    return rb_int_equal(rb_int_and(num, mask), mask);
}
anybits?(mask) → true 或 false 按一下以切換來源

如果 mask 中任何設定為 (=1) 的位元也在 self 中設定,則傳回 true;否則傳回 false

範例值

0b10000010  self
0b11111111  mask
0b10000010  self & mask
      true  self.anybits?(mask)

0b00000000  self
0b11111111  mask
0b00000000  self & mask
     false  self.anybits?(mask)

相關:Integer#allbits?Integer#nobits?

static VALUE
int_anybits_p(VALUE num, VALUE mask)
{
    mask = rb_to_int(mask);
    return RBOOL(!int_zero_p(rb_int_and(num, mask)));
}
bit_length → integer 按一下以切換來源

傳回 self 值的位元數,也就是與符號位元不同的最高位元之位元位置(其中最低有效位元之位元位置為 1)。如果沒有此類位元(零或負一),則傳回零。

此方法傳回 ceil(log2(self < 0 ? -self : self + 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

對於整數 n,此方法可用於偵測 Array#pack 中的溢位

if n.bit_length < 32
  [n].pack('l') # No overflow.
else
  raise 'Overflow'
end
# File numeric.rb, line 160
def bit_length
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_int_bit_length(self)'
end
ceil(ndigits = 0) → integer 按一下以切換來源

傳回大於或等於 self 的最小數字,其精度為 ndigits 個小數位。

當精度為負數時,傳回值為一個整數,其尾數至少有 ndigits.abs 個零

555.ceil(-1)  # => 560
555.ceil(-2)  # => 600
-555.ceil(-2) # => -500
555.ceil(-3)  # => 1000

ndigits 為零或正數時,傳回 self

555.ceil     # => 555
555.ceil(50) # => 555

相關:Integer#floor

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);
}
ceildiv(numeric) → integer 按一下以切換原始碼

傳回 self 除以 numeric 的結果,無條件進位到最接近的整數。

3.ceildiv(3)   # => 1
4.ceildiv(3)   # => 2

4.ceildiv(-3)  # => -1
-4.ceildiv(3)  # => -1
-4.ceildiv(-3) # => 2

3.ceildiv(1.2) # => 3
# File numeric.rb, line 283
def ceildiv(other)
  -div(0 - other)
end
chr → string 按一下以切換原始碼
chr(encoding) → string

傳回一個 1 個字元的字串,包含根據指定的 encoding,由 self 的值所表示的字元。

65.chr                   # => "A"
0.chr                    # => "\x00"
255.chr                  # => "\xFF"
string = 255.chr(Encoding::UTF_8)
string.encoding          # => Encoding::UTF_8

如果 self 為負數,則會引發例外。

相關:Integer#ord

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);
}
coerce(numeric) → array 按一下以切換原始碼

傳回一個陣列,其中包含表示為 Integer 物件或 Float 物件的 numericint

這是透過將 numeric 轉換為 IntegerFloat 來達成。

如果 numeric 不是 IntegerFloat 類型,則會引發 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);
    }
}
denominator → 1 按一下以切換原始碼

傳回 1

# File numeric.rb, line 301
def denominator
  1
end
digits(base = 10) → array_of_integers 按一下以切換原始碼

傳回一個整數陣列,表示 selfbase 進位數字;陣列的第一個元素表示最不重要的數字

12345.digits      # => [5, 4, 3, 2, 1]
12345.digits(7)   # => [4, 6, 6, 0, 5]
12345.digits(100) # => [45, 23, 1]

如果 self 為負數或 base 小於 2,則會引發例外。

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_BIGNUM_TYPE_P(base_value))
            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_BIGNUM_TYPE_P(num))
        return rb_int_digits_bigbase(num, LONG2FIX(base));

    return Qnil;
}
div(numeric) → integer 按一下以切換原始碼

執行整數除法;傳回將 self 除以 numeric 的整數結果

  4.div(3)      # => 1
  4.div(-3)      # => -2
  -4.div(3)      # => -2
  -4.div(-3)      # => 1
  4.div(3.0)      # => 1
  4.div(Rational(3, 1))      # => 1

Raises an exception if +numeric+ does not have method +div+.
VALUE
rb_int_idiv(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_idiv(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_idiv(x, y);
    }
    return num_div(x, y);
}
divmod(other) → array 按一下以切換原始碼

傳回一個 2 個元素的陣列 [q, r],其中

q = (self/other).floor    # Quotient
r = self % other          # Remainder

範例

11.divmod(4)              # => [2, 3]
11.divmod(-4)             # => [-3, -1]
-11.divmod(4)             # => [-3, 1]
-11.divmod(-4)            # => [2, -3]

12.divmod(4)              # => [3, 0]
12.divmod(-4)             # => [-3, 0]
-12.divmod(4)             # => [-3, 0]
-12.divmod(-4)            # => [3, 0]

13.divmod(4.0)            # => [3, 1.0]
13.divmod(Rational(4, 1)) # => [3, (1/1)]
VALUE
rb_int_divmod(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_divmod(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_divmod(x, y);
    }
    return Qnil;
}
downto(limit) {|i| ... } → self 按一下以切換原始碼
downto(limit) → enumerator

使用從 selflimit 的每個整數值呼叫指定的區塊;傳回 self

a = []
10.downto(5) {|i| a << i }              # => 10
a                                       # => [10, 9, 8, 7, 6, 5]
a = []
0.downto(-5) {|i| a << i }              # => 0
a                                       # => [0, -1, -2, -3, -4, -5]
4.downto(5) {|i| fail 'Cannot happen' } # => 4

如果沒有給予區塊,則傳回 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;
}
even? → true 或 false 按一下切換來源

如果 self 是偶數,則傳回 true,否則傳回 false

# File numeric.rb, line 169
def even?
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_int_even_p(self)'
end
fdiv(數字) → 浮點數 按一下切換來源

傳回將 self 除以 數字Float 結果

4.fdiv(2)      # => 2.0
4.fdiv(-2)      # => -2.0
-4.fdiv(2)      # => -2.0
4.fdiv(2.0)      # => 2.0
4.fdiv(Rational(3, 4))      # => 5.333333333333333

如果無法將 數字 轉換為 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;
}
floor(位數 = 0) → 整數 按一下切換來源

傳回小於或等於 self 的最大數字,其精確度為 位數 個小數位。

位數 為負數時,傳回值至少有 位數.abs 個尾數零

555.floor(-1)  # => 550
555.floor(-2)  # => 500
-555.floor(-2) # => -600
555.floor(-3)  # => 0

ndigits 為零或正數時,傳回 self

555.floor     # => 555
555.floor(50) # => 555

相關: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(其他整數) → 整數 按一下切換來源

傳回兩個整數的最大公因數。結果永遠為正數。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(其他整數) → 陣列 按一下切換來源

傳回一個陣列,其中包含兩個整數的最大公因數和最小公倍數,[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
別名為:to_s
integer? → true 按一下切換來源

由於 self 已經是整數,因此永遠傳回 true

# File numeric.rb, line 178
def integer?
  true
end
lcm(其他整數) → 整數 按一下切換來源

傳回兩個整數的最小公倍數。結果永遠為正數。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
別名為:%
next
別名為:succ
nobits?(遮罩) → true 或 false 按一下切換來源

如果 遮罩 中設定 (=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)

相關:Integer#allbits?Integer#anybits?

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 numeric.rb, line 293
def numerator
  self
end
odd? → true 或 false 按一下切換來源

如果 self 是奇數,則傳回 true,否則傳回 false

# File numeric.rb, line 188
def odd?
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_int_odd_p(self)'
end
ord → self 按一下以切換原始碼

傳回 self;用於與 Ruby 1.9 中的字元文字相容。

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

位數 為負數時,傳回值至少有 位數.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 值進行

  • :upnil:朝遠離零的方向四捨五入

    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 的值無效,則會引發例外狀況。

相關:Integer#truncate

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);
}
size → integer 按一下以切換原始碼

傳回 self 的機器表示中的位元組數;此值與系統相關

1.size             # => 8
-1.size            # => 8
2147483647.size    # => 8
(256**10 - 1).size # => 10
(256**20 - 1).size # => 20
(256**40 - 1).size # => 40
# File numeric.rb, line 215
def size
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_int_size(self)'
end
succ → next_integer 按一下以切換原始碼

傳回 self 的後一個整數(等於 self + 1

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

相關:Integer#pred(前一個值)。

VALUE
rb_int_succ(VALUE num)
{
    if (FIXNUM_P(num)) {
        long i = FIX2LONG(num) + 1;
        return LONG2NUM(i);
    }
    if (RB_BIGNUM_TYPE_P(num)) {
        return rb_big_plus(num, INT2FIX(1));
    }
    return num_funcall1(num, '+', INT2FIX(1));
}
別名:next
times {|i| ... } → self 按一下以切換原始碼
times → enumerator

呼叫給定的區塊 self 次,並使用 (0..self-1) 中的每個整數

a = []
5.times {|i| a.push(i) } # => 5
a                        # => [0, 1, 2, 3, 4]

如果沒有給予區塊,則傳回 Enumerator

# File numeric.rb, line 231
def times
  unless block_given?
    return to_enum(:times) { self < 0 ? 0 : self }
  end
  i = 0
  while i < self
    yield i
    i = i.succ
  end
  self
end
to_bn() 按一下以切換原始碼

Integer 轉換為 OpenSSL::BN

請參閱「man bn」以取得更多資訊。

# File ext/openssl/lib/openssl/bn.rb, line 37
def to_bn
  OpenSSL::BN::new(self)
end
to_d → bigdecimal 按一下以切換原始碼

傳回 int 的值,為 BigDecimal

require 'bigdecimal'
require 'bigdecimal/util'

42.to_d   # => 0.42e2

另請參閱 Kernel.BigDecimal

# File ext/bigdecimal/lib/bigdecimal/util.rb, line 23
def to_d
  BigDecimal(self)
end
to_f → float 按一下以切換原始碼

self 轉換為浮點數

1.to_f  # => 1.0
-1.to_f # => -1.0

如果 self 的值不符合 Float,結果將會是無限大

(10**400).to_f  # => Infinity
(-10**400).to_f # => -Infinity
static VALUE
int_to_f(VALUE num)
{
    double val;

    if (FIXNUM_P(num)) {
        val = (double)FIX2LONG(num);
    }
    else if (RB_BIGNUM_TYPE_P(num)) {
        val = rb_big2dbl(num);
    }
    else {
        rb_raise(rb_eNotImpError, "Unknown subclass for to_f: %s", rb_obj_classname(num));
    }

    return DBL2NUM(val);
}
to_i → self 按一下以切換來源

傳回 self(它已經是整數)。

# File numeric.rb, line 247
def to_i
  self
end
to_int → self 按一下以切換來源

傳回 self(它已經是整數)。

# File numeric.rb, line 255
def to_int
  self
end
to_r → rational 按一下以切換來源

將值傳回為有理數。

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 按一下以切換來源

傳回包含 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 超出範圍,則會引發例外狀況。

VALUE
rb_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 = 0) → integer 按一下以切換來源

傳回 self,已截斷(朝向零)至 ndigits 小數位精度。

位數 為負數時,傳回值至少有 位數.abs 個尾數零

555.truncate(-1)  # => 550
555.truncate(-2)  # => 500
-555.truncate(-2) # => -500

ndigits 為零或正數時,傳回 self

555.truncate     # => 555
555.truncate(50) # => 555

相關:Integer#round

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);
}
upto(limit) {|i| ... } → self 按一下以切換來源
upto(limit) → enumerator

使用 selflimit 的每個整數值呼叫指定的區塊;傳回 self

a = []
5.upto(10) {|i| a << i }              # => 5
a                                     # => [5, 6, 7, 8, 9, 10]
a = []
-5.upto(0) {|i| a << i }              # => -5
a                                     # => [-5, -4, -3, -2, -1, 0]
5.upto(4) {|i| fail 'Cannot happen' } # => 5

如果沒有給予區塊,則傳回 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;
}
zero? → true or false 按一下以切換來源

如果 self 為零值,則傳回 true,否則傳回 false

# File numeric.rb, line 263
def zero?
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_int_zero_p(self)'
end
self | other → integer 按一下以切換來源

按位元 OR;如果 selfother 中對應的任一按位元為 1,則結果中的每個按位元為 1,否則為 0

"%04b" % (0b0101 | 0b0110) # => "0111"

如果other不是 Integer,則引發例外。

相關:Integer#&(按位元 AND)、Integer#^(按位元 EXCLUSIVE OR)。

static VALUE
int_or(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_or(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_or(x, y);
    }
    return Qnil;
}
~int → integer 按一下以切換來源

一補數:傳回每個按位元都反轉的 self 值。

由於整數值在概念上是無限長,因此結果會作用得好像在數字的左側有無限個一按位元。在十六進位表示法中,這會顯示為數字左側的兩個句點

sprintf("%X", ~0x1122334455)    # => "..FEEDDCCBBAA"
# File numeric.rb, line 99
def ~
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_int_comp(self)'
end