finalized a decent version of elemwise

cutils.py

+
+try:
+    from cutils_ext import *
+
+except ImportError:
+
+    from scipy import weave
+
+    single_runner = """
+        if (!PyCObject_Check(py_cthunk)) {
+            PyErr_SetString(PyExc_ValueError,
+                            "Argument to run_cthunk must be a PyCObject returned by the c_thunk method of an omega_op.");
+            return NULL;
+        }
+        int (*fn)(void*) = reinterpret_cast<int (*)(void*)>(PyCObject_AsVoidPtr(py_cthunk));
+        void* it = PyCObject_GetDesc(py_cthunk);
+        int failure = fn(it);
+        if (failure) {
+            return NULL;
+        }
+        """
+
+    cthunk = object()
+    mod = weave.ext_tools.ext_module('cutils_ext')
+    mod.add_function(weave.ext_tools.ext_function('run_cthunk', single_runner, ['cthunk']))
+    mod.compile()
+
+    from cutils_ext import *

gof/lib.py

@@ -238,7 +238,7 @@ class PythonOp(Op):
             if input not in exc:
                 self.check_input(input)
         try:
-            results = self.impl(*[input.data for input in self.inputs])
+            results = self._impl()
         except Exception, e:
             print "Error in %s: %s" % (self, e)
             raise
@@ -250,7 +250,7 @@ class PythonOp(Op):
                 output.set_value(result)
 
     def _perform(self):
-        results = self.impl(*[input.data for input in self.inputs])
+        results = self._impl()
         if self.nout == 1:
             self.out.set_value(results)
         else:
@@ -267,6 +267,9 @@ class PythonOp(Op):
                     raise Exception("Uncomputed input: %s in %s" % (input, self))
         self.perform()
 
+    def _impl(self):
+        return self.impl(*[input.data for input in self.inputs])
+    
     def impl(*args):
         raise NotImplementedError("This op has no implementation.")
 

type_spec.py

@@ -13,28 +13,33 @@ class omega_type_converter_extension:
         return [(tvars['c_type'], tvars['name'], tvars['var_convert'])]
 
     def format_provide(self, x):
-        return '%s %s = %s;' % x
+        return '%s %s = %s;\n' % x
 
     def declaration_code(self, templatize = 0, inline = 0):
         tvars = self.template_vars(inline=inline)
         code = '%(py_var)s = %(var_lookup)s;\n' % tvars
-        code += '\n'.join([self.format_provide(export) for export in self.provides()])
+        code += ''.join([self.format_provide(export) for export in self.provides()])
         return code
 
+    def struct_init_code(self):
+        return "Py_INCREF(py_%s);" % self.name
+
+    def struct_cleanup_code(self):
+        return "Py_DECREF(py_%s);" % self.name
+    
     def struct_members_code(self):
-        return '\n'.join(['%s_type %s;' % (name, name) for c_type, name, init in self.provides()])
+        res = "PyObject* py_%s;\n" % self.name
+        return res + ''.join(['%s_type %s;\n' % (name, name) for c_type, name, init in self.provides()])
 
     def struct_import_code(self):
-        return '\n'.join(['__STRUCT_P->%s = %s;' % (name, name) for c_type, name, init in self.provides()])
+        res = "__STRUCT_P->py_%s = py_%s;\n" % (self.name, self.name)
+        return res + ''.join(['__STRUCT_P->%s = %s;\n' % (name, name) for c_type, name, init in self.provides()])
 
     def struct_support_code(self):
         return ""
 
     def struct_typedefs(self):
-        return "\n".join(["typedef %s %s_type;" % (c_type, name) for c_type, name, init in self.provides()])
-
-#     def struct_template_types(self):
-#         return [("typename %s_type" % name, ) for c_type, name, init in self.provides()]
+        return ''.join(["typedef %s %s_type;\n" % (c_type, name) for c_type, name, init in self.provides()])
 
 
 class int_converter(omega_type_converter_extension, c_spec.int_converter):