def test_ccode_Indexed():
from sympy.tensor import IndexedBase, Idx
from sympy import symbols
s, n, m, o = symbols('s n m o', integer=True)
i, j, k = Idx('i', n), Idx('j', m), Idx('k', o)
x = IndexedBase('x')[j]
A = IndexedBase('A')[i, j]
B = IndexedBase('B')[i, j, k]
with warnings.catch_warnings():
warnings.filterwarnings("ignore", category=SymPyDeprecationWarning)
p = CCodePrinter()
p._not_c = set()
assert p._print_Indexed(x) == 'x[j]'
assert p._print_Indexed(A) == 'A[%s]' % (m*i+j)
assert p._print_Indexed(B) == 'B[%s]' % (i*o*m+j*o+k)
assert p._not_c == set()
A = IndexedBase('A', shape=(5,3))[i, j]
assert p._print_Indexed(A) == 'A[%s]' % (3*i + j)
A = IndexedBase('A', shape=(5,3), strides='F')[i, j]
assert ccode(A) == 'A[%s]' % (i + 5*j)
A = IndexedBase('A', shape=(29,29), strides=(1, s), offset=o)[i, j]
assert ccode(A) == 'A[o + s*j + i]'
Abase = IndexedBase('A', strides=(s, m, n), offset=o)
assert ccode(Abase[i, j, k]) == 'A[m*j + n*k + o + s*i]'
assert ccode(Abase[2, 3, k]) == 'A[3*m + n*k + o + 2*s]'
def test_CCodePrinter():
with warnings.catch_warnings():
warnings.filterwarnings("error", category=SymPyDeprecationWarning)
with raises(SymPyDeprecationWarning):
CCodePrinter()
with warnings.catch_warnings():
warnings.filterwarnings("ignore", category=SymPyDeprecationWarning)
assert CCodePrinter().language == 'C'
def test_ccode_Indexed():
from sympy.tensor import IndexedBase, Idx
from sympy import symbols
i, j, k, n, m, o = symbols('i j k n m o', integer=True)
p = CCodePrinter()
p._not_c = set()
x = IndexedBase('x')[Idx(j, n)]
assert p._print_Indexed(x) == 'x[j]'
A = IndexedBase('A')[Idx(i, m), Idx(j, n)]
assert p._print_Indexed(A) == 'A[%s]' % str(j + n*i)
B = IndexedBase('B')[Idx(i, m), Idx(j, n), Idx(k, o)]
assert p._print_Indexed(B) == 'B[%s]' % str(k + i*n*o + j*o)
assert p._not_c == set()
def test_ccode_Indexed():
from sympy.tensor import IndexedBase, Idx
from sympy import symbols
n, m, o = symbols('n m o', integer=True)
i, j, k = Idx('i', n), Idx('j', m), Idx('k', o)
p = CCodePrinter()
p._not_c = set()
x = IndexedBase('x')[j]
assert p._print_Indexed(x) == 'x[j]'
A = IndexedBase('A')[i, j]
assert p._print_Indexed(A) == 'A[%s]' % (m*i+j)
B = IndexedBase('B')[i, j, k]
assert p._print_Indexed(B) == 'B[%s]' % (i*o*m+j*o+k)
assert p._not_c == set()
def _print_Mul(self, expr):
if len(expr.args) == 2: # log2 and log10
a, b = expr.args
if is_inv(a) and is_log(a.base) and is_log(b):
log_base = a.base.args[0]
if log_base in [2, 10]:
return "log%d(%s)" % (log_base, self._print(b.args[0]))
return CCodePrinter._print_Mul(self, expr)
def test_ccode_Indexed():
from sympy.tensor import IndexedBase, Idx
from sympy import symbols
n, m, o = symbols('n m o', integer=True)
i, j, k = Idx('i', n), Idx('j', m), Idx('k', o)
x = IndexedBase('x')[j]
A = IndexedBase('A')[i, j]
B = IndexedBase('B')[i, j, k]
with warnings.catch_warnings():
warnings.filterwarnings("ignore", category=SymPyDeprecationWarning)
p = CCodePrinter()
p._not_c = set()
assert p._print_Indexed(x) == 'x[j]'
assert p._print_Indexed(A) == 'A[%s]' % (m * i + j)
assert p._print_Indexed(B) == 'B[%s]' % (i * o * m + j * o + k)
assert p._not_c == set()
def test_ccode_Indexed():
from sympy.tensor import IndexedBase, Idx
from sympy import symbols
n, m, o = symbols('n m o', integer=True)
i, j, k = Idx('i', n), Idx('j', m), Idx('k', o)
x = IndexedBase('x')[j]
A = IndexedBase('A')[i, j]
B = IndexedBase('B')[i, j, k]
with warnings.catch_warnings():
warnings.filterwarnings("ignore", category=SymPyDeprecationWarning)
p = CCodePrinter()
p._not_c = set()
assert p._print_Indexed(x) == 'x[j]'
assert p._print_Indexed(A) == 'A[%s]' % (m*i+j)
assert p._print_Indexed(B) == 'B[%s]' % (i*o*m+j*o+k)
assert p._not_c == set()
def test_ccode_Indexed():
from sympy.tensor import IndexedBase, Idx
from sympy import symbols
s, n, m, o = symbols('s n m o', integer=True)
i, j, k = Idx('i', n), Idx('j', m), Idx('k', o)
x = IndexedBase('x')[j]
A = IndexedBase('A')[i, j]
B = IndexedBase('B')[i, j, k]
with warnings.catch_warnings():
warnings.filterwarnings("ignore", category=SymPyDeprecationWarning)
p = CCodePrinter()
p._not_c = set()
assert p._print_Indexed(x) == 'x[j]'
assert p._print_Indexed(A) == 'A[%s]' % (m * i + j)
assert p._print_Indexed(B) == 'B[%s]' % (i * o * m + j * o + k)
assert p._not_c == set()
A = IndexedBase('A', shape=(5, 3))[i, j]
assert p._print_Indexed(A) == 'A[%s]' % (3 * i + j)
A = IndexedBase('A', shape=(5, 3), strides='F')[i, j]
assert ccode(A) == 'A[%s]' % (i + 5 * j)
A = IndexedBase('A', shape=(29, 29), strides=(1, s), offset=o)[i, j]
assert ccode(A) == 'A[o + s*j + i]'
Abase = IndexedBase('A', strides=(s, m, n), offset=o)
assert ccode(Abase[i, j, k]) == 'A[m*j + n*k + o + s*i]'
assert ccode(Abase[2, 3, k]) == 'A[3*m + n*k + o + 2*s]'
def convert_to(self, language, symbols={}, namespace={}):
'''
Converts expression into a string for the given ``language`` using the
given set of ``symbols``. Replaces each :class:`Symbol` appearing in the
expression with ``sym.read()``, and if the language is C++ or GPU then
uses ``sympy.CCodePrinter().doprint()`` to convert the syntax, e.g.
``x**y`` becomes ``pow(x,y)``.
'''
if language.name == 'python':
return substitute_symbols(self.expr, symbols)
elif language.name == 'c' or language.name == 'gpu':
return substitute_symbols(CCodePrinter().doprint(self.sympy_expr),
symbols)
def __init__(self,
settings={},
tab=' ',
level=0,
array_format='C',
epsilon_nan=0,
epsilon_inf=0,
epsilon_power=1,
assertions=False,
contracts=False,
postcheck_hooks=False,
do_cse=True,
user_exprs=[]):
CCodePrinter.__init__(self, settings)
self._some_vars = SomeVars()
self._value_type = 'double'
self._relational_type = 'int'
self._assignments_values = dict()
self._decls = dict()
self._varid = dict()
self._declared = dict()
self._affcts = dict()
self._cond_affcts = dict()
self._tab = tab
self._level = level
self._do_cse = do_cse
self._array_format = array_format
self._epsilon_nan = epsilon_nan
self._epsilon_inf = epsilon_inf
self._epsilon_power = epsilon_power
self._assertions = assertions
self._contracts = contracts
self._postcheck_hooks = postcheck_hooks
self._current_condition = None
self._sign = dict()
self._user_exprs = user_exprs
self._var_asserts = {}
def __init__(self, **kwargs):
"""Initialize a C code printer.
The printer class, the name of the template, the line continuation
symbol, and the statement ending will be set automatically.
"""
super().__init__(
CCodePrinter(),
lambda base, indices: ''.join(
[base] + ['[{}]'.format(i.index) for i in indices]),
line_cont='\\',
stmt_end=';',
add_filters={
'form_loop_beg': _form_c_loop_beg,
'form_loop_end': _form_c_loop_end,
},
add_globals={'zero_literal': '0.0'},
**kwargs)
def test_ccode_Indexed():
from sympy.tensor import IndexedBase, Idx
from sympy import symbols
i, j, k, n, m, o = symbols('i j k n m o', integer=True)
p = CCodePrinter()
p._not_c = set()
x = IndexedBase('x')[Idx(j, n)]
assert p._print_Indexed(x) == 'x[j]'
A = IndexedBase('A')[Idx(i, m), Idx(j, n)]
assert p._print_Indexed(A) == 'A[%s]' % str(j + n * i)
B = IndexedBase('B')[Idx(i, m), Idx(j, n), Idx(k, o)]
assert p._print_Indexed(B) == 'B[%s]' % str(k + i * n * o + j * o)
assert p._not_c == set()
def test_ccode_Indexed():
from sympy.tensor import IndexedBase, Idx
from sympy import symbols
n, m, o = symbols('n m o', integer=True)
i, j, k = Idx('i', n), Idx('j', m), Idx('k', o)
p = CCodePrinter()
p._not_c = set()
x = IndexedBase('x')[j]
assert p._print_Indexed(x) == 'x[j]'
A = IndexedBase('A')[i, j]
assert p._print_Indexed(A) == 'A[%s]' % (m * i + j)
B = IndexedBase('B')[i, j, k]
assert p._print_Indexed(B) == 'B[%s]' % (i * o * m + j * o + k)
assert p._not_c == set()
def _print_Pow(self, expr):
if expr.base == 2:
return "exp2(%s)" % self._print(expr.exp)
if expr.base == 10:
return "exp10(%s)" % self._print(expr.exp)
if expr.exp == 0.5 and isinstance(expr.base, Add):
args = expr.base.args
if len(args) == 2 and all(map(is_square, args)):
if self.order != 'none':
args = self._as_ordered_terms(expr.base, order=None)
# TODO: (above) is it fine to use `order=None`?
return "hypot(%s, %s)" % (self._print(args[0].args[0]),
self._print(args[1].args[0]))
if expr.exp == Rational(1, 3):
return "cbrt(%s)" % self._print(expr.base)
if expr.exp.is_integer and expr.exp != -1:
return "pown(%s, %s)" % (
self._print(expr.base), self._print(expr.exp))
if expr.exp.is_positive and expr.exp != 0.5:
return "powr(%s, %s)" % (
self._print(expr.base), self._print(expr.exp))
return CCodePrinter._print_Pow(self, expr)
def test_CCodePrinter():
with warns_deprecated_sympy():
CCodePrinter()
with warns_deprecated_sympy():
assert CCodePrinter().language == 'C'
def _indent_code(self, codelines):
p = CCodePrinter()
return p.indent_code(codelines)
def convert_to(self, language, symbols={}):
if language.name == 'python':
return self.substitute_symbols(self.expr, symbols)
elif language.name == 'c':
return self.substitute_symbols(
CCodePrinter().doprint(self.sympy_expr), symbols)
def __init__(self, settings={}):
settings = dict(settings)
userfuncs = settings.setdefault('user_functions', {})
for k, v in known_functions.items():
userfuncs.setdefault(k, v)
CCodePrinter.__init__(self, settings)
def __init__(self, settings={}):
CCodePrinter.__init__(self, settings)
def __init__(self, settings={}):
CCodePrinter.__init__(self, settings)
custom_functions = {'INT': '(int)', 'FLOAT': '(float)'}
self.known_functions.update(custom_functions)
def _indent_code(self, codelines):
p = CCodePrinter()
return p.indent_code(codelines)
def __init__(self, settings={}):
CCodePrinter.__init__(self, settings)
def __init__(self, settings={}):
CCodePrinter.__init__(self, settings)
self.known_functions.update(self.custom_functions)