|
|
from sympy.core import (S, pi, oo, symbols, Rational, Integer, |
|
|
GoldenRatio, EulerGamma, Catalan, Lambda, Dummy, |
|
|
Eq, Ne, Le, Lt, Gt, Ge, Mod) |
|
|
from sympy.functions import (Piecewise, sin, cos, Abs, exp, ceiling, sqrt, |
|
|
sign, floor) |
|
|
from sympy.logic import ITE |
|
|
from sympy.testing.pytest import raises |
|
|
from sympy.utilities.lambdify import implemented_function |
|
|
from sympy.tensor import IndexedBase, Idx |
|
|
from sympy.matrices import MatrixSymbol, SparseMatrix, Matrix |
|
|
|
|
|
from sympy.printing.codeprinter import rust_code |
|
|
|
|
|
x, y, z = symbols('x,y,z', integer=False, real=True) |
|
|
k, m, n = symbols('k,m,n', integer=True) |
|
|
|
|
|
|
|
|
def test_Integer(): |
|
|
assert rust_code(Integer(42)) == "42" |
|
|
assert rust_code(Integer(-56)) == "-56" |
|
|
|
|
|
|
|
|
def test_Relational(): |
|
|
assert rust_code(Eq(x, y)) == "x == y" |
|
|
assert rust_code(Ne(x, y)) == "x != y" |
|
|
assert rust_code(Le(x, y)) == "x <= y" |
|
|
assert rust_code(Lt(x, y)) == "x < y" |
|
|
assert rust_code(Gt(x, y)) == "x > y" |
|
|
assert rust_code(Ge(x, y)) == "x >= y" |
|
|
|
|
|
|
|
|
def test_Rational(): |
|
|
assert rust_code(Rational(3, 7)) == "3_f64/7.0" |
|
|
assert rust_code(Rational(18, 9)) == "2" |
|
|
assert rust_code(Rational(3, -7)) == "-3_f64/7.0" |
|
|
assert rust_code(Rational(-3, -7)) == "3_f64/7.0" |
|
|
assert rust_code(x + Rational(3, 7)) == "x + 3_f64/7.0" |
|
|
assert rust_code(Rational(3, 7)*x) == "(3_f64/7.0)*x" |
|
|
|
|
|
|
|
|
def test_basic_ops(): |
|
|
assert rust_code(x + y) == "x + y" |
|
|
assert rust_code(x - y) == "x - y" |
|
|
assert rust_code(x * y) == "x*y" |
|
|
assert rust_code(x / y) == "x*y.recip()" |
|
|
assert rust_code(-x) == "-x" |
|
|
assert rust_code(2 * x) == "2.0*x" |
|
|
assert rust_code(y + 2) == "y + 2.0" |
|
|
assert rust_code(x + n) == "n as f64 + x" |
|
|
|
|
|
def test_printmethod(): |
|
|
class fabs(Abs): |
|
|
def _rust_code(self, printer): |
|
|
return "%s.fabs()" % printer._print(self.args[0]) |
|
|
assert rust_code(fabs(x)) == "x.fabs()" |
|
|
a = MatrixSymbol("a", 1, 3) |
|
|
assert rust_code(a[0,0]) == 'a[0]' |
|
|
|
|
|
|
|
|
def test_Functions(): |
|
|
assert rust_code(sin(x) ** cos(x)) == "x.sin().powf(x.cos())" |
|
|
assert rust_code(abs(x)) == "x.abs()" |
|
|
assert rust_code(ceiling(x)) == "x.ceil()" |
|
|
assert rust_code(floor(x)) == "x.floor()" |
|
|
|
|
|
|
|
|
assert rust_code(Mod(x, 3)) == 'x - 3.0*((1_f64/3.0)*x).floor()' |
|
|
|
|
|
|
|
|
def test_Pow(): |
|
|
assert rust_code(1/x) == "x.recip()" |
|
|
assert rust_code(x**-1) == rust_code(x**-1.0) == "x.recip()" |
|
|
assert rust_code(sqrt(x)) == "x.sqrt()" |
|
|
assert rust_code(x**S.Half) == rust_code(x**0.5) == "x.sqrt()" |
|
|
|
|
|
assert rust_code(1/sqrt(x)) == "x.sqrt().recip()" |
|
|
assert rust_code(x**-S.Half) == rust_code(x**-0.5) == "x.sqrt().recip()" |
|
|
|
|
|
assert rust_code(1/pi) == "PI.recip()" |
|
|
assert rust_code(pi**-1) == rust_code(pi**-1.0) == "PI.recip()" |
|
|
assert rust_code(pi**-0.5) == "PI.sqrt().recip()" |
|
|
|
|
|
assert rust_code(x**Rational(1, 3)) == "x.cbrt()" |
|
|
assert rust_code(2**x) == "x.exp2()" |
|
|
assert rust_code(exp(x)) == "x.exp()" |
|
|
assert rust_code(x**3) == "x.powi(3)" |
|
|
assert rust_code(x**(y**3)) == "x.powf(y.powi(3))" |
|
|
assert rust_code(x**Rational(2, 3)) == "x.powf(2_f64/3.0)" |
|
|
|
|
|
g = implemented_function('g', Lambda(x, 2*x)) |
|
|
assert rust_code(1/(g(x)*3.5)**(x - y**x)/(x**2 + y)) == \ |
|
|
"(3.5*2.0*x).powf(-x + y.powf(x))/(x.powi(2) + y)" |
|
|
_cond_cfunc = [(lambda base, exp: exp.is_integer, "dpowi", 1), |
|
|
(lambda base, exp: not exp.is_integer, "pow", 1)] |
|
|
assert rust_code(x**3, user_functions={'Pow': _cond_cfunc}) == 'x.dpowi(3)' |
|
|
assert rust_code(x**3.2, user_functions={'Pow': _cond_cfunc}) == 'x.pow(3.2)' |
|
|
|
|
|
|
|
|
def test_constants(): |
|
|
assert rust_code(pi) == "PI" |
|
|
assert rust_code(oo) == "INFINITY" |
|
|
assert rust_code(S.Infinity) == "INFINITY" |
|
|
assert rust_code(-oo) == "NEG_INFINITY" |
|
|
assert rust_code(S.NegativeInfinity) == "NEG_INFINITY" |
|
|
assert rust_code(S.NaN) == "NAN" |
|
|
assert rust_code(exp(1)) == "E" |
|
|
assert rust_code(S.Exp1) == "E" |
|
|
|
|
|
|
|
|
def test_constants_other(): |
|
|
assert rust_code(2*GoldenRatio) == "const GoldenRatio: f64 = %s;\n2.0*GoldenRatio" % GoldenRatio.evalf(17) |
|
|
assert rust_code( |
|
|
2*Catalan) == "const Catalan: f64 = %s;\n2.0*Catalan" % Catalan.evalf(17) |
|
|
assert rust_code(2*EulerGamma) == "const EulerGamma: f64 = %s;\n2.0*EulerGamma" % EulerGamma.evalf(17) |
|
|
|
|
|
|
|
|
def test_boolean(): |
|
|
assert rust_code(True) == "true" |
|
|
assert rust_code(S.true) == "true" |
|
|
assert rust_code(False) == "false" |
|
|
assert rust_code(S.false) == "false" |
|
|
assert rust_code(k & m) == "k && m" |
|
|
assert rust_code(k | m) == "k || m" |
|
|
assert rust_code(~k) == "!k" |
|
|
assert rust_code(k & m & n) == "k && m && n" |
|
|
assert rust_code(k | m | n) == "k || m || n" |
|
|
assert rust_code((k & m) | n) == "n || k && m" |
|
|
assert rust_code((k | m) & n) == "n && (k || m)" |
|
|
|
|
|
|
|
|
def test_Piecewise(): |
|
|
expr = Piecewise((x, x < 1), (x + 2, True)) |
|
|
assert rust_code(expr) == ( |
|
|
"if (x < 1.0) {\n" |
|
|
" x\n" |
|
|
"} else {\n" |
|
|
" x + 2.0\n" |
|
|
"}") |
|
|
assert rust_code(expr, assign_to="r") == ( |
|
|
"r = if (x < 1.0) {\n" |
|
|
" x\n" |
|
|
"} else {\n" |
|
|
" x + 2.0\n" |
|
|
"};") |
|
|
assert rust_code(expr, assign_to="r", inline=True) == ( |
|
|
"r = if (x < 1.0) { x } else { x + 2.0 };") |
|
|
expr = Piecewise((x, x < 1), (x + 1, x < 5), (x + 2, True)) |
|
|
assert rust_code(expr, inline=True) == ( |
|
|
"if (x < 1.0) { x } else if (x < 5.0) { x + 1.0 } else { x + 2.0 }") |
|
|
assert rust_code(expr, assign_to="r", inline=True) == ( |
|
|
"r = if (x < 1.0) { x } else if (x < 5.0) { x + 1.0 } else { x + 2.0 };") |
|
|
assert rust_code(expr, assign_to="r") == ( |
|
|
"r = if (x < 1.0) {\n" |
|
|
" x\n" |
|
|
"} else if (x < 5.0) {\n" |
|
|
" x + 1.0\n" |
|
|
"} else {\n" |
|
|
" x + 2.0\n" |
|
|
"};") |
|
|
expr = 2*Piecewise((x, x < 1), (x + 1, x < 5), (x + 2, True)) |
|
|
assert rust_code(expr, inline=True) == ( |
|
|
"2.0*if (x < 1.0) { x } else if (x < 5.0) { x + 1.0 } else { x + 2.0 }") |
|
|
expr = 2*Piecewise((x, x < 1), (x + 1, x < 5), (x + 2, True)) - 42 |
|
|
assert rust_code(expr, inline=True) == ( |
|
|
"2.0*if (x < 1.0) { x } else if (x < 5.0) { x + 1.0 } else { x + 2.0 } - 42.0") |
|
|
|
|
|
expr = Piecewise((x, x < 1), (x**2, x > 1), (sin(x), x > 0)) |
|
|
raises(ValueError, lambda: rust_code(expr)) |
|
|
|
|
|
|
|
|
def test_dereference_printing(): |
|
|
expr = x + y + sin(z) + z |
|
|
assert rust_code(expr, dereference=[z]) == "x + y + (*z) + (*z).sin()" |
|
|
|
|
|
|
|
|
def test_sign(): |
|
|
expr = sign(x) * y |
|
|
assert rust_code(expr) == "y*(if (x == 0.0) { 0.0 } else { (x).signum() }) as f64" |
|
|
assert rust_code(expr, assign_to='r') == "r = y*(if (x == 0.0) { 0.0 } else { (x).signum() }) as f64;" |
|
|
|
|
|
expr = sign(x + y) + 42 |
|
|
assert rust_code(expr) == "(if (x + y == 0.0) { 0.0 } else { (x + y).signum() }) + 42" |
|
|
assert rust_code(expr, assign_to='r') == "r = (if (x + y == 0.0) { 0.0 } else { (x + y).signum() }) + 42;" |
|
|
|
|
|
expr = sign(cos(x)) |
|
|
assert rust_code(expr) == "(if (x.cos() == 0.0) { 0.0 } else { (x.cos()).signum() })" |
|
|
|
|
|
|
|
|
def test_reserved_words(): |
|
|
|
|
|
x, y = symbols("x if") |
|
|
|
|
|
expr = sin(y) |
|
|
assert rust_code(expr) == "if_.sin()" |
|
|
assert rust_code(expr, dereference=[y]) == "(*if_).sin()" |
|
|
assert rust_code(expr, reserved_word_suffix='_unreserved') == "if_unreserved.sin()" |
|
|
|
|
|
with raises(ValueError): |
|
|
rust_code(expr, error_on_reserved=True) |
|
|
|
|
|
|
|
|
def test_ITE(): |
|
|
ekpr = ITE(k < 1, m, n) |
|
|
assert rust_code(ekpr) == ( |
|
|
"if (k < 1) {\n" |
|
|
" m\n" |
|
|
"} else {\n" |
|
|
" n\n" |
|
|
"}") |
|
|
|
|
|
|
|
|
def test_Indexed(): |
|
|
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] |
|
|
assert rust_code(x) == "x[j]" |
|
|
|
|
|
A = IndexedBase('A')[i, j] |
|
|
assert rust_code(A) == "A[m*i + j]" |
|
|
|
|
|
B = IndexedBase('B')[i, j, k] |
|
|
assert rust_code(B) == "B[m*o*i + o*j + k]" |
|
|
|
|
|
|
|
|
def test_dummy_loops(): |
|
|
i, m = symbols('i m', integer=True, cls=Dummy) |
|
|
x = IndexedBase('x') |
|
|
y = IndexedBase('y') |
|
|
i = Idx(i, m) |
|
|
|
|
|
assert rust_code(x[i], assign_to=y[i]) == ( |
|
|
"for i in 0..m {\n" |
|
|
" y[i] = x[i];\n" |
|
|
"}") |
|
|
|
|
|
|
|
|
def test_loops(): |
|
|
m, n = symbols('m n', integer=True) |
|
|
A = IndexedBase('A') |
|
|
x = IndexedBase('x') |
|
|
y = IndexedBase('y') |
|
|
z = IndexedBase('z') |
|
|
i = Idx('i', m) |
|
|
j = Idx('j', n) |
|
|
|
|
|
assert rust_code(A[i, j]*x[j], assign_to=y[i]) == ( |
|
|
"for i in 0..m {\n" |
|
|
" y[i] = 0;\n" |
|
|
"}\n" |
|
|
"for i in 0..m {\n" |
|
|
" for j in 0..n {\n" |
|
|
" y[i] = A[n*i + j]*x[j] + y[i];\n" |
|
|
" }\n" |
|
|
"}") |
|
|
|
|
|
assert rust_code(A[i, j]*x[j] + x[i] + z[i], assign_to=y[i]) == ( |
|
|
"for i in 0..m {\n" |
|
|
" y[i] = x[i] + z[i];\n" |
|
|
"}\n" |
|
|
"for i in 0..m {\n" |
|
|
" for j in 0..n {\n" |
|
|
" y[i] = A[n*i + j]*x[j] + y[i];\n" |
|
|
" }\n" |
|
|
"}") |
|
|
|
|
|
|
|
|
def test_loops_multiple_contractions(): |
|
|
n, m, o, p = symbols('n m o p', integer=True) |
|
|
a = IndexedBase('a') |
|
|
b = IndexedBase('b') |
|
|
y = IndexedBase('y') |
|
|
i = Idx('i', m) |
|
|
j = Idx('j', n) |
|
|
k = Idx('k', o) |
|
|
l = Idx('l', p) |
|
|
|
|
|
assert rust_code(b[j, k, l]*a[i, j, k, l], assign_to=y[i]) == ( |
|
|
"for i in 0..m {\n" |
|
|
" y[i] = 0;\n" |
|
|
"}\n" |
|
|
"for i in 0..m {\n" |
|
|
" for j in 0..n {\n" |
|
|
" for k in 0..o {\n" |
|
|
" for l in 0..p {\n" |
|
|
" y[i] = a[%s]*b[%s] + y[i];\n" % (i*n*o*p + j*o*p + k*p + l, j*o*p + k*p + l) +\ |
|
|
" }\n" |
|
|
" }\n" |
|
|
" }\n" |
|
|
"}") |
|
|
|
|
|
|
|
|
def test_loops_addfactor(): |
|
|
m, n, o, p = symbols('m n o p', integer=True) |
|
|
a = IndexedBase('a') |
|
|
b = IndexedBase('b') |
|
|
c = IndexedBase('c') |
|
|
y = IndexedBase('y') |
|
|
i = Idx('i', m) |
|
|
j = Idx('j', n) |
|
|
k = Idx('k', o) |
|
|
l = Idx('l', p) |
|
|
|
|
|
code = rust_code((a[i, j, k, l] + b[i, j, k, l])*c[j, k, l], assign_to=y[i]) |
|
|
assert code == ( |
|
|
"for i in 0..m {\n" |
|
|
" y[i] = 0;\n" |
|
|
"}\n" |
|
|
"for i in 0..m {\n" |
|
|
" for j in 0..n {\n" |
|
|
" for k in 0..o {\n" |
|
|
" for l in 0..p {\n" |
|
|
" y[i] = (a[%s] + b[%s])*c[%s] + y[i];\n" % (i*n*o*p + j*o*p + k*p + l, i*n*o*p + j*o*p + k*p + l, j*o*p + k*p + l) +\ |
|
|
" }\n" |
|
|
" }\n" |
|
|
" }\n" |
|
|
"}") |
|
|
|
|
|
|
|
|
def test_settings(): |
|
|
raises(TypeError, lambda: rust_code(sin(x), method="garbage")) |
|
|
|
|
|
|
|
|
def test_inline_function(): |
|
|
x = symbols('x') |
|
|
g = implemented_function('g', Lambda(x, 2*x)) |
|
|
assert rust_code(g(x)) == "2*x" |
|
|
|
|
|
g = implemented_function('g', Lambda(x, 2*x/Catalan)) |
|
|
assert rust_code(g(x)) == ( |
|
|
"const Catalan: f64 = %s;\n2.0*x/Catalan" % Catalan.evalf(17)) |
|
|
|
|
|
A = IndexedBase('A') |
|
|
i = Idx('i', symbols('n', integer=True)) |
|
|
g = implemented_function('g', Lambda(x, x*(1 + x)*(2 + x))) |
|
|
assert rust_code(g(A[i]), assign_to=A[i]) == ( |
|
|
"for i in 0..n {\n" |
|
|
" A[i] = (A[i] + 1)*(A[i] + 2)*A[i];\n" |
|
|
"}") |
|
|
|
|
|
|
|
|
def test_user_functions(): |
|
|
x = symbols('x', integer=False) |
|
|
n = symbols('n', integer=True) |
|
|
custom_functions = { |
|
|
"ceiling": "ceil", |
|
|
"Abs": [(lambda x: not x.is_integer, "fabs", 4), (lambda x: x.is_integer, "abs", 4)], |
|
|
} |
|
|
assert rust_code(ceiling(x), user_functions=custom_functions) == "x.ceil()" |
|
|
assert rust_code(Abs(x), user_functions=custom_functions) == "fabs(x)" |
|
|
assert rust_code(Abs(n), user_functions=custom_functions) == "abs(n)" |
|
|
|
|
|
|
|
|
def test_matrix(): |
|
|
assert rust_code(Matrix([1, 2, 3])) == '[1, 2, 3]' |
|
|
with raises(ValueError): |
|
|
rust_code(Matrix([[1, 2, 3]])) |
|
|
|
|
|
|
|
|
def test_sparse_matrix(): |
|
|
|
|
|
with raises(NotImplementedError): |
|
|
rust_code(SparseMatrix([[1, 2, 3]])) |
|
|
|
