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 visit_Assignment(self, node):
"""Visitor Function for Assignment
Visits each Assignment is the LFortran ASR and creates corresponding
assignment for SymPy.
Notes
=====
The function currently only supports variable assignment and binary
operation assignments of varying multitudes. Any type of numberS or
array is not supported.
Raises
======
NotImplementedError() when called for Numeric assignments or Arrays
"""
# TODO: Arithmatic Assignment
if isinstance(node.target, asr.Variable):
target = node.target
value = node.value
if isinstance(value, asr.Variable):
new_node = Assignment(Variable(target.name), Variable(value.name))
elif type(value) == asr.BinOp:
exp_ast = call_visitor(value)
for expr in exp_ast:
new_node = Assignment(Variable(target.name), expr)
else:
raise NotImplementedError("Numeric assignments not supported")
else:
raise NotImplementedError("Arrays not supported")
self._py_ast.append(new_node)
def test_ccode_Declaration():
i = symbols('i', integer=True)
var1 = Variable(i, type_=Type.from_expr(i))
dcl1 = Declaration(var1)
assert ccode(dcl1) == 'int i'
var2 = Variable(x, {value_const}, float32)
dcl2a = Declaration(var2)
assert ccode(dcl2a) == 'const float x'
dcl2b = Declaration(var2, pi)
assert ccode(dcl2b) == 'const float x = M_PI'
var3 = Variable(y, type_=Type('bool'))
dcl3 = Declaration(var3)
printer = C89CodePrinter()
assert 'stdbool.h' not in printer.headers
assert printer.doprint(dcl3) == 'bool y'
assert 'stdbool.h' in printer.headers
u = symbols('u', real=True)
ptr4 = Pointer.deduced(u, {pointer_const, restrict})
dcl4 = Declaration(ptr4)
assert ccode(dcl4) == 'double * const restrict u'
var5 = Variable(x, {value_const}, Type('__float128'))
dcl5a = Declaration(var5)
assert ccode(dcl5a) == 'const __float128 x'
dcl5b = Declaration(var5, pi)
assert ccode(dcl5b) == 'const __float128 x = M_PI'
def perform_operation(self, lhs, rhs, op):
"""Performs operation supported by the SymPy core
Returns
=======
combined_variable: list
contains variable content and type of variable
"""
lhs_value = self.get_expr_for_operand(lhs)
rhs_value = self.get_expr_for_operand(rhs)
if op == '+':
return [Add(lhs_value, rhs_value), 'expr']
if op == '-':
return [Add(lhs_value, -rhs_value), 'expr']
if op == '*':
return [Mul(lhs_value, rhs_value), 'expr']
if op == '/':
return [Mul(lhs_value, Pow(rhs_value, Integer(-1))), 'expr']
if op == '%':
return [Mod(lhs_value, rhs_value), 'expr']
if op in ['<', '<=', '>', '>=', '==', '!=']:
return [Rel(lhs_value, rhs_value, op), 'expr']
if op == '&&':
return [And(as_Boolean(lhs_value), as_Boolean(rhs_value)), 'expr']
if op == '||':
return [Or(as_Boolean(lhs_value), as_Boolean(rhs_value)), 'expr']
if op == '=':
return [Assignment(Variable(lhs_value), rhs_value), 'expr']
if op in ['+=', '-=', '*=', '/=', '%=']:
return [aug_assign(Variable(lhs_value), op[0], rhs_value), 'expr']
def test_ccode_Declaration():
i = symbols('i', integer=True)
var1 = Variable(i, type=Type.from_expr(i))
dcl1 = Declaration(var1)
assert ccode(dcl1) == 'int i'
var2 = Variable(x, type=float32, attrs={value_const})
dcl2a = Declaration(var2)
assert ccode(dcl2a) == 'const float x'
dcl2b = var2.as_Declaration(value=pi)
assert ccode(dcl2b) == 'const float x = M_PI'
var3 = Variable(y, type=Type('bool'))
dcl3 = Declaration(var3)
printer = C89CodePrinter()
assert 'stdbool.h' not in printer.headers
assert printer.doprint(dcl3) == 'bool y'
assert 'stdbool.h' in printer.headers
u = symbols('u', real=True)
ptr4 = Pointer.deduced(u, attrs={pointer_const, restrict})
dcl4 = Declaration(ptr4)
assert ccode(dcl4) == 'double * const restrict u'
var5 = Variable(x, Type('__float128'), attrs={value_const})
dcl5a = Declaration(var5)
assert ccode(dcl5a) == 'const __float128 x'
var5b = Variable(var5.symbol, var5.type, pi, attrs=var5.attrs)
dcl5b = Declaration(var5b)
assert ccode(dcl5b) == 'const __float128 x = M_PI'
def test_mul_binop():
src1 = (
src
+ """\
d = a + b - c
c = a * b + d
s = p * q / r
r = p * s + q / p
"""
)
expr1.convert_to_expr(src1, "f")
ls1 = expr1.return_expr()
for iter in range(8, 12):
assert isinstance(ls1[iter], Assignment)
assert ls1[8] == Assignment(
Variable(Symbol("d")), Symbol("a") + Symbol("b") - Symbol("c")
)
assert ls1[9] == Assignment(
Variable(Symbol("c")), Symbol("a") * Symbol("b") + Symbol("d")
)
assert ls1[10] == Assignment(
Variable(Symbol("s")), Symbol("p") * Symbol("q") / Symbol("r")
)
assert ls1[11] == Assignment(
Variable(Symbol("r")), Symbol("p") * Symbol("s") + Symbol("q") / Symbol("p")
)
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('intc'))))
assert ls[1] == Declaration(
Variable(Symbol('b'),
type=IntBaseType(String('intc')),
value=Integer(4)))
assert ls[2] == Declaration(
Variable(Symbol('c'),
type=FloatType(String('float32'),
nbits=Integer(32),
nmant=Integer(23),
nexp=Integer(8))))
assert ls[3] == Declaration(
Variable(Symbol('d'),
type=FloatType(String('float32'),
nbits=Integer(32),
nmant=Integer(23),
nexp=Integer(8)),
value=Float('2.3999999999999999', precision=53)))
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 test_Declaration():
u = symbols('u', real=True)
vu = Variable(u, type=Type.from_expr(u))
assert Declaration(vu).variable.type == real
vn = Variable(n, type=Type.from_expr(n))
assert Declaration(vn).variable.type == integer
lt = StrictLessThan(vu, vn)
assert isinstance(lt, StrictLessThan)
vuc = Variable(u, Type.from_expr(u), value=3.0, attrs={value_const})
assert value_const in vuc.attrs
assert pointer_const not in vuc.attrs
decl = Declaration(vuc)
assert decl.variable == vuc
assert isinstance(decl.variable.value, Float)
assert decl.variable.value == 3.0
assert decl.func(*decl.args) == decl
assert vuc.as_Declaration() == decl
assert vuc.as_Declaration(value=None, attrs=None) == Declaration(vu)
vy = Variable(y, type=integer, value=3)
decl2 = Declaration(vy)
assert decl2.variable == vy
assert decl2.variable.value == Integer(3)
vi = Variable(i, type=Type.from_expr(i), value=3.0)
decl3 = Declaration(vi)
assert decl3.variable.type == integer
assert decl3.variable.value == 3.0
raises(ValueError, lambda: Declaration(vi, 42))
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 _mk_func1():
declars = n, inp, out = Variable('n', integer), Pointer('inp',
real), Pointer(
'out', real)
i = Variable('i', integer)
whl = While(i < n, [Assignment(out[i], inp[i]), PreIncrement(i)])
body = CodeBlock(i.as_Declaration(value=0), whl)
return FunctionDefinition(void, 'our_test_function', declars, body)
def transform_parm_decl(self, node):
"""Transformation function for Parameter Declaration
Used to create parameter nodes for the required functions for the
respective nodes in the clang AST
Returns
=======
param : Codegen AST Node
Variable node with the value nad type of the variable
Raises
======
ValueError if multiple children encountered in the parameter node
"""
if (node.type.kind == cin.TypeKind.INT):
type = IntBaseType(String('integer'))
value = Integer(0)
elif (node.type.kind == cin.TypeKind.FLOAT):
type = FloatBaseType(String('real'))
value = Float(0.0)
try:
children = node.get_children()
child = next(children)
# Any namespace nodes can be ignored
while child.kind in [cin.CursorKind.NAMESPACE_REF,
cin.CursorKind.TYPE_REF,
cin.CursorKind.TEMPLATE_REF]:
child = next(children)
# If there is a child, it is the default value of the parameter.
args = self.transform(child)
param = Variable(
node.spelling
).as_Declaration(
type = args[0],
value = args[1]
)
except StopIteration:
param = Variable(
node.spelling
).as_Declaration(
type = type,
value = value
)
try:
value = self.transform(next(children))
raise ValueError("Can't handle multiple children on parameter")
except StopIteration:
pass
return param
def test_FunctionPrototype_print():
x = symbols('x')
n = symbols('n', integer=True)
vx = Variable(x, type=real)
vn = Variable(n, type=integer)
fp1 = FunctionPrototype(real, 'power', [vx, vn])
# Should be changed to proper test once multi-line generation is working
# see https://github.com/sympy/sympy/issues/15824
raises(NotImplementedError, lambda: fcode(fp1))
def test_FunctionDefinition_print():
x = symbols('x')
n = symbols('n', integer=True)
vx = Variable(x, type=real)
vn = Variable(n, type=integer)
body = [Assignment(x, x**n), Return(x)]
fd1 = FunctionDefinition(real, 'power', [vx, vn], body)
# Should be changed to proper test once multi-line generation is working
# see https://github.com/sympy/sympy/issues/15824
raises(NotImplementedError, lambda: fcode(fd1))
def _mk_func1():
declars = n, inp, out = (
Variable("n", integer),
Pointer("inp", real),
Pointer("out", real),
)
i = Variable("i", integer)
whl = While(i < n, [Assignment(out[i], inp[i]), PreIncrement(i)])
body = CodeBlock(i.as_Declaration(value=0), whl)
return FunctionDefinition(void, "our_test_function", declars, body)
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_union():
vx, vy = Variable(x, type=float64), Variable(y, type=int64)
u = union("dualuse", [vx, vy])
assert u.func(*u.args) == u
assert u == union("dualuse", (vx, vy))
assert str(u.name) == "dualuse"
assert len(u.declarations) == 2
assert all(isinstance(arg, Declaration) for arg in u.declarations)
assert ccode(u) == ("union dualuse {\n"
" double x;\n"
" int64_t y;\n"
"}")
def kernel_arg_local_assign(self, args_var):
member_types = {
"int32": lambda x: Variable(x, type=int32),
"uint32": lambda x: Variable(x, type=uint32),
"pint8": lambda x: Pointer(x, type=int8, attrs=(restrict, )),
}
return [
AssignmentEx(
Declaration(member_types[kernel_arg[1]](kernel_arg[0])),
StructVariable(args_var, Symbol(kernel_arg[0])))
for kernel_arg in self.kernel_args
]
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;'
c_src5 = "int x = '0', y = 'a';"
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()
res5 = SymPyExpression(c_src5, '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)))
assert res5[0] == Declaration(
Variable(Symbol('x'),
type=IntBaseType(String('integer')),
value=Integer(48)))
assert res5[1] == Declaration(
Variable(Symbol('y'),
type=IntBaseType(String('integer')),
value=Integer(97)))
def test_struct():
vx, vy = Variable(x, type=float64), Variable(y, type=float64)
s = struct("vec2", [vx, vy])
assert s.func(*s.args) == s
assert s == struct("vec2", (vx, vy))
assert s != struct("vec2", (vy, vx))
assert str(s.name) == "vec2"
assert len(s.declarations) == 2
assert all(isinstance(arg, Declaration) for arg in s.declarations)
assert ccode(s) == ("struct vec2 {\n"
" double x;\n"
" double y;\n"
"}")
def test_parameters():
c_src1 = ('void fun1( int a)' + '\n' + '{' + '\n' + 'int i;' + '\n' +
'}')
c_src2 = ('int fun2(float x, float y)' + '\n' + '{' + '\n' + 'int a;' +
'\n' + 'return a;' + '\n' + '}')
c_src3 = ('float fun3(int p, float q, int r)' + '\n' + '{' + '\n' +
'float b;' + '\n' + 'return b;' + '\n' + '}')
res1 = SymPyExpression(c_src1, 'c').return_expr()
res2 = SymPyExpression(c_src2, 'c').return_expr()
res3 = SymPyExpression(c_src3, 'c').return_expr()
assert res1[0] == FunctionDefinition(
NoneToken(),
name=String('fun1'),
parameters=(Variable(Symbol('a'),
type=IntBaseType(String('integer')),
value=Integer(0)), ),
body=CodeBlock(
Declaration(
Variable(Symbol('i'),
type=IntBaseType(String('integer')),
value=Integer(0)))))
assert res2[0] == FunctionDefinition(
IntBaseType(String('integer')),
name=String('fun2'),
parameters=(Variable(Symbol('x'),
type=FloatBaseType(String('real')),
value=Float('0.0', precision=53)),
Variable(Symbol('y'),
type=FloatBaseType(String('real')),
value=Float('0.0', precision=53))),
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=(Variable(Symbol('p'),
type=IntBaseType(String('integer')),
value=Integer(0)),
Variable(Symbol('q'),
type=FloatBaseType(String('real')),
value=Float('0.0', precision=53)),
Variable(Symbol('r'),
type=IntBaseType(String('integer')),
value=Integer(0))),
body=CodeBlock(
Declaration(
Variable(Symbol('b'),
type=FloatBaseType(String('real')),
value=Float('0.0', precision=53))), Return('b')))
def array(symbol, dim, intent=None, **kwargs):
""" Convenience function for creating a Variable instance for a Fortran array
Parameters
==========
symbol : symbol
dim : Attribute or iterable
If dim is an ``Attribute`` it need to have the name 'dimension'. If it is
not an ``Attribute``, then it is passsed to :func:`dimension` as ``*dim``
intent : str
One of: 'in', 'out', 'inout' or None
\\*\\*kwargs:
Keyword arguments for ``Variable`` ('type' & 'value')
Examples
========
>>> from sympy.printing import fcode
>>> from sympy.codegen.ast import integer, real
>>> from sympy.codegen.fnodes import array
>>> arr = array('a', '*', 'in', type=integer)
>>> print(fcode(arr.as_Declaration(), source_format='free', standard=2003))
integer*4, dimension(*), intent(in) :: a
>>> x = array('x', [3, ':', ':'], intent='out', type=real)
>>> print(fcode(x.as_Declaration(value=1), source_format='free', standard=2003))
real*8, dimension(3, :, :), intent(out) :: x = 1
"""
if isinstance(dim, Attribute):
if str(dim.name) != 'dimension':
raise ValueError(
"Got an unexpected Attribute argument as dim: %s" % str(dim))
else:
dim = dimension(*dim)
attrs = list(kwargs.pop('attrs', [])) + [dim]
if intent is not None:
if intent not in (intent_in, intent_out, intent_inout):
intent = {
'in': intent_in,
'out': intent_out,
'inout': intent_inout
}[intent]
attrs.append(intent)
value = kwargs.pop('value', None)
type_ = kwargs.pop('type', None)
if type_ is None:
return Variable.deduced(symbol, value=value, attrs=attrs)
else:
return Variable(symbol, type_, value=value, attrs=attrs)
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_Declaration():
u = symbols('u', real=True)
vu = Variable(u, type=Type.from_expr(u))
assert Declaration(vu).variable.type == real
vn = Variable(n, type=Type.from_expr(n))
assert Declaration(vn).variable.type == integer
lt = StrictLessThan(vu, vn)
assert isinstance(lt, StrictLessThan)
vuc = Variable(u, Type.from_expr(u), value=3.0, attrs={value_const})
assert value_const in vuc.attrs
assert pointer_const not in vuc.attrs
decl = Declaration(vuc)
assert decl.variable == vuc
assert isinstance(decl.variable.value, Float)
assert decl.variable.value == 3.0
assert decl.func(*decl.args) == decl
assert vuc.as_Declaration() == decl
assert vuc.as_Declaration(value=None, attrs=None) == Declaration(vu)
vy = Variable(y, type=integer, value=3)
decl2 = Declaration(vy)
assert decl2.variable == vy
assert decl2.variable.value == Integer(3)
vi = Variable(i, type=Type.from_expr(i), value=3.0)
decl3 = Declaration(vi)
assert decl3.variable.type == integer
assert decl3.variable.value == 3.0
raises(ValueError, lambda: Declaration(vi, 42))
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 test_C99CodePrinter_custom_type():
# We will look at __float128 (new in glibc 2.26)
f128 = FloatType('_Float128', float128.nbits, float128.nmant,
float128.nexp)
p128 = C99CodePrinter(
dict(type_aliases={real: f128},
type_literal_suffixes={f128: 'Q'},
type_func_suffixes={f128: 'f128'},
type_math_macro_suffixes={
real: 'f128',
f128: 'f128'
},
type_macros={f128: ('__STDC_WANT_IEC_60559_TYPES_EXT__', )}))
assert p128.doprint(x) == 'x'
assert not p128.headers
assert not p128.libraries
assert not p128.macros
assert p128.doprint(2.0) == '2.0Q'
assert not p128.headers
assert not p128.libraries
assert p128.macros == {'__STDC_WANT_IEC_60559_TYPES_EXT__'}
assert p128.doprint(Rational(1, 2)) == '1.0Q/2.0Q'
assert p128.doprint(sin(x)) == 'sinf128(x)'
assert p128.doprint(cos(2., evaluate=False)) == 'cosf128(2.0Q)'
var5 = Variable(x, {value_const}, f128)
dcl5a = Declaration(var5)
assert ccode(dcl5a) == 'const _Float128 x'
dcl5b = Declaration(var5, pi)
assert p128.doprint(dcl5b) == 'const _Float128 x = M_PIf128'
dcl5c = Declaration(var5, Catalan.evalf(38))
assert p128.doprint(dcl5c) == 'const _Float128 x = %sQ' % Catalan.evalf(
f128.decimal_dig)
def newtons_method_function(expr, wrt, params=None, func_name="newton", attrs=Tuple(), **kwargs):
""" Generates an AST for a function implementing the Newton-Raphson method.
Parameters
==========
expr : expression
wrt : Symbol
With respect to, i.e. what is the variable
params : iterable of symbols
Symbols appearing in expr that are taken as constants during the iterations
(these will be accepted as parameters to the generated function).
func_name : str
Name of the generated function.
attrs : Tuple
Attribute instances passed as ``attrs`` to ``FunctionDefinition``.
\\*\\*kwargs :
Keyword arguments passed to :func:`sympy.codegen.algorithms.newtons_method`.
Examples
========
>>> from sympy import symbols, cos
>>> from sympy.codegen.algorithms import newtons_method_function
>>> from sympy.codegen.pyutils import render_as_module
>>> from sympy.core.compatibility import exec_
>>> x = symbols('x')
>>> expr = cos(x) - x**3
>>> func = newtons_method_function(expr, x)
>>> py_mod = render_as_module(func) # source code as string
>>> namespace = {}
>>> exec_(py_mod, namespace, namespace)
>>> res = eval('newton(0.5)', namespace)
>>> abs(res - 0.865474033102) < 1e-12
True
See Also
========
sympy.codegen.algorithms.newtons_method
"""
if params is None:
params = (wrt,)
pointer_subs = {p.symbol: Symbol('(*%s)' % p.symbol.name)
for p in params if isinstance(p, Pointer)}
delta = kwargs.pop('delta', None)
if delta is None:
delta = Symbol('d_' + wrt.name)
if expr.has(delta):
delta = None # will use Dummy
algo = newtons_method(expr, wrt, delta=delta, **kwargs).xreplace(pointer_subs)
if isinstance(algo, Scope):
algo = algo.body
not_in_params = expr.free_symbols.difference(set(_symbol_of(p) for p in params))
if not_in_params:
raise ValueError("Missing symbols in params: %s" % ', '.join(map(str, not_in_params)))
declars = tuple(Variable(p, real) for p in params)
body = CodeBlock(algo, Return(wrt))
return FunctionDefinition(real, func_name, declars, body, attrs=attrs)
def test_binop_add():
src1 = (src + """\
c = a + b
d = a + c
s = p + q + r
""")
expr1.convert_to_expr(src1, 'f')
ls1 = expr1.return_expr()
for iter in range(8, 11):
assert isinstance(ls1[iter], Assignment)
assert ls1[8] == Assignment(Variable(Symbol('c')),
Symbol('a') + Symbol('b'))
assert ls1[9] == Assignment(Variable(Symbol('d')),
Symbol('a') + Symbol('c'))
assert ls1[10] == Assignment(Variable(Symbol('s')),
Symbol('p') + Symbol('q') + Symbol('r'))
def _var(arg):
if isinstance(arg, Declaration):
return arg.variable
elif isinstance(arg, Variable):
return arg
else:
return Variable.deduced(arg)
def test_Variable():
v = Variable(x, type_=Type('real'))
assert v.symbol == x
assert v.type == real
assert v.value_const == False
w = Variable(y, {value_const}, f32)
assert w.symbol == y
assert w.type == f32
assert w.value_const
v_n = Variable(n, type_=Type.from_expr(n))
assert v_n.type == integer
v_i = Variable(i, type_=Type.from_expr(n))
assert v_i.type == integer
a_i = Variable.deduced(i)
assert a_i.type == integer
def test_ccode_codegen_ast():
assert ccode(Comment("this is a comment")) == "// this is a comment"
assert ccode(While(abs(x) > 1,
[aug_assign(x, '-', 1)])) == ('while (fabs(x) > 1) {\n'
' x -= 1;\n'
'}')
assert ccode(Scope([AddAugmentedAssignment(x, 1)])) == ('{\n'
' x += 1;\n'
'}')
inp_x = Declaration(Variable(x, type=real))
assert ccode(FunctionPrototype(real, 'pwer',
[inp_x])) == 'double pwer(double x)'
assert ccode(
FunctionDefinition(
real, 'pwer', [inp_x],
[Assignment(x, x**2)])) == ('double pwer(double x){\n'
' x = pow(x, 2);\n'
'}')
# Elements of CodeBlock are formatted as statements:
block = CodeBlock(
x,
Print([x, y], "%d %d"),
FunctionCall('pwer', [x]),
Return(x),
)
assert ccode(block) == '\n'.join([
'x;',
'printf("%d %d", x, y);',
'pwer(x);',
'return x;',
])
def visit_Variable(self, node):
"""Visitor Function for Variable Declaration
Visits each variable declaration present in the ASR and creates a
Symbol declaration for each variable
Notes
=====
The functions currently only support declaration of integer and
real variables. Other data types are still under development.
Raises
======
NotImplementedError() when called for unsupported data types
"""
if isinstance(node.type, asr.Integer):
var_type = IntBaseType(String('integer'))
value = Integer(0)
elif isinstance(node.type, asr.Real):
var_type = FloatBaseType(String('real'))
value = Float(0.0)
else:
raise NotImplementedError("Data type not supported")
if not (node.intent == 'in'):
new_node = Variable(node.name).as_Declaration(type=var_type,
value=value)
self._py_ast.append(new_node)
def test_Subroutine():
# Code to generate the subroutine in the example from
# http://www.fortran90.org/src/best-practices.html#arrays
r = Symbol('r', real=True)
i = Symbol('i', integer=True)
v_r = Variable.deduced(r, attrs=(dimension(assumed_extent), intent_out))
v_i = Variable.deduced(i)
v_n = Variable('n', integer)
do_loop = Do([
Assignment(Element(r, [i]), literal_dp(1)/i**2)
], i, 1, v_n)
sub = Subroutine("f", [v_r], [
Declaration(v_n),
Declaration(v_i),
Assignment(v_n, size(r)),
do_loop
])
x = Symbol('x', real=True)
v_x3 = Variable.deduced(x, attrs=[dimension(3)])
mod = Module('mymod', definitions=[sub])
prog = Program('foo', [
use(mod, only=[sub]),
Declaration(v_x3),
SubroutineCall(sub, [v_x3]),
Print([sum_(v_x3), v_x3])
])
if not has_fortran():
skip("No fortran compiler found.")
(stdout, stderr), info = compile_run_strings([
('a.f90', fcode(mod, standard=90)),
('b.f90', fcode(prog, standard=90))
], clean=True)
ref = [1.0/i**2 for i in range(1, 4)]
assert str(sum(ref))[:-3] in stdout
for _ in ref:
assert str(_)[:-3] in stdout
assert stderr == ''
def test_Program():
x = Symbol('x', real=True)
vx = Variable.deduced(x, 42)
decl = Declaration(vx)
prnt = Print([x, x+1])
prog = Program('foo', [decl, prnt])
if not has_fortran():
skip("No fortran compiler found.")
(stdout, stderr), info = compile_run_strings([('main.f90', fcode(prog, standard=90))], clean=True)
assert '42' in stdout
assert '43' in stdout
assert stderr == ''
assert info['exit_status'] == os.EX_OK
def array(symbol, dim, intent=None, **kwargs):
""" Convenience function for creating a Variable instance for a Fortran array
Parameters
==========
symbol : symbol
dim : Attribute or iterable
If dim is an ``Attribute`` it need to have the name 'dimension'. If it is
not an ``Attribute``, then it is passsed to :func:`dimension` as ``*dim``
intent : str
One of: 'in', 'out', 'inout' or None
\\*\\*kwargs:
Keyword arguments for ``Variable`` ('type' & 'value')
Examples
========
>>> from sympy.printing import fcode
>>> from sympy.codegen.ast import integer, real
>>> from sympy.codegen.fnodes import array
>>> arr = array('a', '*', 'in', type=integer)
>>> print(fcode(arr.as_Declaration(), source_format='free', standard=2003))
integer*4, dimension(*), intent(in) :: a
>>> x = array('x', [3, ':', ':'], intent='out', type=real)
>>> print(fcode(x.as_Declaration(value=1), source_format='free', standard=2003))
real*8, dimension(3, :, :), intent(out) :: x = 1
"""
if isinstance(dim, Attribute):
if str(dim.name) != 'dimension':
raise ValueError("Got an unexpected Attribute argument as dim: %s" % str(dim))
else:
dim = dimension(*dim)
attrs = list(kwargs.pop('attrs', [])) + [dim]
if intent is not None:
if intent not in (intent_in, intent_out, intent_inout):
intent = {'in': intent_in, 'out': intent_out, 'inout': intent_inout}[intent]
attrs.append(intent)
value = kwargs.pop('value', None)
type_ = kwargs.pop('type', None)
if type_ is None:
return Variable.deduced(symbol, value=value, attrs=attrs)
else:
return Variable(symbol, type_, value=value, attrs=attrs)
def test_Module():
x = Symbol('x', real=True)
v_x = Variable.deduced(x)
sq = FunctionDefinition(real, 'sqr', [v_x], [Return(x**2)])
mod_sq = Module('mod_sq', [], [sq])
sq_call = FunctionCall('sqr', [42.])
prg_sq = Program('foobar', [
use('mod_sq', only=['sqr']),
Print(['"Square of 42 = "', sq_call])
])
if not has_fortran():
skip("No fortran compiler found.")
(stdout, stderr), info = compile_run_strings([
('mod_sq.f90', fcode(mod_sq, standard=90)),
('main.f90', fcode(prg_sq, standard=90))
], clean=True)
assert '42' in stdout
assert str(42**2) in stdout
assert stderr == ''
def test_fcode_Declaration():
def check(expr, ref, **kwargs):
assert fcode(expr, standard=95, source_format='free', **kwargs) == ref
i = symbols('i', integer=True)
var1 = Variable.deduced(i)
dcl1 = Declaration(var1)
check(dcl1, "integer*4 :: i")
x, y = symbols('x y')
var2 = Variable(x, float32, value=42, attrs={value_const})
dcl2b = Declaration(var2)
check(dcl2b, 'real*4, parameter :: x = 42')
var3 = Variable(y, type=bool_)
dcl3 = Declaration(var3)
check(dcl3, 'logical :: y')
check(float32, "real*4")
check(float64, "real*8")
check(real, "real*4", type_aliases={real: float32})
check(real, "real*8", type_aliases={real: float64})
def _mk_func1():
declars = n, inp, out = Variable('n', integer), Pointer('inp', real), Pointer('out', real)
i = Variable('i', integer)
whl = While(i<n, [Assignment(out[i], inp[i]), PreIncrement(i)])
body = CodeBlock(i.as_Declaration(value=0), whl)
return FunctionDefinition(void, 'our_test_function', declars, body)
def newtons_method(expr, wrt, atol=1e-12, delta=None, debug=False,
itermax=None, counter=None):
""" Generates an AST for Newton-Raphson method (a root-finding algorithm).
Returns an abstract syntax tree (AST) based on ``sympy.codegen.ast`` for Netwon's
method of root-finding.
Parameters
==========
expr : expression
wrt : Symbol
With respect to, i.e. what is the variable.
atol : number or expr
Absolute tolerance (stopping criterion)
delta : Symbol
Will be a ``Dummy`` if ``None``.
debug : bool
Whether to print convergence information during iterations
itermax : number or expr
Maximum number of iterations.
counter : Symbol
Will be a ``Dummy`` if ``None``.
Examples
========
>>> from sympy import symbols, cos
>>> from sympy.codegen.ast import Assignment
>>> from sympy.codegen.algorithms import newtons_method
>>> x, dx, atol = symbols('x dx atol')
>>> expr = cos(x) - x**3
>>> algo = newtons_method(expr, x, atol, dx)
>>> algo.has(Assignment(dx, -expr/expr.diff(x)))
True
References
==========
.. [1] https://en.wikipedia.org/wiki/Newton%27s_method
"""
if delta is None:
delta = Dummy()
Wrapper = Scope
name_d = 'delta'
else:
Wrapper = lambda x: x
name_d = delta.name
delta_expr = -expr/expr.diff(wrt)
whl_bdy = [Assignment(delta, delta_expr), AddAugmentedAssignment(wrt, delta)]
if debug:
prnt = Print([wrt, delta], r"{0}=%12.5g {1}=%12.5g\n".format(wrt.name, name_d))
whl_bdy = [whl_bdy[0], prnt] + whl_bdy[1:]
req = Gt(Abs(delta), atol)
declars = [Declaration(Variable(delta, type=real, value=oo))]
if itermax is not None:
counter = counter or Dummy(integer=True)
v_counter = Variable.deduced(counter, 0)
declars.append(Declaration(v_counter))
whl_bdy.append(AddAugmentedAssignment(counter, 1))
req = And(req, Lt(counter, itermax))
whl = While(req, CodeBlock(*whl_bdy))
blck = declars + [whl]
return Wrapper(CodeBlock(*blck))
def test_Variable():
v = Variable(x, type=real)
assert v == Variable(v)
assert v == Variable('x', type=real)
assert v.symbol == x
assert v.type == real
assert value_const not in v.attrs
assert v.func(*v.args) == v
assert str(v) == 'Variable(x, type=real)'
w = Variable(y, f32, attrs={value_const})
assert w.symbol == y
assert w.type == f32
assert value_const in w.attrs
assert w.func(*w.args) == w
v_n = Variable(n, type=Type.from_expr(n))
assert v_n.type == integer
assert v_n.func(*v_n.args) == v_n
v_i = Variable(i, type=Type.from_expr(n))
assert v_i.type == integer
assert v_i != v_n
a_i = Variable.deduced(i)
assert a_i.type == integer
assert Variable.deduced(Symbol('x', real=True)).type == real
assert a_i.func(*a_i.args) == a_i
v_n2 = Variable.deduced(n, value=3.5, cast_check=False)
assert v_n2.func(*v_n2.args) == v_n2
assert abs(v_n2.value - 3.5) < 1e-15
raises(ValueError, lambda: Variable.deduced(n, value=3.5, cast_check=True))
v_n3 = Variable.deduced(n)
assert v_n3.type == integer
assert str(v_n3) == 'Variable(n, type=integer)'
assert Variable.deduced(z, value=3).type == integer
assert Variable.deduced(z, value=3.0).type == real
assert Variable.deduced(z, value=3.0+1j).type == complex_
