класс 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 отрицательно.

Если object является объектом Integer, возвращает object.

Integer.try_convert(1) # => 1

В противном случае, если object отвечает на :to_int, вызывает object.to_int и возвращает результат.

Integer.try_convert(1.25) # => 1

Возвращает nil, если object не отвечает на :to_int

Integer.try_convert([]) # => nil

Вызывает исключение, если object.to_int не возвращает объект Integer.

Возвращает остаток от деления self на other в виде вещественного числа (Integer, Float или Rational).

Для целого числа 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)

Побитовое И; каждый бит результата равен 1, если соответствующие биты в self и other равны 1, и 0 в противном случае:

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

Вызывает исключение, если other не является Integer.

Связанные методы: Integer#| (побитовое ИЛИ), Integer#^ (побитовое исключающее ИЛИ).

Возвращает произведение чисел self и other:

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 в степень exponent:

# Result for non-negative Integer exponent is Integer.
2 ** 0   # => 1
2 ** 1   # => 2
2 ** 2   # => 4
2 ** 3   # => 8
-2 ** 3  # => -8
# Result for negative Integer exponent is Rational, not Float.
2 ** -3  # => (1/8)
-2 ** -3 # => (-1/8)

# Result for Float exponent is Float.
2 ** 0.0   # => 1.0
2 ** 1.0   # => 2.0
2 ** 2.0   # => 4.0
2 ** 3.0   # => 8.0
-2 ** 3.0  # => -8.0
2 ** -3.0  # => 0.125
-2 ** -3.0 # => -0.125

# Result for non-negative Complex exponent is Complex with Integer parts.
2 ** Complex(0, 0)   # => (1+0i)
2 ** Complex(1, 0)   # => (2+0i)
2 ** Complex(2, 0)   # => (4+0i)
2 ** Complex(3, 0)   # => (8+0i)
-2 ** Complex(3, 0) # => (-8+0i)
# Result for negative Complex exponent is Complex with Rational parts.
2 ** Complex(-3, 0)  # => ((1/8)+(0/1)*i)
-2 ** Complex(-3, 0) # => ((-1/8)+(0/1)*i)

# Result for Rational exponent is Rational.
2 ** Rational(0, 1)   # => (1/1)
2 ** Rational(1, 1)   # => (2/1)
2 ** Rational(2, 1)   # => (4/1)
2 ** Rational(3, 1)   # => (8/1)
-2 ** Rational(3, 1)  # => (-8/1)
2 ** Rational(-3, 1)  # => (1/8)
-2 ** Rational(-3, 1) # => (-1/8)

Возвращает сумму self и other:

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

При вычислении с числами Float результат может быть неточным (см. Float#+):

1 + 3.14           # => 4.140000000000001

Возвращает разность self и other:

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)

Возвращает self с противоположным знаком:

-1    # => -1
-(-1) # => 1
-0    # => 0

Возвращает частное от деления self на other.

Для целого числа other результат усекается до целого числа:

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

Для нецелого числа other возвращается нецелый результат:

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

Возвращает значение, указывающее, меньше ли значение self значения other; other должно быть числом, но не может быть Complex:

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

Возвращает self со сдвинутыми на count позицию влево битами или вправо, если count отрицательно:

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

Связанный метод: Integer#>>.

Возвращает значение, указывающее, меньше ли или равно значение self значению other; other должно быть числом, но не может быть Complex:

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

Raises an exception if the comparison cannot be made.

Сравнивает self и other.

Возвращает:

• -1, если self меньше other.

• 0, если self равно other.

• 1, если self больше other.

• nil, если self и other несравнимы.

Примеры:

1 <=> 2              # => -1
1 <=> 1              # => 0
1 <=> 1.0            # => 0
1 <=> Rational(1, 1) # => 0
1 <=> Complex(1, 0)  # => 0
1 <=> 0              # => 1
1 <=> 'foo'          # => nil

Класс Integer подключает модуль Comparable, каждый метод которого использует Integer#<=> для сравнения.

Возвращает true, если значение self больше значения other:

  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.

Возвращает true, если значение self больше или равно значению other:

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

Вызывает исключение, если сравнение невозможно выполнить.

Возвращает self со сдвинутыми на count позиций вправо битами или влево, если count отрицательно:

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

Связанный метод: Integer#<<.

Возвращает срез битов из 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

С аргументами offset и size возвращает size бит из self, начиная с offset и включая биты с большим значением разряда:

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

С аргументом range возвращает range.size бит из self, начиная с range.begin и включая биты с большим значением разряда:

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

Вызывает исключение, если срез невозможно создать.

Побитовое исключающее ИЛИ; каждый бит результата равен 1, если соответствующие биты в self и other различаются, и 0 в противном случае:

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

Вызывает исключение, если other не является Integer.

Связанные методы: Integer#& (побитовое И), Integer#| (побитовое ИЛИ).

Побитовое ИЛИ; каждый бит результата равен 1, если соответствующий бит в self или other равен 1, и 0 в противном случае:

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

Вызывает исключение, если other не является Integer.

Связанные методы: Integer#& (побитовое И), Integer#^ (побитовое исключающее ИЛИ).

Дополнение до единицы: возвращает значение self с инвертированными битами.

Поскольку целое число концептуально имеет бесконечную длину, результат ведет себя так, как будто слева от него находится бесконечное количество единичных битов. В шестнадцатеричном представлении это отображается двумя точками слева от цифр:

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

