merge master

Author: mmatera

.github/workflows/osx.yml

@@ -24,10 +24,9 @@ jobs:
         brew install llvm@9
         python -m pip install --upgrade pip
         LLVM_CONFIG=/usr/local/Cellar/llvm@9/9.0.1_2/bin/llvm-config pip install llvmlite
-        python -m pip install -e git://github.com/Mathics3/mathics-scanner.git#egg=Mathics_Scanner
     - name: Install Mathics
       run: |
-        make
+        make develop
     - name: Test Mathics
       run: |
         pip install pytest pexpect

.github/workflows/ubuntu.yml

@@ -22,11 +22,10 @@ jobs:
       run: |
         sudo apt-get update -qq && sudo apt-get install -qq liblapack-dev llvm-dev
         python -m pip install --upgrade pip
-        python -m pip install -e git://github.com/Mathics3/mathics-scanner.git#egg=Mathics_Scanner
     - name: Install Mathics
       run: |
         sed -i "s/'sympy==[0-9]\.[0-9]\.[0-9]', //" setup.py
-        make
+        make develop
     - name: Test Mathics
       run: |
         pip install pytest pexpect

.travis.yml

@@ -19,7 +19,6 @@ before_install:
   - pip install ipywidgets ipykernel requests IPython==5.0.0 langid pycountry pyenchant lxml matplotlib unittest2 pexpect
   - python travis.py
   - pip install cython
-  - pip install -e git://github.com/Mathics3/mathics-scanner.git#egg=Mathics_Scanner
 install:
   - sed -i "s/'sympy==[0-9]\.[0-9]\.[0-9]', //" setup.py
   - make develop

CHANGES.rst

@@ -4,17 +4,77 @@ CHANGES
 2.0.0
 -----
 
-The Django front-end has been unbundled and is a separate `PyPI installable package <https://pypi.org/project/Mathics-Django/>`_.
+In order to accomdate growth and increase use pieces of Mathics inside other packages, some parts of
+Mathics have been split off and moved to separately installable packages. In particular:
+
+* The Django front-end `PyPI installable package <https://pypi.org/project/Mathics-Django/>`_.
+* Scanner routines and character translations tables to/from unicode and noting some character properties
+* Specific builtins involving heavy, non-standard routines were moved to pymathics modules.
+
+
+
 
 New builtins
-++++++++++++++
+++++++++++++
 
 - ``TimeRemaining`` and ``TimeConstrained``
 -``MathicsVersion`` (this is not in WL)
 - ``\[RadicalBox]``
