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

Author: mmatera

CHANGES.rst

@@ -4,17 +4,81 @@ 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.
+
+
+Incompatible changes:
++++++++++++++++++++++
+
+* `-e` `--execute` is better suited for embedded use. It shows just evaluation output as text.
+
 
 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
 ----------------
@@ -32,6 +96,14 @@ Enhancements and Bug fixes:
 - Set the numeric threshold in PossibleZeroQ  to 10^(-10), for compatibility with ``System`Chop``.
 - Catch possible exceptions generated by ``$UserName``.
 
+
+Miscelanea
+----------
+
+- Enlarge of the set of gries_schneider tests
+- Improvement in the way builtins modules are loaded at initialization time (#1138).
+
+
 1.1.1
 -----
 
@@ -51,7 +123,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.
@@ -93,7 +165,7 @@ New builtins:
 - Adding support in ``from_python()`` to convert dictionaries in list of rules.
 - Fix OptionsPattern associated symbols.
 
-  
+
 1.1.0
 -----
 

mathics/builtin/__init__.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
+from mathics.core.expression import ensure_context
 
 import glob
 import importlib
@@ -71,7 +72,10 @@ def is_builtin(var):
             instance = var(expression=False)
 
             if isinstance(instance, Builtin):
-                builtins.append((instance.get_name(), instance))
+                # This set the default context for symbols in mathics.builtins
+                if not type(instance).context:
+                    type(instance).context = "System`"
+                builtins.append( (instance.get_name(), instance))
                 builtins_by_module[module.__name__].append(instance)
 
 

mathics/builtin/assignment.py

@@ -1748,20 +1748,17 @@ def apply(self, module, evaluation):
         except ImportError as e:
             evaluation.message(self.get_name(), 'notfound', module)
             return SymbolFailed
-        except PyMathicsLoadException as e:
-            evaluation.message(self.get_name(), 'notmathicslib', module)
-            return SymbolFailed
-        else:
-            # Add PyMathics` to $ContextPath so that when user don't
-            # have to qualify PyMathics variables and functions,
-            # as the those in the module just loaded.
-
-            # Following the example of $ContextPath in the WL
-            # reference manual where PackletManager appears first in
-            # the list, it seems to be preferable to add this PyMathics
-            # at the beginning.
-            context_path = evaluation.definitions.get_context_path()
-            if "PyMathics`" not in context_path:
-                context_path.insert(0, "PyMathics`")
-            evaluation.definitions.set_context_path(context_path)
+
+        # Add PyMathics` to $ContextPath so that when user don't
+        # have to qualify PyMathics variables and functions,
+        # as the those in the module just loaded.
+        # Following the example of $ContextPath in the WL
+        # reference manual where PackletManager appears first in
+        # the list, it seems to be preferable to add this PyMathics
+        # at the beginning.
+        context_path = evaluation.definitions.get_context_path()
+        if "PyMathics`" not in context_path:
+            context_path.insert(0, "PyMathics`")
+        evaluation.definitions.set_context_path(context_path)
+        
         return module

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
 
 
@@ -60,7 +57,7 @@ def has_option(options, name, evaluation):
 
 class Builtin(object):
     name: typing.Optional[str] = None
-    context = "System`"
+    context = ""
     abstract = False
     attributes: typing.Tuple[Any, ...] = ()
     rules: typing.Dict[str, Any] = {}
@@ -87,11 +84,11 @@ def __init__(self, *args, **kwargs):
 
     def contribute(self, definitions, is_pymodule=False):
         from mathics.core.parser import parse_builtin_rule
+        # Set the default context
+        if not self.context:
+            self.context = "Pymathics`" if is_pymodule else "System`"
 
-        if is_pymodule:
-            name = "PyMathics`" + self.get_name(short=True)
-        else:
-            name = self.get_name()
+        name = self.get_name()
 
         options = {}
         option_syntax = "Warn"
@@ -317,7 +314,7 @@ def get_functions(self, prefix="apply", is_pymodule=False):
                 else:
                     attrs = []
                 if is_pymodule:
-                    name = "PyMathics`" + self.get_name(short=True)
+                    name = ensure_context(self.get_name(short=True), "Pymathics")
                 else:
                     name = self.get_name()
 
@@ -768,3 +765,4 @@ def from_expression(expr):
                             return CountableInteger(0, upper_limit=True)
 
         return None  # leave original expression unevaluated
+

mathics/builtin/files.py

@@ -3813,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"]
@@ -3841,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:
@@ -3866,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):
@@ -4802,6 +4805,7 @@ def apply(self, pathname, evaluation):
             return SymbolTrue
         return SymbolFalse
 
+
 class Needs(Builtin):
     """
     <dl>
@@ -4921,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, '`')
@@ -4931,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
+

mathics/builtin/functional.py

@@ -19,6 +19,8 @@ class Function(PostfixOperator):
         <dd>represents a pure function with parameters '#1', '#2', etc.
     <dt>'Function[{$x1$, $x2$, ...}, $body$]'
         <dd>represents a pure function with parameters $x1$, $x2$, etc.
+    <dt>'Function[{$x1$, $x2$, ...}, $body$, $attr$]'
+        <dd>assume that the function has the attributes $attr$.
     </dl>
 
     >> f := # ^ 2 &
@@ -87,6 +89,22 @@ def apply_named(self, vars, body, args, evaluation):
                 var.get_name() for var in vars), args[:len(vars)])))
             return body.replace_vars(vars)
 
+    # Not sure if DRY is possible here...
+    def apply_named_attr(self, vars, body, attr, args, evaluation):
+        'Function[vars_, body_, attr_][args___]'
+        if vars.has_form('List', None):
+            vars = vars.leaves
+        else:
+            vars = [vars]
+
+        args = args.get_sequence()        
+        if len(vars) > len(args):
+            evaluation.message('Function', 'fpct', )
+        else:
+            vars = dict(list(zip((
+                var.get_name() for var in vars), args[:len(vars)])))
+            return body.replace_vars(vars)
+
 
 class Slot(Builtin):
     """

mathics/builtin/importexport.py

@@ -228,6 +228,34 @@ class ExportFormats(Predefined):
     def evaluate(self, evaluation):
         return Expression('List', *sorted(EXPORTERS.keys()))
 
+class ConverterDumpsExtensionMappings(Predefined):
+    """
+    <dl>
+    <dt>'$extensionMappings'
+        <dd>Returns a list of associations between file extensions and file types.
+    </dl>
+    """
+    context = 'System`ConvertersDump`'
+    name = "$extensionMappings"
+    attributes = ['Unprotected']
+
+    def evaluate(self, evaluation):
+        return from_python(EXTENSIONMAPPINGS)
+
+
+class ConverterDumpsFormatMappings(Predefined):
+    """
+    <dl>
+    <dt>'$formatMappings'
+        <dd>Returns a list of associations between file extensions and file types.
+    </dl>
+    """
+    context = 'System`ConvertersDump`'
+    name = "$formatMappings"
+    attributes = ['Unprotected']
+    def evaluate(self, evaluation):
+        return from_python(FORMATMAPPINGS)
+
 
 class ConverterDumpsExtensionMappings(Predefined):
     """