merge

Author: mmatera

.github/workflows/windows.yml

@@ -0,0 +1,46 @@
+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 llvmlite
+        pip install numpy
+        pip install sympy
+        pip install pillow
+        pip install scikit-image
+        pip install requests
+        pip install wordcloud
+        pip install PyYAML
+        pip install palettable
+        pip install mpmath
+        pip install mathics_scanner
+    - 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,7 @@
 CHANGES
 =======
 
+<<<<<<< HEAD
 
 2.0.1
 -----
@@ -34,6 +35,35 @@ Pymathics Modules
 
 
 
+=======
+2.1.0
+-----
+
+  New builtins
+++++++++++++++
+
+* ``ByteArray``
+* ``FileNames``
+* ``CreateFile``
+* ``CreateTemporary``
+
+
+Enhancements
+++++++++++++
+
+* ``FileNameJoin`` - implement ``OperatingSystem`` option
+* Mathics functions are accepted by ``Compile[]``. The return value or type will be
+  ``CompiledFunction``
+* ``EqualQ[]`` now compares complex against other numbers properly.
+
+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.
+>>>>>>> upstream/master
 
 2.0.0
 -----
@@ -113,7 +143,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:
 +++++++++++++++++++++++++++

mathics/__init__.py

@@ -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/autoload/formats/Base64/Export.m

@@ -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/CSV/Export.m

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

mathics/builtin/base.py

@@ -21,6 +21,7 @@
     MachineReal,
     PrecisionReal,
     String,
+    ByteArrayAtom,
     Symbol,
     ensure_context,
     strip_context,

mathics/builtin/comparison.py

@@ -2,11 +2,12 @@
 # -*- coding: utf-8 -*-
 
 
+from mathics.version import __version__  # noqa used in loading to check consistency.
+
 import itertools
 from typing import Optional, Union
 
 import sympy
