diff --git a/CHANGELOG.md b/CHANGELOG.md index de3e040d3f..e6d1eec6dc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,21 @@ All notable changes to this project will be documented in this file. ### Added +### Fixed + +- #1499 : Fix passing temporary arrays to functions. +- #1241 : Missing transpose when converting from a C-ordered array to F-ordered array. +- #1241 : Incorrect transpose when copying an F-ordered array. +- #1241 : Fix infinite loop when passing an array as the only argument to `np.array`. + +### Changed + +### Deprecated + +## \[1.9.0\] - 2023-08-22 + +### Added + - #752 : Allow passing array variables to `numpy.array`. - #1280 : Allow copying arrays using `numpy.array`. - Allow interfaces in classes. @@ -18,8 +33,8 @@ All notable changes to this project will be documented in this file. - #682 : Wrong data layout when copying a slice of an array. - #1453 : Fix error-level developer mode output. -- #1499 : Fix passing temporary arrays to functions. - \[INTERNALS\] Fix string base class selection. +- #1496 : Fix interfaces which differ only by order or rank. ### Changed diff --git a/pyccel/ast/numpyext.py b/pyccel/ast/numpyext.py index 1a909495f0..5afeddf008 100644 --- a/pyccel/ast/numpyext.py +++ b/pyccel/ast/numpyext.py @@ -502,12 +502,9 @@ def _process_order(rank, order): return order #============================================================================== -# TODO [YG, 18.02.2020]: accept Numpy array argument -# TODO [YG, 18.02.2020]: use order='K' as default, like in numpy.array -# TODO [YG, 22.05.2020]: move dtype & prec processing to __init__ class NumpyArray(NumpyNewArray): """ - Represents a call to numpy.array for code generation. + Represents a call to `numpy.array` for code generation. A class representing a call to the NumPy `array` function. @@ -521,12 +518,16 @@ class NumpyArray(NumpyNewArray): order : str The ordering of the array (C/Fortran). + + ndmin : LiteralInteger, int, optional + The minimum number of dimensions that the resulting array should + have. """ __slots__ = ('_arg','_dtype','_precision','_shape','_rank','_order') _attribute_nodes = ('_arg',) name = 'array' - def __init__(self, arg, dtype=None, order='C'): + def __init__(self, arg, dtype=None, order='K', ndmin=None): if not isinstance(arg, (PythonTuple, PythonList, Variable)): raise TypeError('Unknown type of %s.' % type(arg)) @@ -538,6 +539,17 @@ def __init__(self, arg, dtype=None, order='C'): if not (is_homogeneous_tuple or is_array): raise TypeError('we only accept homogeneous arguments') + if not isinstance(order, (LiteralString, str)): + raise TypeError("The order must be specified explicitly with a string.") + elif isinstance(order, LiteralString): + order = order.python_value + + if ndmin is not None: + if not isinstance(ndmin, (LiteralInteger, int)): + raise TypeError("The minimum number of dimensions must be specified explicitly with an integer.") + elif isinstance(ndmin, LiteralInteger): + ndmin = ndmin.python_value + init_dtype = dtype # Verify dtype and get precision @@ -546,12 +558,14 @@ def __init__(self, arg, dtype=None, order='C'): prec = get_final_precision(arg) else: dtype, prec = process_dtype(dtype) - # ... Determine ordering - order = str(order).strip("\'") shape = process_shape(False, arg.shape) rank = len(shape) + if ndmin and ndmin>rank: + shape = (LiteralInteger(1),)*(ndmin-rank) + shape + rank = ndmin + if rank < 2: order = None else: @@ -561,9 +575,8 @@ def __init__(self, arg, dtype=None, order='C'): if order not in ('K', 'A', 'C', 'F'): raise ValueError(f"Cannot recognize '{order}' order") - # TODO [YG, 18.02.2020]: set correct order based on input array if order in ('K', 'A'): - order = 'C' + order = arg.order or 'C' # ... self._arg = arg diff --git a/pyccel/codegen/printing/fcode.py b/pyccel/codegen/printing/fcode.py index e6935c0cff..dc831d2c8a 100644 --- a/pyccel/codegen/printing/fcode.py +++ b/pyccel/codegen/printing/fcode.py @@ -1075,50 +1075,49 @@ def _print_NumpyWhere(self, expr): return stmt def _print_NumpyArray(self, expr): - """Fortran print.""" - + expr_args = (expr.arg,) if isinstance(expr.arg, Variable) else expr.arg + order = expr.order # If Numpy array is stored with column-major ordering, transpose values # use reshape with order for rank > 2 - if expr.order == 'F': - if expr.rank == 2: - rhs_code = self._print(expr.arg) - rhs_code = 'transpose({})'.format(rhs_code) - elif expr.rank > 2: - args = [self._print(a) for a in expr.arg] - new_args = [] - for ac, a in zip(args, expr.arg): - if a.order == 'C': - shape = ', '.join(self._print(i) for i in a.shape) - order = ', '.join(self._print(LiteralInteger(i)) for i in range(a.rank, 0, -1)) - ac = 'reshape({}, [{}], order=[{}])'.format(ac, shape, order) - new_args.append(ac) - - args = new_args - rhs_code = '[' + ' ,'.join(args) + ']' - shape = ', '.join(self._print(i) for i in expr.shape) - order = [LiteralInteger(i) for i in range(1, expr.rank+1)] - order = order[1:]+ order[:1] - order = ', '.join(self._print(i) for i in order) - rhs_code = 'reshape({}, [{}], order=[{}])'.format(rhs_code, shape, order) - elif expr.order == 'C': - if expr.rank > 2: - args = [self._print(a) for a in expr.arg] - new_args = [] - for ac, a in zip(args, expr.arg): - if a.order == 'F': - shape = ', '.join(self._print(i) for i in a.shape[::-1]) - order = ', '.join(self._print(LiteralInteger(i)) for i in range(a.rank, 0, -1)) - ac = 'reshape({}, [{}], order=[{}])'.format(ac, shape, order) - new_args.append(ac) - - args = new_args - rhs_code = '[' + ' ,'.join(args) + ']' - shape = ', '.join(self._print(i) for i in expr.shape[::-1]) - rhs_code = 'reshape({}, [{}])'.format(rhs_code, shape) - else: - rhs_code = self._print(expr.arg) - elif expr.order is None: + if expr.rank <= 2: rhs_code = self._print(expr.arg) + if expr.arg.order and expr.arg.order != expr.order: + rhs_code = f'transpose({rhs_code})' + if expr.arg.rank < expr.rank: + if order == 'F': + shape_code = ', '.join(self._print(i) for i in expr.shape) + else: + shape_code = ', '.join(self._print(i) for i in expr.shape[::-1]) + rhs_code = f"reshape({rhs_code}, [{shape_code}])" + else: + new_args = [] + inv_order = 'C' if order == 'F' else 'F' + for a in expr_args: + ac = self._print(a) + if a.order == inv_order: + shape = a.shape if a.order == 'C' else a.shape[::-1] + shape_code = ', '.join(self._print(i) for i in shape) + order_code = ', '.join(self._print(LiteralInteger(i)) for i in range(a.rank, 0, -1)) + ac = f'reshape({ac}, [{shape_code}], order=[{order_code}])' + new_args.append(ac) + + if len(new_args) == 1: + rhs_code = new_args[0] + else: + rhs_code = '[' + ' ,'.join(new_args) + ']' + + if len(new_args) != 1 or expr.arg.rank < expr.rank: + if order == 'C': + shape_code = ', '.join(self._print(i) for i in expr.shape[::-1]) + rhs_code = f'reshape({rhs_code}, [{shape_code}])' + else: + shape_code = ', '.join(self._print(i) for i in expr.shape) + order_index = [LiteralInteger(i) for i in range(1, expr.rank+1)] + order_index = order_index[1:]+ order_index[:1] + order_code = ', '.join(self._print(i) for i in order_index) + rhs_code = f'reshape({rhs_code}, [{shape_code}], order=[{order_code}])' + + return rhs_code def _print_NumpyFloor(self, expr): diff --git a/pyccel/codegen/printing/pycode.py b/pyccel/codegen/printing/pycode.py index 4daeb041ad..e461c4fdc5 100644 --- a/pyccel/codegen/printing/pycode.py +++ b/pyccel/codegen/printing/pycode.py @@ -704,11 +704,13 @@ def _print_Deallocate(self, expr): def _print_NumpyArray(self, expr): name = self._get_numpy_name(expr) + arg_var = expr.arg - arg = self._print(expr.arg) + arg = self._print(arg_var) dtype = self._print_dtype_argument(expr, expr.init_dtype) order = f"order='{expr.order}'" if expr.order else '' - args = ', '.join(a for a in [arg, dtype, order] if a!= '') + ndmin = f"ndmin={expr.rank}" if expr.rank > arg_var.rank else '' + args = ', '.join(a for a in [arg, dtype, order, ndmin] if a!= '') return f"{name}({args})" def _print_NumpyAutoFill(self, expr): diff --git a/tests/epyccel/modules/arrays.py b/tests/epyccel/modules/arrays.py index ea47a7953d..3330838132 100644 --- a/tests/epyccel/modules/arrays.py +++ b/tests/epyccel/modules/arrays.py @@ -650,6 +650,33 @@ def multiple_2d_stack_array_2(): s = s + b[i][j] - a[j] / c[i][j] return s +#============================================================================== +# TEST: Array with ndmin argument +#============================================================================== +@template('T', ['int[:]', 'int[:,:]', 'int[:,:,:]', 'int[:,:](order=F)', 'int[:,:,:](order=F)']) +def array_ndmin_1(x : 'T'): + from numpy import array + y = array(x, ndmin=1) + return y + +@template('T', ['int[:]', 'int[:,:]', 'int[:,:,:]', 'int[:,:](order=F)', 'int[:,:,:](order=F)']) +def array_ndmin_2(x : 'T'): + from numpy import array + y = array(x, ndmin=2) + return y + +@template('T', ['int[:]', 'int[:,:]', 'int[:,:,:]', 'int[:,:](order=F)', 'int[:,:,:](order=F)']) +def array_ndmin_4(x : 'T'): + from numpy import array + y = array(x, ndmin=4) + return y + +@template('T', ['int[:]', 'int[:,:]', 'int[:,:,:]', 'int[:,:](order=F)', 'int[:,:,:](order=F)']) +def array_ndmin_2_order(x : 'T'): + from numpy import array + y = array(x, ndmin=2, order='F') + return y + #============================================================================== # TEST: Product and matrix multiplication #============================================================================== @@ -1602,6 +1629,7 @@ def arrs_2d_different_shapes_0(): pm = np.array([[1, 1, 1]]) x = pn + pm return np.shape(x)[0], np.shape(x)[1] + def arrs_1d_negative_index_1(): import numpy as np a = np.zeros(10) diff --git a/tests/epyccel/test_arrays.py b/tests/epyccel/test_arrays.py index 0df06b3903..c12abd280e 100644 --- a/tests/epyccel/test_arrays.py +++ b/tests/epyccel/test_arrays.py @@ -7,6 +7,17 @@ from pyccel.epyccel import epyccel from modules import arrays +def check_array_equal(a, b): + """ + Check that two arrays are equal. + + Check that two arrays are equal. To be equal they must have the same + shape, dtype, and order. + """ + assert np.array_equal(a, b) + assert a.dtype is b.dtype + assert a.flags.c_contiguous == b.flags.c_contiguous + assert a.flags.f_contiguous == b.flags.f_contiguous #============================================================================== # TEST: VERIFY ARRAY'S DTYPE CORRESPONDENCE TO THE PASSED ELEMENTS #============================================================================== @@ -286,21 +297,21 @@ def test_array_int_1d_initialization_1(language): f1 = arrays.array_int_1d_initialization_1 f2 = epyccel( f1 , language = language) - assert np.array_equal(f1(), f2()) + assert f1() == f2() def test_array_int_1d_initialization_2(language): f1 = arrays.array_int_1d_initialization_2 f2 = epyccel( f1 , language = language) - assert np.array_equal(f1(), f2()) + assert f1() == f2() def test_array_int_1d_initialization_3(language): f1 = arrays.array_int_1d_initialization_3 f2 = epyccel( f1 , language = language) - assert np.array_equal(f1(), f2()) + assert f1() == f2() #============================================================================== # TEST: 2D ARRAYS OF INT-32 WITH C ORDERING @@ -2073,47 +2084,47 @@ def test_multiple_negative_index(language): f1 = arrays.test_multiple_negative_index f2 = epyccel(f1, language = language) - assert np.array_equal(f1(-2, -1), f2(-2, -1)) + assert f1(-2, -1) == f2(-2, -1) def test_multiple_negative_index_2(language): f1 = arrays.test_multiple_negative_index_2 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(-4, -2), f2(-4, -2)) + assert f1(-4, -2) == f2(-4, -2) def test_multiple_negative_index_3(language): f1 = arrays.test_multiple_negative_index_3 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(-1, -1, -3), f2(-1, -1, -3)) + assert f1(-1, -1, -3) == f2(-1, -1, -3) def test_argument_negative_index_1(language): a = arrays.a_1d f1 = arrays.test_argument_negative_index_1 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_argument_negative_index_2(language): a = arrays.a_1d f1 = arrays.test_argument_negative_index_2 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a, a), f2(a, a)) + assert f1(a, a) == f2(a, a) def test_c_order_argument_negative_index(language): a = np.random.randint(20, size=(3,4)) f1 = arrays.test_c_order_argument_negative_index f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a, a), f2(a, a)) + assert f1(a, a) == f2(a, a) def test_f_order_argument_negative_index(language): a = np.array(np.random.randint(20, size=(3,4)), order='F') f1 = arrays.test_f_order_argument_negative_index f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a, a), f2(a, a)) + assert f1(a, a) == f2(a, a) #============================================================================== # TEST: shape initialisation @@ -2151,7 +2162,7 @@ def test_array_1d_slice_1(language): f1 = arrays.array_1d_slice_1 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_1d_slice_2(language): a = arrays.a_1d @@ -2159,7 +2170,7 @@ def test_array_1d_slice_2(language): f1 = arrays.array_1d_slice_2 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_1d_slice_3(language): a = arrays.a_1d @@ -2167,7 +2178,7 @@ def test_array_1d_slice_3(language): f1 = arrays.array_1d_slice_3 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_1d_slice_4(language): a = arrays.a_1d @@ -2175,7 +2186,7 @@ def test_array_1d_slice_4(language): f1 = arrays.array_1d_slice_4 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_1d_slice_5(language): a = arrays.a_1d @@ -2183,7 +2194,7 @@ def test_array_1d_slice_5(language): f1 = arrays.array_1d_slice_5 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_1d_slice_6(language): a = arrays.a_1d @@ -2191,7 +2202,7 @@ def test_array_1d_slice_6(language): f1 = arrays.array_1d_slice_6 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_1d_slice_7(language): a = arrays.a_1d @@ -2199,7 +2210,7 @@ def test_array_1d_slice_7(language): f1 = arrays.array_1d_slice_7 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_1d_slice_8(language): a = arrays.a_1d @@ -2207,7 +2218,7 @@ def test_array_1d_slice_8(language): f1 = arrays.array_1d_slice_8 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_1d_slice_9(language): a = arrays.a_1d @@ -2215,11 +2226,11 @@ def test_array_1d_slice_9(language): f1 = arrays.array_1d_slice_9 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="array slice does not work with variable in c"), + pytest.mark.skip(reason="Array slicing does not work with negative variables in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -2230,11 +2241,11 @@ def test_array_1d_slice_10(language): f1 = arrays.array_1d_slice_10 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="array slice does not work with variable in c"), + pytest.mark.skip(reason="Array slicing does not work with negative variables in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -2245,11 +2256,11 @@ def test_array_1d_slice_11(language): f1 = arrays.array_1d_slice_11 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="array slice does not work with variable in c"), + pytest.mark.skip(reason="Array slicing does not work with negative variables in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -2260,7 +2271,7 @@ def test_array_1d_slice_12(language): f1 = arrays.array_1d_slice_12 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) #============================================================================== # TEST : 2d array slices order F @@ -2271,144 +2282,144 @@ def test_array_2d_F_slice_1(language): f1 = arrays.array_2d_F_slice_1 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_F_slice_2(language): a = arrays.a_2d_f f1 = arrays.array_2d_F_slice_2 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_F_slice_3(language): a = arrays.a_2d_f f1 = arrays.array_2d_F_slice_3 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_F_slice_4(language): a = arrays.a_2d_f f1 = arrays.array_2d_F_slice_4 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_F_slice_5(language): a = arrays.a_2d_f f1 = arrays.array_2d_F_slice_5 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_F_slice_6(language): a = arrays.a_2d_f f1 = arrays.array_2d_F_slice_6 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_F_slice_7(language): a = arrays.a_2d_f f1 = arrays.array_2d_F_slice_7 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_F_slice_8(language): a = arrays.a_2d_f f1 = arrays.array_2d_F_slice_8 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_F_slice_9(language): a = arrays.a_2d_f f1 = arrays.array_2d_F_slice_9 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_F_slice_10(language): a = arrays.a_2d_f f1 = arrays.array_2d_F_slice_10 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_F_slice_11(language): a = arrays.a_2d_f f1 = arrays.array_2d_F_slice_11 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_F_slice_12(language): a = arrays.a_2d_f f1 = arrays.array_2d_F_slice_12 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_F_slice_13(language): a = arrays.a_2d_f f1 = arrays.array_2d_F_slice_13 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_F_slice_14(language): a = arrays.a_2d_f f1 = arrays.array_2d_F_slice_14 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_F_slice_15(language): a = arrays.a_2d_f f1 = arrays.array_2d_F_slice_15 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_F_slice_16(language): a = arrays.a_2d_f f1 = arrays.array_2d_F_slice_16 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_F_slice_17(language): a = arrays.a_2d_f f1 = arrays.array_2d_F_slice_17 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_F_slice_18(language): a = arrays.a_2d_f f1 = arrays.array_2d_F_slice_18 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_F_slice_19(language): a = arrays.a_2d_f f1 = arrays.array_2d_F_slice_19 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_F_slice_20(language): a = arrays.a_2d_f f1 = arrays.array_2d_F_slice_20 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="array slice does not work with variable in c"), + pytest.mark.skip(reason="Array slicing does not work with negative variables in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -2418,11 +2429,11 @@ def test_array_2d_F_slice_21(language): f1 = arrays.array_2d_F_slice_21 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="array slice does not work with variable in c"), + pytest.mark.skip(reason="Array slicing does not work with negative variables in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -2432,11 +2443,11 @@ def test_array_2d_F_slice_22(language): f1 = arrays.array_2d_F_slice_22 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="array slice does not work with variable in c"), + pytest.mark.skip(reason="Array slicing does not work with negative variables in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -2446,7 +2457,7 @@ def test_array_2d_F_slice_23(language): f1 = arrays.array_2d_F_slice_23 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) #============================================================================== # TEST : 2d array slices order C @@ -2458,145 +2469,144 @@ def test_array_2d_C_slice_1(language): f1 = arrays.array_2d_C_slice_1 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_C_slice_2(language): a = arrays.a_2d_c f1 = arrays.array_2d_C_slice_2 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_C_slice_3(language): a = arrays.a_2d_c f1 = arrays.array_2d_C_slice_3 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_C_slice_4(language): a = arrays.a_2d_c f1 = arrays.array_2d_C_slice_4 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_C_slice_5(language): a = arrays.a_2d_c f1 = arrays.array_2d_C_slice_5 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_C_slice_6(language): a = arrays.a_2d_c f1 = arrays.array_2d_C_slice_6 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_C_slice_7(language): a = arrays.a_2d_c f1 = arrays.array_2d_C_slice_7 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) - + assert f1(a) == f2(a) def test_array_2d_C_slice_8(language): a = arrays.a_2d_c f1 = arrays.array_2d_C_slice_8 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_C_slice_9(language): a = arrays.a_2d_c f1 = arrays.array_2d_C_slice_9 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_C_slice_10(language): a = arrays.a_2d_c f1 = arrays.array_2d_C_slice_10 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_C_slice_11(language): a = arrays.a_2d_c f1 = arrays.array_2d_C_slice_11 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_C_slice_12(language): a = arrays.a_2d_c f1 = arrays.array_2d_C_slice_12 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_C_slice_13(language): a = arrays.a_2d_c f1 = arrays.array_2d_C_slice_13 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_C_slice_14(language): a = arrays.a_2d_c f1 = arrays.array_2d_C_slice_14 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_C_slice_15(language): a = arrays.a_2d_c f1 = arrays.array_2d_C_slice_15 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_C_slice_16(language): a = arrays.a_2d_c f1 = arrays.array_2d_C_slice_16 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_C_slice_17(language): a = arrays.a_2d_c f1 = arrays.array_2d_C_slice_17 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_C_slice_18(language): a = arrays.a_2d_c f1 = arrays.array_2d_C_slice_18 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_C_slice_19(language): a = arrays.a_2d_c f1 = arrays.array_2d_C_slice_19 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_C_slice_20(language): a = arrays.a_2d_c f1 = arrays.array_2d_C_slice_20 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="array slice does not work with variable in c"), + pytest.mark.skip(reason="Array slicing does not work with negative variables in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -2606,11 +2616,11 @@ def test_array_2d_C_slice_21(language): f1 = arrays.array_2d_C_slice_21 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="array slice does not work with variable in c"), + pytest.mark.skip(reason="Array slicing does not work with negative variables in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -2620,11 +2630,11 @@ def test_array_2d_C_slice_22(language): f1 = arrays.array_2d_C_slice_22 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="array slice does not work with variable in c"), + pytest.mark.skip(reason="Array slicing does not work with negative variables in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -2634,7 +2644,7 @@ def test_array_2d_C_slice_23(language): f1 = arrays.array_2d_C_slice_23 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) #============================================================================== # TEST : 1d array slices stride @@ -2645,12 +2655,12 @@ def test_array_1d_slice_stride_1(language): f1 = arrays.array_1d_slice_stride_1 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -2660,7 +2670,7 @@ def test_array_1d_slice_stride_2(language): f1 = arrays.array_1d_slice_stride_2 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_1d_slice_stride_3(language): @@ -2668,7 +2678,7 @@ def test_array_1d_slice_stride_3(language): f1 = arrays.array_1d_slice_stride_3 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_1d_slice_stride_4(language): @@ -2676,7 +2686,7 @@ def test_array_1d_slice_stride_4(language): f1 = arrays.array_1d_slice_stride_4 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_1d_slice_stride_5(language): @@ -2684,12 +2694,12 @@ def test_array_1d_slice_stride_5(language): f1 = arrays.array_1d_slice_stride_5 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -2699,7 +2709,7 @@ def test_array_1d_slice_stride_6(language): f1 = arrays.array_1d_slice_stride_6 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_1d_slice_stride_7(language): @@ -2707,12 +2717,12 @@ def test_array_1d_slice_stride_7(language): f1 = arrays.array_1d_slice_stride_7 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -2722,19 +2732,19 @@ def test_array_1d_slice_stride_8(language): f1 = arrays.array_1d_slice_stride_8 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_1d_slice_stride_9(language): a = arrays.a_1d f1 = arrays.array_1d_slice_stride_9 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -2744,19 +2754,19 @@ def test_array_1d_slice_stride_10(language): f1 = arrays.array_1d_slice_stride_10 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_1d_slice_stride_11(language): a = arrays.a_1d f1 = arrays.array_1d_slice_stride_11 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -2766,18 +2776,18 @@ def test_array_1d_slice_stride_12(language): f1 = arrays.array_1d_slice_stride_12 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_1d_slice_stride_13(language): a = arrays.a_1d f1 = arrays.array_1d_slice_stride_13 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -2787,12 +2797,12 @@ def test_array_1d_slice_stride_14(language): f1 = arrays.array_1d_slice_stride_14 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -2802,18 +2812,18 @@ def test_array_1d_slice_stride_15(language): f1 = arrays.array_1d_slice_stride_15 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_1d_slice_stride_16(language): a = arrays.a_1d f1 = arrays.array_1d_slice_stride_16 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -2823,11 +2833,11 @@ def test_array_1d_slice_stride_17(language): f1 = arrays.array_1d_slice_stride_17 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -2837,18 +2847,18 @@ def test_array_1d_slice_stride_18(language): f1 = arrays.array_1d_slice_stride_18 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_1d_slice_stride_19(language): a = arrays.a_1d f1 = arrays.array_1d_slice_stride_19 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -2858,11 +2868,11 @@ def test_array_1d_slice_stride_20(language): f1 = arrays.array_1d_slice_stride_20 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -2872,21 +2882,21 @@ def test_array_1d_slice_stride_21(language): f1 = arrays.array_1d_slice_stride_21 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_1d_slice_stride_22(language): a = arrays.a_1d f1 = arrays.array_1d_slice_stride_22 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_1d_slice_stride_23(language): a = arrays.a_1d f1 = arrays.array_1d_slice_stride_23 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) #============================================================================== # TEST : 2d array slices stride order F @@ -2897,11 +2907,11 @@ def test_array_2d_F_slice_stride_1(language): f1 = arrays.array_2d_F_slice_stride_1 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -2911,11 +2921,11 @@ def test_array_2d_F_slice_stride_2(language): f1 = arrays.array_2d_F_slice_stride_2 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -2925,35 +2935,35 @@ def test_array_2d_F_slice_stride_3(language): f1 = arrays.array_2d_F_slice_stride_3 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_F_slice_stride_4(language): a = arrays.a_2d_f f1 = arrays.array_2d_F_slice_stride_4 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_F_slice_stride_5(language): a = arrays.a_2d_f f1 = arrays.array_2d_F_slice_stride_5 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_F_slice_stride_6(language): a = arrays.a_2d_f f1 = arrays.array_2d_F_slice_stride_6 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_F_slice_stride_7(language): a = arrays.a_2d_f f1 = arrays.array_2d_F_slice_stride_7 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_F_slice_stride_8(language): @@ -2961,18 +2971,18 @@ def test_array_2d_F_slice_stride_8(language): f1 = arrays.array_2d_F_slice_stride_8 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_F_slice_stride_9(language): a = arrays.a_2d_f f1 = arrays.array_2d_F_slice_stride_9 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -2982,11 +2992,11 @@ def test_array_2d_F_slice_stride_10(language): f1 = arrays.array_2d_F_slice_stride_10 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -2996,11 +3006,11 @@ def test_array_2d_F_slice_stride_11(language): f1 = arrays.array_2d_F_slice_stride_11 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3010,11 +3020,11 @@ def test_array_2d_F_slice_stride_12(language): f1 = arrays.array_2d_F_slice_stride_12 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3024,11 +3034,11 @@ def test_array_2d_F_slice_stride_13(language): f1 = arrays.array_2d_F_slice_stride_13 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3038,11 +3048,11 @@ def test_array_2d_F_slice_stride_14(language): f1 = arrays.array_2d_F_slice_stride_14 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3052,11 +3062,11 @@ def test_array_2d_F_slice_stride_15(language): f1 = arrays.array_2d_F_slice_stride_15 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3066,11 +3076,11 @@ def test_array_2d_F_slice_stride_16(language): f1 = arrays.array_2d_F_slice_stride_16 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3080,11 +3090,11 @@ def test_array_2d_F_slice_stride_17(language): f1 = arrays.array_2d_F_slice_stride_17 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3094,11 +3104,11 @@ def test_array_2d_F_slice_stride_18(language): f1 = arrays.array_2d_F_slice_stride_18 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3108,11 +3118,11 @@ def test_array_2d_F_slice_stride_19(language): f1 = arrays.array_2d_F_slice_stride_19 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3122,12 +3132,12 @@ def test_array_2d_F_slice_stride_20(language): f1 = arrays.array_2d_F_slice_stride_20 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3137,11 +3147,11 @@ def test_array_2d_F_slice_stride_21(language): f1 = arrays.array_2d_F_slice_stride_21 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3151,11 +3161,11 @@ def test_array_2d_F_slice_stride_22(language): f1 = arrays.array_2d_F_slice_stride_22 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3165,7 +3175,7 @@ def test_array_2d_F_slice_stride_23(language): f1 = arrays.array_2d_F_slice_stride_23 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) #============================================================================== # TEST : 2d array slices stride order C @@ -3176,11 +3186,11 @@ def test_array_2d_C_slice_stride_1(language): f1 = arrays.array_2d_C_slice_stride_1 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3190,11 +3200,11 @@ def test_array_2d_C_slice_stride_2(language): f1 = arrays.array_2d_C_slice_stride_2 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3204,18 +3214,18 @@ def test_array_2d_C_slice_stride_3(language): f1 = arrays.array_2d_C_slice_stride_3 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_C_slice_stride_4(language): a = arrays.a_2d_c f1 = arrays.array_2d_C_slice_stride_4 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3225,18 +3235,18 @@ def test_array_2d_C_slice_stride_5(language): f1 = arrays.array_2d_C_slice_stride_5 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_C_slice_stride_6(language): a = arrays.a_2d_c f1 = arrays.array_2d_C_slice_stride_6 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3246,7 +3256,7 @@ def test_array_2d_C_slice_stride_7(language): f1 = arrays.array_2d_C_slice_stride_7 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) def test_array_2d_C_slice_stride_8(language): @@ -3254,11 +3264,11 @@ def test_array_2d_C_slice_stride_8(language): f1 = arrays.array_2d_C_slice_stride_8 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3268,11 +3278,11 @@ def test_array_2d_C_slice_stride_9(language): f1 = arrays.array_2d_C_slice_stride_9 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3282,11 +3292,11 @@ def test_array_2d_C_slice_stride_10(language): f1 = arrays.array_2d_C_slice_stride_10 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3296,11 +3306,11 @@ def test_array_2d_C_slice_stride_11(language): f1 = arrays.array_2d_C_slice_stride_11 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3310,11 +3320,11 @@ def test_array_2d_C_slice_stride_12(language): f1 = arrays.array_2d_C_slice_stride_12 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3324,11 +3334,11 @@ def test_array_2d_C_slice_stride_13(language): f1 = arrays.array_2d_C_slice_stride_13 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3338,11 +3348,11 @@ def test_array_2d_C_slice_stride_14(language): f1 = arrays.array_2d_C_slice_stride_14 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3352,11 +3362,11 @@ def test_array_2d_C_slice_stride_15(language): f1 = arrays.array_2d_C_slice_stride_15 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3366,11 +3376,11 @@ def test_array_2d_C_slice_stride_16(language): f1 = arrays.array_2d_C_slice_stride_16 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3380,11 +3390,11 @@ def test_array_2d_C_slice_stride_17(language): f1 = arrays.array_2d_C_slice_stride_17 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3394,11 +3404,11 @@ def test_array_2d_C_slice_stride_18(language): f1 = arrays.array_2d_C_slice_stride_18 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3408,11 +3418,11 @@ def test_array_2d_C_slice_stride_19(language): f1 = arrays.array_2d_C_slice_stride_19 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3422,11 +3432,11 @@ def test_array_2d_C_slice_stride_20(language): f1 = arrays.array_2d_C_slice_stride_20 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3436,11 +3446,11 @@ def test_array_2d_C_slice_stride_21(language): f1 = arrays.array_2d_C_slice_stride_21 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3450,11 +3460,11 @@ def test_array_2d_C_slice_stride_22(language): f1 = arrays.array_2d_C_slice_stride_22 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3464,7 +3474,7 @@ def test_array_2d_C_slice_stride_23(language): f1 = arrays.array_2d_C_slice_stride_23 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + assert f1(a) == f2(a) #============================================================================== # TEST : arithmetic operations @@ -3493,16 +3503,16 @@ def test_arrs_uncertain_shape_1(language): def test_arrs_2d_similar_shapes_0(language): f1 = arrays.arrs_2d_similar_shapes_0 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(), f2()) + assert f1() == f2() def test_arrs_2d_different_shapes_0(language): f1 = arrays.arrs_2d_different_shapes_0 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(), f2()) + assert f1() == f2() @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="eppycel zero gives 0 or +inf randomly"), + pytest.mark.skip(reason="Negative start of range does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3515,21 +3525,21 @@ def test_arrs_1d_negative_index_1(language): def test_arrs_1d_negative_index_2(language): f1 = arrays.arrs_1d_negative_index_2 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(), f2()) + assert np.allclose(f1(), f2(), rtol=RTOL, atol=ATOL) def test_arrs_1d_int32_index(language): f1 = arrays.arrs_1d_int32_index f2 = epyccel(f1, language = language) - assert np.array_equal(f1(), f2()) + assert f1() == f2() def test_arrs_1d_int64_index(language): f1 = arrays.arrs_1d_int64_index f2 = epyccel(f1, language = language) - assert np.array_equal(f1(), f2()) + assert f1() == f2() @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3537,16 +3547,16 @@ def test_arrs_1d_int64_index(language): def test_arrs_1d_negative_index_negative_step(language): f1 = arrays.arrs_1d_negative_index_negative_step f2 = epyccel(f1, language = language) - assert np.array_equal(f1(), f2()) + assert np.allclose(f1(), f2(), rtol=RTOL, atol=ATOL) def test_arrs_1d_negative_step_positive_step(language): f1 = arrays.arrs_1d_negative_step_positive_step f2 = epyccel(f1, language = language) - assert np.array_equal(f1(), f2()) + assert np.allclose(f1(), f2(), rtol=RTOL, atol=ATOL) @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ - pytest.mark.skip(reason="negative step does not work in c"), + pytest.mark.skip(reason="negative step does not work in c. See #1311"), pytest.mark.c]), pytest.param("fortran", marks = pytest.mark.fortran) ] @@ -3554,7 +3564,7 @@ def test_arrs_1d_negative_step_positive_step(language): def test_arrs_2d_negative_index(language): f1 = arrays.arrs_2d_negative_index f2 = epyccel(f1, language = language) - assert np.array_equal(f1(), f2()) + assert np.allclose(f1(), f2(), rtol=RTOL, atol=ATOL) #============================================================================== # TEST : NUMPY ARANGE @@ -3565,12 +3575,12 @@ def test_arrs_2d_negative_index(language): def test_numpy_arange_one_arg(language): f1 = arrays.arr_arange_1 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(), f2()) + assert f1() == f2() def test_numpy_arange_two_arg(language): f1 = arrays.arr_arange_2 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(), f2()) + assert f1() == f2() def test_numpy_arange_full_arg(language): f1 = arrays.arr_arange_3 @@ -3585,7 +3595,7 @@ def test_numpy_arange_full_arg(language): def test_numpy_arange_with_dtype(language): f1 = arrays.arr_arange_4 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(), f2()) + assert f1() == f2() def test_numpy_arange_negative_step(language): f1 = arrays.arr_arange_5 @@ -3765,14 +3775,14 @@ def test_array_view_steps_C_1D_1(language): f1 = arrays.array_view_steps_C_1D_1 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + check_array_equal(f1(a), f2(a)) def test_array_view_steps_C_1D_2(language): a = arrays.a_1d f1 = arrays.array_view_steps_C_1D_2 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + check_array_equal(f1(a), f2(a)) ##============================================================================== ## TEST SIMPLE ARRAY SLICING WITH ORDER C 2D @@ -3783,21 +3793,21 @@ def test_array_view_steps_C_2D_1(language): f1 = arrays.array_view_steps_C_2D_1 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + check_array_equal(f1(a), f2(a)) def test_array_view_steps_C_2D_2(language): a = arrays.a_2d_c f1 = arrays.array_view_steps_C_2D_2 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + check_array_equal(f1(a), f2(a)) def test_array_view_steps_C_2D_3(language): a = arrays.a_2d_c f1 = arrays.array_view_steps_C_2D_3 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + check_array_equal(f1(a), f2(a)) ##============================================================================== ## TEST ARRAY VIEW STEPS ARRAY INITIALIZATION ORDER F 1D @@ -3808,60 +3818,144 @@ def test_array_view_steps_F_1D_1(language): f1 = arrays.array_view_steps_F_1D_1 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + check_array_equal(f1(a), f2(a)) def test_array_view_steps_F_1D_2(language): a = arrays.a_1d_f f1 = arrays.array_view_steps_F_1D_2 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + check_array_equal(f1(a), f2(a)) ##============================================================================== ## TEST ARRAY VIEW STEPS ARRAY INITIALIZATION ORDER F 2D ##============================================================================== -@pytest.mark.parametrize( 'language', [ - pytest.param("c", marks = pytest.mark.c), - pytest.param("fortran", marks = [pytest.mark.skip(reason="fortran bug, issue #1257"), - pytest.mark.fortran]) - ] -) - def test_array_view_steps_F_2D_1(language): a = arrays.a_2d_f f1 = arrays.array_view_steps_F_2D_1 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) - -@pytest.mark.parametrize( 'language', [ - pytest.param("c", marks = pytest.mark.c), - pytest.param("fortran", marks = [pytest.mark.skip(reason="fortran bug, issue #1257"), - pytest.mark.fortran]) - ] -) + check_array_equal(f1(a), f2(a)) def test_array_view_steps_F_2D_2(language): a = arrays.a_2d_f f1 = arrays.array_view_steps_F_2D_2 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) - -@pytest.mark.parametrize( 'language', [ - pytest.param("c", marks = pytest.mark.c), - pytest.param("fortran", marks = [pytest.mark.skip(reason="fortran bug, issue #1257"), - pytest.mark.fortran]) - ] -) + check_array_equal(f1(a), f2(a)) def test_array_view_steps_F_2D_3(language): a = arrays.a_2d_f f1 = arrays.array_view_steps_F_2D_3 f2 = epyccel(f1, language = language) - assert np.array_equal(f1(a), f2(a)) + check_array_equal(f1(a), f2(a)) + +#============================================================================== +# TEST: Array with ndmin argument +#============================================================================== + +@pytest.mark.parametrize( 'language', ( + pytest.param("fortran", marks = pytest.mark.fortran), + pytest.param("c", marks = pytest.mark.c), + pytest.param("python", marks = [ + pytest.mark.skip(reason=("Template results in wrong ordered arrays")), + pytest.mark.python] + ) + ) +) +def test_array_ndmin_1(language): + f1 = arrays.array_ndmin_1 + f2 = epyccel(f1, language = language) + + a = arrays.a_1d + b = arrays.a_2d_c + c = arrays.a_2d_c + d = randint(low = iinfo(int).min, high = iinfo(int).max, dtype=int, size=(2,3,4)) + e = d.copy(order='F') + + check_array_equal(f1(a), f2(a)) + check_array_equal(f1(b), f2(b)) + check_array_equal(f1(c), f2(c)) + check_array_equal(f1(d), f2(d)) + check_array_equal(f1(e), f2(e)) + +@pytest.mark.parametrize( 'language', ( + pytest.param("fortran", marks = pytest.mark.fortran), + pytest.param("c", marks = pytest.mark.c), + pytest.param("python", marks = [ + pytest.mark.skip(reason=("Template results in wrong ordered arrays")), + pytest.mark.python] + ) + ) +) +def test_array_ndmin_2(language): + f1 = arrays.array_ndmin_2 + f2 = epyccel(f1, language = language) + + a = arrays.a_1d + b = arrays.a_2d_c + c = arrays.a_2d_c + d = randint(low = iinfo(int).min, high = iinfo(int).max, dtype=int, size=(2,3,4)) + e = d.copy(order='F') + + check_array_equal(f1(a), f2(a)) + check_array_equal(f1(b), f2(b)) + check_array_equal(f1(c), f2(c)) + check_array_equal(f1(d), f2(d)) + check_array_equal(f1(e), f2(e)) + +@pytest.mark.parametrize( 'language', ( + pytest.param("fortran", marks = pytest.mark.fortran), + pytest.param("c", marks = pytest.mark.c), + pytest.param("python", marks = [ + pytest.mark.skip(reason=("Template results in wrong ordered arrays")), + pytest.mark.python] + ) + ) +) +def test_array_ndmin_4(language): + f1 = arrays.array_ndmin_4 + f2 = epyccel(f1, language = language) + + a = arrays.a_1d + b = arrays.a_2d_c + c = arrays.a_2d_c + d = randint(low = iinfo(int).min, high = iinfo(int).max, dtype=int, size=(2,3,4)) + e = d.copy(order='F') + + check_array_equal(f1(a), f2(a)) + check_array_equal(f1(b), f2(b)) + check_array_equal(f1(c), f2(c)) + check_array_equal(f1(d), f2(d)) + check_array_equal(f1(e), f2(e)) + +@pytest.mark.parametrize( 'language', ( + pytest.param("fortran", marks = pytest.mark.fortran), + pytest.param("c", marks = pytest.mark.c), + pytest.param("python", marks = [ + pytest.mark.skip(reason=("Template results in wrong ordered arrays")), + pytest.mark.python] + ) + ) +) +def test_array_ndmin_2_order(language): + f1 = arrays.array_ndmin_2_order + f2 = epyccel(f1, language = language) + + a = arrays.a_1d + b = arrays.a_2d_c + c = arrays.a_2d_c + d = randint(low = iinfo(int).min, high = iinfo(int).max, dtype=int, size=(2,3,4)) + e = d.copy(order='F') + + check_array_equal(f1(a), f2(a)) + check_array_equal(f1(b), f2(b)) + check_array_equal(f1(c), f2(c)) + check_array_equal(f1(d), f2(d)) + check_array_equal(f1(e), f2(e)) + #def teardown_module(): # import os, glob diff --git a/tests/epyccel/test_epyccel_return_arrays.py b/tests/epyccel/test_epyccel_return_arrays.py index 325bec7576..80b2666852 100644 --- a/tests/epyccel/test_epyccel_return_arrays.py +++ b/tests/epyccel/test_epyccel_return_arrays.py @@ -778,3 +778,123 @@ def return_f_array(b : 'T'): assert np.array_equal(f_output, test_output) assert f_output.flags.c_contiguous == test_output.flags.c_contiguous assert f_output.flags.f_contiguous == test_output.flags.f_contiguous + +def test_copy_f_to_f(language): + @template('T', ['float[:,:,:](order=F)', 'float[:,:](order=F)']) + def copy_f_to_f(b : 'T'): + from numpy import array + a = array(b, order='F') + return a + + epyccel_func = epyccel(copy_f_to_f, language=language) + fl_3d = np.array(uniform(min_float / 2, max_float / 2, (2,3,4)), order='F') + fl_2d = np.array(uniform(min_float / 2, max_float / 2, (3,4)), order='F') + + for fl in (fl_2d, fl_3d): + pyth_out = copy_f_to_f(fl) + pycc_out = epyccel_func(fl) + + assert np.array_equal(pyth_out, pycc_out) + assert pyth_out.dtype is pycc_out.dtype + assert pyth_out.flags.c_contiguous == pycc_out.flags.c_contiguous + assert pyth_out.flags.f_contiguous == pycc_out.flags.f_contiguous + +def test_copy_f_to_c(language): + @template('T', ['float[:,:,:](order=F)', 'float[:,:](order=F)']) + def copy_f_to_c(b : 'T'): + from numpy import array + a = array(b, order='C') + return a + + epyccel_func = epyccel(copy_f_to_c, language=language) + fl_3d = np.array(uniform(min_float / 2, max_float / 2, (2,3,4)), order='F') + fl_2d = np.array(uniform(min_float / 2, max_float / 2, (3,4)), order='F') + + for fl in (fl_2d, fl_3d): + pyth_out = copy_f_to_c(fl) + pycc_out = epyccel_func(fl) + + assert np.array_equal(pyth_out, pycc_out) + assert pyth_out.dtype is pycc_out.dtype + assert pyth_out.flags.c_contiguous == pycc_out.flags.c_contiguous + assert pyth_out.flags.f_contiguous == pycc_out.flags.f_contiguous + +def test_copy_c_to_c(language): + @template('T', ['float[:,:,:](order=C)', 'float[:,:](order=C)']) + def copy_c_to_c(b : 'T'): + from numpy import array + a = array(b, order='C') + return a + + epyccel_func = epyccel(copy_c_to_c, language=language) + fl_3d = uniform(min_float / 2, max_float / 2, (2,3,4)) + fl_2d = uniform(min_float / 2, max_float / 2, (3,4)) + + for fl in (fl_2d, fl_3d): + pyth_out = copy_c_to_c(fl) + pycc_out = epyccel_func(fl) + + assert np.array_equal(pyth_out, pycc_out) + assert pyth_out.dtype is pycc_out.dtype + assert pyth_out.flags.c_contiguous == pycc_out.flags.c_contiguous + assert pyth_out.flags.f_contiguous == pycc_out.flags.f_contiguous + +def test_copy_c_to_f(language): + @template('T', ['float[:,:,:](order=C)', 'float[:,:](order=C)']) + def copy_c_to_f(b : 'T'): + from numpy import array + a = array(b, order='F') + return a + + epyccel_func = epyccel(copy_c_to_f, language=language) + fl_3d = uniform(min_float / 2, max_float / 2, (2,3,4)) + fl_2d = uniform(min_float / 2, max_float / 2, (3,4)) + + for fl in (fl_2d, fl_3d): + pyth_out = copy_c_to_f(fl) + pycc_out = epyccel_func(fl) + + assert np.array_equal(pyth_out, pycc_out) + assert pyth_out.dtype is pycc_out.dtype + assert pyth_out.flags.c_contiguous == pycc_out.flags.c_contiguous + assert pyth_out.flags.f_contiguous == pycc_out.flags.f_contiguous + +def test_copy_c_to_default(language): + @template('T', ['float[:,:,:](order=C)', 'float[:,:](order=C)']) + def copy_c_to_default(b : 'T'): + from numpy import array + a = array(b) + return a + + epyccel_func = epyccel(copy_c_to_default, language=language) + fl_3d = uniform(min_float / 2, max_float / 2, (2,3,4)) + fl_2d = uniform(min_float / 2, max_float / 2, (3,4)) + + for fl in (fl_2d, fl_3d): + pyth_out = copy_c_to_default(fl) + pycc_out = epyccel_func(fl) + + assert np.array_equal(pyth_out, pycc_out) + assert pyth_out.dtype is pycc_out.dtype + assert pyth_out.flags.c_contiguous == pycc_out.flags.c_contiguous + assert pyth_out.flags.f_contiguous == pycc_out.flags.f_contiguous + +def test_copy_f_to_default(language): + @template('T', ['float[:,:,:](order=F)', 'float[:,:](order=F)']) + def copy_f_to_default(b : 'T'): + from numpy import array + a = array(b) + return a + + epyccel_func = epyccel(copy_f_to_default, language=language) + fl_3d = np.array(uniform(min_float / 2, max_float / 2, (2,3,4)), order='F') + fl_2d = np.array(uniform(min_float / 2, max_float / 2, (3,4)), order='F') + + for fl in (fl_2d, fl_3d): + pyth_out = copy_f_to_default(fl) + pycc_out = epyccel_func(fl) + + assert np.array_equal(pyth_out, pycc_out) + assert pyth_out.dtype is pycc_out.dtype + assert pyth_out.flags.c_contiguous == pycc_out.flags.c_contiguous + assert pyth_out.flags.f_contiguous == pycc_out.flags.f_contiguous