Merge remote-tracking branch 'upstream/master' into newcellstotexfixes2

Author: mmatera

.github/workflows/windows.yml

@@ -0,0 +1,36 @@
+name: Mathics (Windows)
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        os: [windows]
+        python-version: [3.7, 3.8]
+    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: |
+        python -m pip install --upgrade pip
+        python -m pip install wheel
+        choco install llvm
+        set LLVM_DIR="C:\Program Files\LLVM"
+        pip install -e .
+    - name: Install Mathics
+      run: |
+        python setup.py install
+    - name: Test Mathics
+      run: |
+        pip install pytest
+        py.test test
+        python mathics/test.py

CHANGES.rst

@@ -1,6 +1,58 @@
 CHANGES
 =======
 
+2.1.0
+-----
+
+New builtins
+++++++++++++
+
+* ``ArcTanh``
+* ``ByteArray``
+* ``CreateFile``
+* ``CreateTemporary``
+* ``FileNames``
+* ``NIntegrate``
+* ``PartitionsP``
+* ``$Notebooks``
+
+Enhancements
+++++++++++++
+
+* the Mathics version is checked for builtin modules at load time. A message is given when a builtin doesn't load.
+* Automatic detection for the best strategy to numeric evaluation of constants.
+* ``FileNameJoin`` - implement ``OperatingSystem`` option
+* Mathics functions are accepted by ``Compile[]``. The return value or type will be
+  ``Compile[] and CompiledFunction[]``  every expression can have a compiled form,
+  as a Python function.
+* ``Equal[]`` now compares complex against other numbers properly.
+
+
+Bug fixes
++++++++++
+
+* TeXForm for integrals are now properly formatted.
+
+
+Pymathics Modules
++++++++++++++++++
+
+* Pymathics modules now can run initialization code when are loaded.
+* The ``builtins`` list is not hardliked to the library anymore. This simplifies
+  the loading and reloading of pymathics modules.
+* Decoupling of BoxConstructors from the library. Now are defined at the
+  level of the definition objects. This is useful for customizing the
+  Graphics output if it is available.
+
+
+Miscellanea
++++++++++++
+
+* A pass was made to improve Microsoft Windows compatability and testing
+Windows under MSYS.
+* Include numpy version in version string. Show in CLI
+* Small CLI tweaks ``--colors=None`` added to match mathicsscript.
+
 2.0.0
 -----
 
@@ -79,7 +131,7 @@ Numerous bugs were fixed while working on Combinatorica V0.9 and CellsToTeX.
 Document updates
 ++++++++++++++++
 
-- Start a readthedocs `Developer Guide <https://mathics-development-guide.readthedocs.io/en/latest/>`_
+- Start a readthedocs `Developer Guide <https://mathics-development-guide.reandthedocs.io/en/latest/>`_
 
 Enhancements and bug fixes:
 +++++++++++++++++++++++++++

README.rst

@@ -28,7 +28,7 @@ mathicsserver: a Django-based Web interface
 Installing and Running
 ----------------------
 
-See the `readthe docs guide <https://mathics-development-guide.readthedocs.io/en/latest/>`_ for instructions on `installing <https://mathics-development-guide.readthedocs.io/en/latest/installing.html>`_ and `running <https://mathics-development-guide.readthedocs.io/en/latest/running.html>`_.
+See the `read the docs guide <https://mathics-development-guide.readthedocs.io/en/latest/>`_ for instructions on `installing <https://mathics-development-guide.readthedocs.io/en/latest/installing.html>`_ and `running <https://mathics-development-guide.readthedocs.io/en/latest/running.html>`_.
 
 Contributing
 ------------

mathics/Makefile

@@ -5,6 +5,7 @@
 import platform
 import sympy
 import mpmath
+import numpy
 
 from mathics.version import __version__
 from mathics.core.expression import (
@@ -27,6 +28,7 @@
     "mathics": __version__,
     "sympy": sympy.__version__,
     "mpmath": mpmath.__version__,
+    "numpy": numpy.__version__,
     "python": platform.python_implementation() + " " + sys.version.split("\n")[0],
 }
 
