# # Copyright (c) 2017 Intel Corporation # SPDX-License-Identifier: BSD-2-Clause # import numpy as np from contextlib import contextmanager import numba from numba import njit, stencil from numba.core import types, registry from numba.core.compiler import compile_extra, Flags from numba.core.cpu import ParallelOptions from numba.tests.support import skip_parfors_unsupported, _32bit from numba.core.errors import LoweringError, TypingError, NumbaValueError import unittest skip_unsupported = skip_parfors_unsupported @stencil def stencil1_kernel(a): return 0.25 * (a[0, 1] + a[1, 0] + a[0, -1] + a[-1, 0]) @stencil(neighborhood=((-5, 0), )) def stencil2_kernel(a): cum = a[-5] for i in range(-4, 1): cum += a[i] return 0.3 * cum @stencil(cval=1.0) def stencil3_kernel(a): return 0.25 * a[-2, 2] @stencil def stencil_multiple_input_kernel(a, b): return 0.25 * (a[0, 1] + a[1, 0] + a[0, -1] + a[-1, 0] + b[0, 1] + b[1, 0] + b[0, -1] + b[-1, 0]) @stencil def stencil_multiple_input_kernel_var(a, b, w): return w * (a[0, 1] + a[1, 0] + a[0, -1] + a[-1, 0] + b[0, 1] + b[1, 0] + b[0, -1] + b[-1, 0]) @stencil def stencil_multiple_input_mixed_types_2d(a, b, f): return a[0, 0] if f[0, 0] else b[0, 0] @stencil(standard_indexing=("b",)) def stencil_with_standard_indexing_1d(a, b): return a[-1] * b[0] + a[0] * b[1] @stencil(standard_indexing=("b",)) def stencil_with_standard_indexing_2d(a, b): return (a[0, 1] * b[0, 1] + a[1, 0] * b[1, 0] + a[0, -1] * b[0, -1] + a[-1, 0] * b[-1, 0]) @njit def addone_njit(a): return a + 1 if not _32bit: # prevent compilation on unsupported 32bit targets @njit(parallel=True) def addone_pjit(a): return a + 1 class TestStencilBase(unittest.TestCase): _numba_parallel_test_ = False def __init__(self, *args): # flags for njit() self.cflags = Flags() self.cflags.nrt = True super(TestStencilBase, self).__init__(*args) def _compile_this(self, func, sig, flags): return compile_extra(registry.cpu_target.typing_context, registry.cpu_target.target_context, func, sig, None, flags, {}) def compile_parallel(self, func, sig, **kws): flags = Flags() flags.nrt = True options = True if not kws else kws flags.auto_parallel = ParallelOptions(options) return self._compile_this(func, sig, flags) def compile_njit(self, func, sig): return self._compile_this(func, sig, flags=self.cflags) def compile_all(self, pyfunc, *args, **kwargs): sig = tuple([numba.typeof(x) for x in args]) # compile with parallel=True cpfunc = self.compile_parallel(pyfunc, sig) # compile a standard njit of the original function cfunc = self.compile_njit(pyfunc, sig) return cfunc, cpfunc def check(self, no_stencil_func, pyfunc, *args): cfunc, cpfunc = self.compile_all(pyfunc, *args) # results without stencil macro expected = no_stencil_func(*args) # python result py_output = pyfunc(*args) # njit result njit_output = cfunc.entry_point(*args) # parfor result parfor_output = cpfunc.entry_point(*args) np.testing.assert_almost_equal(py_output, expected, decimal=3) np.testing.assert_almost_equal(njit_output, expected, decimal=3) np.testing.assert_almost_equal(parfor_output, expected, decimal=3) # make sure parfor set up scheduling self.assertIn('@do_scheduling', cpfunc.library.get_llvm_str()) class TestStencil(TestStencilBase): def __init__(self, *args, **kwargs): super(TestStencil, self).__init__(*args, **kwargs) @skip_unsupported def test_stencil1(self): """Tests whether the optional out argument to stencil calls works. """ def test_with_out(n): A = np.arange(n**2).reshape((n, n)) B = np.zeros(n**2).reshape((n, n)) B = stencil1_kernel(A, out=B) return B def test_without_out(n): A = np.arange(n**2).reshape((n, n)) B = stencil1_kernel(A) return B def test_impl_seq(n): A = np.arange(n**2).reshape((n, n)) B = np.zeros(n**2).reshape((n, n)) for i in range(1, n - 1): for j in range(1, n - 1): B[i, j] = 0.25 * (A[i, j + 1] + A[i + 1, j] + A[i, j - 1] + A[i - 1, j]) return B n = 100 self.check(test_impl_seq, test_with_out, n) self.check(test_impl_seq, test_without_out, n) @skip_unsupported def test_stencil2(self): """Tests whether the optional neighborhood argument to the stencil decorate works. """ def test_seq(n): A = np.arange(n) B = stencil2_kernel(A) return B def test_impl_seq(n): A = np.arange(n) B = np.zeros(n) for i in range(5, len(A)): B[i] = 0.3 * sum(A[i - 5:i + 1]) return B n = 100 self.check(test_impl_seq, test_seq, n) # variable length neighborhood in numba.stencil call # only supported in parallel path def test_seq(n, w): A = np.arange(n) def stencil2_kernel(a, w): cum = a[-w] for i in range(-w + 1, w + 1): cum += a[i] return 0.3 * cum B = numba.stencil(stencil2_kernel, neighborhood=((-w, w), ))(A, w) return B def test_impl_seq(n, w): A = np.arange(n) B = np.zeros(n) for i in range(w, len(A) - w): B[i] = 0.3 * sum(A[i - w:i + w + 1]) return B n = 100 w = 5 cpfunc = self.compile_parallel(test_seq, (types.intp, types.intp)) expected = test_impl_seq(n, w) # parfor result parfor_output = cpfunc.entry_point(n, w) np.testing.assert_almost_equal(parfor_output, expected, decimal=3) self.assertIn('@do_scheduling', cpfunc.library.get_llvm_str()) # test index_offsets def test_seq(n, w, offset): A = np.arange(n) def stencil2_kernel(a, w): cum = a[-w + 1] for i in range(-w + 1, w + 1): cum += a[i + 1] return 0.3 * cum B = numba.stencil(stencil2_kernel, neighborhood=((-w, w), ), index_offsets=(-offset, ))(A, w) return B offset = 1 cpfunc = self.compile_parallel(test_seq, (types.intp, types.intp, types.intp)) parfor_output = cpfunc.entry_point(n, w, offset) np.testing.assert_almost_equal(parfor_output, expected, decimal=3) self.assertIn('@do_scheduling', cpfunc.library.get_llvm_str()) # test slice in kernel def test_seq(n, w, offset): A = np.arange(n) def stencil2_kernel(a, w): return 0.3 * np.sum(a[-w + 1:w + 2]) B = numba.stencil(stencil2_kernel, neighborhood=((-w, w), ), index_offsets=(-offset, ))(A, w) return B offset = 1 cpfunc = self.compile_parallel(test_seq, (types.intp, types.intp, types.intp)) parfor_output = cpfunc.entry_point(n, w, offset) np.testing.assert_almost_equal(parfor_output, expected, decimal=3) self.assertIn('@do_scheduling', cpfunc.library.get_llvm_str()) @skip_unsupported def test_stencil3(self): """Tests whether a non-zero optional cval argument to the stencil decorator works. Also tests integer result type. """ def test_seq(n): A = np.arange(n**2).reshape((n, n)) B = stencil3_kernel(A) return B test_njit = njit(test_seq) test_par = njit(test_seq, parallel=True) n = 5 seq_res = test_seq(n) njit_res = test_njit(n) par_res = test_par(n) self.assertTrue(seq_res[0, 0] == 1.0 and seq_res[4, 4] == 1.0) self.assertTrue(njit_res[0, 0] == 1.0 and njit_res[4, 4] == 1.0) self.assertTrue(par_res[0, 0] == 1.0 and par_res[4, 4] == 1.0) @skip_unsupported def test_stencil_standard_indexing_1d(self): """Tests standard indexing with a 1d array. """ def test_seq(n): A = np.arange(n) B = [3.0, 7.0] C = stencil_with_standard_indexing_1d(A, B) return C def test_impl_seq(n): A = np.arange(n) B = [3.0, 7.0] C = np.zeros(n) for i in range(1, n): C[i] = A[i - 1] * B[0] + A[i] * B[1] return C n = 100 self.check(test_impl_seq, test_seq, n) @skip_unsupported def test_stencil_standard_indexing_2d(self): """Tests standard indexing with a 2d array and multiple stencil calls. """ def test_seq(n): A = np.arange(n**2).reshape((n, n)) B = np.ones((3, 3)) C = stencil_with_standard_indexing_2d(A, B) D = stencil_with_standard_indexing_2d(C, B) return D def test_impl_seq(n): A = np.arange(n**2).reshape((n, n)) B = np.ones((3, 3)) C = np.zeros(n**2).reshape((n, n)) D = np.zeros(n**2).reshape((n, n)) for i in range(1, n - 1): for j in range(1, n - 1): C[i, j] = (A[i, j + 1] * B[0, 1] + A[i + 1, j] * B[1, 0] + A[i, j - 1] * B[0, -1] + A[i - 1, j] * B[-1, 0]) for i in range(1, n - 1): for j in range(1, n - 1): D[i, j] = (C[i, j + 1] * B[0, 1] + C[i + 1, j] * B[1, 0] + C[i, j - 1] * B[0, -1] + C[i - 1, j] * B[-1, 0]) return D n = 5 self.check(test_impl_seq, test_seq, n) @skip_unsupported def test_stencil_multiple_inputs(self): """Tests whether multiple inputs of the same size work. """ def test_seq(n): A = np.arange(n**2).reshape((n, n)) B = np.arange(n**2).reshape((n, n)) C = stencil_multiple_input_kernel(A, B) return C def test_impl_seq(n): A = np.arange(n**2).reshape((n, n)) B = np.arange(n**2).reshape((n, n)) C = np.zeros(n**2).reshape((n, n)) for i in range(1, n - 1): for j in range(1, n - 1): C[i, j] = 0.25 * \ (A[i, j + 1] + A[i + 1, j] + A[i, j - 1] + A[i - 1, j] + B[i, j + 1] + B[i + 1, j] + B[i, j - 1] + B[i - 1, j]) return C n = 3 self.check(test_impl_seq, test_seq, n) # test stencil with a non-array input def test_seq(n): A = np.arange(n**2).reshape((n, n)) B = np.arange(n**2).reshape((n, n)) w = 0.25 C = stencil_multiple_input_kernel_var(A, B, w) return C self.check(test_impl_seq, test_seq, n) @skip_unsupported def test_stencil_mixed_types(self): def test_impl_seq(n): A = np.arange(n ** 2).reshape((n, n)) B = n ** 2 - np.arange(n ** 2).reshape((n, n)) S = np.eye(n, dtype=np.bool_) O = np.zeros((n, n), dtype=A.dtype) for i in range(0, n): for j in range(0, n): O[i, j] = A[i, j] if S[i, j] else B[i, j] return O def test_seq(n): A = np.arange(n ** 2).reshape((n, n)) B = n ** 2 - np.arange(n ** 2).reshape((n, n)) S = np.eye(n, dtype=np.bool_) O = stencil_multiple_input_mixed_types_2d(A, B, S) return O n = 3 self.check(test_impl_seq, test_seq, n) @skip_unsupported def test_stencil_call(self): """Tests 2D numba.stencil calls. """ def test_impl1(n): A = np.arange(n**2).reshape((n, n)) B = np.zeros(n**2).reshape((n, n)) numba.stencil(lambda a: 0.25 * (a[0, 1] + a[1, 0] + a[0, -1] + a[-1, 0]))(A, out=B) return B def test_impl2(n): A = np.arange(n**2).reshape((n, n)) B = np.zeros(n**2).reshape((n, n)) def sf(a): return 0.25 * (a[0, 1] + a[1, 0] + a[0, -1] + a[-1, 0]) B = numba.stencil(sf)(A) return B def test_impl_seq(n): A = np.arange(n**2).reshape((n, n)) B = np.zeros(n**2).reshape((n, n)) for i in range(1, n - 1): for j in range(1, n - 1): B[i, j] = 0.25 * (A[i, j + 1] + A[i + 1, j] + A[i, j - 1] + A[i - 1, j]) return B n = 100 self.check(test_impl_seq, test_impl1, n) self.check(test_impl_seq, test_impl2, n) @skip_unsupported def test_stencil_call_1D(self): """Tests 1D numba.stencil calls. """ def test_impl(n): A = np.arange(n) B = np.zeros(n) numba.stencil(lambda a: 0.3 * (a[-1] + a[0] + a[1]))(A, out=B) return B def test_impl_seq(n): A = np.arange(n) B = np.zeros(n) for i in range(1, n - 1): B[i] = 0.3 * (A[i - 1] + A[i] + A[i + 1]) return B n = 100 self.check(test_impl_seq, test_impl, n) @skip_unsupported def test_stencil_call_const(self): """Tests numba.stencil call that has an index that can be inferred as constant from a unary expr. Otherwise, this would raise an error since neighborhood length is not specified. """ def test_impl1(n): A = np.arange(n) B = np.zeros(n) c = 1 numba.stencil(lambda a,c : 0.3 * (a[-c] + a[0] + a[c]))(A, c, out=B) return B def test_impl2(n): A = np.arange(n) B = np.zeros(n) c = 2 numba.stencil( lambda a,c : 0.3 * (a[1 - c] + a[0] + a[c - 1]))(A, c, out=B) return B # recursive expr case def test_impl3(n): A = np.arange(n) B = np.zeros(n) c = 2 numba.stencil( lambda a,c : 0.3 * (a[-c + 1] + a[0] + a[c - 1]))(A, c, out=B) return B # multi-constant case def test_impl4(n): A = np.arange(n) B = np.zeros(n) d = 1 c = 2 numba.stencil( lambda a,c,d : 0.3 * (a[-c + d] + a[0] + a[c - d]))(A, c, d, out=B) return B def test_impl_seq(n): A = np.arange(n) B = np.zeros(n) c = 1 for i in range(1, n - 1): B[i] = 0.3 * (A[i - c] + A[i] + A[i + c]) return B n = 100 # constant inference is only possible in parallel path cpfunc1 = self.compile_parallel(test_impl1, (types.intp,)) cpfunc2 = self.compile_parallel(test_impl2, (types.intp,)) cpfunc3 = self.compile_parallel(test_impl3, (types.intp,)) cpfunc4 = self.compile_parallel(test_impl4, (types.intp,)) expected = test_impl_seq(n) # parfor result parfor_output1 = cpfunc1.entry_point(n) parfor_output2 = cpfunc2.entry_point(n) parfor_output3 = cpfunc3.entry_point(n) parfor_output4 = cpfunc4.entry_point(n) np.testing.assert_almost_equal(parfor_output1, expected, decimal=3) np.testing.assert_almost_equal(parfor_output2, expected, decimal=3) np.testing.assert_almost_equal(parfor_output3, expected, decimal=3) np.testing.assert_almost_equal(parfor_output4, expected, decimal=3) # check error in regular Python path with self.assertRaises(NumbaValueError) as e: test_impl4(4) self.assertIn("stencil kernel index is not constant, " "'neighborhood' option required", str(e.exception)) # check error in njit path # TODO: ValueError should be thrown instead of LoweringError with self.assertRaises((LoweringError, NumbaValueError)) as e: njit(test_impl4)(4) self.assertIn("stencil kernel index is not constant, " "'neighborhood' option required", str(e.exception)) @skip_unsupported def test_stencil_parallel_off(self): """Tests 1D numba.stencil calls without parallel translation turned off. """ def test_impl(A): return numba.stencil(lambda a: 0.3 * (a[-1] + a[0] + a[1]))(A) cpfunc = self.compile_parallel(test_impl, (numba.float64[:],), stencil=False) self.assertNotIn('@do_scheduling', cpfunc.library.get_llvm_str()) @skip_unsupported def test_stencil_nested1(self): """Tests whether nested stencil decorator works. """ @njit(parallel=True) def test_impl(n): @stencil def fun(a): c = 2 return a[-c + 1] B = fun(n) return B def test_impl_seq(n): B = np.zeros(len(n), dtype=int) for i in range(1, len(n)): B[i] = n[i - 1] return B n = np.arange(10) np.testing.assert_equal(test_impl(n), test_impl_seq(n)) @skip_unsupported def test_out_kwarg_w_cval(self): """ Issue #3518, out kwarg did not work with cval.""" # test const value that matches the arg dtype, and one that can be cast const_vals = [7, 7.0] def kernel(a): return (a[0, 0] - a[1, 0]) for const_val in const_vals: stencil_fn = numba.stencil(kernel, cval=const_val) def wrapped(): A = np.arange(12).reshape((3, 4)) ret = np.ones_like(A) stencil_fn(A, out=ret) return ret # stencil function case A = np.arange(12).reshape((3, 4)) expected = np.full_like(A, -4) expected[-1, :] = const_val ret = np.ones_like(A) stencil_fn(A, out=ret) np.testing.assert_almost_equal(ret, expected) # wrapped function case, check njit, then njit(parallel=True) impls = self.compile_all(wrapped,) for impl in impls: got = impl.entry_point() np.testing.assert_almost_equal(got, expected) # now check exceptions for cval dtype mismatch with out kwarg dtype stencil_fn = numba.stencil(kernel, cval=1j) def wrapped(): A = np.arange(12).reshape((3, 4)) ret = np.ones_like(A) stencil_fn(A, out=ret) return ret A = np.arange(12).reshape((3, 4)) ret = np.ones_like(A) with self.assertRaises(NumbaValueError) as e: stencil_fn(A, out=ret) msg = "cval type does not match stencil return type." self.assertIn(msg, str(e.exception)) for compiler in [self.compile_njit, self.compile_parallel]: try: compiler(wrapped,()) except (NumbaValueError, LoweringError) as e: self.assertIn(msg, str(e)) else: raise AssertionError("Expected error was not raised") @skip_unsupported def test_out_kwarg_w_cval_np_attr(self): """ Test issue #7286 where the cval is a np attr/string-based numerical constant""" for cval in (np.nan, np.inf, -np.inf, float('inf'), -float('inf')): def kernel(a): return (a[0, 0] - a[1, 0]) stencil_fn = numba.stencil(kernel, cval=cval) def wrapped(): A = np.arange(12.).reshape((3, 4)) ret = np.ones_like(A) stencil_fn(A, out=ret) return ret # stencil function case A = np.arange(12.).reshape((3, 4)) expected = np.full_like(A, -4) expected[-1, :] = cval ret = np.ones_like(A) stencil_fn(A, out=ret) np.testing.assert_almost_equal(ret, expected) # wrapped function case, check njit, then njit(parallel=True) impls = self.compile_all(wrapped,) for impl in impls: got = impl.entry_point() np.testing.assert_almost_equal(got, expected) @skip_unsupported class TestManyStencils(TestStencilBase): # NOTE: the original implementation of this test used manipulations of the # Python AST repr of a kernel to create another implementation of the # stencil being tested so to act as another reference point when # comparing the various forms of @stencil calls. This implementation was # based on the cPython 3.7 version of the AST and proved too much effort to # continuously port to newer python versions. Ahead of dropping Python 3.7 # support, all the kernel invocations were translated via the ``astor`` # package ``astor.to_source()`` function to pure python source and this # source was hardcoded into the tests themselves. In the following tests, # regions demarked with dashed lines (----) and with the header # "Autogenerated kernel" correspond to these translations. def __init__(self, *args, **kwargs): super(TestManyStencils, self).__init__(*args, **kwargs) def check_against_expected(self, pyfunc, expected, *args, **kwargs): """ For a given kernel: The expected result is available from argument `expected`. The following results are then computed: * from a pure @stencil decoration of the kernel. * from the njit of a trivial wrapper function around the pure @stencil decorated function. * from the njit(parallel=True) of a trivial wrapper function around the pure @stencil decorated function. The results are then compared. """ options = kwargs.get('options', dict()) expected_exception = kwargs.get('expected_exception') # DEBUG print output arrays DEBUG_OUTPUT = False # collect fails should_fail = [] should_not_fail = [] # runner that handles fails @contextmanager def errorhandler(exty=None, usecase=None): try: yield except Exception as e: if exty is not None: lexty = exty if hasattr(exty, '__iter__') else [exty, ] found = False for ex in lexty: found |= isinstance(e, ex) if not found: raise else: should_not_fail.append( (usecase, "%s: %s" % (type(e), str(e)))) else: if exty is not None: should_fail.append(usecase) if isinstance(expected_exception, dict): stencil_ex = expected_exception['stencil'] njit_ex = expected_exception['njit'] parfor_ex = expected_exception['parfor'] else: stencil_ex = expected_exception njit_ex = expected_exception parfor_ex = expected_exception stencil_args = {'func_or_mode': pyfunc} stencil_args.update(options) stencilfunc_output = None with errorhandler(stencil_ex, "@stencil"): stencil_func_impl = stencil(**stencil_args) # stencil result stencilfunc_output = stencil_func_impl(*args) # wrapped stencil impl, could this be generated? if len(args) == 1: def wrap_stencil(arg0): return stencil_func_impl(arg0) elif len(args) == 2: def wrap_stencil(arg0, arg1): return stencil_func_impl(arg0, arg1) elif len(args) == 3: def wrap_stencil(arg0, arg1, arg2): return stencil_func_impl(arg0, arg1, arg2) else: raise ValueError( "Up to 3 arguments can be provided, found %s" % len(args)) sig = tuple([numba.typeof(x) for x in args]) njit_output = None with errorhandler(njit_ex, "njit"): wrapped_cfunc = self.compile_njit(wrap_stencil, sig) # njit result njit_output = wrapped_cfunc.entry_point(*args) parfor_output = None with errorhandler(parfor_ex, "parfors"): wrapped_cpfunc = self.compile_parallel(wrap_stencil, sig) # parfor result parfor_output = wrapped_cpfunc.entry_point(*args) if DEBUG_OUTPUT: print("\n@stencil_output:\n", stencilfunc_output) print("\nnjit_output:\n", njit_output) print("\nparfor_output:\n", parfor_output) try: if not stencil_ex: np.testing.assert_almost_equal( stencilfunc_output, expected, decimal=1) self.assertEqual(expected.dtype, stencilfunc_output.dtype) except Exception as e: should_not_fail.append( ('@stencil', "%s: %s" % (type(e), str(e)))) print("@stencil failed: %s" % str(e)) try: if not njit_ex: np.testing.assert_almost_equal( njit_output, expected, decimal=1) self.assertEqual(expected.dtype, njit_output.dtype) except Exception as e: should_not_fail.append(('njit', "%s: %s" % (type(e), str(e)))) print("@njit failed: %s" % str(e)) try: if not parfor_ex: np.testing.assert_almost_equal( parfor_output, expected, decimal=1) self.assertEqual(expected.dtype, parfor_output.dtype) try: self.assertIn( '@do_scheduling', wrapped_cpfunc.library.get_llvm_str()) except AssertionError: msg = 'Could not find `@do_scheduling` in LLVM IR' raise AssertionError(msg) except Exception as e: should_not_fail.append( ('parfors', "%s: %s" % (type(e), str(e)))) print("@njit(parallel=True) failed: %s" % str(e)) if DEBUG_OUTPUT: print("\n\n") if should_fail: msg = ["%s" % x for x in should_fail] raise RuntimeError(("The following implementations should have " "raised an exception but did not:\n%s") % msg) if should_not_fail: impls = ["%s" % x[0] for x in should_not_fail] errs = ''.join(["%s: Message: %s\n\n" % x for x in should_not_fail]) str1 = ("The following implementations should not have raised an " "exception but did:\n%s\n" % impls) str2 = "Errors were:\n\n%s" % errs raise RuntimeError(str1 + str2) def check_exceptions(self, pyfunc, *args, **kwargs): """ For a given kernel: The expected result is computed from a pyStencil version of the stencil. The following results are then computed: * from a pure @stencil decoration of the kernel. * from the njit of a trivial wrapper function around the pure @stencil decorated function. * from the njit(parallel=True) of a trivial wrapper function around the pure @stencil decorated function. The results are then compared. """ options = kwargs.get('options', dict()) expected_exception = kwargs.get('expected_exception') # collect fails should_fail = [] should_not_fail = [] # runner that handles fails @contextmanager def errorhandler(exty=None, usecase=None): try: yield except Exception as e: if exty is not None: lexty = exty if hasattr(exty, '__iter__') else [exty, ] found = False for ex in lexty: found |= isinstance(e, ex) if not found: raise else: should_not_fail.append( (usecase, "%s: %s" % (type(e), str(e)))) else: if exty is not None: should_fail.append(usecase) if isinstance(expected_exception, dict): stencil_ex = expected_exception['stencil'] njit_ex = expected_exception['njit'] parfor_ex = expected_exception['parfor'] else: stencil_ex = expected_exception njit_ex = expected_exception parfor_ex = expected_exception stencil_args = {'func_or_mode': pyfunc} stencil_args.update(options) with errorhandler(stencil_ex, "@stencil"): stencil_func_impl = stencil(**stencil_args) # stencil result stencil_func_impl(*args) # wrapped stencil impl, could this be generated? if len(args) == 1: def wrap_stencil(arg0): return stencil_func_impl(arg0) elif len(args) == 2: def wrap_stencil(arg0, arg1): return stencil_func_impl(arg0, arg1) elif len(args) == 3: def wrap_stencil(arg0, arg1, arg2): return stencil_func_impl(arg0, arg1, arg2) else: raise ValueError( "Up to 3 arguments can be provided, found %s" % len(args)) sig = tuple([numba.typeof(x) for x in args]) with errorhandler(njit_ex, "njit"): wrapped_cfunc = self.compile_njit(wrap_stencil, sig) # njit result wrapped_cfunc.entry_point(*args) with errorhandler(parfor_ex, "parfors"): wrapped_cpfunc = self.compile_parallel(wrap_stencil, sig) # parfor result wrapped_cpfunc.entry_point(*args) if should_fail: msg = ["%s" % x for x in should_fail] raise RuntimeError(("The following implementations should have " "raised an exception but did not:\n%s") % msg) if should_not_fail: impls = ["%s" % x[0] for x in should_not_fail] errs = ''.join(["%s: Message: %s\n\n" % x for x in should_not_fail]) str1 = ("The following implementations should not have raised an " "exception but did:\n%s\n" % impls) str2 = "Errors were:\n\n%s" % errs raise RuntimeError(str1 + str2) def exception_dict(self, **kwargs): d = dict() d['pyStencil'] = None d['stencil'] = None d['njit'] = None d['parfor'] = None for k, v in kwargs.items(): d[k] = v return d def check_stencil_arrays(self, *args, **kwargs): neighborhood = kwargs.get('neighborhood') init_shape = args[0].shape if neighborhood is not None: if len(init_shape) != len(neighborhood): raise ValueError('Invalid neighborhood supplied') for x in args[1:]: if hasattr(x, 'shape'): if init_shape != x.shape: raise ValueError('Input stencil arrays do not commute') def test_basic00(self): """rel index""" def kernel(a): return a[0, 0] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1]): for __a in range(0, a.shape[0]): __b0[__a, __b] = a[__a + 0, __b + 0] return __b0 # ---------------------------------------------------------------------- a = np.arange(12).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic01(self): """rel index add const""" def kernel(a): return a[0, 1] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1] - 1): for __a in range(0, a.shape[0]): __b0[__a, __b] = a[__a + 0, __b + 1] return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic02(self): """rel index add const""" def kernel(a): return a[0, -1] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(1, a.shape[1]): for __a in range(0, a.shape[0]): __b0[__a, __b] = a[__a + 0, __b + -1] return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic03(self): """rel index add const""" def kernel(a): return a[1, 0] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1]): for __a in range(0, a.shape[0] - 1): __b0[__a, __b] = a[__a + 1, __b + 0] return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic04(self): """rel index add const""" def kernel(a): return a[-1, 0] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1]): for __a in range(1, a.shape[0]): __b0[__a, __b] = a[__a + -1, __b + 0] return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic05(self): """rel index add const""" def kernel(a): return a[-1, 1] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1] - 1): for __a in range(1, a.shape[0]): __b0[__a, __b] = a[__a + -1, __b + 1] return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic06(self): """rel index add const""" def kernel(a): return a[1, -1] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(1, a.shape[1]): for __a in range(0, a.shape[0] - 1): __b0[__a, __b] = a[__a + 1, __b + -1] return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic07(self): """rel index add const""" def kernel(a): return a[1, 1] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1] - 1): for __a in range(0, a.shape[0] - 1): __b0[__a, __b] = a[__a + 1, __b + 1] return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic08(self): """rel index add const""" def kernel(a): return a[-1, -1] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(1, a.shape[1]): for __a in range(1, a.shape[0]): __b0[__a, __b] = a[__a + -1, __b + -1] return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic09(self): """rel index add const""" def kernel(a): return a[-2, 2] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1] - 2): for __a in range(2, a.shape[0]): __b0[__a, __b] = a[__a + -2, __b + 2] return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic10(self): """rel index add const""" def kernel(a): return a[0, 0] + a[1, 0] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1]): for __a in range(0, a.shape[0] - 1): __b0[__a, __b] = a[__a + 0, __b + 0] + a[__a + 1, __b + 0] return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic11(self): """rel index add const""" def kernel(a): return a[-1, 0] + a[1, 0] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1]): for __a in range(1, a.shape[0] - 1): __b0[__a, __b] = a[__a + -1, __b + 0] + a[__a + 1, __b + 0] return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic12(self): """rel index add const""" def kernel(a): return a[-1, 1] + a[1, -1] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(1, a.shape[1] - 1): for __a in range(1, a.shape[0] - 1): __b0[__a, __b] = a[__a + -1, __b + 1] + a[__a + 1, __b + -1] return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic13(self): """rel index add const""" def kernel(a): return a[-1, -1] + a[1, 1] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(1, a.shape[1] - 1): for __a in range(1, a.shape[0] - 1): __b0[__a, __b] = a[__a + -1, __b + -1] + a[__a + 1, __b + 1] return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic14(self): """rel index add domain change const""" def kernel(a): return a[0, 0] + 1j # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1]): for __a in range(0, a.shape[0]): __b0[__a, __b] = a[__a + 0, __b + 0] + 1.0j return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic14b(self): """rel index add domain change const""" def kernel(a): t = 1.j return a[0, 0] + t # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1]): for __a in range(0, a.shape[0]): t = 1.0j __b0[__a, __b] = a[__a + 0, __b + 0] + t return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic15(self): """two rel index, add const""" def kernel(a): return a[0, 0] + a[1, 0] + 1. # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1]): for __a in range(0, a.shape[0] - 1): __b0[__a, __b] = (a[__a + 0, __b + 0] + a[__a + 1, __b + 0] + 1.0) return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic17(self): """two rel index boundary test, add const""" def kernel(a): return a[0, 0] + a[2, 0] + 1. # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1]): for __a in range(0, a.shape[0] - 2): __b0[__a, __b] = (a[__a + 0, __b + 0] + a[__a + 2, __b + 0] + 1.0) return __b0 # ---------------------------------------------------------------------- a = np.arange(12).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic18(self): """two rel index boundary test, add const""" def kernel(a): return a[0, 0] + a[-2, 0] + 1. # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1]): for __a in range(2, a.shape[0]): __b0[__a, __b] = (a[__a + 0, __b + 0] + a[__a + -2, __b + 0] + 1.0) return __b0 # ---------------------------------------------------------------------- a = np.arange(12).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic19(self): """two rel index boundary test, add const""" def kernel(a): return a[0, 0] + a[0, 3] + 1. # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1] - 3): for __a in range(0, a.shape[0]): __b0[__a, __b] = (a[__a + 0, __b + 0] + a[__a + 0, __b + 3] + 1.0) return __b0 # ---------------------------------------------------------------------- a = np.arange(12).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic20(self): """two rel index boundary test, add const""" def kernel(a): return a[0, 0] + a[0, -3] + 1. # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(3, a.shape[1]): for __a in range(0, a.shape[0]): __b0[__a, __b] = (a[__a + 0, __b + 0] + a[__a + 0, __b + -3] + 1.0) return __b0 # ---------------------------------------------------------------------- a = np.arange(12).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic21(self): """same rel, add const""" def kernel(a): return a[0, 0] + a[0, 0] + 1. # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1]): for __a in range(0, a.shape[0]): __b0[__a, __b] = (a[__a + 0, __b + 0] + a[__a + 0, __b + 0] + 1.0) return __b0 # ---------------------------------------------------------------------- a = np.arange(12).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic22(self): """rel idx const expr folding, add const""" def kernel(a): return a[1 + 0, 0] + a[0, 0] + 1. # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1]): for __a in range(0, a.shape[0] - 1): __b0[__a, __b] = (a[__a + 1, __b + 0] + a[__a + 0, __b + 0] + 1.0) return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic23(self): """rel idx, work in body""" def kernel(a): x = np.sin(10 + a[2, 1]) return a[1 + 0, 0] + a[0, 0] + x # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1] - 1): for __a in range(0, a.shape[0] - 2): x = np.sin(10 + a[__a + 2, __b + 1]) __b0[__a, __b] = (a[__a + 1, __b + 0] + a[__a + 0, __b + 0] + x) return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic23a(self): """rel idx, dead code should not impact rel idx""" def kernel(a): x = np.sin(10 + a[2, 1]) # noqa: F841 # dead code expected return a[1 + 0, 0] + a[0, 0] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1] - 1): for __a in range(0, a.shape[0] - 2): x = np.sin(10 + a[__a + 2, __b + 1]) # noqa: F841 __b0[__a, __b] = a[__a + 1, __b + 0] + a[__a + 0, __b + 0] return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic24(self): """1d idx on 2d arr""" a = np.arange(12).reshape(3, 4) def kernel(a): return a[0] + 1. self.check_exceptions(kernel, a, expected_exception=[TypingError,]) def test_basic25(self): """no idx on 2d arr""" a = np.arange(12).reshape(3, 4) def kernel(a): return 1. self.check_exceptions(kernel, a, expected_exception=[ValueError, NumbaValueError,]) def test_basic26(self): """3d arr""" def kernel(a): return a[0, 0, 0] - a[0, 1, 0] + 1. # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __c in range(0, a.shape[2]): for __b in range(0, a.shape[1] - 1): for __a in range(0, a.shape[0]): __b0[__a, __b, __c] = (a[__a + 0, __b + 0, __c + 0] - a[__a + 0, __b + 1, __c + 0] + 1.0) return __b0 # ---------------------------------------------------------------------- a = np.arange(64).reshape(4, 8, 2) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic27(self): """4d arr""" def kernel(a): return a[0, 0, 0, 0] - a[0, 1, 0, -1] + 1. # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __d in range(1, a.shape[3]): for __c in range(0, a.shape[2]): for __b in range(0, a.shape[1] - 1): for __a in range(0, a.shape[0]): __b0[__a, __b, __c, __d] = (a[__a + 0, __b + 0, __c + 0, __d + 0] - a[__a + 0, __b + 1, __c + 0, __d + -1] + 1.0) return __b0 # ---------------------------------------------------------------------- a = np.arange(128).reshape(4, 8, 2, 2) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic28(self): """type widen """ def kernel(a): return a[0, 0] + np.float64(10.) # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1]): for __a in range(0, a.shape[0]): __b0[__a, __b] = a[__a + 0, __b + 0] + np.float64(10.0) return __b0 # ---------------------------------------------------------------------- a = np.arange(12).reshape(3, 4).astype(np.float32) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic29(self): """const index from func """ a = np.arange(12.).reshape(3, 4) def kernel(a): return a[0, int(np.cos(0))] self.check_exceptions(kernel, a, expected_exception=[ValueError, NumbaValueError, LoweringError]) def test_basic30(self): """signed zeros""" def kernel(a): return a[-0, -0] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1]): for __a in range(0, a.shape[0]): __b0[__a, __b] = a[__a + -0, __b + -0] return __b0 # ---------------------------------------------------------------------- a = np.arange(12).reshape(3, 4).astype(np.float32) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic31(self): """does a const propagate? 2D""" def kernel(a): t = 1 return a[t, 0] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1]): for __a in range(0, a.shape[0] - 1): t = 1 __b0[__a, __b] = a[__a + t, __b + 0] return __b0 # ---------------------------------------------------------------------- a = np.arange(12).reshape(3, 4).astype(np.float32) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) @unittest.skip("constant folding not implemented") def test_basic31b(self): """does a const propagate?""" a = np.arange(12.).reshape(3, 4) # noqa: F841 def kernel(a): s = 1 t = 1 - s return a[t, 0] #TODO: add check should this be implemented def test_basic31c(self): """does a const propagate? 1D""" def kernel(a): t = 1 return a[t] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __a in range(0, a.shape[0] - 1): t = 1 __b0[__a,] = a[__a + t] return __b0 # ---------------------------------------------------------------------- a = np.arange(12.) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic32(self): """typed int index""" a = np.arange(12.).reshape(3, 4) def kernel(a): return a[np.int8(1), 0] self.check_exceptions(kernel, a, expected_exception=[ValueError, NumbaValueError, LoweringError]) def test_basic33(self): """add 0d array""" def kernel(a): return a[0, 0] + np.array(1) # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1]): for __a in range(0, a.shape[0]): __b0[__a, __b] = a[__a + 0, __b + 0] + np.array(1) return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic34(self): """More complex rel index with dependency on addition rel index""" def kernel(a): g = 4. + a[0, 1] return g + (a[0, 1] + a[1, 0] + a[0, -1] + np.sin(a[-2, 0])) # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(1, a.shape[1] - 1): for __a in range(2, a.shape[0] - 1): g = 4.0 + a[__a + 0, __b + 1] __b0[__a, __b] = g + (a[__a + 0, __b + 1] + a[__a + 1, __b + 0] + a[__a + 0, __b + -1] + np.sin(a[__a + -2, __b + 0])) return __b0 # ---------------------------------------------------------------------- a = np.arange(144).reshape(12, 12) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic35(self): """simple cval where cval is int but castable to dtype of float""" def kernel(a): return a[0, 1] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 5, dtype=type(__retdtype)) for __b in range(0, a.shape[1] - 1): for __a in range(0, a.shape[0]): __b0[__a, __b] = a[__a + 0, __b + 1] return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a, options={'cval': 5}) def test_basic36(self): """more complex with cval""" def kernel(a): return a[0, 1] + a[0, -1] + a[1, -1] + a[1, -1] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 5.0, dtype=type(__retdtype)) for __b in range(1, a.shape[1] - 1): for __a in range(0, a.shape[0] - 1): __b0[__a, __b] = (a[__a + 0, __b + 1] + a[__a + 0, __b + -1] + a[__a + 1, __b + -1] + a[__a + 1, __b + -1]) return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a, options={'cval': 5}) def test_basic37(self): """cval is expr""" def kernel(a): return a[0, 1] + a[0, -1] + a[1, -1] + a[1, -1] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 68.0, dtype=type(__retdtype)) for __b in range(1, a.shape[1] - 1): for __a in range(0, a.shape[0] - 1): __b0[__a, __b] = (a[__a + 0, __b + 1] + a[__a + 0, __b + -1] + a[__a + 1, __b + -1] + a[__a + 1, __b + -1]) return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a, options={'cval': 5 + 63.}) def test_basic38(self): """cval is complex""" def kernel(a): return a[0, 1] + a[0, -1] + a[1, -1] + a[1, -1] a = np.arange(12.).reshape(3, 4) ex = self.exception_dict( stencil=NumbaValueError, parfor=ValueError, njit=NumbaValueError) self.check_exceptions(kernel, a, options={'cval': 1.j}, expected_exception=ex) def test_basic39(self): """cval is func expr""" def kernel(a): return a[0, 1] + a[0, -1] + a[1, -1] + a[1, -1] cval = np.sin(3.) + np.cos(2) # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, cval, dtype=type(__retdtype)) for __b in range(1, a.shape[1] - 1): for __a in range(0, a.shape[0] - 1): __b0[__a, __b] = (a[__a + 0, __b + 1] + a[__a + 0, __b + -1] + a[__a + 1, __b + -1] + a[__a + 1, __b + -1]) return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a, options={'cval': cval}) def test_basic40(self): """2 args!""" def kernel(a, b): return a[0, 1] + b[0, -2] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, b, neighborhood): self.check_stencil_arrays(a, b, neighborhood=neighborhood) __retdtype = kernel(a, b) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(2, a.shape[1] - 1): for __a in range(0, a.shape[0]): __b0[__a, __b] = a[__a + 0, __b + 1] + b[__a + 0, __b + -2] return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) b = np.arange(12.).reshape(3, 4) expected = __kernel(a, b, None) self.check_against_expected(kernel, expected, a, b) def test_basic41(self): """2 args! rel arrays wildly not same size!""" def kernel(a, b): return a[0, 1] + b[0, -2] a = np.arange(12.).reshape(3, 4) b = np.arange(1.).reshape(1, 1) self.check_exceptions(kernel, a, b, expected_exception=[ValueError, AssertionError]) def test_basic42(self): """2 args! rel arrays very close in size""" def kernel(a, b): return a[0, 1] + b[0, -2] a = np.arange(12.).reshape(3, 4) b = np.arange(9.).reshape(3, 3) self.check_exceptions(kernel, a, b, expected_exception=[ValueError, AssertionError]) def test_basic43(self): """2 args more complexity""" def kernel(a, b): return a[0, 1] + a[1, 2] + b[-2, 0] + b[0, -1] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, b, neighborhood): self.check_stencil_arrays(a, b, neighborhood=neighborhood) __retdtype = kernel(a, b) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(1, a.shape[1] - 2): for __a in range(2, a.shape[0] - 1): __b0[__a, __b] = (a[__a + 0, __b + 1] + a[__a + 1, __b + 2] + b[__a + -2, __b + 0] + b[__a + 0, __b + -1]) return __b0 # ---------------------------------------------------------------------- a = np.arange(30.).reshape(5, 6) b = np.arange(30.).reshape(5, 6) expected = __kernel(a, b, None) self.check_against_expected(kernel, expected, a, b) def test_basic44(self): """2 args, has assignment before use""" def kernel(a, b): a[0, 1] = 12 return a[0, 1] a = np.arange(12.).reshape(3, 4) b = np.arange(12.).reshape(3, 4) self.check_exceptions(kernel, a, b, expected_exception=[ValueError, LoweringError]) def test_basic45(self): """2 args, has assignment and then cross dependency""" def kernel(a, b): a[0, 1] = 12 return a[0, 1] + a[1, 0] a = np.arange(12.).reshape(3, 4) b = np.arange(12.).reshape(3, 4) self.check_exceptions(kernel, a, b, expected_exception=[ValueError, LoweringError]) def test_basic46(self): """2 args, has cross relidx assignment""" def kernel(a, b): a[0, 1] = b[1, 2] return a[0, 1] + a[1, 0] a = np.arange(12.).reshape(3, 4) b = np.arange(12.).reshape(3, 4) self.check_exceptions(kernel, a, b, expected_exception=[ValueError, LoweringError]) def test_basic47(self): """3 args""" def kernel(a, b, c): return a[0, 1] + b[1, 0] + c[-1, 0] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, b, c, neighborhood): self.check_stencil_arrays(a, b, c, neighborhood=neighborhood) __retdtype = kernel(a, b, c) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1] - 1): for __a in range(1, a.shape[0] - 1): __b0[__a, __b] = (a[__a + 0, __b + 1] + b[__a + 1, __b + 0] + c[__a + -1, __b + 0]) return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) b = np.arange(12.).reshape(3, 4) c = np.arange(12.).reshape(3, 4) expected = __kernel(a, b, c, None) self.check_against_expected(kernel, expected, a, b, c) # matches pyStencil, but all ought to fail # probably hard to detect? def test_basic48(self): """2 args, has assignment before use via memory alias""" def kernel(a): c = a.T c[:, :] = 10 return a[0, 1] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a,neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1] - 1): for __a in range(0, a.shape[0]): c = a.T c[:, :] = 10 __b0[__a, __b] = a[__a + 0, __b + 1] return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic49(self): """2 args, standard_indexing on second""" def kernel(a, b): return a[0, 1] + b[0, 3] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, b, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a, b) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1] - 1): for __a in range(0, a.shape[0]): __b0[__a, __b] = a[__a + 0, __b + 1] + b[0, 3] return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) b = np.arange(12.).reshape(3, 4) expected = __kernel(a, b, None) self.check_against_expected(kernel, expected, a, b, options={'standard_indexing': 'b'}) @unittest.skip("dynamic range checking not implemented") def test_basic50(self): """2 args, standard_indexing OOB""" def kernel(a, b): return a[0, 1] + b[0, 15] #TODO: add check should this be implemented def test_basic51(self): """2 args, standard_indexing, no relidx""" def kernel(a, b): return a[0, 1] + b[0, 2] a = np.arange(12.).reshape(3, 4) b = np.arange(12.).reshape(3, 4) self.check_exceptions(kernel, a, b, options={'standard_indexing': ['a', 'b']}, expected_exception=[ValueError, NumbaValueError]) def test_basic52(self): """3 args, standard_indexing on middle arg """ def kernel(a, b, c): return a[0, 1] + b[0, 1] + c[1, 2] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, b, c, neighborhood): self.check_stencil_arrays(a, c, neighborhood=neighborhood) __retdtype = kernel(a, b, c) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1] - 2): for __a in range(0, a.shape[0] - 1): __b0[__a, __b] = (a[__a + 0, __b + 1] + b[0, 1] + c[__a + 1, __b + 2]) return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) b = np.arange(4.).reshape(2, 2) c = np.arange(12.).reshape(3, 4) expected = __kernel(a, b, c, None) self.check_against_expected(kernel, expected, a, b, c, options={'standard_indexing': 'b'}) def test_basic53(self): """2 args, standard_indexing on variable that does not exist""" def kernel(a, b): return a[0, 1] + b[0, 2] a = np.arange(12.).reshape(3, 4) b = np.arange(12.).reshape(3, 4) ex = self.exception_dict( stencil=Exception, parfor=ValueError, njit=Exception) self.check_exceptions(kernel, a, b, options={'standard_indexing': 'c'}, expected_exception=ex) def test_basic54(self): """2 args, standard_indexing, index from var""" def kernel(a, b): t = 2 return a[0, 1] + b[0, t] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, b, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a, b) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1] - 1): for __a in range(0, a.shape[0]): t = 2 __b0[__a, __b] = a[__a + 0, __b + 1] + b[0, t] return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) b = np.arange(12.).reshape(3, 4) expected = __kernel(a, b, None) self.check_against_expected(kernel, expected, a, b, options={'standard_indexing': 'b'}) def test_basic55(self): """2 args, standard_indexing, index from more complex var""" def kernel(a, b): s = 1 t = 2 - s return a[0, 1] + b[0, t] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, b, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a, b) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1] - 1): for __a in range(0, a.shape[0]): s = 1 t = 2 - s __b0[__a, __b] = a[__a + 0, __b + 1] + b[0, t] return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) b = np.arange(12.).reshape(3, 4) expected = __kernel(a, b, None) self.check_against_expected(kernel, expected, a, b, options={'standard_indexing': 'b'}) def test_basic56(self): """2 args, standard_indexing, added complexity """ def kernel(a, b): s = 1 acc = 0 for k in b[0, :]: acc += k t = 2 - s - 1 return a[0, 1] + b[0, t] + acc # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, b, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a, b) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1] - 1): for __a in range(0, a.shape[0]): s = 1 acc = 0 for k in b[(0), :]: acc += k t = 2 - s - 1 __b0[__a, __b] = a[__a + 0, __b + 1] + b[0, t] + acc return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) b = np.arange(12.).reshape(3, 4) expected = __kernel(a, b, None) self.check_against_expected(kernel, expected, a, b, options={'standard_indexing': 'b'}) def test_basic57(self): """2 args, standard_indexing, split index operation """ def kernel(a, b): c = b[0] return a[0, 1] + c[1] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, b, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a, b) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1] - 1): for __a in range(0, a.shape[0]): c = b[0] __b0[__a, __b] = a[__a + 0, __b + 1] + c[1] return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) b = np.arange(12.).reshape(3, 4) expected = __kernel(a, b, None) self.check_against_expected(kernel, expected, a, b, options={'standard_indexing': 'b'}) def test_basic58(self): """2 args, standard_indexing, split index with broadcast mutation """ def kernel(a, b): c = b[0] + 1 return a[0, 1] + c[1] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, b, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a, b) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1] - 1): for __a in range(0, a.shape[0]): c = b[0] + 1 __b0[__a, __b] = a[__a + 0, __b + 1] + c[1] return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) b = np.arange(12.).reshape(3, 4) expected = __kernel(a, b, None) self.check_against_expected(kernel, expected, a, b, options={'standard_indexing': 'b'}) def test_basic59(self): """3 args, mix of array, relative and standard indexing and const""" def kernel(a, b, c): return a[0, 1] + b[1, 1] + c # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, b, c, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a, b, c) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1] - 1): for __a in range(0, a.shape[0]): __b0[__a, __b] = a[__a + 0, __b + 1] + b[1, 1] + c return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) b = np.arange(12.).reshape(3, 4) c = 10 expected = __kernel(a, b, c, None) self.check_against_expected(kernel, expected, a, b, c, options={'standard_indexing': ['b', 'c']}) def test_basic60(self): """3 args, mix of array, relative and standard indexing, tuple pass through""" def kernel(a, b, c): return a[0, 1] + b[1, 1] + c[0] a = np.arange(12.).reshape(3, 4) b = np.arange(12.).reshape(3, 4) c = (10,) # parfors does not support tuple args for stencil kernels ex = self.exception_dict(parfor=ValueError) self.check_exceptions(kernel, a, b, c, options={'standard_indexing': ['b', 'c']}, expected_exception=ex) def test_basic61(self): """2 args, standard_indexing on first""" def kernel(a, b): return a[0, 1] + b[1, 1] a = np.arange(12.).reshape(3, 4) b = np.arange(12.).reshape(3, 4) self.check_exceptions(kernel, a, b, options={'standard_indexing': 'a'}, expected_exception=Exception) def test_basic62(self): """2 args, standard_indexing and cval""" def kernel(a, b): return a[0, 1] + b[1, 1] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, b, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a, b) __b0 = np.full(a.shape, 10.0, dtype=type(__retdtype)) for __b in range(0, a.shape[1] - 1): for __a in range(0, a.shape[0]): __b0[__a, __b] = a[__a + 0, __b + 1] + b[1, 1] return __b0 # ---------------------------------------------------------------------- a = np.arange(12.).reshape(3, 4) b = np.arange(12.).reshape(3, 4) expected = __kernel(a, b, None) self.check_against_expected(kernel, expected, a, b, options={'standard_indexing': 'b', 'cval': 10.}) def test_basic63(self): """2 args, standard_indexing applied to relative, should fail, non-const idx""" def kernel(a, b): return a[0, b[0, 1]] a = np.arange(12.).reshape(3, 4) b = np.arange(12).reshape(3, 4) ex = self.exception_dict( stencil=NumbaValueError, parfor=ValueError, njit=NumbaValueError) self.check_exceptions(kernel, a, b, options={'standard_indexing': 'b'}, expected_exception=ex) # stencil, njit, parfors all fail. Does this make sense? def test_basic64(self): """1 arg that uses standard_indexing""" def kernel(a): return a[0, 0] a = np.arange(12.).reshape(3, 4) self.check_exceptions(kernel, a, options={'standard_indexing': 'a'}, expected_exception=[ValueError, NumbaValueError]) def test_basic65(self): """basic induced neighborhood test""" def kernel(a): cumul = 0 for i in range(-29, 1): cumul += a[i] return cumul / 30 # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __an in range(29, a.shape[0]): cumul = 0 for i in range(-29, 1): cumul += a[__an + i] __b0[__an,] = cumul / 30 return __b0 # ---------------------------------------------------------------------- a = np.arange(60.) nh = ((-29, 0),) expected = __kernel(a, nh) self.check_against_expected(kernel, expected, a, options={'neighborhood': nh}) # Should this work? a[0] is out of neighborhood? def test_basic66(self): """basic const neighborhood test""" def kernel(a): cumul = 0 for i in range(-29, 1): cumul += a[0] return cumul / 30 # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __an in range(29, a.shape[0]): cumul = 0 for i in range(-29, 1): cumul += a[__an + 0] __b0[__an,] = cumul / 30 return __b0 # ---------------------------------------------------------------------- a = np.arange(60.) nh = ((-29, 0),) expected = __kernel(a, nh) self.check_against_expected(kernel, expected, a, options={'neighborhood': nh}) def test_basic67(self): """basic 2d induced neighborhood test""" def kernel(a): cumul = 0 for i in range(-5, 1): for j in range(-10, 1): cumul += a[i, j] return cumul / (10 * 5) # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __bn in range(10, a.shape[1]): for __an in range(5, a.shape[0]): cumul = 0 for i in range(-5, 1): for j in range(-10, 1): cumul += a[__an + i, __bn + j] __b0[__an, __bn] = cumul / 50 return __b0 # ---------------------------------------------------------------------- a = np.arange(10. * 20.).reshape(10, 20) nh = ((-5, 0), (-10, 0),) expected = __kernel(a, nh) self.check_against_expected(kernel, expected, a, options={'neighborhood': nh}) def test_basic67b(self): """basic 2d induced 1D neighborhood""" def kernel(a): cumul = 0 for j in range(-10, 1): cumul += a[0, j] return cumul / (10 * 5) a = np.arange(10. * 20.).reshape(10, 20) self.check_exceptions(kernel, a, options={'neighborhood': ((-10, 0),)}, expected_exception=[TypingError, ValueError]) # Should this work or is it UB? a[i, 0] is out of neighborhood? def test_basic68(self): """basic 2d one induced, one cost neighborhood test""" def kernel(a): cumul = 0 for i in range(-5, 1): for j in range(-10, 1): cumul += a[i, 0] return cumul / (10 * 5) # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __bn in range(10, a.shape[1]): for __an in range(5, a.shape[0]): cumul = 0 for i in range(-5, 1): for j in range(-10, 1): cumul += a[__an + i, __bn + 0] __b0[__an, __bn] = cumul / 50 return __b0 # ---------------------------------------------------------------------- a = np.arange(10. * 20.).reshape(10, 20) nh = ((-5, 0), (-10, 0),) expected = __kernel(a, nh) self.check_against_expected(kernel, expected, a, options={'neighborhood': nh}) # Should this work or is it UB? a[0, 0] is out of neighborhood? def test_basic69(self): """basic 2d two cost neighborhood test""" def kernel(a): cumul = 0 for i in range(-5, 1): for j in range(-10, 1): cumul += a[0, 0] return cumul / (10 * 5) # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __bn in range(10, a.shape[1]): for __an in range(5, a.shape[0]): cumul = 0 for i in range(-5, 1): for j in range(-10, 1): cumul += a[__an + 0, __bn + 0] __b0[__an, __bn] = cumul / 50 return __b0 # ---------------------------------------------------------------------- a = np.arange(10. * 20.).reshape(10, 20) nh = ((-5, 0), (-10, 0),) expected = __kernel(a, nh) self.check_against_expected(kernel, expected, a, options={'neighborhood': nh}) def test_basic70(self): """neighborhood adding complexity""" def kernel(a): cumul = 0 zz = 12. for i in range(-5, 1): t = zz + i for j in range(-10, 1): cumul += a[i, j] + t return cumul / (10 * 5) # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __bn in range(10, a.shape[1]): for __an in range(5, a.shape[0]): cumul = 0 zz = 12.0 for i in range(-5, 1): t = zz + i for j in range(-10, 1): cumul += a[__an + i, __bn + j] + t __b0[__an, __bn] = cumul / 50 return __b0 # ---------------------------------------------------------------------- a = np.arange(10. * 20.).reshape(10, 20) nh = ((-5, 0), (-10, 0),) expected = __kernel(a, nh) self.check_against_expected(kernel, expected, a, options={'neighborhood': nh}) def test_basic71(self): """neighborhood, type change""" def kernel(a): cumul = 0 for i in range(-29, 1): k = 0. if i > -15: k = 1j cumul += a[i] + k return cumul / 30 # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __an in range(29, a.shape[0]): cumul = 0 for i in range(-29, 1): k = 0.0 if i > -15: k = 1.0j cumul += a[__an + i] + k __b0[__an,] = cumul / 30 return __b0 # ---------------------------------------------------------------------- a = np.arange(60.) nh = ((-29, 0),) expected = __kernel(a, nh) self.check_against_expected(kernel, expected, a, options={'neighborhood': nh}) def test_basic72(self): """neighborhood, narrower range than specified""" def kernel(a): cumul = 0 for i in range(-19, -3): cumul += a[i] return cumul / 30 # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __an in range(29, a.shape[0]): cumul = 0 for i in range(-19, -3): cumul += a[__an + i] __b0[__an,] = cumul / 30 return __b0 # ---------------------------------------------------------------------- a = np.arange(60.) nh = ((-29, 0),) expected = __kernel(a, nh) self.check_against_expected(kernel, expected, a, options={'neighborhood': nh}) def test_basic73(self): """neighborhood, +ve range""" def kernel(a): cumul = 0 for i in range(5, 11): cumul += a[i] return cumul / 30 # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __an in range(0, a.shape[0] - 10): cumul = 0 for i in range(5, 11): cumul += a[__an + i] __b0[__an,] = cumul / 30 return __b0 # ---------------------------------------------------------------------- a = np.arange(60.) nh = ((5, 10),) expected = __kernel(a, nh) self.check_against_expected(kernel, expected, a, options={'neighborhood': nh}) def test_basic73b(self): """neighborhood, -ve range""" def kernel(a): cumul = 0 for i in range(-10, -4): cumul += a[i] return cumul / 30 # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __an in range(10, a.shape[0]): cumul = 0 for i in range(-10, -4): cumul += a[__an + i] __b0[__an,] = cumul / 30 return __b0 # ---------------------------------------------------------------------- a = np.arange(60.) nh = ((-10, -5),) expected = __kernel(a, nh) self.check_against_expected(kernel, expected, a, options={'neighborhood': nh}) def test_basic74(self): """neighborhood, -ve->+ve range span""" def kernel(a): cumul = 0 for i in range(-5, 11): cumul += a[i] return cumul / 30 # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __an in range(5, a.shape[0] - 10): cumul = 0 for i in range(-5, 11): cumul += a[__an + i] __b0[__an,] = cumul / 30 return __b0 # ---------------------------------------------------------------------- a = np.arange(60.) nh = ((-5, 10),) expected = __kernel(a, nh) self.check_against_expected(kernel, expected, a, options={'neighborhood': nh}) def test_basic75(self): """neighborhood, -ve->-ve range span""" def kernel(a): cumul = 0 for i in range(-10, -1): cumul += a[i] return cumul / 30 # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __an in range(10, a.shape[0]): cumul = 0 for i in range(-10, -1): cumul += a[__an + i] __b0[__an,] = cumul / 30 return __b0 # ---------------------------------------------------------------------- a = np.arange(60.) nh = ((-10, -2),) expected = __kernel(a, nh) self.check_against_expected(kernel, expected, a, options={'neighborhood': nh}) def test_basic76(self): """neighborhood, mixed range span""" def kernel(a): cumul = 0 zz = 12. for i in range(-3, 0): t = zz + i for j in range(-3, 4): cumul += a[i, j] + t return cumul / (10 * 5) # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __bn in range(3, a.shape[1] - 3): for __an in range(3, a.shape[0]): cumul = 0 zz = 12.0 for i in range(-3, 0): t = zz + i for j in range(-3, 4): cumul += a[__an + i, __bn + j] + t __b0[__an, __bn] = cumul / 50 return __b0 # ---------------------------------------------------------------------- a = np.arange(10. * 20.).reshape(10, 20) nh = ((-3, -1), (-3, 3),) expected = __kernel(a, nh) self.check_against_expected(kernel, expected, a, options={'neighborhood': nh}) def test_basic77(self): """ neighborhood, two args """ def kernel(a, b): cumul = 0 for i in range(-3, 1): for j in range(-3, 1): cumul += a[i, j] + b[i, j] return cumul / (9.) # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, b, neighborhood): self.check_stencil_arrays(a, b, neighborhood=neighborhood) __retdtype = kernel(a, b) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __bn in range(3, a.shape[1]): for __an in range(3, a.shape[0]): cumul = 0 for i in range(-3, 1): for j in range(-3, 1): cumul += (a[__an + i, __bn + j] + b[__an + i, __bn + j]) __b0[__an, __bn] = cumul / 9.0 return __b0 # ---------------------------------------------------------------------- a = np.arange(10. * 20.).reshape(10, 20) b = np.arange(10. * 20.).reshape(10, 20) nh = ((-3, 0), (-3, 0),) expected = __kernel(a, b, nh) self.check_against_expected(kernel, expected, a, b, options={'neighborhood': nh}) def test_basic78(self): """ neighborhood, two args, -ve range, -ve range """ def kernel(a, b): cumul = 0 for i in range(-6, -2): for j in range(-7, -1): cumul += a[i, j] + b[i, j] return cumul / (9.) # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, b, neighborhood): self.check_stencil_arrays(a, b, neighborhood=neighborhood) __retdtype = kernel(a, b) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __bn in range(7, a.shape[1]): for __an in range(6, a.shape[0]): cumul = 0 for i in range(-6, -2): for j in range(-7, -1): cumul += (a[__an + i, __bn + j] + b[__an + i, __bn + j]) __b0[__an, __bn] = cumul / 9.0 return __b0 # ---------------------------------------------------------------------- a = np.arange(15. * 20.).reshape(15, 20) b = np.arange(15. * 20.).reshape(15, 20) nh = ((-6, -3), (-7, -2),) expected = __kernel(a, b, nh) self.check_against_expected(kernel, expected, a, b, options={'neighborhood': nh}) def test_basic78b(self): """ neighborhood, two args, -ve range, +ve range """ def kernel(a, b): cumul = 0 for i in range(-6, -2): for j in range(2, 10): cumul += a[i, j] + b[i, j] return cumul / (9.) # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, b, neighborhood): self.check_stencil_arrays(a, b, neighborhood=neighborhood) __retdtype = kernel(a, b) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __bn in range(0, a.shape[1] - 9): for __an in range(6, a.shape[0]): cumul = 0 for i in range(-6, -2): for j in range(2, 10): cumul += (a[__an + i, __bn + j] + b[__an + i, __bn + j]) __b0[__an, __bn] = cumul / 9.0 return __b0 # ---------------------------------------------------------------------- a = np.arange(15. * 20.).reshape(15, 20) b = np.arange(15. * 20.).reshape(15, 20) nh = ((-6, -3), (2, 9),) expected = __kernel(a, b, nh) self.check_against_expected(kernel, expected, a, b, options={'neighborhood': nh}) def test_basic79(self): """ neighborhood, two incompatible args """ def kernel(a, b): cumul = 0 for i in range(-3, 1): for j in range(-3, 1): cumul += a[i, j] + b[i, j] return cumul / (9.) a = np.arange(10. * 20.).reshape(10, 20) b = np.arange(10. * 20.).reshape(10, 10, 2) ex = self.exception_dict( stencil=TypingError, parfor=TypingError, njit=TypingError) self.check_exceptions(kernel, a, b, options={'neighborhood': ((-3, 0), (-3, 0),)}, expected_exception=ex) def test_basic80(self): """ neighborhood, type change """ def kernel(a, b): cumul = 0 for i in range(-3, 1): for j in range(-3, 1): cumul += a[i, j] + b return cumul / (9.) # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, b, neighborhood): self.check_stencil_arrays(a, b, neighborhood=neighborhood) __retdtype = kernel(a, b) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __bn in range(3, a.shape[1]): for __an in range(3, a.shape[0]): cumul = 0 for i in range(-3, 1): for j in range(-3, 1): cumul += a[__an + i, __bn + j] + b __b0[__an, __bn] = cumul / 9.0 return __b0 # ---------------------------------------------------------------------- a = np.arange(10. * 20.).reshape(10, 20) b = 12.j nh = ((-3, 0), (-3, 0)) expected = __kernel(a, b, nh) self.check_against_expected(kernel, expected, a, b, options={'neighborhood': nh}) def test_basic81(self): """ neighborhood, dimensionally incompatible arrays """ def kernel(a, b): cumul = 0 for i in range(-3, 1): for j in range(-3, 1): cumul += a[i, j] + b[i] return cumul / (9.) a = np.arange(10. * 20.).reshape(10, 20) b = a[0].copy() ex = self.exception_dict( stencil=TypingError, parfor=AssertionError, njit=TypingError) self.check_exceptions(kernel, a, b, options={'neighborhood': ((-3, 0), (-3, 0))}, expected_exception=ex) def test_basic82(self): """ neighborhood, with standard_indexing""" def kernel(a, b): cumul = 0 for i in range(-3, 1): for j in range(-3, 1): cumul += a[i, j] + b[1, 3] return cumul / (9.) # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, b, neighborhood): self.check_stencil_arrays(a, b, neighborhood=neighborhood) __retdtype = kernel(a, b) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __bn in range(3, a.shape[1]): for __an in range(3, a.shape[0]): cumul = 0 for i in range(-3, 1): for j in range(-3, 1): cumul += a[__an + i, __bn + j] + b[1, 3] __b0[__an, __bn] = cumul / 9.0 return __b0 # ---------------------------------------------------------------------- a = np.arange(10. * 20.).reshape(10, 20) b = a.copy() nh = ((-3, 0), (-3, 0)) expected = __kernel(a, b, nh) self.check_against_expected(kernel, expected, a, b, options={'neighborhood': nh, 'standard_indexing': 'b'}) def test_basic83(self): """ neighborhood, with standard_indexing and cval""" def kernel(a, b): cumul = 0 for i in range(-3, 1): for j in range(-3, 1): cumul += a[i, j] + b[1, 3] return cumul / (9.) a = np.arange(10. * 20.).reshape(10, 20) b = a.copy() # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, b, neighborhood): self.check_stencil_arrays(a, b, neighborhood=neighborhood) __retdtype = kernel(a, b) __b0 = np.full(a.shape, 1.5, dtype=type(__retdtype)) for __bn in range(3, a.shape[1]): for __an in range(3, a.shape[0]): cumul = 0 for i in range(-3, 1): for j in range(-3, 1): cumul += a[__an + i, __bn + j] + b[1, 3] __b0[__an, __bn] = cumul / 9.0 return __b0 # ---------------------------------------------------------------------- a = np.arange(10. * 20.).reshape(10, 20) b = a.copy() nh = ((-3, 0), (-3, 0)) expected = __kernel(a, b, nh) self.check_against_expected(kernel, expected, a, b, options={'neighborhood': nh, 'standard_indexing': 'b', 'cval': 1.5,}) def test_basic84(self): """ kernel calls njit """ def kernel(a): return a[0, 0] + addone_njit(a[0, 1]) # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1] - 1): for __a in range(0, a.shape[0]): __b0[__a, __b] = (a[__a + 0, __b + 0] + addone_njit.py_func(a[__a + 0, __b + 1])) return __b0 # ---------------------------------------------------------------------- a = np.arange(10. * 20.).reshape(10, 20) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic85(self): """ kernel calls njit(parallel=True)""" def kernel(a): return a[0, 0] + addone_pjit(a[0, 1]) # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1] - 1): for __a in range(0, a.shape[0]): __b0[__a, __b] = (a[__a + 0, __b + 0] + addone_pjit.py_func(a[__a + 0, __b + 1])) return __b0 # ---------------------------------------------------------------------- a = np.arange(10. * 20.).reshape(10, 20) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) # njit/parfors fail correctly, but the error message isn't very informative def test_basic86(self): """ bad kwarg """ def kernel(a): return a[0, 0] a = np.arange(10. * 20.).reshape(10, 20) self.check_exceptions(kernel, a, options={'bad': 10}, expected_exception=[ValueError, TypingError]) def test_basic87(self): """ reserved arg name in use """ def kernel(__sentinel__): return __sentinel__[0, 0] # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(__sentinel__, neighborhood): self.check_stencil_arrays(__sentinel__, neighborhood=neighborhood) __retdtype = kernel(__sentinel__) __b0 = np.full(__sentinel__.shape, 0, dtype=type(__retdtype)) for __b in range(0, __sentinel__.shape[1]): for __a in range(0, __sentinel__.shape[0]): __b0[__a, __b] = __sentinel__[__a + 0, __b + 0] return __b0 # ---------------------------------------------------------------------- a = np.arange(10. * 20.).reshape(10, 20) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic88(self): """ use of reserved word """ def kernel(a, out): return out * a[0, 1] a = np.arange(12.).reshape(3, 4) ex = self.exception_dict( stencil=NumbaValueError, parfor=ValueError, njit=NumbaValueError) self.check_exceptions(kernel, a, 1.0, options={}, expected_exception=ex) def test_basic89(self): """ basic multiple return""" def kernel(a): if a[0, 1] > 10: return 10. elif a[0, 3] < 8: return a[0, 0] else: return 7. # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1] - 3): for __a in range(0, a.shape[0]): if a[__a + 0, __b + 1] > 10: __b0[__a, __b] = 10.0 elif a[__a + 0, __b + 3] < 8: __b0[__a, __b] = a[__a + 0, __b + 0] else: __b0[__a, __b] = 7.0 return __b0 # ---------------------------------------------------------------------- a = np.arange(10. * 20.).reshape(10, 20) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic90(self): """ neighborhood, with standard_indexing and cval, multiple returns""" def kernel(a, b): cumul = 0 for i in range(-3, 1): for j in range(-3, 1): cumul += a[i, j] + b[1, 3] res = cumul / (9.) if res > 200.0: return res + 1.0 else: return res # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, b, neighborhood): self.check_stencil_arrays(a, b, neighborhood=neighborhood) __retdtype = kernel(a, b) __b0 = np.full(a.shape, 1.5, dtype=type(__retdtype)) for __bn in range(3, a.shape[1]): for __an in range(3, a.shape[0]): cumul = 0 for i in range(-3, 1): for j in range(-3, 1): cumul += a[__an + i, __bn + j] + b[1, 3] res = cumul / 9.0 if res > 200.0: __b0[__an, __bn] = res + 1.0 else: __b0[__an, __bn] = res return __b0 # ---------------------------------------------------------------------- a = np.arange(10. * 20.).reshape(10, 20) b = a.copy() nh = ((-3, 0), (-3, 0)) expected = __kernel(a, b, nh) self.check_against_expected(kernel, expected, a, b, options={'neighborhood': nh, 'standard_indexing': 'b', 'cval': 1.5,}) def test_basic91(self): """ Issue #3454, const(int) == const(int) evaluating incorrectly. """ def kernel(a): b = 0 if (2 == 0): b = 2 return a[0, 0] + b # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(0, a.shape[1]): for __a in range(0, a.shape[0]): b = 0 if 2 == 0: b = 2 __b0[__a, __b] = a[__a + 0, __b + 0] + b return __b0 # ---------------------------------------------------------------------- a = np.arange(10. * 20.).reshape(10, 20) expected = __kernel(a, None) self.check_against_expected(kernel, expected, a) def test_basic92(self): """ Issue #3497, bool return type evaluating incorrectly. """ def kernel(a): return (a[-1, -1] ^ a[-1, 0] ^ a[-1, 1] ^ a[0, -1] ^ a[0, 0] ^ a[0, 1] ^ a[1, -1] ^ a[1, 0] ^ a[1, 1]) # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __b in range(1, a.shape[1] - 1): for __a in range(1, a.shape[0] - 1): __b0[__a, __b] = (a[__a + -1, __b + -1] ^ a[__a + -1, __b + 0] ^ a[__a + -1, __b + 1] ^ a[__a + 0, __b + -1] ^ a[__a + 0, __b + 0] ^ a[__a + 0, __b + 1] ^ a[__a + 1, __b + -1] ^ a[__a + 1, __b + 0] ^ a[__a + 1, __b + 1]) return __b0 # ---------------------------------------------------------------------- A = np.array(np.arange(20) % 2).reshape(4, 5).astype(np.bool_) expected = __kernel(A, None) self.check_against_expected(kernel, expected, A) def test_basic93(self): """ Issue #3497, bool return type evaluating incorrectly. """ def kernel(a): return (a[-1, -1] ^ a[-1, 0] ^ a[-1, 1] ^ a[0, -1] ^ a[0, 0] ^ a[0, 1] ^ a[1, -1] ^ a[1, 0] ^ a[1, 1]) # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 1, dtype=type(__retdtype)) for __b in range(1, a.shape[1] - 1): for __a in range(1, a.shape[0] - 1): __b0[__a, __b] = (a[__a + -1, __b + -1] ^ a[__a + -1, __b + 0] ^ a[__a + -1, __b + 1] ^ a[__a + 0, __b + -1] ^ a[__a + 0, __b + 0] ^ a[__a + 0, __b + 1] ^ a[__a + 1, __b + -1] ^ a[__a + 1, __b + 0] ^ a[__a + 1, __b + 1]) return __b0 # ---------------------------------------------------------------------- A = np.array(np.arange(20) % 2).reshape(4, 5).astype(np.bool_) expected = __kernel(A, None) self.check_against_expected(kernel, expected, A, options={'cval': True}) def test_basic94(self): """ Issue #3528. Support for slices. """ def kernel(a): return np.median(a[-1:2, -1:2]) # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __bn in range(1, a.shape[1] - 1): for __an in range(1, a.shape[0] - 1): __b0[__an, __bn] = np.median(a[__an + -1:__an + 2, __bn + -1:__bn + 2]) return __b0 # ---------------------------------------------------------------------- a = np.arange(20, dtype=np.uint32).reshape(4, 5) nh = ((-1, 1), (-1, 1),) expected = __kernel(a, nh) self.check_against_expected(kernel, expected, a, options={'neighborhood': nh}) @unittest.skip("not yet supported") def test_basic95(self): """ Slice, calculate neighborhood. """ def kernel(a): return np.median(a[-1:2, -3:4]) #TODO: add check should this be implemented def test_basic96(self): """ 1D slice. """ def kernel(a): return np.median(a[-1:2]) # ---------------------------------------------------------------------- # Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, 0, dtype=type(__retdtype)) for __an in range(1, a.shape[0] - 1): __b0[__an,] = np.median(a[__an + -1:__an + 2]) return __b0 # ---------------------------------------------------------------------- a = np.arange(20, dtype=np.uint32) nh = ((-1, 1),) expected = __kernel(a, nh) self.check_against_expected(kernel, expected, a, options={'neighborhood': nh}) @unittest.skip("not yet supported") def test_basic97(self): """ 2D slice and index. """ def kernel(a): return np.median(a[-1:2, 3]) #TODO: add check should this be implemented def test_basic98(self): """ Test issue #7286 where the cval is a np attr/string-based numerical constant""" for cval in (np.nan, np.inf, -np.inf, float('inf'), -float('inf')): def kernel(a): return a[0, 0] ## ----------------------------------------------------------------- ## Autogenerated kernel def __kernel(a, neighborhood): self.check_stencil_arrays(a, neighborhood=neighborhood) __retdtype = kernel(a) __b0 = np.full(a.shape, cval, dtype=type(__retdtype)) for __bn in range(1, a.shape[1] - 1): for __an in range(1, a.shape[0] - 1): __b0[__an, __bn] = a[__an + 0, __bn + 0] return __b0 ## ----------------------------------------------------------------- a = np.arange(6.).reshape((2, 3)) nh = ((-1, 1), (-1, 1),) expected = __kernel(a, nh) self.check_against_expected(kernel, expected, a, options={'neighborhood': nh, 'cval':cval}) if __name__ == "__main__": unittest.main()