import fnmatch

import inspect

import itertools

import operator

import platform

import sys

import warnings

from collections import namedtuple

from fractions import Fraction

from functools import reduce

import pytest

import numpy as np

import numpy._core.umath as ncu

from numpy._core import _umath_tests as ncu_tests, sctypes

from numpy.testing import (

HAS_REFCOUNT,

IS_MUSL,

IS_WASM,

_gen_alignment_data,

assert_,

assert_allclose,

assert_almost_equal,

assert_array_almost_equal,

assert_array_almost_equal_nulp,

assert_array_equal,

assert_array_max_ulp,

assert_equal,

assert_no_warnings,

assert_raises,

assert_raises_regex,

)

from numpy.testing._private.utils import _glibc_older_than

UFUNCS = [obj for obj in np._core.umath.__dict__.values()

if isinstance(obj, np.ufunc)]

UFUNCS_UNARY = [

uf for uf in UFUNCS if uf.nin == 1

]

UFUNCS_UNARY_FP = [

uf for uf in UFUNCS_UNARY if 'f->f' in uf.types

]

UFUNCS_BINARY = [

uf for uf in UFUNCS if uf.nin == 2

]

UFUNCS_BINARY_ACC = [

uf for uf in UFUNCS_BINARY if hasattr(uf, "accumulate") and uf.nout == 1

]

def interesting_binop_operands(val1, val2, dtype):

"""

Helper to create "interesting" operands to cover common code paths:

* scalar inputs

* only first "values" is an array (e.g. scalar division fast-paths)

* Longer array (SIMD) placing the value of interest at different positions

* Oddly strided arrays which may not be SIMD compatible

It does not attempt to cover unaligned access or mixed dtypes.

These are normally handled by the casting/buffering machinery.

This is not a fixture (currently), since I believe a fixture normally

only yields once?

"""

fill_value = 1 # could be a parameter, but maybe not an optional one?

arr1 = np.full(10003, dtype=dtype, fill_value=fill_value)

arr2 = np.full(10003, dtype=dtype, fill_value=fill_value)

arr1[0] = val1

arr2[0] = val2

extractor = lambda res: res

yield arr1[0], arr2[0], extractor, "scalars"

extractor = lambda res: res

yield arr1[0, ...], arr2[0, ...], extractor, "scalar-arrays"

# reset array values to fill_value:

arr1[0] = fill_value

arr2[0] = fill_value

for pos in [0, 1, 2, 3, 4, 5, -1, -2, -3, -4]:

arr1[pos] = val1

arr2[pos] = val2

extractor = lambda res: res[pos]

yield arr1, arr2, extractor, f"off-{pos}"

yield arr1, arr2[pos], extractor, f"off-{pos}-with-scalar"

arr1[pos] = fill_value

arr2[pos] = fill_value

for stride in [-1, 113]:

op1 = arr1[::stride]

op2 = arr2[::stride]

op1[10] = val1

op2[10] = val2

extractor = lambda res: res[10]

yield op1, op2, extractor, f"stride-{stride}"

op1[10] = fill_value

op2[10] = fill_value

def on_powerpc():

""" True if we are running on a Power PC platform."""

return platform.processor() == 'powerpc' or \

platform.machine().startswith('ppc')

def bad_arcsinh():

"""The blocklisted trig functions are not accurate on aarch64/PPC for

complex256. Rather than dig through the actual problem skip the

test. This should be fixed when we can move past glibc2.17

which is the version in manylinux2014

"""

if platform.machine() == 'aarch64':

x = 1.78e-10

elif on_powerpc():

x = 2.16e-10

else:

return False

v1 = np.arcsinh(np.float128(x))

v2 = np.arcsinh(np.complex256(x)).real

# The eps for float128 is 1-e33, so this is way bigger

return abs((v1 / v2) - 1.0) > 1e-23

class _FilterInvalids:

def setup_method(self):

self.olderr = np.seterr(invalid='ignore')

def teardown_method(self):

np.seterr(**self.olderr)

class TestConstants:

def test_pi(self):

assert_allclose(ncu.pi, 3.141592653589793, 1e-15)

def test_e(self):

assert_allclose(ncu.e, 2.718281828459045, 1e-15)

def test_euler_gamma(self):

assert_allclose(ncu.euler_gamma, 0.5772156649015329, 1e-15)

class TestOut:

def test_out_subok(self):

for subok in (True, False):

a = np.array(0.5)

o = np.empty(())

r = np.add(a, 2, o, subok=subok)

assert_(r is o)

r = np.add(a, 2, out=o, subok=subok)

assert_(r is o)

r = np.add(a, 2, out=(o,), subok=subok)

assert_(r is o)

d = np.array(5.7)

o1 = np.empty(())

o2 = np.empty((), dtype=np.int32)

r1, r2 = np.frexp(d, o1, None, subok=subok)

assert_(r1 is o1)

