merge constant-method-option

Author: mmatera

mathics/builtin/assignment.py

@@ -861,20 +861,27 @@ class Information(PrefixOperator):
     'Information' does not print information for 'ReadProtected' symbols.
     'Information' uses 'InputForm' to format values.
 
+    #> a = 2;
+    #> Information[a]
+     | a = 2
+     .
+     = Null
 
-    >> a = 2;
-    >> Information[a]
-     = a = 2
-
+    #> f[x_] := x ^ 2;
+    #> g[f] ^:= 2;
+    #> f::usage = "f[x] returns the square of x";
+    #> Information[f]
+     | f[x] returns the square of x
+     .
+     . f[x_] = x ^ 2
+     .
+     . g[f] ^= 2
+     .
+     = Null
 
-    >> f[x_] := x ^ 2
-    >> g[f] ^:= 2
-    >> f::usage = "f[x] returns the square of x";
-    X> Information[f]
-     = f[x] returns the square of x
 
-    >> ? Table
-     = 
+    #> ? Table
+     | 
      .   'Table[expr, {i, n}]'
      .     evaluates expr with i ranging from 1 to n, returning
      . a list of the results.
@@ -885,9 +892,10 @@ class Information(PrefixOperator):
      .     evaluates expr with i taking on the values e1, e2,
      . ..., ei.
      .
+     = Null
 
-    >> Information[Table]
-     = 
+    #> Information[Table]
+     | 
      .   'Table[expr, {i, n}]'
      .     evaluates expr with i ranging from 1 to n, returning
      . a list of the results.
@@ -900,6 +908,7 @@ class Information(PrefixOperator):
      .
      . Attributes[Table] = {HoldAll, Protected}
      .
