-p[0] - p[1] - 15 * p[10] - 2 * p[11] - 3 * p[12] - 4 * p[13] - 4 * p[2] -
3 * p[3] - 2 * p[4] - 3 * p[6] - 6 * p[7] - 9 * p[8] - 12 * p[9] +
exp(x[0]) + exp(x[1]) + 15 * exp(x[10]) + 2 * exp(x[11]) + 3 * exp(x[12]) +
4 * exp(x[13]) + 4 * exp(x[2]) + 3 * exp(x[3]) + 2 * exp(x[4]) +
3 * exp(x[6]) + 6 * exp(x[7]) + 9 * exp(x[8]) + 12 * exp(x[9]),
-5 * p[10] - p[2] - p[3] - p[6] - 2 * p[7] - 3 * p[8] - 4 * p[9] +
5 * exp(x[10]) + exp(x[2]) + exp(x[3]) + exp(x[6]) + 2 * exp(x[7]) +
3 * exp(x[8]) + 4 * exp(x[9]), -p[1] - 2 * p[11] - 3 * p[12] - 4 * p[13] -
p[4] + exp(x[1]) + 2 * exp(x[11]) + 3 * exp(x[12]) + 4 * exp(x[13]) +
exp(x[4]), -p[10] - 2 * p[11] - p[12] - p[13] - p[5] - p[6] - p[7] - p[8] -
p[9] + exp(x[10]) + 2 * exp(x[11]) + exp(x[12]) + exp(x[13]) + exp(x[5]) +
exp(x[6]) + exp(x[7]) + exp(x[8]) + exp(x[9])
]
lmb_sp = sp.lambdify(args, exprs, modules='math')
lmb_se = se.Lambdify(args, exprs)
lmb_se_cse = se.LambdifyCSE(args, exprs)
lmb_se_llvm = se.Lambdify(args, exprs, backend='llvm')
inp = np.ones(28)
lmb_sp(*inp)
tim_sympy = clock()
for i in range(500):
res_sympy = lmb_sp(*inp)
tim_sympy = clock() - tim_sympy
lmb_se(inp)
tim_se = clock()
res_se = np.empty(len(exprs))
for i in range(500):
def sym2num(t, expr):
return sym_backend.Lambdify(t, expr)
def test_Lambdify_gh174():
# Tests array broadcasting if the expressions form an N-dimensional array
# of say shape (k, l, m) and it contains 'n' arguments (x1, ... xn), then
# if the user provides a Fortran ordered (column-major) input array of shape
# (n, o, p, q), then the returned array will be of shape (k, l, m, o, p, q)
args = x, y = se.symbols('x y')
nargs = len(args)
vec1 = se.DenseMatrix([x, x**2, x**3])
assert vec1.shape == (3, 1)
assert np.asarray(vec1).shape == (3, 1)
lmb1 = se.Lambdify([x], vec1)
out1 = lmb1(3)
assert out1.shape == (3, 1)
assert np.all(out1 == [[3], [9], [27]])
assert lmb1([2, 3]).shape == (2, 3, 1)
lmb1.order = 'F' # change order
out1a = lmb1([2, 3])
assert out1a.shape == (3, 1, 2)
ref1a_squeeze = [[2, 3], [4, 9], [8, 27]]
assert np.all(out1a.squeeze() == ref1a_squeeze)
assert out1a.flags['F_CONTIGUOUS']
assert not out1a.flags['C_CONTIGUOUS']
lmb2c = se.Lambdify(args, vec1, x + y, order='C')
lmb2f = se.Lambdify(args, vec1, x + y, order='F')
for out2a in [lmb2c([2, 3]), lmb2f([2, 3])]:
assert np.all(out2a[0] == [[2], [4], [8]])
assert out2a[0].ndim == 2
assert out2a[1] == 5
assert out2a[1].ndim == 0
inp2b = np.array([[2.0, 3.0], [1.0, 2.0], [0.0, 6.0]])
raises(ValueError, lambda: (lmb2c(inp2b.T)))
out2c = lmb2c(inp2b)
out2f = lmb2f(np.asfortranarray(inp2b.T))
assert out2c[0].shape == (3, 3, 1)
assert out2f[0].shape == (3, 1, 3)
for idx, (_x, _y) in enumerate(inp2b):
assert np.all(out2c[0][idx, ...] == [[_x], [_x**2], [_x**3]])
assert np.all(out2c[1] == [5, 3, 6])
assert np.all(out2f[1] == [5, 3, 6])
assert out2c[1].shape == (3, )
assert out2f[1].shape == (3, )
def _mtx3(_x, _y):
return [[_x**row_idx + _y**col_idx for col_idx in range(3)]
for row_idx in range(4)]
mtx3c = np.array(_mtx3(x, y), order='C')
mtx3f = np.array(_mtx3(x, y), order='F')
lmb3c = se.Lambdify([x, y], x * y, mtx3c, vec1, order='C')
lmb3f = se.Lambdify([x, y], x * y, mtx3f, vec1, order='F')
inp3c = np.array([[2., 3], [3, 4], [5, 7], [6, 2], [3, 1]])
inp3f = np.asfortranarray(inp3c.T)
raises(ValueError, lambda: (lmb3c(inp3c.T)))
out3c = lmb3c(inp3c)
assert out3c[0].shape == (5, )
assert out3c[1].shape == (5, 4, 3)
assert out3c[2].shape == (
5, 3, 1) # user can apply numpy.squeeze if they want to.
for a, b in zip(out3c, lmb3c(np.ravel(inp3c))):
assert np.all(a == b)
out3f = lmb3f(inp3f)
assert out3f[0].shape == (5, )
assert out3f[1].shape == (4, 3, 5)
assert out3f[2].shape == (
3, 1, 5) # user can apply numpy.squeeze if they want to.
for a, b in zip(out3f, lmb3f(np.ravel(inp3f, order='F'))):
assert np.all(a == b)
for idx, (_x, _y) in enumerate(inp3c):
assert out3c[0][idx] == _x * _y
assert out3f[0][idx] == _x * _y
assert np.all(out3c[1][idx, ...] == _mtx3(_x, _y))
assert np.all(out3f[1][..., idx] == _mtx3(_x, _y))
assert np.all(out3c[2][idx, ...] == [[_x], [_x**2], [_x**3]])
assert np.all(out3f[2][..., idx] == [[_x], [_x**2], [_x**3]])
def test_Lambdify_Piecewise():
_test_Lambdify_Piecewise(
lambda *args: se.Lambdify(*args, backend='lambda'))
if se.have_llvm:
_test_Lambdify_Piecewise(
lambda *args: se.Lambdify(*args, backend='llvm'))
def test_complex_2():
x = se.Symbol('x')
lmb = se.Lambdify([x], [3 + x - 1j], real=False)
assert abs(lmb([11 + 13j])[0] - (14 + 12j)) < 1e-15
def test_Lambdify_scalar_vector_matrix_cse():
_test_Lambdify_scalar_vector_matrix(
lambda *args: se.Lambdify(*args, backend='lambda', cse=True))
if se.have_llvm:
_test_Lambdify_scalar_vector_matrix(
lambda *args: se.Lambdify(*args, backend='llvm', cse=True))
def test_itertools_chain():
args, exprs, inp, check = _get_array()
L = se.Lambdify(args, exprs)
inp = itertools.chain([inp[0]], (inp[1], ), [inp[2]])
A = L(inp)
check(A)
def test_complex_1():
x = se.Symbol('x')
lmb = se.Lambdify([x], [1j + x], real=False)
assert abs(lmb([11 + 13j])[0] - (11 + 14j)) < 1e-15
def test_cse():
args, exprs, inp, ref = _get_cse_exprs()
lmb = se.Lambdify(args, exprs, cse=True)
out = lmb(inp)
assert allclose(out, ref)
def test_cse_big():
args, exprs, inp = _get_cse_exprs_big()
lmb = se.Lambdify(args, exprs, cse=True)
out = lmb(inp)
ref = [expr.xreplace(dict(zip(args, inp))) for expr in exprs]
assert allclose(out, ref)
def test_array():
args, exprs, inp, check = _get_array()
lmb = se.Lambdify(args, exprs)
out = lmb(inp)
check(out)
from time import clock
import numpy as np
import sympy as sp
import symengine as se
# Real-life example (ion speciation problem in water chemistry)
x = sp.symarray('x', 14)
p = sp.symarray('p', 14)
args = np.concatenate((x, p))
exp = sp.exp
exprs = [x[0] + x[1] - x[4] + 36.252574322669, x[0] - x[2] + x[3] + 21.3219379611249, x[3] + x[5] - x[6] + 9.9011158998744, 2*x[3] + x[5] - x[7] + 18.190422234653, 3*x[3] + x[5] - x[8] + 24.8679190043357, 4*x[3] + x[5] - x[9] + 29.9336062089226, -x[10] + 5*x[3] + x[5] + 28.5520551531262, 2*x[0] + x[11] - 2*x[4] - 2*x[5] + 32.4401680272417, 3*x[1] - x[12] + x[5] + 34.9992934135095, 4*x[1] - x[13] + x[5] + 37.0716199972041, p[0] - p[1] + 2*p[10] + 2*p[11] - p[12] - 2*p[13] + p[2] + 2*p[5] + 2*p[6] + 2*p[7] + 2*p[8] + 2*p[9] - exp(x[0]) + exp(x[1]) - 2*exp(x[10]) - 2*exp(x[11]) + exp(x[12]) + 2*exp(x[13]) - exp(x[2]) - 2*exp(x[5]) - 2*exp(x[6]) - 2*exp(x[7]) - 2*exp(x[8]) - 2*exp(x[9]), -p[0] - p[1] - 15*p[10] - 2*p[11] - 3*p[12] - 4*p[13] - 4*p[2] - 3*p[3] - 2*p[4] - 3*p[6] - 6*p[7] - 9*p[8] - 12*p[9] + exp(x[0]) + exp(x[1]) + 15*exp(x[10]) + 2*exp(x[11]) + 3*exp(x[12]) + 4*exp(x[13]) + 4*exp(x[2]) + 3*exp(x[3]) + 2*exp(x[4]) + 3*exp(x[6]) + 6*exp(x[7]) + 9*exp(x[8]) + 12*exp(x[9]), -5*p[10] - p[2] - p[3] - p[6] - 2*p[7] - 3*p[8] - 4*p[9] + 5*exp(x[10]) + exp(x[2]) + exp(x[3]) + exp(x[6]) + 2*exp(x[7]) + 3*exp(x[8]) + 4*exp(x[9]), -p[1] - 2*p[11] - 3*p[12] - 4*p[13] - p[4] + exp(x[1]) + 2*exp(x[11]) + 3*exp(x[12]) + 4*exp(x[13]) + exp(x[4]), -p[10] - 2*p[11] - p[12] - p[13] - p[5] - p[6] - p[7] - p[8] - p[9] + exp(x[10]) + 2*exp(x[11]) + exp(x[12]) + exp(x[13]) + exp(x[5]) + exp(x[6]) + exp(x[7]) + exp(x[8]) + exp(x[9])]
lmb_symengine = se.Lambdify(args, exprs)
lmb_sympy = sp.lambdify(args, exprs)
inp = np.ones(28)
tim_symengine = clock()
res_symengine = np.empty(len(exprs))
for i in range(500):
res_symengine = lmb_symengine(inp)
#lmb_symengine.unsafe_real_real(inp, res_symengine)
tim_symengine = clock() - tim_symengine
tim_sympy = clock()
for i in range(500):
res_sympy = lmb_sympy(*inp)
tim_sympy = clock() - tim_sympy
print('symengine speed-up factor (higher is better) vs sympy: %12.5g' %
(tim_sympy/tim_symengine))
def test_Lambdify():
n = 7
args = x, y, z = se.symbols('x y z')
l = se.Lambdify(args, [x + y + z, x**2, (x - y) / z, x * y * z])
assert allclose(l(range(n, n + len(args))),
[3 * n + 3, n**2, -1 / (n + 2), n * (n + 1) * (n + 2)])
def test_complex_2():
if not HAVE_NUMPY: # nosetests work-around
return
x = se.Symbol('x')
lmb = se.Lambdify([x], [3 + x - 1j], real=False)
assert abs(lmb([11 + 13j])[0] - (14 + 12j)) < 1e-15
def test_itertools_chain():
args, exprs, inp, check = _get_array()
l = se.Lambdify(args, exprs)
inp = itertools.chain([inp[0]], (inp[1], ), [inp[2]])
A = l(inp, use_numpy=False)
check(A)
