Add primitive for math.tan and math primiive run tests

python · JukkaL · Mar 14, 2023 · Dec 28, 2021 · Dec 31, 2022 · Aug 27, 2022
commit 2d3b7a3be87fd39e08d68b15205a352a86fcdbef
diff --git a/mypyc/lib-rt/CPy.h b/mypyc/lib-rt/CPy.h
@@ -289,6 +289,7 @@ static inline bool CPyTagged_IsLe(CPyTagged left, CPyTagged right) {
 
 double CPyFloat_Sin(double x);
 double CPyFloat_Cos(double x);
+double CPyFloat_Tan(double x);
 double CPyFloat_Sqrt(double x);
 double CPyFloat_Exp(double x);
 double CPyFloat_Log(double x);

diff --git a/mypyc/lib-rt/float_ops.c b/mypyc/lib-rt/float_ops.c
@@ -43,6 +43,13 @@ double CPyFloat_Cos(double x) {
     return v;
 }
 
+double CPyFloat_Tan(double x) {
+    if (unlikely(isinf(x))) {
+        return CPy_DomainError();
+    }
+    return tan(x);
+}
+
 double CPyFloat_Sqrt(double x) {
     if (x < 0.0) {
         return CPy_DomainError();

diff --git a/mypyc/primitives/float_ops.py b/mypyc/primitives/float_ops.py
@@ -54,6 +54,15 @@
     error_kind=ERR_MAGIC_OVERLAPPING,
 )
 
+# math.tan(float)
+function_op(
+    name="math.tan",
+    arg_types=[float_rprimitive],
+    return_type=float_rprimitive,
+    c_function_name="CPyFloat_Tan",
+    error_kind=ERR_MAGIC_OVERLAPPING,
+)
+
 # math.sqrt(float)
 function_op(
     name="math.sqrt",

diff --git a/mypyc/test-data/fixtures/testutil.py b/mypyc/test-data/fixtures/testutil.py
@@ -16,7 +16,8 @@
     float(n) * 0.25 for n in range(-10, 10)
 ] + [
     -0.0, 1.0/3.0, math.sqrt(2.0), 1.23e200, -2.34e200, 5.43e-100, -6.532e-200,
-    float('inf'), -float('inf'), float('nan'), FLOAT_MAGIC
+    float('inf'), -float('inf'), float('nan'), FLOAT_MAGIC, math.pi, 2.0 * math.pi, math.pi / 2.0,
+    -math.pi / 2.0
 ]
 
 @contextmanager

diff --git a/mypyc/test-data/run-math.test b/mypyc/test-data/run-math.test
@@ -0,0 +1,102 @@
+# Test cases for the math module (compile and run)
+
+[case testMathOps]
+from typing import Any
+from typing_extensions import Final
+import math
+from testutil import assertRaises, float_vals, assertDomainError, assertMathRangeError
+
+pymath: Any = math
+
+def test_sqrt() -> None:
+    for x in float_vals:
+        if x >= 0 or math.isnan(x):
+            assert repr(math.sqrt(x)) == repr(pymath.sqrt(x))
+        elif x < 0:
+            with assertDomainError():
+                math.sqrt(x)
+            with assertDomainError():
+                pymath.sqrt(x)
+
+def test_sin() -> None:
+    for x in float_vals:
+        if not math.isinf(x):
+            assert repr(math.sin(x)) == repr(pymath.sin(x))
+        else:
+            with assertDomainError():
+                math.sin(x)
+            with assertDomainError():
+                pymath.sin(x)
+
+def test_cos() -> None:
+    for x in float_vals:
+        if not math.isinf(x):
+            assert repr(math.cos(x)) == repr(pymath.cos(x))
+        else:
+            with assertDomainError():
+                math.cos(x)
+            with assertDomainError():
+                pymath.cos(x)
+
+def test_tan() -> None:
+    for x in float_vals:
+        if math.isinf(x):
+            with assertDomainError():
+                math.tan(x)
+        else:
+            assert repr(math.tan(x)) == repr(pymath.tan(x))
+
+def test_exp() -> None:
+    for x in float_vals:
+        if math.isfinite(x) and x > 1e100:
+            with assertMathRangeError():
+                math.exp(x)
+        else:
+            assert repr(math.exp(x)) == repr(pymath.exp(x))
+
+def test_log() -> None:
+    for x in float_vals:
+        if x <= 0.0:
+            with assertDomainError():
+                math.log(x)
+        else:
+            assert repr(math.log(x)) == repr(pymath.log(x))
+
+def test_floor() -> None:
+    for x in float_vals:
+        if math.isinf(x):
+            with assertRaises(OverflowError, "cannot convert float infinity to integer"):
+                math.floor(x)
+        elif math.isnan(x):
+            with assertRaises(ValueError, "cannot convert float NaN to integer"):
+                math.floor(x)
+        else:
+            assert repr(math.floor(x)) == repr(pymath.floor(x))
+
+def test_ceil() -> None:
+    for x in float_vals:
+        if math.isinf(x):
+            with assertRaises(OverflowError, "cannot convert float infinity to integer"):
+                math.ceil(x)
+        elif math.isnan(x):
+            with assertRaises(ValueError, "cannot convert float NaN to integer"):
+                math.ceil(x)
+        else:
+            assert repr(math.ceil(x)) == repr(pymath.ceil(x))
+
+def test_fabs() -> None:
+    for x in float_vals:
+        assert repr(math.fabs(x)) == repr(pymath.fabs(x))
+
+def test_copysign() -> None:
+    for x in float_vals:
+        for y in float_vals:
+            assert repr(math.copysign(x, y)) == repr(pymath.copysign(x, y))
+
+def test_isinf() -> None:
+    for x in float_vals:
+        assert repr(math.isinf(x)) == repr(pymath.isinf(x))
+
+def test_isnan() -> None:
+    for x in float_vals:
+        assert repr(math.isnan(x)) == repr(pymath.isnan(x))
diff --git a/test-data/unit/lib-stub/math.pyi b/test-data/unit/lib-stub/math.pyi
@@ -1,6 +1,8 @@
+pi: float
 def sqrt(__x: float) -> float: ...
 def sin(__x: float) -> float: ...
 def cos(__x: float) -> float: ...
+def tan(__x: float) -> float: ...
 def exp(__x: float) -> float: ...
 def log(__x: float) -> float: ...
 def floor(__x: float) -> int: ...