+     = Null
     """
 
     operator = "??"
@@ -910,15 +919,14 @@ class Information(PrefixOperator):
 
     def format_definition(self, symbol, evaluation, options, grid=True):
         'StandardForm,TraditionalForm,OutputForm: Information[symbol_, OptionsPattern[Information]]'
-        from mathics.core.expression import from_python
+        ret = Symbol('Null')
         lines = []
         if isinstance(symbol, String):
             evaluation.print_out(symbol)
-            evaluation.evaluate(Expression('Information', Symbol('System`String')))
-            return
+            return ret
         if not isinstance(symbol, Symbol):
             evaluation.message('Information', 'notfound', symbol)
-            return Symbol('Null')
+            return ret
         # Print the "usage" message if available.
         usagetext = _get_usage_string(symbol, evaluation)
         if usagetext is not None:
@@ -929,17 +937,16 @@ def format_definition(self, symbol, evaluation, options, grid=True):
 
         if grid:
             if lines:
-                return Expression(
+                infoshow = Expression(
                     'Grid', Expression(
                         'List', *(Expression('List', line) for line in lines)),
                     Expression(
                         'Rule', Symbol('ColumnAlignments'), Symbol('Left')))
-            else:
-                return Symbol('Null')
+                evaluation.print_out(infoshow)
         else:
             for line in lines:
                 evaluation.print_out(Expression('InputForm', line))
-            return Symbol('Null')
+        return ret
 
         # It would be deserable to call here the routine inside Definition, but for some reason it fails...
         # Instead, I just copy the code from Definition
@@ -1006,7 +1013,9 @@ def rhs(expr):
 
     def format_definition_input(self, symbol, evaluation, options):
         'InputForm: Information[symbol_, OptionsPattern[Information]]'
-        return self.format_definition(symbol, evaluation, options, grid=False)
+        self.format_definition(symbol, evaluation, options, grid=False)
+        ret = Symbol("Null")
+        return ret
 
 
 class Clear(Builtin):

mathics/builtin/constants.py

@@ -19,7 +19,7 @@
     Symbol,
     strip_context,
 )
-from mathics.core.numbers import get_precision, PrecisionValueError
+from mathics.core.numbers import get_precision, PrecisionValueError, machine_precision
 
 
 def mp_constant(fn: str, d=None) -> mpmath.ctx_mp_python.mpf:
@@ -29,7 +29,11 @@ def mp_constant(fn: str, d=None) -> mpmath.ctx_mp_python.mpf:
     if d is None:
         return getattr(mpmath, fn)()
     else:
-        mpmath.mp.dps = int_d = int(d)
+        # TODO: In some functions like Pi, you can
+        # ask for a certain number of digits, but the
+        # accuracy will be less than that. Figure out
+        # what's up and compensate somehow.
+        mpmath.mp.dps = int_d = int(d * 3.321928)
         return getattr(mpmath, fn)(prec=int_d)
 
 
@@ -43,7 +47,16 @@ def mp_convert_constant(obj, **kwargs):
 
 
 def numpy_constant(name: str, d=None) -> float:
-    return getattr(numpy, name)
+    if d:
+        # by mmatera: Here I have a question:
+        # 0.0123`2 should be rounded to
+        # 0.01 or to 0.0123?
+        # (absolute versus relative accuracy)
+        val = getattr(numpy, name)
+        val = numpy.round(val, d)
+        return val
+    else:
+        return getattr(numpy, name)
 
 
 def sympy_constant(fn, d=None):
@@ -54,46 +67,75 @@ class _Constant_Common(Predefined):
 
     attributes = ("Constant", "Protected", "ReadProtected")
     nargs = 0
+    options = {"Method": "Automatic"}
 
-    def apply_N(self, precision, evaluation):
-        "N[%(name)s, precision_]"
-        return self.get_constant(precision, evaluation)
+    def apply_N(self, precision, evaluation, options={}):
+        "N[%(name)s, precision_?NumericQ, OptionsPattern[%(name)s]]"
+
+        preference = self.get_option(options, "Method", evaluation).get_string_value()
+        if preference == "Automatic":
+            return self.get_constant(precision, evaluation)
+        else:
+            return self.get_constant(precision, evaluation, preference)
+
+    def apply_N2(self, evaluation, options={}):
+        "N[%(name)s, OptionsPattern[%(name)s]]"
+        return self.apply_N(None, evaluation, options)
 
     def is_constant(self) -> bool:
         return True
 
     def get_constant(self, precision, evaluation, preference=None):
-        ## print("XXX", self, preference)
-        if preference is None:
-            preference = (
-                evaluation.parse("Settings`$PreferredBackendMethod")
-                .evaluate(evaluation)
-                .get_string_value()
-            )
-            # TODO: validate PreferredBackendMethod is in "mpmath", "numpy", "sympy"
-        try:
-            d = get_precision(precision, evaluation)
-        except PrecisionValueError:
-            d = None
+        # first, determine the precision
+        machine_d = int( 0.30103 * machine_precision)
+        d = None
+        if precision:
+            try:
+                d = get_precision(precision, evaluation)
+            except PrecisionValueError:
+                pass
 
-        conversion_fn = MachineReal if d is None else PrecisionReal
-
-        # print("XXX1", self, preference, conversion_fn)
+        if d is None:
+            d = machine_d
 
-        if preference == "sympy" and hasattr(self, "sympy_name"):
-            value = sympy_constant(self.sympy_name, d)
-        elif preference == "mpmath" and hasattr(self, "mpmath_name"):
-            value = mp_constant(self.mpmath_name, d)
-        elif preference == "numpy" and hasattr(self, "numpy_name"):
-            value = numpy_constant(self.numpy_name)
-        elif hasattr(self, "mpmath_name"):
-            value = mp_constant(self.mpmath_name, d)
-        elif hasattr(self, "sympy_name"):
-            value = sympy_constant(self.sympy_name, d)
-        elif hasattr(self, "numpy_name"):
+        # If preference not especified, determine it
+        # from the precision.
+        if preference is None:
+            if d <= machine_d:
+                preference = "numpy"
+            else:
+                preference = "mpmath"
+        # If preference is not valid, send a message and return.
+        if not (preference in  ("sympy", "numpy", "mpmath")):
+            evaluation.message(f'{preference} not in ("sympy", "numpy", "mpmath")')
+            return
+        # Try to determine the numeric value
+        value = None
+        if preference == "mpmath" and not hasattr(self, "mpmath_name"):
+            preference = "numpy"
+        elif preference == "sympy" and not hasattr(self, "sympy_name"):
+            preference = "numpy"
+        
+        if preference == "numpy" and not hasattr(self, "numpy_name"):
+            if hasattr(self, "sympy_name"):
+                preference = "sympy"
+            elif hasattr(self, "mpmath_name"):
+                preference = "mpmath"
+            else:
+                preference = ""
+        if preference == "numpy":
             value = numpy_constant(self.numpy_name)
-        return conversion_fn(value)
-
+            if d == machine_d:
+                return MachineReal(value)
+        if preference == "sympy":
+            value = sympy_constant(self.sympy_name, d+2)
+        if preference == "mpmath":
+            value = mp_constant(self.mpmath_name, d*2)
+        if value:
+            return PrecisionReal(sympy.Float(str(value), d))
+        # If the value is not available, return none
+        # and keep it unevaluated.
+        return
 
 class MPMathConstant(_Constant_Common):
     """Representation of a constant in mpmath, e.g. Pi, E, I, etc."""
@@ -152,22 +194,22 @@ def to_sympy(self, expr=None, **kwargs):
             return None
 
 
-class Catalan(MPMathConstant, NumpyConstant, SympyConstant):
+class Catalan(MPMathConstant, SympyConstant):
     """
     <dl>
     <dt>'Catalan'
         <dd>is Catalan's constant with numerical value \u2243 0.915966.
     </dl>
 
     >> Catalan // N