@@ -40,7 +42,7 @@
 
 version_string = """Mathics {mathics}
 on {python}
-using SymPy {sympy}, mpmath {mpmath}""".format(
+using SymPy {sympy}, mpmath {mpmath}, numpy {numpy}""".format(
     **version_info
 )
 

mathics/__init__.py

@@ -11,7 +11,7 @@
     strm = OpenWrite[filename];
     If[strm === $Failed, Return[$Failed]];
     data = B64Encode[expr];
-    WriteString[strm, data];    
+    WriteString[strm, data];
     Close[strm];
   ]
 
@@ -21,7 +21,7 @@
 	FunctionChannels -> {"FileNames"},
 	Options -> {"CharacterEncoding", "ByteOrderMark"},
 	DefaultElement -> "Plaintext",
-	BinaryFormat -> True
+	BinaryFormat -> False
 ]
 
 

mathics/autoload/formats/Base64/Export.m

@@ -22,7 +22,7 @@
     FunctionChannels -> {"Streams"},
     Options -> {"ByteOrderMark"},
     DefaultElement -> "Plaintext",
-    BinaryFormat -> True,
+    BinaryFormat -> False,
     Options -> {
         "CharacterEncoding",
         "FieldSeparators"

mathics/autoload/formats/CSV/Export.m

@@ -10,3 +10,9 @@
 Settings`$PreferredBackendMethod::usage = "Set this do whether to use mpmath, numpy or Sympy for numeric and symbolic constants and methods when there is s choice";
 Settings`$PreferredBackendMethod = "sympy"
 Unprotect[Settings`$PreferredBackendMethod]
+
+(* Some packages like Feyncalc, test for whether a they are being used
+inside a notbook. *)
+System`$Notebooks::usage = "Set True if the Mathics is being used with a notebook‐based front end.";
+System`$Notebooks = False;
+Unprotect[System`Notebooks];

mathics/autoload/settings.m

@@ -10,6 +10,7 @@
 from mathics.version import __version__  # noqa used in loading to check consistency.
 import sympy
 import mpmath
+from functools import lru_cache
 
 from mathics.builtin.base import (
     Builtin,
@@ -34,12 +35,29 @@
     SymbolNull,
     SymbolTrue,
     from_python,
+    from_mpmath,
 )
 from mathics.core.numbers import min_prec, dps, SpecialValueError
 
 from mathics.builtin.lists import _IterationFunction
 from mathics.core.convert import from_sympy, SympyExpression
 
+@lru_cache(maxsize=1024)
+def call_mpmath(mpmath_function, mpmath_args):
+    try:
+        return mpmath_function(*mpmath_args)
+    except ValueError as exc:
+        text = str(exc)
+        if text == "gamma function pole":
+            return Symbol("ComplexInfinity")
+        else:
+            raise
+    except ZeroDivisionError:
+        return
+    except SpecialValueError as exc:
+        return Symbol(exc.name)
+
+
 class _MPMathFunction(SympyFunction):
 
     attributes = ("Listable", "NumericFunction")
@@ -48,6 +66,7 @@ class _MPMathFunction(SympyFunction):
 
     nargs = 1
 
+    @lru_cache(maxsize=1024)
     def get_mpmath_function(self, args):
         if self.mpmath_name is None or len(args) != self.nargs:
             return None
@@ -57,7 +76,7 @@ def apply(self, z, evaluation):
         "%(name)s[z__]"
 
         args = z.numerify(evaluation).get_sequence()
-        mpmath_function = self.get_mpmath_function(args)
+        mpmath_function = self.get_mpmath_function(tuple(args))
         result = None
 
         # if no arguments are inexact attempt to use sympy
@@ -82,7 +101,7 @@ def apply(self, z, evaluation):
             if None in float_args:
                 return
 
-            result = self.call_mpmath(mpmath_function, float_args)
+            result = call_mpmath(mpmath_function, tuple(float_args))
             if isinstance(result, (mpmath.mpc, mpmath.mpf)):
                 if mpmath.isinf(result) and isinstance(result, mpmath.mpc):
                     result = Symbol("ComplexInfinity")
@@ -93,7 +112,7 @@ def apply(self, z, evaluation):
                 elif mpmath.isnan(result):
                     result = Symbol("Indeterminate")
                 else:
-                    result = Number.from_mpmath(result)
+                    result = from_mpmath(result)
         else:
             prec = min_prec(*args)
             d = dps(prec)
@@ -104,9 +123,9 @@ def apply(self, z, evaluation):
                 mpmath_args = [x.to_mpmath() for x in args]
                 if None in mpmath_args:
                     return
-                result = self.call_mpmath(mpmath_function, mpmath_args)
+                result = call_mpmath(mpmath_function, tuple(mpmath_args))
                 if isinstance(result, (mpmath.mpc, mpmath.mpf)):
-                    result = Number.from_mpmath(result, d)
+                    result = from_mpmath(result, d)
         return result
 
     def call_mpmath(self, mpmath_function, mpmath_args):
@@ -338,12 +357,12 @@ def append_last():
                 if is_machine_precision:
                     numbers = [item.to_mpmath() for item in numbers]
                     number = mpmath.fsum(numbers)
-                    number = Number.from_mpmath(number)
+                    number = from_mpmath(number)
                 else:
                     with mpmath.workprec(prec):
                         numbers = [item.to_mpmath() for item in numbers]
                         number = mpmath.fsum(numbers)
-                        number = Number.from_mpmath(number, dps(prec))
+                        number = from_mpmath(number, dps(prec))
             else:
                 number = from_sympy(sum(item.to_sympy() for item in numbers))
         else:
@@ -670,12 +689,12 @@ def apply(self, items, evaluation):
                 if is_machine_precision:
                     numbers = [item.to_mpmath() for item in numbers]
                     number = mpmath.fprod(numbers)
-                    number = Number.from_mpmath(number)
+                    number = from_mpmath(number)
                 else:
                     with mpmath.workprec(prec):
                         numbers = [item.to_mpmath() for item in numbers]
                         number = mpmath.fprod(numbers)
-                        number = Number.from_mpmath(number, dps(prec))
+                        number = from_mpmath(number, dps(prec))
             else:
                 number = sympy.Mul(*[item.to_sympy() for item in numbers])
                 number = from_sympy(number)
@@ -1095,6 +1114,7 @@ class Re(SympyFunction):
     """
 
     attributes = ("Listable", "NumericFunction")
+    sympy_name = "re"
 
     def apply_complex(self, number, evaluation):
         "Re[number_Complex]"
@@ -1209,7 +1229,7 @@ class Abs(_MPMathFunction):
     mpmath_name = "fabs"  # mpmath actually uses python abs(x) / x.__abs__()
 
 
-class Sign(Builtin):
+class Sign(SympyFunction):
     """
     <dl>
     <dt>'Sign[$x$]'
@@ -1237,8 +1257,7 @@ class Sign(Builtin):
      = Sign[20]
     """
 
-    # Sympy and mpmath do not give the desired form of complex number
-    # sympy_name = 'sign'
+    sympy_name = "sign"
     # mpmath_name = 'sign'
 
     attributes = ("Listable", "NumericFunction")
@@ -1248,14 +1267,15 @@ class Sign(Builtin):
     }
 
     def apply(self, x, evaluation):
