merge

Author: mmatera

mathics/builtin/compilation.py

@@ -2,7 +2,7 @@
 
 from mathics.builtin.base import Builtin, BoxConstruct
 from mathics.core.expression import Atom, Expression, Symbol, String, from_python, Integer, Real
-
+from mathics.core.evaluation import Evaluation
 
 class Compile(Builtin):
     '''
@@ -33,8 +33,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]
@@ -50,10 +49,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 = (
@@ -110,9 +109,27 @@ 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)
+            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)
@@ -206,5 +223,6 @@ def apply(self, argnames, expr, code, args, evaluation):
         try:
             result = code.cfunc(*py_args)
         except (TypeError, ctypes.ArgumentError):
-            return evaluation.message('CompiledFunction', 'argerr', args)
+            evaluation.message('CompiledFunction', 'argerr', args)
+            return
         return from_python(result)

mathics/builtin/functional.py

@@ -86,7 +86,7 @@ def apply_named(self, vars, body, args, evaluation):
         # 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:
             # 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
@@ -109,7 +109,7 @@ 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)])))

mathics/core/expression.py

@@ -984,16 +984,22 @@ def to_python(self, *args, **kwargs):
         Null       -> None
         Symbol     -> '...'
         String     -> '"..."'
+        Function   -> python function
         numbers    -> Python number
         If kwarg n_evaluation is given, apply N first to the expression.
         """
         from mathics.builtin.base import mathics_to_python
-
         n_evaluation = kwargs.get('n_evaluation')
+        head_name = self._head.get_name()
         if n_evaluation is not None:
+            if head_name == 'System`Function':
+                compiled = Expression("System`Compile", *(self._leaves))
+                compiled = compiled.evaluate(n_evaluation)
+                if compiled.get_head_name() == "System`CompiledFunction":
+                    return compiled.leaves[2].cfunc
             value = Expression('N', self).evaluate(n_evaluation)
             return value.to_python()
-        head_name = self._head.get_name()
+
         if head_name == 'System`DirectedInfinity' and len(self._leaves) == 1:
             direction = self._leaves[0].get_int_value()
             if direction == 1:
@@ -1002,6 +1008,7 @@ def to_python(self, *args, **kwargs):
                 return -math.inf
         elif head_name == 'System`List':
             return [leaf.to_python(*args, **kwargs) for leaf in self._leaves]
+
         if head_name in mathics_to_python:
             py_obj = mathics_to_python[head_name]
             # Start here