def test_case():
ob = FCodePrinter()
x,x_,x__,y,X,X_,Y = symbols('x,x_,x__,y,X,X_,Y')
assert fcode(exp(x_) + sin(x*y) + cos(X*Y)) == \
' exp(x_) + sin(x*y) + cos(X__*Y_)'
assert fcode(exp(x__) + 2*x*Y*X_**Rational(7, 2)) == \
' 2*X_**(7.0d0/2.0d0)*Y*x + exp(x__)'
assert fcode(exp(x_) + sin(x*y) + cos(X*Y), name_mangling=False) == \
' exp(x_) + sin(x*y) + cos(X*Y)'
assert fcode(x - cos(X), name_mangling=False) == ' x - cos(X)'
assert ob.doprint(X*sin(x) + x_, assign_to='me') == ' me = X*sin(x_) + x__'
assert ob.doprint(X*sin(x), assign_to='mu') == ' mu = X*sin(x_)'
assert ob.doprint(x_, assign_to='ad') == ' ad = x__'
n, m = symbols('n,m', integer=True)
A = IndexedBase('A')
x = IndexedBase('x')
y = IndexedBase('y')
i = Idx('i', m)
I = Idx('I', n)
assert fcode(A[i, I]*x[I], assign_to=y[i], source_format='free') == (
"do i = 1, m\n"
" y(i) = 0\n"
"end do\n"
"do i = 1, m\n"
" do I_ = 1, n\n"
" y(i) = A(i, I_)*x(I_) + y(i)\n"
" end do\n"
"end do" )
def test_case():
ob = FCodePrinter()
x, x_, x__, y, X, X_, Y = symbols('x,x_,x__,y,X,X_,Y')
assert fcode(exp(x_) + sin(x*y) + cos(X*Y)) == \
' exp(x_) + sin(x*y) + cos(X__*Y_)'
assert fcode(exp(x__) + 2*x*Y*X_**Rational(7, 2)) == \
' 2*X_**(7.0d0/2.0d0)*Y*x + exp(x__)'
assert fcode(exp(x_) + sin(x*y) + cos(X*Y), name_mangling=False) == \
' exp(x_) + sin(x*y) + cos(X*Y)'
assert fcode(x - cos(X), name_mangling=False) == ' x - cos(X)'
assert ob.doprint(X * sin(x) + x_,
assign_to='me') == ' me = X*sin(x_) + x__'
assert ob.doprint(X * sin(x), assign_to='mu') == ' mu = X*sin(x_)'
assert ob.doprint(x_, assign_to='ad') == ' ad = x__'
n, m = symbols('n,m', integer=True)
A = IndexedBase('A')
x = IndexedBase('x')
y = IndexedBase('y')
i = Idx('i', m)
I = Idx('I', n)
assert fcode(
A[i, I] * x[I], assign_to=y[i],
source_format='free') == ("do i = 1, m\n"
" y(i) = 0\n"
"end do\n"
"do i = 1, m\n"
" do I_ = 1, n\n"
" y(i) = A(i, I_)*x(I_) + y(i)\n"
" end do\n"
"end do")
def render_as_module(definitions, name, declarations=(), printer_settings=None):
""" Creates a ``Module`` instance and renders it as a string.
This generates Fortran source code for a module with the correct ``use`` statements.
Parameters
==========
definitions : iterable
Passed to :class:`sympy.codegen.fnodes.Module`.
name : str
Passed to :class:`sympy.codegen.fnodes.Module`.
declarations : iterable
Passed to :class:`sympy.codegen.fnodes.Module`. It will be extended with
use statements, 'implicit none' and public list generated from ``definitions``.
printer_settings : dict
Passed to ``FCodePrinter`` (default: ``{'standard': 2003, 'source_format': 'free'}``).
"""
printer_settings = printer_settings or {'standard': 2003, 'source_format': 'free'}
printer = FCodePrinter(printer_settings)
dummy = Dummy()
if isinstance(definitions, Module):
raise ValueError("This function expects to construct a module on its own.")
mod = Module(name, chain(declarations, [dummy]), definitions)
fstr = printer.doprint(mod)
module_use_str = ' %s\n' % ' \n'.join(['use %s, only: %s' % (k, ', '.join(v)) for
k, v in printer.module_uses.items()])
module_use_str += ' implicit none\n'
module_use_str += ' private\n'
module_use_str += ' public %s\n' % ', '.join([str(node.name) for node in definitions if getattr(node, 'name', None)])
return fstr.replace(printer.doprint(dummy), module_use_str)
return fstr
def test_case():
ob = FCodePrinter()
x, x_, x__, y, X, X_, Y = symbols("x,x_,x__,y,X,X_,Y")
assert (fcode(exp(x_) + sin(x * y) +
cos(X * Y)) == " exp(x_) + sin(x*y) + cos(X__*Y_)")
assert (fcode(exp(x__) + 2 * x * Y * X_**Rational(7, 2)) ==
" 2*X_**(7.0d0/2.0d0)*Y*x + exp(x__)")
assert (fcode(
exp(x_) + sin(x * y) + cos(X * Y),
name_mangling=False) == " exp(x_) + sin(x*y) + cos(X*Y)")
assert fcode(x - cos(X), name_mangling=False) == " x - cos(X)"
assert ob.doprint(X * sin(x) + x_,
assign_to="me") == " me = X*sin(x_) + x__"
assert ob.doprint(X * sin(x), assign_to="mu") == " mu = X*sin(x_)"
assert ob.doprint(x_, assign_to="ad") == " ad = x__"
n, m = symbols("n,m", integer=True)
A = IndexedBase("A")
x = IndexedBase("x")
y = IndexedBase("y")
i = Idx("i", m)
I = Idx("I", n)
assert fcode(
A[i, I] * x[I], assign_to=y[i],
source_format="free") == ("do i = 1, m\n"
" y(i) = 0\n"
"end do\n"
"do i = 1, m\n"
" do I_ = 1, n\n"
" y(i) = A(i, I_)*x(I_) + y(i)\n"
" end do\n"
"end do")
def test_loops():
from sympy import symbols
i,j,n,m = symbols('i j n m', integer=True)
A,x,y = symbols('A x y')
A = Indexed(A)(Idx(i, m), Idx(j, n))
x = Indexed(x)(Idx(j, n))
y = Indexed(y)(Idx(i, m))
# human = False
printer = FCodePrinter({ 'source_format': 'free', 'assign_to':y, 'human':0})
expected = ([], set([A, x, y, Idx(j, n), Idx(i, m)]), 'do i = 1, m\n do j = 1, n\n y(i) = A(i, j)*x(j)\n end do\nend do')
code = printer.doprint(A*x)
# assert expected == code
# human = True
printer = FCodePrinter({ 'source_format': 'free', 'assign_to':y, 'human':1})
expected = (
'! Not Fortran:\n'
'! A(i, j)\n'
'! i\n'
'! j\n'
'! x(j)\n'
'! y(i)\n'
'do i = 1, m\n'
' do j = 1, n\n'
' y(i) = A(i, j)*x(j)\n'
' end do\n'
'end do'
)
code = printer.doprint(A*x)
assert expected == code
