basic implementation of NIntegrate

CHANGES.rst

@@ -4,23 +4,45 @@ CHANGES
 2.1.0
 -----
 
-  New builtins
-++++++++++++++
+New builtins
+++++++++++++
 
+* ``ArcTanh``
 * ``ByteArray``
-* ``FileNames``
 * ``CreateFile``
 * ``CreateTemporary``
-
+* ``FileNames``
+* ``NIntegrate``
 
 Enhancements
 ++++++++++++
 
+* the Mathics version is checked for builtin modules at load time. A message is given when a builtin doesn't load.
+* Automatic detection for the best strategy to numeric evaluation of constants.
 * ``FileNameJoin`` - implement ``OperatingSystem`` option
 * Mathics functions are accepted by ``Compile[]``. The return value or type will be
-  ``CompiledFunction``
+  ``Compiled[] and CompiledFunction[]``  every expression can have a compiled form,
+  as a Python function.
 * ``EqualQ[]`` now compares complex against other numbers properly.
 
+
+Bug fixes
++++++++++
+
+* TeXForm for integrals are now properly formatted.
+
+
+Pymathics Modules
++++++++++++++++++
+
+* Pymathics modules now can run initialization code when are loaded.
+* The ``builtins`` list is not hardliked to the library anymore. This simplifies
+  the loading and reloading of pymathics modules.
+* Decoupling of BoxConstructors from the library. Now are defined at the
+  level of the definition objects. This is useful for customizing the
+  Graphics output if it is available.
+
+
 Miscellanea
 +++++++++++
 

mathics/builtin/compilation.py

@@ -1,5 +1,6 @@
 import ctypes
 
+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 (
@@ -10,7 +11,7 @@
     from_python,
     Integer,
 )
-from mathics.version import __version__  # noqa used in loading to check consistency.
+from types import FunctionType
 
 
 class Compile(Builtin):
@@ -42,7 +43,7 @@ class Compile(Builtin):
      : Duplicate parameter x found in {{x, _Real}, {x, _Integer}}.
      = Compile[{{x, _Real}, {x, _Integer}}, Sin[x + y]]
     #> cf = Compile[{{x, _Real}, {y, _Integer}}, Sin[x + z]]
-     = CompiledFunction[{x, y}, Sin[x + z], -CompiledCode-]
+     = CompiledFunction[{x, y}, Sin[x + z], -PythonizedCode-]
     #> cf = Compile[{{x, _Real}, {y, _Integer}}, Sin[x + y]]
      = CompiledFunction[{x, y}, Sin[x + y], -CompiledCode-]
     #> cf[1, 2]
@@ -61,7 +62,7 @@ class Compile(Builtin):
     Loops and variable assignments are supported as python (not llvmlite)
     functions
     >> Compile[{{a, _Integer}, {b, _Integer}}, While[b != 0, {a, b} = {b, Mod[a, b]}]; a]       (* GCD of a, b *)
-     = CompiledFunction[{a, b}, a, -CompiledCode-]
+     =  CompiledFunction[{a, b}, a, -PythonizedCode-]
     """
 
     requires = ("llvmlite",)
@@ -138,7 +139,7 @@ def _pythonized_mathics_expr(*x):
 
                 # TODO: check if we can use numba to compile this...
                 cfunc = _pythonized_mathics_expr
-            except Exception as e:
+            except Exception:
                 cfunc = None
 
         if cfunc is None:
@@ -158,6 +159,8 @@ def __init__(self, cfunc, args, **kwargs):
         self.args = args
 
     def __str__(self):
+        if type(self.cfunc) is FunctionType:
+            return "-PythonizedCode-"
         return "-CompiledCode-"
 
     def do_copy(self):
@@ -182,7 +185,7 @@ def __hash__(self):
         return hash(("CompiledCode", ctypes.addressof(self.cfunc)))  # XXX hack
 
     def atom_to_boxes(self, f, evaluation):
-        return CompiledCodeBox(String("Nocode"), evaluation=evaluation)
+        return CompiledCodeBox(String(self.__str__()), evaluation=evaluation)
 
 
 class CompiledCodeBox(BoxConstruct):
@@ -191,19 +194,19 @@ class CompiledCodeBox(BoxConstruct):
     """
 
     def boxes_to_text(self, leaves=None, **options):
-        if not leaves:
+        if leaves is None:
             leaves = self._leaves
-        return "-CompiledCode-"
+        return leaves[0].value
 
     def boxes_to_xml(self, leaves=None, **options):
-        if not leaves:
+        if leaves is None:
             leaves = self._leaves
-        return "-CompiledCode-"
+        return leaves[0].value
 
     def boxes_to_tex(self, leaves=None, **options):
-        if not leaves:
+        if leaves is None:
             leaves = self._leaves
-        return "-CompiledCode-"
+        return leaves[0].value
 
 
 class CompiledFunction(Builtin):

mathics/builtin/exptrig.py

