Trac #14778: Fix numerical_approx with algorithm keyword

Author: eviatarbach

src/sage/matrix/matrix2.pyx

@@ -12067,7 +12067,7 @@ cdef class Matrix(matrix1.Matrix):
         if p == 'frob':
             return sum([i**2 for i in A.list()]).sqrt()
 
-    def _numerical_approx(self,prec=None,digits=None):
+    def _numerical_approx(self, prec=None, digits=None, algorithm=None):
         r"""
         Return a numerical approximation of ``self`` as either
         a real or complex number with at least the requested number of bits

src/sage/misc/functional.py

@@ -1210,10 +1210,10 @@ def numerator(x):
     return x.numerator()
 
 # Following is the top-level numerical_approx function.
-# Implement a ._numerical_approx(prec, digits) method for your
+# Implement a ._numerical_approx(prec, digits, algorithm) method for your
 # objects to enable the three top-level functions and three methods
 
-def numerical_approx(x, prec=None, digits=None):
+def numerical_approx(x, prec=None, digits=None, algorithm=None):
     r"""
     Returns a numerical approximation of an object ``x`` with at
     least ``prec`` bits (or decimal ``digits``) of precision.
@@ -1228,10 +1228,13 @@ def numerical_approx(x, prec=None, digits=None):
 
     -  ``x`` - an object that has a numerical_approx
        method, or can be coerced into a real or complex field
-    -  ``prec (optional)`` - an integer (bits of
+    -  ``prec`` (optional) - an integer (bits of
        precision)
-    -  ``digits (optional)`` - an integer (digits of
+    -  ``digits`` (optional) - an integer (digits of
        precision)
+    -  ``algorithm`` (optional) - a string specifying
+       the algorithm to use for functions that implement
+       more than one
 
     If neither the ``prec`` or ``digits`` are specified,
     the default is 53 bits of precision.  If both are
@@ -1384,14 +1387,18 @@ def numerical_approx(x, prec=None, digits=None):
         sage: len(str(n(golden_ratio, digits=5000000)))  # long time (4s on sage.math, 2012)
         5000001
 
+    Check that :trac:`14778` is fixed::
+
+        sage: n(0, algorithm='foo')
+        0.000000000000000
     """
     if prec is None:
         if digits is None:
             prec = 53
         else:
             prec = int((digits+1) * LOG_TEN_TWO_PLUS_EPSILON) + 1
     try:
-        return x._numerical_approx(prec)
+        return x._numerical_approx(prec, algorithm=algorithm)
     except AttributeError:
         from sage.rings.complex_double import is_ComplexDoubleElement
         from sage.rings.complex_number import is_ComplexNumber

src/sage/modules/free_module_element.pyx

@@ -996,7 +996,7 @@ cdef class FreeModuleElement(element_Vector):   # abstract base class
             return sib.name('vector')(self.base_ring(),
                                       [sib(e, 2) for e in self])
 
-    def _numerical_approx(self, prec=None, digits=None):
+    def _numerical_approx(self, prec=None, digits=None, algorithm=None):
         r"""
         Implements numerical approximation of a free module element
         by calling the ``n()`` method on all of its entries.
@@ -1114,7 +1114,7 @@ cdef class FreeModuleElement(element_Vector):   # abstract base class
             sage: u
             (0.5000, 0.0000, 0.0000, 0.3333, 0.0000, 0.0000, 0.0000, 0.2500)
         """
-        return vector([e.n(prec, digits) for e in self])
+        return vector([e.n(prec, digits, algorithm) for e in self])
 
     def transpose(self):
         r"""
@@ -4512,7 +4512,7 @@ cdef class FreeModuleElement_generic_sparse(FreeModuleElement):
         """
         return len(self._entries)
 
-    def _numerical_approx(self, prec=None, digits=None):
+    def _numerical_approx(self, prec=None, digits=None, algorithm=None):
         """
         Returns a numerical approximation of self by calling the n() method
         on all of its entries.
@@ -4529,5 +4529,6 @@ cdef class FreeModuleElement_generic_sparse(FreeModuleElement):
             sage: _.parent()
             Sparse vector space of dimension 3 over Real Field with 75 bits of precision
         """
-        return vector(dict([(e[0],e[1].n(prec, digits)) for e in self._entries.iteritems()]), sparse=True)
+        return vector(dict([(e[0], e[1].n(prec, digits, algorithm)) for e in
+                            self._entries.iteritems()]), sparse=True)
 

src/sage/schemes/elliptic_curves/heegner.py

@@ -3124,7 +3124,7 @@ def quadratic_form(self):
         return self.__x.quadratic_form()
 
     @cached_method
-    def numerical_approx(self, prec=53):
+    def numerical_approx(self, prec=53, algorithm=None):
         """
         Return a numerical approximation to this Heegner point
         computed using a working precision of prec bits.

src/sage/structure/element.pyx

@@ -628,7 +628,7 @@ cdef class Element(sage_object.SageObject):
                 variables.append(gen)
         return self(*variables)
 
-    def numerical_approx (self, prec=None, digits=None):
+    def numerical_approx(self, prec=None, digits=None, algorithm=None):
         """
         Return a numerical approximation of x with at least prec bits of
         precision.
@@ -641,11 +641,20 @@ cdef class Element(sage_object.SageObject):
             3.141592654
             sage: pi.n(prec=20)   # 20 bits
             3.1416
+
+        TESTS:
+
+        Check that :trac:`14778` is fixed::
+
+            sage: (0).n(algorithm='foo')
+            0.000000000000000
         """
         import sage.misc.functional
-        return sage.misc.functional.numerical_approx(self, prec=prec, digits=digits)
-    n=numerical_approx
-    N=n
+        return sage.misc.functional.numerical_approx(self, prec=prec,
+                                                     digits=digits,
+                                                     algorithm=algorithm)
+    n = numerical_approx
+    N = n
 
     def _mpmath_(self, prec=53, rounding=None):
         """