def test_copies(self):

A = np.array([[1, 2], [3, 4]])

Ar1 = np.array([[1, 2, 3, 4], [1, 2, 3, 4]])

assert_equal(np.resize(A, (2, 4)), Ar1)

Ar2 = np.array([[1, 2], [3, 4], [1, 2], [3, 4]])

assert_equal(np.resize(A, (4, 2)), Ar2)

Ar3 = np.array([[1, 2, 3], [4, 1, 2], [3, 4, 1], [2, 3, 4]])

assert_equal(np.resize(A, (4, 3)), Ar3)

def test_repeats(self):

A = np.array([1, 2, 3])

Ar1 = np.array([[1, 2, 3, 1], [2, 3, 1, 2]])

assert_equal(np.resize(A, (2, 4)), Ar1)

Ar2 = np.array([[1, 2], [3, 1], [2, 3], [1, 2]])

assert_equal(np.resize(A, (4, 2)), Ar2)

Ar3 = np.array([[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]])

assert_equal(np.resize(A, (4, 3)), Ar3)

def test_zeroresize(self):

A = np.array([[1, 2], [3, 4]])

Ar = np.resize(A, (0,))

assert_array_equal(Ar, np.array([]))

assert_equal(A.dtype, Ar.dtype)

Ar = np.resize(A, (0, 2))

assert_equal(Ar.shape, (0, 2))

Ar = np.resize(A, (2, 0))

assert_equal(Ar.shape, (2, 0))

def test_reshape_from_zero(self):

# See also gh-6740

A = np.zeros(0, dtype=[('a', np.float32)])

Ar = np.resize(A, (2, 1))

assert_array_equal(Ar, np.zeros((2, 1), Ar.dtype))

assert_equal(A.dtype, Ar.dtype)

def test_negative_resize(self):

A = np.arange(0, 10, dtype=np.float32)

new_shape = (-10, -1)

with pytest.raises(ValueError, match=r"negative"):

np.resize(A, new_shape=new_shape)

def test_subclass(self):

class MyArray(np.ndarray):

__array_priority__ = 1.

my_arr = np.array([1]).view(MyArray)

assert type(np.resize(my_arr, 5)) is MyArray

assert type(np.resize(my_arr, 0)) is MyArray

my_arr = np.array([]).view(MyArray)

# check that non-array arguments to functions wrap them in arrays

def test_choose(self):

choices = [[0, 1, 2],

[3, 4, 5],

[5, 6, 7]]

tgt = [5, 1, 5]

a = [2, 0, 1]

out = np.choose(a, choices)

assert_equal(out, tgt)

def test_clip(self):

arr = [-1, 5, 2, 3, 10, -4, -9]

out = np.clip(arr, 2, 7)

tgt = [2, 5, 2, 3, 7, 2, 2]

assert_equal(out, tgt)

def test_compress(self):

arr = [[0, 1, 2, 3, 4],

[5, 6, 7, 8, 9]]

tgt = [[5, 6, 7, 8, 9]]

out = np.compress([0, 1], arr, axis=0)

assert_equal(out, tgt)

def test_count_nonzero(self):

arr = [[0, 1, 7, 0, 0],

[3, 0, 0, 2, 19]]

tgt = np.array([2, 3])

out = np.count_nonzero(arr, axis=1)

assert_equal(out, tgt)

def test_cumproduct(self):

A = [[1, 2, 3], [4, 5, 6]]

assert_(np.all(np.cumproduct(A) == np.array([1, 2, 6, 24, 120, 720])))

def test_diagonal(self):

a = [[0, 1, 2, 3],

[4, 5, 6, 7],

[8, 9, 10, 11]]

out = np.diagonal(a)

tgt = [0, 5, 10]

assert_equal(out, tgt)

def test_mean(self):

A = [[1, 2, 3], [4, 5, 6]]

assert_(np.mean(A) == 3.5)

assert_(np.all(np.mean(A, 0) == np.array([2.5, 3.5, 4.5])))

assert_(np.all(np.mean(A, 1) == np.array([2., 5.])))

with warnings.catch_warnings(record=True) as w:

warnings.filterwarnings('always', '', RuntimeWarning)

assert_(np.isnan(np.mean([])))

assert_(w[0].category is RuntimeWarning)

def test_ptp(self):

