Merge pull request #106 from isuruf/llvm

Use symengine's new interface for lambda double

Author: isuruf

symengine/lib/symengine.pxd

@@ -703,12 +703,18 @@ cdef extern from "<symengine/eval_double.h>" namespace "SymEngine":
 cdef extern from "<symengine/lambda_double.h>" namespace "SymEngine":
     cdef cppclass LambdaRealDoubleVisitor:
         LambdaRealDoubleVisitor() nogil
-        void init(const vec_basic &x, const Basic &b) nogil except +
-        double call(const vector[double] &x) nogil except +
+        void init(const vec_basic &x, const vec_basic &b) nogil except +
+        double call(double *r, const double *x) nogil except +
     cdef cppclass LambdaComplexDoubleVisitor:
         LambdaComplexDoubleVisitor() nogil
-        void init(const vec_basic &x, const Basic &b) nogil except +
-        double complex call(const vector[double complex] &x) nogil except +
+        void init(const vec_basic &x, const vec_basic &b) nogil except +
+        double complex call(double complex *r, const double complex *x) nogil except +
+
+cdef extern from "<symengine/llvm_double.h>" namespace "SymEngine":
+    cdef cppclass LLVMDoubleVisitor:
+        LLVMDoubleVisitor() nogil
+        void init(const vec_basic &x, const vec_basic &b) nogil except +
+        double call(double *r, const double *x) nogil except +
 
 cdef extern from "<symengine/series.h>" namespace "SymEngine":
     cdef cppclass SeriesCoeffInterface:

symengine/lib/symengine_wrapper.pyx

@@ -2604,6 +2604,7 @@ cdef class Lambdify(object):
     def __cinit__(self, args, exprs, bool real=True):
         cdef:
             symengine.vec_basic args_
+            symengine.vec_basic outs_
             Basic e_
             size_t ri, ci, nr, nc
             symengine.MatrixBase *mtx
@@ -2626,63 +2627,40 @@ cdef class Lambdify(object):
                 e_ = sympify(e)
                 args_.push_back(e_.thisptr)
 
-        if self.real:
-            self.lambda_double.resize(self.out_size)
-        else:
-            self.lambda_double_complex.resize(self.out_size)
-
         if isinstance(exprs, DenseMatrix):
             nr = exprs.nrows()
             nc = exprs.ncols()
             mtx = (<DenseMatrix>exprs).thisptr
             for ri in range(nr):
                 for ci in range(nc):
                     b_ = deref(mtx).get(ri, ci)
-                    if real:
-                        self.lambda_double[ri*nc+ci].init(args_, deref(b_))
-                    else:
-                        self.lambda_double_complex[ri*nc+ci].init(args_, deref(b_))
+                    outs_.push_back(b_)
         else:
             for e in ravel(exprs):
                 e_ = sympify(e)
-                if real:
-                    self.lambda_double[idx].init(args_, deref(e_.thisptr))
-                else:
-                    self.lambda_double_complex[idx].init(args_, deref(e_.thisptr))
-                idx += 1
+                outs_.push_back(e_.thisptr)
+
+        if real:
+            self.lambda_double.resize(1)
+            self.lambda_double[0].init(args_, outs_)
+        else:
+            self.lambda_double_complex.resize(1)
+            self.lambda_double_complex[0].init(args_, outs_)
+
 
     cdef void _eval(self, ValueType[::1] inp, ValueType[::1] out):
-        cdef vector[ValueType] inp_
         cdef size_t idx, ninp = inp.size, nout = out.size
 
         if inp.size != self.args_size:
             raise ValueError("Size of inp incompatible with number of args.")
         if out.size != self.out_size:
             raise ValueError("Size of out incompatible with number of exprs.")
 
-        # Create the substitution "dict"
-        for idx in range(ninp):
-            inp_.push_back(inp[idx])
-
         # Convert expr_subs to doubles write to out
         if ValueType == cython.double:
-            self.as_real(inp_, out)
+            self.lambda_double[0].call(&out[0], &inp[0])
         else:
-            self.as_complex(inp_, out)
-
-    @cython.wraparound(False)
-    @cython.boundscheck(False)
-    cdef void as_real(self, vector[double] &vec, double[::1] out) nogil:
-        cdef size_t i
-        for i in range(self.out_size):
-            out[i] = self.lambda_double[i].call(vec)
-
-    @cython.wraparound(False)
-    @cython.boundscheck(False)
-    cdef void as_complex(self, vector[double complex] &vec, double complex[::1] out) nogil:
-        cdef size_t i
-        for i in range(self.out_size):
-            out[i] = self.lambda_double_complex[i].call(vec)
+            self.lambda_double_complex[0].call(&out[0], &inp[0])
 
     # the two cpdef:ed methods below may use void return type
     # once Cython 0.23 (from 2015) is acceptable as requirement.