-- ``FirstCase``, ``Lookup``
-- ``Catalan``, ``LerchPhi``
-- ``System`ConvertersDump`` context variables 
+- ``ContinuedFraction``
+- ``Insert`` and ``Delete``
+- ``FirstCase``, ``Lookup``, ``Key``, ``Lookup`` and ``Failure``
+- ``ConvertCommonDumpRemoveLinearSyntax`` and ``System`ConvertersDump`` context variables
+- ``PossibleZeroQ`` PR #1100
+- ``Run``
+- ``SympyObject``
+- ``NumberQ``
+- ``AnglePath``,  ``AnglePathFold``, ``AngleVector``
+- ``Haversine``, ``InverseHaversine``
+- ``Show``
+-  Improving support for options in the Plot module: ``Axes``, ``Filling``, ``ImageSize``, ``Joined``
+- ``BoxData``, ``TextData``, ``InterpretationBox``, ``StyleBox``, ``TagBox``, ``TemplateBox``, ``ButtonBox``, ``InterpretationBox``
+- ``LerchPhi``
+
+New Constants
++++++++++++++
+
+Mathematical Constants is now its own module/section. Contants have been filled out.
+These constants have been added:
+
+- ``Catalan``
+- ``Glaisher``
+- ``Khinchin``
+- ``Degree``
+- ``GoldenRatio``
+- ``Khinchin``
+
+
+Many of these and the existing constants are computable via mpmath, numpy, or sympy.
+
+
+Settings through WL variables
+-----------------------------
+
+Certain aspects of the configuration of the kernel are now controlled by variables, defined in /autoad/settings.m
+
+- ``$GetTrace`` (``False`` by default).  Defines if when a WL module is load through ``Get``, definitions will be traced (for debug).
+-  ``$PreferredBackendMethod`` Set this do whether to use mpmath, numpy or Sympy for numeric and symbolic constants and methods when there is s choice (``"sympy"`` by default) (see #1124)
+
+
+Enhancements
+------------
+
+- Add ``Method`` option "mpmath" to compute ``Eignevalues`` using mpmath (#1115).
+- Improving the support for OptionValue and OptionsPattern (#1113)
+
+
+Bug Fixes
+---------
+
+There have been numerous bug is driven by working on Combinatorica V0.9 and CellsToTeX.
+
+- ``Sum`` involving numeric integer bounds involving Mathics functions fixed.
+- ``Equal`` ``UnEqual`` testing on Strings (#1128).
 
 Document updates
 ----------------
@@ -29,6 +89,14 @@ Enhancements and Bug fixes:
 - ``Sum``'s lower and upper bounds values can now be Mathics expressions
 
 
+
+Miscelanea
+----------
+
+- Enlarge of the set of gries_schneider tests
+- Improvement in the way builtins modules are loaded at initialization time (#1138).
+
+
 1.1.1
 -----
 
@@ -48,7 +116,7 @@ Package Updates
 
 Mathics Packages added:
 
-- ``DiscreteMath`CombinatoricaV0.9`` (preferred) aand
+- ``DiscreteMath`CombinatoricaV0.9`` (preferred) and
   ``DiscreteMath`CombinatoricaV0.6``.
 
 Both of these correspond to Steven Skiena's *older* book: "Implementing Discrete Mathematics: Combinatorics and Graph Theory" book.
@@ -90,7 +158,7 @@ New builtins:
 - Adding support in ``from_python()`` to convert dictionaries in list of rules.
 - Fix OptionsPattern associated symbols.
 
-  
+
 1.1.0
 -----
 

examples/symbolic_logic/gries_schneider/test_gs.py

@@ -6,14 +6,12 @@
 from mathics.core.expression import Expression, Integer, Rational, Symbol
 from mathics.core.definitions import Definitions
 from mathics.core.evaluation import Evaluation
-from mathics.core.parser import SingleLineFeeder, parse
+from mathics.core.parser import MathicsSingleLineFeeder, parse
 
 definitions = Definitions(add_builtin=True)
 
 for i in range(1, 4):
   evaluation = Evaluation(definitions=definitions, catch_interrupt=False)
 
-  expr = parse(definitions, SingleLineFeeder(f"<< GS{i}.m"))
+  expr = parse(definitions, MathicsSingleLineFeeder(f"<< GS{i}.m"))
   expr.evaluate(evaluation)
-
-

mathics/benchmark.py

@@ -15,7 +15,7 @@
 
 
 import mathics
-from mathics.core.parser import parse, MultiLineFeeder, SingleLineFeeder
+from mathics.core.parser import parse, MathicsMultiLineFeeder, MathicsSingleLineFeeder
 from mathics.core.definitions import Definitions
 from mathics.core.evaluation import Evaluation
 
@@ -126,7 +126,7 @@ def truncate_line(string):
 
 def benchmark_parse(expression_string):
     print("  '{0}'".format(truncate_line(expression_string)))
-    timeit(lambda: parse(definitions, SingleLineFeeder(expression_string)))
+    timeit(lambda: parse(definitions, MathicsSingleLineFeeder(expression_string)))
 
 
 def benchmark_parse_file(fname):
@@ -140,7 +140,7 @@ def benchmark_parse_file(fname):
         code = f.read().decode('utf-8')
 
     def do_parse():
-        feeder = MultiLineFeeder(code)
+        feeder = MathicsMultiLineFeeder(code)
         while not feeder.empty():
             parse(definitions, feeder)
     timeit(do_parse)
@@ -156,13 +156,13 @@ def benchmark_parser():
 
 def benchmark_format(expression_string):
     print("  '{0}'".format(expression_string))
-    expr = parse(definitions, SingleLineFeeder(expression_string))
+    expr = parse(definitions, MathicsSingleLineFeeder(expression_string))
     timeit(lambda: expr.default_format(evaluation, "FullForm"))
 
 
 def benchmark_expression(expression_string):
     print("  '{0}'".format(expression_string))
-    expr = parse(definitions, SingleLineFeeder(expression_string))
+    expr = parse(definitions, MathicsSingleLineFeeder(expression_string))
     timeit(lambda: expr.evaluate(evaluation))
 
 

mathics/builtin/arithmetic.py

@@ -1346,6 +1346,11 @@ def apply(self, expr, evaluation):
 
         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)        
         if result is None:
             # Can't get exact answer, so try approximate equal
             numeric_val = Expression("N", expr).evaluate(evaluation)

mathics/builtin/base.py

@@ -34,20 +34,17 @@ def get_option(options, name, evaluation, pop=False, evaluate=True):
     # matter. Also, the quoted string form "X" is ok. all these
     # variants name the same option. this matches Wolfram Language
     # behaviour.
-
+    name = strip_context(name)
     contexts = (s + "%s" for s in evaluation.definitions.get_context_path())
 
     for variant in chain(contexts, ('"%s"',)):
         resolved_name = variant % name
-
         if pop:
             value = options.pop(resolved_name, None)
         else:
             value = options.get(resolved_name)
-
         if value is not None:
             return value.evaluate(evaluation) if evaluate else value
-
     return None
 
 

mathics/builtin/evaluation.py

@@ -110,11 +110,12 @@ class IterationLimit(Predefined):
      = $Aborted
     #> ClearAll[f];
 
-    #> ClearAll[f];
-    #> f[x_, 0] := x; f[x_, n_] := Module[{y = x + 1}, f[y, n - 1]];
-    #> Block[{$IterationLimit = 20}, f[0, 100]]
-     = 100
-    #> ClearAll[f];
+    # FIX Later
+    # #> ClearAll[f];
+    # #> f[x_, 0] := x; f[x_, n_] := Module[{y = x + 1}, f[y, n - 1]];
+    # #> Block[{$IterationLimit = 20}, f[0, 100]]
+    #  = 100
+    # #> ClearAll[f];
     """
 
     name = "$IterationLimit"

mathics/builtin/files.py

@@ -23,7 +23,8 @@
 import os.path as osp
 from itertools import chain
 
-from mathics_scanner import TranslateError, FileLineFeeder
+from mathics_scanner import TranslateError
+from mathics.core.parser import MathicsFileLineFeeder
 
 from mathics.core.expression import (
     Expression,
@@ -2183,7 +2184,7 @@ def check_options(options):
             if trace_fn:
                 trace_fn(pypath)
             with mathics_open(pypath, "r") as f:
-                feeder = FileLineFeeder(f, trace_fn)
+                feeder = MathicsFileLineFeeder(f, trace_fn)
                 while not feeder.empty():
                     try:
                         query = parse(definitions, feeder)
@@ -3812,6 +3813,8 @@ class FileHash(Builtin):
     <dt>'FileHash[$file$, $type$]'
       <dd>returns an integer hash of the specified $type$ for the given $file$.</dd>
       <dd>The types supported are "MD5", "Adler32", "CRC32", "SHA", "SHA224", "SHA256", "SHA384", and "SHA512".</dd>
+    <dt>'FileHash[$file$, $type$, $format$]'
+      <dd>gives a hash code in the specified format.</dd>
     </dl>
 
     >> FileHash["ExampleData/sunflowers.jpg"]
@@ -3840,19 +3843,20 @@ class FileHash(Builtin):
     #> FileHash["ExampleData/sunflowers.jpg", xyzsymbol]
      = FileHash[ExampleData/sunflowers.jpg, xyzsymbol]
     #> FileHash["ExampleData/sunflowers.jpg", "xyzstr"]
-     = FileHash[ExampleData/sunflowers.jpg, xyzstr]
+     = FileHash[ExampleData/sunflowers.jpg, xyzstr, Integer]
     #> FileHash[xyzsymbol]
      = FileHash[xyzsymbol]
     """
 
     rules = {
-        "FileHash[filename_String]": 'FileHash[filename, "MD5"]',
+        "FileHash[filename_String]": 'FileHash[filename, "MD5", "Integer"]',
+        "FileHash[filename_String, hashtype_String]": 'FileHash[filename, hashtype, "Integer"]',
     }
 
     attributes = ("Protected", "ReadProtected")
 
-    def apply(self, filename, hashtype, evaluation):
-        "FileHash[filename_String, hashtype_String]"
+    def apply(self, filename, hashtype, format, evaluation):
+        "FileHash[filename_String, hashtype_String, format_String]"
         py_filename = filename.get_string_value()
 
         try:
@@ -3865,7 +3869,7 @@ def apply(self, filename, hashtype, evaluation):
             e.message(evaluation)
             return
 
-        return Hash.compute(lambda update: update(dump), hashtype.get_string_value())
+        return Hash.compute(lambda update: update(dump), hashtype.get_string_value(), format.get_string_value())
 
 
 class FileDate(Builtin):
@@ -4801,6 +4805,7 @@ def apply(self, pathname, evaluation):
             return SymbolTrue
         return SymbolFalse
 
+
 class Needs(Builtin):
     """
     <dl>
@@ -4920,7 +4925,6 @@ def apply(self, context, evaluation):
             curr_ctxt = evaluation.definitions.get_current_context()
             contextstr = curr_ctxt + contextstr[1:]
             context = String(contextstr)
-
         if not valid_context_name(contextstr):
             evaluation.message('Needs', 'ctx', Expression(
                 'Needs', context), 1, '`')
@@ -4930,19 +4934,11 @@ def apply(self, context, evaluation):
         if test_loaded.is_true():
             # Already loaded
             return SymbolNull
-
-        # TODO: Figure out why this raises the message:
-        # "Select::normal: Nonatomic expression expected."
-        already_loaded = Expression('MemberQ',
-                                    Symbol('System`$Packages'), context)
-        already_loaded = already_loaded.evaluate(evaluation).is_true()
-        if already_loaded:
-           return SymbolNull
-
         result = Expression('Get', context).evaluate(evaluation)
 
         if result == SymbolFailed:
             evaluation.message("Needs", "nocont", context)
             return SymbolFailed
 
         return SymbolNull
+