TST: Add special FP tests for FP16 umath

1 files changed, 54 insertions, 32 deletions

diff --git a/numpy/core/tests/test_umath.py b/numpy/core/tests/test_umath.py
index a696fceb8..70c5fc0e5 100644
--- a/numpy/core/tests/test_umath.py
+++ b/numpy/core/tests/test_umath.py
@@ -1052,7 +1052,7 @@ class TestSpecialFloats:
         with np.errstate(under='raise', over='raise'):
             x = [np.nan,  np.nan, np.inf, 0.]
             y = [np.nan, -np.nan, np.inf, -np.inf]
-            for dt in ['f', 'd', 'g']:
+            for dt in ['e', 'f', 'd', 'g']:
                 xf = np.array(x, dtype=dt)
                 yf = np.array(y, dtype=dt)
                 assert_equal(np.exp(yf), xf)
@@ -1064,12 +1064,14 @@ class TestSpecialFloats:
     )
     def test_exp_exceptions(self):
         with np.errstate(over='raise'):
+            assert_raises(FloatingPointError, np.exp, np.float16(11.0899))
             assert_raises(FloatingPointError, np.exp, np.float32(100.))
             assert_raises(FloatingPointError, np.exp, np.float32(1E19))
             assert_raises(FloatingPointError, np.exp, np.float64(800.))
             assert_raises(FloatingPointError, np.exp, np.float64(1E19))
 
         with np.errstate(under='raise'):
+            assert_raises(FloatingPointError, np.exp, np.float16(-17.5))
             assert_raises(FloatingPointError, np.exp, np.float32(-1000.))
             assert_raises(FloatingPointError, np.exp, np.float32(-1E19))
             assert_raises(FloatingPointError, np.exp, np.float64(-1000.))
@@ -1080,7 +1082,7 @@ class TestSpecialFloats:
             x = [np.nan, np.nan, np.inf, np.nan, -np.inf, np.nan]
             y = [np.nan, -np.nan, np.inf, -np.inf, 0.0, -1.0]
             y1p = [np.nan, -np.nan, np.inf, -np.inf, -1.0, -2.0]
-            for dt in ['f', 'd', 'g']:
+            for dt in ['e', 'f', 'd', 'g']:
                 xf = np.array(x, dtype=dt)
                 yf = np.array(y, dtype=dt)
                 yf1p = np.array(y1p, dtype=dt)
@@ -1090,7 +1092,7 @@ class TestSpecialFloats:
                 assert_equal(np.log1p(yf1p), xf)
 
         with np.errstate(divide='raise'):
-            for dt in ['f', 'd']:
+            for dt in ['e', 'f', 'd']:
                 assert_raises(FloatingPointError, np.log,
                               np.array(0.0, dtype=dt))
                 assert_raises(FloatingPointError, np.log2,
@@ -1101,7 +1103,7 @@ class TestSpecialFloats:
                               np.array(-1.0, dtype=dt))
 
         with np.errstate(invalid='raise'):
