Программирование на языке Ruby
вернуться

Фултон Хэл
Шрифт:

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)

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