def test_reduce_psi_psi(): symbol_table = { '_i0': ast.SymbolNode(ast.NodeSymbol.INDEX, (), None, (0, 3, 1)), '_a1': ast.SymbolNode(ast.NodeSymbol.ARRAY, (1, ), None, (ast.Node( (ast.NodeSymbol.INDEX, ), (), ('_i0', ), ()), )), '_a2': ast.SymbolNode(ast.NodeSymbol.ARRAY, (3, ), None, (1, 2, 3)), '_a3': ast.SymbolNode(ast.NodeSymbol.ARRAY, (1, 2, 3, 4), None, None), } tree = ast.Node((ast.NodeSymbol.PSI, ), (0, ), (), (ast.Node((ast.NodeSymbol.ARRAY, ), (1, ), ('_a1', ), ()), ast.Node((ast.NodeSymbol.PSI, ), (4, ), (), (ast.Node((ast.NodeSymbol.ARRAY, ), (3, ), ('_a2', ), ()), ast.Node((ast.NodeSymbol.ARRAY, ), (1, 2, 3, 4), ('_a3', ), ()))))) expected_symbol_table = { **symbol_table, '_a4': ast.SymbolNode( ast.NodeSymbol.ARRAY, (4, ), None, (1, 2, 3, ast.Node((ast.NodeSymbol.INDEX, ), (), ('_i0', ), ()))) } expected_tree = ast.Node((ast.NodeSymbol.PSI, ), (0, ), (), (ast.Node( (ast.NodeSymbol.ARRAY, ), (4, ), ('_a4', ), ()), ast.Node((ast.NodeSymbol.ARRAY, ), (1, 2, 3, 4), ('_a3', ), ()))) testing.assert_transformation(tree, symbol_table, expected_tree, expected_symbol_table, dnf._reduce_psi_psi)
def test_dimension_operation(): symbol_table = {'_a1': ast.SymbolNode(ast.NodeSymbol.ARRAY, (3, 4), None, None)} node = ast.Node((ast.NodeSymbol.TRANSPOSE,), (4, 3), (), ( ast.Node((ast.NodeSymbol.ARRAY,), (3, 4), ('_a1',), ()),)) context = ast.create_context(ast=node, symbol_table=symbol_table) assert shape.dimension(context) == 2
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_ast_select_node_shape(selection, result_shape): node = ast.Node((ast.NodeSymbol.PLUS, ), (1, 2, 3), (), ( ast.Node((ast.NodeSymbol.ARRAY, ), (4, 5, 6), (0, ), ()), ast.Node((ast.NodeSymbol.TRANSPOSE, ), (7, 8, 9), (1, ), (ast.Node( (ast.NodeSymbol.ARRAY, ), (10, 11, 12), (2, ), ()), )), )) context = ast.create_context(ast=node) assert ast.select_node_shape(context, selection) == result_shape
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)
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_ast_select_node(selection, result_node): node = ast.Node((ast.NodeSymbol.PLUS, ), None, (), ( ast.Node((ast.NodeSymbol.ARRAY, ), None, (0, ), ()), ast.Node((ast.NodeSymbol.TRANSPOSE, ), None, (1, ), (ast.Node( (ast.NodeSymbol.ARRAY, ), None, (2, ), ()), )), )) context = ast.create_context(ast=node) result_context = ast.create_context(ast=result_node) testing.assert_context_equal(ast.select_node(context, selection), result_context)
def test_not_matches_rule_nested(): tree = ast.Node((ast.NodeSymbol.TRANSPOSE, ), None, (), (ast.Node( (ast.NodeSymbol.ARRAY, ), (2, 3), ('A', ), ()), )) symbol_table = { 'A': ast.SymbolNode(ast.NodeSymbol.ARRAY, (2, 3), None, (1, 2, 3, 4, 5, 6)) } context = ast.create_context(ast=tree, symbol_table=symbol_table) rule = ((ast.NodeSymbol.TRANSPOSE, ), (((ast.NodeSymbol.TRANSPOSE, ), ), )) assert not dnf.matches_rule(rule, context)
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_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_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_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_reduce_psi_transposev(): symbol_table = { '_a0': ast.SymbolNode(ast.NodeSymbol.ARRAY, (4, ), None, (3, 2, 1, 1)), '_a1': ast.SymbolNode(ast.NodeSymbol.ARRAY, (4, ), None, (4, 2, 3, 1)), '_a2': ast.SymbolNode(ast.NodeSymbol.ARRAY, (2, 3, 5, 7), None, None), } tree = ast.Node((ast.NodeSymbol.PSI, ), (), (), (ast.Node((ast.NodeSymbol.ARRAY, ), (4, ), ('_a0', ), ()), ast.Node((ast.NodeSymbol.TRANSPOSEV, ), (7, 3, 5, 2), (), (ast.Node((ast.NodeSymbol.ARRAY, ), (4, ), ('_a1', ), ()), ast.Node((ast.NodeSymbol.ARRAY, ), (2, 3, 5, 7), ('_a2', ), ()))))) expected_symbol_table = { **symbol_table, '_a3': ast.SymbolNode(ast.NodeSymbol.ARRAY, (4, ), None, (1, 2, 1, 3)) } expected_tree = ast.Node((ast.NodeSymbol.PSI, ), (), (), (ast.Node( (ast.NodeSymbol.ARRAY, ), (4, ), ('_a3', ), ()), ast.Node((ast.NodeSymbol.ARRAY, ), (2, 3, 5, 7), ('_a2', ), ()))) testing.assert_transformation(tree, symbol_table, expected_tree, expected_symbol_table, dnf._reduce_psi_transposev)
def test_shape_unit_reduce_plus_minus_multiply_divide_no_symbol(operation): symbol_table = { 'A': ast.SymbolNode(ast.NodeSymbol.ARRAY, (1, 2, 3), None, None), } tree = ast.Node((ast.NodeSymbol.REDUCE, operation), None, (), ( ast.Node((ast.NodeSymbol.ARRAY,), None, ('A',), ()),)) expected_tree = ast.Node((ast.NodeSymbol.REDUCE, operation), (2, 3), (), ( ast.Node((ast.NodeSymbol.ARRAY,), (1, 2, 3), ('A',), ()),)) context = ast.create_context(ast=tree, symbol_table=symbol_table) expected_context = ast.create_context(ast=expected_tree, symbol_table=symbol_table) context_copy = copy.deepcopy(context) new_context = shape.calculate_shapes(context) testing.assert_context_equal(context, context_copy) testing.assert_context_equal(expected_context, new_context)
def test_matches_rule_simple(): tree = ast.Node((ast.NodeSymbol.ARRAY, ), (2, 3), ('A', ), ()) symbol_table = { 'A': ast.SymbolNode(ast.NodeSymbol.ARRAY, (2, 3), None, (1, 2, 3, 4, 5, 6)) } context = ast.create_context(ast=tree, symbol_table=symbol_table) rule = ((ast.NodeSymbol.ARRAY, ), ) assert dnf.matches_rule(rule, context)
def test_add_indexing_node(): tree = ast.Node((ast.NodeSymbol.ARRAY, ), (2, 3), ('A', ), ()) symbol_table = { 'A': ast.SymbolNode(ast.NodeSymbol.ARRAY, (2, 3), None, (1, 2, 3, 4, 5, 6)) } expected_tree = ast.Node((ast.NodeSymbol.PSI, ), (2, 3), (), (ast.Node( (ast.NodeSymbol.ARRAY, ), (2, ), ('_a3', ), ()), ast.Node((ast.NodeSymbol.ARRAY, ), (2, 3), ('A', ), ()))) expected_symbol_table = { 'A': ast.SymbolNode(ast.NodeSymbol.ARRAY, (2, 3), None, (1, 2, 3, 4, 5, 6)), '_i1': ast.SymbolNode(ast.NodeSymbol.INDEX, (), None, (0, 2, 1)), '_i2': ast.SymbolNode(ast.NodeSymbol.INDEX, (), None, (0, 3, 1)), '_a3': ast.SymbolNode(ast.NodeSymbol.ARRAY, (2, ), None, (ast.Node( (ast.NodeSymbol.ARRAY, ), (), ('_i1', ), ()), ast.Node((ast.NodeSymbol.ARRAY, ), (), ('_i2', ), ()))), } testing.assert_transformation(tree, symbol_table, expected_tree, expected_symbol_table, dnf.add_indexing_node)
def test_shape_unit_plus_symbolic(left_shape, right_shape): symbol_table = { 'A': ast.SymbolNode(ast.NodeSymbol.ARRAY, left_shape, None, None), 'B': ast.SymbolNode(ast.NodeSymbol.ARRAY, right_shape, None, None), 'n': ast.SymbolNode(ast.NodeSymbol.ARRAY, (), None, None), } tree = ast.Node((ast.NodeSymbol.PLUS,), None, (), ( ast.Node((ast.NodeSymbol.ARRAY,), None, ('A',), ()), ast.Node((ast.NodeSymbol.ARRAY,), None, ('B',), ()),)) expected_tree = ast.Node((ast.NodeSymbol.PLUS,), (3, 4, 5), (), ( ast.Node((ast.NodeSymbol.ARRAY,), left_shape, ('A',), ()), ast.Node((ast.NodeSymbol.ARRAY,), right_shape, ('B',), ()),)) context = ast.create_context(ast=tree, symbol_table=symbol_table) expected_context = ast.create_context(ast=expected_tree, symbol_table={ **symbol_table, '_a3': ast.SymbolNode(ast.NodeSymbol.ARRAY, (), None, (5,)), }) context_copy = copy.deepcopy(context) new_context = shape.calculate_shapes(context) exclude_condition_node = ast.select_node(new_context, (1,)) print(new_context.symbol_table) testing.assert_context_equal(context, context_copy) testing.assert_context_equal(expected_context, exclude_condition_node)
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: tree = ast.Node((operation,), 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, (), None, (1,)) } context = ast.create_context(ast=tree, symbol_table=symbol_table) testing.assert_context_equal(context, expression.context)
def test_graphviz_visualization(): symbol_table = { '_a1': ast.SymbolNode(ast.NodeSymbol.ARRAY, (1, ), None, (0, )), 'A': ast.SymbolNode(ast.NodeSymbol.ARRAY, (3, 4), None, None), 'B': ast.SymbolNode(ast.NodeSymbol.ARRAY, (3, 4), None, None) } tree = ast.Node( (ast.NodeSymbol.PSI, ), None, (), (ast.Node((ast.NodeSymbol.ARRAY, ), None, ('_a1', ), ()), ast.Node((ast.NodeSymbol.TRANSPOSE, ), None, (), (ast.Node( (ast.NodeSymbol.PLUS, ), None, (), ( ast.Node((ast.NodeSymbol.ARRAY, ), None, ('A', ), ()), ast.Node((ast.NodeSymbol.ARRAY, ), None, ('B', ), ()), )), )))) context = ast.create_context(ast=tree, symbol_table=symbol_table) visualize_ast(context)
def test_shape_scalar_plus_minus_multiply_divide_no_symbol(operation): symbol_table = { 'A': ast.SymbolNode(ast.NodeSymbol.ARRAY, (3, 4, 5), None, None), 'B': ast.SymbolNode(ast.NodeSymbol.ARRAY, (), None, (0,)) } tree = ast.Node((operation,), None, (), ( ast.Node((ast.NodeSymbol.ARRAY,), None, ('A',), ()), ast.Node((ast.NodeSymbol.ARRAY,), None, ('B',), ()),)) expected_tree = ast.Node((operation,), (3, 4, 5), (), ( ast.Node((ast.NodeSymbol.ARRAY,), (3, 4, 5), ('A',), ()), ast.Node((ast.NodeSymbol.ARRAY,), (), ('B',), ()),)) context = ast.create_context(ast=tree, symbol_table=symbol_table) expected_context = ast.create_context(ast=expected_tree, symbol_table=symbol_table) context_copy = copy.deepcopy(context) new_context = shape.calculate_shapes(context) testing.assert_context_equal(context, context_copy) testing.assert_context_equal(expected_context, new_context)
def test_metric_flops(): tree = ast.Node((ast.NodeSymbol.PSI,), None, (), ( ast.Node((ast.NodeSymbol.ARRAY,), None, ('_a1',), ()), ast.Node((ast.NodeSymbol.TRANSPOSE,), None, (), ( ast.Node((ast.NodeSymbol.PLUS,), None, (), ( ast.Node((ast.NodeSymbol.ARRAY,), None, ('A',), ()), ast.Node((ast.NodeSymbol.ARRAY,), None, ('B',), ()))),)))) symbol_table = { '_a1': ast.SymbolNode(ast.NodeSymbol.ARRAY, (1,), None, (0,)), 'A': ast.SymbolNode(ast.NodeSymbol.ARRAY, (10, 100), None, None), 'B': ast.SymbolNode(ast.NodeSymbol.ARRAY, (10, 100), None, None) } context = ast.create_context(ast=tree, symbol_table=symbol_table) context = shape.calculate_shapes(context) assert analysis.metric_flops(context) == 1000 context = dnf.reduce_to_dnf(context) assert analysis.metric_flops(context) == 10
def test_preorder_replacement(): counter = itertools.count() def replacement_function(context): if context.ast.shape is None: return ast.replace_node_shape(context, (next(counter), ), ()) return None tree = ast.Node((ast.NodeSymbol.CAT, ), None, (), ( ast.Node((ast.NodeSymbol.TRANSPOSE, ), None, (), (ast.Node( (ast.NodeSymbol.ARRAY, ), None, (), ()), )), ast.Node((ast.NodeSymbol.PLUS, ), None, (), ( ast.Node((ast.NodeSymbol.SHAPE, ), None, (), (ast.Node( (ast.NodeSymbol.ARRAY, ), None, (), ()), )), ast.Node((ast.NodeSymbol.RAV, ), None, (), (ast.Node( (ast.NodeSymbol.ARRAY, ), None, (), ()), )), )), )) context = ast.create_context(ast=tree) context_copy = copy.deepcopy(context) expected_tree = ast.Node((ast.NodeSymbol.CAT, ), (0, ), (), ( ast.Node((ast.NodeSymbol.TRANSPOSE, ), (1, ), (), (ast.Node( (ast.NodeSymbol.ARRAY, ), (2, ), (), ()), )), ast.Node((ast.NodeSymbol.PLUS, ), (3, ), (), ( ast.Node((ast.NodeSymbol.SHAPE, ), (4, ), (), (ast.Node( (ast.NodeSymbol.ARRAY, ), (5, ), (), ()), )), ast.Node((ast.NodeSymbol.RAV, ), (6, ), (), (ast.Node( (ast.NodeSymbol.ARRAY, ), (7, ), (), ()), )), )), )) expected_context = ast.create_context(ast=expected_tree) new_context = ast.node_traversal(context, replacement_function, traversal='preorder') testing.assert_context_equal(context, context_copy) testing.assert_context_equal(new_context, expected_context)
import itertools import copy import pytest from moa import ast from moa import visualize from moa import testing # is node type @pytest.mark.parametrize('node, result', [ (ast.Node((ast.NodeSymbol.ARRAY, ), None, (), ()), (True, False, False, False)), (ast.Node((ast.NodeSymbol.TRANSPOSE, ), None, (), (None, )), (False, True, True, False)), (ast.Node((ast.NodeSymbol.CAT, ), None, (), (None, None)), (False, True, False, True)), (ast.Node((ast.NodeSymbol.DOT, ast.NodeSymbol.TIMES), None, (), (None, None)), (False, True, False, True)), ]) def test_ast_nodes(node, result): context = ast.create_context(ast=node) assert result == (ast.is_array(context), ast.is_operation(context), ast.is_unary_operation(context), ast.is_binary_operation(context)) # node selection and replacement @pytest.mark.parametrize('node, result', [ (ast.Node((ast.NodeSymbol.ARRAY, ), None, (), ()), 0),
def test_join_symbol_tables_simple(): left_tree = ast.Node((ast.NodeSymbol.PLUS, ), None, (), ( ast.Node((ast.NodeSymbol.ARRAY, ), None, ('A', ), ()), ast.Node((ast.NodeSymbol.ARRAY, ), None, ('B', ), ()), )) left_symbol_table = { 'A': ast.SymbolNode(ast.NodeSymbol.ARRAY, (3, 4), None, None), '_a1': ast.SymbolNode(ast.NodeSymbol.ARRAY, (1, ast.Node((ast.NodeSymbol.ARRAY, ), (), ('m', ), ())), None, None), 'B': ast.SymbolNode(ast.NodeSymbol.ARRAY, (2, 4), None, None) } right_tree = ast.Node((ast.NodeSymbol.MINUS, ), None, (), ( ast.Node((ast.NodeSymbol.ARRAY, ), None, ('A', ), ()), ast.Node((ast.NodeSymbol.ARRAY, ), None, ('_a3', ), ()), )) right_symbol_table = { 'A': ast.SymbolNode(ast.NodeSymbol.ARRAY, (3, 4), None, None), '_a3': ast.SymbolNode(ast.NodeSymbol.ARRAY, (ast.Node( (ast.NodeSymbol.ARRAY, ), (), ('_a10', ), ()), ast.Node((ast.NodeSymbol.ARRAY, ), (), ('m', ), ())), None, None), '_a10': ast.SymbolNode(ast.NodeSymbol.ARRAY, (), None, (1, )), 'm': ast.SymbolNode(ast.NodeSymbol.ARRAY, (), None, None), 'B': ast.SymbolNode(ast.NodeSymbol.ARRAY, (2, 4), None, None), 'n': ast.SymbolNode(ast.NodeSymbol.ARRAY, (), None, None), } left_context = ast.create_context(ast=left_tree, symbol_table=left_symbol_table) right_context = ast.create_context(ast=right_tree, symbol_table=right_symbol_table) new_symbol_table, new_left_context, new_right_context = ast.join_symbol_tables( left_context, right_context) assert new_symbol_table == { 'A': ast.SymbolNode(ast.NodeSymbol.ARRAY, (3, 4), None, None), 'B': ast.SymbolNode(ast.NodeSymbol.ARRAY, (2, 4), None, None), 'm': ast.SymbolNode(ast.NodeSymbol.ARRAY, (), None, None), '_a0': ast.SymbolNode(ast.NodeSymbol.ARRAY, (), None, (1, )), '_a1': ast.SymbolNode(ast.NodeSymbol.ARRAY, (ast.Node( (ast.NodeSymbol.ARRAY, ), (), ('_a0', ), ()), ast.Node((ast.NodeSymbol.ARRAY, ), (), ('m', ), ())), None, None), } expected_left_context = ast.create_context( ast=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, (3, 4), None, None), 'B': ast.SymbolNode(ast.NodeSymbol.ARRAY, (2, 4), None, None) }) expected_right_context = ast.create_context( ast=ast.Node( (ast.NodeSymbol.MINUS, ), None, (), ( ast.Node((ast.NodeSymbol.ARRAY, ), None, ('A', ), ()), ast.Node((ast.NodeSymbol.ARRAY, ), None, ('_a1', ), ()), )), symbol_table={ 'A': ast.SymbolNode(ast.NodeSymbol.ARRAY, (3, 4), None, None), 'm': ast.SymbolNode(ast.NodeSymbol.ARRAY, (), None, None), '_a0': ast.SymbolNode(ast.NodeSymbol.ARRAY, (), None, (1, )), '_a1': ast.SymbolNode(ast.NodeSymbol.ARRAY, (ast.Node( (ast.NodeSymbol.ARRAY, ), (), ('_a0', ), ()), ast.Node((ast.NodeSymbol.ARRAY, ), (), ('m', ), ())), None, None) }) testing.assert_context_equal(new_left_context, expected_left_context) testing.assert_context_equal(new_right_context, expected_right_context)
def test_dimension_array(): symbol_table = {'_a1': ast.SymbolNode(ast.NodeSymbol.ARRAY, (), None, (3,))} node = ast.Node((ast.NodeSymbol.ARRAY,), None, ('_a1',), ()) context = ast.create_context(ast=node, symbol_table=symbol_table) assert shape.dimension(context) == 0
def test_is_not_vector_2d(): # 2D array symbol_table = {'A': ast.SymbolNode(ast.NodeSymbol.ARRAY, (5, 1), None, (1, 2, 3, 4, 5))} node = ast.Node((ast.NodeSymbol.ARRAY,), None, ('A',), ()) context = ast.create_context(ast=node, symbol_table=symbol_table) assert not shape.is_vector(context)
def test_is_not_vector_1d(): # scalar symbol_table = {'asdf': ast.SymbolNode(ast.NodeSymbol.ARRAY, (), None, (3,))} node = ast.Node((ast.NodeSymbol.ARRAY,), None, ('asdf',), ()) context = ast.create_context(ast=node, symbol_table=symbol_table) assert not shape.is_vector(context)
def test_is_vector(): symbol_table = {'_a1': ast.SymbolNode(ast.NodeSymbol.ARRAY, (5,), None, (1, 2, 3, 4, 5))} node = ast.Node((ast.NodeSymbol.ARRAY,), None, ('_a1',), ()) context = ast.create_context(ast=node, symbol_table=symbol_table) assert shape.is_vector(context)
def test_is_not_scalar_2d(): # 2D array symbol_table = {'_a1': ast.SymbolNode(ast.NodeSymbol.ARRAY, (2, 3), None, (1, 2, 3, 4, 5, 6))} node = ast.Node((ast.NodeSymbol.ARRAY,), None, ('_a1',), ()) context = ast.create_context(ast=node, symbol_table=symbol_table) assert not shape.is_scalar(context)