Integer

Integer 객체는 정수(integer) 값을 나타내요.

출처: Ruby 3.3 API

본문

Integer 객체는 정수 값을 나타내요. Integer 객체를 만들려면:

정수 리터럴(integer literal).

특정 객체를 Integer로 변환하려면:

Integer 메서드.

이 클래스의 인스턴스에 싱글턴 메서드를 추가하려 하면 예외가 발생해요.

여기에 있는 것 (What's Here)

먼저, 다른 곳에 있는 것부터 볼게요. Integer 클래스는:

Numeric 클래스에서 상속받아요.

여기에서 Integer 클래스는 다음을 위한 메서드를 제공해요.

조회 (Querying)
비교 (Comparing)
변환 (Converting)
기타 (Other)

조회 (Querying)

allbits?: self의 모든 비트가 설정되었는지를 돌려줘요.
anybits?: self의 어떤 비트가 설정되었는지를 돌려줘요.
nobits?: self의 비트가 하나도 설정되지 않았는지를 돌려줘요.

비교 (Comparing)

<: self가 주어진 값보다 작은지를 돌려줘요.
<=: self가 주어진 값보다 작거나 같은지를 돌려줘요.
<=>: self가 주어진 값보다 작은지, 같은지, 큰지를 나타내는 숫자를 돌려줘요.
== (별칭 ===): self가 주어진 값과 같은지를 돌려줘요.
>: self가 주어진 값보다 큰지를 돌려줘요.
>=: self가 주어진 값보다 크거나 같은지를 돌려줘요.

변환 (Converting)

::sqrt: 주어진 값의 정수 제곱근을 돌려줘요.
::try_convert: 주어진 값을 Integer로 변환해서 돌려줘요.
% (별칭 modulo): self를 주어진 값으로 나눈 나머지를 돌려줘요.
&: self와 주어진 값의 비트 AND를 돌려줘요.
*: self와 주어진 값의 곱을 돌려줘요.
**: self를 주어진 값만큼 제곱한 값을 돌려줘요.
+: self와 주어진 값의 합을 돌려줘요.
-: self와 주어진 값의 차를 돌려줘요.
/: self를 주어진 값으로 나눈 몫을 돌려줘요.
<<: self를 왼쪽으로 비트 시프트한 값을 돌려줘요.
>>: self를 오른쪽으로 비트 시프트한 값을 돌려줘요.
[]: self에서 비트 슬라이스를 돌려줘요.
^: self와 주어진 값의 비트 배타적 OR(XOR)를 돌려줘요.
ceil: self보다 크거나 같은 가장 작은 수를 돌려줘요.
chr: self의 값이 나타내는 문자를 담은 1문자 문자열을 돌려줘요.
digits: self의 진법 자릿수를 나타내는 정수 배열을 돌려줘요.
div: self를 주어진 값으로 나눈 정수 결과를 돌려줘요.
divmod: self를 주어진 값으로 나눈 몫과 나머지를 담은 2요소 배열을 돌려줘요.
fdiv: self를 주어진 값으로 나눈 Float 결과를 돌려줘요.
floor: self보다 작거나 같은 가장 큰 수를 돌려줘요.
pow: self의 모듈러 지수 연산을 돌려줘요.
pred: self의 정수 이전 값을 돌려줘요.
remainder: self를 주어진 값으로 나눈 후의 나머지를 돌려줘요.
round: self를 주어진 정밀도로 가장 가까운 값에 반올림해 돌려줘요.
succ (별칭 next): self의 정수 다음 값을 돌려줘요.
to_f: self를 Float로 변환해 돌려줘요.
to_s (별칭 inspect): self를 주어진 진법으로 위치값 표현(place-value representation)한 문자열을 돌려줘요.
truncate: self를 주어진 정밀도로 버림(truncate)한 값을 돌려줘요.
|: self와 주어진 값의 비트 OR을 돌려줘요.

기타 (Other)

downto: self에서 주어진 값까지 내려가며 각 정수 값으로 주어진 블록을 호출해요.
times: self번 만큼 (0..self-1)의 각 정수로 주어진 블록을 호출해요.
upto: self에서 주어진 값까지 올라가며 각 정수 값으로 주어진 블록을 호출해요.

Constants (상수)

GMP_VERSION — 로드된 GMP의 버전.

Public Class Methods

`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이 음수이면 예외를 발생시켜요.

`try_convert(object) → object, integer, or 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 객체를 돌려주지 않으면 예외를 발생시켜요.

Public Instance Methods

`self % other → real_number`

self를 other로 나눈 나머지를 실수(real number)로 돌려줘요.

정수 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)

`self & other → integer`

비트 AND. 결과의 각 비트는 self와 other의 대응 비트가 모두 1이면 1, 아니면 0이에요.

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

other가 Integer가 아니면 예외를 발생시켜요. 관련: Integer#| (비트 OR), Integer#^ (비트 배타적 OR).

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

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

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

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

`-int → integer`

self를 부정(negate)한 값을 돌려줘요.

`self / numeric → numeric_result`

나눗셈을 수행해요. 정수 numeric에 대해서는 결과를 정수로 버립니다.

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

그 외의 numeric에 대해서는 비정수 결과를 돌려줘요.

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

`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

비교를 할 수 없으면 예외를 발생시켜요.

`self << count → integer`

self의 비트를 count 위치만큼 왼쪽으로 시프트한 값을 돌려줘요. count가 음수면 오른쪽으로 시프트해요.

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

`self <= real → true or false`

self의 값이 other의 값보다 작거나 같으면 true를 돌려줘요.

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

비교를 할 수 없으면 예외를 발생시켜요.

`self <=> other → -1, 0, +1, or nil`

다음을 돌려줘요.

self가 other보다 작으면 -1.
self가 other와 같으면 0.
self가 other보다 크면 1.
self와 other를 비교할 수 없으면 nil.

예시:

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 모듈에서 비교의 기초가 돼요.

`self == other → true or false`

self가 other와 수치적으로 같으면 true, 아니면 false를 돌려줘요.

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

관련: Integer#eql? (other가 Integer여야 함).

`===`

`self > other → true or false`

self의 값이 other의 값보다 크면 true를 돌려줘요.

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

비교를 할 수 없으면 예외를 발생시켜요.

`self >= real → true or false`

self의 값이 other의 값보다 크거나 같으면 true를 돌려줘요.

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

비교를 할 수 없으면 예외를 발생시켜요.

`self >> count → integer`

self의 비트를 count 위치만큼 오른쪽으로 시프트한 값을 돌려줘요. count가 음수면 왼쪽으로 시프트해요.

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

`self[offset] → 0 or 1`

self에서 비트 슬라이스를 돌려줘요.

인자 offset으로, 주어진 오프셋의 비트를 돌려줘요. 오프셋 0은 최하위 비트를 가리켜요.

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

원칙적으로 n[i]는 (n >> i) & 1과 같아요. 그래서 음수 인덱스는 항상 0을 돌려줘요.

255[-1] # => 0

인자 offset과 size로, offset에서 시작해 더 큰 자릿수의 비트를 포함해 size개의 비트를 돌려줘요.

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

인자 range로, range.begin에서 시작해 더 큰 자릿수의 비트를 포함해 range.size개의 비트를 돌려줘요.

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

슬라이스를 만들 수 없으면 예외를 발생시켜요.

`self ^ other → integer`

비트 배타적 OR(XOR). 결과의 각 비트는 self와 other의 대응 비트가 다르면 1, 아니면 0이에요.

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

other가 Integer가 아니면 예외를 발생시켜요. 관련: Integer#& (비트 AND), Integer#| (비트 OR).

`abs → integer`

self의 절댓값을 돌려줘요.

(-12345).abs # => 12345
-12345.abs   # => 12345
12345.abs    # => 12345

`allbits?(mask) → true or 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?.

`anybits?(mask) → true or 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?.

`bit_length → integer`

self 값의 비트 수를 돌려줘요. 이것은 부호 비트와 다른 최상위 비트의 위치(최하위 비트가 비트 위치 1)예요. 그런 비트가 없으면(0 또는 -1) 0을 돌려줘요.

이 메서드는 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

`ceil(ndigits = 0) → integer`

self보다 크거나 같은 ndigits 소수 자릿수 정밀도의 가장 작은 수를 돌려줘요.

정밀도가 음수이면 돌려주는 값은 ndigits.abs개의 끝자리 0을 가진 정수예요.

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

ndigits가 0 또는 양수이면 self를 돌려줘요.

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

`ceildiv(numeric) → integer`

self를 numeric으로 나눈 결과를 가장 가까운 정수로 올림(round up)한 값을 돌려줘요.

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

`chr → string`

self의 값이 나타내는 문자를 주어진 인코딩에 따라 담은 1문자 문자열을 돌려줘요.

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

self가 음수이면 예외를 발생시켜요. 관련: Integer#ord.

`coerce(numeric) → array`

numeric과 int를 Integer 객체나 Float 객체로 나타낸 배열을 돌려줘요. numeric을 Integer나 Float로 변환해서 이뤄져요.

numeric이 Integer나 Float 타입이 아니면 TypeError가 발생해요.

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

`denominator → 1`

1을 돌려줘요.

`digits(base = 10) → array_of_integers`

self의 진법(base) 자릿수를 나타내는 정수 배열을 돌려줘요. 배열의 첫 요소는 최하위 자릿수를 나타내요.

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

self가 음수이거나 base가 2보다 작으면 예외를 발생시켜요.

`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

numeric에 div 메서드가 없으면 예외를 발생시켜요.

`divmod(other) → array`

[q, r] 2요소 배열을 돌려줘요. 여기서:

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

`downto(limit) {|i| ... } → self`

self에서 limit까지 내려가며 각 정수 값으로 주어진 블록을 호출하고 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를 돌려줘요.

`even? → true or false`

self가 짝수이면 true, 아니면 false를 돌려줘요.

`fdiv(numeric) → float`

self를 numeric으로 나눈 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

numeric을 Float로 변환할 수 없으면 예외를 발생시켜요.

`floor(ndigits = 0) → integer`

