def avg_along_axis_0(Xs):
assign = np.array([0,0,1,0,1,0,1,0,1,1])
Ys = Xs[assign == 1]
def zero(x):
return 0.0
zeros = parakeet.each(zero, Xs[0])
s = reduce(parakeet.add, Ys, init=zeros)
def d(s):
return s / Ys.shape[0]
return parakeet.each(d, s)
def avg_along_axis_0(Xs):
assign = np.array([0, 0, 1, 0, 1, 0, 1, 0, 1, 1])
Ys = Xs[assign == 1]
def zero(x):
return 0.0
zeros = parakeet.each(zero, Xs[0])
s = reduce(parakeet.add, Ys, init=zeros)
def d(s):
return s / Ys.shape[0]
return parakeet.each(d, s)
def test_black_scholes(): x1 = (False, 10.0, 10.0, 2.0, 2.0, 2.0) x2 = (True, 10.0, 10.0, 2.0, 2.0, 2.0) xs = np.array([x1, x2]) par_rslt = parakeet.each(black_scholes, xs) py_rslt = black_scholes(xs) assert eq(par_rslt, py_rslt)
def test_sqr_dist():
z = a[0]
def run_sqr_dist(c):
return sqr_dist(z, c)
par_rslt = parakeet.each(run_sqr_dist, a)
py_rslt = np.array(map(run_sqr_dist, a))
assert testing_helpers.eq(par_rslt, py_rslt), \
"Expected %s but got %s" % (py_rslt, par_rslt)
def test_sqr_dist():
z = a[0]
def run_sqr_dist(c):
return sqr_dist(z, c)
par_rslt = parakeet.each(run_sqr_dist, a)
py_rslt = np.array(map(run_sqr_dist, a))
assert testing_helpers.eq(par_rslt, py_rslt), \
"Expected %s but got %s" % (py_rslt, par_rslt)
def parallel_harris(I):
dx = diff_x(I)
dy = diff_y(I)
def scalar_computation(dx,dy):
A = dx * dx
B = dy * dy
C = dx * dy
tr = A + B
det = A * B - C * C
k = 0.05
return det - k * tr * tr
return parakeet.each(scalar_computation, dx, dy)
def parakeet_dists(W, E = None):
C = init(W,E)
m,n = C.shape
assert m == n
vertices = np.arange(n)
def min_row(c_row, a_row):
return map(min, c_row, a_row)
for k in vertices:
from_k = C[:, k]
to_k = C[k, :]
A = parakeet.allpairs(parakeet.add, from_k, to_k)
C = parakeet.each(min_row, C, A)
return C
def test_rule30():
output = init.copy()
cur = init
zero_array = np.array([0])
indices = np.arange(1,size+1)
for _ in range(size/2):
extended = np.concatenate((zero_array, cur, zero_array))
def run_rule30(i):
return rule30(extended, i)
parakeet_iter = parakeet.each(run_rule30, indices)
cur = np.array(map(run_rule30, indices))
assert eq(parakeet_iter, cur), \
"Parakeet result (%s) didn't match Python result(%s)" % \
(parakeet_iter, cur)
output = np.vstack((output,cur))
if plot:
pylab.matshow(output,cmap = pylab.cm.gray)
pylab.show()
def g(x):
def h(xi):
return xi + 1.0
return each(h,x)
def reduce_2d(Ys):
def zero(x):
return 0.0
zeros = each(zero, Ys[0])
return reduce(add, Ys, init = zeros)
def fprop_linear(x, W, b):
def dot_add(w_row, b_elt):
return sum(w_row * x) + b_elt
return par.each(dot_add, W, b)
def nested_each(x):
def dummy(x):
def dummy2():
return x
return dummy2()
return each(dummy, x)
def nested_add1(X):
return each(g, X)
def test_add1():
result = each(add11d, int_vec)
expected = int_vec + 1
assert testing_helpers.eq(result, expected), \
"Expected %s, got %s" % (expected, result)
def g(x):
def h(xi):
return xi + 1.0
return each(h, x)
def each_conditional_div(x,y): return each(conditional_div, x, y)
def test_add1_external_map():
parakeet_result = each(add1_scalar, ints_1d)
python_result = ints_1d + 1
assert eq(parakeet_result, python_result), \
"Python %s != Parakeet %s" % (python_result, parakeet_result)
def test_add1():
result = each(add11d, int_vec)
expected = int_vec + 1
assert testing_helpers.eq(result, expected), \
"Expected %s, got %s" % (expected, result)
def each_each_ident(x): return each(each_ident, x)
def fprop_linear(x, W, b):
def dot_add(w_row, b_elt):
return sum(w_row * x) + b_elt
return par.each(dot_add, W, b)
def add11d(x):
return each(add1, x)
def nested_add1(X): return each(g, X)
def second_of_columns(X): return each(second_elt, X, axis=1)
def each_sum(X): return parakeet.each(parakeet.sum, X)
def second_of_rows(X): return each(second_elt, X, axis=0)
def add1_map(x_vec): return each(add1_scalar, x_vec)
def each_sum(X):
return parakeet.each(np.sum, X)
def add11d(x): return each(add1, x)
def each_add(x,y): return each(add, x, y)
