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

class MyNumberSystem

def +(other)

if other.kind_of?(MyNumberSystem)

result = some_calculation_between_self_and_other

MyNumberSystem.new(result)

else

n1, n2 = other.coerce(self)

n1 + n2

end

end

end

Метод coerceвозвращает массив из двух элементов, содержащий аргумент и вызывающий объект, приведенные к совместимым типам.

В данном примере мы полагаемся на то, что приведение выполнит тип аргумента. Но если мы хотим быть законопослушными гражданами, то должны реализовать приведение в своем классе, сделав его пригодным для работы с другими типами чисел. Для этого нужно знать, с какими типами мы в состоянии работать непосредственно, и при необходимости выполнять приведение к одному из этих типов. Если мы не можем сделать это самостоятельно, то должны обратиться за помощью к родительскому классу.

def coerce(other)

if other.kind_of?(Float)

return other, self.to_f

elsif other.kind_of?(Integer)

return other, self.to_i

else

super

end

end

Разумеется, это будет работать только, если наш объект реализует методы to_iи to_f.

Метод coerceможно применить для реализации автоматического преобразования строк в числа, как в языке Perl:

class String

def coerce(n)

if self['.']

[n, Float(self)]

else

[n, Integer(self)]

end

end

end

x = 1 + "23" # 24

y = 23 * "1.23" # 28.29

Мы не настаиваем на таком решении. Но рекомендуем реализовывать coerceпри создании любого класса для работы с числовыми данными.

Иногда требуется работать с двоичным представлением объекта Fixnum. На прикладном уровне такая необходимость возникает нечасто, но все-таки возникает.

Ruby обладает всеми средствами для таких операций. Для удобства числовые константы можно записывать в двоичном, восьмеричном или шестнадцатеричном виде. Поразрядным операциям И, ИЛИ, ИСКЛЮЧАЮЩЕЕ ИЛИ и НЕ соответствуют операторы &, |, ^и ~.

x = 0377 # Восьмеричное (десятичное 255)

y = 0b00100110 # Двоичное (десятичное 38)

z = 0xBEEF # Шестнадцатеричное (десятичное 48879)

а = x | z # 48895 (поразрядное ИЛИ)

b = x & z # 239 (поразрядное И)

с = x ^ z # 48656 (поразрядное ИСКЛЮЧАЮЩЕЕ ИЛИ)

d = ~ y # -39 (отрицание или дополнение до 1)

Метод экземпляра sizeпозволяет узнать размер слова для той машины, на которой исполняется программа.

size # Для конкретной машины возвращает 4.

Имеются операторы сдвига влево и вправо ( <<и >>соответственно). Это логические операторы сдвига, они не затрагивают знаковый бит (хотя оператор >>распространяет его).

x = 8

y = -8

а = x >> 2 # 2

b = y >> 2 # -2

с = x << 2 # 32

d = y << 2 # -32

Конечно, если сдвиг настолько велик, что дает нулевое значение, то знаковый бит теряется, поскольку -0 и 0 — одно и то же.

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

x = 5 # То же, что 0b0101

а = x[0] # 1

b = x[1] # 0

с = x[2] # 1

d = x[3] # 0

# И так далее # 0

Присваивать новые значения отдельным битам с помощью такой нотации невозможно (поскольку Fixnumхранится как непосредственное значение, а не как ссылка на объект). Но можно имитировать это действие путем сдвига 1 влево на нужное число позиций с последующим выполнением операции ИЛИ или И.

# Выполнить присваивание x[3] = 1 нельзя,

# но можно поступить так:

x |= (1<<3)

# Выполнить присваивание x[4] = 0 нельзя,

# но можно поступить так:

x &= ~(1<<4)

Ясно, что любое целое число можно представить в любой системе счисления, поскольку хранятся эти числа в двоичном виде. Мы знаем, что Ruby умеет работать c целыми константами, записанными в любой из четырех наиболее популярных систем. Следовательно, разговор о преобразовании системы счисления может вестись только применительно к числам, записанным в виде строк.

Вопрос о преобразовании строки в целое рассмотрен в разделе 2.24. Для преобразования числа в строку проще всего воспользоваться методом to_s, которому можно еще передать основание системы счисления. По умолчанию оно равно 10, но в принципе может быть любым вплоть до 36 (когда задействованы все буквы латинского алфавита).

237.to_s(2) # "11101101"

237.to_s(5) # "1422"

237.to_s(8) # "355"

237.to_s # "237"

237.to_s(16) # "ed"

237.to_s(30) # "7r"

Другой способ — обратиться к методу %класса String:

hex = "%x" % 1234 # "4d2"

oct = "%о" % 1234 # "2322"

bin = "%b" % 1234 # "10011010010"

Метод sprintfтоже годится:

str = sprintf(str,"Nietzsche is %x\n",57005)

# str теперь равно: "Nietzsche is dead\n"

Если нужно сразу же вывести преобразованное в строку значение, то подойдет и метод printf.

В Ruby встроена функция извлечения квадратного корня ( Math.sqrt), поскольку именно она применяется чаще всего. А если надо извлечь корень более высокой степени? Если вы еще не забыли математику, то эта задача не вызовет затруднений.

Можно, например, воспользоваться логарифмами. Напомним, что е в степени x — обратная функция к натуральному логарифму x и что умножение чисел эквивалентно сложению их логарифмов.

x = 531441

cuberoot = Math.exp(Math.log(x)/3.0) # 81.0

fourthroot = Math.exp(Math.log(x)/4.0) # 27.0

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

include Math

y = 4096

cuberoot = y**(1.0/3.0) # 16.0

fourthroot = y**(1.0/4.0) # 8.0

fourthroot = sqrt(sqrt(y)) # 8.0 (то же самое)

twelfthroot = y**(1.0/12.0) # 2.0

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

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

Хотите верьте, хотите нет, но решение не произвольно. Существуют убедительные аргументы в пользу обеих точек зрения (обсуждать их здесь мы не будем).

Вот уже больше двадцати лет, как для описания противоположных позиций применяются термины «остроконечный» (little-endian) и «тупоконечный» (big-endian). Кажется, впервые их употребил Дэнни Коэн (Danny Cohen); см. его классическую статью "On Holy Wars and a Plea for Peace" (IEEE Computer, October 1981). Взяты они из романа Джонатана Свифта «Путешествия Гулливера».