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_np_functions.py

6276 lines
203 KiB
Python
Raw Permalink Blame History

# Tests numpy methods of <class 'function'>
import itertools
import math
import platform
from functools import partial
from itertools import product
import warnings
from textwrap import dedent
import numpy as np
from numba import jit, njit, typeof
from numba.core import types
from numba.typed import List, Dict
from numba.np.numpy_support import numpy_version
from numba.core.errors import TypingError, NumbaDeprecationWarning
from numba.core.config import IS_32BITS
from numba.core.utils import pysignature
from numba.np.extensions import cross2d
from numba.tests.support import (TestCase, MemoryLeakMixin,
needs_blas, run_in_subprocess)
import unittest
def sinc(x):
return np.sinc(x)
def angle1(x):
return np.angle(x)
def angle2(x, deg):
return np.angle(x, deg)
def array_equal(a, b):
return np.array_equal(a, b)
def intersect1d(a, b):
return np.intersect1d(a, b)
def append(arr, values, axis):
return np.append(arr, values, axis=axis)
def count_nonzero(arr, axis):
return np.count_nonzero(arr, axis=axis)
def delete(arr, obj):
return np.delete(arr, obj)
def diff1(a):
return np.diff(a)
def diff2(a, n):
return np.diff(a, n)
def bincount1(a):
return np.bincount(a)
def bincount2(a, w):
return np.bincount(a, weights=w)
def bincount3(a, w=None, minlength=0):
return np.bincount(a, w, minlength)
def searchsorted(a, v):
return np.searchsorted(a, v)
def searchsorted_left(a, v):
return np.searchsorted(a, v, side='left')
def searchsorted_right(a, v):
return np.searchsorted(a, v, side='right')
def digitize(*args):
return np.digitize(*args)
def histogram(*args):
return np.histogram(*args)
def machar(*args):
return np.MachAr()
def iscomplex(x):
return np.iscomplex(x)
def iscomplexobj(x):
return np.iscomplexobj(x)
def isscalar(x):
return np.isscalar(x)
def isreal(x):
return np.isreal(x)
def isrealobj(x):
return np.isrealobj(x)
def isneginf(x, out=None):
return np.isneginf(x, out)
def isposinf(x, out=None):
return np.isposinf(x, out)
def isclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False):
return np.isclose(a, b, rtol, atol, equal_nan)
def isnat(x):
return np.isnat(x)
def iinfo(*args):
return np.iinfo(*args)
def finfo(*args):
return np.finfo(*args)
def finfo_machar(*args):
return np.finfo(*args).machar
def fliplr(a):
return np.fliplr(a)
def flipud(a):
return np.flipud(a)
def flip(a):
return np.flip(a)
def logspace2(start, stop):
return np.logspace(start, stop)
def logspace3(start, stop, num=50):
return np.logspace(start, stop, num=num)
def geomspace2(start, stop):
return np.geomspace(start, stop)
def geomspace3(start, stop, num=50):
return np.geomspace(start, stop, num=num)
def rot90(a):
return np.rot90(a)
def rot90_k(a, k=1):
return np.rot90(a, k)
def array_split(a, indices, axis=0):
return np.array_split(a, indices, axis=axis)
def split(a, indices, axis=0):
return np.split(a, indices, axis=axis)
def vsplit(a, ind_or_sec):
return np.vsplit(a, ind_or_sec)
def hsplit(a, ind_or_sec):
return np.hsplit(a, ind_or_sec)
def dsplit(a, ind_or_sec):
return np.dsplit(a, ind_or_sec)
def correlate(a, v, mode="valid"):
return np.correlate(a, v, mode=mode)
def convolve(a, v, mode="full"):
return np.convolve(a, v, mode=mode)
def tri_n(N):
return np.tri(N)
def tri_n_m(N, M=None):
return np.tri(N, M)
def tri_n_k(N, k=0):
return np.tri(N, k)
def tri_n_m_k(N, M=None, k=0):
return np.tri(N, M, k)
def tril_m(m):
return np.tril(m)
def tril_m_k(m, k=0):
return np.tril(m, k)
def tril_indices_n(n):
return np.tril_indices(n)
def tril_indices_n_k(n, k=0):
return np.tril_indices(n, k)
def tril_indices_n_m(n, m=None):
return np.tril_indices(n, m=m)
def tril_indices_n_k_m(n, k=0, m=None):
return np.tril_indices(n, k, m)
def tril_indices_from_arr(arr):
return np.tril_indices_from(arr)
def tril_indices_from_arr_k(arr, k=0):
return np.tril_indices_from(arr, k)
def triu_m(m):
return np.triu(m)
def triu_m_k(m, k=0):
return np.triu(m, k)
def triu_indices_n(n):
return np.triu_indices(n)
def triu_indices_n_k(n, k=0):
return np.triu_indices(n, k)
def triu_indices_n_m(n, m=None):
return np.triu_indices(n, m=m)
def triu_indices_n_k_m(n, k=0, m=None):
return np.triu_indices(n, k, m)
def triu_indices_from_arr(arr):
return np.triu_indices_from(arr)
def triu_indices_from_arr_k(arr, k=0):
return np.triu_indices_from(arr, k)
def vander(x, N=None, increasing=False):
return np.vander(x, N, increasing)
def partition(a, kth):
return np.partition(a, kth)
def argpartition(a, kth):
return np.argpartition(a, kth)
def cov(m, y=None, rowvar=True, bias=False, ddof=None):
return np.cov(m, y, rowvar, bias, ddof)
def corrcoef(x, y=None, rowvar=True):
return np.corrcoef(x, y, rowvar)
def ediff1d(ary, to_end=None, to_begin=None):
return np.ediff1d(ary, to_end, to_begin)
def roll(a, shift):
return np.roll(a, shift)
def asarray(a):
return np.asarray(a)
def asarray_kws(a, dtype):
return np.asarray(a, dtype=dtype)
def asfarray(a, dtype=np.float64):
return np.asfarray(a, dtype=dtype)
def asfarray_default_kwarg(a):
return np.asfarray(a)
def extract(condition, arr):
return np.extract(condition, arr)
def np_trapz(y):
return np.trapz(y)
def np_trapz_x(y, x):
return np.trapz(y, x)
def np_trapz_dx(y, dx):
return np.trapz(y, dx=dx)
def np_trapz_x_dx(y, x, dx):
return np.trapz(y, x, dx)
def np_allclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False):
return np.allclose(a, b, rtol, atol, equal_nan)
def np_average(a, axis=None, weights=None):
return np.average(a, axis=axis, weights=weights)
def interp(x, xp, fp):
return np.interp(x, xp, fp)
def np_repeat(a, repeats):
return np.repeat(a, repeats)
def array_repeat(a, repeats):
return np.asarray(a).repeat(repeats)
def np_select(condlist, choicelist, default=0):
return np.select(condlist, choicelist, default=default)
def np_select_defaults(condlist, choicelist):
return np.select(condlist, choicelist)
def np_bartlett(M):
return np.bartlett(M)
def np_blackman(M):
return np.blackman(M)
def np_hamming(M):
return np.hamming(M)
def np_hanning(M):
return np.hanning(M)
def np_kaiser(M, beta):
return np.kaiser(M, beta)
def np_cross(a, b):
return np.cross(a, b)
def np_trim_zeros(a, trim='fb'):
return np.trim_zeros(a, trim)
def nb_cross2d(a, b):
return cross2d(a, b)
def flip_lr(a):
return np.fliplr(a)
def flip_ud(a):
return np.flipud(a)
def np_union1d(a, b):
return np.union1d(a,b)
def np_asarray_chkfinite(a, dtype=None):
return np.asarray_chkfinite(a, dtype)
def unwrap(p, discont=None, axis=-1, period=6.283185307179586):
return np.unwrap(p, discont, axis, period=period)
def unwrap1(p):
return np.unwrap(p)
def unwrap13(p, period):
return np.unwrap(p, period=period)
def unwrap123(p, period, discont):
return np.unwrap(p, period=period, discont=discont)
def array_contains(a, key):
return key in a
def swapaxes(a, a1, a2):
return np.swapaxes(a, a1, a2)
def nan_to_num(X, copy=True, nan=0.0):
return np.nan_to_num(X, copy=copy, nan=nan)
def np_indices(dimensions):
return np.indices(dimensions)
def diagflat1(v):
return np.diagflat(v)
def diagflat2(v, k=0):
return np.diagflat(v, k)
class TestNPFunctions(MemoryLeakMixin, TestCase):
"""
Tests for various Numpy functions.
"""
def setUp(self):
super(TestNPFunctions, self).setUp()
self.rnd = np.random.RandomState(42)
def run_unary(self, pyfunc, x_types, x_values, func_extra_types=None,
func_extra_args=None, ignore_sign_on_zero=False, abs_tol=None,
**kwargs):
"""
Runs tests for a unary function operating in the numerical real space.
Parameters
----------
pyfunc : a python function definition holding that calls the numpy
functions to be tested.
x_types: the types of the values being tested, see numba.types
x_values: the numerical values of the values to be tested
func_extra_types: the types of additional arguments to the numpy
function
func_extra_args: additional arguments to the numpy function
ignore_sign_on_zero: boolean as to whether to allow zero values
with incorrect signs to be considered equal
prec: the required precision match, see assertPreciseEqual
Notes:
------
x_types and x_values must have the same length
"""
for tx, vx in zip(x_types, x_values):
if func_extra_args is None:
func_extra_types = func_extra_args = [()]
for xtypes, xargs in zip(func_extra_types, func_extra_args):
cfunc = njit((tx,) + xtypes,)(pyfunc)
got = cfunc(vx, *xargs)
expected = pyfunc(vx, *xargs)
try:
scalty = tx.dtype
except AttributeError:
scalty = tx
prec = ('single'
if scalty in (types.float32, types.complex64)
else 'double')
msg = 'for input %r with prec %r' % (vx, prec)
self.assertPreciseEqual(got, expected,
prec=prec,
msg=msg,
ignore_sign_on_zero=ignore_sign_on_zero,
abs_tol=abs_tol, **kwargs)
def test_sinc(self):
"""
Tests the sinc() function.
This test is purely to assert numerical computations are correct.
"""
# Ignore sign of zeros, this will need masking depending on numpy
# version once the fix to numpy complex division is in upstream
# See: https://github.com/numpy/numpy/pull/6699
isoz = True
# Testing sinc(1.) leads to sin(pi)/pi, which is below machine
# precision in practice on most machines. Small floating point
# differences in sin() etc. may lead to large differences in the result
# that are at a range that is inaccessible using standard width
# floating point representations.
# e.g. Assume float64 type.
# sin(pi) ~= 1e-16, but should be zero
# sin(pi)/pi ~= 1e-17, should be zero, error carried from above
# float64 has log10(2^53)~=15.9 digits of precision and the magnitude
# change in the alg is > 16 digits (1.0...0 -> 0.0...0),
# so comparison via ULP is invalid.
# We therefore opt to assume that values under machine precision are
# equal in this case.
tol = "eps"
pyfunc = sinc
def check(x_types, x_values, **kwargs):
self.run_unary(pyfunc, x_types, x_values,
ignore_sign_on_zero=isoz, abs_tol=tol,
**kwargs)
# real domain scalar context
x_values = [1., -1., 0.0, -0.0, 0.5, -0.5, 5, -5, 5e-21, -5e-21]
x_types = [types.float32, types.float64] * (len(x_values) // 2)
check(x_types, x_values)
# real domain vector context
x_values = [np.array(x_values, dtype=np.float64)]
x_types = [typeof(v) for v in x_values]
check(x_types, x_values)
# complex domain scalar context
x_values = [1.+0j, -1+0j, 0.0+0.0j, -0.0+0.0j, 0+1j, 0-1j, 0.5+0.0j, # noqa
-0.5+0.0j, 0.5+0.5j, -0.5-0.5j, 5+5j, -5-5j, # noqa
# the following are to test sin(x)/x for small x
5e-21+0j, -5e-21+0j, 5e-21j, +(0-5e-21j) # noqa
]
x_types = [types.complex64, types.complex128] * (len(x_values) // 2)
check(x_types, x_values, ulps=2)
# complex domain vector context
x_values = [np.array(x_values, dtype=np.complex128)]
x_types = [typeof(v) for v in x_values]
check(x_types, x_values, ulps=2)
def test_sinc_exceptions(self):
pyfunc = sinc
cfunc = jit(nopython=True)(pyfunc)
with self.assertRaises(TypingError) as raises:
cfunc('str')
self.assertIn('Argument "x" must be a Number or array-like',
str(raises.exception))
# Exceptions leak references
self.disable_leak_check()
def test_contains(self):
def arrs():
a_0 = np.arange(10, 50)
k_0 = 20
yield a_0, k_0
a_1 = np.arange(6)
k_1 = 10
yield a_1, k_1
single_val_a = np.asarray([20])
k_in = 20
k_out = 13
yield single_val_a, k_in
yield single_val_a, k_out
empty_arr = np.asarray([])
yield empty_arr, k_out
# np scalars
bool_arr = np.array([True, False])
yield bool_arr, True
yield bool_arr, k_0
np.random.seed(2)
float_arr = np.random.rand(10)
np.random.seed(2)
rand_k = np.random.rand()
present_k = float_arr[0]
yield float_arr, rand_k
yield float_arr, present_k
complx_arr = float_arr.view(np.complex128)
yield complx_arr, complx_arr[0]
yield complx_arr, rand_k
np.random.seed(2)
uint_arr = np.random.randint(10, size=15, dtype=np.uint8)
yield uint_arr, 5
yield uint_arr, 25
pyfunc = array_contains
cfunc = jit(nopython=True)(pyfunc)
for arr, key in arrs():
expected = pyfunc(arr, key)
received = cfunc(arr, key)
self.assertPreciseEqual(expected, received)
def test_angle(self):
"""
Tests the angle() function.
This test is purely to assert numerical computations are correct.
"""
pyfunc1 = angle1
pyfunc2 = angle2
def check(x_types, x_values):
# angle(x)
self.run_unary(pyfunc1, x_types, x_values)
# angle(x, deg)
xtra_values = [(True,), (False,)]
xtra_types = [(types.bool_,)] * len(xtra_values)
self.run_unary(pyfunc2, x_types, x_values,
func_extra_types=xtra_types,
func_extra_args=xtra_values,)
# real domain scalar context
x_values = [1., -1., 0.0, -0.0, 0.5, -0.5, 5, -5]
x_types = [types.float32, types.float64] * (len(x_values) // 2 + 1)
check(x_types, x_values)
# real domain vector context
x_values = [np.array(x_values, dtype=np.float64)]
x_types = [typeof(v) for v in x_values]
check(x_types, x_values)
# complex domain scalar context
x_values = [1.+0j, -1+0j, 0.0+0.0j, -0.0+0.0j, 1j, -1j, 0.5+0.0j, # noqa
-0.5+0.0j, 0.5+0.5j, -0.5-0.5j, 5+5j, -5-5j] # noqa
x_types = [types.complex64, types.complex128] * (len(x_values) // 2 + 1)
check(x_types, x_values)
# complex domain vector context
x_values = np.array(x_values)
x_types = [types.complex64, types.complex128]
check(x_types, x_values)
def test_angle_return_type(self):
# see issue #8949
def numba_angle(x):
r = np.angle(x)
return r.dtype
pyfunc = numba_angle
x_values = [1., -1., 1. + 0j, -5 - 5j]
x_types = ['f4', 'f8', 'c8', 'c16']
for val, typ in zip(x_values, x_types):
x = np.array([val], dtype=typ)
cfunc = jit(nopython=True)(pyfunc)
expected = pyfunc(x)
got = cfunc(x)
self.assertEqual(expected, got)
def test_angle_exceptions(self):
pyfunc = angle1
cfunc = jit(nopython=True)(pyfunc)
with self.assertRaises(TypingError) as raises:
cfunc('hello')
self.assertIn('Argument "z" must be a complex or Array[complex]',
str(raises.exception))
# Exceptions leak references
self.disable_leak_check()
def test_array_equal(self):
def arrays():
yield np.array([]), np.array([])
yield np.array([1, 2]), np.array([1, 2])
yield np.array([]), np.array([1])
x = np.arange(10).reshape(5, 2)
x[1][1] = 30
yield np.arange(10).reshape(5, 2), x
yield x, x
yield (1, 2, 3), (1, 2, 3)
yield 2, 2
yield 3, 2
yield True, True
yield True, False
yield True, 2
yield True, 1
yield False, 0
pyfunc = array_equal
cfunc = jit(nopython=True)(pyfunc)
for arr, obj in arrays():
expected = pyfunc(arr, obj)
got = cfunc(arr, obj)
self.assertPreciseEqual(expected, got)
def test_array_equal_exception(self):
pyfunc = array_equal
cfunc = jit(nopython=True)(pyfunc)
with self.assertRaises(TypingError) as raises:
cfunc(np.arange(3 * 4).reshape(3, 4), None)
self.assertIn(
'Both arguments to "array_equals" must be array-like',
str(raises.exception)
)
def test_intersect1d(self):
def arrays():
yield [], [] # two empty arrays
yield [1], [] # empty right
yield [], [1] # empty left
yield [1], [2] # singletons no intersection
yield [1], [1] # singletons one intersection
yield [1, 2], [1]
yield [1, 2, 2], [2, 2]
yield [1, 2], [2, 1]
yield [1, 2, 3], [1, 2, 3]
pyfunc = intersect1d
cfunc = jit(nopython=True)(pyfunc)
for a, b in arrays():
a = np.array(a)
b = np.array(b)
expected = pyfunc(a, b)
got = cfunc(a, b)
self.assertPreciseEqual(expected, got)
def test_count_nonzero(self):
def arrays():
yield np.array([]), None
yield np.zeros(10), None
yield np.arange(10), None
yield np.arange(3 * 4 * 5).reshape(3, 4, 5), None
yield np.arange(3 * 4).reshape(3, 4), 0
yield np.arange(3 * 4).reshape(3, 4), 1
pyfunc = count_nonzero
cfunc = jit(nopython=True)(pyfunc)
for arr, axis in arrays():
expected = pyfunc(arr, axis)
got = cfunc(arr, axis)
self.assertPreciseEqual(expected, got)
def test_np_append(self):
def arrays():
yield 2, 2, None
yield np.arange(10), 3, None
yield np.arange(10), np.arange(3), None
yield np.arange(10).reshape(5, 2), np.arange(3), None
yield np.array([[1, 2, 3], [4, 5, 6]]), np.array([[7, 8, 9]]), 0
arr = np.array([[1, 2, 3], [4, 5, 6]])
yield arr, arr, 1
pyfunc = append
cfunc = jit(nopython=True)(pyfunc)
for arr, obj, axis in arrays():
expected = pyfunc(arr, obj, axis)
got = cfunc(arr, obj, axis)
self.assertPreciseEqual(expected, got)
def test_np_append_exceptions(self):
pyfunc = append
cfunc = jit(nopython=True)(pyfunc)
arr = np.array([[1, 2, 3], [4, 5, 6]])
values = np.array([[7, 8, 9]])
axis = 0
# first argument must be array-like
with self.assertRaises(TypingError) as raises:
cfunc(None, values, axis)
self.assertIn(
'The first argument "arr" must be array-like',
str(raises.exception)
)
# second argument must also be array-like
with self.assertRaises(TypingError) as raises:
cfunc(arr, None, axis)
self.assertIn(
'The second argument "values" must be array-like',
str(raises.exception)
)
# third argument must be either nonelike or an integer
with self.assertRaises(TypingError) as raises:
cfunc(arr, values, axis=0.0)
self.assertIn(
'The third argument "axis" must be an integer',
str(raises.exception)
)
# Exceptions leak references
self.disable_leak_check()
def test_delete(self):
def arrays():
# array, obj
#
# an array-like type
yield [1, 2, 3, 4, 5], 3
yield [1, 2, 3, 4, 5], [2, 3]
# 1d array, scalar
yield np.arange(10), 3
yield np.arange(10), -3 # Negative obj
# 1d array, list
yield np.arange(10), [3, 5, 6]
yield np.arange(10), [2, 3, 4, 5]
# 3d array, scalar
yield np.arange(3 * 4 * 5).reshape(3, 4, 5), 2
# 3d array, list
yield np.arange(3 * 4 * 5).reshape(3, 4, 5), [5, 30, 27, 8]
# slices
yield [1, 2, 3, 4], slice(1, 3, 1)
yield np.arange(10), slice(10)
pyfunc = delete
cfunc = jit(nopython=True)(pyfunc)
for arr, obj in arrays():
expected = pyfunc(arr, obj)
got = cfunc(arr, obj)
self.assertPreciseEqual(expected, got)
def test_delete_exceptions(self):
pyfunc = delete
cfunc = jit(nopython=True)(pyfunc)
self.disable_leak_check()
with self.assertRaises(TypingError) as raises:
cfunc([1, 2], 3.14)
self.assertIn(
'obj should be of Integer dtype',
str(raises.exception)
)
with self.assertRaises(TypingError) as raises:
cfunc(np.arange(10), [3.5, 5.6, 6.2])
self.assertIn(
'obj should be of Integer dtype',
str(raises.exception)
)
with self.assertRaises(TypingError) as raises:
cfunc(2, 3)
self.assertIn(
'arr must be either an Array or a Sequence',
str(raises.exception)
)
with self.assertRaises(IndexError) as raises:
cfunc([1, 2], 3)
self.assertIn(
'obj must be less than the len(arr)',
str(raises.exception),
)
# Exceptions leak references
self.disable_leak_check()
def diff_arrays(self):
"""
Some test arrays for np.diff()
"""
a = np.arange(12) ** 3
yield a
b = a.reshape((3, 4))
yield b
c = np.arange(24).reshape((3, 2, 4)) ** 3
yield c
def test_diff1(self):
pyfunc = diff1
cfunc = jit(nopython=True)(pyfunc)
for arr in self.diff_arrays():
expected = pyfunc(arr)
got = cfunc(arr)
self.assertPreciseEqual(expected, got)
# 0-dim array
a = np.array(42)
with self.assertTypingError():
cfunc(a)
def test_diff2(self):
pyfunc = diff2
cfunc = jit(nopython=True)(pyfunc)
for arr in self.diff_arrays():
size = arr.shape[-1]
for n in (0, 1, 2, 3, size - 1, size, size + 1, 421):
expected = pyfunc(arr, n)
got = cfunc(arr, n)
self.assertPreciseEqual(expected, got)
def test_diff2_exceptions(self):
pyfunc = diff2
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
# 0-dim array
arr = np.array(42)
with self.assertTypingError():
cfunc(arr, 1)
# Invalid `n`
arr = np.arange(10)
for n in (-1, -2, -42):
with self.assertRaises(ValueError) as raises:
cfunc(arr, n)
self.assertIn("order must be non-negative", str(raises.exception))
# Exceptions leak references
self.disable_leak_check()
def test_isscalar(self):
def values():
yield 3
yield np.asarray([3])
yield (3,)
yield 3j
yield 'numba'
yield int(10)
yield np.int16(12345)
yield 4.234
yield True
yield None
yield np.timedelta64(10, 'Y')
yield np.datetime64('nat')
yield np.datetime64(1, 'Y')
pyfunc = isscalar
cfunc = jit(nopython=True)(pyfunc)
for x in values():
expected = pyfunc(x)
got = cfunc(x)
self.assertEqual(expected, got, x)
def test_isobj_functions(self):
def values():
yield 1
yield 1 + 0j
yield np.asarray([3, 1 + 0j, True])
yield "hello world"
@jit(nopython=True)
def optional_fn(x, cond, cfunc):
y = x if cond else None
return cfunc(y)
pyfuncs = [iscomplexobj, isrealobj]
for pyfunc in pyfuncs:
cfunc = jit(nopython=True)(pyfunc)
for x in values():
expected = pyfunc(x)
got = cfunc(x)
self.assertEqual(expected, got)
# optional type
expected_optional = optional_fn.py_func(x, True, pyfunc)
got_optional = optional_fn(x, True, cfunc)
self.assertEqual(expected_optional, got_optional)
# none type
expected_none = optional_fn.py_func(x, False, pyfunc)
got_none = optional_fn(x, False, cfunc)
self.assertEqual(expected_none, got_none)
self.assertEqual(len(cfunc.signatures), 8)
def test_is_real_or_complex(self):
def values():
yield np.array([1 + 1j, 1 + 0j, 4.5, 3, 2, 2j])
yield np.array([1, 2, 3])
yield 3
yield 12j
yield 1 + 4j
yield 10 + 0j
yield (1 + 4j, 2 + 0j)
yield np.array([[1, 2], [3, 4], [5, 6], [7, 8]])
pyfuncs = [iscomplex, isreal]
for pyfunc in pyfuncs:
cfunc = jit(nopython=True)(pyfunc)
for x in values():
expected = pyfunc(x)
got = cfunc(x)
self.assertPreciseEqual(expected, got)
def test_isneg_or_ispos_inf(self):
def values():
yield np.NINF, None
yield np.inf, None
yield np.PINF, None
yield np.asarray([-np.inf, 0., np.inf]), None
yield np.NINF, np.zeros(1, dtype=np.bool_)
yield np.inf, np.zeros(1, dtype=np.bool_)
yield np.PINF, np.zeros(1, dtype=np.bool_)
yield np.NINF, np.empty(12)
yield np.asarray([-np.inf, 0., np.inf]), np.zeros(3, dtype=np.bool_)
pyfuncs = [isneginf, isposinf]
for pyfunc in pyfuncs:
cfunc = jit(nopython=True)(pyfunc)
for x, out in values():
expected = pyfunc(x, out)
got = cfunc(x, out)
self.assertPreciseEqual(expected, got)
def test_isclose(self):
rtol = 1e-5
atol = 1e-8
arr = np.array([100, 1000])
aran = np.arange(8).reshape((2, 2, 2))
kw = {'rtol': rtol, 'atol': atol}
def values():
yield 1e10, 1.00001e10, {}
yield 1e10, np.nan, {}
yield np.array([1e-8, 1e-7]), np.array([0.0, 0.0]), {}
yield np.array([1e10, 1e-7]), np.array([1.00001e10, 1e-8]), {}
yield np.array([1e10, 1e-8]), np.array([1.00001e10, 1e-9]), {}
yield np.array([1e10, 1e-8]), np.array([1.0001e10, 1e-9]), {}
yield np.array([1.0, np.nan]), np.array([1.0, np.nan]), {}
yield np.array([1.0, np.nan]), np.array([1.0, np.nan]), {'equal_nan': True} # noqa
yield np.array([np.nan, np.nan]), np.array([1.0, np.nan]), {'equal_nan': True} # noqa
yield np.array([1e-100, 1e-7]), np.array([0.0, 0.0]), {'atol': 0.0}
yield np.array([1e-10, 1e-10]), np.array([1e-20, 0.0]), {}
yield np.array([1e-10, 1e-10]), np.array([1e-20, 0.999999e-10]), {'atol': 0.0} # noqa
yield np.array([1, np.inf, 2]), np.array([3, np.inf, 4]), kw
yield np.array([atol, np.inf, -np.inf, np.nan]), np.array([0]), kw
yield np.array([atol, np.inf, -np.inf, np.nan]), 0, kw
yield 0, np.array([atol, np.inf, -np.inf, np.nan]), kw
# tests taken from
# https://github.com/numpy/numpy/blob/aac965af6032b69d5cb515ad785cc9a331e816f4/numpy/core/tests/test_numeric.py#L2298-L2335 # noqa: E501
# all close tests
yield np.array([0, 1]), np.array([1, 0]), kw
yield arr, arr, kw
yield np.array([1]), np.array([1 + rtol + atol]), kw
yield arr, arr + arr * rtol, kw
yield arr, arr + arr * rtol + atol, kw
yield aran, aran + aran * rtol, kw
yield np.inf, np.inf, kw
yield -np.inf, np.inf, kw
yield np.inf, np.array([np.inf]), kw
yield np.array([np.inf, -np.inf]), np.array([np.inf, -np.inf]), kw
# none close tests
yield np.array([np.inf, 0]), np.array([1, np.inf]), kw
yield np.array([np.inf, -np.inf]), np.array([1, 0]), kw
yield np.array([np.inf, np.inf]), np.array([1, -np.inf]), kw
yield np.array([np.inf, np.inf]), np.array([1, 0]), kw
yield np.array([np.nan, 0]), np.array([np.nan, -np.inf]), kw
yield np.array([atol * 2]), np.array([0]), kw
yield np.array([1]), np.array([1 + rtol + atol * 2]), kw
yield aran, aran + rtol * 1.1 * aran + atol * 1.1, kw
yield np.array(np.array([np.inf, 1])), np.array(np.array([0, np.inf])), kw # noqa
# some close tests
yield np.array([np.inf, 0]), np.array([atol * 2, atol * 2]), kw
yield np.array([np.inf, 0]), np.array([np.inf, atol * 2]), kw
yield np.array([atol, 1, 1e6 * (1 + 2 * rtol) + atol]), np.array([0, np.nan, 1e6]), kw # noqa
yield np.arange(3), np.array([0, 1, 2.1]), kw
yield np.nan, np.array([np.nan, np.nan, np.nan]), kw
yield np.array([0]), np.array([atol, np.inf, -np.inf, np.nan]), kw
yield 0, np.array([atol, np.inf, -np.inf, np.nan]), kw
pyfunc = isclose
cfunc = jit(nopython=True)(pyfunc)
for a, b, kwargs in values():
expected = pyfunc(a, b, **kwargs)
got = cfunc(a, b, **kwargs)
if isinstance(expected, np.bool_):
self.assertEqual(expected, got)
else:
self.assertTrue(np.array_equal(expected, got))
def isclose_exception(self):
pyfunc = isclose
cfunc = jit(nopython=True)(pyfunc)
inps = [
(np.asarray([1e10, 1e-9, np.nan]),
np.asarray([1.0001e10, 1e-9]),
1e-05, 1e-08, False,
"shape mismatch: objects cannot be broadcast to a single shape",
ValueError),
('hello', 3, False, 1e-08, False,
'The first argument "a" must be array-like',
TypingError),
(3, 'hello', False, 1e-08, False,
'The second argument "b" must be array-like',
TypingError),
(2, 3, False, 1e-08, False,
'The third argument "rtol" must be a floating point',
TypingError),
(2, 3, 1e-05, False, False,
'The fourth argument "atol" must be a floating point',
TypingError),
(2, 3, 1e-05, 1e-08, 1,
'The fifth argument "equal_nan" must be a boolean',
TypingError),
]
for a, b, rtol, atol, equal_nan, exc_msg, exc in inps:
with self.assertRaisesRegex(exc, exc_msg):
cfunc(a, b, rtol, atol, equal_nan)
def bincount_sequences(self):
"""
Some test sequences for np.bincount()
"""
a = [1, 2, 5, 2, 3, 20]
b = np.array([5, 8, 42, 5])
c = self.rnd.randint(0, 100, size=300).astype(np.int8)
return (a, b, c)
def test_bincount1(self):
pyfunc = bincount1
cfunc = jit(nopython=True)(pyfunc)
for seq in self.bincount_sequences():
expected = pyfunc(seq)
got = cfunc(seq)
self.assertPreciseEqual(expected, got)
def test_bincount1_exceptions(self):
pyfunc = bincount1
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
# Negative input
with self.assertRaises(ValueError) as raises:
cfunc([2, -1])
self.assertIn("first argument must be non-negative",
str(raises.exception))
# Exceptions leak references
self.disable_leak_check()
def test_bincount2(self):
pyfunc = bincount2
cfunc = jit(nopython=True)(pyfunc)
for seq in self.bincount_sequences():
w = [math.sqrt(x) - 2 for x in seq]
# weights as list, then array, mixed types, check upcast is ok
for weights in (w, np.array(w), seq, np.array(seq)):
expected = pyfunc(seq, weights)
got = cfunc(seq, weights)
self.assertPreciseEqual(expected, got)
def test_bincount2_exceptions(self):
pyfunc = bincount2
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
# Negative input
with self.assertRaises(ValueError) as raises:
cfunc([2, -1], [0, 0])
self.assertIn("first argument must be non-negative",
str(raises.exception))
# Mismatching input sizes
with self.assertRaises(ValueError) as raises:
cfunc([2, -1], [0])
self.assertIn("weights and list don't have the same length",
str(raises.exception))
def test_bincount3(self):
pyfunc = bincount3
cfunc = jit(nopython=True)(pyfunc)
for seq in self.bincount_sequences():
a_max = max(seq)
# Length should be a_max in the first case, minlength in the second
for minlength in (a_max, a_max + 2):
expected = pyfunc(seq, None, minlength)
got = cfunc(seq, None, minlength)
self.assertEqual(len(expected), len(got))
self.assertPreciseEqual(expected, got)
def test_bincount3_exceptions(self):
pyfunc = bincount3
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
# Negative input
with self.assertRaises(ValueError) as raises:
cfunc([2, -1], [0, 0])
self.assertIn("first argument must be non-negative",
str(raises.exception))
# Negative minlength
with self.assertRaises(ValueError) as raises:
cfunc([17, 38], None, -1)
self.assertIn("'minlength' must not be negative",
str(raises.exception))
def test_searchsorted(self):
pyfunc = searchsorted
cfunc = jit(nopython=True)(pyfunc)
pyfunc_left = searchsorted_left
cfunc_left = jit(nopython=True)(pyfunc_left)
pyfunc_right = searchsorted_right
cfunc_right = jit(nopython=True)(pyfunc_right)
def check(a, v):
expected = pyfunc(a, v)
got = cfunc(a, v)
self.assertPreciseEqual(expected, got)
expected = pyfunc_left(a, v)
got = cfunc_left(a, v)
self.assertPreciseEqual(expected, got)
expected = pyfunc_right(a, v)
got = cfunc_right(a, v)
self.assertPreciseEqual(expected, got)
# First with integer values (no NaNs)
bins = np.arange(5) ** 2
values = np.arange(20) - 1
for a in (bins, list(bins)):
# Scalar values
for v in values:
check(a, v)
# Array values
for v in (values, values.reshape((4, 5))):
check(a, v)
# Sequence values
check(a, list(values))
# Second with float values (including NaNs)
bins = np.float64(list(bins) + [float('nan')] * 7) / 2.0
values = np.arange(20) - 0.5
for a in (bins, list(bins)):
# Scalar values
for v in values:
check(a, v)
# Array values
for v in (values, values.reshape((4, 5))):
check(a, v)
# Sequence values
check(a, list(values))
# nonsense value for 'side' raises TypingError
def bad_side(a, v):
return np.searchsorted(a, v, side='nonsense')
cfunc = jit(nopython=True)(bad_side)
with self.assertTypingError():
cfunc([1,2], 1)
# non-constant value for 'side' raises TypingError
def nonconst_side(a, v, side='left'):
return np.searchsorted(a, v, side=side)
cfunc = jit(nopython=True)(nonconst_side)
with self.assertTypingError():
cfunc([1,2], 1, side='right')
# Test unordered values
a = np.array([1, 2, 0])
v = np.array(
[
[5, 4],
[6, 7],
[2, 1],
[0, 3],
]
)
check(a, v)
a = np.array([9, 1, 4, 2, 0, 3, 7, 6, 8])
v = np.array(
[
[5, 10],
[10, 5],
[-1, 5],
]
)
check(a, v)
def test_searchsorted_supplemental(self):
pyfunc = searchsorted
cfunc = jit(nopython=True)(pyfunc)
pyfunc_left = searchsorted_left
cfunc_left = jit(nopython=True)(pyfunc_left)
pyfunc_right = searchsorted_right
cfunc_right = jit(nopython=True)(pyfunc_right)
def check(a, v):
expected = pyfunc(a, v)
got = cfunc(a, v)
self.assertPreciseEqual(expected, got)
expected = pyfunc_left(a, v)
got = cfunc_left(a, v)
self.assertPreciseEqual(expected, got)
expected = pyfunc_right(a, v)
got = cfunc_right(a, v)
self.assertPreciseEqual(expected, got)
element_pool = list(range(-5, 50))
element_pool += [np.nan] * 5 + [np.inf] * 3 + [-np.inf] * 3
for i in range(1000):
sample_size = self.rnd.choice([5, 10, 25])
# `a` and `v` not sorted; either may have repeating values
a = self.rnd.choice(element_pool, sample_size)
v = self.rnd.choice(element_pool, sample_size + (i % 3 - 1))
# output should match numpy regardless of whether `a` is sorted
check(a, v)
check(np.sort(a), v)
ones = np.ones(5)
nans = np.full(len(ones), fill_value=np.nan)
check(ones, ones)
# `a` and / or `v` full of nans
check(ones, nans)
check(nans, ones)
check(nans, nans)
# `v` is zero size
a = np.arange(1)
v = np.arange(0)
check(a, v)
# `a` and `v` booleans
a = np.array([False, False, True, True])
v = np.array([False, True])
check(a, v)
# `v` is a (scalar) boolean
a = [1, 2, 3]
v = True
check(a, v)
# `a` and `v` arrays of strings
a = np.array(['1', '2', '3'])
v = np.array(['2', '4'])
check(a, v)
def test_searchsorted_complex(self):
pyfunc = searchsorted
cfunc = jit(nopython=True)(pyfunc)
pyfunc_left = searchsorted_left
cfunc_left = jit(nopython=True)(pyfunc_left)
pyfunc_right = searchsorted_right
cfunc_right = jit(nopython=True)(pyfunc_right)
def check(a, v):
expected = pyfunc(a, v)
got = cfunc(a, v)
self.assertPreciseEqual(expected, got)
expected = pyfunc_left(a, v)
got = cfunc_left(a, v)
self.assertPreciseEqual(expected, got)
expected = pyfunc_right(a, v)
got = cfunc_right(a, v)
self.assertPreciseEqual(expected, got)
pool = [0, 1, np.nan]
element_pool = [complex(*c) for c in itertools.product(pool, pool)]
for i in range(100):
sample_size = self.rnd.choice([3, 5, len(element_pool)])
# `a` and `v` not sorted; either may have repeating values
a = self.rnd.choice(element_pool, sample_size)
v = self.rnd.choice(element_pool, sample_size + (i % 3 - 1))
# output should match numpy regardless of whether `a` is sorted
check(a, v)
check(np.sort(a), v)
# check type promotion (a complex; v not so much)
check(a=np.array(element_pool), v=np.arange(2))
def test_digitize(self):
pyfunc = digitize
cfunc = jit(nopython=True)(pyfunc)
def check(*args):
expected = pyfunc(*args)
got = cfunc(*args)
self.assertPreciseEqual(expected, got)
values = np.float64((0, 0.99, 1, 4.4, 4.5, 7, 8, 9, 9.5,
float('inf'), float('-inf'), float('nan')))
assert len(values) == 12
self.rnd.shuffle(values)
bins1 = np.float64([1, 3, 4.5, 8])
bins2 = np.float64([1, 3, 4.5, 8, float('inf'), float('-inf')])
bins3 = np.float64([1, 3, 4.5, 8, float('inf'), float('-inf')]
+ [float('nan')] * 10)
all_bins = [bins1, bins2, bins3]
xs = [values, values.reshape((3, 4))]
# 2-ary digitize()
for bins in all_bins:
bins.sort()
for x in xs:
check(x, bins)
check(x, bins[::-1])
# 3-ary digitize()
for bins in all_bins:
for right in (True, False):
check(values, bins, right)
check(values, bins[::-1], right)
# Sequence input
check(list(values), bins1)
# per https://github.com/numba/numba/issues/8768
check(np.array([np.nan, 1]), np.array([1.5, np.nan]))
def test_digitize_non_monotonic_bins(self):
# Exceptions leak references
self.disable_leak_check()
pyfunc = digitize
cfunc = jit(nopython=True)(pyfunc)
def check_error(*args):
for fn in (pyfunc, cfunc):
with self.assertRaises(ValueError) as raises:
fn(*args)
msg = 'bins must be monotonically increasing or decreasing'
self.assertIn(msg, str(raises.exception))
x = np.array([np.nan, 1])
bins = np.array([np.nan, 1.5, 2.3, np.nan])
check_error(x, bins)
x = [-1, 0, 1, 2]
bins = [0, 0, 1, 0]
check_error(x, bins)
bins = [1, 1, 0, 1]
check_error(x, bins)
def test_digitize_supplemental(self):
# inspired by the tests in
# https://github.com/numpy/numpy/blob/a277f62/numpy/lib/tests/test_function_base.py
pyfunc = digitize
cfunc = jit(nopython=True)(pyfunc)
def check(*args):
expected = pyfunc(*args)
got = cfunc(*args)
self.assertPreciseEqual(expected, got)
# forward
x = np.arange(-6, 5)
bins = np.arange(-5, 5)
check(x, bins)
# reverse
x = np.arange(5, -6, -1)
bins = np.arange(5, -5, -1)
check(x, bins)
# random
x = self.rnd.rand(10)
bins = np.linspace(x.min(), x.max(), 10)
check(x, bins)
# right_basic
x = [1, 5, 4, 10, 8, 11, 0]
bins = [1, 5, 10]
check(x, bins)
# right_open
x = np.arange(-6, 5)
bins = np.arange(-6, 4)
check(x, bins, True)
# right_open_reverse
x = np.arange(5, -6, -1)
bins = np.arange(4, -6, -1)
check(x, bins, True)
# right_open_random
x = self.rnd.rand(10)
bins = np.linspace(x.min(), x.max(), 10)
check(x, bins, True)
# monotonic
x = [-1, 0, 1, 2]
bins = [0, 0, 1]
check(x, bins)
bins = [1, 1, 0]
check(x, bins)
bins = [1, 1, 1, 1]
check(x, bins)
# large_integers_increasing
x = 2 ** 54 # loses precision in a float
check([x], [x - 1, x + 1])
def test_digitize_raise_if_x_complex(self):
# Exceptions leak references
self.disable_leak_check()
pyfunc = digitize
cfunc = jit(nopython=True)(pyfunc)
x = np.array([1 + 1j])
y = np.array([1., 3., 4.5, 8.])
msg = 'x may not be complex'
for func in pyfunc, cfunc:
with self.assertTypingError() as raises:
func(x, y)
self.assertIn(msg, str(raises.exception))
def test_histogram(self):
pyfunc = histogram
cfunc = jit(nopython=True)(pyfunc)
def check(*args):
pyhist, pybins = pyfunc(*args)
chist, cbins = cfunc(*args)
self.assertPreciseEqual(pyhist, chist)
# There can be a slight discrepancy in the linspace() result
# when `bins` is an integer...
self.assertPreciseEqual(pybins, cbins, prec='double', ulps=2)
def check_values(values):
# Explicit bins array
# (note Numpy seems to not support NaN bins)
bins = np.float64([1, 3, 4.5, 8])
check(values, bins)
check(values.reshape((3, 4)), bins)
# Explicit number of bins
check(values, 7)
# Explicit number of bins and bins range
check(values, 7, (1.0, 13.5))
# Implicit bins=10
check(values)
values = np.float64((0, 0.99, 1, 4.4, 4.5, 7, 8,
9, 9.5, 42.5, -1.0, -0.0))
assert len(values) == 12
self.rnd.shuffle(values)
check_values(values)
def _test_correlate_convolve(self, pyfunc):
cfunc = jit(nopython=True)(pyfunc)
# only 1d arrays are accepted, test varying lengths
# and varying dtype
lengths = (1, 2, 3, 7)
dts = [np.int8, np.int32, np.int64, np.float32, np.float64,
np.complex64, np.complex128]
modes = ["full", "valid", "same"]
for dt1, dt2, n, m, mode in itertools.product(
dts, dts, lengths, lengths, modes
):
a = np.arange(n, dtype=dt1)
v = np.arange(m, dtype=dt2)
if np.issubdtype(dt1, np.complexfloating):
a = (a + 1j * a).astype(dt1)
if np.issubdtype(dt2, np.complexfloating):
v = (v + 1j * v).astype(dt2)
expected = pyfunc(a, v, mode=mode)
got = cfunc(a, v, mode=mode)
self.assertPreciseEqual(expected, got)
_a = np.arange(12).reshape(4, 3)
_b = np.arange(12)
for x, y in [(_a, _b), (_b, _a)]:
with self.assertRaises(TypingError) as raises:
cfunc(x, y)
msg = 'only supported on 1D arrays'
self.assertIn(msg, str(raises.exception))
def test_correlate(self):
self._test_correlate_convolve(correlate)
def _test_correlate_convolve_exceptions(self, fn):
# Exceptions leak references
self.disable_leak_check()
# convolve raises if either array has a 0 dimension
_a = np.ones(shape=(0,))
_b = np.arange(5)
cfunc = jit(nopython=True)(fn)
for x, y in [(_a, _b), (_b, _a)]:
with self.assertRaises(ValueError) as raises:
cfunc(x, y)
if len(x) == 0:
self.assertIn("'a' cannot be empty", str(raises.exception))
else:
self.assertIn("'v' cannot be empty", str(raises.exception))
with self.assertRaises(ValueError) as raises:
cfunc(_b, _b, mode="invalid mode")
self.assertIn("Invalid 'mode'", str(raises.exception))
def test_correlate_exceptions(self):
# correlate supported 0 dimension arrays until 1.18
self._test_correlate_convolve_exceptions(correlate)
def test_convolve(self):
self._test_correlate_convolve(convolve)
def test_convolve_exceptions(self):
self._test_correlate_convolve_exceptions(convolve)
def _check_output(self, pyfunc, cfunc, params, abs_tol=None):
expected = pyfunc(**params)
got = cfunc(**params)
self.assertPreciseEqual(expected, got, abs_tol=abs_tol)
def test_vander_basic(self):
pyfunc = vander
cfunc = jit(nopython=True)(pyfunc)
_check_output = partial(self._check_output, pyfunc, cfunc)
def _check(x):
n_choices = [None, 0, 1, 2, 3, 4]
increasing_choices = [True, False]
# N and increasing defaulted
params = {'x': x}
_check_output(params)
# N provided and increasing defaulted
for n in n_choices:
params = {'x': x, 'N': n}
_check_output(params)
# increasing provided and N defaulted:
for increasing in increasing_choices:
params = {'x': x, 'increasing': increasing}
_check_output(params)
# both n and increasing supplied
for n in n_choices:
for increasing in increasing_choices:
params = {'x': x, 'N': n, 'increasing': increasing}
_check_output(params)
_check(np.array([1, 2, 3, 5]))
_check(np.arange(7) - 10.5)
_check(np.linspace(3, 10, 5))
_check(np.array([1.2, np.nan, np.inf, -np.inf]))
_check(np.array([]))
_check(np.arange(-5, 5) - 0.3)
# # boolean array
_check(np.array([True] * 5 + [False] * 4))
# cycle through dtypes to check type promotion a la numpy
for dtype in np.int32, np.int64, np.float32, np.float64:
_check(np.arange(10, dtype=dtype))
# non array inputs
_check([0, 1, 2, 3])
_check((4, 5, 6, 7))
_check((0.0, 1.0, 2.0))
_check(())
# edge cases
_check((3, 4.444, 3.142))
_check((True, False, 4))
def test_vander_exceptions(self):
pyfunc = vander
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
x = np.arange(5) - 0.5
def _check_n(N):
with self.assertTypingError() as raises:
cfunc(x, N=N)
self.assertIn("Second argument N must be None or an integer",
str(raises.exception))
for N in 1.1, True, np.inf, [1, 2]:
_check_n(N)
with self.assertRaises(ValueError) as raises:
cfunc(x, N=-1)
self.assertIn("Negative dimensions are not allowed",
str(raises.exception))
def _check_1d(x):
with self.assertRaises(ValueError) as raises:
cfunc(x)
self.assertEqual("x must be a one-dimensional array or sequence.",
str(raises.exception))
x = np.arange(27).reshape((3, 3, 3))
_check_1d(x)
x = ((2, 3), (4, 5))
_check_1d(x)
def test_tri_n_basic(self):
pyfunc = tri_n
cfunc = jit(nopython=True)(pyfunc)
_check = partial(self._check_output, pyfunc, cfunc)
def n_variations():
return np.arange(-4, 8) # number of rows
# N supplied, M and k defaulted
for n in n_variations():
params = {'N': n}
_check(params)
def test_tri_n_m_basic(self):
pyfunc = tri_n_m
cfunc = jit(nopython=True)(pyfunc)
_check = partial(self._check_output, pyfunc, cfunc)
def n_variations():
return np.arange(-4, 8) # number of rows
def m_variations():
# number of columns
return itertools.chain.from_iterable(([None], range(-5, 9)))
# N supplied, M and k defaulted
for n in n_variations():
params = {'N': n}
_check(params)
# N and M supplied, k defaulted
for n in n_variations():
for m in m_variations():
params = {'N': n, 'M': m}
_check(params)
def test_tri_n_k_basic(self):
pyfunc = tri_n_k
cfunc = jit(nopython=True)(pyfunc)
_check = partial(self._check_output, pyfunc, cfunc)
def n_variations():
return np.arange(-4, 8) # number of rows
def k_variations():
return np.arange(-10, 10) # offset
# N supplied, M and k defaulted
for n in n_variations():
params = {'N': n}
_check(params)
# N and k supplied, M defaulted
for n in n_variations():
for k in k_variations():
params = {'N': n, 'k': k}
_check(params)
def test_tri_n_m_k_basic(self):
pyfunc = tri_n_m_k
cfunc = jit(nopython=True)(pyfunc)
_check = partial(self._check_output, pyfunc, cfunc)
def n_variations():
return np.arange(-4, 8) # number of rows
def m_variations():
# number of columns
return itertools.chain.from_iterable(([None], range(-5, 9)))
def k_variations():
return np.arange(-10, 10) # offset
# N supplied, M and k defaulted
for n in n_variations():
params = {'N': n}
_check(params)
# N and M supplied, k defaulted
for n in n_variations():
for m in m_variations():
params = {'N': n, 'M': m}
_check(params)
# N and k supplied, M defaulted
for n in n_variations():
for k in k_variations():
params = {'N': n, 'k': k}
_check(params)
# N, M and k supplied
for n in n_variations():
for k in k_variations():
for m in m_variations():
params = {'N': n, 'M': m, 'k': k}
_check(params)
def test_tri_exceptions(self):
pyfunc = tri_n_m_k
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
def _check(k):
with self.assertTypingError() as raises:
cfunc(5, 6, k=k)
assert "k must be an integer" in str(raises.exception)
for k in 1.5, True, np.inf, [1, 2]:
_check(k)
def _triangular_matrix_tests_m(self, pyfunc):
cfunc = jit(nopython=True)(pyfunc)
def _check(arr):
expected = pyfunc(arr)
got = cfunc(arr)
# TODO: Contiguity of result not consistent with numpy
self.assertEqual(got.dtype, expected.dtype)
np.testing.assert_array_equal(got, expected)
return self._triangular_matrix_tests_inner(self, pyfunc, _check)
def _triangular_matrix_tests_m_k(self, pyfunc):
cfunc = jit(nopython=True)(pyfunc)
def _check(arr):
for k in itertools.chain.from_iterable(([None], range(-10, 10))):
if k is None:
params = {}
else:
params = {'k': k}
expected = pyfunc(arr, **params)
got = cfunc(arr, **params)
# TODO: Contiguity of result not consistent with numpy
self.assertEqual(got.dtype, expected.dtype)
np.testing.assert_array_equal(got, expected)
return self._triangular_matrix_tests_inner(self, pyfunc, _check)
@staticmethod
def _triangular_matrix_tests_inner(self, pyfunc, _check):
def check_odd(a):
_check(a)
a = a.reshape((9, 7))
_check(a)
a = a.reshape((7, 1, 3, 3))
_check(a)
_check(a.T)
def check_even(a):
_check(a)
a = a.reshape((4, 16))
_check(a)
a = a.reshape((4, 2, 2, 4))
_check(a)
_check(a.T)
check_odd(np.arange(63) + 10.5)
check_even(np.arange(64) - 10.5)
# edge cases
_check(np.arange(360).reshape(3, 4, 5, 6))
_check(np.array([]))
_check(np.arange(9).reshape((3, 3))[::-1])
_check(np.arange(9).reshape((3, 3), order='F'))
arr = (np.arange(64) - 10.5).reshape((4, 2, 2, 4))
_check(arr)
_check(np.asfortranarray(arr))
def _triangular_matrix_exceptions(self, pyfunc):
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
a = np.ones((5, 6))
with self.assertTypingError() as raises:
cfunc(a, k=1.5)
self.assertIn("k must be an integer", str(raises.exception))
def _triangular_indices_tests_base(self, pyfunc, args):
cfunc = jit(nopython=True)(pyfunc)
for x in args:
expected = pyfunc(*x)
got = cfunc(*x)
self.assertEqual(type(expected), type(got))
self.assertEqual(len(expected), len(got))
for e, g in zip(expected, got):
np.testing.assert_array_equal(e, g)
def _triangular_indices_tests_n(self, pyfunc):
self._triangular_indices_tests_base(
pyfunc,
[[n] for n in range(10)]
)
def _triangular_indices_tests_n_k(self, pyfunc):
self._triangular_indices_tests_base(
pyfunc,
[[n, k] for n in range(10) for k in range(-n - 1, n + 2)]
)
def _triangular_indices_tests_n_m(self, pyfunc):
self._triangular_indices_tests_base(
pyfunc,
[[n, m] for n in range(10) for m in range(2 * n)]
)
def _triangular_indices_tests_n_k_m(self, pyfunc):
self._triangular_indices_tests_base(
pyfunc,
[[n, k, m] for n in range(10)
for k in range(-n - 1, n + 2)
for m in range(2 * n)]
)
# Check jitted version works with default values for kwargs
cfunc = jit(nopython=True)(pyfunc)
cfunc(1)
def _triangular_indices_from_tests_arr(self, pyfunc):
cfunc = jit(nopython=True)(pyfunc)
for dtype in [int, float, bool]:
for n,m in itertools.product(range(10), range(10)):
arr = np.ones((n, m), dtype)
expected = pyfunc(arr)
got = cfunc(arr)
self.assertEqual(type(expected), type(got))
self.assertEqual(len(expected), len(got))
for e, g in zip(expected, got):
np.testing.assert_array_equal(e, g)
def _triangular_indices_from_tests_arr_k(self, pyfunc):
cfunc = jit(nopython=True)(pyfunc)
for dtype in [int, float, bool]:
for n,m in itertools.product(range(10), range(10)):
arr = np.ones((n, m), dtype)
for k in range(-10, 10):
expected = pyfunc(arr)
got = cfunc(arr)
self.assertEqual(type(expected), type(got))
self.assertEqual(len(expected), len(got))
for e, g in zip(expected, got):
np.testing.assert_array_equal(e, g)
def _triangular_indices_exceptions(self, pyfunc):
cfunc = jit(nopython=True)(pyfunc)
parameters = pysignature(pyfunc).parameters
with self.assertTypingError() as raises:
cfunc(1.0)
self.assertIn("n must be an integer", str(raises.exception))
if 'k' in parameters:
with self.assertTypingError() as raises:
cfunc(1, k=1.0)
self.assertIn("k must be an integer", str(raises.exception))
if 'm' in parameters:
with self.assertTypingError() as raises:
cfunc(1, m=1.0)
self.assertIn("m must be an integer", str(raises.exception))
def _triangular_indices_from_exceptions(self, pyfunc, test_k=True):
cfunc = jit(nopython=True)(pyfunc)
for ndims in [0, 1, 3]:
a = np.ones([5] * ndims)
with self.assertTypingError() as raises:
cfunc(a)
self.assertIn("input array must be 2-d", str(raises.exception))
if test_k:
a = np.ones([5, 5])
with self.assertTypingError() as raises:
cfunc(a, k=0.5)
self.assertIn("k must be an integer", str(raises.exception))
def test_tril_basic(self):
self._triangular_matrix_tests_m(tril_m)
self._triangular_matrix_tests_m_k(tril_m_k)
def test_tril_exceptions(self):
self._triangular_matrix_exceptions(tril_m_k)
def test_tril_indices(self):
self._triangular_indices_tests_n(tril_indices_n)
self._triangular_indices_tests_n_k(tril_indices_n_k)
self._triangular_indices_tests_n_m(tril_indices_n_m)
self._triangular_indices_tests_n_k_m(tril_indices_n_k_m)
self._triangular_indices_exceptions(tril_indices_n)
self._triangular_indices_exceptions(tril_indices_n_k)
self._triangular_indices_exceptions(tril_indices_n_m)
self._triangular_indices_exceptions(tril_indices_n_k_m)
def test_tril_indices_from(self):
self._triangular_indices_from_tests_arr(tril_indices_from_arr)
self._triangular_indices_from_tests_arr_k(tril_indices_from_arr_k)
self._triangular_indices_from_exceptions(tril_indices_from_arr, False)
self._triangular_indices_from_exceptions(tril_indices_from_arr_k, True)
def test_triu_basic(self):
self._triangular_matrix_tests_m(triu_m)
self._triangular_matrix_tests_m_k(triu_m_k)
def test_triu_exceptions(self):
self._triangular_matrix_exceptions(triu_m_k)
def test_triu_indices(self):
self._triangular_indices_tests_n(triu_indices_n)
self._triangular_indices_tests_n_k(triu_indices_n_k)
self._triangular_indices_tests_n_m(triu_indices_n_m)
self._triangular_indices_tests_n_k_m(triu_indices_n_k_m)
self._triangular_indices_exceptions(triu_indices_n)
self._triangular_indices_exceptions(triu_indices_n_k)
self._triangular_indices_exceptions(triu_indices_n_m)
self._triangular_indices_exceptions(triu_indices_n_k_m)
def test_triu_indices_from(self):
self._triangular_indices_from_tests_arr(triu_indices_from_arr)
self._triangular_indices_from_tests_arr_k(triu_indices_from_arr_k)
self._triangular_indices_from_exceptions(triu_indices_from_arr, False)
self._triangular_indices_from_exceptions(triu_indices_from_arr_k, True)
def test_indices_basic(self):
pyfunc = np_indices
cfunc = njit(np_indices)
def inputs():
# Taken from https://github.com/numpy/numpy/blob/db4f43983cb938f12c311e1f5b7165e270c393b4/numpy/core/tests/test_numeric.py#L3383-L3407 # noqa: E501
yield (4, 3)
yield (4,)
yield (0,)
yield (2, 2, 3, 5)
for dims in inputs():
self.assertPreciseEqual(pyfunc(dims), cfunc(dims))
def test_indices_exception(self):
cfunc = njit(np_indices)
self.disable_leak_check()
errmsg = 'The argument "dimensions" must be a tuple of integers'
with self.assertRaises(TypingError) as raises:
cfunc("abc")
self.assertIn(errmsg,
str(raises.exception))
with self.assertRaises(TypingError) as raises:
cfunc((2.0, 3.0))
self.assertIn(errmsg,
str(raises.exception))
with self.assertRaises(TypingError) as raises:
cfunc((2, 3.0))
self.assertIn(errmsg,
str(raises.exception))
def partition_sanity_check(self, pyfunc, cfunc, a, kth):
# as NumPy uses a different algorithm, we do not expect to
# match outputs exactly...
expected = pyfunc(a, kth)
got = cfunc(a, kth)
# but we do expect the unordered collection of elements up to the
# kth to tie out
self.assertPreciseEqual(np.unique(expected[:kth]), np.unique(got[:kth]))
# likewise the unordered collection of elements from the kth onwards
self.assertPreciseEqual(np.unique(expected[kth:]), np.unique(got[kth:]))
def argpartition_sanity_check(self, pyfunc, cfunc, a, kth):
# as NumPy uses a different algorithm, we do not expect to
# match outputs exactly...
expected = pyfunc(a, kth)
got = cfunc(a, kth)
# but we do expect the unordered collection of elements up to the
# kth to tie out
self.assertPreciseEqual(np.unique(a[expected[:kth]]),
np.unique(a[got[:kth]]))
# likewise the unordered collection of elements from the kth onwards
self.assertPreciseEqual(np.unique(a[expected[kth:]]),
np.unique(a[got[kth:]]))
def test_partition_fuzz(self):
# inspired by the test of the same name in:
# https://github.com/numpy/numpy/blob/043a840/numpy/core/tests/test_multiarray.py # noqa: E501
pyfunc = partition
cfunc = jit(nopython=True)(pyfunc)
for j in range(10, 30):
for i in range(1, j - 2):
d = np.arange(j)
self.rnd.shuffle(d)
d = d % self.rnd.randint(2, 30)
idx = self.rnd.randint(d.size)
kth = [0, idx, i, i + 1, -idx, -i] # include negative kth's
tgt = np.sort(d)[kth]
self.assertPreciseEqual(cfunc(d, kth)[kth],
tgt) # a -> array
self.assertPreciseEqual(cfunc(d.tolist(), kth)[kth],
tgt) # a -> list
self.assertPreciseEqual(cfunc(tuple(d.tolist()), kth)[kth],
tgt) # a -> tuple
for k in kth:
self.partition_sanity_check(pyfunc, cfunc, d, k)
def test_argpartition_fuzz(self):
# inspired by the test of the same name in:
# https://github.com/numpy/numpy/blob/043a840/numpy/core/tests/test_multiarray.py # noqa: E501
pyfunc = argpartition
cfunc = jit(nopython=True)(pyfunc)
for j in range(10, 30):
for i in range(1, j - 2):
d = np.arange(j)
self.rnd.shuffle(d)
d = d % self.rnd.randint(2, 30)
idx = self.rnd.randint(d.size)
kth = [0, idx, i, i + 1, -idx, -i] # include negative kth's
tgt = np.argsort(d)[kth]
self.assertPreciseEqual(d[cfunc(d, kth)[kth]],
d[tgt]) # a -> array
self.assertPreciseEqual(d[cfunc(d.tolist(), kth)[kth]],
d[tgt]) # a -> list
self.assertPreciseEqual(d[cfunc(tuple(d.tolist()), kth)[kth]],
d[tgt]) # a -> tuple
for k in kth:
self.argpartition_sanity_check(pyfunc, cfunc, d, k)
def test_partition_exception_out_of_range(self):
# inspired by the test of the same name in:
# https://github.com/numpy/numpy/blob/043a840/numpy/core/tests/test_multiarray.py # noqa: E501
pyfunc = partition
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
# Test out of range values in kth raise an error
a = np.arange(10)
def _check(a, kth):
with self.assertRaises(ValueError) as e:
cfunc(a, kth)
assert str(e.exception) == "kth out of bounds"
_check(a, 10)
_check(a, -11)
_check(a, (3, 30))
def test_argpartition_exception_out_of_range(self):
# inspired by the test of the same name in:
# https://github.com/numpy/numpy/blob/043a840/numpy/core/tests/test_multiarray.py # noqa: E501
pyfunc = argpartition
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
# Test out of range values in kth raise an error
a = np.arange(10)
def _check(a, kth):
with self.assertRaises(ValueError) as e:
cfunc(a, kth)
assert str(e.exception) == "kth out of bounds"
_check(a, 10)
_check(a, -11)
_check(a, (3, 30))
def test_partition_exception_non_integer_kth(self):
# inspired by the test of the same name in:
# https://github.com/numpy/numpy/blob/043a840/numpy/core/tests/test_multiarray.py # noqa: E501
pyfunc = partition
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
def _check(a, kth):
with self.assertTypingError() as raises:
cfunc(a, kth)
self.assertIn("Partition index must be integer",
str(raises.exception))
a = np.arange(10)
_check(a, 9.0)
_check(a, (3.3, 4.4))
_check(a, np.array((1, 2, np.nan)))
def test_argpartition_exception_non_integer_kth(self):
# inspired by the test of the same name in:
# https://github.com/numpy/numpy/blob/043a840/numpy/core/tests/test_multiarray.py # noqa: E501
pyfunc = argpartition
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
def _check(a, kth):
with self.assertTypingError() as raises:
cfunc(a, kth)
self.assertIn("Partition index must be integer",
str(raises.exception))
a = np.arange(10)
_check(a, 9.0)
_check(a, (3.3, 4.4))
_check(a, np.array((1, 2, np.nan)))
def test_partition_exception_a_not_array_like(self):
pyfunc = partition
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
def _check(a, kth):
with self.assertTypingError() as raises:
cfunc(a, kth)
self.assertIn('The first argument must be an array-like',
str(raises.exception))
_check(4, 0)
_check('Sausages', 0)
def test_argpartition_exception_a_not_array_like(self):
pyfunc = argpartition
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
def _check(a, kth):
with self.assertTypingError() as raises:
cfunc(a, kth)
self.assertIn('The first argument must be an array-like',
str(raises.exception))
_check(4, 0)
_check('Sausages', 0)
def test_partition_exception_a_zero_dim(self):
pyfunc = partition
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
def _check(a, kth):
with self.assertTypingError() as raises:
cfunc(a, kth)
self.assertIn('The first argument must be at least 1-D (found 0-D)',
str(raises.exception))
_check(np.array(1), 0)
def test_argpartition_exception_a_zero_dim(self):
pyfunc = argpartition
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
def _check(a, kth):
with self.assertTypingError() as raises:
cfunc(a, kth)
self.assertIn('The first argument must be at least 1-D (found 0-D)',
str(raises.exception))
_check(np.array(1), 0)
def test_partition_exception_kth_multi_dimensional(self):
pyfunc = partition
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
def _check(a, kth):
with self.assertRaises(ValueError) as raises:
cfunc(a, kth)
self.assertIn('kth must be scalar or 1-D', str(raises.exception))
_check(np.arange(10), kth=np.arange(6).reshape(3, 2))
def test_argpartition_exception_kth_multi_dimensional(self):
pyfunc = argpartition
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
def _check(a, kth):
with self.assertRaises(ValueError) as raises:
cfunc(a, kth)
self.assertIn('kth must be scalar or 1-D', str(raises.exception))
_check(np.arange(10), kth=np.arange(6).reshape(3, 2))
def test_partition_empty_array(self):
# inspired by the test of the same name in:
# https://github.com/numpy/numpy/blob/043a840/numpy/core/tests/test_multiarray.py # noqa: E501
pyfunc = partition
cfunc = jit(nopython=True)(pyfunc)
def check(a, kth=0):
expected = pyfunc(a, kth)
got = cfunc(a, kth)
self.assertPreciseEqual(expected, got)
# check axis handling for multidimensional empty arrays
a = np.array([])
a.shape = (3, 2, 1, 0)
# include this with some other empty data structures
for arr in a, (), np.array([]):
check(arr)
def test_argpartition_empty_array(self):
# inspired by the test of the same name in:
# https://github.com/numpy/numpy/blob/043a840/numpy/core/tests/test_multiarray.py # noqa: E501
pyfunc = argpartition
cfunc = jit(nopython=True)(pyfunc)
def check(a, kth=0):
expected = pyfunc(a, kth)
got = cfunc(a, kth)
self.assertPreciseEqual(expected, got)
# check axis handling for multidimensional empty arrays
a = np.array([])
a.shape = (3, 2, 1, 0)
# include this with some other empty data structures
for arr in a, (), np.array([]):
check(arr)
def test_partition_basic(self):
# inspired by the test of the same name in:
# https://github.com/numpy/numpy/blob/043a840/numpy/core/tests/test_multiarray.py # noqa: E501
pyfunc = partition
cfunc = jit(nopython=True)(pyfunc)
d = np.array([])
got = cfunc(d, 0)
self.assertPreciseEqual(d, got)
d = np.ones(1)
got = cfunc(d, 0)
self.assertPreciseEqual(d, got)
# kth not modified
kth = np.array([30, 15, 5])
okth = kth.copy()
cfunc(np.arange(40), kth)
self.assertPreciseEqual(kth, okth)
for r in ([2, 1], [1, 2], [1, 1]):
d = np.array(r)
tgt = np.sort(d)
for k in 0, 1:
self.assertPreciseEqual(cfunc(d, k)[k], tgt[k])
self.partition_sanity_check(pyfunc, cfunc, d, k)
for r in ([3, 2, 1], [1, 2, 3], [2, 1, 3], [2, 3, 1],
[1, 1, 1], [1, 2, 2], [2, 2, 1], [1, 2, 1]):
d = np.array(r)
tgt = np.sort(d)
for k in 0, 1, 2:
self.assertPreciseEqual(cfunc(d, k)[k], tgt[k])
self.partition_sanity_check(pyfunc, cfunc, d, k)
d = np.ones(50)
self.assertPreciseEqual(cfunc(d, 0), d)
# sorted
d = np.arange(49)
for k in 5, 15:
self.assertEqual(cfunc(d, k)[k], k)
self.partition_sanity_check(pyfunc, cfunc, d, k)
# rsorted, with input flavours: array, list and tuple
d = np.arange(47)[::-1]
for a in d, d.tolist(), tuple(d.tolist()):
self.assertEqual(cfunc(a, 6)[6], 6)
self.assertEqual(cfunc(a, 16)[16], 16)
self.assertPreciseEqual(cfunc(a, -6), cfunc(a, 41))
self.assertPreciseEqual(cfunc(a, -16), cfunc(a, 31))
self.partition_sanity_check(pyfunc, cfunc, d, -16)
# median of 3 killer, O(n^2) on pure median 3 pivot quickselect
# exercises the median of median of 5 code used to keep O(n)
d = np.arange(1000000)
x = np.roll(d, d.size // 2)
mid = x.size // 2 + 1
self.assertEqual(cfunc(x, mid)[mid], mid)
d = np.arange(1000001)
x = np.roll(d, d.size // 2 + 1)
mid = x.size // 2 + 1
self.assertEqual(cfunc(x, mid)[mid], mid)
# max
d = np.ones(10)
d[1] = 4
self.assertEqual(cfunc(d, (2, -1))[-1], 4)
self.assertEqual(cfunc(d, (2, -1))[2], 1)
d[1] = np.nan
assert np.isnan(cfunc(d, (2, -1))[-1])
# equal elements
d = np.arange(47) % 7
tgt = np.sort(np.arange(47) % 7)
self.rnd.shuffle(d)
for i in range(d.size):
self.assertEqual(cfunc(d, i)[i], tgt[i])
self.partition_sanity_check(pyfunc, cfunc, d, i)
d = np.array([0, 1, 2, 3, 4, 5, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 7, 7, 7, 7, 9])
kth = [0, 3, 19, 20]
self.assertEqual(tuple(cfunc(d, kth)[kth]), (0, 3, 7, 7))
td = [(dt, s) for dt in [np.int32, np.float32] for s in (9, 16)]
for dt, s in td:
d = np.arange(s, dtype=dt)
self.rnd.shuffle(d)
d1 = np.tile(np.arange(s, dtype=dt), (4, 1))
map(self.rnd.shuffle, d1)
for i in range(d.size):
p = cfunc(d, i)
self.assertEqual(p[i], i)
# all before are smaller
np.testing.assert_array_less(p[:i], p[i])
# all after are larger
np.testing.assert_array_less(p[i], p[i + 1:])
# sanity check
self.partition_sanity_check(pyfunc, cfunc, d, i)
def test_argpartition_basic(self):
# inspired by the test of the same name in:
# https://github.com/numpy/numpy/blob/043a840/numpy/core/tests/test_multiarray.py # noqa: E501
pyfunc = argpartition
cfunc = jit(nopython=True)(pyfunc)
d = np.array([], dtype=np.int64)
expected = pyfunc(d, 0)
got = cfunc(d, 0)
self.assertPreciseEqual(expected, got)
d = np.ones(1, dtype=np.int64)
expected = pyfunc(d, 0)
got = cfunc(d, 0)
self.assertPreciseEqual(expected, got)
# kth not modified
kth = np.array([30, 15, 5])
okth = kth.copy()
cfunc(np.arange(40), kth)
self.assertPreciseEqual(kth, okth)
for r in ([2, 1], [1, 2], [1, 1]):
d = np.array(r)
tgt = np.argsort(d)
for k in 0, 1:
self.assertPreciseEqual(d[cfunc(d, k)[k]], d[tgt[k]])
self.argpartition_sanity_check(pyfunc, cfunc, d, k)
for r in ([3, 2, 1], [1, 2, 3], [2, 1, 3], [2, 3, 1],
[1, 1, 1], [1, 2, 2], [2, 2, 1], [1, 2, 1]):
d = np.array(r)
tgt = np.argsort(d)
for k in 0, 1, 2:
self.assertPreciseEqual(d[cfunc(d, k)[k]], d[tgt[k]])
self.argpartition_sanity_check(pyfunc, cfunc, d, k)
d = np.ones(50)
self.assertPreciseEqual(d[cfunc(d, 0)], d)
# sorted
d = np.arange(49)
for k in 5, 15:
self.assertEqual(cfunc(d, k)[k], k)
self.partition_sanity_check(pyfunc, cfunc, d, k)
# rsorted, with input flavours: array, list and tuple
d = np.arange(47)[::-1]
for a in d, d.tolist(), tuple(d.tolist()):
self.assertEqual(cfunc(a, 6)[6], 40)
self.assertEqual(cfunc(a, 16)[16], 30)
self.assertPreciseEqual(cfunc(a, -6), cfunc(a, 41))
self.assertPreciseEqual(cfunc(a, -16), cfunc(a, 31))
self.argpartition_sanity_check(pyfunc, cfunc, d, -16)
# median of 3 killer, O(n^2) on pure median 3 pivot quickselect
# exercises the median of median of 5 code used to keep O(n)
d = np.arange(1000000)
x = np.roll(d, d.size // 2)
mid = x.size // 2 + 1
self.assertEqual(x[cfunc(x, mid)[mid]], mid)
d = np.arange(1000001)
x = np.roll(d, d.size // 2 + 1)
mid = x.size // 2 + 1
self.assertEqual(x[cfunc(x, mid)[mid]], mid)
# max
d = np.ones(10)
d[1] = 4
self.assertEqual(d[cfunc(d, (2, -1))[-1]], 4)
self.assertEqual(d[cfunc(d, (2, -1))[2]], 1)
d[1] = np.nan
assert np.isnan(d[cfunc(d, (2, -1))[-1]])
# equal elements
d = np.arange(47) % 7
tgt = np.sort(np.arange(47) % 7)
self.rnd.shuffle(d)
for i in range(d.size):
self.assertEqual(d[cfunc(d, i)[i]], tgt[i])
self.argpartition_sanity_check(pyfunc, cfunc, d, i)
d = np.array([0, 1, 2, 3, 4, 5, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 7, 7, 7, 7, 9])
kth = [0, 3, 19, 20]
self.assertEqual(tuple(d[cfunc(d, kth)[kth]]), (0, 3, 7, 7))
td = [(dt, s) for dt in [np.int32, np.float32] for s in (9, 16)]
for dt, s in td:
d = np.arange(s, dtype=dt)
self.rnd.shuffle(d)
d1 = np.tile(np.arange(s, dtype=dt), (4, 1))
map(self.rnd.shuffle, d1)
for i in range(d.size):
p = d[cfunc(d, i)]
self.assertEqual(p[i], i)
# all before are smaller
np.testing.assert_array_less(p[:i], p[i])
# all after are larger
np.testing.assert_array_less(p[i], p[i + 1:])
# sanity check
self.argpartition_sanity_check(pyfunc, cfunc, d, i)
def assert_partitioned(self, pyfunc, cfunc, d, kth):
prev = 0
for k in np.sort(kth):
np.testing.assert_array_less(d[prev:k], d[k],
err_msg='kth %d' % k)
self.assertTrue((d[k:] >= d[k]).all(),
msg=("kth %d, %r not greater equal "
"%d" % (k, d[k:], d[k])))
prev = k + 1
self.partition_sanity_check(pyfunc, cfunc, d, k)
def assert_argpartitioned(self, pyfunc, cfunc, d, kth):
prev = 0
for k in np.sort(kth):
np.testing.assert_array_less(d[prev:k], d[k],
err_msg='kth %d' % k)
self.assertTrue((d[k:] >= d[k]).all(),
msg=("kth %d, %r not greater equal "
"%d" % (k, d[k:], d[k])))
prev = k + 1
self.argpartition_sanity_check(pyfunc, cfunc, d, k)
def test_partition_iterative(self):
# inspired by the test of the same name in:
# https://github.com/numpy/numpy/blob/043a840/numpy/core/tests/test_multiarray.py
pyfunc = partition
cfunc = jit(nopython=True)(pyfunc)
assert_partitioned = partial(self.assert_partitioned, pyfunc, cfunc)
d = np.array([3, 4, 2, 1])
p = cfunc(d, (0, 3))
assert_partitioned(p, (0, 3))
assert_partitioned(d[np.argpartition(d, (0, 3))], (0, 3))
self.assertPreciseEqual(p, cfunc(d, (-3, -1)))
d = np.arange(17)
self.rnd.shuffle(d)
self.assertPreciseEqual(np.arange(17), cfunc(d, list(range(d.size))))
# test unsorted kth
d = np.arange(17)
self.rnd.shuffle(d)
keys = np.array([1, 3, 8, -2])
self.rnd.shuffle(d)
p = cfunc(d, keys)
assert_partitioned(p, keys)
self.rnd.shuffle(keys)
self.assertPreciseEqual(cfunc(d, keys), p)
# equal kth
d = np.arange(20)[::-1]
assert_partitioned(cfunc(d, [5] * 4), [5])
assert_partitioned(cfunc(d, [5] * 4 + [6, 13]), [5] * 4 + [6, 13])
def test_argpartition_iterative(self):
# inspired by the test of the same name in:
# https://github.com/numpy/numpy/blob/043a840/numpy/core/tests/test_multiarray.py
pyfunc = argpartition
cfunc = jit(nopython=True)(pyfunc)
assert_argpartitioned = partial(self.assert_argpartitioned,
pyfunc,
cfunc)
d = np.array([3, 4, 2, 1])
p = d[cfunc(d, (0, 3))]
assert_argpartitioned(p, (0, 3))
assert_argpartitioned(d[np.argpartition(d, (0, 3))], (0, 3))
self.assertPreciseEqual(p, d[cfunc(d, (-3, -1))])
d = np.arange(17)
self.rnd.shuffle(d)
self.assertPreciseEqual(np.arange(17), d[cfunc(d, list(range(d.size)))])
# test unsorted kth
d = np.arange(17)
self.rnd.shuffle(d)
keys = np.array([1, 3, 8, -2])
self.rnd.shuffle(d)
p = d[cfunc(d, keys)]
assert_argpartitioned(p, keys)
self.rnd.shuffle(keys)
self.assertPreciseEqual(d[cfunc(d, keys)], p)
# equal kth
d = np.arange(20)[::-1]
assert_argpartitioned(d[cfunc(d, [5] * 4)], [5])
assert_argpartitioned(d[cfunc(d, [5] * 4 + [6, 13])], [5] * 4 + [6, 13])
def test_partition_multi_dim(self):
pyfunc = partition
cfunc = jit(nopython=True)(pyfunc)
def check(a, kth):
expected = pyfunc(a, kth)
got = cfunc(a, kth)
self.assertPreciseEqual(expected[:, :, kth], got[:, :, kth])
for s in np.ndindex(expected.shape[:-1]):
self.assertPreciseEqual(np.unique(expected[s][:kth]),
np.unique(got[s][:kth]))
self.assertPreciseEqual(np.unique(expected[s][kth:]),
np.unique(got[s][kth:]))
def a_variations(a):
yield a
yield a.T
yield np.asfortranarray(a)
yield np.full_like(a, fill_value=np.nan)
yield np.full_like(a, fill_value=np.inf)
# multi-dimensional tuple input
yield (((1.0, 3.142, -np.inf, 3),),)
a = np.linspace(1, 10, 48)
a[4:7] = np.nan
a[8] = -np.inf
a[9] = np.inf
a = a.reshape((4, 3, 4))
for arr in a_variations(a):
for k in range(-3, 3):
check(arr, k)
def test_argpartition_multi_dim(self):
pyfunc = argpartition
cfunc = jit(nopython=True)(pyfunc)
def check(a, kth):
expected = pyfunc(a, kth)
got = cfunc(a, kth)
a = np.asarray(a)
idx = np.ndindex(a.shape[:-1])
for s in idx:
self.assertPreciseEqual(a[s][expected[s][kth]],
a[s][got[s][kth]])
for s in np.ndindex(expected.shape[:-1]):
self.assertPreciseEqual(np.unique(a[s][expected[s][:kth]]),
np.unique(a[s][got[s][:kth]]))
self.assertPreciseEqual(np.unique(a[s][expected[s][kth:]]),
np.unique(a[s][got[s][kth:]]))
def a_variations(a):
yield a
yield a.T
yield np.asfortranarray(a)
yield np.full_like(a, fill_value=np.nan)
yield np.full_like(a, fill_value=np.inf)
# multi-dimensional tuple input
yield (((1.0, 3.142, -np.inf, 3),),)
a = np.linspace(1, 10, 48)
a[4:7] = np.nan
a[8] = -np.inf
a[9] = np.inf
a = a.reshape((4, 3, 4))
for arr in a_variations(a):
for k in range(-3, 3):
check(arr, k)
def test_partition_boolean_inputs(self):
pyfunc = partition
cfunc = jit(nopython=True)(pyfunc)
for d in np.linspace(1, 10, 17), np.array((True, False, True)):
for kth in True, False, -1, 0, 1:
self.partition_sanity_check(pyfunc, cfunc, d, kth)
def test_argpartition_boolean_inputs(self):
pyfunc = argpartition
cfunc = jit(nopython=True)(pyfunc)
for d in np.linspace(1, 10, 17), np.array((True, False, True)):
for kth in True, False, -1, 0, 1:
self.argpartition_sanity_check(pyfunc, cfunc, d, kth)
@needs_blas
def test_cov_invalid_ddof(self):
pyfunc = cov
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
m = np.array([[0, 2], [1, 1], [2, 0]]).T
for ddof in np.arange(4), 4j:
with self.assertTypingError() as raises:
cfunc(m, ddof=ddof)
self.assertIn('ddof must be a real numerical scalar type',
str(raises.exception))
for ddof in np.nan, np.inf:
with self.assertRaises(ValueError) as raises:
cfunc(m, ddof=ddof)
self.assertIn('Cannot convert non-finite ddof to integer',
str(raises.exception))
for ddof in 1.1, -0.7:
with self.assertRaises(ValueError) as raises:
cfunc(m, ddof=ddof)
self.assertIn('ddof must be integral value', str(raises.exception))
def corr_corrcoef_basic(self, pyfunc, first_arg_name):
cfunc = jit(nopython=True)(pyfunc)
_check = partial(self._check_output, pyfunc, cfunc, abs_tol=1e-14)
def input_variations():
# array inputs
yield np.array([[0, 2], [1, 1], [2, 0]]).T
yield self.rnd.randn(100).reshape(5, 20)
yield np.asfortranarray(np.array([[0, 2], [1, 1], [2, 0]]).T)
yield self.rnd.randn(100).reshape(5, 20)[:, ::2]
yield np.array([0.3942, 0.5969, 0.7730, 0.9918, 0.7964])
yield np.full((4, 5), fill_value=True)
yield np.array([np.nan, 0.5969, -np.inf, 0.9918, 0.7964])
yield np.linspace(-3, 3, 33).reshape(33, 1)
# non-array inputs
yield ((0.1, 0.2), (0.11, 0.19), (0.09, 0.21)) # UniTuple
yield ((0.1, 0.2), (0.11, 0.19), (0.09j, 0.21j)) # Tuple
yield (-2.1, -1, 4.3)
yield (1, 2, 3)
yield [4, 5, 6]
yield ((0.1, 0.2, 0.3), (0.1, 0.2, 0.3))
yield [(1, 2, 3), (1, 3, 2)]
yield 3.142
yield ((1.1, 2.2, 1.5),)
# empty data structures
yield np.array([])
yield np.array([]).reshape(0, 2)
yield np.array([]).reshape(2, 0)
yield ()
# all inputs other than the first are defaulted
for input_arr in input_variations():
_check({first_arg_name: input_arr})
@needs_blas
def test_corrcoef_basic(self):
pyfunc = corrcoef
self.corr_corrcoef_basic(pyfunc, first_arg_name='x')
@needs_blas
def test_cov_basic(self):
pyfunc = cov
self.corr_corrcoef_basic(pyfunc, first_arg_name='m')
@needs_blas
def test_cov_explicit_arguments(self):
pyfunc = cov
cfunc = jit(nopython=True)(pyfunc)
_check = partial(self._check_output, pyfunc, cfunc, abs_tol=1e-14)
m = self.rnd.randn(105).reshape(15, 7)
y_choices = None, m[::-1]
rowvar_choices = False, True
bias_choices = False, True
ddof_choice = None, -1, 0, 1, 3.0, True
products = itertools.product(y_choices, rowvar_choices,
bias_choices, ddof_choice)
for y, rowvar, bias, ddof in products:
params = {'m': m, 'y': y, 'ddof': ddof,
'bias': bias, 'rowvar': rowvar}
_check(params)
@needs_blas
def test_corrcoef_explicit_arguments(self):
pyfunc = corrcoef
cfunc = jit(nopython=True)(pyfunc)
_check = partial(self._check_output, pyfunc, cfunc, abs_tol=1e-14)
x = self.rnd.randn(105).reshape(15, 7)
y_choices = None, x[::-1]
rowvar_choices = False, True
for y, rowvar in itertools.product(y_choices, rowvar_choices):
params = {'x': x, 'y': y, 'rowvar': rowvar}
_check(params)
def cov_corrcoef_edge_cases(self, pyfunc, first_arg_name):
cfunc = jit(nopython=True)(pyfunc)
_check = partial(self._check_output, pyfunc, cfunc, abs_tol=1e-14)
# some of these examples borrowed from numpy doc string examples:
# https://github.com/numpy/numpy/blob/v1.15.0/numpy/lib/function_base.py#L2199-L2231 # noqa: E501
# some borrowed from TestCov and TestCorrCoef:
# https://github.com/numpy/numpy/blob/80d3a7a/numpy/lib/tests/test_function_base.py # noqa: E501
m = np.array([-2.1, -1, 4.3])
y = np.array([3, 1.1, 0.12])
params = {first_arg_name: m, 'y': y}
_check(params)
m = np.array([1, 2, 3]) # test case modified such that m is 1D
y = np.array([[1j, 2j, 3j]])
params = {first_arg_name: m, 'y': y}
_check(params)
m = np.array([1, 2, 3])
y = (1j, 2j, 3j)
params = {first_arg_name: m, 'y': y}
_check(params)
params = {first_arg_name: y, 'y': m} # flip real and complex inputs
_check(params)
m = np.array([1, 2, 3])
y = (1j, 2j, 3) # note last item is not complex
params = {first_arg_name: m, 'y': y}
_check(params)
params = {first_arg_name: y, 'y': m} # flip real and complex inputs
_check(params)
m = np.array([])
y = np.array([])
params = {first_arg_name: m, 'y': y}
_check(params)
m = 1.1
y = 2.2
params = {first_arg_name: m, 'y': y}
_check(params)
m = self.rnd.randn(10, 3)
y = np.array([-2.1, -1, 4.3]).reshape(1, 3) / 10
params = {first_arg_name: m, 'y': y}
_check(params)
m = np.array([-2.1, -1, 4.3])
y = np.array([[3, 1.1, 0.12], [3, 1.1, 0.12]])
params = {first_arg_name: m, 'y': y}
_check(params)
for rowvar in False, True:
m = np.array([-2.1, -1, 4.3])
y = np.array([[3, 1.1, 0.12], [3, 1.1, 0.12], [4, 1.1, 0.12]])
params = {first_arg_name: m, 'y': y, 'rowvar': rowvar}
_check(params)
# swap m and y
params = {first_arg_name: y, 'y': m, 'rowvar': rowvar}
_check(params)
@needs_blas
def test_corrcoef_edge_cases(self):
pyfunc = corrcoef
self.cov_corrcoef_edge_cases(pyfunc, first_arg_name='x')
cfunc = jit(nopython=True)(pyfunc)
_check = partial(self._check_output, pyfunc, cfunc, abs_tol=1e-14)
for x in (np.nan, -np.inf, 3.142, 0):
params = {'x': x}
_check(params)
@needs_blas
def test_corrcoef_edge_case_extreme_values(self):
pyfunc = corrcoef
cfunc = jit(nopython=True)(pyfunc)
_check = partial(self._check_output, pyfunc, cfunc, abs_tol=1e-14)
# extreme values
x = ((1e-100, 1e100), (1e100, 1e-100))
params = {'x': x}
_check(params)
@needs_blas
def test_cov_edge_cases(self):
pyfunc = cov
self.cov_corrcoef_edge_cases(pyfunc, first_arg_name='m')
cfunc = jit(nopython=True)(pyfunc)
_check = partial(self._check_output, pyfunc, cfunc, abs_tol=1e-14)
# invalid ddof
m = np.array([[0, 2], [1, 1], [2, 0]]).T
params = {'m': m, 'ddof': 5}
_check(params)
@needs_blas
def test_cov_exceptions(self):
pyfunc = cov
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
def _check_m(m):
with self.assertTypingError() as raises:
cfunc(m)
self.assertIn('m has more than 2 dimensions', str(raises.exception))
m = np.ones((5, 6, 7))
_check_m(m)
m = ((((1, 2, 3), (2, 2, 2)),),)
_check_m(m)
m = [[[5, 6, 7]]]
_check_m(m)
def _check_y(m, y):
with self.assertTypingError() as raises:
cfunc(m, y=y)
self.assertIn('y has more than 2 dimensions', str(raises.exception))
m = np.ones((5, 6))
y = np.ones((5, 6, 7))
_check_y(m, y)
m = np.array((1.1, 2.2, 1.1))
y = (((1.2, 2.2, 2.3),),)
_check_y(m, y)
m = np.arange(3)
y = np.arange(4)
with self.assertRaises(ValueError) as raises:
cfunc(m, y=y)
self.assertIn('m and y have incompatible dimensions',
str(raises.exception))
# Numpy raises ValueError: all the input array dimensions except for the
# concatenation axis must match exactly.
m = np.array([-2.1, -1, 4.3]).reshape(1, 3)
with self.assertRaises(RuntimeError) as raises:
cfunc(m)
self.assertIn('2D array containing a single row is unsupported',
str(raises.exception))
def test_ediff1d_basic(self):
pyfunc = ediff1d
cfunc = jit(nopython=True)(pyfunc)
_check = partial(self._check_output, pyfunc, cfunc)
def to_variations(a):
yield None
yield a
yield a.astype(np.int16)
def ary_variations(a):
yield a
yield a.reshape(3, 2, 2)
yield a.astype(np.int32)
for ary in ary_variations(np.linspace(-2, 7, 12)):
params = {'ary': ary}
_check(params)
for a in to_variations(ary):
params = {'ary': ary, 'to_begin': a}
_check(params)
params = {'ary': ary, 'to_end': a}
_check(params)
for b in to_variations(ary):
params = {'ary': ary, 'to_begin': a, 'to_end': b}
_check(params)
def test_ediff1d_exceptions(self):
pyfunc = ediff1d
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
with self.assertTypingError() as e:
cfunc(np.array((True, True, False)))
msg = "Boolean dtype is unsupported (as per NumPy)"
assert msg in str(e.exception)
def test_fliplr_basic(self):
pyfunc = fliplr
cfunc = jit(nopython=True)(pyfunc)
def a_variations():
yield np.arange(10).reshape(5, 2)
yield np.arange(20).reshape(5, 2, 2)
yield ((1, 2),)
yield ([1, 2], [3, 4],)
for a in a_variations():
expected = pyfunc(a)
got = cfunc(a)
self.assertPreciseEqual(expected, got)
with self.assertRaises(TypingError) as raises:
cfunc("abc")
self.assertIn("Cannot np.fliplr on %s type" % types.unicode_type,
str(raises.exception))
def test_fliplr_exception(self):
pyfunc = fliplr
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
with self.assertRaises(TypingError) as raises:
cfunc(np.arange(3))
self.assertIn("cannot index array", str(raises.exception))
self.assertIn("with 2 indices", str(raises.exception))
def test_flipud_basic(self):
pyfunc = flipud
cfunc = jit(nopython=True)(pyfunc)
def a_variations():
yield [1]
yield np.arange(10)
yield np.arange(10).reshape(5, 2)
yield np.arange(20).reshape(5, 2, 2)
yield ((1, 2),)
yield ([1, 2], [3, 4],)
for a in a_variations():
expected = pyfunc(a)
got = cfunc(a)
self.assertPreciseEqual(expected, got)
with self.assertRaises(TypingError) as raises:
cfunc("abc")
self.assertIn("Cannot np.flipud on %s type" % types.unicode_type,
str(raises.exception))
def test_flipud_exception(self):
pyfunc = flipud
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
with self.assertRaises(TypingError) as raises:
cfunc(1)
self.assertIn("cannot index array", str(raises.exception))
self.assertIn("with 1 indices", str(raises.exception))
def test_flip_basic(self):
pyfunc = flip
cfunc = jit(nopython=True)(pyfunc)
def a_variations():
yield np.array(1)
yield np.arange(10)
yield np.arange(10).reshape(5, 2)
yield np.arange(20).reshape(5, 2, 2)
for a in a_variations():
expected = pyfunc(a)
got = cfunc(a)
self.assertPreciseEqual(expected, got)
with self.assertRaises(TypingError) as raises:
cfunc((1, 2, 3))
self.assertIn("Cannot np.flip on UniTuple", str(raises.exception))
def test_logspace2_basic(self):
def inputs():
#start, stop
yield 1, 60
yield -1, 60
yield -60, -1
yield -1, -60
yield 60, -1
yield 1.0, 60.0
yield -60.0, -1.0
yield -1.0, 60.0
yield 0.0, np.e
yield 0.0, np.pi
yield np.complex64(1), np.complex64(2)
yield np.complex64(2j), np.complex64(4j)
yield np.complex64(2), np.complex64(4j)
yield np.complex64(1 + 2j), np.complex64(3 + 4j)
yield np.complex64(1 - 2j), np.complex64(3 - 4j)
yield np.complex64(-1 + 2j), np.complex64(3 + 4j)
pyfunc = logspace2
cfunc = jit(nopython=True)(pyfunc)
for start, stop in inputs():
np.testing.assert_allclose(pyfunc(start, stop), cfunc(start, stop))
def test_logspace2_exception(self):
cfunc = jit(nopython=True)(logspace2)
self.disable_leak_check()
with self.assertRaises(TypingError) as raises:
cfunc("abc", 5)
self.assertIn('The first argument "start" must be a number',
str(raises.exception))
with self.assertRaises(TypingError) as raises:
cfunc(5, "abc")
self.assertIn('The second argument "stop" must be a number',
str(raises.exception))
def test_logspace3_basic(self):
def inputs():
#start, stop
yield 1, 60
yield -1, 60
yield -60, -1
yield -1, -60
yield 60, -1
yield 1.0, 60.0
yield -60.0, -1.0
yield -1.0, 60.0
yield 0.0, np.e
yield 0.0, np.pi
yield np.complex64(1), np.complex64(2)
yield np.complex64(2j), np.complex64(4j)
yield np.complex64(2), np.complex64(4j)
yield np.complex64(1 + 2j), np.complex64(3 + 4j)
yield np.complex64(1 - 2j), np.complex64(3 - 4j)
yield np.complex64(-1 + 2j), np.complex64(3 + 4j)
pyfunc = logspace3
cfunc = jit(nopython=True)(pyfunc)
for start, stop in inputs():
np.testing.assert_allclose(pyfunc(start, stop), cfunc(start, stop))
def test_logspace3_with_num_basic(self):
def inputs():
#start, stop, num
yield 1, 60, 20
yield -1, 60, 30
yield -60, -1, 40
yield -1, -60, 50
yield 60, -1, 60
yield 1.0, 60.0, 70
yield -60.0, -1.0, 80
yield -1.0, 60.0, 90
yield 0.0, np.e, 20
yield 0.0, np.pi, 30
yield np.complex64(1), np.complex64(2), 40
yield np.complex64(2j), np.complex64(4j), 50
yield np.complex64(2), np.complex64(4j), 60
yield np.complex64(1 + 2j), np.complex64(3 + 4j), 70
yield np.complex64(1 - 2j), np.complex64(3 - 4j), 80
yield np.complex64(-1 + 2j), np.complex64(3 + 4j), 90
pyfunc = logspace3
cfunc = jit(nopython=True)(pyfunc)
for start, stop, num in inputs():
np.testing.assert_allclose(pyfunc(start, stop, num),
cfunc(start, stop, num))
def test_logspace3_exception(self):
cfunc = jit(nopython=True)(logspace3)
self.disable_leak_check()
with self.assertRaises(TypingError) as raises:
cfunc("abc", 5)
self.assertIn('The first argument "start" must be a number',
str(raises.exception))
with self.assertRaises(TypingError) as raises:
cfunc(5, "abc")
self.assertIn('The second argument "stop" must be a number',
str(raises.exception))
with self.assertRaises(TypingError) as raises:
cfunc(0, 5, "abc")
self.assertIn('The third argument "num" must be an integer',
str(raises.exception))
def test_geomspace2_basic(self):
def inputs():
#start, stop
yield -1, -60
yield 1.0, 60.0
yield -60.0, -1.0
yield 1, 1000
yield 1000, 1
yield 1, 256
yield -1000, -1
yield -1, np.complex64(2j)
yield np.complex64(2j), -1
yield -1.0, np.complex64(2j)
yield np.complex64(1j), np.complex64(1000j)
yield np.complex64(-1 + 0j), np.complex64(1 + 0j)
yield np.complex64(1), np.complex64(2)
yield np.complex64(2j), np.complex64(4j)
yield np.complex64(2), np.complex64(4j)
yield np.complex64(1 + 2j), np.complex64(3 + 4j)
yield np.complex64(1 - 2j), np.complex64(3 - 4j)
yield np.complex64(-1 + 2j), np.complex64(3 + 4j)
pyfunc = geomspace2
cfunc = jit(nopython=True)(pyfunc)
for start, stop in inputs():
self.assertPreciseEqual(pyfunc(start, stop),
cfunc(start, stop),
abs_tol=1e-12)
def test_geomspace2_exception(self):
cfunc = jit(nopython=True)(geomspace2)
self.disable_leak_check()
with self.assertRaises(TypingError) as raises:
cfunc("abc", 5)
self.assertIn('The argument "start" must be a number',
str(raises.exception))
with self.assertRaises(TypingError) as raises:
cfunc(5, "abc")
self.assertIn('The argument "stop" must be a number',
str(raises.exception))
with self.assertRaises(ValueError) as raises:
cfunc(0, 5)
self.assertIn('Geometric sequence cannot include zero',
str(raises.exception))
with self.assertRaises(ValueError) as raises:
cfunc(5, 0)
self.assertIn('Geometric sequence cannot include zero',
str(raises.exception))
def test_geomspace3_basic(self):
def inputs():
#start, stop, num
yield -1, -60, 50
yield 1.0, 60.0, 70
yield -60.0, -1.0, 80
yield 1, 1000, 4
yield 1, 1000, 3
yield 1000, 1, 4
yield 1, 256, 9
yield -1000, -1, 4
yield -1, np.complex64(2j), 10
yield np.complex64(2j), -1, 20
yield -1.0, np.complex64(2j), 30
yield np.complex64(1j), np.complex64(1000j), 4
yield np.complex64(-1 + 0j), np.complex64(1 + 0j), 5
yield np.complex64(1), np.complex64(2), 40
yield np.complex64(2j), np.complex64(4j), 50
yield np.complex64(2), np.complex64(4j), 60
yield np.complex64(1 + 2j), np.complex64(3 + 4j), 70
yield np.complex64(1 - 2j), np.complex64(3 - 4j), 80
yield np.complex64(-1 + 2j), np.complex64(3 + 4j), 90
pyfunc = geomspace3
cfunc = jit(nopython=True)(pyfunc)
for start, stop, num in inputs():
self.assertPreciseEqual(pyfunc(start, stop, num),
cfunc(start, stop, num),
abs_tol=1e-14)
def test_geomspace3_exception(self):
cfunc = jit(nopython=True)(geomspace3)
self.disable_leak_check()
with self.assertRaises(TypingError) as raises:
cfunc("abc", 5, 10)
self.assertIn('The argument "start" must be a number',
str(raises.exception))
with self.assertRaises(TypingError) as raises:
cfunc(5, "abc", 10)
self.assertIn('The argument "stop" must be a number',
str(raises.exception))
with self.assertRaises(TypingError) as raises:
cfunc(5, 10, "abc")
self.assertIn('The argument "num" must be an integer',
str(raises.exception))
with self.assertRaises(ValueError) as raises:
cfunc(0, 5, 5)
self.assertIn('Geometric sequence cannot include zero',
str(raises.exception))
with self.assertRaises(ValueError) as raises:
cfunc(5, 0, 5)
self.assertIn('Geometric sequence cannot include zero',
str(raises.exception))
def test_geomspace_numpy(self):
cfunc2 = jit(nopython=True)(geomspace2)
cfunc3 = jit(nopython=True)(geomspace3)
pfunc3 = geomspace3
# https://github.com/numpy/numpy/blob/ab2178b47c0ee834180c318db196976623710691/numpy/core/tests/test_function_base.py#L122C3-L142
# test_basic
y = cfunc2(1, 1e6)
self.assertEqual(len(y), 50)
y = cfunc3(1, 1e6, num=100)
self.assertEqual(y[-1], 10 ** 6)
y = cfunc3(1, 1e6, num=7)
self.assertPreciseEqual(y, pfunc3(1,1e6, num=7))
y = cfunc3(8, 2, num=3)
self.assertPreciseEqual(y, pfunc3(8, 2, num=3))
self.assertTrue([x == 0 for x in y.imag])
y = cfunc3(-1, -100, num=3)
self.assertPreciseEqual(y, pfunc3(-1, -100, num=3))
self.assertTrue([x == 0 for x in y.imag])
y = cfunc3(-100, -1, num=3)
self.assertPreciseEqual(y, pfunc3(-100, -1, num=3))
self.assertTrue([x == 0 for x in y.imag])
# test_boundaries_match_start_and_stop_exactly
start = 0.3
stop = 20.3
y = cfunc3(start, stop, num=1)
self.assertPreciseEqual(y[0], start)
y = cfunc3(start, stop, num=3)
self.assertPreciseEqual(y[0], start)
self.assertPreciseEqual(y[-1], stop)
# test_nan_interior
with np.errstate(invalid='ignore'):
y = cfunc3(-3, 3, num=4)
self.assertPreciseEqual(y[0], -3.0)
self.assertTrue(np.isnan(y[1:-1]).all())
self.assertPreciseEqual(y[3], 3.0)
# test_complex
# Purely imaginary
y = cfunc3(1j, 16j, num=5)
self.assertPreciseEqual(y, pfunc3(1j, 16j, num=5), abs_tol=1e-14)
self.assertTrue([x == 0 for x in y.real])
y = cfunc3(-4j, -324j, num=5)
self.assertPreciseEqual(y, pfunc3(-4j, -324j, num=5), abs_tol=1e-13)
self.assertTrue([x == 0 for x in y.real])
y = cfunc3(1 + 1j, 1000 + 1000j, num=4)
self.assertPreciseEqual(y,
pfunc3(1 + 1j, 1000 + 1000j, num=4),
abs_tol=1e-13)
y = cfunc3(-1 + 1j, -1000 + 1000j, num=4)
self.assertPreciseEqual(y,
pfunc3(-1 + 1j, -1000 + 1000j, num=4),
abs_tol=1e-13)
# Logarithmic spirals
y = cfunc3(-1 + 0j, 1 + 0j, num=3)
self.assertPreciseEqual(y, pfunc3(-1 + 0j, 1 + 0j, num=3))
y = cfunc3(0 + 3j, -3 + 0j, 3)
self.assertPreciseEqual(y, pfunc3(0 + 3j, -3 + 0j, 3), abs_tol=1e-15)
y = cfunc3(0 + 3j, 3 + 0j, 3)
self.assertPreciseEqual(y, pfunc3(0 + 3j, 3 + 0j, 3), abs_tol=1e-15)
y = cfunc3(-3 + 0j, 0 - 3j, 3)
self.assertPreciseEqual(y, pfunc3(-3 + 0j, 0 - 3j, 3), abs_tol=1e-15)
y = cfunc3(0 + 3j, -3 + 0j, 3)
self.assertPreciseEqual(y, pfunc3(0 + 3j, -3 + 0j, 3), abs_tol=1e-15)
y = cfunc3(-2 - 3j, 5 + 7j, 7)
self.assertPreciseEqual(y, pfunc3(-2 - 3j, 5 + 7j, 7), abs_tol=1e-14)
y = cfunc3(3j, -5, 2)
self.assertPreciseEqual(y, pfunc3(3j, -5, 2))
y = cfunc3(-5, 3j, 2)
self.assertPreciseEqual(y, pfunc3(-5, 3j, 2))
def test_rot90_basic(self):
pyfunc = rot90
cfunc = jit(nopython=True)(pyfunc)
def a_variations():
yield np.arange(10).reshape(5, 2)
yield np.arange(20).reshape(5, 2, 2)
yield np.arange(64).reshape(2, 2, 2, 2, 2, 2)
for a in a_variations():
expected = pyfunc(a)
got = cfunc(a)
self.assertPreciseEqual(expected, got)
def test_rot90_with_k_basic(self):
pyfunc = rot90_k
cfunc = jit(nopython=True)(pyfunc)
def a_variations():
yield np.arange(10).reshape(5, 2)
yield np.arange(20).reshape(5, 2, 2)
yield np.arange(64).reshape(2, 2, 2, 2, 2, 2)
for a in a_variations():
for k in range(-5, 6):
expected = pyfunc(a, k)
got = cfunc(a, k)
self.assertPreciseEqual(expected, got)
def test_rot90_exception(self):
pyfunc = rot90_k
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
with self.assertRaises(TypingError) as raises:
cfunc("abc")
self.assertIn('The first argument "m" must be an array',
str(raises.exception))
with self.assertRaises(TypingError) as raises:
cfunc(np.arange(4).reshape(2, 2), k="abc")
self.assertIn('The second argument "k" must be an integer',
str(raises.exception))
with self.assertRaises(TypingError) as raises:
cfunc(np.arange(3))
self.assertIn("Input must be >= 2-d.", str(raises.exception))
def _check_split(self, func):
# Since np.split and np.array_split are very similar
pyfunc = func
cfunc = jit(nopython=True)(pyfunc)
def args_variations():
a = np.arange(100)
yield a, 2
yield a, 2, 0
yield a, [1, 4, 72]
yield list(a), [1, 4, 72]
yield tuple(a), [1, 4, 72]
yield a, [1, 4, 72], 0
yield list(a), [1, 4, 72], 0
yield tuple(a), [1, 4, 72], 0
a = np.arange(64).reshape(4, 4, 4)
yield a, 2
yield a, 2, 0
yield a, 2, 1
yield a, [2, 1, 5]
yield a, [2, 1, 5], 1
yield a, [2, 1, 5], 2
yield a, [1, 3]
yield a, [1, 3], 1
yield a, [1, 3], 2
yield a, [1], -1
yield a, [1], -2
yield a, [1], -3
yield a, np.array([], dtype=np.int64), 0
a = np.arange(100).reshape(2, -1)
yield a, 1
yield a, 1, 0
yield a, [1], 0
yield a, 50, 1
yield a, np.arange(10, 50, 10), 1
yield a, (1,)
yield a, (np.int32(4), 10)
a = np.array([])
yield a, 1
yield a, 2
yield a, (2, 3), 0
yield a, 1, 0
a = np.array([[]])
yield a, 1
yield a, (2, 3), 1
yield a, 1, 0
yield a, 1, 1
for args in args_variations():
expected = pyfunc(*args)
got = cfunc(*args)
np.testing.assert_equal(expected, list(got))
def _check_array_split(self, func):
# array_split specific checks, mainly dealing with `int`s
pyfunc = func
cfunc = jit(nopython=True)(pyfunc)
def args_variations():
yield np.arange(8), 3
yield list(np.arange(8)), 3
yield tuple(np.arange(8)), 3
yield np.arange(24).reshape(12, 2), 5
for args in args_variations():
expected = pyfunc(*args)
got = cfunc(*args)
np.testing.assert_equal(expected, list(got))
def test_array_split_basic(self):
self._check_split(array_split)
self._check_array_split(array_split)
def test_split_basic(self):
self._check_split(split)
self.disable_leak_check() # The exception leaks
with self.assertRaises(ValueError) as raises:
njit(split)(np.ones(5), 2)
self.assertIn(
"array split does not result in an equal division",
str(raises.exception)
)
with self.assertRaises(ValueError) as raises:
njit(split)(np.ones(5), [3], axis=-3)
self.assertIn("np.split: Argument axis out of bounds",
str(raises.exception))
def test_vhdsplit_basic(self):
# split and array_split have more comprehensive tests of splitting.
# only do simple tests on vsplit, hsplit and dsplit
# Based on tests from https://github.com/numpy/numpy/blob/f0befec40376fc46fdaceac2c49c7349ad671bde/numpy/lib/tests/test_shape_base.py#L538-L624 # noqa: E501
def inputs1D():
# test_1D_array
yield np.array([1, 2, 3, 4]), 2
yield np.array([1., 2., 3., 4.]), 2
def inputs2D():
# test_2D_array
yield np.array([[1, 2, 3, 4], [1, 2, 3, 4]]), 2
yield np.array([[1., 2., 3., 4.], [1., 2., 3., 4.]]), 2
yield np.arange(16.0).reshape(4, 4), 2
yield np.arange(16.0).reshape(4, 4), np.array([3, 6])
yield np.arange(16.0).reshape(4, 4), [3, 6]
yield np.arange(16.0).reshape(4, 4), (3, 6)
yield np.arange(8.0).reshape(2, 2, 2), 2
def inputs3D():
# test_3D_array
np.array([[[1, 2, 3, 4],
[1, 2, 3, 4]],
[[1, 2, 3, 4],
[1, 2, 3, 4]]]), 2
yield np.arange(16.0).reshape(2, 2, 4), 2
yield np.arange(16.0).reshape(2, 2, 4), np.array([3, 6])
yield np.arange(16.0).reshape(2, 2, 4), [3, 6]
yield np.arange(16.0).reshape(2, 2, 4), (3, 6)
yield np.arange(8.0).reshape(2, 2, 2), 2
inputs = [inputs1D(), inputs2D(), inputs3D()]
for (f, mindim, name) in [(vsplit, 2, "vsplit"),
(hsplit, 1, "hsplit"),
(dsplit, 3, "dsplit")]:
pyfunc = f
cfunc = njit(pyfunc)
for i in range(mindim, 4):
for a, ind_or_sec in inputs[i - 1]:
self.assertPreciseEqual(pyfunc(a, ind_or_sec),
cfunc(a, ind_or_sec))
def test_vhdsplit_exception(self):
# Single test method for vsplit, hsplit and dsplit exceptions
for (f, mindim, name) in [(vsplit, 2, "vsplit"),
(hsplit, 1, "hsplit"),
(dsplit, 3, "dsplit")]:
cfunc = jit(nopython=True)(f)
self.disable_leak_check()
with self.assertRaises(TypingError) as raises:
cfunc(1, 2)
self.assertIn('The argument "ary" must be an array',
str(raises.exception))
with self.assertRaises(TypingError) as raises:
cfunc("abc", 2)
self.assertIn('The argument "ary" must be an array',
str(raises.exception))
with self.assertRaises(TypingError) as raises:
cfunc(np.array([[1, 2, 3, 4], [1, 2, 3, 4]]), "abc")
self.assertIn(('The argument "indices_or_sections" must be int or '
'1d-array'),
str(raises.exception))
with self.assertRaises(ValueError) as raises:
cfunc(np.array(1), 2)
self.assertIn(name + ' only works on arrays of ' + str(mindim) +
' or more dimensions',
str(raises.exception))
def test_roll_basic(self):
pyfunc = roll
cfunc = jit(nopython=True)(pyfunc)
def a_variations():
yield np.arange(7)
yield np.arange(3 * 4 * 5).reshape(3, 4, 5)
yield [1.1, 2.2, 3.3]
yield (True, False, True)
yield False
yield 4
yield (9,)
yield np.asfortranarray(np.array([[1.1, np.nan], [np.inf, 7.8]]))
yield np.array([])
yield ()
def shift_variations():
return itertools.chain.from_iterable(((True, False),
range(-10, 10)))
for a in a_variations():
for shift in shift_variations():
expected = pyfunc(a, shift)
got = cfunc(a, shift)
self.assertPreciseEqual(expected, got)
def test_roll_exceptions(self):
pyfunc = roll
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
for shift in 1.1, (1, 2):
with self.assertTypingError() as e:
cfunc(np.arange(10), shift)
msg = "shift must be an integer"
assert msg in str(e.exception)
def test_extract_basic(self):
pyfunc = extract
cfunc = jit(nopython=True)(pyfunc)
_check = partial(self._check_output, pyfunc, cfunc)
a = np.arange(10)
self.rnd.shuffle(a)
for threshold in range(-3, 13):
cond = a > threshold
_check({'condition': cond, 'arr': a})
a = np.arange(60).reshape(4, 5, 3)
cond = a > 11.2
_check({'condition': cond, 'arr': a})
a = ((1, 2, 3), (3, 4, 5), (4, 5, 6))
cond = np.eye(3).flatten()
_check({'condition': cond, 'arr': a})
a = [1.1, 2.2, 3.3, 4.4]
cond = [1, 1, 0, 1]
_check({'condition': cond, 'arr': a})
a = np.linspace(-2, 10, 6)
element_pool = (True, False, np.nan, -1, -1.0, -1.2, 1, 1.0, 1.5j)
for cond in itertools.combinations_with_replacement(element_pool, 4):
_check({'condition': cond, 'arr': a})
_check({'condition': np.array(cond).reshape(2, 2), 'arr': a})
a = np.array([1, 2, 3])
cond = np.array([])
_check({'condition': cond, 'arr': a})
a = np.array([1, 2, 3])
cond = np.array([1, 0, 1, 0]) # but [1, 0, 1, 0, 1] raises
_check({'condition': cond, 'arr': a})
a = np.array([[1, 2, 3], [4, 5, 6]])
cond = [1, 0, 1, 0, 1, 0] # but [1, 0, 1, 0, 1, 0, 1] raises
_check({'condition': cond, 'arr': a})
a = np.array([[1, 2, 3], [4, 5, 6]])
cond = np.array([1, 0, 1, 0, 1, 0, 0, 0]).reshape(2, 2, 2)
_check({'condition': cond, 'arr': a})
a = np.asfortranarray(np.arange(60).reshape(3, 4, 5))
cond = np.repeat((0, 1), 30)
_check({'condition': cond, 'arr': a})
_check({'condition': cond, 'arr': a[::-1]})
a = np.array(4)
for cond in 0, 1:
_check({'condition': cond, 'arr': a})
a = 1
cond = 1
_check({'condition': cond, 'arr': a})
a = np.array(1)
cond = np.array([True, False])
_check({'condition': cond, 'arr': a})
a = np.arange(4)
cond = np.array([1, 0, 1, 0, 0, 0]).reshape(2, 3) * 1j
_check({'condition': cond, 'arr': a})
def test_extract_exceptions(self):
pyfunc = extract
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
a = np.array([])
cond = np.array([1, 2, 3])
with self.assertRaises(ValueError) as e:
cfunc(cond, a)
self.assertIn('Cannot extract from an empty array', str(e.exception))
def _check(cond, a):
msg = 'condition shape inconsistent with arr shape'
with self.assertRaises(ValueError) as e:
cfunc(cond, a)
self.assertIn(msg, str(e.exception))
a = np.array([[1, 2, 3], [1, 2, 3]])
cond = [1, 0, 1, 0, 1, 0, 1]
_check(cond, a)
a = np.array([1, 2, 3])
cond = np.array([1, 0, 1, 0, 1])
_check(cond, a)
a = np.array(60) # note, this is 0D
cond = 0, 1
_check(cond, a)
a = np.arange(4)
cond = np.array([True, False, False, False, True])
_check(cond, a)
a = np.arange(4)
cond = np.array([True, False, True, False, False, True, False])
_check(cond, a)
def test_np_trapz_basic(self):
pyfunc = np_trapz
cfunc = jit(nopython=True)(pyfunc)
_check = partial(self._check_output, pyfunc, cfunc)
y = [1, 2, 3]
_check({'y': y})
y = (3, 1, 2, 2, 2)
_check({'y': y})
y = np.arange(15).reshape(3, 5)
_check({'y': y})
y = np.linspace(-10, 10, 60).reshape(4, 3, 5)
_check({'y': y}, abs_tol=1e-13)
self.rnd.shuffle(y)
_check({'y': y}, abs_tol=1e-13)
y = np.array([])
_check({'y': y})
y = np.array([3.142, np.nan, np.inf, -np.inf, 5])
_check({'y': y})
y = np.arange(20) + np.linspace(0, 10, 20) * 1j
_check({'y': y})
y = np.array([], dtype=np.complex128)
_check({'y': y})
y = (True, False, True)
_check({'y': y})
def test_np_trapz_x_basic(self):
pyfunc = np_trapz_x
cfunc = jit(nopython=True)(pyfunc)
_check = partial(self._check_output, pyfunc, cfunc)
y = [1, 2, 3]
x = [4, 6, 8]
_check({'y': y, 'x': x})
y = [1, 2, 3, 4, 5]
x = (4, 6)
_check({'y': y, 'x': x})
y = (1, 2, 3, 4, 5)
x = [4, 5, 6, 7, 8]
_check({'y': y, 'x': x})
y = np.array([1, 2, 3, 4, 5])
x = [4, 4]
_check({'y': y, 'x': x})
y = np.array([])
x = np.array([2, 3])
_check({'y': y, 'x': x})
y = (1, 2, 3, 4, 5)
x = None
_check({'y': y, 'x': x})
y = np.arange(20).reshape(5, 4)
x = np.array([4, 5])
_check({'y': y, 'x': x})
y = np.arange(20).reshape(5, 4)
x = np.array([4, 5, 6, 7])
_check({'y': y, 'x': x})
y = np.arange(60).reshape(5, 4, 3)
x = np.array([4, 5])
_check({'y': y, 'x': x})
y = np.arange(60).reshape(5, 4, 3)
x = np.array([4, 5, 7])
_check({'y': y, 'x': x})
y = np.arange(60).reshape(5, 4, 3)
self.rnd.shuffle(y)
x = y + 1.1
self.rnd.shuffle(x)
_check({'y': y, 'x': x})
y = np.arange(20)
x = y + np.linspace(0, 10, 20) * 1j
_check({'y': y, 'x': x})
y = np.array([1, 2, 3])
x = np.array([1 + 1j, 1 + 2j])
_check({'y': y, 'x': x})
@unittest.skip('NumPy behaviour questionable')
def test_trapz_numpy_questionable(self):
# https://github.com/numpy/numpy/issues/12858
pyfunc = np_trapz
cfunc = jit(nopython=True)(pyfunc)
_check = partial(self._check_output, pyfunc, cfunc)
# passes (NumPy and Numba return 2.0)
y = np.array([True, False, True, True]).astype(int)
_check({'y': y})
# fails (NumPy returns 1.5; Numba returns 2.0)
y = np.array([True, False, True, True])
_check({'y': y})
def test_np_trapz_dx_basic(self):
pyfunc = np_trapz_dx
cfunc = jit(nopython=True)(pyfunc)
_check = partial(self._check_output, pyfunc, cfunc)
y = [1, 2, 3]
dx = 2
_check({'y': y, 'dx': dx})
y = [1, 2, 3, 4, 5]
dx = [1, 4, 5, 6]
_check({'y': y, 'dx': dx})
y = [1, 2, 3, 4, 5]
dx = [1, 4, 5, 6]
_check({'y': y, 'dx': dx})
y = np.linspace(-2, 5, 10)
dx = np.nan
_check({'y': y, 'dx': dx})
y = np.linspace(-2, 5, 10)
dx = np.inf
_check({'y': y, 'dx': dx})
y = np.linspace(-2, 5, 10)
dx = np.linspace(-2, 5, 9)
_check({'y': y, 'dx': dx}, abs_tol=1e-13)
y = np.arange(60).reshape(4, 5, 3) * 1j
dx = np.arange(40).reshape(4, 5, 2)
_check({'y': y, 'dx': dx})
x = np.arange(-10, 10, .1)
r = cfunc(np.exp(-.5 * x ** 2) / np.sqrt(2 * np.pi), dx=0.1)
# check integral of normal equals 1
np.testing.assert_almost_equal(r, 1, 7)
y = np.arange(20)
dx = 1j
_check({'y': y, 'dx': dx})
y = np.arange(20)
dx = np.array([5])
_check({'y': y, 'dx': dx})
def test_np_trapz_x_dx_basic(self):
pyfunc = np_trapz_x_dx
cfunc = jit(nopython=True)(pyfunc)
_check = partial(self._check_output, pyfunc, cfunc)
# dx should be ignored
for dx in (None, 2, np.array([1, 2, 3, 4, 5])):
y = [1, 2, 3]
x = [4, 6, 8]
_check({'y': y, 'x': x, 'dx': dx})
y = [1, 2, 3, 4, 5]
x = [4, 6]
_check({'y': y, 'x': x, 'dx': dx})
y = [1, 2, 3, 4, 5]
x = [4, 5, 6, 7, 8]
_check({'y': y, 'x': x, 'dx': dx})
y = np.arange(60).reshape(4, 5, 3)
self.rnd.shuffle(y)
x = y * 1.1
x[2, 2, 2] = np.nan
_check({'y': y, 'x': x, 'dx': dx})
def test_np_trapz_x_dx_exceptions(self):
pyfunc = np_trapz_x_dx
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
def check_not_ok(params):
with self.assertRaises(ValueError) as e:
cfunc(*params)
self.assertIn('unable to broadcast', str(e.exception))
y = [1, 2, 3, 4, 5]
for x in [4, 5, 6, 7, 8, 9], [4, 5, 6]:
check_not_ok((y, x, 1.0))
y = np.arange(60).reshape(3, 4, 5)
x = np.arange(36).reshape(3, 4, 3)
check_not_ok((y, x, 1.0))
y = np.arange(60).reshape(3, 4, 5)
x = np.array([4, 5, 6, 7])
check_not_ok((y, x, 1.0))
y = [1, 2, 3, 4, 5]
dx = np.array([1.0, 2.0])
check_not_ok((y, None, dx))
y = np.arange(60).reshape(3, 4, 5)
dx = np.arange(60).reshape(3, 4, 5)
check_not_ok((y, None, dx))
with self.assertTypingError() as e:
y = np.array(4)
check_not_ok((y, None, 1.0))
self.assertIn('y cannot be 0D', str(e.exception))
for y in 5, False, np.nan:
with self.assertTypingError() as e:
cfunc(y, None, 1.0)
self.assertIn('y cannot be a scalar', str(e.exception))
def test_average(self):
#array of random numbers
N = 100
a = np.random.ranf(N) * 100
w = np.random.ranf(N) * 100
w0 = np.zeros(N)
#boolean array and weights
a_bool = np.random.ranf(N) > 0.5
w_bool = np.random.ranf(N) > 0.5
#array of random ints
a_int = np.random.randint(101, size=N)
w_int = np.random.randint(101, size=N)
#3D array of random numbers
d0 = 100
d1 = 50
d2 = 25
a_3d = np.random.rand(d0,d1,d2) * 100
w_3d = np.random.rand(d0,d1,d2) * 100
pyfunc = np_average
cfunc = jit(nopython=True)(pyfunc)
#test case for average with weights
#(number of elements in array and weight array are equal)
self.assertAlmostEqual( pyfunc(a,weights=w),
cfunc(a,weights=w), places=10)
self.assertAlmostEqual( pyfunc(a_3d,weights=w_3d),
cfunc(a_3d,weights=w_3d), places=10)
#test case for average with array and weights with
#int datatype (number of elements in array and weight array are equal)
self.assertAlmostEqual( pyfunc(a_int,weights=w_int),
cfunc(a_int,weights=w_int), places=10)
#test case for average with boolean weights
self.assertAlmostEqual( pyfunc(a,weights=w_bool),
cfunc(a,weights=w_bool), places=10)
self.assertAlmostEqual( pyfunc(a_bool,weights=w),
cfunc(a_bool,weights=w), places=10)
self.assertAlmostEqual( pyfunc(a_bool, weights=w_bool),
cfunc(a_bool, weights=w_bool), places=10)
#test case for average without weights
self.assertAlmostEqual(pyfunc(a), cfunc(a), places=10)
self.assertAlmostEqual(pyfunc(a_3d), cfunc(a_3d), places=10)
def test_weights_zero_sum(data, weights):
with self.assertRaises(ZeroDivisionError) as e:
cfunc(data, weights=weights)
err = e.exception
self.assertEqual(str(err),
"Weights sum to zero, can't be normalized.")
#test case when sum of weights is zero
test_weights_zero_sum(a, weights=w0)
def test_1D_weights(data, weights):
with self.assertRaises(TypeError) as e:
cfunc(data, weights=weights)
err = e.exception
self.assertEqual(str(err),
"Numba does not support average when shapes of "
"a and weights differ.")
def test_1D_weights_axis(data, axis, weights):
with self.assertRaises(TypeError) as e:
cfunc(data,axis=axis, weights=weights)
err = e.exception
self.assertEqual(str(err),
"Numba does not support average with axis.")
#small case to test exceptions for 2D array and 1D weights
data = np.arange(6).reshape((3,2,1))
w = np.asarray([1. / 4, 3. / 4])
#test without axis argument
test_1D_weights(data, weights=w)
#test with axis argument
test_1D_weights_axis(data, axis=1, weights=w)
def test_allclose(self):
pyfunc = np_allclose
cfunc = jit(nopython=True)(pyfunc)
min_int = np.iinfo(np.int_).min
a = np.array([min_int], dtype=np.int_)
simple_data = [
(np.asarray([1e10, 1e-7]), np.asarray([1.00001e10, 1e-8])),
(np.asarray([1e10, 1e-8]), np.asarray([1.00001e10, 1e-9])),
(np.asarray([1e10, 1e-8]), np.asarray([1.0001e10, 1e-9])),
(np.asarray([1e10]), np.asarray([1.0001e10, 1e-9])),
(1.0, 1.0),
(np.array([np.inf, 1]), np.array([0, np.inf])),
(a, a)
]
for a, b in simple_data:
py_result = pyfunc(a, b)
c_result = cfunc(a, b)
self.assertEqual(py_result, c_result)
a = np.asarray([1.0, np.nan])
b = np.asarray([1.0, np.nan])
self.assertFalse(cfunc(a, b))
self.assertEqual(pyfunc(a, b, equal_nan=True),
cfunc(a, b, equal_nan=True))
b = np.asarray([np.nan, 1.0])
self.assertEqual(pyfunc(a, b), cfunc(a, b))
noise_levels = [1.0, 1e-1, 1e-2, 1e-3, 1e-4, 1e-5, 1e-6, 0.0]
zero_array = np.zeros((25, 4))
a = np.random.ranf((25, 4))
for noise in noise_levels:
for rtol in noise_levels:
for atol in noise_levels:
py_result = pyfunc(zero_array, noise,
atol=atol, rtol=rtol)
c_result = cfunc(zero_array, noise,
atol=atol, rtol=rtol)
self.assertEqual(py_result, c_result)
py_result = pyfunc(noise, zero_array,
atol=atol, rtol=rtol)
c_result = cfunc(noise, zero_array,
atol=atol, rtol=rtol)
self.assertEqual(py_result, c_result)
py_result = pyfunc(np.asarray([noise]), zero_array,
atol=atol, rtol=rtol)
c_result = cfunc(np.asarray([noise]), zero_array,
atol=atol, rtol=rtol)
self.assertEqual(py_result, c_result)
py_result = pyfunc(a, a + noise, atol=atol, rtol=rtol)
c_result = cfunc(a, a + noise, atol=atol, rtol=rtol)
self.assertEqual(py_result, c_result)
py_result = pyfunc(a + noise, a, atol=atol, rtol=rtol)
c_result = cfunc(a + noise, a, atol=atol, rtol=rtol)
self.assertEqual(py_result, c_result)
def test_ip_allclose_numpy(self):
# https://github.com/numpy/numpy/blob/4adc87dff15a247e417d50f10cc4def8e1c17a03/numpy/core/tests/test_numeric.py#L2402-L2420 # noqa: E501
pyfunc = np_allclose
cfunc = jit(nopython=True)(pyfunc)
arr = np.array([100.0, 1000.0])
aran = np.arange(125).astype(dtype=np.float64).reshape((5, 5, 5))
atol = 1e-8
rtol = 1e-5
numpy_data = [
(np.asarray([1, 0]), np.asarray([1, 0])),
(np.asarray([atol]), np.asarray([0.0])),
(np.asarray([1.0]), np.asarray([1 + rtol + atol])),
(arr, arr + arr * rtol),
(arr, arr + arr * rtol + atol * 2),
(aran, aran + aran * rtol),
(np.inf, np.inf),
(np.inf, np.asarray([np.inf]))
]
for (x, y) in numpy_data:
self.assertEqual(pyfunc(x, y), cfunc(x, y))
def test_ip_not_allclose_numpy(self):
# https://github.com/numpy/numpy/blob/4adc87dff15a247e417d50f10cc4def8e1c17a03/numpy/core/tests/test_numeric.py#L2422-L2441 # noqa: E501
pyfunc = np_allclose
cfunc = jit(nopython=True)(pyfunc)
aran = np.arange(125).astype(dtype=np.float64).reshape((5, 5, 5))
atol = 1e-8
rtol = 1e-5
numpy_data = [
(np.asarray([np.inf, 0]), np.asarray([1.0, np.inf])),
(np.asarray([np.inf, 0]), np.asarray([1.0, 0])),
(np.asarray([np.inf, np.inf]), np.asarray([1.0, np.inf])),
(np.asarray([np.inf, np.inf]), np.asarray([1.0, 0.0])),
(np.asarray([-np.inf, 0.0]), np.asarray([np.inf, 0.0])),
(np.asarray([np.nan, 0.0]), np.asarray([np.nan, 0.0])),
(np.asarray([atol * 2]), np.asarray([0.0])),
(np.asarray([1.0]), np.asarray([1 + rtol + atol * 2])),
(aran, aran + aran * atol + atol * 2),
(np.array([np.inf, 1.0]), np.array([0.0, np.inf]))
]
for (x, y) in numpy_data:
self.assertEqual(pyfunc(x, y), cfunc(x, y))
def test_return_class_is_ndarray_numpy(self):
# https://github.com/numpy/numpy/blob/4adc87dff15a247e417d50f10cc4def8e1c17a03/numpy/core/tests/test_numeric.py#L2460-L2468 # noqa: E501
pyfunc = np_allclose
cfunc = jit(nopython=True)(pyfunc)
class Foo(np.ndarray):
def __new__(cls, *args, **kwargs):
return np.array(*args, **kwargs).view(cls)
a = Foo([1])
self.assertTrue(type(cfunc(a, a)) is bool)
def test_equalnan_numpy(self):
# https://github.com/numpy/numpy/blob/4adc87dff15a247e417d50f10cc4def8e1c17a03/numpy/core/tests/test_numeric.py#L2456-L2458 # noqa: E501
pyfunc = np_allclose
cfunc = jit(nopython=True)(pyfunc)
x = np.array([1.0, np.nan])
self.assertEqual(pyfunc(x, x, equal_nan=True),
cfunc(x, x, equal_nan=True))
def test_no_parameter_modification_numpy(self):
# https://github.com/numpy/numpy/blob/4adc87dff15a247e417d50f10cc4def8e1c17a03/numpy/core/tests/test_numeric.py#L2443-L2448 # noqa: E501
pyfunc = np_allclose
cfunc = jit(nopython=True)(pyfunc)
x = np.array([np.inf, 1])
y = np.array([0, np.inf])
cfunc(x, y)
np.testing.assert_array_equal(x, np.array([np.inf, 1]))
np.testing.assert_array_equal(y, np.array([0, np.inf]))
def test_min_int_numpy(self):
# https://github.com/numpy/numpy/blob/4adc87dff15a247e417d50f10cc4def8e1c17a03/numpy/core/tests/test_numeric.py#L2450-L2454 # noqa: E501
pyfunc = np_allclose
cfunc = jit(nopython=True)(pyfunc)
min_int = np.iinfo(np.int_).min
a = np.array([min_int], dtype=np.int_)
self.assertEqual(pyfunc(a, a), cfunc(a, a))
def test_allclose_exception(self):
self.disable_leak_check()
pyfunc = np_allclose
cfunc = jit(nopython=True)(pyfunc)
inps = [
(np.asarray([1e10, 1e-9, np.nan]),
np.asarray([1.0001e10, 1e-9]),
1e-05, 1e-08, False,
"shape mismatch: objects cannot be broadcast to a single shape",
ValueError),
('hello', 3, False, 1e-08, False,
'The first argument "a" must be array-like',
TypingError),
(3, 'hello', False, 1e-08, False,
'The second argument "b" must be array-like',
TypingError),
(2, 3, False, 1e-08, False,
'The third argument "rtol" must be a floating point',
TypingError),
(2, 3, 1e-05, False, False,
'The fourth argument "atol" must be a floating point',
TypingError),
(2, 3, 1e-05, 1e-08, 1,
'The fifth argument "equal_nan" must be a boolean',
TypingError),
]
for a, b, rtol, atol, equal_nan, exc_msg, exc in inps:
with self.assertRaisesRegex(exc, exc_msg):
cfunc(a, b, rtol, atol, equal_nan)
def test_interp_basic(self):
pyfunc = interp
cfunc = jit(nopython=True)(pyfunc)
_check = partial(self._check_output, pyfunc, cfunc, abs_tol=1e-10)
x = np.linspace(-5, 5, 25)
xp = np.arange(-4, 8)
fp = xp + 1.5
_check(params={'x': x, 'xp': xp, 'fp': fp})
self.rnd.shuffle(x)
_check(params={'x': x, 'xp': xp, 'fp': fp})
self.rnd.shuffle(fp)
_check(params={'x': x, 'xp': xp, 'fp': fp})
x[:5] = np.nan
x[-5:] = np.inf
self.rnd.shuffle(x)
_check(params={'x': x, 'xp': xp, 'fp': fp})
fp[:5] = np.nan
fp[-5:] = -np.inf
self.rnd.shuffle(fp)
_check(params={'x': x, 'xp': xp, 'fp': fp})
x = np.arange(-4, 8)
xp = x + 1
fp = x + 2
_check(params={'x': x, 'xp': xp, 'fp': fp})
x = (2.2, 3.3, -5.0)
xp = (2, 3, 4)
fp = (5, 6, 7)
_check(params={'x': x, 'xp': xp, 'fp': fp})
x = ((2.2, 3.3, -5.0), (1.2, 1.3, 4.0))
xp = np.linspace(-4, 4, 10)
fp = np.arange(-5, 5)
_check(params={'x': x, 'xp': xp, 'fp': fp})
x = np.array([1.4, np.nan, np.inf, -np.inf, 0.0, -9.1])
x = x.reshape(3, 2, order='F')
xp = np.linspace(-4, 4, 10)
fp = np.arange(-5, 5)
_check(params={'x': x, 'xp': xp, 'fp': fp})
for x in range(-2, 4):
xp = [0, 1, 2]
fp = (3, 4, 5)
_check(params={'x': x, 'xp': xp, 'fp': fp})
x = np.array([])
xp = [0, 1, 2]
fp = (3, 4, 5)
_check(params={'x': x, 'xp': xp, 'fp': fp})
x = np.linspace(0, 25, 60).reshape(3, 4, 5)
xp = np.arange(20)
fp = xp - 10
_check(params={'x': x, 'xp': xp, 'fp': fp})
x = np.nan
xp = np.arange(5)
fp = np.full(5, np.nan)
_check(params={'x': x, 'xp': xp, 'fp': fp})
x = np.nan
xp = [3]
fp = [4]
_check(params={'x': x, 'xp': xp, 'fp': fp})
x = np.arange(-4, 8)
xp = x
fp = x
_check(params={'x': x, 'xp': xp, 'fp': fp})
x = [True, False]
xp = np.arange(-4, 8)
fp = xp
_check(params={'x': x, 'xp': xp, 'fp': fp})
x = [-np.inf, -1.0, 0.0, 1.0, np.inf]
xp = np.arange(-4, 8)
fp = xp * 2.2
_check(params={'x': x, 'xp': xp, 'fp': fp})
x = np.linspace(-10, 10, 10)
xp = np.array([-np.inf, -1.0, 0.0, 1.0, np.inf])
fp = xp * 2.2
_check(params={'x': x, 'xp': xp, 'fp': fp})
x = self.rnd.randn(100)
xp = np.linspace(-3, 3, 100)
fp = np.full(100, fill_value=3.142)
_check(params={'x': x, 'xp': xp, 'fp': fp})
for factor in 1, -1:
x = np.array([5, 6, 7]) * factor
xp = [1, 2]
fp = [3, 4]
_check(params={'x': x, 'xp': xp, 'fp': fp})
x = 1
xp = [1]
fp = [True]
_check(params={'x': x, 'xp': xp, 'fp': fp})
x = np.linspace(0, 1, 5)
y = np.linspace(0, 1, 5)
x0 = np.linspace(0, 1, 50)
out = cfunc(x0, x, y)
np.testing.assert_almost_equal(out, x0)
x = np.array([1, 2, 3, 4])
xp = np.array([1, 2, 3, 4])
fp = np.array([1, 2, 3.01, 4])
_check(params={'x': x, 'xp': xp, 'fp': fp})
xp = [1]
fp = [np.inf]
_check(params={'x': 1, 'xp': xp, 'fp': fp})
x = np.array([1, 2, 2.5, 3, 4])
xp = np.array([1, 2, 3, 4])
fp = np.array([1, 2, np.nan, 4])
_check({'x': x, 'xp': xp, 'fp': fp})
x = np.array([1, 1.5, 2, 2.5, 3, 4, 4.5, 5, 5.5])
xp = np.array([1, 2, 3, 4, 5])
fp = np.array([np.nan, 2, np.nan, 4, np.nan])
_check({'x': x, 'xp': xp, 'fp': fp})
x = np.array([1, 2, 2.5, 3, 4])
xp = np.array([1, 2, 3, 4])
fp = np.array([1, 2, np.inf, 4])
_check({'x': x, 'xp': xp, 'fp': fp})
x = np.array([1, 1.5, np.nan, 2.5, -np.inf, 4, 4.5, 5, np.inf, 0, 7])
xp = np.array([1, 2, 3, 4, 5, 6])
fp = np.array([1, 2, np.nan, 4, 3, np.inf])
_check({'x': x, 'xp': xp, 'fp': fp})
x = np.array([3.10034867, 3.0999066, 3.10001529])
xp = np.linspace(0, 10, 1 + 20000)
fp = np.sin(xp / 2.0)
_check({'x': x, 'xp': xp, 'fp': fp})
x = self.rnd.uniform(0, 2 * np.pi, (100,))
xp = np.linspace(0, 2 * np.pi, 1000)
fp = np.cos(xp)
exact = np.cos(x)
got = cfunc(x, xp, fp)
np.testing.assert_allclose(exact, got, atol=1e-5)
# very dense calibration
x = self.rnd.randn(10)
xp = np.linspace(-10, 10, 1000)
fp = np.ones_like(xp)
_check({'x': x, 'xp': xp, 'fp': fp})
# very sparse calibration
x = self.rnd.randn(1000)
xp = np.linspace(-10, 10, 10)
fp = np.ones_like(xp)
_check({'x': x, 'xp': xp, 'fp': fp})
def _make_some_values_non_finite(self, a):
p = a.size // 100
np.put(a, self.rnd.choice(range(a.size), p, replace=False), np.nan)
np.put(a, self.rnd.choice(range(a.size), p, replace=False), -np.inf)
np.put(a, self.rnd.choice(range(a.size), p, replace=False), np.inf)
def arrays(self, ndata):
# much_finer_grid
yield np.linspace(2.0, 7.0, 1 + ndata * 5)
# finer_grid
yield np.linspace(2.0, 7.0, 1 + ndata)
# similar_grid
yield np.linspace(2.1, 6.8, 1 + ndata // 2)
# coarser_grid
yield np.linspace(2.1, 7.5, 1 + ndata // 2)
# much_coarser_grid
yield np.linspace(1.1, 9.5, 1 + ndata // 5)
# finer_stretched_grid
yield np.linspace(3.1, 5.3, 1 + ndata) * 1.09
# similar_stretched_grid
yield np.linspace(3.1, 8.3, 1 + ndata // 2) * 1.09
# finer_compressed_grid
yield np.linspace(3.1, 5.3, 1 + ndata) * 0.91
# similar_compressed_grid
yield np.linspace(3.1, 8.3, 1 + ndata // 2) * 0.91
# warped_grid
yield np.linspace(3.1, 5.3, 1 + ndata // 2) + 0.3 * np.sin(
np.arange(1 + ndata / 2) * np.pi / (1 + ndata / 2))
# very_low_noise_grid
yield np.linspace(3.1, 5.3, 1 + ndata) + self.rnd.normal(
size=1 + ndata, scale=0.5 / ndata)
# low_noise_grid
yield np.linspace(3.1, 5.3, 1 + ndata) + self.rnd.normal(
size=1 + ndata, scale=2.0 / ndata)
# med_noise_grid
yield np.linspace(3.1, 5.3, 1 + ndata) + self.rnd.normal(
size=1 + ndata, scale=5.0 / ndata)
# high_noise_grid
yield np.linspace(3.1, 5.3, 1 + ndata) + self.rnd.normal(
size=1 + ndata, scale=20.0 / ndata)
# very_high_noise_grid
yield np.linspace(3.1, 5.3, 1 + ndata) + self.rnd.normal(
size=1 + ndata, scale=50.0 / ndata)
# extreme_noise_grid
yield np.linspace(3.1, 5.3, 1 + ndata) + self.rnd.normal(
size=1 + ndata, scale=200.0 / ndata)
# random_fine_grid
yield self.rnd.rand(1 + ndata) * 9.0 + 0.6
# random_grid
yield self.rnd.rand(1 + ndata * 2) * 4.0 + 1.3
def test_interp_stress_tests(self):
pyfunc = interp
cfunc = jit(nopython=True)(pyfunc)
ndata = 20000
xp = np.linspace(0, 10, 1 + ndata)
fp = np.sin(xp / 2.0)
for x in self.arrays(ndata):
atol = 1e-14 # using abs_tol as otherwise fails on 32bit builds
expected = pyfunc(x, xp, fp)
got = cfunc(x, xp, fp)
self.assertPreciseEqual(expected, got, abs_tol=atol)
# no longer require xp to be monotonically increasing
# (in keeping with numpy) even if the output might not
# be meaningful; shuffle all inputs
self.rnd.shuffle(x)
expected = pyfunc(x, xp, fp)
got = cfunc(x, xp, fp)
self.assertPreciseEqual(expected, got, abs_tol=atol)
self.rnd.shuffle(xp)
expected = pyfunc(x, xp, fp)
got = cfunc(x, xp, fp)
self.assertPreciseEqual(expected, got, abs_tol=atol)
self.rnd.shuffle(fp)
expected = pyfunc(x, xp, fp)
got = cfunc(x, xp, fp)
self.assertPreciseEqual(expected, got, abs_tol=atol)
# add some values non finite
self._make_some_values_non_finite(x)
expected = pyfunc(x, xp, fp)
got = cfunc(x, xp, fp)
self.assertPreciseEqual(expected, got, abs_tol=atol)
self._make_some_values_non_finite(xp)
expected = pyfunc(x, xp, fp)
got = cfunc(x, xp, fp)
self.assertPreciseEqual(expected, got, abs_tol=atol)
self._make_some_values_non_finite(fp)
expected = pyfunc(x, xp, fp)
got = cfunc(x, xp, fp)
self.assertPreciseEqual(expected, got, abs_tol=atol)
def test_interp_complex_stress_tests(self):
pyfunc = interp
cfunc = jit(nopython=True)(pyfunc)
ndata = 2000
xp = np.linspace(0, 10, 1 + ndata)
real = np.sin(xp / 2.0)
real[:200] = self.rnd.choice([np.inf, -np.inf, np.nan], 200)
self.rnd.shuffle(real)
imag = np.cos(xp / 2.0)
imag[:200] = self.rnd.choice([np.inf, -np.inf, np.nan], 200)
self.rnd.shuffle(imag)
fp = real + 1j * imag
for x in self.arrays(ndata):
expected = pyfunc(x, xp, fp)
got = cfunc(x, xp, fp)
np.testing.assert_allclose(expected, got, equal_nan=True)
self.rnd.shuffle(x)
self.rnd.shuffle(xp)
self.rnd.shuffle(fp)
np.testing.assert_allclose(expected, got, equal_nan=True)
def test_interp_exceptions(self):
pyfunc = interp
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
x = np.array([1, 2, 3])
xp = np.array([])
fp = np.array([])
with self.assertRaises(ValueError) as e:
cfunc(x, xp, fp)
msg = "array of sample points is empty"
self.assertIn(msg, str(e.exception))
x = 1
xp = np.array([1, 2, 3])
fp = np.array([1, 2])
with self.assertRaises(ValueError) as e:
cfunc(x, xp, fp)
msg = "fp and xp are not of the same size."
self.assertIn(msg, str(e.exception))
x = 1
xp = np.arange(6).reshape(3, 2)
fp = np.arange(6)
with self.assertTypingError() as e:
cfunc(x, xp, fp)
msg = "xp must be 1D"
self.assertIn(msg, str(e.exception))
x = 1
xp = np.arange(6)
fp = np.arange(6).reshape(3, 2)
with self.assertTypingError() as e:
cfunc(x, xp, fp)
msg = "fp must be 1D"
self.assertIn(msg, str(e.exception))
x = 1 + 1j
xp = np.arange(6)
fp = np.arange(6)
with self.assertTypingError() as e:
cfunc(x, xp, fp)
complex_dtype_msg = (
"Cannot cast array data from complex dtype "
"to float64 dtype"
)
self.assertIn(complex_dtype_msg, str(e.exception))
x = 1
xp = (np.arange(6) + 1j).astype(np.complex64)
fp = np.arange(6)
with self.assertTypingError() as e:
cfunc(x, xp, fp)
self.assertIn(complex_dtype_msg, str(e.exception))
def test_interp_non_finite_calibration(self):
# examples from
# https://github.com/numpy/numpy/issues/12951
pyfunc = interp
cfunc = jit(nopython=True)(pyfunc)
_check = partial(self._check_output, pyfunc, cfunc)
xp = np.array([0, 1, 9, 10])
fp = np.array([-np.inf, 0.1, 0.9, np.inf])
x = np.array([0.2, 9.5])
params = {'x': x, 'xp': xp, 'fp': fp}
_check(params)
xp = np.array([-np.inf, 1, 9, np.inf])
fp = np.array([0, 0.1, 0.9, 1])
x = np.array([0.2, 9.5])
params = {'x': x, 'xp': xp, 'fp': fp}
_check(params)
def test_interp_supplemental_tests(self):
# inspired by class TestInterp
# https://github.com/numpy/numpy/blob/f5b6850f231/numpy/lib/tests/test_function_base.py # noqa: E501
pyfunc = interp
cfunc = jit(nopython=True)(pyfunc)
for size in range(1, 10):
xp = np.arange(size, dtype=np.double)
yp = np.ones(size, dtype=np.double)
incpts = np.array([-1, 0, size - 1, size], dtype=np.double)
decpts = incpts[::-1]
incres = cfunc(incpts, xp, yp)
decres = cfunc(decpts, xp, yp)
inctgt = np.array([1, 1, 1, 1], dtype=float)
dectgt = inctgt[::-1]
np.testing.assert_almost_equal(incres, inctgt)
np.testing.assert_almost_equal(decres, dectgt)
x = np.linspace(0, 1, 5)
y = np.linspace(0, 1, 5)
x0 = 0
np.testing.assert_almost_equal(cfunc(x0, x, y), x0)
x0 = 0.3
np.testing.assert_almost_equal(cfunc(x0, x, y), x0)
x0 = np.float32(0.3)
np.testing.assert_almost_equal(cfunc(x0, x, y), x0)
x0 = np.float64(0.3)
np.testing.assert_almost_equal(cfunc(x0, x, y), x0)
x0 = np.nan
np.testing.assert_almost_equal(cfunc(x0, x, y), x0)
x = np.linspace(0, 1, 5)
y = np.linspace(0, 1, 5)
x0 = np.array(0.3)
np.testing.assert_almost_equal(cfunc(x0, x, y), x0)
xp = np.arange(0, 10, 0.0001)
fp = np.sin(xp)
np.testing.assert_almost_equal(cfunc(np.pi, xp, fp), 0.0)
def test_interp_supplemental_complex_tests(self):
# inspired by class TestInterp
# https://github.com/numpy/numpy/blob/f5b6850f231/numpy/lib/tests/test_function_base.py # noqa: E501
pyfunc = interp
cfunc = jit(nopython=True)(pyfunc)
x = np.linspace(0, 1, 5)
y = np.linspace(0, 1, 5) + (1 + np.linspace(0, 1, 5)) * 1.0j
x0 = 0.3
y0 = x0 + (1 + x0) * 1.0j
np.testing.assert_almost_equal(cfunc(x0, x, y), y0)
def test_interp_float_precision_handled_per_numpy(self):
# test cases from https://github.com/numba/numba/issues/4890
pyfunc = interp
cfunc = jit(nopython=True)(pyfunc)
dtypes = [np.float32, np.float64, np.int32, np.int64]
for combo in itertools.combinations_with_replacement(dtypes, 3):
xp_dtype, fp_dtype, x_dtype = combo
xp = np.arange(10, dtype=xp_dtype)
fp = (xp ** 2).astype(fp_dtype)
x = np.linspace(2, 3, 10, dtype=x_dtype)
expected = pyfunc(x, xp, fp)
got = cfunc(x, xp, fp)
self.assertPreciseEqual(expected, got)
def test_isnat(self):
def values():
yield np.datetime64("2016-01-01")
yield np.datetime64("NaT")
yield np.datetime64('NaT', 'ms')
yield np.datetime64('NaT', 'ns')
yield np.datetime64('2038-01-19T03:14:07')
yield np.timedelta64('NaT', "ms")
yield np.timedelta64(34, "ms")
for unit in ['Y', 'M', 'W', 'D',
'h', 'm', 's', 'ms', 'us',
'ns', 'ps', 'fs', 'as']:
yield np.array([123, -321, "NaT"],
dtype='<datetime64[%s]' % unit)
yield np.array([123, -321, "NaT"],
dtype='<timedelta64[%s]' % unit)
pyfunc = isnat
cfunc = jit(nopython=True)(pyfunc)
for x in values():
expected = pyfunc(x)
got = cfunc(x)
if isinstance(x, np.ndarray):
self.assertPreciseEqual(expected, got, (x,))
else:
self.assertEqual(expected, got, x)
def test_asarray(self):
def input_variations():
"""
To quote from: https://docs.scipy.org/doc/numpy/reference/generated/numpy.asarray.html # noqa: E501
Input data, in any form that can be converted to an array.
This includes:
* lists
* lists of tuples
* tuples
* tuples of tuples
* tuples of lists
* ndarrays
"""
yield 1j
yield 1.2
yield False
yield 1
yield [1, 2, 3]
yield [(1, 2, 3), (1, 2, 3)]
yield (1, 2, 3)
yield ((1, 2, 3), (1, 2, 3))
yield ([1, 2, 3], [1, 2, 3])
yield np.array([])
yield np.arange(4)
yield np.arange(12).reshape(3, 4)
yield np.arange(12).reshape(3, 4).T
# Test cases for `numba.typed.List`
def make_list(values):
a = List()
for i in values:
a.append(i)
return a
yield make_list((1, 2, 3))
yield make_list((1.0, 2.0, 3.0))
yield make_list((1j, 2j, 3j))
yield make_list((True, False, True))
# used to check that if the input is already an array and the dtype is
# the same as that of the input/omitted then the array itself is
# returned.
def check_pass_through(jitted, expect_same, params):
returned = jitted(**params)
if expect_same:
self.assertTrue(returned is params['a'])
else:
self.assertTrue(returned is not params['a'])
# should be numerically the same, just different dtype
np.testing.assert_allclose(returned, params['a'])
self.assertTrue(returned.dtype == params['dtype'])
for pyfunc in [asarray, asarray_kws]:
cfunc = jit(nopython=True)(pyfunc)
_check = partial(self._check_output, pyfunc, cfunc)
for x in input_variations():
params = {'a': x}
if 'kws' in pyfunc.__name__:
for dt in [None, np.complex128]:
params['dtype'] = dt
_check(params)
else:
_check(params)
# check the behaviour over a dtype change (or not!)
x = np.arange(10, dtype=np.float32)
params = {'a': x}
if 'kws' in pyfunc.__name__:
params['dtype'] = None
check_pass_through(cfunc, True, params)
params['dtype'] = np.complex128
check_pass_through(cfunc, False, params)
params['dtype'] = np.float32
check_pass_through(cfunc, True, params)
else:
check_pass_through(cfunc, True, params)
def test_asarray_literal(self):
def case1():
return np.asarray("hello world")
def case2(): # kind1
s = "hello world"
return np.asarray(s)
def case3(): # kind2
s = '大处 着眼，小处着手。大大大处'
return np.asarray(s)
def case4():
s = ''
return np.asarray(s)
funcs = [case1, case2, case3, case4]
for pyfunc in funcs:
cfunc = jit(nopython=True)(pyfunc)
expected = pyfunc()
got = cfunc()
self.assertPreciseEqual(expected, got)
def test_asarray_rejects_List_with_illegal_dtype(self):
self.disable_leak_check()
cfunc = jit(nopython=True)(asarray)
def test_reject(alist):
with self.assertRaises(TypingError) as e:
cfunc(alist)
self.assertIn(
"asarray support for List is limited "
"to Boolean and Number types",
str(e.exception))
def make_none_typed_list():
l = List()
l.append(None)
return l
def make_nested_list():
l = List()
m = List()
m.append(1)
l.append(m)
return l
def make_nested_list_with_dict():
l = List()
d = Dict()
d[1] = "a"
l.append(d)
return l
def make_unicode_list():
l = List()
for i in ("a", "bc", "def"):
l.append(i)
return l
test_reject(make_none_typed_list())
test_reject(make_nested_list())
test_reject(make_nested_list_with_dict())
test_reject(make_unicode_list())
def test_asfarray(self):
def inputs():
yield np.array([1, 2, 3]), None
yield np.array([2, 3], dtype=np.float32), np.float32
yield np.array([2, 3], dtype=np.int8), np.int8
yield np.array([2, 3], dtype=np.int8), np.complex64
yield np.array([2, 3], dtype=np.int8), np.complex128
pyfunc = asfarray
cfunc = jit(nopython=True)(pyfunc)
for arr, dt in inputs():
if dt is None:
expected = pyfunc(arr)
got = cfunc(arr)
else:
expected = pyfunc(arr, dtype=dt)
got = cfunc(arr, dtype=dt)
self.assertPreciseEqual(expected, got)
self.assertTrue(np.issubdtype(got.dtype, np.inexact), got.dtype)
# test default kwarg variant
pyfunc = asfarray_default_kwarg
cfunc = jit(nopython=True)(pyfunc)
arr = np.array([1, 2, 3])
expected = pyfunc(arr)
got = cfunc(arr)
self.assertPreciseEqual(expected, got)
self.assertTrue(np.issubdtype(got.dtype, np.inexact), got.dtype)
def test_repeat(self):
# np.repeat(a, repeats)
np_pyfunc = np_repeat
np_nbfunc = njit(np_pyfunc)
# a.repeat(repeats)
array_pyfunc = array_repeat
array_nbfunc = njit(array_pyfunc)
for pyfunc, nbfunc in ((np_pyfunc, np_nbfunc),
(array_pyfunc, array_nbfunc)):
def check(a, repeats):
self.assertPreciseEqual(pyfunc(a, repeats), nbfunc(a, repeats))
# test array arguments
target_numpy_values = [
np.ones(1),
np.arange(1000),
np.array([[0, 1], [2, 3]]),
np.array([]),
np.array([[], []]),
]
target_numpy_types = [
np.uint32,
np.int32,
np.uint64,
np.int64,
np.float32,
np.float64,
np.complex64,
np.complex128,
]
target_numpy_inputs = (np.array(a,dtype=t) for a,t in
itertools.product(target_numpy_values,
target_numpy_types))
target_non_numpy_inputs = [
1,
1.0,
True,
1j,
[0, 1, 2],
(0, 1, 2),
]
for i in itertools.chain(target_numpy_inputs,
target_non_numpy_inputs):
check(i, repeats=0)
check(i, repeats=1)
check(i, repeats=2)
check(i, repeats=3)
check(i, repeats=100)
# check broadcasting when repeats is an array/list
one = np.arange(1)
for i in ([0], [1], [2]):
check(one, repeats=i)
check(one, repeats=np.array(i))
two = np.arange(2)
for i in ([0, 0], [0, 1], [1, 0], [0, 1], [1, 2], [2, 1], [2, 2]):
check(two, repeats=i)
check(two, repeats=np.array(i))
check(two, repeats=np.array([2, 2], dtype=np.int32))
check(np.arange(10), repeats=np.arange(10))
def test_repeat_exception(self):
# np.repeat(a, repeats)
np_pyfunc = np_repeat
np_nbfunc = njit(np_pyfunc)
# a.repeat(repeats)
array_pyfunc = array_repeat
array_nbfunc = njit(array_pyfunc)
self.disable_leak_check()
for pyfunc, nbfunc in ((np_pyfunc, np_nbfunc),
(array_pyfunc, array_nbfunc)):
# negative repeat argument
with self.assertRaises(ValueError) as e:
nbfunc(np.ones(1), -1)
self.assertIn("negative dimensions are not allowed",
str(e.exception))
# float repeat argument has custom error message
with self.assertRaises(TypingError) as e:
nbfunc(np.ones(1), 1.0)
self.assertIn(
"The repeats argument must be an integer "
"or an array-like of integer dtype",
str(e.exception))
# negative repeat argument as array
with self.assertRaises(ValueError) as e:
nbfunc(np.ones(2), np.array([1, -1]))
self.assertIn("negative dimensions are not allowed",
str(e.exception))
# broadcasting error, repeats too large
with self.assertRaises(ValueError) as e:
nbfunc(np.ones(2), np.array([1, 1, 1]))
self.assertIn("operands could not be broadcast together",
str(e.exception))
# broadcasting error, repeats too small
with self.assertRaises(ValueError) as e:
nbfunc(np.ones(5), np.array([1, 1, 1, 1]))
self.assertIn("operands could not be broadcast together",
str(e.exception))
# float repeat argument has custom error message
with self.assertRaises(TypingError) as e:
nbfunc(np.ones(2), [1.0, 1.0])
self.assertIn(
"The repeats argument must be an integer "
"or an array-like of integer dtype",
str(e.exception))
for rep in [True, "a", "1"]:
with self.assertRaises(TypingError):
nbfunc(np.ones(1), rep)
def test_select(self):
np_pyfunc = np_select
np_nbfunc = njit(np_select)
test_cases = [
# Each test case below is one tuple.
# Each tuple is separated by a description of what's being tested
# test with arrays of length 3 instead of 2 and a different default
([np.array([False, False, False]),
np.array([False, True, False]),
np.array([False, False, True])],
[np.array([1, 2, 3]),
np.array([4, 5, 6]),
np.array([7, 8, 9])], 15.3),
# test with arrays of length 1 instead of 2
([np.array([True]),
np.array([False])], [np.array([1]), np.array([2])], 0),
# test with lists of length 100 of arrays of length 1
([np.array([False])] * 100, [np.array([1])] * 100, 0),
# passing arrays with NaNs
([np.isnan(np.array([1, 2, 3, np.nan, 5, 7]))] * 2,
[np.array([1, 2, 3, np.nan, 5, 7])] * 2, 0),
# passing lists with 2d arrays
([np.isnan(np.array([[1, 2, 3, np.nan, 5, 7]]))] * 2,
[np.array([[1, 2, 3, np.nan, 5, 7]])] * 2, 0),
# passing arrays with complex numbers
([np.isnan(np.array([1, 2, 3 + 2j, np.nan, 5, 7]))] * 2,
[np.array([1, 2, 3 + 2j, np.nan, 5, 7])] * 2, 0)
]
for x in (np.arange(10), np.arange(10).reshape((5, 2))):
# test with two lists
test_cases.append(([x < 3, x > 5], [x, x ** 2], 0))
# test with two tuples
test_cases.append(((x < 3, x > 5), (x, x ** 2), 0))
# test with one list and one tuple
test_cases.append(([x < 3, x > 5], (x, x ** 2), 0))
# test with one tuple and one list
test_cases.append(((x < 3, x > 5), [x, x ** 2], 0))
for condlist, choicelist, default in test_cases:
self.assertPreciseEqual(np_pyfunc(condlist, choicelist, default),
np_nbfunc(condlist, choicelist, default))
np_pyfunc_defaults = np_select_defaults
np_nbfunc_defaults = njit(np_select_defaults)
# check the defaults work, using whatever the last input was
self.assertPreciseEqual(np_pyfunc_defaults(condlist, choicelist),
np_nbfunc_defaults(condlist, choicelist))
def test_select_exception(self):
np_nbfunc = njit(np_select)
x = np.arange(10)
self.disable_leak_check()
for condlist, choicelist, default, expected_error, expected_text in [
# Each test case below is one tuple.
# Each tuple is separated by the description of the intended error
# passing condlist of dim zero
([np.array(True), np.array([False, True, False])],
[np.array(1), np.arange(12).reshape(4, 3)], 0,
TypingError, "condlist arrays must be of at least dimension 1"),
# condlist and choicelist with different dimensions
([np.array(True), np.array(False)], [np.array([1]), np.array([2])],
0, TypingError, "condlist and choicelist elements must have the "
"same number of dimensions"),
# condlist and choicelist with different dimensions
([np.array([True]), np.array([False])],
[np.array([[1]]), np.array([[2]])], 0, TypingError,
"condlist and choicelist elements must have the "
"same number of dimensions"),
# passing choicelist of dim zero
([np.array(True), np.array(False)], [np.array(1), np.array(2)], 0,
TypingError, "condlist arrays must be of at least dimension 1"),
# passing an array as condlist instead of a list or tuple
(np.isnan(np.array([1, 2, 3, np.nan, 5, 7])),
np.array([1, 2, 3, np.nan, 5, 7]), 0, TypingError,
"condlist must be a List or a Tuple"),
# default is a list
([True], [0], [0], TypingError,
"default must be a scalar"),
# condlist with ints instead of booleans
([(x < 3).astype(int), (x > 5).astype(int)], [x, x ** 2], 0,
TypingError, "condlist arrays must contain booleans"),
# condlist and choicelist of different length
([x > 9, x > 8, x > 7, x > 6], [x, x**2, x], 0, ValueError,
"list of cases must be same length as list of conditions"),
# condlist contains tuples instead of arrays
# if in the future numba's np.where accepts tuples, the
# implementation of np.select should also accept them and
# the following two test cases should be normal tests
# instead of negative tests
# test with lists of length 100 of tuples of length 1 for condlist
([(False,)] * 100, [np.array([1])] * 100, 0, TypingError,
'items of condlist must be arrays'),
# test with lists of length 100 of tuples of length 1 for choicelist
([np.array([False])] * 100, [(1,)] * 100, 0, TypingError,
'items of choicelist must be arrays'),
]:
with self.assertRaises(expected_error) as e:
np_nbfunc(condlist, choicelist, default)
self.assertIn(expected_text, str(e.exception))
def test_windowing(self):
def check_window(func):
np_pyfunc = func
np_nbfunc = njit(func)
for M in [0, 1, 5, 12]:
expected = np_pyfunc(M)
got = np_nbfunc(M)
self.assertPreciseEqual(expected, got, prec='double')
for M in ['a', 1.1, 1j]:
with self.assertRaises(TypingError) as raises:
np_nbfunc(1.1)
self.assertIn("M must be an integer", str(raises.exception))
check_window(np_bartlett)
check_window(np_blackman)
check_window(np_hamming)
check_window(np_hanning)
# Test np.kaiser separately
np_pyfunc = np_kaiser
np_nbfunc = njit(np_kaiser)
for M in [0, 1, 5, 12]:
for beta in [0.0, 5.0, 14.0]:
expected = np_pyfunc(M, beta)
got = np_nbfunc(M, beta)
if IS_32BITS or platform.machine() in ['ppc64le', 'aarch64']:
self.assertPreciseEqual(expected,
got, prec='double', ulps=2)
else:
self.assertPreciseEqual(expected, got, prec='double',
ulps=2)
for M in ['a', 1.1, 1j]:
with self.assertRaises(TypingError) as raises:
np_nbfunc(M, 1.0)
self.assertIn("M must be an integer", str(raises.exception))
for beta in ['a', 1j]:
with self.assertRaises(TypingError) as raises:
np_nbfunc(5, beta)
self.assertIn("beta must be an integer or float",
str(raises.exception))
def test_cross(self):
pyfunc = np_cross
cfunc = jit(nopython=True)(pyfunc)
pairs = [
# 3x3 (n-dims)
(
np.array([[1, 2, 3], [4, 5, 6]]),
np.array([[4, 5, 6], [1, 2, 3]])
),
# 2x3 array-like (n-dims)
(
np.array([[1, 2, 3], [4, 5, 6]]),
((4, 5), (1, 2))
),
# 3x3 (1-dim) with type promotion
(
np.array([1, 2, 3], dtype=np.int64),
np.array([4, 5, 6], dtype=np.float64)
),
# 3x3 array-like (1-dim)
(
(1, 2, 3),
(4, 5, 6)
),
# 2x3 (1-dim)
(
np.array([1, 2]),
np.array([4, 5, 6])
),
# 3x3 (with broadcasting 1d x 2d)
(
np.array([1, 2, 3]),
np.array([[4, 5, 6], [1, 2, 3]])
),
# 3x3 (with broadcasting 2d x 1d)
(
np.array([[1, 2, 3], [4, 5, 6]]),
np.array([1, 2, 3])
),
# 3x2 (with higher order broadcasting)
(
np.arange(36).reshape(6, 2, 3),
np.arange(4).reshape(2, 2)
)
]
for x, y in pairs:
expected = pyfunc(x, y)
got = cfunc(x, y)
self.assertPreciseEqual(expected, got)
def test_cross_exceptions(self):
pyfunc = np_cross
cfunc = jit(nopython=True)(pyfunc)
self.disable_leak_check()
# test incompatible dimensions for ndim == 1
with self.assertRaises(ValueError) as raises:
cfunc(
np.arange(4),
np.arange(3)
)
self.assertIn(
'Incompatible dimensions for cross product',
str(raises.exception)
)
# test 2d cross product error for ndim == 1
with self.assertRaises(ValueError) as raises:
cfunc(
np.array((1, 2)),
np.array((3, 4))
)
self.assertIn(
'Dimensions for both inputs is 2.',
str(raises.exception)
)
self.assertIn(
'`cross2d(a, b)` from `numba.np.extensions`.',
str(raises.exception)
)
# test incompatible dimensions for ndim > 1
with self.assertRaises(ValueError) as raises:
cfunc(
np.arange(8).reshape((2, 4)),
np.arange(6)[::-1].reshape((2, 3))
)
self.assertIn(
'Incompatible dimensions for cross product',
str(raises.exception)
)
# test 2d cross product error for ndim == 1
with self.assertRaises(ValueError) as raises:
cfunc(
np.arange(8).reshape((4, 2)),
np.arange(8)[::-1].reshape((4, 2))
)
self.assertIn(
'Dimensions for both inputs is 2',
str(raises.exception)
)
# test non-array-like input
with self.assertRaises(TypingError) as raises:
cfunc(
set([1, 2, 3]),
set([4, 5, 6])
)
self.assertIn(
'Inputs must be array-like.',
str(raises.exception)
)
def test_cross2d(self):
pyfunc = np_cross
cfunc = njit(nb_cross2d)
pairs = [
# 2x2 (n-dims)
(
np.array([[1, 2], [4, 5]]),
np.array([[4, 5], [1, 2]])
),
# 2x2 array-like (n-dims)
(
np.array([[1, 2], [4, 5]]),
((4, 5), (1, 2))
),
# 2x2 (1-dim) with type promotion
(
np.array([1, 2], dtype=np.int64),
np.array([4, 5], dtype=np.float64)
),
# 2x2 array-like (1-dim)
(
(1, 2),
(4, 5)
),
# 2x2 (with broadcasting 1d x 2d)
(
np.array([1, 2]),
np.array([[4, 5], [1, 2]])
),
# 2x2 (with broadcasting 2d x 1d)
(
np.array([[1, 2], [4, 5]]),
np.array([1, 2])
),
# 2x2 (with higher order broadcasting)
(
np.arange(36).reshape(6, 3, 2),
np.arange(6).reshape(3, 2)
)
]
for x, y in pairs:
expected = pyfunc(x, y)
got = cfunc(x, y)
self.assertPreciseEqual(expected, got)
def test_cross2d_exceptions(self):
cfunc = njit(nb_cross2d)
self.disable_leak_check()
# test incompatible dimensions for ndim == 1
with self.assertRaises(ValueError) as raises:
cfunc(
np.array((1, 2, 3)),
np.array((4, 5, 6))
)
self.assertIn(
'Incompatible dimensions for 2D cross product',
str(raises.exception)
)
# test incompatible dimensions for ndim > 1
with self.assertRaises(ValueError) as raises:
cfunc(
np.arange(6).reshape((2, 3)),
np.arange(6)[::-1].reshape((2, 3))
)
self.assertIn(
'Incompatible dimensions for 2D cross product',
str(raises.exception)
)
# test non-array-like input
with self.assertRaises(TypingError) as raises:
cfunc(
set([1, 2]),
set([4, 5])
)
self.assertIn(
'Inputs must be array-like.',
str(raises.exception)
)
def test_trim_zeros(self):
def arrays():
yield np.array([])
yield np.zeros(5)
yield np.zeros(1)
yield np.array([1, 2, 3])
yield np.array([0, 1, 2, 3])
yield np.array([0., 1., 2., np.nan, 0.])
yield np.array(['0', 'Hello', 'world'])
def explicit_trim():
yield np.array([0, 1, 2, 0, 0]), 'FB'
yield np.array([0, 1, 2]), 'B'
yield np.array([np.nan, 0., 1.2, 2.3, 0.]), 'b'
yield np.array([0, 0, 1, 2, 5]), 'f'
yield np.array([0, 1, 2, 0]), 'abf'
yield np.array([0, 4, 0]), 'd'
yield np.array(['\0', '1', '2']), 'f'
pyfunc = np_trim_zeros
cfunc = jit(nopython=True)(pyfunc)
for arr in arrays():
expected = pyfunc(arr)
got = cfunc(arr)
self.assertPreciseEqual(expected, got)
for arr, trim in explicit_trim():
expected = pyfunc(arr, trim)
got = cfunc(arr, trim)
self.assertPreciseEqual(expected, got)
def test_trim_zeros_numpy(self):
# https://github.com/numpy/numpy/blob/9d8d46ad615a7e13256b930146ac369f651016c0/numpy/lib/tests/test_function_base.py#L1251-L1313
a = np.array([0, 0, 1, 0, 2, 3, 4, 0])
b = a.astype(float)
c = a.astype(complex)
# d = a.astype(object)
values = [a, b, c]
# test_basic
slc = np.s_[2:-1]
for arr in values:
res = np_trim_zeros(arr)
self.assertPreciseEqual(res, arr[slc])
# test_leading_skip
slc = np.s_[:-1]
for arr in values:
res = np_trim_zeros(arr, trim='b')
self.assertPreciseEqual(res, arr[slc])
# test_trailing_skip
slc = np.s_[2:]
for arr in values:
res = np_trim_zeros(arr, trim='F')
self.assertPreciseEqual(res, arr[slc])
# test_all_zero
for _arr in values:
arr = np.zeros_like(_arr, dtype=_arr.dtype)
res1 = np_trim_zeros(arr, trim='B')
assert len(res1) == 0
res2 = np_trim_zeros(arr, trim='f')
assert len(res2) == 0
# test_size_zero
arr = np.zeros(0)
res = np_trim_zeros(arr)
self.assertPreciseEqual(arr, res)
# test_overflow
for arr in [np.array([0, 2**62, 0]), np.array([0, 2**63, 0]),
np.array([0, 2**64, 0])]:
slc = np.s_[1:2]
res = np_trim_zeros(arr)
self.assertPreciseEqual(res, arr[slc])
# test_no_trim
arr = np.array([None, 1, None])
res = np_trim_zeros(arr)
self.assertPreciseEqual(arr, res)
# test_list_to_list
res = np_trim_zeros(a.tolist())
assert isinstance(res, list)
def test_trim_zeros_exceptions(self):
self.disable_leak_check()
cfunc = jit(nopython=True)(np_trim_zeros)
with self.assertRaises(TypingError) as raises:
cfunc(np.array([[1, 2, 3], [4, 5, 6]]))
self.assertIn(
'array must be 1D',
str(raises.exception)
)
with self.assertRaises(TypingError) as raises:
cfunc(3)
self.assertIn(
'The first argument must be an array',
str(raises.exception)
)
with self.assertRaises(TypingError) as raises:
cfunc({0, 1, 2})
self.assertIn(
'The first argument must be an array',
str(raises.exception)
)
with self.assertRaises(TypingError) as raises:
cfunc(np.array([0, 1, 2]), 1)
self.assertIn(
'The second argument must be a string',
str(raises.exception)
)
def test_union1d(self):
pyfunc = np_union1d
cfunc = jit(nopython=True)(pyfunc)
arrays = [
# Test 1d arrays
(
np.array([1, 2, 3]),
np.array([2, 3, 4])
),
# Test 2d with 1d array
(
np.array([[1, 2, 3], [2, 3, 4]]),
np.array([2, 5, 6])
),
# Test 3d with 1d array
(
np.arange(0, 20).reshape(2,2,5),
np.array([1, 20, 21])
),
# Test 2d with 3d array
(
np.arange(0, 10).reshape(2,5),
np.arange(0, 20).reshape(2,5,2)
),
# Test other array-like
(
np.array([False, True, 7]),
np.array([1, 2, 3])
)
]
for a, b in arrays:
expected = pyfunc(a,b)
got = cfunc(a,b)
self.assertPreciseEqual(expected, got)
def test_union1d_exceptions(self):
cfunc = jit(nopython=True)(np_union1d)
self.disable_leak_check()
# Test inputs not array-like
with self.assertRaises(TypingError) as raises:
cfunc("Hello", np.array([1,2]))
self.assertIn(
"The arguments to np.union1d must be array-like",
str(raises.exception)
)
with self.assertRaises(TypingError) as raises:
cfunc(np.array([1,2]), "Hello")
self.assertIn(
"The arguments to np.union1d must be array-like",
str(raises.exception)
)
with self.assertRaises(TypingError) as raises:
cfunc("Hello", "World")
self.assertIn(
"The arguments to np.union1d must be array-like",
str(raises.exception)
)
# Test Unicode array exceptions
with self.assertRaises(TypingError) as raises:
cfunc(np.array(['hello', 'world']), np.array(['a', 'b']))
self.assertIn(
"For Unicode arrays, arrays must have same dtype",
str(raises.exception)
)
with self.assertRaises(TypingError) as raises:
cfunc(np.array(['c', 'd']), np.array(['foo', 'bar']))
self.assertIn(
"For Unicode arrays, arrays must have same dtype",
str(raises.exception)
)
with self.assertRaises(TypingError) as raises:
cfunc(np.array(['c', 'd']), np.array([1, 2]))
self.assertIn(
"For Unicode arrays, arrays must have same dtype",
str(raises.exception)
)
with self.assertRaises(TypingError) as raises:
cfunc(np.array(['c', 'd']), np.array([1.1, 2.5]))
self.assertIn(
"For Unicode arrays, arrays must have same dtype",
str(raises.exception)
)
def test_asarray_chkfinite(self):
pyfunc = np_asarray_chkfinite
cfunc = jit(nopython=True)(pyfunc)
self.disable_leak_check()
pairs = [
#1D array with all args
(
np.array([1, 2, 3]),
np.float32,
),
#1D array
(
np.array([1, 2, 3]),
),
#1D array-like
(
[1, 2, 3, 4],
),
# 2x2 (n-dims)
(
np.array([[1, 2], [3, 4]]),
np.float32,
),
# 2x2 array-like (n-dims)
(
((1, 2), (3, 4)),
np.int64
),
# 2x2 (1-dim) with type promotion
(
np.array([1, 2], dtype=np.int64),
),
# 3x2 (with higher order broadcasting)
(
np.arange(36).reshape(6, 2, 3),
),
]
for pair in pairs:
expected = pyfunc(*pair)
got = cfunc(*pair)
self.assertPreciseEqual(expected, got)
def test_asarray_chkfinite_exceptions(self):
cfunc = jit(nopython=True)(np_asarray_chkfinite)
self.disable_leak_check()
#test for single value
with self.assertRaises(TypingError) as e:
cfunc(2)
msg = "The argument to np.asarray_chkfinite must be array-like"
self.assertIn(msg, str(e.exception))
#test for NaNs
with self.assertRaises(ValueError) as e:
cfunc(np.array([2, 4, np.nan, 5]))
self.assertIn("array must not contain infs or NaNs", str(e.exception))
#test for infs
with self.assertRaises(ValueError) as e:
cfunc(np.array([1, 2, np.inf, 4]))
self.assertIn("array must not contain infs or NaNs", str(e.exception))
#test for dtype
with self.assertRaises(TypingError) as e:
cfunc(np.array([1, 2, 3, 4]), 'float32')
self.assertIn("dtype must be a valid Numpy dtype", str(e.exception))
def test_unwrap_basic(self):
pyfunc = unwrap
cfunc = njit(pyfunc)
pyfunc1 = unwrap1
cfunc1 = njit(pyfunc1)
pyfunc13 = unwrap13
cfunc13 = njit(pyfunc13)
pyfunc123 = unwrap123
cfunc123 = njit(pyfunc123)
# Based on tests from https://github.com/numpy/numpy/blob/3032e84ff34f20def2ef4ebf9f8695947af3fd24/numpy/lib/tests/test_function_base.py#L1979-L2003 # noqa: E501
# Additional tests are included to ensure proper support for
# higher dimensional arrays
# p only
def inputs1():
yield np.array([1, 1 + 2 * np.pi])
phase = np.linspace(0, np.pi, num=5)
phase[3:] += np.pi
yield phase
yield np.arange(16).reshape((4,4))
yield np.arange(160, step=10).reshape((4,4))
yield np.arange(240, step=10).reshape((2,3,4))
for p in inputs1():
self.assertPreciseEqual(pyfunc1(p), cfunc1(p))
uneven_seq = np.array([0, 75, 150, 225, 300, 430])
wrap_uneven = np.mod(uneven_seq, 250)
# p and period only
def inputs13():
yield np.array([1, 1 + 256]), 255
yield np.array([0, 75, 150, 225, 300]), 255
yield np.array([0, 1, 2, -1, 0]), 4
yield np.array([2, 3, 4, 5, 2, 3, 4, 5]), 4
yield wrap_uneven, 250
# check that you can set axis=-1 without errors
self.assertPreciseEqual(pyfunc(wrap_uneven, axis=-1, period=250),
cfunc(wrap_uneven, axis=-1, period=250))
for p, period in inputs13():
self.assertPreciseEqual(pyfunc13(p, period=period),
cfunc13(p, period=period))
# p, period and discont
def inputs123():
yield wrap_uneven, 250, 140
for p, period, discont in inputs123():
self.assertPreciseEqual(pyfunc123(p, period=period,
discont=discont),
cfunc123(p, period=period,
discont=discont))
def test_unwrap_exception(self):
cfunc = njit(unwrap)
self.disable_leak_check()
with self.assertRaises(TypingError) as e:
cfunc('abc')
self.assertIn('The argument "p" must be array-like',
str(e.exception))
with self.assertRaises(TypingError) as e:
cfunc(np.array([1, 2]), 'abc')
self.assertIn('The argument "discont" must be a scalar',
str(e.exception))
with self.assertRaises(TypingError) as e:
cfunc(np.array([1, 2]), 3, period='abc')
self.assertIn('The argument "period" must be a scalar',
str(e.exception))
with self.assertRaises(TypingError) as e:
cfunc(np.array([1, 2]), 3, axis='abc')
self.assertIn('The argument "axis" must be an integer',
str(e.exception))
with self.assertRaises(ValueError) as e:
cfunc(np.array([1, 2]), 3, axis=2)
self.assertIn('Value for argument "axis" is not supported',
str(e.exception))
def test_swapaxes_basic(self):
pyfunc = swapaxes
cfunc = jit(nopython=True)(pyfunc)
def a_variations():
yield np.arange(10)
yield np.arange(10).reshape(2, 5)
yield np.arange(60).reshape(5, 4, 3)
for a in a_variations():
for a1 in range(-a.ndim, a.ndim):
for a2 in range(-a.ndim, a.ndim):
expected = pyfunc(a, a1, a2)
got = cfunc(a, a1, a2)
self.assertPreciseEqual(expected, got)
def test_swapaxes_exception(self):
pyfunc = swapaxes
cfunc = jit(nopython=True)(pyfunc)
# Exceptions leak references
self.disable_leak_check()
with self.assertRaises(TypingError) as raises:
cfunc('abc', 0, 0)
self.assertIn('The first argument "a" must be an array',
str(raises.exception))
with self.assertRaises(TypingError) as raises:
cfunc(np.arange(4), 'abc', 0)
self.assertIn('The second argument "axis1" must be an integer',
str(raises.exception))
with self.assertRaises(TypingError) as raises:
cfunc(np.arange(4), 0, 'abc')
self.assertIn('The third argument "axis2" must be an integer',
str(raises.exception))
with self.assertRaises(ValueError) as raises:
cfunc(np.arange(4), 1, 0)
self.assertIn('np.swapaxes: Argument axis1 out of bounds',
str(raises.exception))
with self.assertRaises(ValueError) as raises:
cfunc(np.arange(8).reshape(2, 4), 0, -3)
self.assertIn('np.swapaxes: Argument axis2 out of bounds',
str(raises.exception))
def test_take_along_axis(self):
a = np.arange(24).reshape((3, 1, 4, 2))
# For now axis must be literal, test explicitly defined implementations
@njit
def axis_none(a, i):
return np.take_along_axis(a, i, axis=None)
indices = np.array([1, 2], dtype=np.uint64)
self.assertPreciseEqual(axis_none(a, indices),
axis_none.py_func(a, indices))
def gen(axis):
@njit
def impl(a, i):
return np.take_along_axis(a, i, axis)
return impl
for i in range(-1, a.ndim):
jfunc = gen(i)
ai = np.argsort(a, axis=i)
self.assertPreciseEqual(jfunc(a, ai), jfunc.py_func(a, ai))
def test_take_along_axis_broadcasting(self):
# Based on
# https://github.com/numpy/numpy/blob/v1.21.0/numpy/lib/tests/test_shape_base.py#L74-L79
# This demonstrates that arrays are broadcast before the algorithm is
# applied.
arr = np.ones((3, 4, 1))
ai = np.ones((1, 2, 5), dtype=np.intp)
def gen(axis):
@njit
def impl(a, i):
return np.take_along_axis(a, i, axis)
return impl
# Check same axis but expressed as positive/negative value
for i in (1, -2):
check = gen(i)
expected = check.py_func(arr, ai)
actual = check(arr, ai)
self.assertPreciseEqual(expected, actual)
self.assertEqual(actual.shape, (3, 2, 5))
def test_take_along_axis_exceptions(self):
arr2d = np.arange(8).reshape(2, 4)
# Valid indices when axis=None is passed to take_along_axis:
indices_none = np.array([0, 1], dtype=np.uint64)
indices = np.ones((2, 4), dtype=np.uint64)
# For now axis must be literal, so we need to construct functions with
# explicit axis:
def gen(axis):
@njit
def impl(a, i):
return np.take_along_axis(a, i, axis)
return impl
with self.assertRaises(TypingError) as raises:
gen("a")(arr2d, indices)
self.assertIn("axis must be an integer", str(raises.exception))
with self.assertRaises(TypingError) as raises:
gen(-3)(arr2d, indices)
self.assertIn("axis is out of bounds", str(raises.exception))
with self.assertRaises(TypingError) as raises:
gen(2)(arr2d, indices)
self.assertIn("axis is out of bounds", str(raises.exception))
with self.assertRaises(TypingError) as raises:
gen(None)(12, indices_none)
self.assertIn('"arr" must be an array', str(raises.exception))
with self.assertRaises(TypingError) as raises:
gen(None)(arr2d, 5)
self.assertIn('"indices" must be an array', str(raises.exception))
with self.assertRaises(TypingError) as raises:
gen(None)(arr2d, np.array([0.0, 1.0]))
self.assertIn(
'indices array must contain integers',
str(raises.exception)
)
@njit
def not_literal_axis(a, i, axis):
return np.take_along_axis(a, i, axis)
with self.assertRaises(TypingError) as raises:
not_literal_axis(arr2d, indices, 0)
self.assertIn("axis must be a literal value", str(raises.exception))
with self.assertRaises(TypingError) as raises:
gen(0)(arr2d, np.array([0, 1], dtype=np.uint64))
self.assertIn("must have the same number of dimensions",
str(raises.exception))
# With axis None, array's ndim is implicitly 1.
with self.assertRaises(TypingError) as raises:
gen(None)(arr2d, arr2d)
self.assertIn("must have the same number of dimensions",
str(raises.exception))
with self.assertRaises(ValueError) as raises:
gen(0)(arr2d, np.ones((2, 3), dtype=np.uint64))
self.assertIn("dimensions don't match", str(raises.exception))
# Exceptions leak references
self.disable_leak_check()
def test_nan_to_num(self):
# Test cases are from
# https://github.com/numpy/numpy/blob/8ff45c5bb520db04af8720bf1d34a392a8d2561a/numpy/lib/tests/test_type_check.py#L350-L452
values = [
np.nan,
1,
1.1,
1 + 1j,
complex(-np.inf, np.nan),
complex(np.nan, np.nan),
np.array([1], dtype=int),
np.array([complex(-np.inf, np.inf), complex(1, np.nan),
complex(np.nan, 1), complex(np.inf, -np.inf)]),
np.array([0.1, 1.0, 0.4]),
np.array([1, 2, 3]),
np.array([[0.1, 1.0, 0.4], [0.4, 1.2, 4.0]]),
np.array([0.1, np.nan, 0.4]),
np.array([[0.1, np.nan, 0.4], [np.nan, 1.2, 4.0]]),
np.array([-np.inf, np.nan, np.inf]),
np.array([-np.inf, np.nan, np.inf], dtype=np.float32)
]
nans = [0.0, 10]
pyfunc = nan_to_num
cfunc = njit(nan_to_num)
for value, nan in product(values, nans):
expected = pyfunc(value, nan=nan)
got = cfunc(value, nan=nan)
self.assertPreciseEqual(expected, got)
def test_nan_to_num_copy_false(self):
# Check that copy=False operates in-place.
cfunc = njit(nan_to_num)
x = np.array([0.1, 0.4, np.nan])
expected = 1.0
cfunc(x, copy=False, nan=expected)
self.assertPreciseEqual(x[-1], expected)
x_complex = np.array([0.1, 0.4, complex(np.nan, np.nan)])
cfunc(x_complex, copy=False, nan=expected)
self.assertPreciseEqual(x_complex[-1], 1. + 1.j)
def test_nan_to_num_invalid_argument(self):
cfunc = njit(nan_to_num)
with self.assertTypingError() as raises:
cfunc("invalid_input")
self.assertIn("The first argument must be a scalar or an array-like",
str(raises.exception))
def test_diagflat_basic(self):
pyfunc1 = diagflat1
cfunc1 = njit(pyfunc1)
pyfunc2 = diagflat2
cfunc2 = njit(pyfunc2)
def inputs():
yield np.array([1,2]), 1
yield np.array([[1,2],[3,4]]), -2
yield np.arange(8).reshape((2,2,2)), 2
yield [1, 2], 1
yield np.array([]), 1
for v, k in inputs():
self.assertPreciseEqual(pyfunc1(v), cfunc1(v))
self.assertPreciseEqual(pyfunc2(v, k), cfunc2(v, k))
def test_diagflat1_exception(self):
pyfunc = diagflat1
cfunc = njit(pyfunc)
self.disable_leak_check()
with self.assertRaises(TypingError) as raises:
cfunc("abc")
self.assertIn('The argument "v" must be array-like',
str(raises.exception))
def test_diagflat2_exception(self):
pyfunc = diagflat2
cfunc = njit(pyfunc)
self.disable_leak_check()
with self.assertRaises(TypingError) as raises:
cfunc("abc", 2)
self.assertIn('The argument "v" must be array-like',
str(raises.exception))
with self.assertRaises(TypingError) as raises:
cfunc([1, 2], "abc")
self.assertIn('The argument "k" must be an integer',
str(raises.exception))
with self.assertRaises(TypingError) as raises:
cfunc([1, 2], 3.0)
self.assertIn('The argument "k" must be an integer',
str(raises.exception))
class TestNPMachineParameters(TestCase):
# tests np.finfo, np.iinfo, np.MachAr
template = '''
def foo():
ty = np.%s
return np.%s(ty)
'''
def check(self, func, attrs, *args):
pyfunc = func
cfunc = jit(nopython=True)(pyfunc)
expected = pyfunc(*args)
got = cfunc(*args)
# check result
for attr in attrs:
self.assertPreciseEqual(getattr(expected, attr),
getattr(got, attr))
def create_harcoded_variant(self, basefunc, ty):
#create an instance of using the function with a hardcoded type
#and eval it into existence, return the function for use
tystr = ty.__name__
basestr = basefunc.__name__
funcstr = self.template % (tystr, basestr)
eval(compile(funcstr, '<string>', 'exec'))
return locals()['foo']
@unittest.skipIf(numpy_version >= (1, 24), "NumPy < 1.24 required")
def test_MachAr(self):
attrs = ('ibeta', 'it', 'machep', 'eps', 'negep', 'epsneg', 'iexp',
'minexp', 'xmin', 'maxexp', 'xmax', 'irnd', 'ngrd',
'epsilon', 'tiny', 'huge', 'precision', 'resolution',)
self.check(machar, attrs)
def test_finfo(self):
types = [np.float32, np.float64, np.complex64, np.complex128]
attrs = ('eps', 'epsneg', 'iexp', 'machep', 'max', 'maxexp', 'negep',
'nexp', 'nmant', 'precision', 'resolution', 'tiny', 'bits',)
for ty in types:
self.check(finfo, attrs, ty(1))
hc_func = self.create_harcoded_variant(np.finfo, ty)
self.check(hc_func, attrs)
# check unsupported attr raises
with self.assertRaises(TypingError) as raises:
cfunc = jit(nopython=True)(finfo_machar)
cfunc(7.)
msg = "Unknown attribute 'machar' of type finfo"
self.assertIn(msg, str(raises.exception))
# check invalid type raises
with self.assertTypingError():
cfunc = jit(nopython=True)(finfo)
cfunc(np.int32(7))
def test_iinfo(self):
# check types and instances of types
types = [np.int8, np.int16, np.int32, np.int64, np.uint8, np.uint16,
np.uint32, np.uint64]
attrs = ('min', 'max', 'bits',)
for ty in types:
self.check(iinfo, attrs, ty(1))
hc_func = self.create_harcoded_variant(np.iinfo, ty)
self.check(hc_func, attrs)
# check invalid type raises
with self.assertTypingError():
cfunc = jit(nopython=True)(iinfo)
cfunc(np.float64(7))
@unittest.skipUnless(numpy_version < (1, 24), "Needs NumPy < 1.24")
@TestCase.run_test_in_subprocess
def test_np_MachAr_deprecation_np122(self):
# Tests that Numba is replaying the NumPy 1.22 deprecation warning
# raised on the getattr of 'MachAr' on the NumPy module.
# Needs to be run in a subprocess as the warning is generated from the
# typing part of the `np.MachAr` overload, which may already have been
# executed for the given types and so an empty in memory cache is
# needed.
msg = r'.*`np.MachAr` is deprecated \(NumPy 1.22\)'
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('ignore') # override warning behavior
warnings.filterwarnings("always", message=msg,
category=NumbaDeprecationWarning,)
f = njit(lambda : np.MachAr().eps)
f()
self.assertEqual(len(w), 1)
self.assertIn('`np.MachAr` is deprecated', str(w[0]))
class TestRegistryImports(TestCase):
def test_unsafe_import_in_registry(self):
# See 8940
# This should not fail
code = dedent("""
import numba
import numpy as np
@numba.njit
def foo():
np.array([1 for _ in range(1)])
foo()
print("OK")
""")
result, error = run_in_subprocess(code)
# Assert that the bytestring "OK" was printed to stdout
self.assertEqual(b"OK", result.strip())
self.assertEqual(b"", error.strip())
if __name__ == '__main__':
unittest.main()
Reference in New Issue View Git Blame Copy Permalink