r1, r2 = np.frexp(d, None, o2, subok=subok)

assert_(r2 is o2)

r1, r2 = np.frexp(d, o1, o2, subok=subok)

assert_(r1 is o1)

assert_(r2 is o2)

r1, r2 = np.frexp(d, out=(o1, None), subok=subok)

assert_(r1 is o1)

r1, r2 = np.frexp(d, out=(None, o2), subok=subok)

assert_(r2 is o2)

r1, r2 = np.frexp(d, out=(o1, o2), subok=subok)

assert_(r1 is o1)

assert_(r2 is o2)

with assert_raises(TypeError):

# Out argument must be tuple, since there are multiple outputs.

r1, r2 = np.frexp(d, out=o1, subok=subok)

assert_raises(TypeError, np.add, a, 2, o, o, subok=subok)

assert_raises(TypeError, np.add, a, 2, o, out=o, subok=subok)

assert_raises(TypeError, np.add, a, 2, None, out=o, subok=subok)

assert_raises(ValueError, np.add, a, 2, out=(o, o), subok=subok)

assert_raises(ValueError, np.add, a, 2, out=(), subok=subok)

assert_raises(TypeError, np.add, a, 2, [], subok=subok)

assert_raises(TypeError, np.add, a, 2, out=[], subok=subok)

assert_raises(TypeError, np.add, a, 2, out=([],), subok=subok)

o.flags.writeable = False

assert_raises(ValueError, np.add, a, 2, o, subok=subok)

assert_raises(ValueError, np.add, a, 2, out=o, subok=subok)

assert_raises(ValueError, np.add, a, 2, out=(o,), subok=subok)

def test_out_wrap_subok(self):

class ArrayWrap(np.ndarray):

__array_priority__ = 10

def __new__(cls, arr):

return np.asarray(arr).view(cls).copy()

def __array_wrap__(self, arr, context=None, return_scalar=False):

return arr.view(type(self))

for subok in (True, False):

a = ArrayWrap([0.5])

r = np.add(a, 2, subok=subok)

if subok:

assert_(isinstance(r, ArrayWrap))

else:

assert_(type(r) is np.ndarray)

r = np.add(a, 2, None, subok=subok)

if subok:

assert_(isinstance(r, ArrayWrap))

else:

assert_(type(r) is np.ndarray)

r = np.add(a, 2, out=None, subok=subok)

if subok:

assert_(isinstance(r, ArrayWrap))

else:

assert_(type(r) is np.ndarray)

r = np.add(a, 2, out=(None,), subok=subok)

if subok:

assert_(isinstance(r, ArrayWrap))

else:

assert_(type(r) is np.ndarray)

d = ArrayWrap([5.7])

o1 = np.empty((1,))

o2 = np.empty((1,), dtype=np.int32)

r1, r2 = np.frexp(d, o1, subok=subok)

if subok:

assert_(isinstance(r2, ArrayWrap))

else:

assert_(type(r2) is np.ndarray)

r1, r2 = np.frexp(d, o1, None, subok=subok)

if subok:

assert_(isinstance(r2, ArrayWrap))

else:

assert_(type(r2) is np.ndarray)

r1, r2 = np.frexp(d, None, o2, subok=subok)

if subok:

assert_(isinstance(r1, ArrayWrap))

else:

assert_(type(r1) is np.ndarray)

r1, r2 = np.frexp(d, out=(o1, None), subok=subok)

if subok:

assert_(isinstance(r2, ArrayWrap))

else:

assert_(type(r2) is np.ndarray)

r1, r2 = np.frexp(d, out=(None, o2), subok=subok)

if subok:

assert_(isinstance(r1, ArrayWrap))

else:

assert_(type(r1) is np.ndarray)

with assert_raises(TypeError):

# Out argument must be tuple, since there are multiple outputs.

r1, r2 = np.frexp(d, out=o1, subok=subok)

@pytest.mark.skipif(not HAS_REFCOUNT, reason="Python lacks refcounts")

def test_out_wrap_no_leak(self):

# Regression test for gh-26545

class ArrSubclass(np.ndarray):

pass

arr = np.arange(10).view(ArrSubclass)

orig_refcount = sys.getrefcount(arr)

arr *= 1

assert sys.getrefcount(arr) == orig_refcount

class TestComparisons:

import operator

@pytest.mark.parametrize('dtype', sctypes['uint'] + sctypes['int'] +

sctypes['float'] + [np.bool])

@pytest.mark.parametrize('py_comp,np_comp', [

(operator.lt, np.less),

(operator.le, np.less_equal),

(operator.gt, np.greater),

(operator.ge, np.greater_equal),

(operator.eq, np.equal),

(operator.ne, np.not_equal)

])

def test_comparison_functions(self, dtype, py_comp, np_comp):

# Initialize input arrays

if dtype == np.bool:

a = np.random.choice(a=[False, True], size=1000)

b = np.random.choice(a=[False, True], size=1000)

