Added Routine Data Structures

These are used for describe the computation wanted for the generated
code. The main type is `Routine`, which takes in a name, arguments, and
results. An easy interface `routine` is also created that makes common
assumptions about what the user wants. This allows finer control for
users that want it, while still having an easy interface.

Routines cannot be used in expression trees, but they can be called as a
function, resulting in a `RoutineCall` type. This type has two
attributes: `returns` and `inplace`. The `returns` attr returns a
`RoutineCallResult` representing the result for what is directly
returned. A `Tuple` of these is returned if there is more than one
result. The `inplace` attr returns a dict of `symbol` ->
`RoutineCallResult`, which represents results returned "inplace".

The `RoutineCallResult` types "alias" all assumptions to what the
underlying computation represented would be. This means they can be used
inside sympy expressions. This design makes it easy to call generated
routines from other routines, while keeping everything modular and
expressive.

At this point only `ScalarRoutineCallResult` is implemented.
Corresponding types for Matrices (and later Indexed) still need to be
done.

bin/test

@@ -4,4 +4,4 @@ import pytest
 import sys
 
 path_hack()
-sys.exit(pytest.main())
+sys.exit(pytest.main('-s'))

symcc/__init__.py

@@ -1,5 +1,2 @@
-from .generators import *
 from .printers import *
-from .utilities import *
 from .types import *
-from .wrappers import *

symcc/printers/codeprinter.py

@@ -7,7 +7,7 @@
 from sympy.printing.str import StrPrinter
 from sympy.printing.precedence import precedence
 
-from symcc.types.routines import Assign, AssignmentError
+from symcc.types.ast import Assign
 
 __all__ = ["CodePrinter"]
 

symcc/printers/tests/test_ccode.py

@@ -12,7 +12,6 @@
 
 x, y, z = symbols('x, y, z')
 a, b, c = symbols('a, b, c')
-some_long_name = 'yaaaaaaa'
 
 
 def test_printmethod():

symcc/types/ast.py

@@ -9,9 +9,9 @@
 -------------
 
 *Basic*
-     |--->Assign      
-     |--->AugAssign  
-     |--->NativeOp  
+     |--->Assign
+     |--->AugAssign
+     |--->NativeOp
      |           |--------------|
      |                          |--->AddOp
      |                          |--->SubOp
@@ -259,7 +259,7 @@ class For(Basic):
     iter : iterable
     body : sympy expr
     """
-    
+
     def __new__(cls, target, iter, body):
         target = _sympify(target)
         if not iterable(iter):
@@ -293,43 +293,64 @@ class DataType(with_metaclass(Singleton, Basic)):
 
 
 class NativeBool(DataType):
+    _name = 'Bool'
     pass
 
 
 class NativeInteger(DataType):
+    _name = 'Int'
     pass
 
 
 class NativeFloat(DataType):
+    _name = 'Float'
     pass
 
 
 class NativeDouble(DataType):
+    _name = 'Double'
     pass
 
 
 class NativeVoid(DataType):
+    _name = 'Void'
     pass
 
 
-dtype_registry = {'bool': NativeBool(),
-                  'int': NativeInteger(),
-                  'float': NativeFloat(),
-                  'double': NativeDouble(),
-                  'void': NativeVoid()}
+Bool = NativeBool()
+Int = NativeInteger()
+Float = NativeFloat()
+Double = NativeDouble()
+Void = NativeVoid()
+
+
+dtype_registry = {'bool': Bool,
+                  'int': Int,
+                  'float': Float,
+                  'double': Double,
+                  'void': Void}
 
 
 def datatype(dtype):
     """Returns the datatype singleton for the given dtype"""
 
-    if dtype.lower() not in dtype_registry:
-        raise ValueError("Unrecognized datatype " + dtype)
-    return dtype_registry[dtype]
+    if isinstance(dtype, str):
+        if dtype.lower() not in dtype_registry:
+            raise ValueError("Unrecognized datatype " + dtype)
+        return dtype_registry[dtype]
+    else:
+        dtype = _sympify(dtype)
+        if dtype.is_integer:
+            return dtype_registry['int']
+        elif dtype.is_Boolean:
+            return dtype_registry['bool']
+        else:
+            return dtype_registry['double']
 
 
 class Variable(Basic):
     """Represents a typed variable.
-    
+
     Parameters
     ----------
     name : Symbol, MatrixSymbol
@@ -444,9 +465,10 @@ class FunctionDef(Basic):
 
     def __new__(cls, name, args, body, results):
         # name
-        if not isinstance(name, str):
-            raise TypeError("Function name must be string")
-        name = Symbol(name)
+        if isinstance(name, str):
+            name = Symbol(name)
+        elif not isinstance(name, Symbol):
+            raise TypeError("Function name must be Symbol or string")
         # args
         if not iterable(args):
             raise TypeError("args must be an iterable")