merge

Author: mmatera

CHANGES.rst

@@ -5,17 +5,20 @@ CHANGES
 2.1.1
 -----
 
-New builtins
-++++++++++++
+New variables and builtins
+++++++++++++++++++++++++++
 
 * ``Arg``
 * ``CoefficientArrays`` and ``Collect`` (#1174, #1194)
 * ``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``.
 
 
@@ -40,7 +43,7 @@ Enhancements
 * ``Table`` [*expr*, *n*] is supported.
 * ``ToString`` accepts an optional *form* parameter.
 * ``ToExpression`` handles multi-line string input.
-*  The implementation of Streams was redone.
+* The implementation of Streams was redone.
 
 
 Bug fixes

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

@@ -1859,109 +1859,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.

mathics/builtin/evaluation.py

@@ -317,145 +317,6 @@ class Sequence(Builtin):
     """
 
 
-class Line(Builtin):
-    """
-    <dl>
-    <dt>'$Line'
-        <dd>holds the current input line number.
-    </dl>
-    >> $Line
-     = 1
-    >> $Line
-     = 2
-    >> $Line = 12;
-    >> 2 * 5
-     = 10
-    >> Out[13]
-     = 10
-    >> $Line = -1;
-     : Non-negative integer expected.
-    """
-
-    name = "$Line"
-
-
-class HistoryLength(Builtin):
-    """
-    <dl>
-    <dt>'$HistoryLength'
-        <dd>specifies the maximum number of 'In' and 'Out' entries.
-    </dl>
-    >> $HistoryLength
-     = 100
-    >> $HistoryLength = 1;
-    >> 42
-     = 42
-    >> %
-     = 42
-    >> %%
-     = %3
-    >> $HistoryLength = 0;
-    >> 42
-     = 42
-    >> %
-     = %7
-    """
-
-    name = "$HistoryLength"
-
-    rules = {
-        "$HistoryLength": "100",
-    }
-
-
-class In(Builtin):
-    """
-    <dl>
-    <dt>'In[$k$]'
-        <dd>gives the $k$th line of input.
-    </dl>
-    >> x = 1
-     = 1
-    >> x = x + 1
-     = 2
-    >> Do[In[2], {3}]
-    >> x
-     = 5
-    >> In[-1]
-     = 5
-    >> Definition[In]
-     = Attributes[In] = {Listable, Protected}
-     .
-     . In[6] = Definition[In]
-     .
-     . In[5] = In[-1]
-     .
-     . In[4] = x
-     .
-     . In[3] = Do[In[2], {3}]
-     .
-     . In[2] = x = x + 1
-     .
-     . In[1] = x = 1
-    """
-
-    attributes = ("Listable", "Protected")
-
-    rules = {
-        "In[k_Integer?Negative]": "In[$Line + k]",
-    }
-
-
-class Out(Builtin):
-    """
-    <dl>
-    <dt>'Out[$k$]'
-    <dt>'%$k$'
-        <dd>gives the result of the $k$th input line.
-    <dt>'%', '%%', etc.
-        <dd>gives the result of the previous input line, of the line before the previous input line, etc.
-    </dl>
-
-    >> 42
-     = 42
-    >> %
-     = 42
-    >> 43;
-    >> %
-     = 43
-    >> 44
-     = 44
-    >> %1
-     = 42
-    >> %%
-     = 44
-    >> Hold[Out[-1]]
-     = Hold[%]
-    >> Hold[%4]
-     = Hold[%4]
-    >> Out[0]
-     = Out[0]
-
-    #> 10
-     = 10
-    #> Out[-1] + 1
-     = 11
-    #> Out[] + 1
-     = 12
-    """
-
-    attributes = ("Listable", "Protected")
-
-    rules = {
-        "Out[k_Integer?Negative]": "Out[$Line + k]",
-        "Out[]": "Out[$Line - 1]",
-        "MakeBoxes[Out[k_Integer?((-10 <= # < 0)&)],"
-        "    f:StandardForm|TraditionalForm|InputForm|OutputForm]": r'StringJoin[ConstantArray["%%", -k]]',
-        "MakeBoxes[Out[k_Integer?Positive],"
-        "    f:StandardForm|TraditionalForm|InputForm|OutputForm]": r'"%%" <> ToString[k]',
-    }
-
-
 class Quit(Builtin):
     """
     <dl>

mathics/builtin/files_io/__init__.py

@@ -0,0 +1,5 @@
+"""
+Input/Output, Files, and Filesystem
+"""
+
+from mathics.version import __version__  # noqa used in loading to check consistency.