16587: f(expr,hold).n() fails for all generalized functions

Author: rwst

src/sage/functions/generalized.py

@@ -142,16 +142,27 @@ def _eval_(self, x):
             0
         """
         try:
-            approx_x = ComplexIntervalField()(x)
-            if bool(approx_x.imag() == 0):      # x is real
-                if bool(approx_x.real() == 0):  # x is zero
-                    return None
-                else:
-                    return 0
-        except Exception:                     # x is symbolic
+            return self._evalf_(x)
+        except (TypeError,ValueError):      # x is symbolic
             pass
         return None
 
+    def _evalf_(self, x, **kwds):
+        """
+        TESTS::
+
+            sage: h(x) = dirac_delta(x)
+            sage: h(pi)._numerical_approx()
+            0.000000000000000
+        """
+        approx_x = ComplexIntervalField()(x)
+        if bool(approx_x.imag() == 0):      # x is real
+            if bool(approx_x.real() == 0):  # x is zero
+                return None
+            else:
+                return 0
+        raise ValueError("Numeric evaluation of symbolic expression")
+
 dirac_delta = FunctionDiracDelta()
 
 class FunctionHeaviside(BuiltinFunction):
@@ -252,19 +263,30 @@ def _eval_(self, x):
             2
         """
         try:
-            approx_x = ComplexIntervalField()(x)
-            if bool(approx_x.imag() == 0):      # x is real
-                if bool(approx_x.real() == 0):  # x is zero
-                    return None
-                # Now we have a non-zero real
-                if bool((approx_x**(0.5)).imag() == 0): # Check: x > 0
-                    return 1
-                else:
-                    return 0
-        except Exception:                     # x is symbolic
+            return self._evalf_(x)
+        except (TypeError,ValueError):      # x is symbolic
             pass
         return None
 
+    def _evalf_(self, x, **kwds):
+        """
+        TESTS::
+
+            sage: h(x) = heaviside(x)
+            sage: h(pi)._numerical_approx()
+            1.00000000000000
+        """
+        approx_x = ComplexIntervalField()(x)
+        if bool(approx_x.imag() == 0):      # x is real
+            if bool(approx_x.real() == 0):  # x is zero
+                return None
+            # Now we have a non-zero real
+            if bool((approx_x**(0.5)).imag() == 0): # Check: x > 0
+                return 1
+            else:
+                return 0
+        raise ValueError("Numeric evaluation of symbolic expression")
+
     def _derivative_(self, x, diff_param=None):
         """
         Derivative of Heaviside step function
@@ -361,19 +383,30 @@ def _eval_(self, x):
             1
         """
         try:
-            approx_x = ComplexIntervalField()(x)
-            if bool(approx_x.imag() == 0):      # x is real
-                if bool(approx_x.real() == 0):  # x is zero
-                    return 1
-                # Now we have a non-zero real
-                if bool((approx_x**(0.5)).imag() == 0): # Check: x > 0
-                    return 1
-                else:
-                    return 0
-        except Exception:                     # x is symbolic
+            return self._evalf_(x)
+        except (TypeError,ValueError):      # x is symbolic
             pass
         return None
 
+    def _evalf_(self, x, **kwds):
+        """
+        TESTS::
+
+            sage: h(x) = unit_step(x)
+            sage: h(pi)._numerical_approx()
+            1.00000000000000
+        """
+        approx_x = ComplexIntervalField()(x)
+        if bool(approx_x.imag() == 0):      # x is real
+            if bool(approx_x.real() == 0):  # x is zero
+                return 1
+            # Now we have a non-zero real
+            if bool((approx_x**(0.5)).imag() == 0): # Check: x > 0
+                return 1
+            else:
+                return 0
+        raise ValueError("Numeric evaluation of symbolic expression")
+
     def _derivative_(self, x, diff_param=None):
         """
         Derivative of unit step function
@@ -491,23 +524,40 @@ def _eval_(self, x):
             sage: sign(AA(0))
             0
         """
+        try:
+            return self._evalf_(x)
+        except (TypeError,ValueError):      # x is symbolic
+            pass
+        return None
+
+    def _evalf_(self, x, **kwds):
+        """
+        TESTS:
+
+        Check that :trac:`16587` is fixed::
+
+            sage: M = sgn(3/2, hold=True); M
+            sgn(3/2)
+            sage: M.n()
+            1
+            sage: h(x) = sgn(x)
+            sage: h(pi)._numerical_approx()
+            1.00000000000000
+        """
         if hasattr(x,'sign'): # First check if x has a sign method
             return x.sign()
         if hasattr(x,'sgn'): # or a sgn method
             return x.sgn()
-        try:
-            approx_x = ComplexIntervalField()(x)
-            if bool(approx_x.imag() == 0):      # x is real
-                if bool(approx_x.real() == 0):  # x is zero
-                    return ZZ(0)
-                # Now we have a non-zero real
-                if bool((approx_x**(0.5)).imag() == 0): # Check: x > 0
-                    return ZZ(1)
-                else:
-                    return ZZ(-1)
-        except Exception:                     # x is symbolic
-            pass
-        return None
+        approx_x = ComplexIntervalField()(x)
+        if bool(approx_x.imag() == 0):      # x is real
+            if bool(approx_x.real() == 0):  # x is zero
+                return ZZ(0)
+            # Now we have a non-zero real
+            if bool((approx_x**(0.5)).imag() == 0): # Check: x > 0
+                return ZZ(1)
+            else:
+                return ZZ(-1)
+        raise ValueError("Numeric evaluation of symbolic expression")
 
     def _derivative_(self, x, diff_param=None):
         """
@@ -601,22 +651,33 @@ def _eval_(self, m, n):
             sage: kronecker_delta(1,x).subs(x=1)
             1
         """
+        try:
+            return self._evalf_(m,n)
+        except (TypeError,ValueError):      # x is symbolic
+            pass
+        return None
+
+    def _evalf_(self, m, n, **kwds):
+        """
+        TESTS::
+
+            sage: h(x) = kronecker_delta(3,x)
+            sage: h(pi)._numerical_approx()
+            0.000000000000000
+        """
         if bool(repr(m) > repr(n)):
             return kronecker_delta(n, m)
 
         x = m - n
-        try:
-            approx_x = ComplexIntervalField()(x)
-            if bool(approx_x.imag() == 0):      # x is real
-                if bool(approx_x.real() == 0):  # x is zero
-                    return 1
-                else:
-                    return 0
+        approx_x = ComplexIntervalField()(x)
+        if bool(approx_x.imag() == 0):      # x is real
+            if bool(approx_x.real() == 0):  # x is zero
+                return 1
             else:
-                return 0            # x is complex
-        except Exception:                     # x is symbolic
-            pass
-        return None
+                return 0
+        else:
+            return 0            # x is complex
+        raise ValueError("Numeric evaluation of symbolic expression")
 
     def _derivative_(self, *args, **kwds):
         """