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 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 each_each_ident(x): return each(each_ident, x)
def add11d(x): return each(add1, 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 each_add(x,y): return each(add, x, y)