def transform_floating_literal(self, node): """Transformation function for floating literal Used to get the value and type of the given floating literal. Returns ======= val : list List with two arguments type and Value type contains the type of float value contains the value stored in the variable Notes ===== Only Base Float type supported for now """ type = FloatBaseType(String('real')) try: value = next(node.get_tokens()).spelling except (StopIteration, ValueError): # No tokens value = Float(node.literal) val = [type, value] return val
def transform_integer_literal(self, node): """Transformation function for integer literal Used to get the value and type of the given integer literal. Returns ======= val : list List with two arguments type and Value type contains the type of the integer value contains the value stored in the variable Notes ===== Only Base Integer type supported for now """ type = IntBaseType(String('integer')) try: value = next(node.get_tokens()).spelling except StopIteration: # No tokens value = Integer(node.literal) val = [type, value] return val
def test_FunctionPrototype_and_FunctionDefinition(): vx = Variable(x, type=real) vn = Variable(n, type=integer) fp1 = FunctionPrototype(real, 'power', [vx, vn]) assert fp1.return_type == real assert fp1.name == String('power') assert fp1.parameters == Tuple(vx, vn) assert fp1 == FunctionPrototype(real, 'power', [vx, vn]) assert fp1 != FunctionPrototype(real, 'power', [vn, vx]) assert fp1.func(*fp1.args) == fp1 body = [Assignment(x, x**n), Return(x)] fd1 = FunctionDefinition(real, 'power', [vx, vn], body) assert fd1.return_type == real assert str(fd1.name) == 'power' assert fd1.parameters == Tuple(vx, vn) assert fd1.body == CodeBlock(*body) assert fd1 == FunctionDefinition(real, 'power', [vx, vn], body) assert fd1 != FunctionDefinition(real, 'power', [vx, vn], body[::-1]) assert fd1.func(*fd1.args) == fd1 fp2 = FunctionPrototype.from_FunctionDefinition(fd1) assert fp2 == fp1 fd2 = FunctionDefinition.from_FunctionPrototype(fp1, body) assert fd2 == fd1
def bind_C(name=None): """ Creates an Attribute ``bind_C`` with a name Parameters ========== name : str Examples ======== >>> from sympy import Symbol >>> from sympy.printing import fcode >>> from sympy.codegen.ast import FunctionDefinition, real, Return, Variable >>> from sympy.codegen.fnodes import array, sum_, size, bind_C >>> a = Symbol('a', real=True) >>> s = Symbol('s', integer=True) >>> arr = array(a, dim=[s], intent='in') >>> body = [Return((sum_(a**2)/s)**.5)] >>> fd = FunctionDefinition(real, 'rms', [arr, s], body, attrs=[bind_C('rms')]) >>> print(fcode(fd, source_format='free', standard=2003)) real*8 function rms(a, s) bind(C, name="rms") real*8, dimension(s), intent(in) :: a integer*4 :: s rms = sqrt(sum(a**2)/s) end function """ return Attribute('bind_C', [String(name)] if name else [])
def dimension(*args): """ Creates a 'dimension' Attribute with (up to 7) extents. Examples ======== >>> from sympy.printing import fcode >>> from sympy.codegen.fnodes import dimension, intent_in >>> dim = dimension('2', ':') # 2 rows, runtime determined number of columns >>> from sympy.codegen.ast import Variable, integer >>> arr = Variable('a', integer, attrs=[dim, intent_in]) >>> fcode(arr.as_Declaration(), source_format='free', standard=2003) 'integer*4, dimension(2, :), intent(in) :: a' """ if len(args) > 7: raise ValueError("Fortran only supports up to 7 dimensional arrays") parameters = [] for arg in args: if isinstance(arg, Extent): parameters.append(arg) elif isinstance(arg, string_types): if arg == ':': parameters.append(Extent()) else: parameters.append(String(arg)) elif iterable(arg): parameters.append(Extent(*arg)) else: parameters.append(sympify(arg)) if len(args) == 0: raise ValueError("Need at least one dimension") return Attribute('dimension', parameters)
def test_function(): c_src1 = ('void fun1()' + '\n' + '{' + '\n' + 'int a;' + '\n' + '}') c_src2 = ('int fun2()' + '\n' + '{' + '\n' + 'int a;' + '\n' + 'return a;' + '\n' + '}') c_src3 = ('float fun3()' + '\n' + '{' + '\n' + 'float b;' + '\n' + 'return b;' + '\n' + '}') c_src4 = ('float fun4()' + '\n' + '{}') res1 = SymPyExpression(c_src1, 'c').return_expr() res2 = SymPyExpression(c_src2, 'c').return_expr() res3 = SymPyExpression(c_src3, 'c').return_expr() res4 = SymPyExpression(c_src4, 'c').return_expr() assert res1[0] == FunctionDefinition( NoneToken(), name=String('fun1'), parameters=(), body=CodeBlock( Declaration( Variable(Symbol('a'), type=IntBaseType(String('integer')), value=Integer(0))))) assert res2[0] == FunctionDefinition( IntBaseType(String('integer')), name=String('fun2'), parameters=(), body=CodeBlock( Declaration( Variable(Symbol('a'), type=IntBaseType(String('integer')), value=Integer(0))), Return('a'))) assert res3[0] == FunctionDefinition( FloatBaseType(String('real')), name=String('fun3'), parameters=(), body=CodeBlock( Declaration( Variable(Symbol('b'), type=FloatBaseType(String('real')), value=Float('0.0', precision=53))), Return('b'))) assert res4[0] == FunctionPrototype(FloatBaseType(String('real')), name=String('fun4'), parameters=())
def test_String(): st = String('foobar') assert st.is_Atom assert st == String('foobar') assert st.text == 'foobar' assert st.func(**st.kwargs()) == st class Signifier(String): pass si = Signifier('foobar') assert si != st assert si.text == st.text s = String('foo') assert str(s) == 'foo' assert repr(s) == "String('foo')"
def visit_Function(self, node): """Visitor Function for function Definitions Visits each function definition present in the ASR and creates a function definition node in the Python AST with all the elements of the given function The functions declare all the variables required as SymPy symbols in the function before the function definition This function also the call_visior_function to parse the contents of the function body """ # TODO: Return statement, variable declaration fn_args = [] fn_body = [] fn_name = node.name for arg_iter in node.args: fn_args.append(Variable(arg_iter.name)) for i in node.body: fn_ast = call_visitor(i) try: fn_body_expr = fn_ast except UnboundLocalError: fn_body_expr = [] for sym in node.symtab.symbols: decl = call_visitor(node.symtab.symbols[sym]) for symbols in decl: fn_body.append(symbols) for elem in fn_body_expr: fn_body.append(elem) fn_body.append(Return(Variable(node.return_var.name))) if isinstance(node.return_var.type, asr.Integer): ret_type = IntBaseType(String('integer')) elif isinstance(node.return_var.type, asr.Real): ret_type = FloatBaseType(String('real')) else: raise NotImplementedError("Data type not supported") new_node = FunctionDefinition(return_type=ret_type, name=fn_name, parameters=fn_args, body=fn_body) self._py_ast.append(new_node)
def test_float(): c_src1 = "float a = 1.0;" c_src2 = "float a = 1.25;" + "\n" + "float b = 2.39;" + "\n" c_src3 = "float x = 1, y = 2;" c_src4 = "float p = 5, e = 7.89;" res1 = SymPyExpression(c_src1, "c").return_expr() res2 = SymPyExpression(c_src2, "c").return_expr() res3 = SymPyExpression(c_src3, "c").return_expr() res4 = SymPyExpression(c_src4, "c").return_expr() assert res1[0] == Declaration( Variable( Symbol("a"), type=FloatBaseType(String("real")), value=Float("1.0", precision=53), )) assert res2[0] == Declaration( Variable( Symbol("a"), type=FloatBaseType(String("real")), value=Float("1.25", precision=53), )) assert res2[1] == Declaration( Variable( Symbol("b"), type=FloatBaseType(String("real")), value=Float("2.3900000000000001", precision=53), )) assert res3[0] == Declaration( Variable( Symbol("x"), type=FloatBaseType(String("real")), value=Float("1.0", precision=53), )) assert res3[1] == Declaration( Variable( Symbol("y"), type=FloatBaseType(String("real")), value=Float("2.0", precision=53), )) assert res4[0] == Declaration( Variable( Symbol("p"), type=FloatBaseType(String("real")), value=Float("5.0", precision=53), )) assert res4[1] == Declaration( Variable( Symbol("e"), type=FloatBaseType(String("real")), value=Float("7.89", precision=53), ))
def test_int(): c_src1 = 'int a = 1;' c_src2 = ('int a = 1;' + '\n' + 'int b = 2;' + '\n') res1 = SymPyExpression(c_src1, 'c').return_expr() res2 = SymPyExpression(c_src2, 'c').return_expr() assert res1[0] == Declaration( Variable(Symbol('a'), type=IntBaseType(String('integer')), value=Integer(1))) assert res2[0] == Declaration( Variable(Symbol('a'), type=IntBaseType(String('integer')), value=Integer(1))) assert res2[1] == Declaration( Variable(Symbol('b'), type=IntBaseType(String('integer')), value=Integer(2)))
def test_float(): c_src1 = 'float a = 1.0;' c_src2 = ('float a = 1.25;' + '\n' + 'float b = 2.39;' + '\n') res1 = SymPyExpression(c_src1, 'c').return_expr() res2 = SymPyExpression(c_src2, 'c').return_expr() assert res1[0] == Declaration( Variable(Symbol('a'), type=FloatBaseType(String('real')), value=Float('1.0', precision=53))) assert res2[0] == Declaration( Variable(Symbol('a'), type=FloatBaseType(String('real')), value=Float('1.25', precision=53))) assert res2[1] == Declaration( Variable(Symbol('b'), type=FloatBaseType(String('real')), value=Float('2.3900000000000001', precision=53)))
def test_parse(): c_src1 = "int a;" + "\n" + "int b;" + "\n" c_src2 = "void fun1()" + "\n" + "{" + "\n" + "int a;" + "\n" + "}" f1 = open("..a.h", "w") f2 = open("..b.h", "w") f1.write(c_src1) f2.write(c_src2) f1.close() f2.close() res1 = SymPyExpression("..a.h", "c").return_expr() res2 = SymPyExpression("..b.h", "c").return_expr() os.remove("..a.h") os.remove("..b.h") assert res1[0] == Declaration( Variable(Symbol("a"), type=IntBaseType(String("integer")), value=Integer(0))) assert res1[1] == Declaration( Variable(Symbol("b"), type=IntBaseType(String("integer")), value=Integer(0))) assert res2[0] == FunctionDefinition( NoneToken(), name=String("fun1"), parameters=(), body=CodeBlock( Declaration( Variable( Symbol("a"), type=IntBaseType(String("integer")), value=Integer(0), ))), )
def test_function(): src1 = """\ integer function f(a,b) integer :: x, y f = x + y end function """ expr1.convert_to_expr(src1, "f") for iter in expr1.return_expr(): assert isinstance(iter, FunctionDefinition) assert iter == FunctionDefinition( IntBaseType(String("integer")), name=String("f"), parameters=(Variable(Symbol("a")), Variable(Symbol("b"))), body=CodeBlock( Declaration( Variable( Symbol("a"), type=IntBaseType(String("integer")), value=Integer(0), ) ), Declaration( Variable( Symbol("b"), type=IntBaseType(String("integer")), value=Integer(0), ) ), Declaration( Variable( Symbol("f"), type=IntBaseType(String("integer")), value=Integer(0), ) ), Declaration( Variable( Symbol("x"), type=IntBaseType(String("integer")), value=Integer(0), ) ), Declaration( Variable( Symbol("y"), type=IntBaseType(String("integer")), value=Integer(0), ) ), Assignment(Variable(Symbol("f")), Add(Symbol("x"), Symbol("y"))), Return(Variable(Symbol("f"))), ), )
def sizeof(arg): """ Generate of FunctionCall instance for calling 'sizeof' Examples ======== >>> from sympy.codegen.ast import real >>> from sympy.codegen.cnodes import sizeof >>> from sympy.printing.ccode import ccode >>> ccode(sizeof(real)) 'sizeof(double)' """ return FunctionCall('sizeof', [String(arg) if isinstance(arg, string_types) else arg])
def test_goto_Label(): s = 'early_exit' g = goto(s) assert g.func(*g.args) == g assert g != goto('foobar') assert ccode(g) == 'goto early_exit' l1 = Label(s) assert ccode(l1) == 'early_exit:' assert l1 == Label('early_exit') assert l1 != Label('foobar') body = [PreIncrement(x)] l2 = Label(s, body) assert l2.name == String("early_exit") assert l2.body == CodeBlock(PreIncrement(x)) assert ccode(l2) == ("early_exit:\n" "++(x);") body = [PreIncrement(x), PreDecrement(y)] l2 = Label(s, body) assert l2.name == String("early_exit") assert l2.body == CodeBlock(PreIncrement(x), PreDecrement(y)) assert ccode(l2) == ("early_exit:\n" "{\n ++(x);\n --(y);\n}")
def test_c_parse(): src1 = """\ int a, b = 4; float c, d = 2.4; """ expr1.convert_to_expr(src1, 'c') ls = expr1.return_expr() assert ls[0] == Declaration( Variable(Symbol('a'), type=IntBaseType(String('integer')), value=Integer(0))) assert ls[1] == Declaration( Variable(Symbol('b'), type=IntBaseType(String('integer')), value=Integer(4))) assert ls[2] == Declaration( Variable(Symbol('c'), type=FloatBaseType(String('real')), value=Float('0.0', precision=53))) assert ls[3] == Declaration( Variable(Symbol('d'), type=FloatBaseType(String('real')), value=Float('2.3999999999999999', precision=53)))
def test_parse(): c_src1 = ('int a;' + '\n' + 'int b;' + '\n') c_src2 = ('void fun1()' + '\n' + '{' + '\n' + 'int a;' + '\n' + '}') f1 = open('..a.h', 'w') f2 = open('..b.h', 'w') f1.write(c_src1) f2.write(c_src2) f1.close() f2.close() res1 = SymPyExpression('..a.h', 'c').return_expr() res2 = SymPyExpression('..b.h', 'c').return_expr() os.remove('..a.h') os.remove('..b.h') assert res1[0] == Declaration( Variable(Symbol('a'), type=IntBaseType(String('integer')), value=Integer(0))) assert res1[1] == Declaration( Variable(Symbol('b'), type=IntBaseType(String('integer')), value=Integer(0))) assert res2[0] == FunctionDefinition( NoneToken(), name=String('fun1'), parameters=(), body=CodeBlock( Declaration( Variable(Symbol('a'), type=IntBaseType(String('integer')), value=Integer(0)))))
def test_Type(): t = Type('MyType') assert len(t.args) == 1 assert t.name == String('MyType') assert str(t) == 'MyType' assert repr(t) == "Type(String('MyType'))" assert Type(t) == t assert t.func(*t.args) == t t1 = Type('t1') t2 = Type('t2') assert t1 != t2 assert t1 == t1 and t2 == t2 t1b = Type('t1') assert t1 == t1b assert t2 != t1b
def test_sym_expr(): src1 = (src + """\ d = a + b -c """) expr3 = SymPyExpression(src, 'f') expr4 = SymPyExpression(src1, 'f') ls1 = expr3.return_expr() ls2 = expr4.return_expr() for i in range(0, 7): assert isinstance(ls1[i], Declaration) assert isinstance(ls2[i], Declaration) assert isinstance(ls2[8], Assignment) assert ls1[0] == Declaration( Variable(Symbol('a'), type=IntBaseType(String('integer')), value=Integer(0))) assert ls1[1] == Declaration( Variable(Symbol('b'), type=IntBaseType(String('integer')), value=Integer(0))) assert ls1[2] == Declaration( Variable(Symbol('c'), type=IntBaseType(String('integer')), value=Integer(0))) assert ls1[3] == Declaration( Variable(Symbol('d'), type=IntBaseType(String('integer')), value=Integer(0))) assert ls1[4] == Declaration( Variable(Symbol('p'), type=FloatBaseType(String('real')), value=Float(0.0))) assert ls1[5] == Declaration( Variable(Symbol('q'), type=FloatBaseType(String('real')), value=Float(0.0))) assert ls1[6] == Declaration( Variable(Symbol('r'), type=FloatBaseType(String('real')), value=Float(0.0))) assert ls1[7] == Declaration( Variable(Symbol('s'), type=FloatBaseType(String('real')), value=Float(0.0))) assert ls2[8] == Assignment(Variable(Symbol('d')), Symbol('a') + Symbol('b') - Symbol('c'))
def test_fortran_parse(): expr = SymPyExpression(src, "f") ls = expr.return_expr() assert ls[0] == Declaration( Variable(Symbol("a"), type=IntBaseType(String("integer")), value=Integer(0))) assert ls[1] == Declaration( Variable(Symbol("b"), type=IntBaseType(String("integer")), value=Integer(0))) assert ls[2] == Declaration( Variable(Symbol("c"), type=IntBaseType(String("integer")), value=Integer(0))) assert ls[3] == Declaration( Variable(Symbol("d"), type=IntBaseType(String("integer")), value=Integer(0))) assert ls[4] == Declaration( Variable( Symbol("p"), type=FloatBaseType(String("real")), value=Float("0.0", precision=53), )) assert ls[5] == Declaration( Variable( Symbol("q"), type=FloatBaseType(String("real")), value=Float("0.0", precision=53), )) assert ls[6] == Declaration( Variable( Symbol("r"), type=FloatBaseType(String("real")), value=Float("0.0", precision=53), )) assert ls[7] == Declaration( Variable( Symbol("s"), type=FloatBaseType(String("real")), value=Float("0.0", precision=53), ))
def test_sym_expr(): src1 = ( src + """\ d = a + b -c """ ) expr3 = SymPyExpression(src, "f") expr4 = SymPyExpression(src1, "f") ls1 = expr3.return_expr() ls2 = expr4.return_expr() for i in range(0, 7): assert isinstance(ls1[i], Declaration) assert isinstance(ls2[i], Declaration) assert isinstance(ls2[8], Assignment) assert ls1[0] == Declaration( Variable(Symbol("a"), type=IntBaseType(String("integer")), value=Integer(0)) ) assert ls1[1] == Declaration( Variable(Symbol("b"), type=IntBaseType(String("integer")), value=Integer(0)) ) assert ls1[2] == Declaration( Variable(Symbol("c"), type=IntBaseType(String("integer")), value=Integer(0)) ) assert ls1[3] == Declaration( Variable(Symbol("d"), type=IntBaseType(String("integer")), value=Integer(0)) ) assert ls1[4] == Declaration( Variable(Symbol("p"), type=FloatBaseType(String("real")), value=Float(0.0)) ) assert ls1[5] == Declaration( Variable(Symbol("q"), type=FloatBaseType(String("real")), value=Float(0.0)) ) assert ls1[6] == Declaration( Variable(Symbol("r"), type=FloatBaseType(String("real")), value=Float(0.0)) ) assert ls1[7] == Declaration( Variable(Symbol("s"), type=FloatBaseType(String("real")), value=Float(0.0)) ) assert ls2[8] == Assignment( Variable(Symbol("d")), Symbol("a") + Symbol("b") - Symbol("c") )
def test_String(): st = String('foobar') assert st.is_Atom assert st == String('foobar') assert st.text == 'foobar' assert st.func(**st.kwargs()) == st assert st.func(*st.args) == st class Signifier(String): pass si = Signifier('foobar') assert si != st assert si.text == st.text s = String('foo') assert str(s) == 'foo' assert repr(s) == "String('foo')"
def test_int(): c_src1 = "int a = 1;" c_src2 = "int a = 1;" + "\n" + "int b = 2;" + "\n" c_src3 = "int a = 2.345, b = 5.67;" c_src4 = "int p = 6, q = 23.45;" res1 = SymPyExpression(c_src1, "c").return_expr() res2 = SymPyExpression(c_src2, "c").return_expr() res3 = SymPyExpression(c_src3, "c").return_expr() res4 = SymPyExpression(c_src4, "c").return_expr() assert res1[0] == Declaration( Variable(Symbol("a"), type=IntBaseType(String("integer")), value=Integer(1))) assert res2[0] == Declaration( Variable(Symbol("a"), type=IntBaseType(String("integer")), value=Integer(1))) assert res2[1] == Declaration( Variable(Symbol("b"), type=IntBaseType(String("integer")), value=Integer(2))) assert res3[0] == Declaration( Variable(Symbol("a"), type=IntBaseType(String("integer")), value=Integer(2))) assert res3[1] == Declaration( Variable(Symbol("b"), type=IntBaseType(String("integer")), value=Integer(5))) assert res4[0] == Declaration( Variable(Symbol("p"), type=IntBaseType(String("integer")), value=Integer(6))) assert res4[1] == Declaration( Variable(Symbol("q"), type=IntBaseType(String("integer")), value=Integer(23)))
def test_int(): c_src1 = 'int a = 1;' c_src2 = ('int a = 1;' + '\n' + 'int b = 2;' + '\n') c_src3 = 'int a = 2.345, b = 5.67;' c_src4 = 'int p = 6, q = 23.45;' res1 = SymPyExpression(c_src1, 'c').return_expr() res2 = SymPyExpression(c_src2, 'c').return_expr() res3 = SymPyExpression(c_src3, 'c').return_expr() res4 = SymPyExpression(c_src4, 'c').return_expr() assert res1[0] == Declaration( Variable(Symbol('a'), type=IntBaseType(String('integer')), value=Integer(1))) assert res2[0] == Declaration( Variable(Symbol('a'), type=IntBaseType(String('integer')), value=Integer(1))) assert res2[1] == Declaration( Variable(Symbol('b'), type=IntBaseType(String('integer')), value=Integer(2))) assert res3[0] == Declaration( Variable(Symbol('a'), type=IntBaseType(String('integer')), value=Integer(2))) assert res3[1] == Declaration( Variable(Symbol('b'), type=IntBaseType(String('integer')), value=Integer(5))) assert res4[0] == Declaration( Variable(Symbol('p'), type=IntBaseType(String('integer')), value=Integer(6))) assert res4[1] == Declaration( Variable(Symbol('q'), type=IntBaseType(String('integer')), value=Integer(23)))
def test_float(): c_src1 = 'float a = 1.0;' c_src2 = ('float a = 1.25;' + '\n' + 'float b = 2.39;' + '\n') c_src3 = 'float x = 1, y = 2;' c_src4 = 'float p = 5, e = 7.89;' res1 = SymPyExpression(c_src1, 'c').return_expr() res2 = SymPyExpression(c_src2, 'c').return_expr() res3 = SymPyExpression(c_src3, 'c').return_expr() res4 = SymPyExpression(c_src4, 'c').return_expr() assert res1[0] == Declaration( Variable(Symbol('a'), type=FloatBaseType(String('real')), value=Float('1.0', precision=53))) assert res2[0] == Declaration( Variable(Symbol('a'), type=FloatBaseType(String('real')), value=Float('1.25', precision=53))) assert res2[1] == Declaration( Variable(Symbol('b'), type=FloatBaseType(String('real')), value=Float('2.3900000000000001', precision=53))) assert res3[0] == Declaration( Variable(Symbol('x'), type=FloatBaseType(String('real')), value=Float('1.0', precision=53))) assert res3[1] == Declaration( Variable(Symbol('y'), type=FloatBaseType(String('real')), value=Float('2.0', precision=53))) assert res4[0] == Declaration( Variable(Symbol('p'), type=FloatBaseType(String('real')), value=Float('5.0', precision=53))) assert res4[1] == Declaration( Variable(Symbol('e'), type=FloatBaseType(String('real')), value=Float('7.89', precision=53)))
def test_ast_replace(): x = Variable('x', real) y = Variable('y', real) n = Variable('n', integer) pwer = FunctionDefinition(real, 'pwer', [x, n], [pow(x.symbol, n.symbol)]) pname = pwer.name pcall = FunctionCall('pwer', [y, 3]) tree1 = CodeBlock(pwer, pcall) assert str(tree1.args[0].name) == 'pwer' assert str(tree1.args[1].name) == 'pwer' for a, b in zip(tree1, [pwer, pcall]): assert a == b tree2 = tree1.replace(pname, String('power')) assert str(tree1.args[0].name) == 'pwer' assert str(tree1.args[1].name) == 'pwer' assert str(tree2.args[0].name) == 'power' assert str(tree2.args[1].name) == 'power'
def test_var(): expr1.convert_to_expr(src, 'f') ls = expr1.return_expr() for iter in expr1.return_expr(): assert isinstance(iter, Declaration) assert ls[0] == Declaration( Variable(Symbol('a'), type=IntBaseType(String('integer')), value=Integer(0))) assert ls[1] == Declaration( Variable(Symbol('b'), type=IntBaseType(String('integer')), value=Integer(0))) assert ls[2] == Declaration( Variable(Symbol('c'), type=IntBaseType(String('integer')), value=Integer(0))) assert ls[3] == Declaration( Variable(Symbol('d'), type=IntBaseType(String('integer')), value=Integer(0))) assert ls[4] == Declaration( Variable(Symbol('p'), type=FloatBaseType(String('real')), value=Float(0.0))) assert ls[5] == Declaration( Variable(Symbol('q'), type=FloatBaseType(String('real')), value=Float(0.0))) assert ls[6] == Declaration( Variable(Symbol('r'), type=FloatBaseType(String('real')), value=Float(0.0))) assert ls[7] == Declaration( Variable(Symbol('s'), type=FloatBaseType(String('real')), value=Float(0.0)))
def test_fortran_parse(): expr = SymPyExpression(src, 'f') ls = expr.return_expr() assert ls[0] == Declaration( Variable(Symbol('a'), type=IntBaseType(String('integer')), value=Integer(0))) assert ls[1] == Declaration( Variable(Symbol('b'), type=IntBaseType(String('integer')), value=Integer(0))) assert ls[2] == Declaration( Variable(Symbol('c'), type=IntBaseType(String('integer')), value=Integer(0))) assert ls[3] == Declaration( Variable(Symbol('d'), type=IntBaseType(String('integer')), value=Integer(0))) assert ls[4] == Declaration( Variable(Symbol('p'), type=FloatBaseType(String('real')), value=Float('0.0', precision=53))) assert ls[5] == Declaration( Variable(Symbol('q'), type=FloatBaseType(String('real')), value=Float('0.0', precision=53))) assert ls[6] == Declaration( Variable(Symbol('r'), type=FloatBaseType(String('real')), value=Float('0.0', precision=53))) assert ls[7] == Declaration( Variable(Symbol('s'), type=FloatBaseType(String('real')), value=Float('0.0', precision=53)))
def test_variable(): c_src1 = ('int a;' + '\n' + 'int b;' + '\n') c_src2 = ('float a;' + '\n' + 'float b;' + '\n') c_src3 = ('int a;' + '\n' + 'float b;' + '\n' + 'int c;') res1 = SymPyExpression(c_src1, 'c').return_expr() res2 = SymPyExpression(c_src2, 'c').return_expr() res3 = SymPyExpression(c_src3, 'c').return_expr() assert res1[0] == Declaration( Variable(Symbol('a'), type=IntBaseType(String('integer')), value=Integer(0))) assert res1[1] == Declaration( Variable(Symbol('b'), type=IntBaseType(String('integer')), value=Integer(0))) assert res2[0] == Declaration( Variable(Symbol('a'), type=FloatBaseType(String('real')), value=Float('0.0', precision=53))) assert res2[1] == Declaration( Variable(Symbol('b'), type=FloatBaseType(String('real')), value=Float('0.0', precision=53))) assert res3[0] == Declaration( Variable(Symbol('a'), type=IntBaseType(String('integer')), value=Integer(0))) assert res3[1] == Declaration( Variable(Symbol('b'), type=FloatBaseType(String('real')), value=Float('0.0', precision=53))) assert res3[2] == Declaration( Variable(Symbol('c'), type=IntBaseType(String('integer')), value=Integer(0)))
def gen_kernel_model(self, kernel_name, kernel_arg_type_name): member_types = { "int32": lambda x: (QuotedString("int"), QuotedString(x)), "uint32": lambda x: (QuotedString("unsigned int"), QuotedString(x)), "pint8": lambda x: (QuotedString("signed char *"), QuotedString(x)) } kernel_args = self.kernel_args code_block = CodeBlock( FunctionCall("LibKernelTemplate", (QuotedString(kernel_arg_type_name), FunctionCall( "CArgs", tuple([Integer(len(kernel_args))] + [ FunctionCall( "TCArg", member_types[kernel_arg[1]] (kernel_arg[0])) for kernel_arg in kernel_args ])))), FunctionCall( "LibKernel", (QuotedString(kernel_name), String("CALL_PARALLEL"), Integer(0), QuotedString(kernel_arg_type_name), Integer(0)))) return ccode(code_block, contract=False, type_mappings=TYPE_MAPPINGS)
def _name(arg): if hasattr(arg, 'name'): return arg.name else: return String(arg)