Хэл Фултон - Программирование на языке Ruby

class Float

# Определение round2 такое же, как и выше.

def roundf2(places)

shift = 10**places

(self * shift).round2 / shift.to_f

end

end

a = 6.125

b = 6.135

x = a.roundf2(a) #6.12

y = b.roundf2(b) #6.13

У методов roundfи roundf2есть ограничение: большое число с плавающей точкой может стать непредставимым при умножении на большую степень 10. На этот случай следовало бы предусмотреть проверку ошибок.

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

x = 1000001.0/0.003

y = 0.003*x

if y == 1000001.0

puts "да"

else

puts "нет"

end

Объясняется это тем, что для хранения числа с плавающей точкой выделено конечное число битов, а с помощью любого, сколь угодно большого, но конечного числа битов нельзя представить периодическую десятичную дробь с бесконечным числом знаков после запятой.

Из-за этой неустранимой неточности при сравнении чисел с плавающей точкой мы можем оказаться в ситуации (продемонстрированной выше), когда с практической точки зрения два числа равны, но аппаратура упрямо считает их различными.

Ниже показан простой способ выполнения сравнения с «поправкой», когда числа считаются равными, если отличаются не более чем на величину, задаваемую программистом:

class Float

EPSILON = 1e-6 # 0.000001

def == (x)

(self-x).abs < EPSILON

end

end

x = 1000001.0/0.003

y = 0.003*x

if y == 1.0 # Пользуемся новым оператором ==.

puts "да" # Теперь печатается "да".

else

puts "нет"

end

В зависимости от ситуации может понадобиться задавать разные погрешности. Для этого определим в классе Floatновый метод equals?. (При таком выборе имени мы избежим конфликта со стандартными методами equal?и eql?; последний, кстати, вообще не следует переопределять).

class Float

EPSILON = 1e-6

def equals?(x, tolerance=EPSILON)

(self-x).abs < tolerance

end

end

flag1 = (3.1416).equals? Math::PI # false

flag2 = (3.1416).equals?(Math::PI, 0.001) # true

Можно также ввести совершенно новый оператор для приближенного сравнения, назвав его, например, =~.

Имейте в виду, что это нельзя назвать настоящим решением. При последовательных вычислениях погрешность накапливается. Если вам совершенно необходимы числа с плавающей точкой, смиритесь с неточностями (см. также разделы 5.8 и 5.9).

Для вывода числа в заданном формате применяется метод printfиз модуля Kernel. Он практически не отличается от одноименной функции в стандартной библиотеке С. Дополнительную информацию см. в документации по методу printf.

x = 345.6789

i = 123

printf("x = %6.2f\n", x) # x = 345.68

printf("x = %9.2e\n", x) # x = 3.457e+02

printf("i = %5d\n\ i) # i = 123

printf("i = %05d\n", i) # i = 00123

printf("i = %-5d\n\, i) # i = 123

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

str = sprintf ("%5.1f",x) # "345.7"

Наконец, в классе Stringесть метод %, решающий ту же задачу. Слева от знака %должна стоять форматная строка, а справа — единственный аргумент (или массив значений), результатом является строка.

# Порядок вызова: 'формат % значение'

str = "%5.1f" % x # "345.7"

str = "%6.2f, %05d" % [x,i] # "345.68, 00123"

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

def commas(x)

str = x.to_s.reverse

str.gsub!(/([0-9]{3})/,"\\1,")

str.gsub(/,$/,"").reverse

end

puts commas(123) # "123"

puts commas(1234) # "1,234"

puts commas(12345) # "12,435"

puts commas(123456) # "123,456"

puts commas(1234567) # "1,234,567"

При необходимости Ruby позволяет работать с произвольно большими целыми числами. Переход от Fixnumк Bignumпроизводится автоматически, прозрачно для программиста. В следующем разделе результат оказывается настолько большим, что преобразуется из объекта Fixnumв Bignum:

num1 = 1000000 # Один миллион (10**6)

num2 = num1*num1 # Один триллион (10**12)

puts num1 # 1000000

puts num1.class # Fixnum

puts num2 # 1000000000000

puts num2.class # Bignum

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

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

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

if (3.2 - 2.0) == 1.2

puts "равны"

else

puts "не равны" # Печатается "не равны"!

end

В подобной ситуации на помощь приходит класс BigDecimal. Однако в случае бесконечных периодических дробей проблема остается. Другой подход обсуждается в разделе 5.9 «Работа с рациональными числами».

Объект BigDecimalинициализируется строкой. (Объекта типа Floatбыло бы недостаточно, поскольку погрешность вкралась бы еще до начала конструирования BigDecimal.) Метод BigDecimalэквивалентен BigDecimal.new; это еще один особый случай, когда имя метода начинается с прописной буквы. Поддерживаются обычные математические операции, например +и *. Отметим, что метод to_sможет принимать в качестве параметра форматную строку. Дополнительную информацию вы найдете на сайте ruby-doc.org.

require 'bigdecimal'

x = BigDecimal("3.2")

y = BigDecimal("2.0")

z = BigDecimal("1.2")

if (x - y) == z

puts "равны" # Печатается "равны"!

else

puts "не равны"

end

а = x*y*z

a.to_s # "0.768Е1" (по умолчанию: научная нотация)

a.to_s("F") # "7.68" (обычная запись)

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