woo

.hgignore

+syntax: glob
+
+*.pyc
+*.o
+*.so
+*~
+\#*\#

compile.py

+
+import gof
+
+import opt
+
+#prog(inputs, outputs)
+#single(*outputs)
+#multi(*output_lists)
+
+import core
+
+
+def to_func(inputs, outputs):
+    p = prog(inputs, outputs)
+    print p.env
+    def f(*args):
+        for input, value in zip(inputs, args):
+            p[input] = value
+        outputs = p()
+        if len(outputs) == 1:
+            return outputs[0]
+        else:
+            return outputs
+    return f
+
+
+# def prog(inputs, outputs):
+#     outputs = gof.ext.mark_outputs_as_destroyed(outputs)
+#     program = gof.Prog(inputs, outputs, opt.optimizer, gof.link.ThunkLinker(), [gof.features.PrintListener])
+#     for orphan in program.env.orphans():
+#         if orphan.storage is core.UNCOMPUTED:
+#             raise Exception("Your program depends on a few uncomputed values.")
+#     return program
+
+class prog(gof.Prog):
+
+    def __init__(self, inputs, outputs):
+#        core.build_mode()
+        outputs = gof.ext.mark_outputs_as_destroyed(outputs)
+        gof.Prog.__init__(self,
+                          inputs,
+                          outputs,
+                          opt.optimizer,
+                          gof.link.thunk_linker,
+                          [])
+#        core.pop_mode()
+
+    def __call__(self, check_uncomputed = True):
+        if check_uncomputed:
+            for input in self.env.inputs:
+                if input.data is core.UNCOMPUTED:
+                    raise Exception("You must provide a value for input %s!" % input)
+            for orphan in self.env.orphans():
+                if orphan.data is core.UNCOMPUTED:
+                    raise Exception("Orphan %s is uncomputed but needed to calculate the function. " % input + \
+                                        "Try calling prog.compute_orphans() or set it manually.")
+        return gof.Prog.__call__(self)
+
+    def compute_orphans(self):
+        raise NotImplementedError
+
+
+def single(*outputs):
+    return prog(gof.graph.inputs(outputs), outputs)
+

opt.py

@@ -3,24 +3,28 @@ from core import *
 import gof
 
 
-def pattern_opt(in_pattern, out_pattern):
-    def parse(x):
-        if isinstance(x, (list, tuple)):
-            return [parse(y) for y in x]
-        elif isinstance(x, wrapper):
-            return x.opclass
-        elif isinstance(x, str) or (hasattr(x, '__bases__') and issubclass(x, gof.op.Op)):
-            return x
-        else:
-            raise TypeError("Bad input type for pattern_opt.")
-    return gof.opt.PatternOptimizer(parse(in_pattern), parse(out_pattern))
-
-def op_sub(op1, op2):
-    if isinstance(op1, wrapper):
-        op1 = op1.opclass
-    if isinstance(op2, wrapper):
-        op2 = op2.opclass
-    return gof.opt.OpSubOptimizer(op1, op2)
+# def pattern_opt(in_pattern, out_pattern):
+#     def parse(x):
+#         if isinstance(x, (list, tuple)):
+#             return [parse(y) for y in x]
+#         elif isinstance(x, wrapper):
+#             return x.opclass
+#         elif isinstance(x, str) or (hasattr(x, '__bases__') and issubclass(x, gof.op.Op)):
+#             return x
+#         else:
+#             raise TypeError("Bad input type for pattern_opt.")
+#     return gof.opt.PatternOptimizer(parse(in_pattern), parse(out_pattern))
+
+# def op_sub(op1, op2):
+#     if isinstance(op1, wrapper):
+#         op1 = op1.opclass
+#     if isinstance(op2, wrapper):
+#         op2 = op2.opclass
+#     return gof.opt.OpSubOptimizer(op1, op2)
+
+
+pattern_opt = gof.opt.PatternOptimizer
+op_sub = gof.opt.OpSubOptimizer
 
 
 #def make_patterns(patterns):
@@ -67,4 +71,15 @@ opts = [
 export_opts(opts) # publish the optimizations performed under individual names
 
 
-optimizer = gof.opt.MergeOptMerge(gof.opt.SeqOptimizer([opt for name, opt in opts]))
+# class AAA(gof.opt.Optimizer):
+
+#     def __init__(self, opt):
+#         self.opt = opt
+    
+#     def optimize(self, env):
+#         build_mode()
+#         self.opt.optimize(env)
+#         pop_mode()
+
+
+optimizer = gof.lib.PythonOpt(gof.opt.MergeOptMerge(gof.opt.SeqOptimizer([opt for name, opt in opts])))