class TestElementwiseType(unittest.TestCase):
# Skip this test due to NumPy bug on Windows (fixed in NumPy 1.14.0).
# https://github.com/numpy/numpy/pull/9778
@unittest.skipIf(sys.platform == 'win32'
and testing.numpy_satisfies('<1.14'),
'This test requires 1.14.0 when running on Windows.')
@testing.for_int_dtypes(no_bool=True)
@testing.numpy_cupy_array_equal()
def test_large_int_upper_1(self, xp, dtype):
a = xp.array([0], dtype=xp.int8)
b = xp.iinfo(dtype).max
return a + b
@testing.for_int_dtypes(no_bool=True)
@testing.numpy_cupy_array_equal()
def test_large_int_upper_2(self, xp, dtype):
a = xp.array([1], dtype=xp.int8)
b = xp.iinfo(dtype).max - 1
return a + b
@testing.for_int_dtypes(no_bool=True)
@testing.numpy_cupy_array_equal()
def test_large_int_upper_3(self, xp, dtype):
a = xp.array([xp.iinfo(dtype).max], dtype=dtype)
b = xp.int8(0)
return a + b
@testing.for_int_dtypes(no_bool=True)
@testing.numpy_cupy_array_equal()
def test_large_int_upper_4(self, xp, dtype):
a = xp.array([xp.iinfo(dtype).max - 1], dtype=dtype)
b = xp.int8(1)
return a + b
@testing.for_int_dtypes(no_bool=True)
@testing.numpy_cupy_array_equal()
def test_large_int_lower_1(self, xp, dtype):
a = xp.array([0], dtype=xp.int8)
b = xp.iinfo(dtype).min
return a + b
@testing.for_int_dtypes(no_bool=True)
@testing.numpy_cupy_array_equal()
def test_large_int_lower_2(self, xp, dtype):
a = xp.array([-1], dtype=xp.int8)
b = xp.iinfo(dtype).min + 1
return a + b
@testing.for_int_dtypes(no_bool=True)
@testing.numpy_cupy_array_equal()
def test_large_int_lower_3(self, xp, dtype):
a = xp.array([xp.iinfo(dtype).min], dtype=dtype)
b = xp.int8(0)
return a + b
@testing.for_int_dtypes(no_bool=True)
@testing.numpy_cupy_array_equal()
def test_large_int_lower_4(self, xp, dtype):
a = xp.array([xp.iinfo(dtype).min + 1], dtype=dtype)
b = xp.int8(-1)
return a + b
class TestMisc(unittest.TestCase):
_multiprocess_can_split_ = True
@testing.for_all_dtypes(no_complex=True)
@testing.numpy_cupy_allclose(atol=1e-5)
def check_unary(self, name, xp, dtype, no_bool=False):
if no_bool and numpy.dtype(dtype).char == '?':
return numpy.int_(0)
a = testing.shaped_arange((2, 3), xp, dtype)
return getattr(xp, name)(a)
@testing.for_all_dtypes(no_complex=True)
@testing.numpy_cupy_allclose(atol=1e-5)
def check_binary(self, name, xp, dtype, no_bool=False):
if no_bool and numpy.dtype(dtype).char == '?':
return numpy.int_(0)
a = testing.shaped_arange((2, 3), xp, dtype)
b = testing.shaped_reverse_arange((2, 3), xp, dtype)
return getattr(xp, name)(a, b)
@testing.for_dtypes(['?', 'b', 'h', 'i', 'q', 'e', 'f', 'd'])
@testing.numpy_cupy_allclose(atol=1e-5)
def check_unary_negative(self, name, xp, dtype, no_bool=False):
if no_bool and numpy.dtype(dtype).char == '?':
return numpy.int_(0)
a = xp.array([-3, -2, -1, 1, 2, 3], dtype=dtype)
return getattr(xp, name)(a)
@testing.for_float_dtypes()
@testing.numpy_cupy_array_equal()
def check_binary_nan(self, name, xp, dtype):
a = xp.array([-3, numpy.NAN, -1, numpy.NAN, 0, numpy.NAN, 2],
dtype=dtype)
b = xp.array([numpy.NAN, numpy.NAN, 1, 0, numpy.NAN, -1, -2],
dtype=dtype)
return getattr(xp, name)(a, b)
@unittest.skipIf(sys.platform == 'win32', 'dtype problem on Windows')
@testing.for_all_dtypes(no_complex=True)
@testing.numpy_cupy_array_equal()
def test_clip1(self, xp, dtype):
a = testing.shaped_arange((2, 3, 4), xp, dtype)
return a.clip(3, 13)
@testing.for_all_dtypes(no_bool=True, no_complex=True)
@testing.numpy_cupy_array_equal()
def test_clip3(self, xp, dtype):
a = testing.shaped_arange((2, 3, 4), xp, dtype)
return a.clip(3, 13)
@testing.for_all_dtypes(no_bool=True, no_complex=True)
@testing.numpy_cupy_array_equal()
def test_clip_min_none(self, xp, dtype):
a = testing.shaped_arange((2, 3, 4), xp, dtype)
return a.clip(None, 3)
# Skip this test due to NumPy bug on Windows (fixed in NumPy 1.14.0).
# https://github.com/numpy/numpy/pull/9778
@unittest.skipIf(sys.platform == 'win32'
and testing.numpy_satisfies('<1.14'),
'This test requires 1.14.0 when running on Windows.')
@testing.for_all_dtypes(no_bool=True, no_complex=True)
@testing.numpy_cupy_array_equal()
def test_clip_max_none(self, xp, dtype):
a = testing.shaped_arange((2, 3, 4), xp, dtype)
return a.clip(3, None)
@testing.for_all_dtypes(no_bool=True, no_complex=True)
@testing.numpy_cupy_raises(accept_error=ValueError)
def test_clip_min_max_none(self, xp, dtype):
a = testing.shaped_arange((2, 3, 4), xp, dtype)
return a.clip(None, None)
@unittest.skipIf(sys.platform == 'win32', 'dtype problem on Windows')
@testing.for_all_dtypes(no_complex=True)
@testing.numpy_cupy_array_equal()
def test_external_clip1(self, xp, dtype):
a = testing.shaped_arange((2, 3, 4), xp, dtype)
return xp.clip(a, 3, 13)
@testing.for_all_dtypes(no_bool=True, no_complex=True)
@testing.numpy_cupy_array_equal()
def test_external_clip2(self, xp, dtype):
a = testing.shaped_arange((2, 3, 4), xp, dtype)
return xp.clip(a, 3, 13)
@testing.for_all_dtypes(no_complex=True)
@testing.numpy_cupy_array_equal()
def test_clip2(self, xp, dtype):
a = testing.shaped_arange((2, 3, 4), xp, dtype)
a_min = xp.array([3, 4, 5, 6], dtype=dtype)
a_max = xp.array([[10], [9], [8]], dtype=dtype)
return a.clip(a_min, a_max)
@testing.with_requires('numpy>=1.11.2')
def test_sqrt(self):
# numpy.sqrt is broken in numpy<1.11.2
self.check_unary('sqrt')
def test_square(self):
self.check_unary('square')
def test_absolute(self):
self.check_unary('absolute')
def test_absolute_negative(self):
self.check_unary_negative('absolute')
def test_sign(self):
self.check_unary('sign', no_bool=True)
def test_sign_negative(self):
self.check_unary_negative('sign', no_bool=True)
def test_maximum(self):
self.check_binary('maximum')
def test_maximum_nan(self):
self.check_binary_nan('maximum')
def test_minimum(self):
self.check_binary('minimum')
def test_minimum_nan(self):
self.check_binary_nan('minimum')
def test_fmax(self):
self.check_binary('fmax')
def test_fmax_nan(self):
self.check_binary_nan('fmax')
def test_fmin(self):
self.check_binary('fmin')
def test_fmin_nan(self):
self.check_binary_nan('fmin')
import unittest
import warnings
import numpy
from cupy import testing
_bool_ok = testing.numpy_satisfies('>=1.10') # after numpy PR #5946
_float16_ok = testing.numpy_satisfies('>=1.15') # after numpy PR #10911
def _dec_shape(shape, dec):
# Test smaller shape
return tuple(1 if s == 1 else max(0, s - dec) for s in shape)
def _rand1_shape(shape, prob):
# Test broadcast
# If diagonals are "broadcasted" we can simply:
# return tuple(1 if numpy.random.rand() < prob else s for s in shape)
table = {}
new_shape = []
for s in shape:
if s not in table:
table[s] = 1 if numpy.random.rand() < prob else s
new_shape.append(table[s])
return tuple(new_shape)
def augument_einsum_testcases(*params):
"""Modify shapes in einsum tests
def check_binary(self, xp):
arg1 = self.arg1
arg2 = self.arg2
np1 = numpy.asarray(arg1)
np2 = numpy.asarray(arg2)
dtype1 = np1.dtype
dtype2 = np2.dtype
if self.name == 'power':
# TODO(niboshi): Fix this: power(0, 1j)
# numpy => 1+0j
# cupy => 0j
if dtype2 in complex_types and (np1 == 0).any():
return xp.array(True)
# TODO(niboshi): Fix this: xp.power(0j, 0)
# numpy => 1+0j
# cupy => 0j
c_arg1 = dtype1 in complex_types
if c_arg1 and (np1 == 0j).any() and (np2 == 0).any():
return xp.array(True)
# TODO(niboshi): Fix this: xp.add(0j, xp.array([2.], 'f')).dtype
# numpy => complex64
# cupy => complex128
if isinstance(arg1, complex):
if dtype2 in (numpy.float16, numpy.float32):
return xp.array(True)
if isinstance(arg1, numpy.ndarray):
arg1 = xp.asarray(arg1)
if isinstance(arg2, numpy.ndarray):
arg2 = xp.asarray(arg2)
# NumPy>=1.13.0 does not support subtraction between booleans
# TODO(niboshi): Write a separate test to check both NumPy and CuPy
# raise TypeError.
if testing.numpy_satisfies('>=1.13.0') and self.name == 'subtract':
if dtype1 == numpy.bool_ and dtype2 == numpy.bool_:
return xp.array(True)
func = getattr(xp, self.name)
with testing.NumpyError(divide='ignore'):
with numpy.warnings.catch_warnings():
numpy.warnings.filterwarnings('ignore')
if self.use_dtype:
y = func(arg1, arg2, dtype=self.dtype)
else:
y = func(arg1, arg2)
# TODO(niboshi): Fix this. If rhs is a Python complex,
# numpy returns complex64
# cupy returns complex128
if xp is cupy and isinstance(arg2, complex):
if dtype1 in (numpy.float16, numpy.float32):
y = y.astype(numpy.complex64)
# NumPy returns different values (nan/inf) on division by zero
# depending on the architecture.
# As it is not possible for CuPy to replicate this behavior, we ignore
# the difference here.
if self.name in ('floor_divide', 'remainder'):
if y.dtype in (float_types + complex_types) and (np2 == 0).any():
y = xp.asarray(y)
y[y == numpy.inf] = numpy.nan
y[y == -numpy.inf] = numpy.nan
return y
def test_numpy_satisfies(self):
assert testing.numpy_satisfies('>1.10')
assert not testing.numpy_satisfies('>=2.10')
