Videre

linedance-app/venv/lib/python3.12/site-packages/numba/tests/test_recursion.py

@@ -0,0 +1,129 @@
+import math
+import warnings
+
+from numba import jit
+from numba.core.errors import TypingError, NumbaWarning
+from numba.tests.support import TestCase
+import unittest
+
+
+class TestSelfRecursion(TestCase):
+
+    def check_fib(self, cfunc):
+        self.assertPreciseEqual(cfunc(10), 55)
+
+    def test_global_explicit_sig(self):
+        from numba.tests.recursion_usecases import fib1
+        self.check_fib(fib1)
+
+    def test_inner_explicit_sig(self):
+        from numba.tests.recursion_usecases import fib2
+        self.check_fib(fib2)
+
+    def test_global_implicit_sig(self):
+        from numba.tests.recursion_usecases import fib3
+        self.check_fib(fib3)
+
+    def test_runaway(self):
+        from numba.tests.recursion_usecases import runaway_self
+        with self.assertRaises(TypingError) as raises:
+            runaway_self(123)
+        self.assertIn("cannot type infer runaway recursion",
+                      str(raises.exception))
+
+    def test_type_change(self):
+        from numba.tests.recursion_usecases import make_type_change_self
+        pfunc = make_type_change_self()
+        cfunc = make_type_change_self(jit(nopython=True))
+        args = 13, 0.125
+        self.assertPreciseEqual(pfunc(*args), cfunc(*args))
+
+    def test_raise(self):
+        from numba.tests.recursion_usecases import raise_self
+        with self.assertRaises(ValueError) as raises:
+            raise_self(3)
+
+        self.assertEqual(str(raises.exception), "raise_self")
+
+    def test_optional_return(self):
+        from numba.tests.recursion_usecases import make_optional_return_case
+        pfunc = make_optional_return_case()
+        cfunc = make_optional_return_case(jit(nopython=True))
+        for arg in (0, 5, 10, 15):
+            self.assertEqual(pfunc(arg), cfunc(arg))
+
+    def test_growing_return_tuple(self):
+        from numba.tests.recursion_usecases import make_growing_tuple_case
+        cfunc = make_growing_tuple_case(jit(nopython=True))
+        with self.assertRaises(TypingError) as raises:
+            cfunc(100)
+        self.assertIn(
+            "Return type of recursive function does not converge",
+            str(raises.exception),
+        )
+
+
+class TestMutualRecursion(TestCase):
+
+    def test_mutual_1(self):
+        from numba.tests.recursion_usecases import outer_fac
+        expect = math.factorial(10)
+        self.assertPreciseEqual(outer_fac(10), expect)
+
+    def test_mutual_2(self):
+        from numba.tests.recursion_usecases import make_mutual2
+        pfoo, pbar = make_mutual2()
+        cfoo, cbar = make_mutual2(jit(nopython=True))
+        for x in [-1, 0, 1, 3]:
+            self.assertPreciseEqual(pfoo(x=x), cfoo(x=x))
+            self.assertPreciseEqual(pbar(y=x, z=1), cbar(y=x, z=1))
+
+    def test_runaway(self):
+        from numba.tests.recursion_usecases import runaway_mutual
+        with self.assertRaises(TypingError) as raises:
+            runaway_mutual(123)
+        self.assertIn("cannot type infer runaway recursion",
+                      str(raises.exception))
+
+    def test_type_change(self):
+        from numba.tests.recursion_usecases import make_type_change_mutual
+        pfunc = make_type_change_mutual()
+        cfunc = make_type_change_mutual(jit(nopython=True))
+        args = 13, 0.125
+        self.assertPreciseEqual(pfunc(*args), cfunc(*args))
+
+    def test_four_level(self):
+        from numba.tests.recursion_usecases import make_four_level
+        pfunc = make_four_level()
+        cfunc = make_four_level(jit(nopython=True))
+        arg = 7
+        self.assertPreciseEqual(pfunc(arg), cfunc(arg))
+
+    def test_inner_error(self):
+        from numba.tests.recursion_usecases import make_inner_error
+        # nopython mode
+        cfunc = make_inner_error(jit(nopython=True))
+        with self.assertRaises(TypingError) as raises:
+            cfunc(2)
+        errmsg = 'Unknown attribute \'ndim\''
+        self.assertIn(errmsg, str(raises.exception))
+        # objectmode
+        # error is never trigger, function return normally
+        cfunc = make_inner_error(jit(forceobj=True))
+        pfunc = make_inner_error()
+        with warnings.catch_warnings():
+            warnings.filterwarnings('ignore', category=NumbaWarning)
+            got = cfunc(6)
+        self.assertEqual(got, pfunc(6))
+
+    def test_raise(self):
+        from numba.tests.recursion_usecases import make_raise_mutual
+        cfunc = make_raise_mutual()#jit(nopython=True))
+        with self.assertRaises(ValueError) as raises:
+            cfunc(2)
+
+        self.assertEqual(str(raises.exception), "raise_mutual")
+
+
+if __name__ == '__main__':
+    unittest.main()