Викиучебник

Ruby/Справочник/Bignum

< Ruby | Справочник

Класс Bignum < Integer

править

Классу Bignum принадлежат целые числа, которые не умещаются в диапазон класса Fixnum. Объекты класса Bignum создаются автоматически, когда результат вычислений превышает (по модулю) предельное значение класса Fixnum. Когда, в результате вычислений, объект класса Bignum уменьшается настолько, что его значение можно хранить в объекте класса Fixnum, то он автоматически преобразуется в Fixnum. Для обеспечения работы побитовых операций и метода [], объект класса Bignum следует рассматривать как двоичную последовательность бесконечной длины. В отличие от Fixnum, объекты класса Bignum передаются не непосредственно, а по ссылке.

Методы объекта

[], %, &, **, *, +, -@, -, /, <<, <=>, ==, >>, ^, abs, coerce, divmod, div, eql?, hash, modulo, power!, quo, rdiv, remainder, rpower, size, to_f, to_s, ||, ~

Bignum#%

править 
big % other         
big.modulo(other)   #-> numeric

Возвращает остаток от деления чис#-> numeric 

1234567890 % 2      #-> 0
1234567890 % 1.2    #-> 4.56881898980299e-008
1234567890 % -2     #-> 0
 

Полезно взглянуть в описание метода Numeric#divmod для получения более детальной информации

 

Методы % и modulo — абсолютно идентичны, то есть являются именами одного и того же метода

 

Полезно посмотреть на методы **, +, -, / и *, которые имеют схожую функциональность

Bignum#&

править 
big & numeric   #->  integer

Побитовое И.

Bignum#*

править 
big * other  #-> numeric

Умножает число big на число other и возвращает результат. 

1234567890 * 2      #-> 2469135780
1234567890 * 1.2    #-> 1481481468.0
1234567890 * -2     #-> -2469135780
 

Полезно посмотреть на методы **, +, -, / и %, которые имеют схожую функциональность

Bignum#**

править 
big ** other        #-> numeric
big.rpower(other)   #-> numeric

Возводит число big в степень other (которая может быть целым, дробным или любым другим числом). Результат может быть класса Fixnum, Bignum или Float. 

123456789 ** 2      #-> 15241578750190521
123456789 ** 1.2    #-> 5126464716.09932
123456789 ** -2     #-> 6.5610001194102e-17
 

Полезно посмотреть на методы *, +, -, /, % и power!, которые имеют схожую функциональность

 

Методы ** и rpower — абсолютно идентичны, то есть являются именами одного и того же метода

Bignum#+

править 
big + other  #-> numeric

Складывает число big с числом other и возвращает результат. 

1234567890 + 2      #-> 1234567892
1234567890 + 1.2    #-> 1234567891.2
1234567890 + (-2)   #-> 1234567888
 

Полезно посмотреть на методы **, *, -, / и %, которые имеют схожую функциональность

Bignum#-

править 
big - other  #-> numeric

Вычитает из числа big число other и возвращает результат. 

1234567890 - 2      #-> 1234567888
1234567890 - 1.2    #-> 1234567888.8
1234567890 - (-2)   #-> 1234567892
 

Полезно посмотреть на методы **, +, *, / и %, которые имеют схожую функциональность

Bignum#-@

править 
-big   #->  other_big

Унарный минус (возвращает новый объект класса Bignum, значение которого равно 0-big)

Bignum#/

править 
big / other     #-> numeric
big.div(other)  #-> numeric

Делит число big на число other и возвращает результат. 

1234567890 / 2      #-> 617283945
1234567890 / 1.2    #-> 1028806575.0
1234567890 / (-2)   #-> -617283945
 

Полезно посмотреть на методы **, *, -, +, % и quo, которые имеют схожую функциональность

 

Методы / и div — абсолютно идентичны, то есть являются именами одного и того же метода

Bignum#<<

править 
big << numeric   #->  integer

Побитовый сдвиг числа big влево на numeric позиций (вправо, если numeric меньше нуля).

 

Полезно посмотреть на метод >>, который имеет схожую функциональность

Bignum#<=>

править 
big <=> numeric   #-> -1, 0, +1

Сравнение — возвращает −1, 0 или +1, если значение числа big меньше, равно или больше значения числа numeric, соответственно. Это базис для тестов в примеси Comparable.

Bignum#

править 
big == obj  #-> true или false

Возвращает true, если число obj имеет такое же значение, что и число big. В отличие от метода eql?, приводит число obj к классу Bignum. 

68719476736 == 68719476736.0   #-> true

Bignum#>>

править 
big >> numeric   #->  integer

Побитовый сдвиг числа big вправо на numeric позиций (влево, если numeric меньше нуля).

 

Полезно посмотреть на метод <<, который имеет схожую функциональность

Bignum#[]

править 
big[n]   #-> 0, 1

Побитовый доступ — возвращает nый бит (виртуальный) двоичного представления числа big, где big[0] — младший значащий бит. 

a = 9**15
50.downto(0) do |n|
  print a[n]
end

результат: 

 000101110110100000111000011110010100111100010111001

Bignum#^

править 
big ^ numeric   #->  integer

Побитовое ИСКЛЮЧАЮЩЕЕ ИЛИ

Bignum#abs

править 
big.abs #-> bignum

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

-1234567890987654321.abs   #-> 1234567890987654321

Bignum#coerce

править 
big.coerce(other)   #-> array

