Merge pull request #1161 from mathics/fixes4Compile

Implementing Compile for non compilable llvmlite functions as python functions

Author: rocky

CHANGES.rst

@@ -21,9 +21,13 @@ Enhancements
 Miscellanea
 +++++++++++
 
-A pass was made to improve Microsoft Windows compatability and testing
+* A pass was made to improve Microsoft Windows compatability and testing
 Windows under MSYS.
 
+* Mathics functions are accepted by ``Compile[]``. The return value or type will be
+  ``CompiledFunction``
+
+
 2.0.0
 -----
 

mathics/builtin/compilation.py

@@ -1,6 +1,7 @@
 import ctypes
 
 from mathics.builtin.base import Builtin, BoxConstruct
+from mathics.core.evaluation import Evaluation
 from mathics.core.expression import (
     Atom,
     Expression,
@@ -41,8 +42,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]]
-     : Expression Sin[x + z] could not be compiled.
-     = Function[{Global`x, Global`y}, Sin[x + z]]
+     = CompiledFunction[{x, y}, Sin[x + z], -CompiledCode-]
     #> cf = Compile[{{x, _Real}, {y, _Integer}}, Sin[x + y]]
      = CompiledFunction[{x, y}, Sin[x + y], -CompiledCode-]
     #> cf[1, 2]
@@ -58,10 +58,10 @@ class Compile(Builtin):
     #> cf[0, -2]
      = 0.5
 
-    Loops and variable assignments are not yet supported
+    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 *)
-     : Expression While[b != 0, {a, b} = {b, Mod[a, b]}] ; a could not be compiled.
-     = Function[{Global`a, Global`b}, While[b != 0, {a, b} = {b, Mod[a, b]}] ; a]
+     = CompiledFunction[{a, b}, a, -CompiledCode-]
     """
 
     requires = ("llvmlite",)
@@ -123,9 +123,29 @@ def apply(self, vars, expr, evaluation):
         try:
             cfunc = _compile(expr, args)
         except CompileError:
+            cfunc = None
+
+        if cfunc is None:
+            try:
+
+                def _pythonized_mathics_expr(*x):
+                    inner_evaluation = Evaluation(definitions=evaluation.definitions)
+                    vars = dict(list(zip(names, x[: len(names)])))
+                    pyexpr = expr.replace_vars(vars)
+                    pyexpr = Expression("N", pyexpr).evaluate(inner_evaluation)
+                    res = pyexpr.to_python(n_evaluation=inner_evaluation)
+                    return res
+
+                # TODO: check if we can use numba to compile this...
+                cfunc = _pythonized_mathics_expr
+            except Exception as e:
+                cfunc = None
+
+        if cfunc is None:
             evaluation.message("Compile", "comperr", expr)
             args = Expression("List", *names)
             return Expression("Function", args, expr)
+
         code = CompiledCode(cfunc, args)
         arg_names = Expression("List", *(Symbol(arg.name) for arg in args))
         return Expression("CompiledFunction", arg_names, expr, code)

mathics/builtin/functional.py

@@ -83,11 +83,14 @@ def apply_named(self, vars, body, args, evaluation):
 
         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)])))
-            return body.replace_vars(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):
@@ -99,12 +102,14 @@ def apply_named_attr(self, vars, body, attr, args, evaluation):
 
         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)])))
-            return body.replace_vars(vars)
-
+            try:
+                return body.replace_vars(vars)
+            except:
+                return
 
 class Slot(Builtin):
     """