Текст книги "Программирование на языке Ruby"
Автор книги: Хэл Фултон
Жанр:
Программирование
сообщить о нарушении
Текущая страница: 17 (всего у книги 56 страниц) [доступный отрывок для чтения: 20 страниц]
5.25. Вычисление среднего, медианы и моды набора данных
Пусть дан массив x, вычислим среднее значение по всем элементам массива. На самом деле есть три общеупотребительные разновидности среднего значения. Среднее арифметическое – это то, что мы называем средним в обыденной жизни. Среднее гармоническое – это число элементов, поделенное на сумму обратных к ним. И, наконец, среднее геометрическое – это корень n-ой степени из произведения n значений. Вот эти определения, воплощенные в коде:
def mean(x)
sum=0
x.each {|v| sum += v}
sum/x.size
end
def hmean(x)
sum=0
x.each {|v| sum += (1.0/v)}
x.size/sum
end
def gmean(x)
prod=1.0
x.each {|v| prod *= v}
prod**(1.0/x.size)
end
data = [1.1, 2.3, 3.3, 1.2, 4.5, 2.1, 6.6]
am = mean(data) # 3.014285714
hm = hmean(data) # 2.101997946
gm = gmean(data) # 2.508411474
Медианой набора данных называется значение, которое оказывается приблизительно в середине отсортированного набора (ниже приведен код для вычисления медианы). Примерно половина элементов набора меньше медианы, а другая половина – больше. Ясно, что такая статистика показательна не для всякого набора.
def median(x)
sorted = x.sort
mid = x.size/2
sorted[mid]
end
data = [7,7,7,4,4,5,4,5,7,2,2,3,3,7,3,4]
puts median(data) # 4
Мода набора данных – это наиболее часто встречающееся в нем значение. Если такое значение единственно, набор называется унимодальным, в противном случае — мультимодальным. Мультимодальные наборы более сложны, здесь мы их рассматривать не будем. Интересующийся читатель может обобщить и улучшить приведенный ниже код:
def mode(x)
f = {} # Таблица частот.
fmax = 0 # Максимальная частота.
m = nil # Мода.
x.each do |v|
f[v] ||= 0
f[v] += 1
fmax,m = f[v], v if f[v] > fmax
end
return m
end
data = [7,7,7,4,4,5,4,5,7,2,2,3,3,7,3,4]
puts mode(data) # 7
5.26. Дисперсия и стандартное отклонение
Дисперсия – это мера «разброса» значений из набора. (Здесь мы не различаем смещенные и несмещенные оценки.) Стандартное отклонение, которое обычно обозначается буквой σ, равно квадратному корню из дисперсии.
Data = [2, 3, 2, 2, 3, 4, 5, 5, 4, 3, 4, 1, 2]
def variance(x)
m = mean(x)
sum = 0.0
x.each {|v| sum += (v-m)**2 }
sum/x.size
end
def sigma(x)
Math.sqrt(variance(x))
end
puts variance(data) # 1.461538462
puts sigma(data) # 1.20894105
Отметим, что функция variance вызывает определенную выше функцию mean.
5.27. Вычисление коэффициента корреляции
Коэффициент корреляции — одна из самых простых и полезных статистических мер. Он измеряет «линейность» набора, состоящего из пар (x, у), и изменяется от -1.0 (полная отрицательная корреляция) до +1.0 (полная положительная корреляция).
Для вычисления воспользуемся функциями mean и sigma (стандартное отклонение), которые были определены в разделах 5.25 и 5.26. О смысле этого показателя можно прочитать в любом учебнике по математической статистике.
В следующем коде предполагается, что есть два массива чисел одинакового размера:
def correlate(x,y)
sum = 0.0
x.each_index do |i|
sum += x[i]*y[i]
end
xymean = sum/x.size.to_f
xmean = mean(x)
ymean = mean(y)
sx = sigma(x)
sy = sigma(y)
(xymean-(xmean*ymean))/(sx*sy)
end
a = [3, 6, 9, 12, 15, 18, 21]
b = [1.1, 2.1, 3.4, 4.8, 5.6]
с = [1.9, 1.0, 3.9, 3.1, 6.9]
c1 = correlate(a,a) # 1.0
c2 = correlate(a,a.reverse) # -1.0
c3 = correlate(b,c) # 0.8221970228
Приведенная ниже версия отличается лишь тем, что работает с одним массивом, каждый элемент которого – массив, содержащий пару (x, у):
def correlate2(v)
sum = 0.0
v.each do |a|
sum += a[0]*a[1]
end
xymean = sum/v.size.to_f
x = v.collect {|a| a[0]}
y = v.collect {|a| a[1]}
xmean = mean(x)
ymean = mean(y)
sx = sigma(x)
sy = sigma(y)
(xymean-(xmean*ymean))/(sx*sy)
end
d = [[1,6.1], [2.1,3.1], [3.9,5.0], [4.8,6.2]]
c4 = correlate2(d) # 0.2277822492
И, наконец, в последнем варианте предполагается, что пары (x, у) хранятся в хэше. Код основан на предыдущем примере:
def correlate_h(h)
correlate2(h.to_a)
end
e = { 1 => 6.1, 2.1 => 3.1, 3.9 => 5.0, 4.8 => 6.2}
c5 = correlated(e) # 0.2277822492
5.28. Генерирование случайных чисел
Если вас устраивают псевдослучайные числа, вам повезло. Именно они предоставляются в большинстве языков, включая и Ruby.
Метод rand из модуля Kernel возвращает псевдослучайное число x с плавающей точкой, отвечающее условиям x >= 0.0 и x < 1.0. Например (вы можете получить совсем другое число):
a = rand # 0.6279091137
Если при вызове задается целочисленный параметр max, то возвращается целое число из диапазона 0...max (верхняя граница не включена). Например:
n = rand(10) # 7
Чтобы «затравить» генератор случайных чисел (задать начальное значение – seed), применяется метод srand из модуля Kernel, который принимает один числовой параметр. Если не передавать никакого значения, то метод srand самостоятельно изготовит затравку, учитывая (среди прочего) текущее время. Если же параметр передан, то именно он и становится затравкой. Это бывает полезно при тестировании, когда для воспроизводимости результатов многократно вызываемая программа должна получать одну и ту же последовательность псевдослучайных чисел.
srand(5)
i, j, k = rand(100), rand(100), rand(100)
# 26, 45, 56
srand(5)
l, m, n = rand(100), rand(100), rand(100)
# 26, 45, 56
5.29. Кэширование функций с помощью метода memoize
Пусть имеется вычислительно сложная математическая функция, которую нужно многократно вызывать по ходу работы программы. Если быстродействие критично и при этом можно пожертвовать небольшим количеством памяти, то имеет смысл сохранить результаты вычисления функции в таблице и обращаться к ней во время выполнения. (Тут неявно предполагается, что функция будет часто вызываться с одними и теми же параметрами, то есть получается, что мы «выбрасываем» результат дорогостоящего вычисления и снова повторяем его позже.) Такая техника иногда называется запоминанием (memoizing), отсюда и название библиотеки memoize.
Эта библиотека не входит в стандартный дистрибутив, поэтому придется установить ее вручную.
В следующем примере демонстрируется сложная функция zeta. Она применяется при решении одной задачи из области популяционной генетики, но вдаваться в объяснения мы не станем.
require 'memoize'
include Memoize
def zeta(x,y,z)
lim = 0.0001
gen = 0
loop do
gen += 1
p,q = x + y/2.0, z + y/2.0
x1, y1, z1 = p*p*1.0, 2*p*q*1.0, q*q*0.9
sum = x1 + y1 + z1
x1 /= sum
y1 /= sum
z1 /= sum
delta = [[x1,x],[y1,y],[z1,z]]
break if delta.all? {|a,b| (a-b).abs < lim }
x,y,z = x1,y1,z1
end
gen
end
g1 = zeta(0.8,0.1,0.1)
memoize(:zeta) # Сохранить таблицу в памяти.
g2 = zeta(0.8,0.1,0.1)
memoize(:zeta,"z.cache") # Сохранить таблицу на диске.
g3 = zeta(0.8,0.1,0.1)
Обратите внимание, что можно задать имя файла. Это может несколько замедлить работу, зато экономится память, и таким образом мы можем сохранить запомненные результаты и воспользоваться ими при следующих вызовах программы.
В ходе неформального тестирования мы вызывали функцию 50000 раз в цикле. Оказалось, что g2 вычисляется примерно в 1100 раз быстрее, чем g1, а g3 – примерно в 700 раз. На вашей машине может получиться иной результат.
Отметим еще, что библиотека memoize предназначена не только для математических функций. Ее можно использовать для запоминания результатов работы любого вычислительно сложного метода.
5.30. Заключение
В этой главе были рассмотрены различные представления чисел, в том числе целых (в разных системах счисления) и с плавающей точкой. Мы видели, какие трудности возникают при работе с числами с плавающей точкой и как можно частично обойти эти трудности, применяя рациональные числа. Мы познакомились с явными и неявными преобразованиями, а также с приведениями типов.
Также мы изучили разнообразные способы манипулирования числами, векторами и матрицами. Был приведен обзор стандартных библиотек, полезных для численного анализа, в частности библиотеки mathn.
Пойдем дальше. В следующей главе мы обсудим два очень характерных для Ruby типа данных: символы и диапазоны.
Глава 6. Символы и диапазоны
Я слышу и забываю. Я вижу и запоминаю. Я делаю и понимаю.
Конфуций
Символы и диапазоны – объекты, весьма характерные для языка Ruby. Они рассматриваются в одной главе не потому, что тесно связаны между собой, а потому, что сказать о них можно не так уж много.
Концепцию символа в Ruby понять непросто. Они напоминают «атомы» в языке Lisp. Вместо того чтобы давать длинное и сложное определение, я расскажу о том, что можно делать с символами и как они применяются. В конце концов, на вопрос «что такое число» можно дать очень глубокомысленный ответ, но нам нужно всего лишь знать, как манипулировать числами.
Диапазоны проще. Это всего лишь представление множества, заданного конечными точками. Аналогичные конструкции есть в языках Pascal, PHP и даже SQL.
Познакомимся с символами и диапазонами поближе, чтобы понять, как они практически используются в программах на Ruby.
6.1. Символы
Символ в Ruby – это экземпляр класса Symbol. Синтаксически он обычно обозначается двоеточием (:), за которым следует идентификатор.
Символ похож на строку, он тоже соответствует последовательности символов. Отличие от строки состоит в том, что у каждого символа есть только один экземпляр (как и в случае с объектами Fixnum). Следовательно, имеет место проблема потребления памяти или производительности, о которой нужно помнить. Например, в нижеприведенном коде строка "foo" представлена в памяти тремя различными объектами, а символ :foo – одним, на который есть несколько ссылок:
array = ["foo", "foo", "foo", :foo, :foo, :foo]
Некоторых смущает двоеточие перед именем символа. Не волнуйтесь, это всего лишь синтаксическое соглашение. У строк, массивов и хэшей есть начальный и конечный ограничители, а у символов – только начальный. Считайте, что это унарный, а не бинарный ограничитель. На первый взгляд синтаксис кажется странным, но ничего таинственного в нем нет.
Стоит отметить, что в старых версиях Ruby (до 1.6) символьные константы были полноценными объектами, поскольку преобразовывались в Fixnum и в таком виде хранились. Внутреннее представление осталось таким же; символу ставится в соответствие число, и хранится он как непосредственное значение. Само число можно получить, вызвав метод to_i, но в этом редко возникает необходимость.
По словам Джима Вайриха, символ – это «объект, у которого есть имя». Остин Зиглер предпочитает говорить об «объекте, который сам является именем». Как бы то ни было, существует взаимно однозначное соответствие между символами и именами. К чему можно применить имена? Например, к переменным, методам и произвольным константам.
Типичное применение символов – для представления имени переменной или метода. Например, чтобы добавить в класс атрибут, допускающий чтение и изменение, можно поступить следующим образом:
class SomeClass
attr_accessor :whatever
end
To же самое можно выразить иначе:
class SomeClass
def whatever
@whatever
end
def whatever=(val)
@whatever = val
end
end
Другими словами, символ :whatever говорит методу attr_accessor, что методам чтения и установки (а равно и самой переменной экземпляра) следует присвоить имена, определяемые указанным символом.
Но почему не воспользоваться просто строкой? Вообще-то можно. Многие, даже большинство системных методов, ожидающих символ в качестве параметра, соглашаются и на строку.
attr_reader :alpha
attr_reader "beta" # Так тоже можно.
На самом деле символ «похож» на строку в том смысле, что ему соответствует последовательность символов. Поэтому некоторые говорят, что «символ – это просто неизменяемая строка». Но класс Symbol не наследует классу String, а типичные операции над строками необязательно применимы к символам.
Также неправильно думать, что символы напрямую соответствуют идентификаторам. Из-за этого непонимания некоторые говорят о «таблице символов» (как если бы речь шла об ассемблированном объектном коде). В действительности это представление бессмысленно; хотя символы и хранятся в какой-то внутренней таблице (а как же иначе?), Ruby не дает к ней доступа, поэтому программистам все равно, существует она или нет.
Более того, символы даже не всегда выглядят как идентификаторы. Обычно это так, что бы под этим ни понимать, но символ может содержать и знаки препинания, если заключен в кавычки. Все показанные ниже символы допустимы:
sym1 = :"This is a symbol"
sym2 = :"This is, too!"
sym3 = :")(*&^%$" # И даже такой.
Можно даже использовать символы для определения переменных и методов экземпляра, но тогда для ссылки на них пришлось бы применять такие методы, как send и instance_variable_get. Вообще говоря, такая практика не рекомендуется.
В языке Pascal и в поздних версиях С есть понятие перечисляемого типа. В Ruby ничего подобного быть не может, ведь никакого контроля типов не производится. Но символы часто используются как мнемонические имена; стороны света можно было бы представить как :north, :south, :east и :west.
Быть может, немного понятнее хранить их в виде констант:
North, South, East, West = :north, :south, :east, :west
Если бы это были строки, а не символы, то определение их в виде констант могло бы сэкономить память, но каждый символ все равно существует в объектном пространстве в единственном экземпляре. (Символы, подобно объектам Fixnum, хранятся как непосредственные значения.)
Мы нередко пользуемся исключениями, чтобы уйти от кодов возврата. Но никто не мешает возвращать коды ошибки, если вам так хочется. К тому же в Ruby метод может возвращать более одного значения.
В таком механизме часто возникает необходимость. Когда-то символ NUL кода ASCII вообще не считался символом. В языке С есть понятие нулевого указателя (NULL), в Pascal есть указатель nil, в SQL NULL означает отсутствие какого бы то ни было значения. В Ruby, конечно, тоже есть свой nil.
Проблема в том, что такие метазначения часто путают с действительными значениями. В наши дни все считают NUL настоящим символом кода ASCII. И в Ruby нельзя сказать, что nil не является объектом; его можно хранить, над ним можно выполнять какие-то операции. Поэтому не вполне понятно, как интерпретировать ситуацию, когда hash [key] возвращает nil: то ли указанный ключ вообще не найден, то ли с ним ассоциировано значение nil.
Идея в том, что иногда символы могут выступать в роли подходящих метазначений. Представьте метод, который получает строку из сети (возможно, по протоколу HTTP или иным способом). При желании можно было бы вернуть нестроковое значение как индикатор исключительной ситуации.
str = get_string
case str
when String
# Нормальная обработка.
when :eof
# Конец файла, закрытие сокета и т.п.
when :error
# Ошибка сети или ввода/вывода.
when :timeout
# Ответ не получен вовремя.
end
Можно ли сказать, что это «лучше», чем механизм исключений? Необязательно. Но такую методику стоит иметь в виду, особенно когда приходится обрабатывать «граничные случаи», которые не считаются ошибками.
6.1.3. Символы, переменные и методыНаверное, чаще всего символы применяются для определения атрибутов класса:
class MyClass
attr_reader :alpha, :beta
attr_writer :gamma, :delta
attr_accessor :epsilon
# ...
end
Имейте в виду, что в этом фрагменте на самом деле исполняется некий код. Например, attr_accessor использует имя символа для определения имени переменной экземпляра, а также методов для ее чтения и изменения. Это не означает, что всегда имеется точное соответствие между символом и именем переменной экземпляра. Например, обращаясь к методу instance_variable_set, мы должны задать точное имя переменной, включая и знак @:
sym1 = :@foo
sym2 = :foo
instance_variable_set(sym1,"str") # Правильно.
instance_variable_set(sym2,"str") # Ошибка.
Короче говоря, символ, передаваемый методам из семейства attr, – всего лишь аргумент, а сами эти методы создают требуемые переменные и методы экземпляра, основываясь на значении символа. (В конец имени метода изменения добавляется знак равенства, а в начало имени переменной экземпляра – знак @.) Бывают также случаи, когда символ должен точно соответствовать идентификатору, на который ссылается.
В большинстве случаев (если не во всех!) методы, ожидающие на входе символ, принимают также строку. Обратное не всегда верно.
6.1.4. Преобразование строки в символ и обратноСтроки и символы можно преобразовывать друг в друга с помощью методов to_str и to_sym:
a = "foobar"
b = :foobar
a == b.to_str # true
b == a.to_sym # true
Для метапрограммирования иногда бывает полезен такой метод:
class Symbol
def +(other)
(self.to_s + other.to_s).to_sym
end
end
Он позволяет конкатенировать символы (или дописывать строку в конец символа). Ниже приведен пример использования; мы принимаем на входе символ и пытаемся определить, представляет ли он какой-нибудь метод доступа (то есть существует ли метод чтения или установки атрибута с таким именем):
class Object
def accessor?(sym)
return (self .respond_to?(sym) and self .respond_to?(sym+"="))
end
end
Упомяну также о более изощренном способе применения символов. Иногда при выполнении операции map нужно указать сложный блок. Однако во многих случаях мы просто вызываем некоторый метод для каждого элемента массива или набора:
list = words.map {|x| x.capitalize }
He кажется ли вам, что для такой простой задачи слишком много знаков препинания? Давайте вместо этого определим метод to_proc в классе Symbol. Он будет приводить любой символ к типу объекта proc. Но какой именно объект proc следует вернуть? Очевидно, соответствующий самому символу в контексте объекта; иными словами, такой, который пошлет сам символ в виде сообщения объекту.
def to_proc
proc {|obj, *args| obj.send(self, *args) }
end
Кстати, этот код заимствован из проекта Гэвина Синклера (Gavin Sinclair) «Расширения Ruby». Имея такой метод, мы можем следующим образом переписать первоначальный код:
list = words.map(&:capitalize)
Стоит потратить немного времени и разобраться, как это работает. Метод map обычно принимает только блок (никаких других параметров). Наличие знака & (амперсанд) позволяет передать объект proc вместо явно указанного блока. Поскольку мы применяем амперсанд к объекту, не являющемуся proc, то интерпретатор пытается вызвать метод to_proc этого объекта. Получающийся в результате объект proc подставляется вместо явного блока, чтобы метод map вызывал его для каждого элемента массива. А зачем передавать self в виде сообщения элементу массива? Затем, что объект proc является замыканием и, следовательно, помнит контекст, в котором был создан. А в момент создания self был ссылкой на символ, для которого вызывался метод to_proc.
6.2. Диапазоны
Понятие диапазона интуитивно понятно, но и у него имеются некоторые неочевидные особенности и способы применения. Одним из самых простых является числовой диапазон:
digits = 0..9
scalel = 0..10
scale2 = 0...10
Оператор .. включает конечную точку, а оператор ... не включает. (Если это вас неочевидно, просто запомните.) Таким образом, диапазоны digits и scale2 из предыдущего примера одинаковы.
Но диапазоны могут состоять не только из целых чисел – более того, не только из чисел. Началом и концом диапазона в Ruby может быть любой объект. Однако, как мы вскоре увидим, не все диапазоны осмыслены или полезны.
Основные операции над диапазоном – обход, преобразование в массив, а также выяснение, попадает ли некоторый объект в данный диапазон. Рассмотрим разнообразные варианты этих и других операций.
6.2.1. Открытые и замкнутые диапазоныДиапазон называется замкнутым, если включает конечную точку, и открытым – в противном случае:
r1 = 3..6 # Замкнутый.
r2 = 3...6 # Открытый.
a1 = r1.to_a # [3,4,5,6]
а2 = r2.to_a # [3,4,5]
Нельзя сконструировать диапазон, который не включал бы начальную точку. Можно считать это ограничением языка.
6.2.2. Нахождение границ диапазонаМетоды first и last возвращают соответственно левую и правую границу диапазона. У них есть синонимы begin и end (это еще и ключевые слова, но интерпретируются как вызов метода, если явно указан вызывающий объект).
r1 = 3..6
r2 = 3...6
r1a, r1b = r1. first, r1.last # 3,6
r1c, r1d = r1.begin, r1.end # 3,6
r2a, r2b = r1.begin, r1.end # 3,6
Метод exclude_end? сообщает, включена ли в диапазон конечная точка:
r1.exclude_end? # false
r2.exclude_end? # true
