Ruby/Подробнее о числах: различия между версиями

Если, например, написать

 

puts 54308428790203478762340052723346983453487023489987231275412390872348475 **

 

то интерпретатор начинает ругаться и выдаёт <code>Infinity</code>. Можно подумать, что он не может обработать такое большое число. Конечно же это не так, что становится ясно после прочтения выдаваемого интерпретатором предупреждения. Там написано, что показатель степени (то есть второе число) не может быть типа Bignum (чтобы не пришлось слишком много считать).}}

{{info|

Как ни странно, <math>2^{30}</math> определяется как <code>Bignum</code>

 

Однако, целое число, меньшее (по модулю)<math>2^{30}</math> определяется как <code>Fixnum</code>

((2**30)-1).class #=> Fixnum

(-(2**30)+1).class #=> Fixnum

 

Так-то!

При записи целых чисел сначала указывается знак числа (знак <code>+</code> обычно не пишется). Далее идёт основание [[w:Система счисления|системы счисления]], в которой задаётся число (если оно отлично от [[w:Десятичная система счисления|десятичной]]): <code>0</code> — для [[w:Восьмеричная система счисления|восьмеричной]], <code>0x</code> — для [[w:Шестнадцатеричная система счисления|шестнадцатеричной]], <code>0b</code> — для [[w:Двоичная система счисления|двоичной]]. Затем идёт последовательность цифр, выражающих число в данной системе счисления. При записи чисел можно использовать символ подчёркивания, который игнорируется при обработке. Чтобы закрепить вышесказанное, посмотрим примеры целых чисел:

 

# тип Fixnum

123_456 # подчёркивание игнорируется

123_456_789_123_456 # подчёркивание игнорируется

-123_456_789_123_456 # отрицательное

 

Как видно из примеров, маленькие целые (<code>Fixnum</code>) и больши́е целые (<code>Bignum</code>) отличаются только значением.

[[w:Числа с плавающей запятой|Числа с плавающей запятой]] задаются только в десятичной системе счисления, при этом для отделения дробной части используется символ <code>.</code> (точка). Для задания чисел с плавающей запятой может быть применена и экспоненциальная форма записи: два различных представления <code>0.1234e2</code> и <code>1234e-2</code> задают одно и то же число <code>12.34</code>.

 

-12.34 # отрицательное число с плавающей запятой

0.1234е2 # экспоненциальная форма для числа 12.34

 

Следует упомянуть, что чи́сла с плавающей запятой имеют фиксированный диапазон значений в отличие от целых чисел. Этот недостаток легко устраняется подключением библиотеки <code>mathn</code> (подключаются рациональные и комплексные числа).

Арифметические операции в Ruby обычны: [[w:Сложение|сложение]] (<code>+</code>), [[w:Вычитание|вычитание]] (<code>-</code>), [[w:Умножение|умножение]] (<code>*</code>), [[w:Деление (математика)|деление]] (<code>/</code>), получение остатка от деления (<code>%</code>), возведение в степень (<code>**</code>).

 

6 - 4 #=> 2

6 * 4 #=> 24

6 / 4 #=> 1

6 % 4 #=> 2

 

Эти операции используются как числами с плавающей запятой, так и целыми числами (а также рациональными дробями и комплексными).

Порядок вычисления обычный. Для изменения приоритета применяются круглые скобки:

 

 

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

 

2/3 #=> 0

 

Если все аргументы арифметического выражения целые числа, то результат будет целым, если хотя бы одно число с плавающей запятой, то результат будет числом с плавающей запятой.

Посмотрим, каковы результаты, когда одно из чисел является числом с плавающей запятой.

 

6 - 4.0 #=> 2.0

6.0 * 4.0 #=> 24.0

6.0 / 4 #=> 1.5 (одно из чисел с плавающей запятой, значит результат с плавающей запятой)

6.0 % 4 #=> 2.0

 

Лучше проверить эти сведения самостоятельно.

Операции [[w:Битовые операции|побитовой арифметики]] заимствованы из языка [[w:Си (язык программирования)|Си]]. На этот раз без всяких экзотических особенностей.

 

6 | 4 #=> 6

6 ^ 4 #=> 2

6 << 4 #=> 96

6 >> 4 #=> 0 (чересчур намного сдвинули)

 

Здесь, вроде, всё понятно и без дополнительных пояснений. А если непонятно, то справочник по языку Си поможет.

Это выполнение операции сразу с присваиванием. Вышеуказанная запись равнозначна следующей:

 

 

Вполне естественно, что вместо операции <code>+</code> может использоваться любая другая, а вместо чисел могут быть другие типы данных.

 

string += ", "

string *= 3

array = [1, 2, 3]

array += [4, 5]

 

При определении метода <code>+</code> метод <code>+=</code> вы получаете в подарок. Это правило касается всех бинарных операций, обозначаемых значками.

Методы преобразования типов в Ruby традиционно начинаются с приставки <code>to_</code>. Последующая буква — это сокращение от названия класса, в который происходит преобразование (<code>f</code> — <code>Float</code> — число с плавающей запятой, <code>i</code> — <code>Integer</code> — целое, <code>s</code> — <code>String</code> — строка, <code>a</code> — <code>Array</code> — массив). Посмотрим их действие на примере:

 

7.to_f #=> 7.0

7.9.to_i #=> 7

7.to_s #=> "7"

 

=== Случайное число ===

Часто требуется получить [[w:Случайная величина|случайное число]]. Пример:

 

 

В первом случае метод <code>rand</code> возвращает ''целое число'' в диапазоне от <code>0</code> до <code>99</code> (на единицу меньше 100). Во втором случае метод <code>rand</code> возвращает ''число с плавающей запятой'' в диапазоне от <code>0.0</code> до <code>1.0</code> включительно. Различие в результате обусловлено передаваемым параметром:

Есть способ предсказать весь ряд «случайных» чисел. Делается это при помощи метода <code>srand</code>. Ему передаётся целое число (идентификатор «случайной» последовательности). После этого весь случайный ряд можно предугадать. Проведём опыт: берусь угадать массив, который будет создан следующей программой.

 

<!-- проверено на ruby 1.8.6 (2008-03-03 patchlevel 114) [x86_64-linux]-->

 

Задача: выдать целое число в [[w:Двоичная система счисления|двоичной системе счисления]].

 

puts sprintf("%b", start_number) # метод sprintf заимствован из Си

puts start_number.to_s(2) # современный метод — означает «по основанию»,

# аргументом может служить не только 8 и 16, но и 5, 30…

# На самом деле, основание не может превышать 36,

 

Поменять порядок цифр данного числа на обратный:

 

 

Получить значение N-го двоичного разряда данного целого числа:

 

 

Поменять целочисленные значения двух переменных без использования третьей переменной:

 

 

Округлить число с плавающей запятой до двух разрядов:

 

puts (float_integer * 100).to_i.to_f / 100

puts ((float_integer + 0.005) * 100).to_i / 100.0

 

На самом деле во второй строке оставляются два знака после запятой, а остальные просто отбрасываются безо всяких округлений, в то время как в третьей строке действительно происходит округление до двух знаков после запятой. Это легко проверить попытавшись округлить до трёх знаков после запятой:

 

puts (float_integer * 1000).to_i.to_f / 1000 #=>3.141

puts ((float_integer + 0.0005) * 1000).to_i / 1000.0 #=>3.142

 

Но всё же лучше:

 

[[Категория:Ruby|Подробнее о числах]]