-        "Sign[x_]"
+        "%(name)s[x_]"
+        # Sympy and mpmath do not give the desired form of complex number
         if isinstance(x, Complex):
             return Expression("Times", x, Expression("Power", Expression("Abs", x), -1))
 
         sympy_x = x.to_sympy()
         if sympy_x is None:
             return None
-        return from_sympy(sympy.sign(sympy_x))
+        return super().apply(x)
 
     def apply_error(self, x, seqs, evaluation):
         "Sign[x_, seqs__]"
@@ -1591,7 +1611,7 @@ class Rational_(Builtin):
     name = "Rational"
 
     def apply(self, n, m, evaluation):
-        "Rational[n_Integer, m_Integer]"
+        "%(name)s[n_Integer, m_Integer]"
 
         if m.to_sympy() == 1:
             return Integer(n.to_sympy())
@@ -1658,7 +1678,7 @@ class Complex_(Builtin):
     name = "Complex"
 
     def apply(self, r, i, evaluation):
-        "Complex[r_?NumberQ, i_?NumberQ]"
+        "%(name)s[r_?NumberQ, i_?NumberQ]"
 
         if isinstance(r, Complex) or isinstance(i, Complex):
             sym_form = r.to_sympy() + sympy.I * i.to_sympy()
@@ -2063,7 +2083,7 @@ class Piecewise(SympyFunction):
     attributes = ("HoldAll",)
 
     def apply(self, items, evaluation):
-        "Piecewise[items__]"
+        "%(name)s[items__]"
         result = self.to_sympy(Expression("Piecewise", *items.get_sequence()))
         if result is None:
             return
@@ -2129,7 +2149,7 @@ class Boole(Builtin):
     attributes = ("Listable",)
 
     def apply(self, expr, evaluation):
-        "Boole[expr_]"
+        "%(name)s[expr_]"
         if isinstance(expr, Symbol):
             if expr == SymbolTrue:
                 return Integer(1)