-            for dt in ['f', 'd']:
+            for dt in ['e', 'f', 'd']:
                 assert_raises(FloatingPointError, np.log,
                               np.array(-np.inf, dtype=dt))
                 assert_raises(FloatingPointError, np.log,
@@ -1128,19 +1130,21 @@ class TestSpecialFloats:
         with np.errstate(all='ignore'):
             x = [np.nan, np.nan, np.nan, np.nan]
             y = [np.nan, -np.nan, np.inf, -np.inf]
-            for dt in ['f', 'd', 'g']:
+            for dt in ['e', 'f', 'd', 'g']:
                 xf = np.array(x, dtype=dt)
                 yf = np.array(y, dtype=dt)
                 assert_equal(np.sin(yf), xf)
                 assert_equal(np.cos(yf), xf)
+        
 
         with np.errstate(invalid='raise'):
-            assert_raises(FloatingPointError, np.sin, np.float32(-np.inf))
-            assert_raises(FloatingPointError, np.sin, np.float32(np.inf))
-            assert_raises(FloatingPointError, np.cos, np.float32(-np.inf))
-            assert_raises(FloatingPointError, np.cos, np.float32(np.inf))
+            for callable in [np.sin, np.cos]:
+                for value in [np.inf, -np.inf]:
+                    for dt in ['e', 'f', 'd']:
+                        assert_raises(FloatingPointError, callable,
+                                np.array([value], dtype=dt))
 
-    @pytest.mark.parametrize('dt', ['f', 'd', 'g'])
+    @pytest.mark.parametrize('dt', ['e', 'f', 'd', 'g'])
     def test_sqrt_values(self, dt):
         with np.errstate(all='ignore'):
             x = [np.nan, np.nan, np.inf, np.nan, 0.]
@@ -1157,7 +1161,7 @@ class TestSpecialFloats:
     def test_abs_values(self):
         x = [np.nan,  np.nan, np.inf, np.inf, 0., 0., 1.0, 1.0]
         y = [np.nan, -np.nan, np.inf, -np.inf, 0., -0., -1.0, 1.0]
-        for dt in ['f', 'd', 'g']:
+        for dt in ['e', 'f', 'd', 'g']:
             xf = np.array(x, dtype=dt)
             yf = np.array(y, dtype=dt)
             assert_equal(np.abs(yf), xf)
@@ -1166,13 +1170,15 @@ class TestSpecialFloats:
         x = [np.nan,  np.nan, np.inf, np.inf]
         y = [np.nan, -np.nan, np.inf, -np.inf]
         with np.errstate(all='ignore'):
-            for dt in ['f', 'd', 'g']:
+            for dt in ['e', 'f', 'd', 'g']:
                 xf = np.array(x, dtype=dt)
                 yf = np.array(y, dtype=dt)
                 assert_equal(np.square(yf), xf)
 
         with np.errstate(over='raise'):
             assert_raises(FloatingPointError, np.square,
+                          np.array(1E3, dtype='e'))
+            assert_raises(FloatingPointError, np.square,
                           np.array(1E32, dtype='f'))
             assert_raises(FloatingPointError, np.square,
                           np.array(1E200, dtype='d'))
@@ -1181,13 +1187,13 @@ class TestSpecialFloats:
         with np.errstate(all='ignore'):
             x = [np.nan,  np.nan, 0.0, -0.0, np.inf, -np.inf]
             y = [np.nan, -np.nan, np.inf, -np.inf, 0., -0.]
-            for dt in ['f', 'd', 'g']:
+            for dt in ['e', 'f', 'd', 'g']:
                 xf = np.array(x, dtype=dt)
                 yf = np.array(y, dtype=dt)
                 assert_equal(np.reciprocal(yf), xf)
 
         with np.errstate(divide='raise'):
-            for dt in ['f', 'd', 'g']:
+            for dt in ['e', 'f', 'd', 'g']:
                 assert_raises(FloatingPointError, np.reciprocal,
                               np.array(-0.0, dtype=dt))
 
@@ -1195,13 +1201,13 @@ class TestSpecialFloats:
         with np.errstate(all='ignore'):
             in_ = [np.nan, -np.nan, 0.0, -0.0, np.inf, -np.inf]
             out = [np.nan, np.nan, 0.0, -0.0, np.nan, np.nan]
-            for dt in ['f', 'd']:
+            for dt in ['e', 'f', 'd']:
                 in_arr = np.array(in_, dtype=dt)
                 out_arr = np.array(out, dtype=dt)
                 assert_equal(np.tan(in_arr), out_arr)
 
         with np.errstate(invalid='raise'):
-            for dt in ['f', 'd']:
+            for dt in ['e', 'f', 'd']:
                 assert_raises(FloatingPointError, np.tan,
                               np.array(np.inf, dtype=dt))
                 assert_raises(FloatingPointError, np.tan,
@@ -1211,7 +1217,7 @@ class TestSpecialFloats:
         with np.errstate(all='ignore'):
             in_ = [np.nan, -np.nan, np.inf, -np.inf]
             out = [np.nan, np.nan, np.nan, np.nan]
-            for dt in ['f', 'd']:
+            for dt in ['e', 'f', 'd']:
                 in_arr = np.array(in_, dtype=dt)
                 out_arr = np.array(out, dtype=dt)
                 assert_equal(np.arcsin(in_arr), out_arr)
@@ -1219,7 +1225,7 @@ class TestSpecialFloats:
 
         for callable in [np.arcsin, np.arccos]:
             for value in [np.inf, -np.inf, 2.0, -2.0]:
-                for dt in ['f', 'd']:
+                for dt in ['e', 'f', 'd']:
                     with np.errstate(invalid='raise'):
                         assert_raises(FloatingPointError, callable,
                                       np.array(value, dtype=dt))
@@ -1228,7 +1234,7 @@ class TestSpecialFloats:
         with np.errstate(all='ignore'):
             in_ = [np.nan, -np.nan]
             out = [np.nan, np.nan]
-            for dt in ['f', 'd']:
+            for dt in ['e', 'f', 'd']:
                 in_arr = np.array(in_, dtype=dt)
                 out_arr = np.array(out, dtype=dt)
                 assert_equal(np.arctan(in_arr), out_arr)
@@ -1236,13 +1242,15 @@ class TestSpecialFloats:
     def test_sinh(self):
         in_ = [np.nan, -np.nan, np.inf, -np.inf]
         out = [np.nan, np.nan, np.inf, -np.inf]
-        for dt in ['f', 'd']:
+        for dt in ['e', 'f', 'd']:
             in_arr = np.array(in_, dtype=dt)
             out_arr = np.array(out, dtype=dt)
             assert_equal(np.sinh(in_arr), out_arr)
 
         with np.errstate(over='raise'):
             assert_raises(FloatingPointError, np.sinh,
+                          np.array(12.0, dtype='e'))
+            assert_raises(FloatingPointError, np.sinh,
                           np.array(120.0, dtype='f'))
             assert_raises(FloatingPointError, np.sinh,
                           np.array(1200.0, dtype='d'))
@@ -1250,13 +1258,15 @@ class TestSpecialFloats:
     def test_cosh(self):
         in_ = [np.nan, -np.nan, np.inf, -np.inf]
         out = [np.nan, np.nan, np.inf, np.inf]
-        for dt in ['f', 'd']:
+        for dt in ['e', 'f', 'd']:
             in_arr = np.array(in_, dtype=dt)
             out_arr = np.array(out, dtype=dt)
             assert_equal(np.cosh(in_arr), out_arr)
 
         with np.errstate(over='raise'):
             assert_raises(FloatingPointError, np.cosh,
+                          np.array(12.0, dtype='e'))
+            assert_raises(FloatingPointError, np.cosh,
                           np.array(120.0, dtype='f'))
             assert_raises(FloatingPointError, np.cosh,
                           np.array(1200.0, dtype='d'))
@@ -1264,7 +1274,7 @@ class TestSpecialFloats:
     def test_tanh(self):
         in_ = [np.nan, -np.nan, np.inf, -np.inf]
         out = [np.nan, np.nan, 1.0, -1.0]
-        for dt in ['f', 'd']:
+        for dt in ['e', 'f', 'd']:
             in_arr = np.array(in_, dtype=dt)
             out_arr = np.array(out, dtype=dt)
             assert_equal(np.tanh(in_arr), out_arr)
@@ -1272,7 +1282,7 @@ class TestSpecialFloats:
     def test_arcsinh(self):
         in_ = [np.nan, -np.nan, np.inf, -np.inf]
         out = [np.nan, np.nan, np.inf, -np.inf]
-        for dt in ['f', 'd']:
+        for dt in ['e', 'f', 'd']:
             in_arr = np.array(in_, dtype=dt)
             out_arr = np.array(out, dtype=dt)
             assert_equal(np.arcsinh(in_arr), out_arr)
@@ -1281,14 +1291,14 @@ class TestSpecialFloats:
         with np.errstate(all='ignore'):
             in_ = [np.nan, -np.nan, np.inf, -np.inf, 1.0, 0.0]
             out = [np.nan, np.nan, np.inf, np.nan, 0.0, np.nan]
-            for dt in ['f', 'd']:
+            for dt in ['e', 'f', 'd']:
                 in_arr = np.array(in_, dtype=dt)
                 out_arr = np.array(out, dtype=dt)
                 assert_equal(np.arccosh(in_arr), out_arr)
 
         for value in [0.0, -np.inf]:
             with np.errstate(invalid='raise'):
-                for dt in ['f', 'd']:
+                for dt in ['e', 'f', 'd']:
                     assert_raises(FloatingPointError, np.arccosh,
                                   np.array(value, dtype=dt))
 
@@ -1296,14 +1306,14 @@ class TestSpecialFloats:
         with np.errstate(all='ignore'):
             in_ = [np.nan, -np.nan, np.inf, -np.inf, 1.0, -1.0, 2.0]
             out = [np.nan, np.nan, np.nan, np.nan, np.inf, -np.inf, np.nan]
-            for dt in ['f', 'd']:
+            for dt in ['e', 'f', 'd']:
                 in_arr = np.array(in_, dtype=dt)
                 out_arr = np.array(out, dtype=dt)
                 assert_equal(np.arctanh(in_arr), out_arr)
 
         for value in [1.01, np.inf, -np.inf, 1.0, -1.0]:
             with np.errstate(invalid='raise', divide='raise'):
-                for dt in ['f', 'd']:
+                for dt in ['e', 'f', 'd']:
                     assert_raises(FloatingPointError, np.arctanh,
                                   np.array(value, dtype=dt))
 
@@ -1316,14 +1326,14 @@ class TestSpecialFloats:
         with np.errstate(all='ignore'):
             in_ = [np.nan, -np.nan, np.inf, -np.inf]
             out = [np.nan, np.nan, np.inf, 0.0]
-            for dt in ['f', 'd']:
+            for dt in ['e', 'f', 'd']:
                 in_arr = np.array(in_, dtype=dt)
                 out_arr = np.array(out, dtype=dt)
                 assert_equal(np.exp2(in_arr), out_arr)
 
         for value in [2000.0, -2000.0]:
             with np.errstate(over='raise', under='raise'):
-                for dt in ['f', 'd']:
+                for dt in ['e', 'f', 'd']:
                     assert_raises(FloatingPointError, np.exp2,
                                   np.array(value, dtype=dt))
 
@@ -1331,15 +1341,27 @@ class TestSpecialFloats:
         with np.errstate(all='ignore'):
             in_ = [np.nan, -np.nan, np.inf, -np.inf]
             out = [np.nan, np.nan, np.inf, -1.0]
-            for dt in ['f', 'd']:
+            for dt in ['e', 'f', 'd']:
                 in_arr = np.array(in_, dtype=dt)
                 out_arr = np.array(out, dtype=dt)
                 assert_equal(np.expm1(in_arr), out_arr)
 
         for value in [200.0, 2000.0]:
             with np.errstate(over='raise'):
-                assert_raises(FloatingPointError, np.expm1,
-                              np.array(value, dtype='f'))
+                for dt in ['e', 'f']:
+                    assert_raises(FloatingPointError, np.expm1,
+                                  np.array(value, dtype=dt))
+
+    # test to ensure no spurious FP exceptions are raised due to SIMD
+    def test_spurious_fpexception(self):
+        for dt in ['e', 'f', 'd']:
+            arr = np.array([1.0, 2.0], dtype=dt)
+            with assert_no_warnings():
+                np.log(arr)
+                np.log2(arr)
+                np.log10(arr)
+                np.arccosh(arr)
+
 
 class TestFPClass:
     @pytest.mark.parametrize("stride", [-4,-2,-1,1,2,4])