Call sig_block() in integral callback

Author: user202729

src/sage/calculus/integration.pyx

@@ -27,7 +27,7 @@ AUTHORS:
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
 
-from cysignals.signals cimport sig_on, sig_off
+from cysignals.signals cimport sig_on, sig_off, sig_block, sig_unblock
 from memory_allocator cimport MemoryAllocator
 
 from sage.rings.real_double import RDF
@@ -50,6 +50,7 @@ cdef class compiled_integrand:
         return 0
 
 cdef double c_f(double t, void *params) noexcept:
+    sig_block()
     cdef double value
     cdef PyFunctionWrapper wrapper
     wrapper = <PyFunctionWrapper> params
@@ -58,16 +59,16 @@ cdef double c_f(double t, void *params) noexcept:
             value = wrapper.the_function(t, wrapper.the_parameters)
         else:
             value = wrapper.the_function(t)
-    except Exception as msg:
+    except Exception as e:
         try:
-            if str(msg).strip():
-                print(msg)
+            if str(e).strip():
+                print(e)
             else:
                 print(f"Unable to evaluate function at {t}")
         except Exception:
             pass
-        return 0
-
+        value = 0
+    sig_unblock()
     return value
 
 
@@ -121,12 +122,12 @@ def numerical_integral(func, a, b=None,
 
     EXAMPLES:
 
-    To integrate the function `x^2` from 0 to 1, we do ::
+    To integrate the function `x^2` from 0 to 1, we do::
 
         sage: numerical_integral(x^2, 0, 1, max_points=100)
         (0.3333333333333333, 3.700743415417188e-15)
 
-    To integrate the function `\sin(x)^3 + \sin(x)` we do ::
+    To integrate the function `\sin(x)^3 + \sin(x)` we do::
 
         sage: numerical_integral(sin(x)^3 + sin(x),  0, pi)
         (3.333333333333333, 3.700743415417188e-14)
@@ -177,18 +178,18 @@ def numerical_integral(func, a, b=None,
     +Infinity or -Infinity in the interval argument. For example::
 
         sage: f = exp(-x)
-        sage: numerical_integral(f, 0, +Infinity)  # random output
+        sage: numerical_integral(f, 0, +Infinity)  # abs tol 1e-6
         (0.99999999999957279, 1.8429811298996553e-07)
 
     Note the coercion to the real field RR, which prevents underflow::
 
         sage: f = exp(-x**2)
-        sage: numerical_integral(f, -Infinity, +Infinity)  # random output
+        sage: numerical_integral(f, -Infinity, +Infinity)  # abs tol 1e-6
         (1.7724538509060035, 3.4295192165889879e-08)
 
     One can integrate any real-valued callable function::
 
-        sage: numerical_integral(lambda x: abs(zeta(x)), [1.1,1.5])  # random output
+        sage: numerical_integral(lambda x: abs(zeta(x)), [1.1,1.5])  # abs tol 1e-6
         (1.8488570602160455, 2.052643677492633e-14)
 
     We can also numerically integrate symbolic expressions using either this
@@ -264,6 +265,33 @@ def numerical_integral(func, a, b=None,
         sage: h(x) = x
         sage: numerical_integral(h,0,1)[0] # abs tol 1e-8
         0.5
+
+    Ensure :issue:`30379` is fixed::
+
+        sage: g(x) = gamma_inc(2,11/5) * x
+        sage: numerical_integral(g(x), 2, 5)  # abs tol 1e-10
+        (3.722986120974418, 4.1333449118656977e-14)
+
+    Check interruptibility::
+
+        sage: from sage.doctest.util import ensure_interruptible_after
+        sage: def f(x):
+        ....:     sleep(0.01r)
+        ....:     return x
+        sage: with ensure_interruptible_after(0.3): numerical_integral(f, 0, 1)
+
+    Unfortunately the current implementation means if a single function call
+    takes a long time then it will take a while to be interrupted,
+    but cysignals does not yet support such sophisticated nested exception::
+
+        sage: def f(x):
+        ....:     sleep(1r)
+        ....:     return x
+        sage: with ensure_interruptible_after(0.5): numerical_integral(f, 0, 1)
+        Traceback (most recent call last):
+        ...
+        RuntimeError: Function is not interruptible within 0.5000 seconds, only after 1.0... seconds
+
     """
     cdef double abs_err  # step size
     cdef double result
@@ -570,7 +598,7 @@ def monte_carlo_integral(func, xl, xu, size_t calls, algorithm='plain',
     cdef gsl_monte_plain_state* state_plain = NULL
     cdef gsl_monte_miser_state* state_miser = NULL
     cdef gsl_monte_vegas_state* state_vegas = NULL
-    cdef gsl_rng_type *type_rng
+    cdef const gsl_rng_type *type_rng
     cdef gsl_rng *_rng
     cdef size_t dim
     cdef double *_xl

src/sage/doctest/util.py

@@ -851,14 +851,14 @@ def ensure_interruptible_after(seconds: float, max_wait_after_interrupt: float =
         sage: with ensure_interruptible_after(1) as data: uninterruptible_sleep(2r)
         Traceback (most recent call last):
         ...
-        RuntimeError: Function is not interruptible within 1.0000 seconds, only after 2.00... seconds
-        sage: data  # abs tol 0.01
+        RuntimeError: Function is not interruptible within 1.0000 seconds, only after 2.0... seconds
+        sage: data  # abs tol 0.1
         {'alarm_raised': True, 'elapsed': 2.0}
         sage: with ensure_interruptible_after(1): uninterruptible_sleep(2r); raise RuntimeError
         Traceback (most recent call last):
         ...
-        RuntimeError: Function is not interruptible within 1.0000 seconds, only after 2.00... seconds
-        sage: data  # abs tol 0.01
+        RuntimeError: Function is not interruptible within 1.0000 seconds, only after 2.0... seconds
+        sage: data  # abs tol 0.1
         {'alarm_raised': True, 'elapsed': 2.0}
 
     ::
@@ -867,7 +867,7 @@ def ensure_interruptible_after(seconds: float, max_wait_after_interrupt: float =
         Traceback (most recent call last):
         ...
         ValueError
-        sage: data  # abs tol 0.01
+        sage: data  # abs tol 0.1
         {'alarm_raised': False, 'elapsed': 0.0}
     """
     from cysignals.alarm import alarm, cancel_alarm, AlarmInterrupt

src/sage/libs/gsl/rng.pxd

@@ -70,7 +70,7 @@ cdef extern from "gsl/gsl_rng.h":
   cdef gsl_rng_type *gsl_rng_default
   unsigned long int gsl_rng_default_seed
 
-  gsl_rng *gsl_rng_alloc ( gsl_rng_type * T)
+  gsl_rng *gsl_rng_alloc ( const gsl_rng_type * T)
   int gsl_rng_memcpy (gsl_rng * dest, gsl_rng * src)
   gsl_rng *gsl_rng_clone ( gsl_rng * r)