Browse files

STY: Cleanup white space and break long lines.

  • Loading branch information...
charris committed Nov 16, 2010
1 parent 72a702d commit 91d4145f30d6795ee4b8e41f476f847b496a3f5d
Showing with 60 additions and 36 deletions.
  1. +60 −36 numpy/core/tests/
@@ -250,63 +250,87 @@ def test_divide_err(self):
class TestFloatExceptions(TestCase):
def assert_raises_fpe(self, strmatch, operation, x, y):
def assert_raises_fpe(self, fpeerr, flop, x, y):
ftype = type(x)
operation(x, y)
assert_(False, "Did not raise a floating point %s error - with type %s" % (strmatch, type(x)))
flop(x, y)
"Type %s did not raise fpe error '%s'." % (ftype, fpeerr))
except FloatingPointError, exc:
assert_(str(exc).find(strmatch) >= 0,
"Raised a floating point error as expected, but not a %s error - with type %s" % (strmatch, type(x)))
def assert_op_raises_fpe(self, strmatch, operation, sc1, sc2):
"""Given an operation and two scalar-typed values, checks that
the operation raises the specified floating point exception.
Tests all variants with 0-d array scalars as well"""
self.assert_raises_fpe(strmatch, operation, sc1, sc2);
self.assert_raises_fpe(strmatch, operation, sc1[()], sc2);
self.assert_raises_fpe(strmatch, operation, sc1, sc2[()]);
self.assert_raises_fpe(strmatch, operation, sc1[()], sc2[()]);
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[()]);
def test_floating_exceptions(self):
"""Test basic arithmetic function errors"""
oldsettings = np.seterr(all='raise')
for typecode in np.typecodes['AllFloat']: # Test for all real and complex float types
# Test for all real and complex float types
for typecode in np.typecodes['AllFloat']:
ftype = np.obj2sctype(typecode)
# Get some extreme values for the type
if np.dtype(ftype).kind == 'f':
# Get some extreme values for the type
fi = np.finfo(ftype)
ft_tiny = fi.tiny
ft_max = fi.max
ft_eps = fi.eps
underflow_str = 'underflow'
divbyzero_str = 'divide by zero'
else: # 'c', complex
rtype = type(ftype(0).real) # corresponding real dtype
underflow = 'underflow'
divbyzero = 'divide by zero'
# 'c', complex, corresponding real dtype
rtype = type(ftype(0).real)
fi = np.finfo(rtype)
ft_tiny = ftype(fi.tiny)
ft_max = ftype(fi.max)
ft_eps = ftype(fi.eps)
# The complex types end up raising different exceptions
underflow_str = ''
divbyzero_str = ''
self.assert_op_raises_fpe(underflow_str, lambda a,b:a/b, ft_tiny, ft_max)
self.assert_op_raises_fpe(underflow_str, lambda a,b:a*b, ft_tiny, ft_tiny)
self.assert_op_raises_fpe('overflow', lambda a,b:a*b, ft_max, ftype(2))
self.assert_op_raises_fpe('overflow', lambda a,b:a/b, ft_max, ftype(0.5))
self.assert_op_raises_fpe('overflow', lambda a,b:a+b, ft_max, ft_max*ft_eps)
self.assert_op_raises_fpe('overflow', lambda a,b:a-b, -ft_max, ft_max*ft_eps)
self.assert_op_raises_fpe(divbyzero_str, lambda a,b:a/b, ftype(1), ftype(0))
self.assert_op_raises_fpe('invalid', lambda a,b:a/b, ftype(0), ftype(0))
self.assert_op_raises_fpe('invalid', lambda a,b:a-b, ftype(np.inf), ftype(np.inf))
self.assert_op_raises_fpe('invalid', lambda a,b:a+b, ftype(np.inf), ftype(-np.inf))
self.assert_op_raises_fpe('invalid', lambda a,b:a*b, ftype(0), ftype(np.inf))
self.assert_op_raises_fpe('overflow', np.power, ftype(2), ftype(2**fi.nexp))
# The complex types raise different exceptions
underflow = ''
divbyzero = ''
overflow = 'overflow'
invalid = 'invalid'
lambda a,b:a/b, ft_tiny, ft_max)
lambda a,b:a*b, ft_tiny, ft_tiny)
lambda a,b:a*b, ft_max, ftype(2))
lambda a,b:a/b, ft_max, ftype(0.5))
lambda a,b:a+b, ft_max, ft_max*ft_eps)
lambda a,b:a-b, -ft_max, ft_max*ft_eps)
lambda a,b:a/b, ftype(1), ftype(0))
lambda a,b:a/b, ftype(0), ftype(0))
lambda a,b:a-b, ftype(np.inf), ftype(np.inf))
lambda a,b:a+b, ftype(np.inf), ftype(-np.inf))
lambda a,b:a*b, ftype(0), ftype(np.inf))
np.power, ftype(2), ftype(2**fi.nexp))
class TestFromiter(TestCase):
def makegen(self):
for x in xrange(24):

0 comments on commit 91d4145

Please sign in to comment.