Merge branch 'master' into makeboxesoverhault

Author: mmatera

.github/workflows/windows.yml

@@ -0,0 +1,33 @@
+name: Mathics (Windows)
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        os: [windows]
+        python-version: [3.6, 3.7, 3.8, 3.9]
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v2
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        choco llvm
+        python -m pip install --upgrade pip
+        LLVM_CONFIG=/usr/local/Cellar/llvm@9/9.0.1_2/bin/llvm-config pip install llvmlite
+    - name: Install Mathics
+      run: |
+        make develop
+    - name: Test Mathics
+      run: |
+        pip install pytest pexpect
+        make -j3 check

mathics/builtin/arithmetic.py

@@ -11,7 +11,6 @@
 
 import sympy
 import mpmath
-import math
 
 from mathics.builtin.base import (
     Builtin,
@@ -1343,14 +1342,13 @@ class PossibleZeroQ(SympyFunction):
     def apply(self, expr, evaluation):
         "%(name)s[expr_]"
         from sympy.matrices.utilities import _iszero
-
         sympy_expr = expr.to_sympy()
         result = _iszero(sympy_expr)
         if result is None:
         # try expanding the expression
             exprexp = Expression("ExpandAll", expr).evaluate(evaluation)
             exprexp = exprexp.to_sympy()
-            result = _iszero(exprexp)        
+            result = _iszero(exprexp)
         if result is None:
             # Can't get exact answer, so try approximate equal
             numeric_val = Expression("N", expr).evaluate(evaluation)
@@ -1364,7 +1362,6 @@ def apply(self, expr, evaluation):
                     if Expression("Simplify", expr).evaluate(evaluation) == Integer(0)
                     else SymbolFalse
                 )
-
         return from_python(result)
 
 

mathics/builtin/base.py

@@ -1,14 +1,12 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
-import mpmath
 import re
 import sympy
 
 from functools import total_ordering
 import importlib
 from itertools import chain
-
 import typing
 from typing import Any, cast
 
@@ -533,7 +531,7 @@ def apply(self, expr, evaluation) -> Symbol:
 
 
 class SympyFunction(SympyObject):
-    def get_constant(self, precision, have_mpmath=False):
+    def get_constant(self, precision, evaluation, have_mpmath=False):
         try:
             d = get_precision(precision, evaluation)
         except PrecisionValueError:

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/datentime.py

@@ -149,7 +149,7 @@ class TimeConstrained(Builtin):
 
     Possible issues: for certain time-consuming functions (like simplify)
     which are based on sympy or other libraries, it is possible that
-    the evaluation continues after the timeout. However, at the end of the evaluation, the function will return $\$Aborted$ and the results will not affect
+    the evaluation continues after the timeout. However, at the end of the evaluation, the function will return $\\$Aborted$ and the results will not affect
     the state of the mathics kernel.
 
     """