def test_partial_1(**settings):
l = lambda xs: map(lambda _: partial(f2, y=2), xs)
L = _lambdify(l, namespace={'f2': f2}, **settings)
xs = range(0, 5)
out = L(xs)
expected = [0., 2., 4., 6., 8.]
assert (np.allclose(out, expected))
print('DONE.')
def test_reduce_function_list(**settings):
l = lambda xs: reduce(add, map(f1, xs))
L = _lambdify( l, namespace = {'f1': f1}, **settings )
nx = 5000000
xs = range(1, nx)
tb = time.time()
out = L(xs)
te = time.time()
print('[pyccel] elapsed time = ', te-tb)
def test_lambda_1(**settings):
l = lambda xs: map(lambda _: f1(_), xs)
L = _lambdify(l, namespace={'f1': f1}, **settings)
xs = range(0, 5)
out = L(xs)
expected = [0., 1, 4., 9., 16.]
assert (np.allclose(out, expected))
print('DONE.')
def test_annotate_map_list(**settings):
sin = np.sin
l = lambda xs: map(sin, xs)
L = _lambdify(l, **settings)
xs = np.linspace(0., np.pi, 100)
out = L(xs)
expected = list(l(xs))
assert (np.allclose(out, expected))
print('DONE.')
def test_map_product(**settings):
l = lambda xs,ys: xmap(f2, xs, ys)
L = _lambdify( l, namespace = {'f2': f2}, **settings )
nx = 5000
xs = range(0, nx)
ny = 5000
ys = range(0, ny)
tb = time.time()
out = L(xs, ys)
te = time.time()
print('[pyccel] elapsed time = ', te-tb)
def test_reduce_function_zip(**settings):
l = lambda xs,ys: reduce(add, map(f2, xs, ys))
L = _lambdify( l, namespace = {'f2': f2}, **settings )
nx = 5000
xs = range(0, nx)
ny = 5000
ys = range(0, ny)
tb = time.time()
out = L(xs, ys)
te = time.time()
print('[pyccel] elapsed time = ', te-tb)
def test_reduce_function_product(**settings):
settings['semantic_only'] = True
l = lambda xs, ys: reduce(add, xmap(f2, xs, ys))
type_L = _lambdify(l, namespace={'f2': f2}, **settings)
assert (isinstance(type_L, TypeVariable))
assert (isinstance(type_L.dtype, NativeReal))
assert (type_L.rank == 0)
assert (type_L.precision == 8)
assert (not type_L.is_stack_array)
print('DONE.')
def test_typing_partial_1(**settings):
settings['semantic_only'] = True
l = lambda xs: map(lambda _: partial(f2, y=2), xs)
type_L = _lambdify( l, namespace = {'f2': f2}, **settings )
assert( isinstance( type_L, TypeList ) )
parent = type_L.parent
assert( isinstance( parent.dtype, NativeReal ) )
assert( parent.rank == 0 )
assert( parent.precision == 8 )
assert( not parent.is_stack_array )
print('DONE.')
def test_map_sin_list(**settings):
settings['semantic_only'] = True
L = lambda xs: map(sin, xs)
type_L = _lambdify(L, **settings)
assert (isinstance(type_L, TypeList))
parent = type_L.parent
assert (isinstance(parent.dtype, NativeReal))
assert (parent.rank == 0)
assert (parent.precision == 8)
assert (not parent.is_stack_array)
print('DONE.')
def test_map_product(**settings):
settings['semantic_only'] = True
l = lambda xs, ys: xmap(f2, xs, ys)
type_L = _lambdify(l, namespace={'f2': f2}, **settings)
assert (isinstance(type_L, TypeList))
parent = type_L.parent
assert (isinstance(parent.dtype, NativeReal))
assert (parent.rank == 0)
assert (parent.precision == 8)
assert (not parent.is_stack_array)
print('DONE.')
def test_map_list(**settings):
l = lambda xs: map(f1, xs)
L = _lambdify( l, namespace = {'f1': f1}, **settings )
nx = 5000000
xs = range(0, nx)
tb = time.time()
out = L(xs)
te = time.time()
print('[pyccel] elapsed time = ', te-tb)
# tb = time.time()
# out = L(xs, out=out)
# te = time.time()
# print('[pyccel] elapsed time = ', te-tb)
tb = time.time()
expected = list(l(xs)) # add list because the result of l is an iterator
te = time.time()
print('[python] elapsed time = ', te-tb)
assert(np.allclose( out, expected ))