scalar = True

else:

a = np.random.randint(low=1, high=10, size=1000).astype(dtype)

b = np.random.randint(low=1, high=10, size=1000).astype(dtype)

scalar = 5

np_scalar = np.dtype(dtype).type(scalar)

a_lst = a.tolist()

b_lst = b.tolist()

# (Binary) Comparison (x1=array, x2=array)

comp_b = np_comp(a, b).view(np.uint8)

comp_b_list = [int(py_comp(x, y)) for x, y in zip(a_lst, b_lst)]

# (Scalar1) Comparison (x1=scalar, x2=array)

comp_s1 = np_comp(np_scalar, b).view(np.uint8)

comp_s1_list = [int(py_comp(scalar, x)) for x in b_lst]

# (Scalar2) Comparison (x1=array, x2=scalar)

comp_s2 = np_comp(a, np_scalar).view(np.uint8)

comp_s2_list = [int(py_comp(x, scalar)) for x in a_lst]

# Sequence: Binary, Scalar1 and Scalar2

assert_(comp_b.tolist() == comp_b_list,

f"Failed comparison ({py_comp.__name__})")

assert_(comp_s1.tolist() == comp_s1_list,

f"Failed comparison ({py_comp.__name__})")

assert_(comp_s2.tolist() == comp_s2_list,

f"Failed comparison ({py_comp.__name__})")

def test_ignore_object_identity_in_equal(self):

# Check comparing identical objects whose comparison

# is not a simple boolean, e.g., arrays that are compared elementwise.

a = np.array([np.array([1, 2, 3]), None], dtype=object)

assert_raises(ValueError, np.equal, a, a)

# Check error raised when comparing identical non-comparable objects.

class FunkyType:

def __eq__(self, other):

raise TypeError("I won't compare")

a = np.array([FunkyType()])

assert_raises(TypeError, np.equal, a, a)

# Check identity doesn't override comparison mismatch.

a = np.array([np.nan], dtype=object)

assert_equal(np.equal(a, a), [False])

def test_ignore_object_identity_in_not_equal(self):

# Check comparing identical objects whose comparison

# is not a simple boolean, e.g., arrays that are compared elementwise.

a = np.array([np.array([1, 2, 3]), None], dtype=object)

assert_raises(ValueError, np.not_equal, a, a)

# Check error raised when comparing identical non-comparable objects.

class FunkyType:

def __ne__(self, other):

raise TypeError("I won't compare")

a = np.array([FunkyType()])

assert_raises(TypeError, np.not_equal, a, a)

# Check identity doesn't override comparison mismatch.

a = np.array([np.nan], dtype=object)

assert_equal(np.not_equal(a, a), [True])

def test_error_in_equal_reduce(self):

# gh-20929

# make sure np.equal.reduce raises a TypeError if an array is passed

# without specifying the dtype

a = np.array([0, 0])

assert_equal(np.equal.reduce(a, dtype=bool), True)

assert_raises(TypeError, np.equal.reduce, a)

def test_object_dtype(self):

assert np.equal(1, [1], dtype=object).dtype == object

assert np.equal(1, [1], signature=(None, None, "O")).dtype == object

def test_object_nonbool_dtype_error(self):

# bool output dtype is fine of course:

assert np.equal(1, [1], dtype=bool).dtype == bool

# but the following are examples do not have a loop:

with pytest.raises(TypeError, match="No loop matching"):

np.equal(1, 1, dtype=np.int64)

with pytest.raises(TypeError, match="No loop matching"):

np.equal(1, 1, sig=(None, None, "l"))

@pytest.mark.parametrize("dtypes", ["qQ", "Qq"])

@pytest.mark.parametrize('py_comp, np_comp', [

(operator.lt, np.less),

(operator.le, np.less_equal),

(operator.gt, np.greater),

(operator.ge, np.greater_equal),

(operator.eq, np.equal),

(operator.ne, np.not_equal)

])

@pytest.mark.parametrize("vals", [(2**60, 2**60 + 1), (2**60 + 1, 2**60)])

def test_large_integer_direct_comparison(

self, dtypes, py_comp, np_comp, vals):

# Note that float(2**60) + 1 == float(2**60).

a1 = np.array([2**60], dtype=dtypes[0])

a2 = np.array([2**60 + 1], dtype=dtypes[1])

expected = py_comp(2**60, 2**60 + 1)

assert py_comp(a1, a2) == expected

assert np_comp(a1, a2) == expected

# Also check the scalars:

s1 = a1[0]

s2 = a2[0]

assert isinstance(s1, np.integer)

assert isinstance(s2, np.integer)

# The Python operator here is mainly interesting:

assert py_comp(s1, s2) == expected

assert np_comp(s1, s2) == expected

@pytest.mark.parametrize("dtype", np.typecodes['UnsignedInteger'])

