def test_moa_compile_simple(benchmark): A = LazyArray(name='A', shape=('n', 'm')) B = LazyArray(name='B', shape=('k', 'l')) expression = A + B def _test(): expression.compile(backend='python', use_numba=True) benchmark(_test)
def test_moa_compile_complex(benchmark): A = LazyArray(name='A', shape=('n', 'm')) B = LazyArray(name='B', shape=('k', 'l')) C = LazyArray(name='C', shape=(10, 5)) expression = (A.inner('+', '*', B)).T[0] + C.reduce('+') def _test(): expression.compile(backend='python', use_numba=True) benchmark(_test)
def test_array_addition(): expression = LazyArray(name='A', shape=(2, 3)) + LazyArray(name='B', shape=(2, 3)) tree = ast.Node((ast.NodeSymbol.PLUS,), None, (), ( ast.Node((ast.NodeSymbol.ARRAY,), None, ('A',), ()), ast.Node((ast.NodeSymbol.ARRAY,), None, ('B',), ()))) symbol_table = { 'A': ast.SymbolNode(ast.NodeSymbol.ARRAY, (2, 3), None, None), 'B': ast.SymbolNode(ast.NodeSymbol.ARRAY, (2, 3), None, None) } context = ast.create_context(ast=tree, symbol_table=symbol_table) testing.assert_context_equal(context, expression.context)
def test_array_inner_product(left_symbol, right_symbol): expression = LazyArray(name='A', shape=(2, 3)).inner(left_symbol, right_symbol, LazyArray(name='B', shape=(3, 4))) expected_tree = ast.Node((ast.NodeSymbol.DOT, LazyArray.OPPERATION_MAP[left_symbol], LazyArray.OPPERATION_MAP[right_symbol]), None, (), ( ast.Node((ast.NodeSymbol.ARRAY,), None, ('A',), ()), ast.Node((ast.NodeSymbol.ARRAY,), None, ('B',), ()))) expected_symbol_table = { 'A': ast.SymbolNode(ast.NodeSymbol.ARRAY, (2, 3), None, None), 'B': ast.SymbolNode(ast.NodeSymbol.ARRAY, (3, 4), None, None), } expected_context = ast.create_context(ast=expected_tree, symbol_table=expected_symbol_table) testing.assert_context_equal(expected_context, expression.context)
def test_lenore_example_1_symbols(): _A = LazyArray(name='A', shape=('n', 'm')) _B = LazyArray(name='B', shape=('l', 3)) python_source = compiler((_A + _B).T['i'].context) local_dict = {} exec(python_source, globals(), local_dict) A = Array((2, 3), (1, 2, 3, 4, 5, 6)) B = Array((2, 3), (7, 8, 9, 10, 11, 12)) i = Array((), (0)) C = local_dict['f'](A=A, B=B, i=i) assert C.shape == (2,) assert C.value == [8, 14]
def test_lenore_example_1(): _A = LazyArray(name='A', shape=(2, 3)) _B = LazyArray(name='B', shape=(2, 3)) python_source = compiler((_A + _B).T[0].context) print(python_source) local_dict = {} exec(python_source, globals(), local_dict) A = Array((2, 3), (1, 2, 3, 4, 5, 6)) B = Array((2, 3), (7, 8, 9, 10, 11, 12)) C = local_dict['f'](A, B) assert C.shape == (2,) assert C.value == [8, 14]
def test_moa_numba_addition_index(benchmark): n = 1000 m = 1000 expression = (LazyArray(name='A', shape=('n', 'm')) + LazyArray(name='B', shape=('n', 'm')))[0] local_dict = {} exec(expression.compile(backend='python', use_numba=True), globals(), local_dict) A = numpy.random.random((n, m)) B = numpy.random.random((n, m)) benchmark(local_dict['f'], A, B)
def test_moa_numba_outer_product(benchmark): n = 100 m = 100 expression = LazyArray(name='A', shape=('n', 'm')).outer( '*', LazyArray(name='B', shape=('n', 'm'))) local_dict = {} exec(expression.compile(backend='python', use_numba=True), globals(), local_dict) A = numpy.random.random((n, m)) B = numpy.random.random((n, m)) benchmark(local_dict['f'], A, B)
def test_array_complex_slice(): _A = LazyArray(name='A', shape=(3, 4, 5)) _B = LazyArray(name='B', shape=(3, 4, 5)) expression = _A[0, 0:2:-1] + _B[:, 1:3, :][1] local_dict = {} exec(expression.compile(), globals(), local_dict) A = Array(shape=(3, 4, 5), value=tuple(range(1, 60))) B = Array(shape=(3, 4, 5), value=tuple(range(61, 121))) B = local_dict['f'](A=A) assert B.shape == (3, 5) assert B.value == [3, 7, 11]
def test_moa_numba_double_addition(benchmark): n = 1000 m = 1000 expression = LazyArray(name='A', shape=('n', 'm')) + LazyArray( name='B', shape=('n', 'm')) + LazyArray(name='C', shape=('n', 'm')) local_dict = {} exec(expression.compile(backend='python', use_numba=True), globals(), local_dict) A = numpy.random.random((n, m)) B = numpy.random.random((n, m)) C = numpy.random.random((n, m)) benchmark(local_dict['f'], A=A, B=B, C=C)
def test_array_single_array(): expression = LazyArray(name='A', shape=(2, 3)) node = ast.Node((ast.NodeSymbol.ARRAY,), None, ('A',), ()) symbol_table = {'A': ast.SymbolNode(ast.NodeSymbol.ARRAY, (2, 3), None, None)} context = ast.create_context(ast=node, symbol_table=symbol_table) testing.assert_context_equal(context, expression.context)
def test_array_transpose_default(): expression = LazyArray(name='A', shape=(2, 3)).transpose() node = ast.Node((ast.NodeSymbol.TRANSPOSE,), None, (), ( ast.Node((ast.NodeSymbol.ARRAY,), None, ('A',), ()),)) symbol_table = {'A': ast.SymbolNode(ast.NodeSymbol.ARRAY, (2, 3), None, None)} context = ast.create_context(ast=node, symbol_table=symbol_table) testing.assert_context_equal(context, expression.context)
def test_array_reduce(symbol): expression = LazyArray(name='A', shape=(2, 3)).reduce(symbol) expected_tree = ast.Node((ast.NodeSymbol.REDUCE, LazyArray.OPPERATION_MAP[symbol]), None, (), ( ast.Node((ast.NodeSymbol.ARRAY,), None, ('A',), ()),)) expected_symbol_table = { 'A': ast.SymbolNode(ast.NodeSymbol.ARRAY, (2, 3), None, None), } expected_context = ast.create_context(ast=expected_tree, symbol_table=expected_symbol_table) testing.assert_context_equal(expected_context, expression.context)
def test_array_frontend_transpose_vector_outer_scalar_addition(): _A = LazyArray(name='A', shape=(3, 2)) _B = LazyArray(name='B', shape=(4, )) _C = LazyArray(name='C', shape=(3, 4)) expression = (((_A.T)[0] - 1).outer('*', _B) + _C + 'n').transpose([1, 0]) local_dict = {} exec(expression.compile(), globals(), local_dict) A = Array(shape=(3, 2), value=(1, 2, 3, 4, 5, 6)) B = Array(shape=(4, ), value=(13, 14, 15, 16)) C = Array(shape=(3, 4), value=(17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28)) n = Array(shape=(), value=(4, )) D = local_dict['f'](A=A, B=B, C=C, n=n) assert D.shape == (4, 3) assert D.value == [21, 51, 81, 22, 54, 86, 23, 57, 91, 24, 60, 96]
def test_array_transpose_with_vector(): expression = LazyArray(name='A', shape=(2, 3)).transpose([1, 0]) node = ast.Node((ast.NodeSymbol.TRANSPOSEV,), None, (), ( ast.Node((ast.NodeSymbol.ARRAY,), None, ('_a1',), ()), ast.Node((ast.NodeSymbol.ARRAY,), None, ('A',), ()),)) symbol_table = { 'A': ast.SymbolNode(ast.NodeSymbol.ARRAY, (2, 3), None, None), '_a1': ast.SymbolNode(ast.NodeSymbol.ARRAY, (2,), None, (1, 0)), } context = ast.create_context(ast=node, symbol_table=symbol_table) testing.assert_context_equal(context, expression.context)
def test_array_index_tuple(): expression = LazyArray(name='A', shape=(2, 3))[1, 0] node = ast.Node((ast.NodeSymbol.PSI,), None, (), ( ast.Node((ast.NodeSymbol.ARRAY,), None, ('_a1',), ()), ast.Node((ast.NodeSymbol.ARRAY,), None, ('A',), ()),)) symbol_table = { 'A': ast.SymbolNode(ast.NodeSymbol.ARRAY, (2, 3), None, None), '_a1': ast.SymbolNode(ast.NodeSymbol.ARRAY, (2,), None, (1, 0)), } context = ast.create_context(ast=node, symbol_table=symbol_table) testing.assert_context_equal(context, expression.context)
def test_moa_numba_reduce(benchmark): n = 1000 m = 1000 expression = LazyArray(name='A', shape=('n', 'm')).reduce('+') local_dict = {} exec(expression.compile(backend='python', use_numba=True), globals(), local_dict) A = numpy.random.random((n, m)) benchmark(local_dict['f'], A)
def test_array_index_stride_reverse(): expression = LazyArray(name='A', shape=(2, 3))[1:2:-1] tree = ast.Node(ast.NodeSymbol.PSI, None, (), ( ast.Node(ast.NodeSymbol.ARRAY, None, ('_a2',), ()), ast.Node(ast.NodeSymbol.ARRAY, None, ('A',), ()))) symbol_table = { 'A': SymbolNode(ast.NodeSymbol.ARRAY, (2, 3), None, None), 'n': SymbolNode(ast.NodeSymbol.ARRAY, (), None, None), '_a2': SymbolNode(ast.NodeSymbol.ARRAY, (1,), None, (Node(ast.NodeSymbol.ARRAY, (), 'n'),)), } context = ast.create_context(ast=tree, symbol_table=symbol_table) testing.assert_context_equal(context, expression.context)
def test_array_reduction(): _A = LazyArray(name='A', shape=(3, 2)) expression = _A.reduce('+') local_dict = {} print(expression.compile()) exec(expression.compile(), globals(), local_dict) A = Array(shape=(3, 2), value=tuple(range(1, 7))) B = local_dict['f'](A=A) assert B.shape == (2, ) assert B.value == [9, 12]
def test_array_single_array_symbolic(): expression = LazyArray(name='A', shape=('n', 3)) node = ast.Node((ast.NodeSymbol.ARRAY,), None, ('A',), ()) symbol_table = { 'A': ast.SymbolNode(ast.NodeSymbol.ARRAY, (ast.Node((ast.NodeSymbol.ARRAY,), (), ('n',), ()), 3), None, None), 'n': ast.SymbolNode(ast.NodeSymbol.ARRAY, (), None, None), } context = ast.create_context(ast=node, symbol_table=symbol_table) testing.assert_context_equal(context, expression.context) @pytest.mark.parametrize("function, side, operation", [ (lambda: LazyArray(name='A', shape=(2, 3)) + 1, 'right', ast.NodeSymbol.PLUS), (lambda: 1 + LazyArray(name='A', shape=(2, 3)), 'left', ast.NodeSymbol.PLUS), (lambda: LazyArray(name='A', shape=(2, 3)) - 1, 'right', ast.NodeSymbol.MINUS), (lambda: 1 - LazyArray(name='A', shape=(2, 3)), 'left', ast.NodeSymbol.MINUS), (lambda: LazyArray(name='A', shape=(2, 3)) * 1, 'right', ast.NodeSymbol.TIMES), (lambda: 1 * LazyArray(name='A', shape=(2, 3)), 'left', ast.NodeSymbol.TIMES), (lambda: LazyArray(name='A', shape=(2, 3)) / 1, 'right', ast.NodeSymbol.DIVIDE), (lambda: 1 / LazyArray(name='A', shape=(2, 3)), 'left', ast.NodeSymbol.DIVIDE), ]) def test_array_single_array_binary_operation_cast(function, side, operation): expression = function() if side == 'right': tree = ast.Node((operation,), None, (), ( ast.Node((ast.NodeSymbol.ARRAY,), None, ('A',), ()), ast.Node((ast.NodeSymbol.ARRAY,), None, ('_a1',), ()))) else: