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_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_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_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_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_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_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_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_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:
