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

Author: mmatera

CHANGES.rst

@@ -5,16 +5,19 @@ CHANGES
 2.1.1
 -----
 
-New builtins
-++++++++++++
+New variables and builtins
+++++++++++++++++++++++++++
 
 * ``Arg``
 * ``Dispatch``
 * ``FullSimplify``
 * ``LetterNumber`` #1298. The ``alphabet`` parameter supports only a minimal number of languages.
+* ``MemoryAvailable``
+* ``MemoryInUse``
 * ``Nand`` and ``Nor`` logical functions.
 * ``Series``,  ``O`` and ``SeriesData``
 * ``StringReverse``
+* ``$SystemMemory``
 * Add all of the named colors, e.g. ``Brown`` or ``LighterMagenta``.
 
 
@@ -28,7 +31,7 @@ Enhancements
 * ``D`` and ``Derivative`` improvements.
 * ``FileNames`` returns a sorted list (#1250).
 * ``FindRoot`` now receives several optional parameters like ``Method`` and ``MaxIterations``.
-* ``FixedPoint`` now supports the ``SameTest`` option.  
+* ``FixedPoint`` now supports the ``SameTest`` option.
 * ``Prime`` and ``PrimePi`` now accept a list parameter and have the ``NumericFunction`` attribute.
 * ``ReplaceRepeated`` and ``FixedPoint`` now supports the ``MaxIteration`` option (#1260).
 * ``Simplify`` performs a more sophisticated set of simplifications.
@@ -38,7 +41,7 @@ Enhancements
 * ``ToString`` accepts an optional *form* parameter.
 * ``ToExpression`` handles multi-line string input
 * The implementation of Streams was redone.
-  
+
 
 
 Bug fixes
@@ -54,7 +57,7 @@ Internal changes
 ----------------
 
 * doctest  accepts the option `-d` to show how long it takes to parse, evaluate and compare each individual test.
-  
+
 
 2.1.0
 -----

mathics/builtin/__init__.py

@@ -85,26 +85,37 @@ def get_module_doc(module):
     return title, text
 
 def import_builtins(module_names: List[str], submodule_name=None) -> None:
-    for module_name in module_names:
-        import_name = (
-            f"mathics.builtin.{submodule_name}.{module_name}"
-            if submodule_name
-            else f"mathics.builtin.{module_name}"
-        )
+    """
+    Imports the list of Mathics Built-in modules so that inside
+    Mathics we have these Builtin Functions, like Plus[], List[] are defined.
+
+    """
+    def import_module(module_name: str, import_name: str):
         try:
             module = importlib.import_module(import_name)
         except Exception as e:
             print(e)
             print(f"    Not able to load {module_name}. Check your installation.")
             print(f"    mathics.builtin loads from {__file__[:-11]}")
-            continue
+            return None
 
         if __version__ != module.__version__:
             print(
-                f"Version {module.__version__} in the module do not match with {__version__}"
+                f"Version {module.__version__} in the module does not match top-level Mathics version {__version__}"
             )
+        if module:
+            modules.append(module)
 
-        modules.append(module)
+    if submodule_name:
+        import_module(submodule_name, f"mathics.builtin.{submodule_name}")
+
+    for module_name in module_names:
+        import_name = (
+            f"mathics.builtin.{submodule_name}.{module_name}"
+            if submodule_name
+            else f"mathics.builtin.{module_name}"
+        )
+        import_module(module_name, import_name)
 
 
 def is_builtin(var):
@@ -116,22 +127,25 @@ def is_builtin(var):
 
 
 # FIXME: redo using importlib since that is probably less fragile.
-exclude_files = set(("files", "codetables", "base", "importexport", "colors"))
+exclude_files = set(("codetables", "base"))
 module_names = [
     f for f in __py_files__ if re.match("^[a-z0-9]+$", f) if f not in exclude_files
 ]
 
-if ENABLE_FILES_MODULE:
-    module_names += ["files", "importexport"]
-
 modules = []
 import_builtins(module_names)
 
 _builtins = []
 builtins_by_module = {}
 
-for subdir in ("drawing", "numbers", "specialfns",):
+disable_file_module_names = [] if ENABLE_FILES_MODULE else ["files_io.files", "files_io.importexport"]
+
+for subdir in ("drawing", "files_io", "numbers", "specialfns",):
     import_name = f"{__name__}.{subdir}"
+
+    if import_name in disable_file_module_names:
+        continue
+
     builtin_module = importlib.import_module(import_name)
     submodule_names = [
         modname

mathics/builtin/arithmetic.py

@@ -1858,109 +1858,6 @@ class Factorial(PostfixOperator, _MPMathFunction):
     precedence = 610
     mpmath_name = "factorial"
 
-
-class Gamma(_MPMathMultiFunction):
-    """
-    <dl>
-    <dt>'Gamma[$z$]'
-        <dd>is the gamma function on the complex number $z$.
-    <dt>'Gamma[$z$, $x$]'
-        <dd>is the upper incomplete gamma function.
-    <dt>'Gamma[$z$, $x0$, $x1$]'
-        <dd>is equivalent to 'Gamma[$z$, $x0$] - Gamma[$z$, $x1$]'.
-    </dl>
-
-    'Gamma[$z$]' is equivalent to '($z$ - 1)!':
-    >> Simplify[Gamma[z] - (z - 1)!]
-     = 0
-
-    Exact arguments:
-    >> Gamma[8]
-     = 5040
-    >> Gamma[1/2]
-     = Sqrt[Pi]
-    >> Gamma[1, x]
-     = E ^ (-x)
-    >> Gamma[0, x]
-     = ExpIntegralE[1, x]
-
-    Numeric arguments:
-    >> Gamma[123.78]
-     = 4.21078*^204
-    >> Gamma[1. + I]
-     = 0.498016 - 0.15495 I
-
-    Both 'Gamma' and 'Factorial' functions are continuous:
-    >> Plot[{Gamma[x], x!}, {x, 0, 4}]
-     = -Graphics-
-
-    ## Issue 203
-    #> N[Gamma[24/10], 100]
-     = 1.242169344504305404913070252268300492431517240992022966055507541481863694148882652446155342679460339
-    #> N[N[Gamma[24/10],100]/N[Gamma[14/10],100],100]
-     = 1.400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
-    #> % // Precision
-     = 100.
-
-    #> Gamma[1.*^20]
-     : Overflow occurred in computation.
-     = Overflow[]
-
-    ## Needs mpmath support for lowergamma
-    #> Gamma[1., 2.]
-     = Gamma[1., 2.]
-    """
-
-    mpmath_names = {
-        1: "gamma",
-    }
-    sympy_names = {
-        1: "gamma",
-        2: "uppergamma",
-    }
-
-    rules = {
-        "Gamma[z_, x0_, x1_]": "Gamma[z, x0] - Gamma[z, x1]",
-        "Gamma[1 + z_]": "z!",
-        "Derivative[1][Gamma]": "(Gamma[#1]*PolyGamma[0, #1])&",
-        "Derivative[1, 0][Gamma]": "(Gamma[#1, #2]*Log[#2] + MeijerG[{{}, {1, 1}}, {{0, 0, #1}, {}}, #2])&",
-        "Derivative[0, 1][Gamma]": "(-(#2^(-1 + #1)/E^#2))&",
-    }
-
-    def get_sympy_names(self):
-        return ["gamma", "uppergamma", "lowergamma"]
-
-    def from_sympy(self, sympy_name, leaves):
-        if sympy_name == "lowergamma":
-            # lowergamma(z, x) -> Gamma[z, 0, x]
-            z, x = leaves
-            return Expression(self.get_name(), z, Integer0, x)
-        else:
-            return Expression(self.get_name(), *leaves)
-
-
-class Pochhammer(SympyFunction):
-    """
-    <dl>
-    <dt>'Pochhammer[$a$, $n$]'
-        <dd>is the Pochhammer symbol (a)_n.
-    </dl>
-
-    >> Pochhammer[4, 8]
-     = 6652800
-    """
-
-    attributes = ("Listable", "NumericFunction", "Protected")
-
-    sympy_name = "RisingFactorial"
-
-    rules = {
-        "Pochhammer[a_, n_]": "Gamma[a + n] / Gamma[a]",
-        "Derivative[1,0][Pochhammer]": "(Pochhammer[#1, #2]*(-PolyGamma[0, #1] + PolyGamma[0, #1 + #2]))&",
-        "Derivative[0,1][Pochhammer]": "(Pochhammer[#1, #2]*PolyGamma[0, #1 + #2])&",
-    }
-
-
 class HarmonicNumber(_MPMathFunction):
     """
     <dl>

mathics/builtin/drawing/__init__.py

@@ -1,3 +1,25 @@
 """
 Graphics, Drawing, and Images
+
+Functions like 'Plot' and 'ListPlot' can be used to draw graphs of functions and data.
+
+Graphics is implemented as a collection of <i>graphics primitives</i>. Primatives are objects like 'Point', 'Line', and 'Polygon' and become elements of a <i>graphics object</i>.
+
+A graphics object can have directives as well such as 'RGBColor', and 'Thickness'.
+
+There are several kinds of graphics objects; each kind has a head which identifies its type.
+
+>> ListPlot[ Table[Prime[n], {n, 20} ]]
+ = -Graphics-
+>> Head[%]
+ = Graphics
+>> Graphics3D[Sphere[]]
+ = -Graphics3D-
+>> Head[%]
+ = Graphics3D
+>>
+
+
 """
+
+from mathics.version import __version__  # noqa used in loading to check consistency.