Возвращает массив, состоящий из чисел other и big, которые преобразованы к классу Bignum. 

result = 1234567890.coerce( 1234 )   #-> [1234, 1234567890]
result[0]                            #-> 1234
result[0].class                      #-> Bignum

Bignum#div

править 
big / other     #-> numeric
big.div(other)  #-> numeric

Делит число big на число other и возвращает результат. 

1234567890 / 2      #-> 617283945
1234567890 / 1.2    #-> 1028806575.0
1234567890 / (-2)   #-> -617283945
 

Полезно посмотреть на методы **, *, -, +, % и quo, которые имеют схожую функциональность

 

Методы / и div — абсолютно идентичны, то есть являются именами одного и того же метода

Bignum#divmod

править 
big.divmod(numeric)   #-> array
 

Полезно взглянуть в описание метода Numeric#divmod для получения более детальной информации

Bignum#eql?

править 
big.eql?(obj)   #-> true или false

Возвращает true, если число obj имеет такое же значение, что и число big. В отличие от метода ==, не занимается приведением типов. 

68719476736.eql?(68719476736.0)   #-> false

Bignum#hash

править 
big.hash   #-> fixnum

Вычисляет контрольную сумму на основе значения числа big.

Bignum#modulo

править 
big % other         #-> numeric
big.modulo(other)   #-> numeric

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

 

Полезно взглянуть в описание метода Numeric#divmod для получения более детальной информации

 

Методы % и modulo — абсолютно идентичны, то есть являются именами одного и того же метода

 

Полезно посмотреть на методы **, +, -, / и *, которые имеют схожую функциональность

Bignum#power!

править 
big.power!(other)   #-> numeric

Производит возведение числа fix в степень other. 

1234567890.power!( 2 )    #-> 1524157875019052100
1234567890.power!( -2 )   #-> 6.5610001194102e-019
 

Полезно посмотреть на методы ** и rpower, которые имеют схожую функциональность

Bignum#quo

править 
big.quo(other)    #-> numeric
big.rdiv(other)   #-> numeric

Делит число big на число other и в качестве результата возвращает рациональное число. 

1234567890.quo(7)   #-> Rational(1234567890, 7)
 

Полезно посмотреть на методы / и div, которые имеют схожую функциональность

 

Методы quo и rdiv — абсолютно идентичны, то есть являются именами одного и того же метода

Bignum#rdiv

править 
big.quo(other)    #-> numeric
big.rdiv(other)   #-> numeric

Делит число big на число other и в качестве результата возвращает рациональное число. 

1234567890.rdiv(7)   #-> Rational(1234567890, 7)
 

Полезно посмотреть на методы / и div, которые имеют схожую функциональность

 

Методы quo и rdiv — абсолютно идентичны, то есть являются именами одного и того же метода

Bignum#remainder

править 
big.remainder(numeric)    #-> number

Возвращает остаток от деления числа big на число numeric. 

-1234567890987654321.remainder(13731)      #-> -6966
-1234567890987654321.remainder(13731.24)   #-> -9906.22531493148
 

Полезно посмотреть на методы quo, rdiv, % и modulo, которые имеют схожую функциональность

 
 Внимание! Результат работы данного метода и методов % и modulo (которые по идее делают тоже самое) существенно отличаются

Bignum#rpower

править 
big ** other        #-> numeric
big.rpower(other)   #-> numeric

Производит возведение числа big в степень other. Возвращает рациональное число, если результат рациональный (то есть, когда other < 0). 

1234567890.power!( 2 )    #-> 1524157875019052100
1234567890.power!( -2 )   #-> Rational(1, 1524157875019052100)
 

Методы ** и rpower — абсолютно идентичны, то есть являются именами одного и того же метода

 

Полезно посмотреть на метод power!, который имеет схожую функциональность

Bignum#size

править 
big.size #-> integer

Возвращает количество байт машинного представления числа big. 

(256**10 - 1).size   #-> 12
(256**20 - 1).size   #-> 20
(256**40 - 1).size   #-> 40

Bignum#to_f

править 
big.to_f   #-> float

Преобразует число big в число класса Float. Если число big не может быть преобразовано к классу Float, то возвращает бесконечность.

 

Полезно посмотреть на метод to_s, который имеет схожую функциональность

Bignum#to_s

править 
big.to_s(base=10)   #->  string

Возвращает строку, где число big имеет основание системы счисления равное base (между 2 и 36). По умолчанию base=10 (то есть десятичная система счисления). 

12345654321.to_s         #-> "12345654321"
12345654321.to_s(2)      #-> "1011011111110110111011110000110001"
12345654321.to_s(8)      #-> "133766736061"
12345654321.to_s(16)     #-> "2dfdbbc31"
78546939656932.to_s(36)  #-> "rubyrules"
 

Полезно посмотреть на метод to_f, который имеет схожую функциональность

Bignum#|

править 
big | numeric   #->  integer

Побитовое ИЛИ.

Bignum#≈

править 
~big  #->  integer

Побитовое НЕ. Так как Bignum теоретически имеет бесконечную длину, то для вычисления результата берется число big на один бит длиннее старшего значащего бита (чтобы операция инверсии была обратимой). 

sprintf("%X", ~0x499602d2)    #-> "-499602d3"
~~1234567890                  #-> 1234567890
Источник — https://ru.wikibooks.org/w/index.php?title=Ruby/Справочник/Bignum&oldid=163402