a = [3, 4, 5, 10, -3, -5, 6.0]

assert_equal(np.ptp(a, axis=0), 15.0)

def test_prod(self):

arr = [[1, 2, 3, 4],

[5, 6, 7, 9],

[10, 3, 4, 5]]

tgt = [24, 1890, 600]

assert_equal(np.prod(arr, axis=-1), tgt)

def test_ravel(self):

a = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]

tgt = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

assert_equal(np.ravel(a), tgt)

def test_repeat(self):

a = [1, 2, 3]

tgt = [1, 1, 2, 2, 3, 3]

out = np.repeat(a, 2)

assert_equal(out, tgt)

def test_reshape(self):

arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]

tgt = [[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12]]

assert_equal(np.reshape(arr, (2, 6)), tgt)

def test_round(self):

arr = [1.56, 72.54, 6.35, 3.25]

tgt = [1.6, 72.5, 6.4, 3.2]

assert_equal(np.around(arr, decimals=1), tgt)

s = np.float64(1.)

assert_(isinstance(s.round(), np.float64))

assert_equal(s.round(), 1.)

@pytest.mark.parametrize('dtype', [

def test_dunder_round(self, dtype):

s = dtype(1)

assert_(isinstance(round(s), int))

assert_(isinstance(round(s, None), int))

assert_(isinstance(round(s, ndigits=None), int))

assert_equal(round(s), 1)

assert_equal(round(s, None), 1)

assert_equal(round(s, ndigits=None), 1)

@pytest.mark.parametrize('val, ndigits', [

def test_dunder_round_edgecases(self, val, ndigits):

assert_equal(round(val, ndigits), round(np.int32(val), ndigits))

def test_dunder_round_accuracy(self):

f = np.float64(5.1 * 10**73)

assert_(isinstance(round(f, -73), np.float64))

assert_array_max_ulp(round(f, -73), 5.0 * 10**73)

assert_(isinstance(round(f, ndigits=-73), np.float64))

assert_array_max_ulp(round(f, ndigits=-73), 5.0 * 10**73)

i = np.int64(501)

assert_(isinstance(round(i, -2), np.int64))

assert_array_max_ulp(round(i, -2), 500)

assert_(isinstance(round(i, ndigits=-2), np.int64))

assert_array_max_ulp(round(i, ndigits=-2), 500)

@pytest.mark.xfail(raises=AssertionError, reason="gh-15896")

def test_round_py_consistency(self):

f = 5.1 * 10**73

assert_equal(round(np.float64(f), -73), round(f, -73))

def test_searchsorted(self):

arr = [-8, -5, -1, 3, 6, 10]

out = np.searchsorted(arr, 0)

assert_equal(out, 3)

def test_size(self):

A = [[1, 2, 3], [4, 5, 6]]

assert_(np.size(A) == 6)

assert_(np.size(A, 0) == 2)

assert_(np.size(A, 1) == 3)

def test_squeeze(self):

A = [[[1, 1, 1], [2, 2, 2], [3, 3, 3]]]

assert_equal(np.squeeze(A).shape, (3, 3))

assert_equal(np.squeeze(np.zeros((1, 3, 1))).shape, (3,))

assert_equal(np.squeeze(np.zeros((1, 3, 1)), axis=0).shape, (3, 1))

assert_equal(np.squeeze(np.zeros((1, 3, 1)), axis=-1).shape, (1, 3))

assert_equal(np.squeeze(np.zeros((1, 3, 1)), axis=2).shape, (1, 3))

assert_equal(np.squeeze([np.zeros((3, 1))]).shape, (3,))

assert_equal(np.squeeze([np.zeros((3, 1))], axis=0).shape, (3, 1))

assert_equal(np.squeeze([np.zeros((3, 1))], axis=2).shape, (1, 3))

assert_equal(np.squeeze([np.zeros((3, 1))], axis=-1).shape, (1, 3))

def test_std(self):

A = [[1, 2, 3], [4, 5, 6]]

assert_almost_equal(np.std(A), 1.707825127659933)

assert_almost_equal(np.std(A, 0), np.array([1.5, 1.5, 1.5]))

assert_almost_equal(np.std(A, 1), np.array([0.81649658, 0.81649658]))

with warnings.catch_warnings(record=True) as w:

warnings.filterwarnings('always', '', RuntimeWarning)

assert_(np.isnan(np.std([])))

assert_(w[0].category is RuntimeWarning)

def test_swapaxes(self):

tgt = [[[0, 4], [2, 6]], [[1, 5], [3, 7]]]

a = [[[0, 1], [2, 3]], [[4, 5], [6, 7]]]

out = np.swapaxes(a, 0, 2)

assert_equal(out, tgt)

def test_sum(self):

m = [[1, 2, 3],

[4, 5, 6],

[7, 8, 9]]

tgt = [[6], [15], [24]]

out = np.sum(m, axis=1, keepdims=True)

assert_equal(tgt, out)

def test_take(self):

tgt = [2, 3, 5]

indices = [1, 2, 4]

a = [1, 2, 3, 4, 5]

out = np.take(a, indices)

assert_equal(out, tgt)

def test_trace(self):

c = [[1, 2], [3, 4], [5, 6]]

assert_equal(np.trace(c), 5)

def test_transpose(self):

arr = [[1, 2], [3, 4], [5, 6]]

tgt = [[1, 3, 5], [2, 4, 6]]

assert_equal(np.transpose(arr, (1, 0)), tgt)

def test_var(self):

A = [[1, 2, 3], [4, 5, 6]]

assert_almost_equal(np.var(A), 2.9166666666666665)

assert_almost_equal(np.var(A, 0), np.array([2.25, 2.25, 2.25]))

assert_almost_equal(np.var(A, 1), np.array([0.66666667, 0.66666667]))

with warnings.catch_warnings(record=True) as w:

warnings.filterwarnings('always', '', RuntimeWarning)

assert_(np.isnan(np.var([])))

assert_(w[0].category is RuntimeWarning)

B = np.array([None, 0])

B[0] = 1j

def test_isscalar(self):

assert_(np.isscalar(3.1))

assert_(np.isscalar(np.int16(12345)))

assert_(np.isscalar(False))

assert_(np.isscalar('numpy'))

assert_(not np.isscalar([3.1]))

assert_(not np.isscalar(None))

# PEP 3141

from fractions import Fraction

assert_(np.isscalar(Fraction(5, 17)))

from numbers import Number

def test_logical(self):

f = np.False_

t = np.True_

s = "xyz"

assert_((t and s) is s)

assert_((f and s) is f)

def test_bitwise_or(self):

f = np.False_

t = np.True_

assert_((t | t) is t)

assert_((f | t) is t)

assert_((t | f) is t)

assert_((f | f) is f)

def test_bitwise_and(self):

f = np.False_

t = np.True_

assert_((t & t) is t)

assert_((f & t) is f)

assert_((t & f) is f)

assert_((f & f) is f)

def test_bitwise_xor(self):

f = np.False_

t = np.True_

assert_((t ^ t) is f)

assert_((f ^ t) is t)

assert_((t ^ f) is t)

def setup(self):

# offset for simd tests

self.t = np.array([True] * 41, dtype=bool)[1::]

self.f = np.array([False] * 41, dtype=bool)[1::]

self.o = np.array([False] * 42, dtype=bool)[2::]

self.nm = self.f.copy()

self.im = self.t.copy()

self.nm[3] = True

self.nm[-2] = True

self.im[3] = False

self.im[-2] = False

def test_all_any(self):

assert_(self.t.all())

assert_(self.t.any())

assert_(not self.f.all())

assert_(not self.f.any())

assert_(self.nm.any())

assert_(self.im.any())

assert_(not self.nm.all())

assert_(not self.im.all())

# check bad element in all positions

for i in range(256 - 7):

d = np.array([False] * 256, dtype=bool)[7::]

d[i] = True

assert_(np.any(d))

e = np.array([True] * 256, dtype=bool)[7::]

e[i] = False

assert_(not np.all(e))

assert_array_equal(e, ~d)

# big array test for blocked libc loops

for i in list(range(9, 6000, 507)) + [7764, 90021, -10]:

d = np.array([False] * 100043, dtype=bool)

d[i] = True

assert_(np.any(d), msg="%r" % i)

e = np.array([True] * 100043, dtype=bool)

e[i] = False

assert_(not np.all(e), msg="%r" % i)

def test_logical_not_abs(self):

assert_array_equal(~self.t, self.f)

assert_array_equal(np.abs(~self.t), self.f)

assert_array_equal(np.abs(~self.f), self.t)

assert_array_equal(np.abs(self.f), self.f)

assert_array_equal(~np.abs(self.f), self.t)

assert_array_equal(~np.abs(self.t), self.f)

assert_array_equal(np.abs(~self.nm), self.im)

np.logical_not(self.t, out=self.o)

assert_array_equal(self.o, self.f)

np.abs(self.t, out=self.o)

assert_array_equal(self.o, self.t)

def test_logical_and_or_xor(self):

assert_array_equal(self.t | self.t, self.t)

assert_array_equal(self.f | self.f, self.f)

assert_array_equal(self.t | self.f, self.t)

assert_array_equal(self.f | self.t, self.t)

np.logical_or(self.t, self.t, out=self.o)

assert_array_equal(self.o, self.t)

assert_array_equal(self.t & self.t, self.t)

assert_array_equal(self.f & self.f, self.f)

assert_array_equal(self.t & self.f, self.f)

assert_array_equal(self.f & self.t, self.f)

np.logical_and(self.t, self.t, out=self.o)

assert_array_equal(self.o, self.t)

assert_array_equal(self.t ^ self.t, self.f)

assert_array_equal(self.f ^ self.f, self.f)

assert_array_equal(self.t ^ self.f, self.t)

assert_array_equal(self.f ^ self.t, self.t)

np.logical_xor(self.t, self.t, out=self.o)

assert_array_equal(self.o, self.f)

assert_array_equal(self.nm & self.t, self.nm)

assert_array_equal(self.im & self.f, False)

assert_array_equal(self.nm & True, self.nm)

assert_array_equal(self.im & False, self.f)

assert_array_equal(self.nm | self.t, self.t)

assert_array_equal(self.im | self.f, self.im)

assert_array_equal(self.nm | True, self.t)

assert_array_equal(self.im | False, self.im)

assert_array_equal(self.nm ^ self.t, self.im)

assert_array_equal(self.im ^ self.f, self.im)

assert_array_equal(self.nm ^ True, self.im)

def setup(self):

self.f = np.ones(256, dtype=np.float32)

self.ef = np.ones(self.f.size, dtype=bool)

self.d = np.ones(128, dtype=np.float64)

self.ed = np.ones(self.d.size, dtype=bool)

# generate values for all permutation of 256bit simd vectors

s = 0

for i in range(32):

self.f[s:s+8] = [i & 2**x for x in range(8)]

self.ef[s:s+8] = [(i & 2**x) != 0 for x in range(8)]

s += 8

s = 0

for i in range(16):

self.d[s:s+4] = [i & 2**x for x in range(4)]

self.ed[s:s+4] = [(i & 2**x) != 0 for x in range(4)]

s += 4

self.nf = self.f.copy()

self.nd = self.d.copy()

self.nf[self.ef] = np.nan

self.nd[self.ed] = np.nan

self.inff = self.f.copy()

self.infd = self.d.copy()

self.inff[::3][self.ef[::3]] = np.inf

self.infd[::3][self.ed[::3]] = np.inf

self.inff[1::3][self.ef[1::3]] = -np.inf

self.infd[1::3][self.ed[1::3]] = -np.inf

self.inff[2::3][self.ef[2::3]] = np.nan

self.infd[2::3][self.ed[2::3]] = np.nan

self.efnonan = self.ef.copy()

self.efnonan[2::3] = False

self.ednonan = self.ed.copy()

self.ednonan[2::3] = False

self.signf = self.f.copy()

self.signd = self.d.copy()

self.signf[self.ef] *= -1.

self.signd[self.ed] *= -1.

self.signf[1::6][self.ef[1::6]] = -np.inf

self.signd[1::6][self.ed[1::6]] = -np.inf

self.signf[3::6][self.ef[3::6]] = -np.nan

self.signd[3::6][self.ed[3::6]] = -np.nan

self.signf[4::6][self.ef[4::6]] = -0.

self.signd[4::6][self.ed[4::6]] = -0.

def test_float(self):

# offset for alignment test

for i in range(4):

assert_array_equal(self.f[i:] > 0, self.ef[i:])

assert_array_equal(self.f[i:] - 1 >= 0, self.ef[i:])

assert_array_equal(self.f[i:] == 0, ~self.ef[i:])

assert_array_equal(-self.f[i:] < 0, self.ef[i:])

assert_array_equal(-self.f[i:] + 1 <= 0, self.ef[i:])

r = self.f[i:] != 0

assert_array_equal(r, self.ef[i:])

r2 = self.f[i:] != np.zeros_like(self.f[i:])

r3 = 0 != self.f[i:]

assert_array_equal(r, r2)

assert_array_equal(r, r3)

# check bool == 0x1

assert_array_equal(r.view(np.int8), r.astype(np.int8))

assert_array_equal(r2.view(np.int8), r2.astype(np.int8))

assert_array_equal(r3.view(np.int8), r3.astype(np.int8))

# isnan on amd64 takes the same code path

assert_array_equal(np.isnan(self.nf[i:]), self.ef[i:])

assert_array_equal(np.isfinite(self.nf[i:]), ~self.ef[i:])

assert_array_equal(np.isfinite(self.inff[i:]), ~self.ef[i:])

assert_array_equal(np.isinf(self.inff[i:]), self.efnonan[i:])

assert_array_equal(np.signbit(self.signf[i:]), self.ef[i:])

def test_double(self):

# offset for alignment test

for i in range(2):

assert_array_equal(self.d[i:] > 0, self.ed[i:])

assert_array_equal(self.d[i:] - 1 >= 0, self.ed[i:])

assert_array_equal(self.d[i:] == 0, ~self.ed[i:])

assert_array_equal(-self.d[i:] < 0, self.ed[i:])

assert_array_equal(-self.d[i:] + 1 <= 0, self.ed[i:])

r = self.d[i:] != 0

assert_array_equal(r, self.ed[i:])

r2 = self.d[i:] != np.zeros_like(self.d[i:])

r3 = 0 != self.d[i:]

assert_array_equal(r, r2)

assert_array_equal(r, r3)

# check bool == 0x1

assert_array_equal(r.view(np.int8), r.astype(np.int8))

assert_array_equal(r2.view(np.int8), r2.astype(np.int8))

assert_array_equal(r3.view(np.int8), r3.astype(np.int8))

# isnan on amd64 takes the same code path

assert_array_equal(np.isnan(self.nd[i:]), self.ed[i:])

assert_array_equal(np.isfinite(self.nd[i:]), ~self.ed[i:])

assert_array_equal(np.isfinite(self.infd[i:]), ~self.ed[i:])

assert_array_equal(np.isinf(self.infd[i:]), self.ednonan[i:])

def test_default(self):

err = np.geterr()

assert_equal(err,

dict(divide='warn',

invalid='warn',

over='warn',

under='ignore')

)

def test_set(self):

with np.errstate():

err = np.seterr()

old = np.seterr(divide='print')

assert_(err == old)

new = np.seterr()

assert_(new['divide'] == 'print')

np.seterr(over='raise')

assert_(np.geterr()['over'] == 'raise')

assert_(new['divide'] == 'print')

np.seterr(**old)

assert_(np.geterr() == old)

@pytest.mark.skipif(platform.machine() == "armv5tel", reason="See gh-413.")

def test_divide_err(self):

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

with assert_raises(FloatingPointError):

np.array([1.]) / np.array([0.])

np.seterr(divide='ignore')

np.array([1.]) / np.array([0.])

def test_errobj(self):

olderrobj = np.geterrobj()

self.called = 0

try:

with warnings.catch_warnings(record=True) as w:

warnings.simplefilter("always")

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

np.seterrobj([20000, 1, None])

np.array([1.]) / np.array([0.])

assert_equal(len(w), 1)

def log_err(*args):

self.called += 1

extobj_err = args

assert_(len(extobj_err) == 2)

assert_("divide" in extobj_err[0])

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

np.seterrobj([20000, 3, log_err])

np.array([1.]) / np.array([0.])

assert_equal(self.called, 1)

np.seterrobj(olderrobj)

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

np.divide(1., 0., extobj=[20000, 3, log_err])

assert_equal(self.called, 2)

finally:

np.seterrobj(olderrobj)

del self.called

def test_errobj_noerrmask(self):

# errmask = 0 has a special code path for the default

olderrobj = np.geterrobj()

try:

# set errobj to something non default

np.seterrobj([umath.UFUNC_BUFSIZE_DEFAULT,

umath.ERR_DEFAULT + 1, None])

# call a ufunc

np.isnan(np.array([6]))

# same with the default, lots of times to get rid of possible

# pre-existing stack in the code

for i in range(10000):

np.seterrobj([umath.UFUNC_BUFSIZE_DEFAULT, umath.ERR_DEFAULT,

None])

np.isnan(np.array([6]))

finally:

def assert_raises_fpe(self, fpeerr, flop, x, y):

ftype = type(x)

try:

flop(x, y)

assert_(False,

"Type %s did not raise fpe error '%s'." % (ftype, fpeerr))

except FloatingPointError as exc:

assert_(str(exc).find(fpeerr) >= 0,

"Type %s raised wrong fpe error '%s'." % (ftype, exc))

def assert_op_raises_fpe(self, fpeerr, flop, sc1, sc2):

# Check that fpe exception is raised.

#

# Given a floating operation `flop` and two scalar values, check that

# the operation raises the floating point exception specified by

# `fpeerr`. Tests all variants with 0-d array scalars as well.

self.assert_raises_fpe(fpeerr, flop, sc1, sc2)

self.assert_raises_fpe(fpeerr, flop, sc1[()], sc2)

self.assert_raises_fpe(fpeerr, flop, sc1, sc2[()])

self.assert_raises_fpe(fpeerr, flop, sc1[()], sc2[()])

# Test for all real and complex float types

@pytest.mark.parametrize("typecode", np.typecodes["AllFloat"])

def test_floating_exceptions(self, typecode):

# Test basic arithmetic function errors

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

ftype = np.obj2sctype(typecode)

if np.dtype(ftype).kind == 'f':

# Get some extreme values for the type

fi = np.finfo(ftype)

ft_tiny = fi.machar.tiny

ft_max = fi.max

ft_eps = fi.eps

underflow = 'underflow'

divbyzero = 'divide by zero'

else:

# 'c', complex, corresponding real dtype

rtype = type(ftype(0).real)

fi = np.finfo(rtype)

ft_tiny = ftype(fi.machar.tiny)

ft_max = ftype(fi.max)

ft_eps = ftype(fi.eps)

# The complex types raise different exceptions

underflow = ''

divbyzero = ''

overflow = 'overflow'

invalid = 'invalid'

# The value of tiny for double double is NaN, so we need to

# pass the assert

if not np.isnan(ft_tiny):

self.assert_raises_fpe(underflow,

lambda a, b: a/b, ft_tiny, ft_max)

self.assert_raises_fpe(underflow,

lambda a, b: a*b, ft_tiny, ft_tiny)

self.assert_raises_fpe(overflow,

lambda a, b: a*b, ft_max, ftype(2))

self.assert_raises_fpe(overflow,

lambda a, b: a/b, ft_max, ftype(0.5))

self.assert_raises_fpe(overflow,

lambda a, b: a+b, ft_max, ft_max*ft_eps)

self.assert_raises_fpe(overflow,

lambda a, b: a-b, -ft_max, ft_max*ft_eps)

self.assert_raises_fpe(overflow,

np.power, ftype(2), ftype(2**fi.nexp))

self.assert_raises_fpe(divbyzero,

lambda a, b: a/b, ftype(1), ftype(0))

self.assert_raises_fpe(

invalid, lambda a, b: a/b, ftype(np.inf), ftype(np.inf)

)

self.assert_raises_fpe(invalid,

lambda a, b: a/b, ftype(0), ftype(0))

self.assert_raises_fpe(

invalid, lambda a, b: a-b, ftype(np.inf), ftype(np.inf)

)

self.assert_raises_fpe(

invalid, lambda a, b: a+b, ftype(np.inf), ftype(-np.inf)

)

self.assert_raises_fpe(invalid,

lambda a, b: a*b, ftype(0), ftype(np.inf))

def test_warnings(self):

# test warning code path

with warnings.catch_warnings(record=True) as w:

warnings.simplefilter("always")

with np.errstate(all="warn"):

np.divide(1, 0.)

assert_equal(len(w), 1)

assert_("divide by zero" in str(w[0].message))

np.array(1e300) * np.array(1e300)

assert_equal(len(w), 2)

assert_("overflow" in str(w[-1].message))

np.array(np.inf) - np.array(np.inf)

assert_equal(len(w), 3)

assert_("invalid value" in str(w[-1].message))

np.array(1e-300) * np.array(1e-300)

assert_equal(len(w), 4)

def check_promotion_cases(self, promote_func):

# tests that the scalars get coerced correctly.

b = np.bool_(0)

i8, i16, i32, i64 = np.int8(0), np.int16(0), np.int32(0), np.int64(0)

u8, u16, u32, u64 = np.uint8(0), np.uint16(0), np.uint32(0), np.uint64(0)

f32, f64, fld = np.float32(0), np.float64(0), np.longdouble(0)

c64, c128, cld = np.complex64(0), np.complex128(0), np.clongdouble(0)

# coercion within the same kind

assert_equal(promote_func(i8, i16), np.dtype(np.int16))

assert_equal(promote_func(i32, i8), np.dtype(np.int32))

assert_equal(promote_func(i16, i64), np.dtype(np.int64))

assert_equal(promote_func(u8, u32), np.dtype(np.uint32))

assert_equal(promote_func(f32, f64), np.dtype(np.float64))

assert_equal(promote_func(fld, f32), np.dtype(np.longdouble))

assert_equal(promote_func(f64, fld), np.dtype(np.longdouble))

assert_equal(promote_func(c128, c64), np.dtype(np.complex128))

assert_equal(promote_func(cld, c128), np.dtype(np.clongdouble))

assert_equal(promote_func(c64, fld), np.dtype(np.clongdouble))

# coercion between kinds

assert_equal(promote_func(b, i32), np.dtype(np.int32))

assert_equal(promote_func(b, u8), np.dtype(np.uint8))

assert_equal(promote_func(i8, u8), np.dtype(np.int16))

assert_equal(promote_func(u8, i32), np.dtype(np.int32))

assert_equal(promote_func(i64, u32), np.dtype(np.int64))

assert_equal(promote_func(u64, i32), np.dtype(np.float64))

assert_equal(promote_func(i32, f32), np.dtype(np.float64))

assert_equal(promote_func(i64, f32), np.dtype(np.float64))

assert_equal(promote_func(f32, i16), np.dtype(np.float32))

assert_equal(promote_func(f32, u32), np.dtype(np.float64))

assert_equal(promote_func(f32, c64), np.dtype(np.complex64))

assert_equal(promote_func(c128, f32), np.dtype(np.complex128))

assert_equal(promote_func(cld, f64), np.dtype(np.clongdouble))

# coercion between scalars and 1-D arrays

assert_equal(promote_func(np.array([b]), i8), np.dtype(np.int8))

assert_equal(promote_func(np.array([b]), u8), np.dtype(np.uint8))

assert_equal(promote_func(np.array([b]), i32), np.dtype(np.int32))

assert_equal(promote_func(np.array([b]), u32), np.dtype(np.uint32))

assert_equal(promote_func(np.array([i8]), i64), np.dtype(np.int8))

assert_equal(promote_func(u64, np.array([i32])), np.dtype(np.int32))

assert_equal(promote_func(i64, np.array([u32])), np.dtype(np.uint32))

assert_equal(promote_func(np.int32(-1), np.array([u64])),

np.dtype(np.float64))

assert_equal(promote_func(f64, np.array([f32])), np.dtype(np.float32))

assert_equal(promote_func(fld, np.array([f32])), np.dtype(np.float32))

assert_equal(promote_func(np.array([f64]), fld), np.dtype(np.float64))

assert_equal(promote_func(fld, np.array([c64])),

np.dtype(np.complex64))

assert_equal(promote_func(c64, np.array([f64])),

np.dtype(np.complex128))

assert_equal(promote_func(np.complex64(3j), np.array([f64])),

np.dtype(np.complex128))

# coercion between scalars and 1-D arrays, where

# the scalar has greater kind than the array

assert_equal(promote_func(np.array([b]), f64), np.dtype(np.float64))

assert_equal(promote_func(np.array([b]), i64), np.dtype(np.int64))

assert_equal(promote_func(np.array([b]), u64), np.dtype(np.uint64))

assert_equal(promote_func(np.array([i8]), f64), np.dtype(np.float64))