-from mathics.version import __version__  # noqa used in loading to check consistency.
 
 from mathics.builtin.base import (
     BinaryOperator,
@@ -21,6 +22,7 @@
     Expression,
     Integer,
     Number,
+    Real,
     String,
     Symbol,
     SymbolFalse,
@@ -32,6 +34,9 @@ def cmp(a, b) -> int:
     "Returns 0 if a == b, -1 if a < b and 1 if a > b"
     return (a > b) - (a < b)
 
+def is_number(sympy_value) -> bool:
+    return hasattr(sympy_value, "is_number") or isinstance(sympy_value, sympy.Float)
+
 class SameQ(BinaryOperator):
     """
     <dl>
@@ -231,17 +236,30 @@ def do_compare(self, l1, l2) -> Union[bool, None]:
                     return result
             return True
 
+        # Use Mathics' built-in comparisons for Real and Integer. These use
+        # WL's interpretation of Equal[] which allows for slop in Reals
+        # in the least significant digit of precision, while for Integers, comparison
+        # has to be exact.
+
+        if ((isinstance(l1, Real) and isinstance(l2, Real)) or
+            (isinstance(l1, Integer) and isinstance(l2, Integer))):
+                return l1 == l2
+
+        # For everything else, use sympy.
+
         l1_sympy = l1.to_sympy(evaluate=True, prec=COMPARE_PREC)
         l2_sympy = l2.to_sympy(evaluate=True, prec=COMPARE_PREC)
 
         if l1_sympy is None or l2_sympy is None:
             return None
 
-        if not hasattr(l1_sympy, "is_number"):
+
+        if not is_number(l1_sympy):
             l1_sympy = mp_convert_constant(l1_sympy, prec=COMPARE_PREC)
-        if not hasattr(l2_sympy, "is_number"):
+        if not is_number(l2_sympy):
             l2_sympy = mp_convert_constant(l2_sympy, prec=COMPARE_PREC)
 
+
         if l1_sympy.is_number and l2_sympy.is_number:
             # assert min_prec(l1, l2) is None
             prec = COMPARE_PREC  # TODO: Use $MaxExtraPrecision
@@ -254,8 +272,12 @@ def do_compare(self, l1, l2) -> Union[bool, None]:
     def apply(self, items, evaluation):
         "%(name)s[items___]"
         items_sequence = items.get_sequence()
-        if len(items_sequence) <= 1:
+        n = len(items_sequence)
+        if n <= 1:
             return SymbolTrue
+        is_exact_vals = [Expression("ExactNumberQ", arg).evaluate(evaluation) for arg in items_sequence]
+        if all(val == SymbolTrue for val in is_exact_vals):
+            return self.apply_other(items, evaluation)
         args = self.numerify_args(items, evaluation)
         wanted = operators[self.get_name()]
         for x, y in itertools.combinations(args, 2):
@@ -274,7 +296,7 @@ def apply(self, items, evaluation):
         return SymbolTrue
 
     def apply_other(self, args, evaluation):
-        "%(name)s[args___?(!RealNumberQ[#]&)]"
+        "%(name)s[args___?(!ExactNumberQ[#]&)]"
         args = args.get_sequence()
         for x, y in itertools.combinations(args, 2):
             c = self.do_compare(x, y)
@@ -285,6 +307,7 @@ def apply_other(self, args, evaluation):
         return SymbolTrue
 
 
+
 class _ComparisonOperator(_InequalityOperator):
     "Compares arguments in a chain e.g. a < b < c compares a < b and b < c."
 
@@ -355,7 +378,6 @@ def apply(self, items, evaluation):
             ]
             return Expression("And", *groups)
 
-
 def do_cmp(x1, x2) -> Optional[int]:
 
     # don't attempt to compare complex numbers
@@ -369,8 +391,10 @@ def do_cmp(x1, x2) -> Optional[int]:
     s1 = x1.to_sympy()
     s2 = x2.to_sympy()
 
-    # use internal comparisons only for Reals
-    # and use sympy for everything else
+    # Use internal comparisons only for Real which is uses
+    # WL's interpretation of equal (which allows for slop
+    # in the least significant digit of precision), and use
+    # use sympy for everything else
     if s1.is_Float and s2.is_Float:
         if x1 == x2:
             return 0
@@ -450,8 +474,9 @@ class Equal(_EqualityOperator, SympyComparison):
     ## TODO Needs power precision tracking
     ## >> 0.1 ^ 10000 == 0.1 ^ 10000 + 0.1 ^ 10012
     ##  = False
-    ## >> 0.1 ^ 10000 == 0.1 ^ 10000 + 0.1 ^ 10013
-    ##  = True
+
+    #> 0.1 ^ 10000 == 0.1 ^ 10000 + 0.1 ^ 10013
+      = True
 
     #> 0.1111111111111111 ==  0.1111111111111126
      = True

mathics/builtin/compilation.py

@@ -2,6 +2,7 @@
 
 from mathics.version import __version__  # noqa used in loading to check consistency.
 from mathics.builtin.base import Builtin, BoxConstruct
+from mathics.core.evaluation import Evaluation
 from mathics.core.expression import (
     Atom,
     Expression,
@@ -16,7 +17,7 @@
 
 
 class Compile(Builtin):
-    '''
+    """
     <dl>
     <dt>'Compile[{x1, x2, ...}, expr_]'
       <dd>Compiles $expr$ assuming each $xi$ is a $Real$ number.
@@ -64,7 +65,7 @@ class Compile(Builtin):
     functions
     >> Compile[{{a, _Integer}, {b, _Integer}}, While[b != 0, {a, b} = {b, Mod[a, b]}]; a]       (* GCD of a, b *)
      =  CompiledFunction[{a, b}, a, -PythonizedCode-]
-    '''
+    """
 
     requires = ("llvmlite",)
 
@@ -126,23 +127,25 @@ def apply(self, vars, expr, evaluation):
             cfunc = _compile(expr, args)
         except CompileError:
             cfunc = None
-        # llvm compilation failed. Try to pythonize it
+
         if cfunc is None:
             try:
+
                 def _pythonized_mathics_expr(*x):
                     inner_evaluation = Evaluation(definitions=evaluation.definitions)
-                    vars = dict(list(zip(names, x[:len(names)])))
+                    vars = dict(list(zip(names, x[: len(names)])))
                     pyexpr = expr.replace_vars(vars)
                     pyexpr = Expression("N", pyexpr).evaluate(inner_evaluation)
                     res = pyexpr.to_python(n_evaluation=inner_evaluation)
                     return res
-                #TODO: check if we can use numba to compile this...
+
+                # TODO: check if we can use numba to compile this...
                 cfunc = _pythonized_mathics_expr
             except Exception as e:
                 cfunc = None
-        # Pythonization failed. Show an error.
+
         if cfunc is None:
-            evaluation.message('Compile', 'comperr', expr)
+            evaluation.message("Compile", "comperr", expr)
             args = Expression("List", *names)
             return Expression("Function", args, expr)
 

mathics/builtin/constants.py

@@ -248,7 +248,7 @@ class Degree(MPMathConstant, NumpyConstant, SympyConstant):
     u"""
     <dl>
       <dt>'Degree'
-      <dd>is the number of radians in one degree. It hsas a numerical value of \u03c0 / 180.
+      <dd>is the number of radians in one degree. It has a numerical value of \u03c0 / 180.
     </dl>
     >> Cos[60 Degree]
      = 1 / 2