Возвращает абсолютное значение self.

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

Возвращает true, если все биты, установленные (=1) в mask, также установлены в self; в противном случае возвращает 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?.

Возвращает true, если хотя бы один бит, установленный (=1) в mask, также установлен в self; в противном случае возвращает 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?.

Возвращает количество битов в значении 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

Для Integer n этот метод можно использовать для обнаружения переполнения в Array#pack:

if n.bit_length < 32
  [n].pack('l') # No overflow.
else
  raise 'Overflow'
end

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

• Если self равно нулю, возвращает ноль (независимо от значения ndigits):

  0.ceil(2)  # => 0
  0.ceil(-2) # => 0
  

• Если self не равно нулю, а ndigits неотрицательно, возвращает self:

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

• Если self не равно нулю, а ndigits отрицательно, возвращает значение, определяемое вычисленной точностью:

  • Точность равна 10 ** ndigits.abs.

  • Возвращаемое значение — наименьшее кратное точности, которое больше или равно self.

  Примеры с положительным self:

  ndigits	Точность	1234.ceil(ndigits)
  -1	10	1240
  -2	100	1300
  -3	1000	2000
  -4	10000	10000
  -5	100000	100000

  Примеры с отрицательным self:

  ndigits	Точность	-1234.ceil(ndigits)
  -1	10	-1230
  -2	100	-1200
  -3	1000	-1000
  -4	10000	0
  -5	100000	0

Связанный метод: Integer#floor.

Возвращает результат деления 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

Возвращает строку из одного символа, представленного значением self в соответствии с заданной encoding.

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

Вызывает исключение, если self отрицательно.

Связанный метод: Integer#ord.

Возвращает массив, в котором numeric и int представлены объектами Integer или Float.

Для этого numeric преобразуется в Integer или Float.

Возникает TypeError, если numeric не относится к типу Integer или Float.

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

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

Возвращает массив целых чисел, представляющих цифры base-ичной системы счисления числа self; первый элемент массива соответствует младшей цифре:

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

Вызывает исключение, если self отрицательно или base меньше 2.

Выполняет целочисленное деление; возвращает целочисленный результат деления 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.

Возвращает массив из 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)]

Вызывает заданный блок для каждого целого значения от 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.

Возвращает true, если self является четным числом, и false в противном случае.

Возвращает результат деления 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.

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

• Если self равно нулю, возвращает ноль (независимо от значения ndigits):

  0.floor(2)  # => 0
  0.floor(-2) # => 0
  

• Если self не равно нулю и ndigits неотрицательно, возвращает self:

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

• Если self не равно нулю и ndigits отрицательно, возвращает значение, рассчитанное на основе определённой точности:

  • Точность равна 10 ** ndigits.abs.

  • Возвращаемое значение — наибольшее кратное этой точности, которое меньше или равно self.

  Примеры с положительным self:

  ndigits	Точность	1234.floor(ndigits)
  -1	10	1230
  -2	100	1200
  -3	1000	1000
  -4	10000	0
  -5	100000	0

  Примеры с отрицательным self:

  ndigits	Точность	-1234.floor(ndigits)
  -1	10	-1240
  -2	100	-1300
  -3	1000	-2000
  -4	10000	-10000
  -5	100000	-100000

Связанные методы: Integer#ceil.

Возвращает наибольший общий делитель двух целых чисел. Результат всегда положителен. 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

Возвращает массив, содержащий наибольший общий делитель и наименьшее общее кратное двух целых чисел: [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]

Поскольку self уже является Integer, всегда возвращает true.

Возвращает наименьшее общее кратное двух целых чисел. Результат всегда положителен. 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

Возвращает true, если ни один бит, установленный (=1) в mask, не установлен в self; в противном случае возвращает 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?.

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

Возвращает true, если self — нечётное число, и false в противном случае.

Возвращает self; предназначен для совместимости с символьными литералами в Ruby 1.9.

Возвращает результат (модульного) возведения в степень:

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

Возвращает предыдущее значение для self (эквивалентно self - 1):

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

Связанный метод: Integer#succ (следующее значение).

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

Возвращает остаток от деления 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)

Возвращает 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

Возвращает self, если ndigits равно нулю или положительно.

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 недопустимо.

Связанный метод: Integer#truncate.

Возвращает количество байтов в машинном представлении 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

Возвращает следующее целое число после self (эквивалентно self + 1):

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

Связанный метод: Integer#pred (предыдущее значение).

Вызывает заданный блок self раз, передавая ему каждое целое число из (0..self-1):

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

Если блок не задан, возвращает Enumerator.

Преобразует Integer в OpenSSL::BN

Дополнительные сведения см. в «man bn».

Преобразует self в Float:

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

Если значение self не помещается в Float, результатом будет бесконечность:

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

Возвращает self (которое уже является Integer).

Возвращает self (которое уже является Integer).

Возвращает значение в виде рационального числа.

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

Возвращает строку, содержащую позиционное представление 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 выходит за допустимый диапазон.

Возвращает self, усечённое (в сторону нуля) до точности в ndigits десятичных знаков.

Если ndigits отрицательно, возвращаемое значение содержит не менее ndigits.abs нулей в конце:

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

Возвращает self, если ndigits равно нулю или положительно.

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

Связанный метод: Integer#round.

Вызывает заданный блок для каждого целого числа от 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.

Возвращает true, если self равно нулю, и false в противном случае.