Handle SymPy matrix in Lambdify. Update benchmark.

Author: bjodah

benchmarks/Lambdify_6_links_reference.pyx

@@ -8,55 +8,45 @@
 import symengine as se
 import warnings
 
-exprs_s = open(os.path.join(os.path.dirname(__file__), '6_links_rhs.txt'), 'tr').read()
-exprs = parse_expr(exprs_s, transformations=standard_transformations)
-args = sp.Matrix(1, 14, exprs).free_symbols
+src = os.path.join(os.path.dirname(__file__), '6_links_rhs.txt')
+serial = open(src, 'tr').read()
+parsed = parse_expr(serial, transformations=standard_transformations)
+vec = sp.Matrix(1, 14, parsed)
+args = tuple(sorted(vec.free_symbols, key=lambda arg: arg.name))
+exprs = vec, vec.jacobian(args[:-14])
 inp = np.ones(len(args))
 assert inp.size == 26
-print([expr.subs(dict(zip(args, [1]*len(args)))) for expr in exprs])
 
-# Real-life example (ion speciation problem in water chemistry)
 
-
-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')
+lmb_sp = sp.lambdify(args, exprs, modules=['math', 'sympy'])
+lmb_se = se.Lambdify(args, *exprs)
+lmb_se_llvm = se.Lambdify(args, *exprs, backend='llvm')
 
 
 lmb_sp(*inp)
 tim_sympy = clock()
 for i in range(500):
-    res_sympy = lmb_sp(*inp)
+    v, m = 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):
-    res_se = lmb_se(inp)
+    v, m = lmb_se(inp)
 tim_se = clock() - tim_se
 
-# lmb_se_cse(inp)
-# tim_se_cse = clock()
-# res_se_cse = np.empty(len(exprs))
-# for i in range(500):
-#     res_se_cse = lmb_se_cse(inp)
-# tim_se_cse = clock() - tim_se_cse
 
 lmb_se_llvm(inp)
 tim_se_llvm = clock()
 res_se_llvm = np.empty(len(exprs))
 for i in range(500):
-    res_se_llvm = lmb_se_llvm(inp)
+    v, m = lmb_se_llvm(inp)
 tim_se_llvm = clock() - tim_se_llvm
 
 
 print('SymEngine (lambda double)       speed-up factor (higher is better) vs sympy: %12.5g' %
       (tim_sympy/tim_se))
 
-# print('symengine (lambda double + CSE) speed-up factor (higher is better) vs sympy: %12.5g' %
-#       (tim_sympy/tim_se_cse))
 
 print('symengine (LLVM)                speed-up factor (higher is better) vs sympy: %12.5g' %
       (tim_sympy/tim_se_llvm))
@@ -80,28 +70,14 @@ def func(*args):
         return result
     return func
 
-lmb_se_llvm_manual = ManualLLVM(args, np.array(exprs))
+lmb_se_llvm_manual = ManualLLVM(args, *exprs)
 lmb_se_llvm_manual(inp)
 tim_se_llvm_manual = clock()
-res_se_llvm_manual = np.empty(len(exprs))
 for i in range(500):
-    res_se_llvm_manual = lmb_se_llvm_manual(inp)
+    v, m = lmb_se_llvm_manual(inp)
 tim_se_llvm_manual = clock() - tim_se_llvm_manual
 print('symengine (ManualLLVM)          speed-up factor (higher is better) vs sympy: %12.5g' %
       (tim_sympy/tim_se_llvm_manual))
 
 if tim_se_llvm_manual < tim_se_llvm:
     warnings.warn("Cython code for Lambdify.__call__ is slow.")
-
-import setuptools
-import pyximport
-pyximport.install()
-from Lambdify_6_links_reference import _benchmark_reference_for_Lambdify as lmb_ref
-
-lmb_ref(inp)
-tim_ref = clock()
-for i in range(500):
-    res_ref = lmb_ref(inp)
-tim_ref = clock() - tim_ref
-print('Hard-coded Cython code          speed-up factor (higher is better) vs sympy: %12.5g' %
-      (tim_sympy/tim_ref))

benchmarks/Lambdify_6_links_rhs.py renamed to benchmarks/heterogenous_output_Lambdify.py

@@ -3060,7 +3060,10 @@ IF HAVE_NUMPY:
         try:
             return ndarr.ravel()
         except AttributeError:
-            return _ravel_nested(ndarr)
+            try:
+                return _ravel_nested(ndarr.tolist())
+            except AttributeError:
+                return _ravel_nested(ndarr)
 
 
     cdef class _Lambdify(object):
@@ -3139,8 +3142,8 @@ IF HAVE_NUMPY:
                     for ci in range(nc):
                        args_.push_back(deref(mtx).get(ri, ci))
             else:
-                for e in args:
-                    e_ = _sympify(e)
+                for arg in args:
+                    e_ = _sympify(arg)
                     args_.push_back(e_.thisptr)
 
 

symengine/lib/symengine_wrapper.pyx

@@ -265,11 +265,11 @@ def test_broadcast_fortran():
         check(A[i, ...], inp[i, :])
 
 
-def _get_1_to_2by3_matrix():
+def _get_1_to_2by3_matrix(Mtx=se.DenseMatrix):
     x = se.symbols('x')
     args = x,
-    exprs = se.DenseMatrix(2, 3, [x+1, x+2, x+3,
-                                  1/x, 1/(x*x), 1/(x**3.0)])
+    exprs = Mtx(2, 3, [x+1, x+2, x+3,
+                       1/x, 1/(x*x), 1/(x**3.0)])
     L = se.Lambdify(args, exprs)
 
     def check(A, inp):
@@ -291,6 +291,15 @@ def test_2dim_Matrix():
     check(L(inp), inp)
 
 
+def test_2dim_Matrix__sympy():
+    if not have_numpy:  # nosetests work-around
+        return
+    import sympy as sp
+    L, check = _get_1_to_2by3_matrix(sp.Matrix)
+    inp = [7]
+    check(L(inp), inp)
+
+
 
 def _test_2dim_Matrix_broadcast():
     L, check = _get_1_to_2by3_matrix()