-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)