self보다 작거나 같은 ndigits 소수 자릿수 정밀도의 가장 큰 수를 돌려줘요.

ndigits가 음수이면 돌려주는 값은 ndigits.abs개의 끝자리 0을 가져요.

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

ndigits가 0 또는 양수이면 self를 돌려줘요.

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

`gcd(other_int) → integer`

두 정수의 최대공약수(greatest common divisor)를 돌려줘요. 결과는 항상 양수예요. 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`

두 정수의 최대공약수와 최소공배수를 [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`

`integer? → true`

self가 이미 Integer이므로 항상 true를 돌려줘요.

`lcm(other_int) → integer`

두 정수의 최소공배수(least common multiple)를 돌려줘요. 결과는 항상 양수예요. 0.lcm(x)와 x.lcm(0)은 0을 돌려줘요.

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

`magnitude`

`modulo`

`next`

`nobits?(mask) → true or 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)

관련: Integer#allbits?, Integer#anybits?.

`numerator → self`

self를 돌려줘요.

`odd? → true or false`

self가 홀수이면 true, 아니면 false를 돌려줘요.

`ord → self`

self를 돌려줘요. Ruby 1.9의 문자 리터럴과의 호환을 위한 거예요.

`pow(numeric) → numeric`

(모듈러) 지수 연산을 다음과 같이 돌려줘요.

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

`pred → next_integer`

self의 이전 값(predecessor)을 돌려줘요 (self - 1과 같음).

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

`rationalize([eps]) → rational`

값을 유리수(rational)로 돌려줘요. 선택 사항 인자 eps는 항상 무시돼요.

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

`round(ndigits= 0, half: :up) → integer`

self를 ndigits 소수 자릿수 정밀도의 가장 가까운 값으로 반올림해 돌려줘요.

ndigits가 음수이면 돌려주는 값은 ndigits.abs개의 끝자리 0을 가져요.

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

ndigits가 0 또는 양수이면 self를 돌려줘요.

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

키워드 인자 half가 주어지고 self가 두 후보 값의 정중앙이면, 주어진 half 값에 따라 반올림해요.

:up 또는 nil: 0에서 멀어지는 방향으로 반올림. 25.round(-1, half: :up) # => 30, (-25).round(-1, half: :up) # => -30
:down: 0에 가까워지는 방향으로 반올림. 25.round(-1, half: :down) # => 20, (-25).round(-1, half: :down) # => -20
:even: 마지막 0이 아닌 자릿수가 짝수인 후보 쪽으로 반올림. 25.round(-1, half: :even) # => 20, 15.round(-1, half: :even) # => 20, (-25).round(-1, half: :even) # => -20

half의 값이 유효하지 않으면 예외를 발생시켜요. 관련: Integer#truncate.

`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

`succ → next_integer`

self의 다음 정수(successor)를 돌려줘요 (self + 1과 같음).

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

`times {|i| ... } → self`

self번 만큼 (0..self-1)의 각 정수로 주어진 블록을 호출해요.

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

블록이 없으면 Enumerator를 돌려줘요.

`to_bn ()`

Integer를 OpenSSL::BN으로 캐스팅해요. 자세한 내용은 man bn을 참고하세요.

`to_d → bigdecimal`

int의 값을 BigDecimal로 돌려줘요.

require 'bigdecimal'
require 'bigdecimal/util'

42.to_d   # => 0.42e2

Kernel.BigDecimal도 참고하세요.

`to_f → float`

self를 Float로 변환해요.

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

self의 값이 Float에 맞지 않으면 결과는 무한대(infinity)예요.

(10**400).to_f  # => Infinity
(-10**400).to_f # => -Infinity

`to_i → self`

self를 돌려줘요 (이미 Integer임).

`to_int → self`

self를 돌려줘요 (이미 Integer임).

`to_r → rational`

값을 유리수로 돌려줘요.

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

`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가 범위를 벗어나면 예외를 발생시켜요.

`truncate(ndigits = 0) → integer`

self를 ndigits 소수 자릿수 정밀도로 (0 쪽으로) 버림한 값을 돌려줘요.

ndigits가 음수이면 돌려주는 값은 ndigits.abs개의 끝자리 0을 가져요.

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

ndigits가 0 또는 양수이면 self를 돌려줘요.

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

`upto(limit) {|i| ... } → self`

self에서 limit까지 올라가며 각 정수 값으로 주어진 블록을 호출하고 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를 돌려줘요.

`zero? → true or false`

self의 값이 0이면 true, 아니면 false를 돌려줘요.

`self | other → integer`

비트 OR. 결과의 각 비트는 self나 other의 대응 비트 중 하나라도 1이면 1, 아니면 0이에요.

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

other가 Integer가 아니면 예외를 발생시켜요. 관련: Integer#& (비트 AND), Integer#^ (비트 배타적 OR).

`~int → integer`

1의 보수(one's complement): self의 각 비트를 반전한 값을 돌려줘요.

정수 값은 개념적으로 무한한 길이이므로, 결과는 왼쪽에 무한한 수의 1 비트가 있는 것처럼 동작해요. 16진수 표현에서는 자릿수 왼쪽에 두 개의 마침표로 표시돼요.

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