@pytest.mark.parametrize('py_comp_func, np_comp_func', [

(operator.lt, np.less),

(operator.le, np.less_equal),

(operator.gt, np.greater),

(operator.ge, np.greater_equal),

(operator.eq, np.equal),

(operator.ne, np.not_equal)

])

@pytest.mark.parametrize("flip", [True, False])

def test_unsigned_signed_direct_comparison(

self, dtype, py_comp_func, np_comp_func, flip):

if flip:

py_comp = lambda x, y: py_comp_func(y, x)

np_comp = lambda x, y: np_comp_func(y, x)

else:

py_comp = py_comp_func

np_comp = np_comp_func

arr = np.array([np.iinfo(dtype).max], dtype=dtype)

expected = py_comp(int(arr[0]), -1)

assert py_comp(arr, -1) == expected

assert np_comp(arr, -1) == expected

scalar = arr[0]

assert isinstance(scalar, np.integer)

# The Python operator here is mainly interesting:

assert py_comp(scalar, -1) == expected

assert np_comp(scalar, -1) == expected

class TestAdd:

def test_reduce_alignment(self):

# gh-9876

# make sure arrays with weird strides work with the optimizations in

# pairwise_sum_@TYPE@. On x86, the 'b' field will count as aligned at a

# 4 byte offset, even though its itemsize is 8.

a = np.zeros(2, dtype=[('a', np.int32), ('b', np.float64)])

a['a'] = -1

assert_equal(a['b'].sum(), 0)

class TestDivision:

def test_division_int(self):

# int division should follow Python

x = np.array([5, 10, 90, 100, -5, -10, -90, -100, -120])

if 5 / 10 == 0.5:

assert_equal(x / 100, [0.05, 0.1, 0.9, 1,

-0.05, -0.1, -0.9, -1, -1.2])

else:

assert_equal(x / 100, [0, 0, 0, 1, -1, -1, -1, -1, -2])

