saad
/
ai-content-maker
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ai-content-maker/.venv/Lib/site-packages/numba/tests/test_stencils.py

3224 lines
124 KiB
Python
Raw Normal View History

first commit
2024-05-03 04:18:51 +03:00
#
# 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()