def create_expr(symbol_table):
'''Utility routine that creates and returns an expression containing a
number of array references containing range nodes. The expression
looks like the following (using Fortran array notation):
x(2:n:2)*z(1,2:n:2)+a(1)
:param symbol_table: the symbol table to which we add the array \
symbols.
:type symbol_table: :py:class:`psyclone.psyir.symbol.SymbolTable`
:returns: an expression containing 3 array references, 2 of which \
contain ranges.
:rtype: :py:class:`psyclone.psyir.nodes.BinaryOperation`
'''
array_symbol = DataSymbol("x", ArrayType(REAL_TYPE, [10]))
symbol_table.add(array_symbol)
symbol_n = symbol_table.lookup("n")
array_x = ArrayReference.create(array_symbol,
[create_stepped_range(symbol_n)])
array_symbol = DataSymbol("z", ArrayType(REAL_TYPE, [10, 10]))
symbol_table.add(array_symbol)
array_z = ArrayReference.create(
array_symbol,
[Literal("1", INTEGER_TYPE),
create_stepped_range(symbol_n)])
array_symbol = DataSymbol("a", ArrayType(REAL_TYPE, [10]))
array_a = ArrayReference.create(array_symbol, [Literal("1", INTEGER_TYPE)])
symbol_table.add(array_symbol)
mult = BinaryOperation.create(BinaryOperation.Operator.MUL, array_x,
array_z)
add = BinaryOperation.create(BinaryOperation.Operator.ADD, mult, array_a)
return add
def test_array_range_with_reduction():
''' Test that we correctly identify an array range when it is the result
of a reduction from an array, e.g x(1, INT(SUM(map(:, :), 1))) = 1.0
'''
one = Literal("1.0", REAL_TYPE)
int_one = Literal("1", INTEGER_TYPE)
int_two = Literal("2", INTEGER_TYPE)
int_array_type = ArrayType(INTEGER_SINGLE_TYPE, [10, 10])
map_sym = DataSymbol("map", int_array_type)
array_type = ArrayType(REAL_TYPE, [10, 10])
symbol = DataSymbol("x", array_type)
lbound1 = BinaryOperation.create(BinaryOperation.Operator.LBOUND,
Reference(map_sym), int_one.copy())
ubound1 = BinaryOperation.create(BinaryOperation.Operator.UBOUND,
Reference(map_sym), int_one.copy())
my_range1 = Range.create(lbound1, ubound1)
lbound2 = BinaryOperation.create(BinaryOperation.Operator.LBOUND,
Reference(map_sym), int_two.copy())
ubound2 = BinaryOperation.create(BinaryOperation.Operator.UBOUND,
Reference(map_sym), int_two.copy())
my_range2 = Range.create(lbound2, ubound2)
bsum_op = BinaryOperation.create(
BinaryOperation.Operator.SUM,
ArrayReference.create(map_sym, [my_range1, my_range2]), int_one.copy())
int_op2 = UnaryOperation.create(UnaryOperation.Operator.INT, bsum_op)
assignment = Assignment.create(
ArrayReference.create(symbol, [int_one.copy(), int_op2]), one.copy())
assert assignment.is_array_range is True
def test_is_not_array_range():
''' Test that is_array_range correctly rejects things that aren't
an assignment to an array range.
'''
int_one = Literal("1", INTEGER_SINGLE_TYPE)
one = Literal("1.0", REAL_TYPE)
var = DataSymbol("x", REAL_TYPE)
reference = Reference(var)
# lhs is not an array
assignment = Assignment.create(reference, one)
assert assignment.is_array_range is False
# lhs is an array reference but has no range
array_type = ArrayType(REAL_TYPE, [10, 10])
symbol = DataSymbol("y", array_type)
array_ref = Reference(symbol)
assignment = Assignment.create(array_ref, one.copy())
assert assignment.is_array_range is False
# lhs is an array reference but the single index value is obtained
# using an array range, y(1, SUM(map(:), 1)) = 1.0
int_array_type = ArrayType(INTEGER_SINGLE_TYPE, [10])
map_sym = DataSymbol("map", int_array_type)
start = BinaryOperation.create(BinaryOperation.Operator.LBOUND,
Reference(map_sym), int_one.copy())
stop = BinaryOperation.create(BinaryOperation.Operator.UBOUND,
Reference(map_sym), int_one.copy())
my_range = Range.create(start, stop)
sum_op = BinaryOperation.create(BinaryOperation.Operator.SUM,
ArrayReference.create(map_sym, [my_range]),
int_one.copy())
assignment = Assignment.create(
ArrayReference.create(symbol, [int_one.copy(), sum_op]), one.copy())
assert assignment.is_array_range is False
# When the slice has two operator ancestors, one of which is a reduction
# e.g y(1, SUM(ABS(map(:)), 1)) = 1.0
abs_op = UnaryOperation.create(
UnaryOperation.Operator.ABS,
ArrayReference.create(map_sym, [my_range.copy()]))
sum_op2 = BinaryOperation.create(BinaryOperation.Operator.SUM, abs_op,
int_one.copy())
assignment = Assignment.create(
ArrayReference.create(symbol, [int_one.copy(), sum_op2]), one.copy())
assert assignment.is_array_range is False
# lhs is a scalar member of a structure
grid_type = StructureType.create([
("dx", REAL_SINGLE_TYPE, Symbol.Visibility.PUBLIC),
("dy", REAL_SINGLE_TYPE, Symbol.Visibility.PUBLIC)
])
grid_type_symbol = DataTypeSymbol("grid_type", grid_type)
grid_sym = DataSymbol("grid", grid_type_symbol)
assignment = Assignment.create(StructureReference.create(grid_sym, ["dx"]),
one.copy())
assert assignment.is_array_range is False
def test_validate_intrinsic():
'''Check that the validate method returns an exception if the rhs of
the assignment contains an operator that only returns an array
i.e. can't be performed elementwise. At the moment MATMUL is the
only operator of this type.
'''
symbol_table = SymbolTable()
array_x = create_array_x(symbol_table)
array_y_2 = create_array_y_2d_slice(symbol_table)
matmul = BinaryOperation.create(BinaryOperation.Operator.MATMUL, array_y_2,
array_x)
reference = ArrayReference.create(
symbol_table.lookup("x"), [create_range(symbol_table.lookup("x"), 1)])
assignment = Assignment.create(reference, matmul)
trans = ArrayRange2LoopTrans()
with pytest.raises(TransformationError) as info:
trans.validate(assignment)
assert ("Error in ArrayRange2LoopTrans transformation. The rhs of the "
"supplied Assignment node 'BinaryOperation[operator:'MATMUL']\n"
"ArrayReference[name:'y2']\nRange[]\nRange[]\n\n"
"ArrayReference[name:'x']\nRange[]\n' contains the "
"MATMUL operator which can't be performed elementwise."
in str(info.value))
def test_is_array_range():
'''test that the is_array_range method behaves as expected, returning
true if the LHS of the assignment is an array range access and
false otherwise.
'''
one = Literal("1.0", REAL_TYPE)
int_one = Literal("1", INTEGER_TYPE)
var = DataSymbol("x", REAL_TYPE)
reference = Reference(var)
# lhs is not an array
assignment = Assignment.create(reference, one)
assert not assignment.is_array_range
# lhs is an array reference but has no range
array_type = ArrayType(REAL_TYPE, [10, 10])
symbol = DataSymbol("x", array_type)
array_ref = ArrayReference(symbol, [1, 3])
assignment = Assignment.create(array_ref, one)
assert not assignment.is_array_range
# lhs is an array reference with a range
my_range = Range.create(int_one, int_one, int_one)
array_ref = ArrayReference.create(symbol, [my_range, int_one])
assignment = Assignment.create(array_ref, one)
assert assignment.is_array_range
def test_reference_accesses_bounds(operator_type):
'''Test that the reference_accesses method behaves as expected when
the reference is the first argument to either the lbound or ubound
intrinsic as that is simply looking up the array bounds (therefore
var_access_info should be empty) and when the reference is the
second argument of either the lbound or ubound intrinsic (in which
case the access should be a read).
'''
# Note, one would usually expect UBOUND to provide the upper bound
# of a range but to simplify the test both LBOUND and UBOUND are
# used for the lower bound. This does not affect the test.
one = Literal("1", INTEGER_TYPE)
array_symbol = DataSymbol("test", ArrayType(REAL_TYPE, [10]))
array_ref1 = Reference(array_symbol)
array_ref2 = Reference(array_symbol)
array_access = ArrayReference.create(array_symbol, [one])
# test when first or second argument to LBOUND or UBOUND is an
# array reference
operator = BinaryOperation.create(operator_type, array_ref1, array_ref2)
array_access.children[0] = Range.create(operator, one, one)
var_access_info = VariablesAccessInfo()
array_ref1.reference_accesses(var_access_info)
assert str(var_access_info) == ""
var_access_info = VariablesAccessInfo()
array_ref2.reference_accesses(var_access_info)
assert str(var_access_info) == "test: READ"
def test_array_create_invalid3():
'''Test that the create method in an ArrayReference class raises the
expected exception if the provided input is invalid.
'''
# symbol argument is not a DataSymbol
with pytest.raises(GenerationError) as excinfo:
_ = ArrayReference.create([], [])
assert ("symbol argument in create method of ArrayReference class should "
"be a DataSymbol but found 'list'." in str(excinfo.value))
# children not a list
with pytest.raises(GenerationError) as excinfo:
_ = ArrayReference.create(DataSymbol("temp", REAL_SINGLE_TYPE),
"invalid")
assert ("indices argument in create method of ArrayReference class should"
" be a list but found 'str'." in str(excinfo.value))
def create_matmul():
'''Utility function that creates a valid matmul node for use with
subsequent tests.
'''
symbol_table = SymbolTable()
one = Literal("1", INTEGER_TYPE)
two = Literal("2", INTEGER_TYPE)
index = DataSymbol("idx", INTEGER_TYPE, constant_value=3)
symbol_table.add(index)
array_type = ArrayType(REAL_TYPE, [5, 10, 15])
mat_symbol = DataSymbol("x", array_type)
symbol_table.add(mat_symbol)
lbound1 = BinaryOperation.create(BinaryOperation.Operator.LBOUND,
Reference(mat_symbol), one.copy())
ubound1 = BinaryOperation.create(BinaryOperation.Operator.UBOUND,
Reference(mat_symbol), one.copy())
my_mat_range1 = Range.create(lbound1, ubound1, one.copy())
lbound2 = BinaryOperation.create(BinaryOperation.Operator.LBOUND,
Reference(mat_symbol), two.copy())
ubound2 = BinaryOperation.create(BinaryOperation.Operator.UBOUND,
Reference(mat_symbol), two.copy())
my_mat_range2 = Range.create(lbound2, ubound2, one.copy())
matrix = ArrayReference.create(
mat_symbol, [my_mat_range1, my_mat_range2,
Reference(index)])
array_type = ArrayType(REAL_TYPE, [10, 20])
vec_symbol = DataSymbol("y", array_type)
symbol_table.add(vec_symbol)
lbound = BinaryOperation.create(BinaryOperation.Operator.LBOUND,
Reference(vec_symbol), one.copy())
ubound = BinaryOperation.create(BinaryOperation.Operator.UBOUND,
Reference(vec_symbol), one.copy())
my_vec_range = Range.create(lbound, ubound, one.copy())
vector = ArrayReference.create(
vec_symbol, [my_vec_range, Reference(index)])
matmul = BinaryOperation.create(BinaryOperation.Operator.MATMUL, matrix,
vector)
lhs_type = ArrayType(REAL_TYPE, [10])
lhs_symbol = DataSymbol("result", lhs_type)
symbol_table.add(lhs_symbol)
lhs = Reference(lhs_symbol)
assign = Assignment.create(lhs, matmul)
KernelSchedule.create("my_kern", symbol_table, [assign])
return matmul
def test_array_is_lower_bound():
'''Test that the is_lower_bound method in the Array Node works as
expected.
'''
one = Literal("1", INTEGER_TYPE)
array = ArrayReference.create(DataSymbol("test",
ArrayType(REAL_TYPE, [10])),
[one])
with pytest.raises(TypeError) as info:
array.is_lower_bound("hello")
assert ("The index argument should be an integer but found 'str'."
in str(info.value))
# not a range node at index 0
assert not array.is_lower_bound(0)
# range node does not have a binary operator for its start value
array.children[0] = Range.create(one, one, one)
assert not array.is_lower_bound(0)
# range node lbound references a different array
array2 = ArrayReference.create(DataSymbol("test2",
ArrayType(REAL_TYPE, [10])),
[one])
operator = BinaryOperation.create(
BinaryOperation.Operator.LBOUND, array2,
Literal("1", INTEGER_TYPE))
array.children[0] = Range.create(operator, one, one)
assert not array.is_lower_bound(0)
# range node lbound references a different index
operator = BinaryOperation.create(
BinaryOperation.Operator.LBOUND, array,
Literal("2", INTEGER_TYPE))
array.children[0] = Range.create(operator, one, one)
assert not array.is_lower_bound(0)
# all is well
operator = BinaryOperation.create(
BinaryOperation.Operator.LBOUND, array, one)
array.children[0] = Range.create(operator, one, one)
assert array.is_lower_bound(0)
def test_validate():
'''Test that the validate method in the ArrayRange2LoopTrans class
raises the expected exceptions.
'''
trans = ArrayRange2LoopTrans()
with pytest.raises(TransformationError) as info:
trans.validate(Node())
assert (
"Error in ArrayRange2LoopTrans transformation. The supplied node "
"argument should be a PSyIR Assignment, but found 'Node'."
in str(info.value))
with pytest.raises(TransformationError) as info:
trans.validate(Assignment.create(DataNode(), DataNode()))
assert (
"Error in ArrayRange2LoopTrans transformation. The lhs of the "
"supplied Assignment node should be a PSyIR ArrayReference, but found "
"'DataNode'." in str(info.value))
array_symbol = DataSymbol("x", ArrayType(INTEGER_TYPE, [10, 10]))
one = Literal("1", INTEGER_TYPE)
array_assignment = ArrayReference.create(array_symbol, [one, one.copy()])
with pytest.raises(TransformationError) as info:
trans.validate(Assignment.create(array_assignment, DataNode()))
assert (
"Error in ArrayRange2LoopTrans transformation. The lhs of the "
"supplied Assignment node should be a PSyIR ArrayReference with at "
"least one "
"of its dimensions being a Range, but found None in "
"'ArrayReference[name:'x']\\nLiteral[value:'1', "
"Scalar<INTEGER, UNDEFINED>]\\nLiteral[value:'1', Scalar<INTEGER, "
"UNDEFINED>]\\n'." in str(info.value))
array_x = create_array_x(SymbolTable())
assignment = Assignment.create(
create_array_x(SymbolTable()), array_x)
trans.validate(assignment)
array_x.children[0].step = Literal("2", INTEGER_TYPE)
with pytest.raises(TransformationError) as info:
trans.validate(assignment)
assert (
"The ArrayRange2LoopTrans transformation only supports ranges that "
"are known to be the same as each other but array access 'x' "
"dimension 0 and 'x' dimension 0 are either different or can't be "
"determined in the assignment 'Assignment[]\\n"
"ArrayReference[name:'x']\\nRange[]\\n"
"ArrayReference[name:'x']\\nRange[]\\n'."
in str(info.value))
def test_array_create_invalid1():
'''Test that the create method in the ArrayReference class raises an
exception if the provided symbol is not an array.
'''
symbol_i = DataSymbol("i", INTEGER_SINGLE_TYPE)
symbol_j = DataSymbol("j", INTEGER_SINGLE_TYPE)
symbol_temp = DataSymbol("temp", REAL_SINGLE_TYPE)
children = [Reference(symbol_i), Reference(symbol_j),
Literal("1", INTEGER_SINGLE_TYPE)]
with pytest.raises(GenerationError) as excinfo:
_ = ArrayReference.create(symbol_temp, children)
assert ("expecting the symbol to be an array, not a scalar."
in str(excinfo.value))
def test_array_create():
'''Test that the create method in the ArrayReference class correctly
creates an ArrayReference instance.
'''
array_type = ArrayType(REAL_SINGLE_TYPE, [10, 10, 10])
symbol_temp = DataSymbol("temp", array_type)
symbol_i = DataSymbol("i", INTEGER_SINGLE_TYPE)
symbol_j = DataSymbol("j", INTEGER_SINGLE_TYPE)
children = [Reference(symbol_i), Reference(symbol_j),
Literal("1", INTEGER_SINGLE_TYPE)]
array = ArrayReference.create(symbol_temp, children)
check_links(array, children)
result = FortranWriter().arrayreference_node(array)
assert result == "temp(i,j,1)"
def test_array_validate_index():
'''Test that the validate_index utility function behaves as expected.'''
array = ArrayReference.create(
DataSymbol("test", ArrayType(REAL_TYPE, [10])),
[Literal("1", INTEGER_TYPE)])
with pytest.raises(TypeError) as info:
array._validate_index("hello")
assert ("The index argument should be an integer but found 'str'."
in str(info.value))
with pytest.raises(ValueError) as info:
array._validate_index(1)
assert ("In ArrayReference 'test' the specified index '1' must be less "
"than the number of dimensions '1'." in str(info.value))
array._validate_index(0)
array._validate_index(-1)
def test_array_create_invalid2():
'''Test that the create method in the ArrayReference class raises an
exception if the number of dimension in the provided symbol is different
to the number of indices provided to the create method.
'''
array_type = ArrayType(REAL_SINGLE_TYPE, [10])
symbol_temp = DataSymbol("temp", array_type)
symbol_i = DataSymbol("i", INTEGER_SINGLE_TYPE)
symbol_j = DataSymbol("j", INTEGER_SINGLE_TYPE)
children = [Reference(symbol_i), Reference(symbol_j),
Literal("1", INTEGER_SINGLE_TYPE)]
with pytest.raises(GenerationError) as excinfo:
_ = ArrayReference.create(symbol_temp, children)
assert ("the symbol should have the same number of dimensions as indices "
"(provided in the 'indices' argument). Expecting '3' but found "
"'1'." in str(excinfo.value))
def test_reference():
'''Test that the common reference visitor writes the referenced symbol name
or raises an error if the node is not Leaf node reference.
'''
# Generate PSyIR Reference
test_visitor = PSyIRVisitor()
reference = Reference(DataSymbol('a', REAL_TYPE))
result = test_visitor(reference)
assert result == "a"
# Generate PSyIR ArrayReference
reference2 = ArrayReference.create(
DataSymbol('b', ArrayType(REAL_TYPE, shape=[1])), [reference])
with pytest.raises(VisitorError) as err:
result = test_visitor(reference2)
assert "Expecting a Reference with no children but found: " \
in str(err.value)
def create_array_x(symbol_table):
'''Utility routine that creates and returns an array reference to a
one-dimensional array "x". The array reference accesses all of the
elements in the array dimension using a range node. In Fortran
array notation this is "x(:)".
:param symbol_table: the symbol table to which we add the array \
symbol.
:type symbol_table: :py:class:`psyclone.psyir.symbol.SymbolTable`
:returns: an array reference that accesses all elements of the \
array "x".
:rtype: :py:class:`psyclone.psyir.nodes.ArrayReference`
'''
array_symbol = DataSymbol("x", ArrayType(REAL_TYPE, [10]))
symbol_table.add(array_symbol)
return ArrayReference.create(array_symbol, [create_range(array_symbol, 1)])
def create_array_y_2d_slice(symbol_table):
'''Utility routine that creates and returns an array reference to a 2
dimensional array "y". The array reference accesses all elements
in the 1st and 2nd dimensions of the array using range nodes. In
Fortran array notation this is "y(:,:)".
:param symbol_table: the symbol table to which we add the array \
symbol.
:type symbol_table: :py:class:`psyclone.psyir.symbol.SymbolTable`
:returns: an array reference that accesses all elements of the 1st \
and 2nd dimensions of the "y" array.
:rtype: :py:class:`psyclone.psyir.nodes.ArrayReference`
'''
array_symbol = DataSymbol("y2", ArrayType(REAL_TYPE, [20, 10]))
symbol_table.add(array_symbol)
return ArrayReference.create(array_symbol, [create_range(array_symbol, 1),
create_range(array_symbol, 2)])
def test_array_indices():
''' Tests for the indices property (provided by the ArrayMixin class). '''
one = Literal("1", INTEGER_TYPE)
array = ArrayReference.create(
DataSymbol("test", ArrayType(REAL_TYPE, [10])), [one])
assert array.indices == [one]
# Add an invalid child
array._children = [one.copy(), "hello"]
with pytest.raises(InternalError) as err:
_ = array.indices
assert ("ArrayReference malformed or incomplete: child 1 must by a "
"psyir.nodes.DataNode or Range representing an array-index "
"expression but found 'str'" in str(err.value))
# Remove the children altogether
array._children = []
with pytest.raises(InternalError) as err:
_ = array.indices
assert ("ArrayReference malformed or incomplete: must have one or more "
"children representing array-index expressions but found none"
in str(err.value))
def test_validate5():
'''Check that the Matmul2Code validate method raises the expected
exception when the supplied node is a MATMUL binary operation but
either or both arguments are not references.
'''
trans = Matmul2CodeTrans()
array_type = ArrayType(REAL_TYPE, [10])
array = ArrayReference.create(DataSymbol("x", array_type),
[Literal("10", INTEGER_TYPE)])
mult = BinaryOperation.create(
BinaryOperation.Operator.MUL, array, array)
matmul = BinaryOperation.create(
BinaryOperation.Operator.MATMUL, mult, mult)
_ = Assignment.create(array, matmul)
with pytest.raises(TransformationError) as excinfo:
trans.validate(matmul)
assert ("Expected children of a MATMUL BinaryOperation to be references, "
"but found 'BinaryOperation', 'BinaryOperation'."
in str(excinfo.value))
def test_range_view(capsys):
''' Check that calling view() on an array with a child Range works
as expected. '''
# Create the PSyIR for 'my_array(1, 1:10)'
erange = Range.create(Literal("1", INTEGER_SINGLE_TYPE),
Literal("10", INTEGER_SINGLE_TYPE))
array_type = ArrayType(REAL_SINGLE_TYPE, [10, 10])
array = ArrayReference.create(DataSymbol("my_array", array_type),
[Literal("1", INTEGER_SINGLE_TYPE), erange])
array.view()
stdout, _ = capsys.readouterr()
arrayref = colored("ArrayReference", ArrayReference._colour)
literal = colored("Literal", Literal._colour)
rangestr = colored("Range", Range._colour)
indent = " "
assert (arrayref + "[name:'my_array']\n" + indent + literal +
"[value:'1', Scalar<INTEGER, SINGLE>]\n" + indent + rangestr +
"[]\n" + 2 * indent + literal +
"[value:'1', Scalar<INTEGER, SINGLE>]\n" + 2 * indent + literal +
"[value:'10', Scalar<INTEGER, SINGLE>]\n" + 2 * indent + literal +
"[value:'1', Scalar<INTEGER, UNDEFINED>]\n" in stdout)
def test_where_array_notation_rank():
''' Test that the _array_notation_rank() utility raises the expected
errors when passed an unsupported Array object.
'''
array_type = ArrayType(REAL_TYPE, [10])
symbol = DataSymbol("my_array", array_type)
my_array = ArrayReference(symbol)
processor = Fparser2Reader()
with pytest.raises(NotImplementedError) as err:
processor._array_notation_rank(my_array)
assert ("Array reference in the PSyIR must have at least one child but "
"'my_array'" in str(err.value))
from psyclone.psyir.nodes import Range
array_type = ArrayType(REAL_TYPE, [10])
my_array = ArrayReference.create(DataSymbol("my_array", array_type), [
Range.create(Literal("1", INTEGER_TYPE), Literal("10", INTEGER_TYPE))
])
with pytest.raises(NotImplementedError) as err:
processor._array_notation_rank(my_array)
assert ("Only array notation of the form my_array(:, :, ...) is "
"supported." in str(err.value))
def create_array_y(symbol_table):
'''Utility routine that creates and returns an array reference to a
two-dimensional array "y". The array reference accesses all
elements in the 2nd dimension of the array using a range node and
the n'th element of the 1st dimension. In Fortran array notation
this is "y(n,:)".
:param symbol_table: the symbol table to which we add the array \
symbol and access the symbol "n".
:type symbol_table: :py:class:`psyclone.psyir.symbol.SymbolTable`
:returns: an array reference that accesses all elements of the \
2nd dimension of array "y" and the n'th element of its 1st \
dimension.
:rtype: :py:class:`psyclone.psyir.nodes.ArrayReference`
'''
array_symbol = DataSymbol("y", ArrayType(REAL_TYPE, [10, 10]))
symbol_table.add(array_symbol)
return ArrayReference.create(array_symbol,
[Reference(symbol_table.lookup("n")),
create_range(array_symbol, 2)])
def create_array_z(symbol_table):
'''Utility routine that creates and returns an array reference to a 3
dimensional array "z". The array reference accesses all elements
in the arrays 1st and 3rd dimensions using range nodes and
accesses element "n" in its second dimension. In Fortran array
notation this is "z(:,n,:)".
:param symbol_table: the symbol table to which we add the array \
symbol and access the symbol "n"
:type symbol_table: :py:class:`psyclone.psyir.symbol.SymbolTable`
:returns: an array reference that accesses all elements of the 1st \
and 3rd dimensions of array "z" and the n'th element of its \
second dimension.
:rtype: :py:class:`psyclone.psyir.nodes.ArrayReference`
'''
array_symbol = DataSymbol("z", ArrayType(REAL_TYPE, [20, 10, 10]))
symbol_table.add(array_symbol)
return ArrayReference.create(array_symbol,
[create_range(array_symbol, 1),
Reference(symbol_table.lookup("n")),
create_range(array_symbol, 3)])
def create_array_y_slice_subset(symbol_table):
'''Utility routine that creates and returns an array reference to a 2
dimensional array "y". The array reference accesses elements 2 to
"n" step 2 in the arrays 2nd dimension using a range node and the
n'th element of the 1st dimension. In Fortran array notation this
is "y(n,2:n:2)".
:param symbol_table: the symbol table to which we add the array \
symbol and access the symbol "n".
:type symbol_table: :py:class:`psyclone.psyir.symbol.SymbolTable`
:returns: an array reference that accesses elements 2 to "n" step \
2 in the array "y"'s 2nd dimension and the n'th element of its \
1st dimension.
:rtype: :py:class:`psyclone.psyir.nodes.ArrayReference`
'''
array_symbol = DataSymbol("y3", ArrayType(REAL_TYPE, [10, 10]))
symbol_table.add(array_symbol)
symbol_n = symbol_table.lookup("n")
return ArrayReference.create(
array_symbol, [Reference(symbol_n),
create_stepped_range(symbol_n)])
def test_apply4(tmpdir):
'''Test that the matmul2code apply method produces the expected
PSyIR. We use the Fortran backend to help provide the test for
correctness. This example make the lhs be the same array as the
second operand of the matmul (the vector in this case).
'''
trans = Matmul2CodeTrans()
one = Literal("1", INTEGER_TYPE)
five = Literal("5", INTEGER_TYPE)
matmul = create_matmul()
root = matmul.root
assignment = matmul.parent
vector = assignment.scope.symbol_table.lookup("y")
assignment.children[0] = ArrayReference.create(
vector, [Range.create(one, five, one.copy()),
one.copy()])
trans.apply(matmul)
writer = FortranWriter()
result = writer(root)
assert ("subroutine my_kern()\n"
" integer, parameter :: idx = 3\n"
" real, dimension(5,10,15) :: x\n"
" real, dimension(10,20) :: y\n"
" real, dimension(10) :: result\n"
" integer :: i\n"
" integer :: j\n"
"\n"
" do i = 1, 5, 1\n"
" y(i,1) = 0.0\n"
" do j = 1, 10, 1\n"
" y(i,1) = y(i,1) + x(i,j,idx) * y(j,idx)\n"
" enddo\n"
" enddo\n"
"\n"
"end subroutine my_kern" in result)
assert Compile(tmpdir).string_compiles(result)
def test_scoping_node_copy_hierarchy():
''' Test that the ScopingNode copy() method creates a new symbol table
with copied symbols and updates the children references.
This test has 2 ScopingNodes, and the copy will only be applied to the
inner one. This means that the References to the symbols on the outer
scope should not be duplicated. Also it contains argument symbols and
a reference inside another reference to make sure all these are copied
appropriately.
'''
parent_node = Container("module")
symbol_b = parent_node.symbol_table.new_symbol("b",
symbol_type=DataSymbol,
datatype=ArrayType(
INTEGER_TYPE, [5]))
schedule = Routine("routine")
parent_node.addchild(schedule)
symbol_a = schedule.symbol_table.new_symbol(
"a",
symbol_type=DataSymbol,
datatype=INTEGER_TYPE,
interface=ArgumentInterface(ArgumentInterface.Access.READWRITE))
schedule.symbol_table.specify_argument_list([symbol_a])
symbol_i = schedule.symbol_table.new_symbol("i",
symbol_type=DataSymbol,
datatype=INTEGER_TYPE)
schedule.addchild(
Assignment.create(
Reference(symbol_a),
ArrayReference.create(symbol_b, [Reference(symbol_i)])))
new_schedule = schedule.copy()
# Check that the symbol_table has been deep copied
assert new_schedule.symbol_table is not schedule.symbol_table
assert new_schedule.symbol_table.lookup("i") is not \
schedule.symbol_table.lookup("i")
assert new_schedule.symbol_table.lookup("a") is not \
schedule.symbol_table.lookup("a")
# Check that 'a' and 'i' have been copied to the new symbol table.
assert new_schedule[0].lhs.symbol not in schedule.symbol_table.symbols
assert new_schedule[0].lhs.symbol in new_schedule.symbol_table.symbols
assert new_schedule[0].rhs.children[0].symbol not in \
schedule.symbol_table.symbols
assert new_schedule[0].rhs.children[0].symbol in \
new_schedule.symbol_table.symbols
# Add the "_new" suffix to all symbol in the copied schedule
for symbol in new_schedule.symbol_table.symbols:
new_schedule.symbol_table.rename_symbol(symbol, symbol.name + "_new")
# An update to a symbol in the outer scope must affect both copies of the
# inner schedule.
parent_node.symbol_table.rename_symbol(symbol_b, symbol_b.name + "_global")
# Insert the schedule back to the original container
parent_node.addchild(new_schedule)
# Check that the expected code is generated
# TODO #1200: the new 'routine' RoutineSymbol also needs to change.
expected = '''\
module module
implicit none
integer, dimension(5) :: b_global
contains
subroutine routine(a)
integer, intent(inout) :: a
integer :: i
a = b_global(i)
end subroutine routine
subroutine routine(a_new)
integer, intent(inout) :: a_new
integer :: i_new
a_new = b_global(i_new)
end subroutine routine
end module module
'''
writer = FortranWriter()
output = writer(parent_node)
assert expected == output
def create_psyir_tree():
''' Create an example PSyIR Tree.
:returns: an example PSyIR tree.
:rtype: :py:class:`psyclone.psyir.nodes.Container`
'''
# Symbol table, symbols and scalar datatypes
symbol_table = SymbolTable()
arg1 = symbol_table.new_symbol(symbol_type=DataSymbol,
datatype=REAL_TYPE,
interface=ArgumentInterface(
ArgumentInterface.Access.READWRITE))
symbol_table.specify_argument_list([arg1])
tmp_symbol = symbol_table.new_symbol(symbol_type=DataSymbol,
datatype=REAL_DOUBLE_TYPE)
index_symbol = symbol_table.new_symbol(root_name="i",
symbol_type=DataSymbol,
datatype=INTEGER4_TYPE)
real_kind = symbol_table.new_symbol(root_name="RKIND",
symbol_type=DataSymbol,
datatype=INTEGER_TYPE,
constant_value=8)
routine_symbol = RoutineSymbol("my_sub")
# Array using precision defined by another symbol
scalar_type = ScalarType(ScalarType.Intrinsic.REAL, real_kind)
array = symbol_table.new_symbol(root_name="a",
symbol_type=DataSymbol,
datatype=ArrayType(scalar_type, [10]))
# Nodes which do not have Nodes as children and (some) predefined
# scalar datatypes
# TODO: Issue #1136 looks at how to avoid all of the _x versions
zero_1 = Literal("0.0", REAL_TYPE)
zero_2 = Literal("0.0", REAL_TYPE)
zero_3 = Literal("0.0", REAL_TYPE)
one_1 = Literal("1.0", REAL4_TYPE)
one_2 = Literal("1.0", REAL4_TYPE)
one_3 = Literal("1.0", REAL4_TYPE)
two = Literal("2.0", scalar_type)
int_zero = Literal("0", INTEGER_SINGLE_TYPE)
int_one_1 = Literal("1", INTEGER8_TYPE)
int_one_2 = Literal("1", INTEGER8_TYPE)
int_one_3 = Literal("1", INTEGER8_TYPE)
int_one_4 = Literal("1", INTEGER8_TYPE)
tmp1_1 = Reference(arg1)
tmp1_2 = Reference(arg1)
tmp1_3 = Reference(arg1)
tmp1_4 = Reference(arg1)
tmp1_5 = Reference(arg1)
tmp1_6 = Reference(arg1)
tmp2_1 = Reference(tmp_symbol)
tmp2_2 = Reference(tmp_symbol)
tmp2_3 = Reference(tmp_symbol)
tmp2_4 = Reference(tmp_symbol)
tmp2_5 = Reference(tmp_symbol)
tmp2_6 = Reference(tmp_symbol)
# Unary Operation
oper = UnaryOperation.Operator.SIN
unaryoperation_1 = UnaryOperation.create(oper, tmp2_1)
unaryoperation_2 = UnaryOperation.create(oper, tmp2_2)
# Binary Operation
oper = BinaryOperation.Operator.ADD
binaryoperation_1 = BinaryOperation.create(oper, one_1, unaryoperation_1)
binaryoperation_2 = BinaryOperation.create(oper, one_2, unaryoperation_2)
# Nary Operation
oper = NaryOperation.Operator.MAX
naryoperation = NaryOperation.create(oper, [tmp1_1, tmp2_3, one_3])
# Array reference using a range
lbound = BinaryOperation.create(BinaryOperation.Operator.LBOUND,
Reference(array), int_one_1)
ubound = BinaryOperation.create(BinaryOperation.Operator.UBOUND,
Reference(array), int_one_2)
my_range = Range.create(lbound, ubound)
tmparray = ArrayReference.create(array, [my_range])
# Assignments
assign1 = Assignment.create(tmp1_2, zero_1)
assign2 = Assignment.create(tmp2_4, zero_2)
assign3 = Assignment.create(tmp2_5, binaryoperation_1)
assign4 = Assignment.create(tmp1_3, tmp2_6)
assign5 = Assignment.create(tmp1_4, naryoperation)
assign6 = Assignment.create(tmparray, two)
# Call
call = Call.create(routine_symbol, [tmp1_5, binaryoperation_2])
# If statement
if_condition = BinaryOperation.create(BinaryOperation.Operator.GT, tmp1_6,
zero_3)
ifblock = IfBlock.create(if_condition, [assign3, assign4])
# Loop
loop = Loop.create(index_symbol, int_zero, int_one_3, int_one_4, [ifblock])
# KernelSchedule
kernel_schedule = KernelSchedule.create(
"work", symbol_table, [assign1, call, assign2, loop, assign5, assign6])
# Container
container_symbol_table = SymbolTable()
container = Container.create("CONTAINER", container_symbol_table,
[kernel_schedule])
# Import data from another container
external_container = ContainerSymbol("some_mod")
container_symbol_table.add(external_container)
external_var = DataSymbol("some_var",
INTEGER_TYPE,
interface=GlobalInterface(external_container))
container_symbol_table.add(external_var)
routine_symbol.interface = GlobalInterface(external_container)
container_symbol_table.add(routine_symbol)
return container
def create_psyir_tree():
''' Create an example PSyIR Tree.
:returns: an example PSyIR tree.
:rtype: :py:class:`psyclone.psyir.nodes.Container`
'''
# Symbol table, symbols and scalar datatypes
symbol_table = SymbolTable()
arg1 = symbol_table.new_symbol(symbol_type=DataSymbol,
datatype=REAL_TYPE,
interface=ArgumentInterface(
ArgumentInterface.Access.READWRITE))
symbol_table.specify_argument_list([arg1])
tmp_symbol = symbol_table.new_symbol(symbol_type=DataSymbol,
datatype=REAL_DOUBLE_TYPE)
index_symbol = symbol_table.new_symbol(root_name="i",
symbol_type=DataSymbol,
datatype=INTEGER4_TYPE)
real_kind = symbol_table.new_symbol(root_name="RKIND",
symbol_type=DataSymbol,
datatype=INTEGER_TYPE,
constant_value=8)
routine_symbol = RoutineSymbol("my_sub")
# Array using precision defined by another symbol
scalar_type = ScalarType(ScalarType.Intrinsic.REAL, real_kind)
array = symbol_table.new_symbol(root_name="a",
symbol_type=DataSymbol,
datatype=ArrayType(scalar_type, [10]))
# Make generators for nodes which do not have other Nodes as children,
# with some predefined scalar datatypes
def zero():
return Literal("0.0", REAL_TYPE)
def one():
return Literal("1.0", REAL4_TYPE)
def two():
return Literal("2.0", scalar_type)
def int_zero():
return Literal("0", INTEGER_SINGLE_TYPE)
def int_one():
return Literal("1", INTEGER8_TYPE)
def tmp1():
return Reference(arg1)
def tmp2():
return Reference(tmp_symbol)
# Unary Operation
oper = UnaryOperation.Operator.SIN
unaryoperation = UnaryOperation.create(oper, tmp2())
# Binary Operation
oper = BinaryOperation.Operator.ADD
binaryoperation = BinaryOperation.create(oper, one(), unaryoperation)
# Nary Operation
oper = NaryOperation.Operator.MAX
naryoperation = NaryOperation.create(oper, [tmp1(), tmp2(), one()])
# Array reference using a range
lbound = BinaryOperation.create(BinaryOperation.Operator.LBOUND,
Reference(array), int_one())
ubound = BinaryOperation.create(BinaryOperation.Operator.UBOUND,
Reference(array), int_one())
my_range = Range.create(lbound, ubound)
tmparray = ArrayReference.create(array, [my_range])
# Assignments
assign1 = Assignment.create(tmp1(), zero())
assign2 = Assignment.create(tmp2(), zero())
assign3 = Assignment.create(tmp2(), binaryoperation)
assign4 = Assignment.create(tmp1(), tmp2())
assign5 = Assignment.create(tmp1(), naryoperation)
assign6 = Assignment.create(tmparray, two())
# Call
call = Call.create(routine_symbol, [tmp1(), binaryoperation.copy()])
# If statement
if_condition = BinaryOperation.create(BinaryOperation.Operator.GT, tmp1(),
zero())
ifblock = IfBlock.create(if_condition, [assign3, assign4])
# Loop
loop = Loop.create(index_symbol, int_zero(), int_one(), int_one(),
[ifblock])
# KernelSchedule
kernel_schedule = KernelSchedule.create(
"work", symbol_table, [assign1, call, assign2, loop, assign5, assign6])
# Container
container_symbol_table = SymbolTable()
container = Container.create("CONTAINER", container_symbol_table,
[kernel_schedule])
# Import data from another container
external_container = ContainerSymbol("some_mod")
container_symbol_table.add(external_container)
external_var = DataSymbol("some_var",
INTEGER_TYPE,
interface=GlobalInterface(external_container))
container_symbol_table.add(external_var)
routine_symbol.interface = GlobalInterface(external_container)
container_symbol_table.add(routine_symbol)
return container
def test_array_is_full_range():
'''Test that the is_full_range method in the Array Node works as
expected. '''
# pylint: disable=too-many-statements
zero = Literal("0", INTEGER_SINGLE_TYPE)
one = Literal("1", INTEGER_SINGLE_TYPE)
array_type = ArrayType(REAL_SINGLE_TYPE, [10])
symbol = DataSymbol("my_array", array_type)
reference = Reference(symbol)
lbound = BinaryOperation.create(BinaryOperation.Operator.LBOUND, reference,
one)
ubound = BinaryOperation.create(BinaryOperation.Operator.UBOUND,
reference.copy(), one.copy())
symbol_error = DataSymbol("another_array", array_type)
reference_error = Reference(symbol_error)
# Index out of bounds
array_reference = ArrayReference.create(symbol, [one.copy()])
with pytest.raises(ValueError) as excinfo:
array_reference.is_full_range(1)
assert ("In ArrayReference 'my_array' the specified index '1' must be "
"less than the number of dimensions '1'." in str(excinfo.value))
# Array dimension is not a Range
assert not array_reference.is_full_range(0)
# Check LBOUND
# Array dimension range lower bound is not a binary operation
my_range = Range.create(one.copy(), one.copy(), one.copy())
array_reference = ArrayReference.create(symbol, [my_range])
assert not array_reference.is_full_range(0)
# Array dimension range lower bound is not an LBOUND binary operation
my_range = Range.create(ubound, one.copy(), one.copy())
array_reference = ArrayReference.create(symbol, [my_range])
assert not array_reference.is_full_range(0)
# Array dimension range lower bound is an LBOUND binary operation
# with the first value not being a reference
lbound_error = BinaryOperation.create(BinaryOperation.Operator.LBOUND,
zero.copy(), zero.copy())
my_range = Range.create(lbound_error, one.copy(), one.copy())
array_reference = ArrayReference.create(symbol, [my_range])
assert not array_reference.is_full_range(0)
# Array dimension range lower bound is an LBOUND binary operation
# with the first value being a reference to a different symbol
lbound_error = BinaryOperation.create(BinaryOperation.Operator.LBOUND,
reference_error, zero.copy())
my_range = Range.create(lbound_error, one.copy(), one.copy())
array_reference = ArrayReference.create(symbol, [my_range])
assert not array_reference.is_full_range(0)
# Array dimension range lower bound is an LBOUND binary operation
# with the second value not being a literal.
lbound_error = BinaryOperation.create(BinaryOperation.Operator.LBOUND,
reference.copy(), reference.copy())
my_range = Range.create(lbound_error, one.copy(), one.copy())
array_reference = ArrayReference.create(symbol, [my_range])
assert not array_reference.is_full_range(0)
# Array dimension range lower bound is an LBOUND binary operation
# with the second value not being an integer literal.
lbound_error = BinaryOperation.create(BinaryOperation.Operator.LBOUND,
reference.copy(),
Literal("1.0", REAL_SINGLE_TYPE))
my_range = Range.create(lbound_error, one.copy(), one.copy())
array_reference = ArrayReference.create(symbol, [my_range])
assert not array_reference.is_full_range(0)
# Array dimension range lower bound is an LBOUND binary operation
# with the second value being an integer literal with the wrong
# value (should be 0 as this dimension index is 0).
lbound_error = BinaryOperation.create(BinaryOperation.Operator.LBOUND,
reference.copy(), one.copy())
my_range = Range.create(lbound_error, one.copy(), one.copy())
array_reference = ArrayReference.create(symbol, [my_range])
assert not array_reference.is_full_range(0)
# Check UBOUND
# Array dimension range upper bound is not a binary operation
my_range = Range.create(lbound, one.copy(), one.copy())
array_reference = ArrayReference.create(symbol, [my_range])
assert not array_reference.is_full_range(0)
# Array dimension range upper bound is not a UBOUND binary operation
my_range = Range.create(lbound.copy(), lbound.copy(), one.copy())
array_reference = ArrayReference.create(symbol, [my_range])
assert not array_reference.is_full_range(0)
# Array dimension range upper bound is a UBOUND binary operation
# with the first value not being a reference
ubound_error = BinaryOperation.create(BinaryOperation.Operator.UBOUND,
zero.copy(), zero.copy())
my_range = Range.create(lbound.copy(), ubound_error, one.copy())
array_reference = ArrayReference.create(symbol, [my_range])
assert not array_reference.is_full_range(0)
# Array dimension range upper bound is a UBOUND binary operation
# with the first value being a reference to a different symbol
ubound_error = BinaryOperation.create(BinaryOperation.Operator.UBOUND,
reference_error.copy(), zero.copy())
my_range = Range.create(lbound.copy(), ubound_error, one.copy())
array_reference = ArrayReference.create(symbol, [my_range])
assert not array_reference.is_full_range(0)
# Array dimension range upper bound is a UBOUND binary operation
# with the second value not being a literal.
ubound_error = BinaryOperation.create(BinaryOperation.Operator.UBOUND,
reference.copy(), reference.copy())
my_range = Range.create(lbound.copy(), ubound_error, one.copy())
array_reference = ArrayReference.create(symbol, [my_range])
assert not array_reference.is_full_range(0)
# Array dimension range upper bound is a UBOUND binary operation
# with the second value not being an integer literal.
ubound_error = BinaryOperation.create(BinaryOperation.Operator.UBOUND,
reference.copy(),
Literal("1.0", REAL_SINGLE_TYPE))
my_range = Range.create(lbound.copy(), ubound_error, one.copy())
array_reference = ArrayReference.create(symbol, [my_range])
assert not array_reference.is_full_range(0)
# Array dimension range upper bound is a UBOUND binary operation
# with the second value being an integer literal with the wrong
# value (should be 1 as this dimension is 1).
ubound_error = BinaryOperation.create(BinaryOperation.Operator.UBOUND,
reference.copy(), zero.copy())
my_range = Range.create(lbound.copy(), ubound_error, one.copy())
array_reference = ArrayReference.create(symbol, [my_range])
assert not array_reference.is_full_range(0)
# Check Step
# Array dimension range step is not a literal.
my_range = Range.create(lbound.copy(), ubound.copy(), lbound.copy())
array_reference = ArrayReference.create(symbol, [my_range])
assert not array_reference.is_full_range(0)
# Array dimension range step is not an integer literal.
my_range = Range.create(lbound.copy(), ubound.copy(), one.copy())
# We have to change this to a non-integer manually as the create
# function only accepts integer literals for the step argument.
my_range.children[2] = Literal("1.0", REAL_SINGLE_TYPE)
array_reference = ArrayReference.create(symbol, [my_range])
assert not array_reference.is_full_range(0)
# Array dimension range step is is an integer literal with the
# wrong value (not 1).
my_range = Range.create(lbound.copy(), ubound.copy(), zero.copy())
array_reference = ArrayReference.create(symbol, [my_range])
assert not array_reference.is_full_range(0)
# All is as it should be.
# The full range is covered so return true.
my_range = Range.create(lbound.copy(), ubound.copy(), one.copy())
array_reference = ArrayReference.create(symbol, [my_range])
assert array_reference.is_full_range(0)
def test_is_array_range():
'''test that the is_array_range method behaves as expected, returning
true if the LHS of the assignment is an array range access.
'''
one = Literal("1.0", REAL_TYPE)
int_one = Literal("1", INTEGER_TYPE)
int_ten = Literal("10", INTEGER_TYPE)
# lhs is an array reference with a range
array_type = ArrayType(REAL_TYPE, [10, 10])
symbol = DataSymbol("x", array_type)
x_range = Range.create(int_one, int_ten.copy(), int_one.copy())
array_ref = ArrayReference.create(symbol, [x_range, int_one.copy()])
assignment = Assignment.create(array_ref, one.copy())
assert assignment.is_array_range is True
# Check when lhs consists of various forms of structure access
grid_type = StructureType.create([
("dx", REAL_SINGLE_TYPE, Symbol.Visibility.PUBLIC),
("dy", REAL_SINGLE_TYPE, Symbol.Visibility.PUBLIC)
])
grid_type_symbol = DataTypeSymbol("grid_type", grid_type)
# Create the definition of the 'field_type', contains array of grid_types
field_type_def = StructureType.create([
("data", ArrayType(REAL_SINGLE_TYPE, [10]), Symbol.Visibility.PUBLIC),
("sub_meshes", ArrayType(grid_type_symbol,
[3]), Symbol.Visibility.PUBLIC)
])
field_type_symbol = DataTypeSymbol("field_type", field_type_def)
field_symbol = DataSymbol("wind", field_type_symbol)
# Array reference to component of derived type using a range
lbound = BinaryOperation.create(
BinaryOperation.Operator.LBOUND,
StructureReference.create(field_symbol, ["data"]), int_one.copy())
ubound = BinaryOperation.create(
BinaryOperation.Operator.UBOUND,
StructureReference.create(field_symbol, ["data"]), int_one.copy())
my_range = Range.create(lbound, ubound)
data_ref = StructureReference.create(field_symbol, [("data", [my_range])])
assign = Assignment.create(data_ref, one.copy())
assert assign.is_array_range is True
# Access to slice of 'sub_meshes': wind%sub_meshes(1:3)%dx = 1.0
sub_range = Range.create(int_one.copy(), Literal("3", INTEGER_TYPE))
dx_ref = StructureReference.create(field_symbol,
[("sub_meshes", [sub_range]), "dx"])
sub_assign = Assignment.create(dx_ref, one.copy())
assert sub_assign.is_array_range is True
# Create an array of these derived types and assign to a slice:
# chi(1:10)%data(1) = 1.0
field_bundle_symbol = DataSymbol("chi", ArrayType(field_type_symbol, [3]))
fld_range = Range.create(int_one.copy(), Literal("10", INTEGER_TYPE))
fld_ref = ArrayOfStructuresReference.create(field_bundle_symbol,
[fld_range],
[("data", [int_one.copy()])])
fld_assign = Assignment.create(fld_ref, one.copy())
assert fld_assign.is_array_range is True
# When the slice has two operator ancestors, none of which are a reduction
# e.g y(1, INT(ABS(map(:, 1)))) = 1.0
int_array_type = ArrayType(INTEGER_SINGLE_TYPE, [10, 10])
map_sym = DataSymbol("map", int_array_type)
lbound1 = BinaryOperation.create(BinaryOperation.Operator.LBOUND,
Reference(map_sym), int_one.copy())
ubound1 = BinaryOperation.create(BinaryOperation.Operator.UBOUND,
Reference(map_sym), int_one.copy())
my_range1 = Range.create(lbound1, ubound1)
abs_op = UnaryOperation.create(
UnaryOperation.Operator.ABS,
ArrayReference.create(map_sym, [my_range1, int_one.copy()]))
int_op = UnaryOperation.create(UnaryOperation.Operator.INT, abs_op)
assignment = Assignment.create(
ArrayReference.create(symbol, [int_one.copy(), int_op]), one.copy())
assert assignment.is_array_range is True