@@ -545,6 +545,7 @@ class ArcTanh(_MPMathFunction):
 
     sympy_name = "atanh"
     mpmath_name = "atanh"
+    numpy_name = "arctanh"
 
     rules = {
         "Derivative[1][ArcTanh]": "1/(1-#^2)&",

mathics/builtin/functional.py

@@ -56,61 +56,68 @@ class Function(PostfixOperator):
      = 3
     """
 
-    operator = '&'
+    operator = "&"
     precedence = 90
-    attributes = ('HoldAll',)
+    attributes = ("HoldAll",)
 
     messages = {
-        'slot': "`1` should contain a positive integer.",
-        'slotn': "Slot number `1` cannot be filled.",
-        'fpct': "Too many parameters to be filled.",
-        'iassoc': "Invalid association item `1`"
+        "slot": "`1` should contain a positive integer.",
+        "slotn": "Slot number `1` cannot be filled.",
+        "fpct": "Too many parameters to be filled.",
+        "iassoc": "Invalid association item `1`",
     }
 
     def apply_slots(self, body, args, evaluation):
-        'Function[body_][args___]'
+        "Function[body_][args___]"
 
-        args = list(chain([Expression('Function', body)], args.get_sequence()))
+        args = list(chain([Expression("Function", body)], args.get_sequence()))
         return body.replace_slots(args, evaluation)
 
     def apply_named(self, vars, body, args, evaluation):
-        'Function[vars_, body_][args___]'
+        "Function[vars_, body_][args___]"
 
-        if vars.has_form('List', None):
+        if vars.has_form("List", None):
             vars = vars.leaves
         else:
             vars = [vars]
 
+        # print([v.get_head_name()=="System`Pattern" or v.is_symbol() for v in vars])
         args = args.get_sequence()
         if len(vars) > len(args):
-            evaluation.message('Function', 'fpct')
+            evaluation.message("Function", "fpct")
         else:
-            vars = dict(list(zip((
-                var.get_name() for var in vars), args[:len(vars)])))
+            # Allows to use both symbols or Blank patterns (z_Complex) to state the symbol.
+            # this is not included in WL, and here does not have any impact, but it is needed for
+            # translating the function to a compiled version.
+            var_names = (
+                var.get_name() if var.is_symbol() else var.leaves[0].get_name()
+                for var in vars
+            )
+            vars = dict(list(zip(var_names, args[: len(vars)])))
             try:
                 return body.replace_vars(vars)
             except:
                 return
 
     # 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):
+        "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')
+            evaluation.message("Function", "fpct")
         else:
-            vars = dict(list(zip((
-                var.get_name() for var in vars), args[:len(vars)])))
+            vars = dict(list(zip((var.get_name() for var in vars), args[: len(vars)])))
             try:
                 return body.replace_vars(vars)
             except:
                 return
 
+
 class Slot(Builtin):
     """
     <dl>
@@ -140,13 +147,14 @@ class Slot(Builtin):
      = #0
     """
 
-    attributes = ('NHoldAll',)
+    attributes = ("NHoldAll",)
 
     rules = {
-        'Slot[]': 'Slot[1]',
-        'MakeBoxes[Slot[n_Integer?NonNegative],'
-        '  f:StandardForm|TraditionalForm|InputForm|OutputForm]': (
-            '"#" <> ToString[n]'),
+        "Slot[]": "Slot[1]",
+        "MakeBoxes[Slot[n_Integer?NonNegative],"
+        "  f:StandardForm|TraditionalForm|InputForm|OutputForm]": (
+            '"#" <> ToString[n]'
+        ),
     }
 
 
@@ -171,13 +179,12 @@ class SlotSequence(Builtin):
      = ##1
     """
 
-    attributes = ('NHoldAll',)
+    attributes = ("NHoldAll",)
 
     rules = {
-        'SlotSequence[]': 'SlotSequence[1]',
-        'MakeBoxes[SlotSequence[n_Integer?Positive],'
-        'f:StandardForm|TraditionalForm|InputForm|OutputForm]': (
-            '"##" <> ToString[n]'),
+        "SlotSequence[]": "SlotSequence[1]",
+        "MakeBoxes[SlotSequence[n_Integer?Positive],"
+        "f:StandardForm|TraditionalForm|InputForm|OutputForm]": ('"##" <> ToString[n]'),
     }
 
 
@@ -202,14 +209,14 @@ class Composition(Builtin):
      = Composition[f, g, h]
     """
 
-    attributes = ('Flat', 'OneIdentity')
+    attributes = ("Flat", "OneIdentity")
 
     rules = {
-        'Composition[]': 'Identity',
+        "Composition[]": "Identity",
     }
 
     def apply(self, functions, args, evaluation):
-        'Composition[functions__][args___]'
+        "Composition[functions__][args___]"
 
         functions = functions.get_sequence()
         args = args.get_sequence()
@@ -232,5 +239,5 @@ class Identity(Builtin):
     """
 
     rules = {
-        'Identity[x_]': 'x',
+        "Identity[x_]": "x",
     }