assert_equal(x // 100, [0, 0, 0, 1, -1, -1, -1, -1, -2])

assert_equal(x % 100, [5, 10, 90, 0, 95, 90, 10, 0, 80])

@pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")

@pytest.mark.parametrize("dtype,ex_val", itertools.product(

sctypes['int'] + sctypes['uint'], (

(

# dividend

"np.array(range(fo.max-lsize, fo.max)).astype(dtype),"

# divisors

"np.arange(lsize).astype(dtype),"

# scalar divisors

"range(15)"

),

(

# dividend

"np.arange(fo.min, fo.min+lsize).astype(dtype),"

# divisors

"np.arange(lsize//-2, lsize//2).astype(dtype),"

# scalar divisors

"range(fo.min, fo.min + 15)"

), (

# dividend

"np.array(range(fo.max-lsize, fo.max)).astype(dtype),"

# divisors

"np.arange(lsize).astype(dtype),"

# scalar divisors

"[1,3,9,13,neg, fo.min+1, fo.min//2, fo.max//3, fo.max//4]"

)

)

))

def test_division_int_boundary(self, dtype, ex_val):

fo = np.iinfo(dtype)

neg = -1 if fo.min < 0 else 1

# Large enough to test SIMD loops and remainder elements

lsize = 512 + 7

a, b, divisors = eval(ex_val)

a_lst, b_lst = a.tolist(), b.tolist()

c_div = lambda n, d: (

0 if d == 0 else (

fo.min if (n and n == fo.min and d == -1) else n // d

)

)

with np.errstate(divide='ignore'):

ac = a.copy()

ac //= b

div_ab = a // b

div_lst = [c_div(x, y) for x, y in zip(a_lst, b_lst)]

msg = "Integer arrays floor division check (//)"

assert all(div_ab == div_lst), msg

msg_eq = "Integer arrays floor division check (//=)"

assert all(ac == div_lst), msg_eq

for divisor in divisors:

ac = a.copy()

with np.errstate(divide='ignore', over='ignore'):

div_a = a // divisor

ac //= divisor

div_lst = [c_div(i, divisor) for i in a_lst]

assert all(div_a == div_lst), msg

assert all(ac == div_lst), msg_eq

with np.errstate(divide='raise', over='raise'):

if 0 in b:

# Verify overflow case

with pytest.raises(FloatingPointError,

match="divide by zero encountered in floor_divide"):

a // b

else:

a // b

if fo.min and fo.min in a:

with pytest.raises(FloatingPointError,

match='overflow encountered in floor_divide'):

a // -1

elif fo.min:

a // -1

with pytest.raises(FloatingPointError,

match="divide by zero encountered in floor_divide"):

a // 0

with pytest.raises(FloatingPointError,

match="divide by zero encountered in floor_divide"):

ac = a.copy()

ac //= 0

np.array([], dtype=dtype) // 0

@pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")

@pytest.mark.parametrize("dtype,ex_val", itertools.product(

sctypes['int'] + sctypes['uint'], (

"np.array([fo.max, 1, 2, 1, 1, 2, 3], dtype=dtype)",

"np.array([fo.min, 1, -2, 1, 1, 2, -3]).astype(dtype)",

"np.arange(fo.min, fo.min+(100*10), 10, dtype=dtype)",

"np.array(range(fo.max-(100*7), fo.max, 7)).astype(dtype)",

)

))

def test_division_int_reduce(self, dtype, ex_val):

fo = np.iinfo(dtype)

a = eval(ex_val)

lst = a.tolist()

c_div = lambda n, d: (

0 if d == 0 or (n and n == fo.min and d == -1) else n // d

)

with np.errstate(divide='ignore'):

div_a = np.floor_divide.reduce(a)

div_lst = reduce(c_div, lst)

msg = "Reduce floor integer division check"

assert div_a == div_lst, msg

with np.errstate(divide='raise', over='raise'):

with pytest.raises(FloatingPointError,

match="divide by zero encountered in reduce"):

np.floor_divide.reduce(np.arange(-100, 100).astype(dtype))

if fo.min:

with pytest.raises(FloatingPointError,

match='overflow encountered in reduce'):

np.floor_divide.reduce(

np.array([fo.min, 1, -1], dtype=dtype)

)

@pytest.mark.parametrize(

"dividend,divisor,quotient",

[(np.timedelta64(2, 'Y'), np.timedelta64(2, 'M'), 12),

(np.timedelta64(2, 'Y'), np.timedelta64(-2, 'M'), -12),

(np.timedelta64(-2, 'Y'), np.timedelta64(2, 'M'), -12),

(np.timedelta64(-2, 'Y'), np.timedelta64(-2, 'M'), 12),

(np.timedelta64(2, 'M'), np.timedelta64(-2, 'Y'), -1),

(np.timedelta64(2, 'Y'), np.timedelta64(0, 'M'), 0),

(np.timedelta64(2, 'Y'), 2, np.timedelta64(1, 'Y')),

(np.timedelta64(2, 'Y'), -2, np.timedelta64(-1, 'Y')),

(np.timedelta64(-2, 'Y'), 2, np.timedelta64(-1, 'Y')),

(np.timedelta64(-2, 'Y'), -2, np.timedelta64(1, 'Y')),

(np.timedelta64(-2, 'Y'), -2, np.timedelta64(1, 'Y')),

(np.timedelta64(-2, 'Y'), -3, np.timedelta64(0, 'Y')),

(np.timedelta64(-2, 'Y'), 0, np.timedelta64('Nat', 'Y')),

])

def test_division_int_timedelta(self, dividend, divisor, quotient):

# If either divisor is 0 or quotient is Nat, check for division by 0

if divisor and (isinstance(quotient, int) or not np.isnat(quotient)):

msg = "Timedelta floor division check"

assert dividend // divisor == quotient, msg

# Test for arrays as well

msg = "Timedelta arrays floor division check"

dividend_array = np.array([dividend] * 5)

quotient_array = np.array([quotient] * 5)

assert all(dividend_array // divisor == quotient_array), msg

else:

if IS_WASM:

pytest.skip("fp errors don't work in wasm")

with np.errstate(divide='raise', invalid='raise'):

with pytest.raises(FloatingPointError):

dividend // divisor

def test_division_complex(self):

# check that implementation is correct

msg = "Complex division implementation check"

x = np.array([1. + 1. * 1j, 1. + .5 * 1j, 1. + 2. * 1j], dtype=np.complex128)

assert_almost_equal(x**2 / x, x, err_msg=msg)

# check overflow, underflow

msg = "Complex division overflow/underflow check"

x = np.array([1.e+110, 1.e-110], dtype=np.complex128)

y = x**2 / x

assert_almost_equal(y / x, [1, 1], err_msg=msg)

def test_zero_division_complex(self):

with np.errstate(invalid="ignore", divide="ignore"):

x = np.array([0.0], dtype=np.complex128)

y = 1.0 / x

assert_(np.isinf(y)[0])

y = complex(np.inf, np.nan) / x

assert_(np.isinf(y)[0])

y = complex(np.nan, np.inf) / x

assert_(np.isinf(y)[0])

y = complex(np.inf, np.inf) / x

assert_(np.isinf(y)[0])

y = 0.0 / x

assert_(np.isnan(y)[0])

def test_floor_division_complex(self):

# check that floor division, divmod and remainder raises type errors

x = np.array(

[.9 + 1j, -.1 + 1j, .9 + .5 * 1j, .9 + 2. * 1j],

dtype=np.complex128,

)

with pytest.raises(TypeError):

x // 7

with pytest.raises(TypeError):

np.divmod(x, 7)

with pytest.raises(TypeError):

np.remainder(x, 7)

def test_floor_division_signed_zero(self):

# Check that the sign bit is correctly set when dividing positive and

# negative zero by one.

x = np.zeros(10)

assert_equal(np.signbit(x // 1), 0)

assert_equal(np.signbit((-x) // 1), 1)

@pytest.mark.skipif(hasattr(np.__config__, "blas_ssl2_info"),

reason="gh-22982")

@pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")

@pytest.mark.parametrize('dtype', np.typecodes['Float'])

def test_floor_division_errors(self, dtype):

fnan = np.array(np.nan, dtype=dtype)

fone = np.array(1.0, dtype=dtype)

fzer = np.array(0.0, dtype=dtype)

finf = np.array(np.inf, dtype=dtype)

# divide by zero error check

with np.errstate(divide='raise', invalid='ignore'):

assert_raises(FloatingPointError, np.floor_divide, fone, fzer)

with np.errstate(divide='ignore', invalid='raise'):

np.floor_divide(fone, fzer)

# The following already contain a NaN and should not warn

with np.errstate(all='raise'):

np.floor_divide(fnan, fone)

np.floor_divide(fone, fnan)

np.floor_divide(fnan, fzer)

np.floor_divide(fzer, fnan)

@pytest.mark.parametrize('dtype', np.typecodes['Float'])

def test_floor_division_corner_cases(self, dtype):

# test corner cases like 1.0//0.0 for errors and return vals

x = np.zeros(10, dtype=dtype)

y = np.ones(10, dtype=dtype)

fnan = np.array(np.nan, dtype=dtype)

fone = np.array(1.0, dtype=dtype)

fzer = np.array(0.0, dtype=dtype)

finf = np.array(np.inf, dtype=dtype)

with warnings.catch_warnings():

warnings.filterwarnings(

'ignore',

"invalid value encountered in floor_divide",

RuntimeWarning,

)

div = np.floor_divide(fnan, fone)

assert np.isnan(div), f"div: {div}"

div = np.floor_divide(fone, fnan)

assert np.isnan(div), f"div: {div}"

div = np.floor_divide(fnan, fzer)

assert np.isnan(div), f"div: {div}"

# verify 1.0//0.0 computations return inf

with np.errstate(divide='ignore'):

z = np.floor_divide(y, x)

assert_(np.isinf(z).all())

def floor_divide_and_remainder(x, y):

return (np.floor_divide(x, y), np.remainder(x, y))

def _signs(dt):

if dt in np.typecodes['UnsignedInteger']:

return (+1,)

else:

return (+1, -1)

class TestRemainder:

def test_remainder_basic(self):

dt = np.typecodes['AllInteger'] + np.typecodes['Float']

for op in [floor_divide_and_remainder, np.divmod]:

for dt1, dt2 in itertools.product(dt, dt):

for sg1, sg2 in itertools.product(_signs(dt1), _signs(dt2)):

fmt = 'op: %s, dt1: %s, dt2: %s, sg1: %s, sg2: %s'

msg = fmt % (op.__name__, dt1, dt2, sg1, sg2)

a = np.array(sg1 * 71, dtype=dt1)

b = np.array(sg2 * 19, dtype=dt2)

div, rem = op(a, b)

assert_equal(div * b + rem, a, err_msg=msg)

if sg2 == -1:

assert_(b < rem <= 0, msg)

else:

assert_(b > rem >= 0, msg)

def test_float_remainder_exact(self):

# test that float results are exact for small integers. This also

# holds for the same integers scaled by powers of two.

nlst = list(range(-127, 0))

plst = list(range(1, 128))

dividend = nlst + [0] + plst

divisor = nlst + plst

arg = list(itertools.product(dividend, divisor))

tgt = [divmod(*t) for t in arg]

a, b = np.array(arg, dtype=int).T

# convert exact integer results from Python to float so that

# signed zero can be used, it is checked.

tgtdiv, tgtrem = np.array(tgt, dtype=float).T

tgtdiv = np.where((tgtdiv == 0.0) & ((b < 0) ^ (a < 0)), -0.0, tgtdiv)

tgtrem = np.where((tgtrem == 0.0) & (b < 0), -0.0, tgtrem)

for op in [floor_divide_and_remainder, np.divmod]:

for dt in np.typecodes['Float']:

msg = f'op: {op.__name__}, dtype: {dt}'

fa = a.astype(dt)

fb = b.astype(dt)

div, rem = op(fa, fb)

assert_equal(div, tgtdiv, err_msg=msg)

assert_equal(rem, tgtrem, err_msg=msg)

def test_float_remainder_roundoff(self):

# gh-6127

dt = np.typecodes['Float']

for op in [floor_divide_and_remainder, np.divmod]:

for dt1, dt2 in itertools.product(dt, dt):

for sg1, sg2 in itertools.product((+1, -1), (+1, -1)):

fmt = 'op: %s, dt1: %s, dt2: %s, sg1: %s, sg2: %s'

msg = fmt % (op.__name__, dt1, dt2, sg1, sg2)

a = np.array(sg1 * 78 * 6e-8, dtype=dt1)

b = np.array(sg2 * 6e-8, dtype=dt2)

div, rem = op(a, b)

# Equal assertion should hold when fmod is used

assert_equal(div * b + rem, a, err_msg=msg)

if sg2 == -1:

assert_(b < rem <= 0, msg)

else:

assert_(b > rem >= 0, msg)

@pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")

@pytest.mark.xfail(sys.platform.startswith("darwin"),

reason="MacOS seems to not give the correct 'invalid' warning for "

"`fmod`. Hopefully, others always do.")

@pytest.mark.parametrize('dtype', np.typecodes['Float'])

def test_float_divmod_errors(self, dtype):

# Check valid errors raised for divmod and remainder

fzero = np.array(0.0, dtype=dtype)

fone = np.array(1.0, dtype=dtype)

finf = np.array(np.inf, dtype=dtype)

fnan = np.array(np.nan, dtype=dtype)

# since divmod is combination of both remainder and divide

# ops it will set both dividebyzero and invalid flags

with np.errstate(divide='raise', invalid='ignore'):

assert_raises(FloatingPointError, np.divmod, fone, fzero)

with np.errstate(divide='ignore', invalid='raise'):

assert_raises(FloatingPointError, np.divmod, fone, fzero)

with np.errstate(invalid='raise'):

assert_raises(FloatingPointError, np.divmod, fzero, fzero)

with np.errstate(invalid='raise'):

assert_raises(FloatingPointError, np.divmod, finf, finf)

with np.errstate(divide='ignore', invalid='raise'):

assert_raises(FloatingPointError, np.divmod, finf, fzero)

with np.errstate(divide='raise', invalid='ignore'):

# inf / 0 does not set any flags, only the modulo creates a NaN

np.divmod(finf, fzero)

@pytest.mark.skipif(hasattr(np.__config__, "blas_ssl2_info"),

reason="gh-22982")

@pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")

@pytest.mark.xfail(sys.platform.startswith("darwin"),

reason="MacOS seems to not give the correct 'invalid' warning for "

"`fmod`. Hopefully, others always do.")

@pytest.mark.parametrize('dtype', np.typecodes['Float'])

@pytest.mark.parametrize('fn', [np.fmod, np.remainder])

def test_float_remainder_errors(self, dtype, fn):

fzero = np.array(0.0, dtype=dtype)

fone = np.array(1.0, dtype=dtype)

finf = np.array(np.inf, dtype=dtype)

fnan = np.array(np.nan, dtype=dtype)

# The following already contain a NaN and should not warn.

with np.errstate(all='raise'):

with pytest.raises(FloatingPointError,

match="invalid value"):

fn(fone, fzero)

fn(fnan, fzero)

fn(fzero, fnan)

fn(fone, fnan)

fn(fnan, fone)

@pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")

def test_float_remainder_overflow(self):

a = np.finfo(np.float64).tiny

with np.errstate(over='ignore', invalid='ignore'):

div, mod = np.divmod(4, a)

np.isinf(div)

assert_(mod == 0)

with np.errstate(over='raise', invalid='ignore'):

assert_raises(FloatingPointError, np.divmod, 4, a)

with np.errstate(invalid='raise', over='ignore'):

assert_raises(FloatingPointError, np.divmod, 4, a)

def test_float_divmod_corner_cases(self):

# check nan cases

for dt in np.typecodes['Float']:

fnan = np.array(np.nan, dtype=dt)

fone = np.array(1.0, dtype=dt)

fzer = np.array(0.0, dtype=dt)

finf = np.array(np.inf, dtype=dt)

with warnings.catch_warnings():

warnings.filterwarnings(

"ignore",

"invalid value encountered in divmod",

RuntimeWarning,

)

warnings.filterwarnings(

"ignore",

"divide by zero encountered in divmod",

RuntimeWarning,

)

div, rem = np.divmod(fone, fzer)

assert np.isinf(div), f'dt: {dt}, div: {rem}'

assert np.isnan(rem), f'dt: {dt}, rem: {rem}'

div, rem = np.divmod(fzer, fzer)

assert np.isnan(rem), f'dt: {dt}, rem: {rem}'

assert_(np.isnan(div)), f'dt: {dt}, rem: {rem}'

div, rem = np.divmod(finf, finf)

assert np.isnan(div), f'dt: {dt}, rem: {rem}'

assert np.isnan(rem), f'dt: {dt}, rem: {rem}'

div, rem = np.divmod(finf, fzer)

assert np.isinf(div), f'dt: {dt}, rem: {rem}'

assert np.isnan(rem), f'dt: {dt}, rem: {rem}'

div, rem = np.divmod(fnan, fone)

assert np.isnan(rem), f"dt: {dt}, rem: {rem}"

assert np.isnan(div), f"dt: {dt}, rem: {rem}"

div, rem = np.divmod(fone, fnan)

assert np.isnan(rem), f"dt: {dt}, rem: {rem}"

assert np.isnan(div), f"dt: {dt}, rem: {rem}"

div, rem = np.divmod(fnan, fzer)

assert np.isnan(rem), f"dt: {dt}, rem: {rem}"

assert np.isnan(div), f"dt: {dt}, rem: {rem}"

def test_float_remainder_corner_cases(self):

# Check remainder magnitude.

for dt in np.typecodes['Float']:

fone = np.array(1.0, dtype=dt)

fzer = np.array(0.0, dtype=dt)

fnan = np.array(np.nan, dtype=dt)

b = np.array(1.0, dtype=dt)

a = np.nextafter(np.array(0.0, dtype=dt), -b)

rem = np.remainder(a, b)

assert_(rem <= b, f'dt: {dt}')

rem = np.remainder(-a, -b)

assert_(rem >= -b, f'dt: {dt}')

# Check nans, inf

with warnings.catch_warnings():

warnings.filterwarnings(

"ignore",

"invalid value encountered in remainder",

RuntimeWarning,

)

warnings.filterwarnings(

"ignore",

"invalid value encountered in fmod",

RuntimeWarning,

)

for dt in np.typecodes['Float']:

fone = np.array(1.0, dtype=dt)

fzer = np.array(0.0, dtype=dt)

finf = np.array(np.inf, dtype=dt)

fnan = np.array(np.nan, dtype=dt)

rem = np.remainder(fone, fzer)

assert_(np.isnan(rem), f'dt: {dt}, rem: {rem}')

# MSVC 2008 returns NaN here, so disable the check.

#rem = np.remainder(fone, finf)

#assert_(rem == fone, 'dt: %s, rem: %s' % (dt, rem))

rem = np.remainder(finf, fone)

fmod = np.fmod(finf, fone)

assert_(np.isnan(fmod), f'dt: {dt}, fmod: {fmod}')

assert_(np.isnan(rem), f'dt: {dt}, rem: {rem}')

rem = np.remainder(finf, finf)

fmod = np.fmod(finf, fone)

assert_(np.isnan(rem), f'dt: {dt}, rem: {rem}')

assert_(np.isnan(fmod), f'dt: {dt}, fmod: {fmod}')

rem = np.remainder(finf, fzer)

fmod = np.fmod(finf, fzer)

assert_(np.isnan(rem), f'dt: {dt}, rem: {rem}')

assert_(np.isnan(fmod), f'dt: {dt}, fmod: {fmod}')

rem = np.remainder(fone, fnan)

fmod = np.fmod(fone, fnan)

assert_(np.isnan(rem), f'dt: {dt}, rem: {rem}')

assert_(np.isnan(fmod), f'dt: {dt}, fmod: {fmod}')

rem = np.remainder(fnan, fzer)

fmod = np.fmod(fnan, fzer)

assert_(np.isnan(rem), f'dt: {dt}, rem: {rem}')

assert_(np.isnan(fmod), f'dt: {dt}, fmod: {rem}')

rem = np.remainder(fnan, fone)

fmod = np.fmod(fnan, fone)

assert_(np.isnan(rem), f'dt: {dt}, rem: {rem}')

assert_(np.isnan(fmod), f'dt: {dt}, fmod: {rem}')

class TestDivisionIntegerOverflowsAndDivideByZero:

result_type = namedtuple('result_type',

['nocast', 'casted'])

helper_lambdas = {

'zero': lambda dtype: 0,

'min': lambda dtype: np.iinfo(dtype).min,

'neg_min': lambda dtype: -np.iinfo(dtype).min,

'min-zero': lambda dtype: (np.iinfo(dtype).min, 0),

'neg_min-zero': lambda dtype: (-np.iinfo(dtype).min, 0),

}

overflow_results = {

np.remainder: result_type(

helper_lambdas['zero'], helper_lambdas['zero']),

np.fmod: result_type(

helper_lambdas['zero'], helper_lambdas['zero']),

operator.mod: result_type(

helper_lambdas['zero'], helper_lambdas['zero']),

operator.floordiv: result_type(

helper_lambdas['min'], helper_lambdas['neg_min']),

np.floor_divide: result_type(

helper_lambdas['min'], helper_lambdas['neg_min']),

np.divmod: result_type(

helper_lambdas['min-zero'], helper_lambdas['neg_min-zero'])

}

@pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")

@pytest.mark.parametrize("dtype", np.typecodes["Integer"])

def test_signed_division_overflow(self, dtype):

to_check = interesting_binop_operands(np.iinfo(dtype).min, -1, dtype)

for op1, op2, extractor, operand_identifier in to_check:

with pytest.warns(RuntimeWarning, match="overflow encountered"):

res = op1 // op2

assert res.dtype == op1.dtype

assert extractor(res) == np.iinfo(op1.dtype).min

# Remainder is well defined though, and does not warn:

res = op1 % op2

assert res.dtype == op1.dtype