-     = 0.915966
+     = 0.915965594177219
 
     >> N[Catalan, 20]
      = 0.91596559417721901505
     """
 
     mpmath_name = "catalan"
-    numpy_name = "catalan"
+    # numpy_name = "catalan"  ## This is not defined in numpy
     sympy_name = "Catalan"
 
 
@@ -239,10 +281,13 @@ def to_numpy(self, expr=None, **kwargs):
             # return mpmath.degree
             return numpy.pi / 180
 
-    def apply_N(self, precision, evaluation):
-        "N[Degree, precision_]"
+    def apply_N(self, precision, evaluation, options={}):
+        "N[Degree, precision_, OptionsPattern[%(name)s]]"
         try:
-            d = get_precision(precision, evaluation)
+            if precision:
+                d = get_precision(precision, evaluation)
+            else:
+                d = get_precision(Symbol("System`MachinePrecision"), evaluation)
         except PrecisionValueError:
             return
 
@@ -278,8 +323,8 @@ class E(MPMathConstant, NumpyConstant, SympyConstant):
     numpy_name = "e"
     sympy_name = "E"
 
-    def apply_N(self, precision, evaluation):
-        "N[E, precision_]"
+    def apply_N(self, precision, evaluation, options={}):
+        "N[E, precision_, OptionsPattern[%(name)s]]"
         return self.get_constant(precision, evaluation)
 
 
@@ -310,9 +355,10 @@ class Glaisher(MPMathConstant):
     </dl>
 
     >> N[Glaisher]
-     = 1.28243
+     = 1.28242712910062
     >> N[Glaisher, 50]
-     = 1.2824271291006219541941391071304678916931152343750
+     = 1.2824271291006226368753425688697917277676889273250
+     # 1.2824271291006219541941391071304678916931152343750
     """
 
     mpmath_name = "glaisher"
@@ -326,7 +372,7 @@ class GoldenRatio(MPMathConstant, SympyConstant):
     </dl>
 
     >> GoldenRatio // N
-     = 1.61803
+     = 1.61803398874989
     >> N[GoldenRatio, 40]
      = 1.618033988749894848204586834365638117720
     """
@@ -399,9 +445,10 @@ class Khinchin(MPMathConstant):
     </dl>
 
     >> N[Khinchin]
-     = 2.68545
+     = 2.68545200106531
     >> N[Khinchin, 50]
-     = 2.6854520010653075701156922150403261184692382812500
+     = 2.6854520010653064453097148354817956938203822939945
+     # = 2.6854520010653075701156922150403261184692382812500
     """
 
     mpmath_name = "khinchin"
@@ -416,7 +463,19 @@ class Pi(MPMathConstant, SympyConstant):
 
     >> N[Pi]
      = 3.14159
-    >> N[Pi, 50]
+
+    Force using the value given from numpy to compute Pi.
+    >> N[Pi, Method->"numpy"]
+     = 3.14159
+
+    Force using the value given from sympy to compute Pi to 3 places,
+    two places after the decimal point.
+
+    Note that sympy is the default method.
+    >> N[Pi, 3, Method->"sympy"]
+     = 3.14
+
+     >> N[Pi, 50]
      = 3.1415926535897932384626433832795028841971693993751
     >> Attributes[Pi]
      = {Constant, Protected, ReadProtected}

mathics/builtin/inout.py

@@ -1901,6 +1901,9 @@ class Print(Builtin):
      | μ
     #> Print["μ"]
      | μ
+    #> Print["-Hola\\n-Qué tal?"]
+     | -Hola
+     . -Qué tal?
     """
 
     def apply(self, expr, evaluation):

mathics/builtin/linalg.py

@@ -739,7 +739,7 @@ def mp_eig(mp_matrix) -> Expression:
         return Expression("List", *eigenvalues)
 
     options = {
-        "Method": "Sympy",
+        "Method": "sympy",
     }
 
     def apply(self, m, evaluation, options={}) -> Expression:

mathics/builtin/system.py

@@ -414,7 +414,7 @@ def evaluate(self, evaluation) -> String:
         try:
             return String(os.getlogin())
         except:
-            evaluation.message('$UserName', 'nologin')
+           evaluation.message('$UserName', 'nologin')
             return