Ruby/Подробнее о числах: различия между версиями
Содержимое удалено Содержимое добавлено
DannyS712 (обсуждение | вклад) м <source> -> <syntaxhighlight> (phab:T237267) |
|||
Строка 10:
Если, например, написать
<
puts 54308428790203478762340052723346983453487023489987231275412390872348475 **
54308428790203478762340052723346983453487023489987231275412390872348475</
то интерпретатор начинает ругаться и выдаёт <code>Infinity</code>. Можно подумать, что он не может обработать такое большое число. Конечно же это не так, что становится ясно после прочтения выдаваемого интерпретатором предупреждения. Там написано, что показатель степени (то есть второе число) не может быть типа Bignum (чтобы не пришлось слишком много считать).}}
Строка 18:
{{info|
Как ни странно, <math>2^{30}</math> определяется как <code>Bignum</code>
<
(2**30).class #=> Bignum</
Однако, целое число, меньшее (по модулю)<math>2^{30}</math> определяется как <code>Fixnum</code>
<
((2**30)-1).class #=> Fixnum
(-(2**30)+1).class #=> Fixnum
</syntaxhighlight>
Так-то!
Строка 34:
При записи целых чисел сначала указывается знак числа (знак <code>+</code> обычно не пишется). Далее идёт основание [[w:Система счисления|системы счисления]], в которой задаётся число (если оно отлично от [[w:Десятичная система счисления|десятичной]]): <code>0</code> — для [[w:Восьмеричная система счисления|восьмеричной]], <code>0x</code> — для [[w:Шестнадцатеричная система счисления|шестнадцатеричной]], <code>0b</code> — для [[w:Двоичная система счисления|двоичной]]. Затем идёт последовательность цифр, выражающих число в данной системе счисления. При записи чисел можно использовать символ подчёркивания, который игнорируется при обработке. Чтобы закрепить вышесказанное, посмотрим примеры целых чисел:
<
# тип Fixnum
123_456 # подчёркивание игнорируется
Строка 46:
123_456_789_123_456 # подчёркивание игнорируется
-123_456_789_123_456 # отрицательное
07777777777777777777 # восьмеричное большое</
Как видно из примеров, маленькие целые (<code>Fixnum</code>) и больши́е целые (<code>Bignum</code>) отличаются только значением.
Строка 54:
[[w:Числа с плавающей запятой|Числа с плавающей запятой]] задаются только в десятичной системе счисления, при этом для отделения дробной части используется символ <code>.</code> (точка). Для задания чисел с плавающей запятой может быть применена и экспоненциальная форма записи: два различных представления <code>0.1234e2</code> и <code>1234e-2</code> задают одно и то же число <code>12.34</code>.
<
-12.34 # отрицательное число с плавающей запятой
0.1234е2 # экспоненциальная форма для числа 12.34
1234е-2 # экспоненциальная форма для числа 12.34</
Следует упомянуть, что чи́сла с плавающей запятой имеют фиксированный диапазон значений в отличие от целых чисел. Этот недостаток легко устраняется подключением библиотеки <code>mathn</code> (подключаются рациональные и комплексные числа).
Строка 78:
Арифметические операции в 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
6 ** 4 #=> 1296</
Эти операции используются как числами с плавающей запятой, так и целыми числами (а также рациональными дробями и комплексными).
Строка 89:
Порядок вычисления обычный. Для изменения приоритета применяются круглые скобки:
<
(2 + 2) * 2 #=> 8</
Первое, что бросается в глаза, — результат арифметической операции двух целых чисел всегда будет целым. Особенно это видно при делении:
<
2/3 #=> 0
3/3 #=> 1</
Если все аргументы арифметического выражения целые числа, то результат будет целым, если хотя бы одно число с плавающей запятой, то результат будет числом с плавающей запятой.
Строка 107:
Посмотрим, каковы результаты, когда одно из чисел является числом с плавающей запятой.
<
6 - 4.0 #=> 2.0
6.0 * 4.0 #=> 24.0
6.0 / 4 #=> 1.5 (одно из чисел с плавающей запятой, значит результат с плавающей запятой)
6.0 % 4 #=> 2.0
6 ** 4.0 #=> 1296.0</
Лучше проверить эти сведения самостоятельно.
Строка 143:
Операции [[w:Битовые операции|побитовой арифметики]] заимствованы из языка [[w:Си (язык программирования)|Си]]. На этот раз без всяких экзотических особенностей.
<
6 | 4 #=> 6
6 ^ 4 #=> 2
6 << 4 #=> 96
6 >> 4 #=> 0 (чересчур намного сдвинули)
~4 #=> -5 (операция только над одним аргументом)</
Здесь, вроде, всё понятно и без дополнительных пояснений. А если непонятно, то справочник по языку Си поможет.
Строка 156:
Часто можно встретить выражения вида:
<
Это выполнение операции сразу с присваиванием. Вышеуказанная запись равнозначна следующей:
<
Вполне естественно, что вместо операции <code>+</code> может использоваться любая другая, а вместо чисел могут быть другие типы данных.
<
string += ", "
string *= 3
Строка 171:
array = [1, 2, 3]
array += [4, 5]
array #=> [1, 2, 3, 4, 5]</
При определении метода <code>+</code> метод <code>+=</code> вы получаете в подарок. Это правило касается всех бинарных операций, обозначаемых значками.
Строка 192:
Методы преобразования типов в 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"
"7".to_a #=> ["7"]</
=== Случайное число ===
Строка 202:
Часто требуется получить [[w:Случайная величина|случайное число]]. Пример:
<
rand #=> 0.599794231588021</
В первом случае метод <code>rand</code> возвращает ''целое число'' в диапазоне от <code>0</code> до <code>99</code> (на единицу меньше 100). Во втором случае метод <code>rand</code> возвращает ''число с плавающей запятой'' в диапазоне от <code>0.0</code> до <code>1.0</code> включительно. Различие в результате обусловлено передаваемым параметром:
Строка 212:
Есть способ предсказать весь ряд «случайных» чисел. Делается это при помощи метода <code>srand</code>. Ему передаётся целое число (идентификатор «случайной» последовательности). После этого весь случайный ряд можно предугадать. Проведём опыт: берусь угадать массив, который будет создан следующей программой.
<
Array.new(5){ rand(100) } #=> [66, 92, 98, 17, 83]</
<!-- проверено на ruby 1.8.6 (2008-03-03 patchlevel 114) [x86_64-linux]-->
Строка 224:
Задача: выдать целое число в [[w:Двоичная система счисления|двоичной системе счисления]].
<
puts sprintf("%b", start_number) # метод sprintf заимствован из Си
puts start_number.to_s(2) # современный метод — означает «по основанию»,
# аргументом может служить не только 8 и 16, но и 5, 30…
# На самом деле, основание не может превышать 36,
# что вполне объяснимо — 10 цифр и 26 букв латинского алфавита.</
Поменять порядок цифр данного числа на обратный:
<
puts start_number.to_s.reverse # метод reverse переворачивает строку</
Получить значение N-го двоичного разряда данного целого числа:
<
puts start_number[N]</
Поменять целочисленные значения двух переменных без использования третьей переменной:
<
number_one, number_two = number_two, number_one</
Округлить число с плавающей запятой до двух разрядов:
<
puts (float_integer * 100).to_i.to_f / 100
puts ((float_integer + 0.005) * 100).to_i / 100.0
puts sprintf("%.2f", float_integer).to_f # полуСишный способ =)</
На самом деле во второй строке оставляются два знака после запятой, а остальные просто отбрасываются безо всяких округлений, в то время как в третьей строке действительно происходит округление до двух знаков после запятой. Это легко проверить попытавшись округлить до трёх знаков после запятой:
<
puts (float_integer * 1000).to_i.to_f / 1000 #=>3.141
puts ((float_integer + 0.0005) * 1000).to_i / 1000.0 #=>3.142
puts sprintf("%.3f", float_integer).to_f #=>3.142</
Но всё же лучше:
<
float_integer.round 3 #=>3.142 (возможно, что round округляет только до целых)</
|