Merge pull request #110 from isuruf/llvm

Use LLVMDoubleVisitor

Author: isuruf

.travis.yml

@@ -66,9 +66,23 @@ matrix:
           - g++-4.8
           - cmake
           - cmake-data
-    - env: BUILD_TYPE="Debug" WITH_BFD="yes" PYTHON_VERSION="3.5"
+    - env: BUILD_TYPE="Debug" WITH_BFD="yes" PYTHON_VERSION="3.5" WITH_LLVM="yes"
       compiler: clang
       os: linux
+      addons:
+        apt:
+          sources:
+          - ubuntu-toolchain-r-test
+          - llvm-toolchain-precise-3.8
+          - george-edison55-precise-backports
+          packages:
+          - clang
+          - libstdc++-4.8-dev
+          - libgmp-dev
+          - binutils-dev
+          - llvm-3.8-dev
+          - cmake
+          - cmake-data
     - env: BUILD_TYPE="Release" PYTHON_VERSION="2.7"
       compiler: clang
       os: linux

CMakeLists.txt

@@ -53,14 +53,21 @@ else()
     set(HAVE_SYMENGINE_FLINT False)
 endif()
 
+if(SYMENGINE_LLVM_COMPONENTS)
+    set(HAVE_SYMENGINE_LLVM True)
+else()
+    set(HAVE_SYMENGINE_LLVM False)
+endif()
+
 
-message("CMAKE_BUILD_TYPE : ${CMAKE_BUILD_TYPE}")
+message("CMAKE_BUILD_TYPE        : ${CMAKE_BUILD_TYPE}")
 message("CMAKE_CXX_FLAGS_RELEASE : ${CMAKE_CXX_FLAGS_RELEASE}")
-message("CMAKE_CXX_FLAGS_DEBUG : ${CMAKE_CXX_FLAGS_DEBUG}")
-message("HAVE_SYMENGINE_MPFR : ${HAVE_SYMENGINE_MPFR}")
-message("HAVE_SYMENGINE_MPC : ${HAVE_SYMENGINE_MPC}")
-message("HAVE_SYMENGINE_PIRANHA : ${HAVE_SYMENGINE_PIRANHA}")
-message("HAVE_SYMENGINE_FLINT : ${HAVE_SYMENGINE_FLINT}")
+message("CMAKE_CXX_FLAGS_DEBUG   : ${CMAKE_CXX_FLAGS_DEBUG}")
+message("HAVE_SYMENGINE_MPFR     : ${HAVE_SYMENGINE_MPFR}")
+message("HAVE_SYMENGINE_MPC      : ${HAVE_SYMENGINE_MPC}")
+message("HAVE_SYMENGINE_PIRANHA  : ${HAVE_SYMENGINE_PIRANHA}")
+message("HAVE_SYMENGINE_FLINT    : ${HAVE_SYMENGINE_FLINT}")
+message("HAVE_SYMENGINE_LLVM     : ${HAVE_SYMENGINE_LLVM}")
 
 message("Copying source of python wrappers into: ${CMAKE_CURRENT_BINARY_DIR}")
 file(COPY symengine/ DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/symengine)

setup.py

@@ -188,7 +188,7 @@ def run(self):
 integration with SymPy and Sage.'''
 
 setup(name = "symengine",
-      version="0.2.0",
+      version="0.2.1.dev",
       description = "Python library providing wrappers to SymEngine",
       setup_requires = ['cython>=0.19.1'],
       long_description = long_description,

symengine/__init__.py

@@ -1,6 +1,7 @@
 from .lib.symengine_wrapper import (Symbol, Integer, sympify, SympifyError,
         Add, Mul, Pow, exp, log, gamma, sqrt, function_symbol, I, E, pi,
-        have_mpfr, have_mpc, RealDouble, ComplexDouble, DenseMatrix, Matrix,
+        have_mpfr, have_mpc, have_flint, have_piranha, have_llvm,
+        RealDouble, ComplexDouble, DenseMatrix, Matrix,
         sin, cos, tan, cot, csc, sec, asin, acos, atan, acot, acsc, asec,
         sinh, cosh, tanh, coth, asinh, acosh, atanh, acoth, Lambdify,
         LambdifyCSE, DictBasic, series, symarray, diff, zeros, eye, diag,
@@ -13,7 +14,7 @@
 if have_mpc:
     from .lib.symengine_wrapper import ComplexMPC
 
-__version__ = "0.1.0.dev"
+__version__ = "0.2.1.dev"
 
 def test():
     import pytest, os

symengine/lib/config.pxi.in

@@ -2,3 +2,4 @@ DEF HAVE_SYMENGINE_MPFR = ${HAVE_SYMENGINE_MPFR}
 DEF HAVE_SYMENGINE_MPC = ${HAVE_SYMENGINE_MPC}
 DEF HAVE_SYMENGINE_PIRANHA = ${HAVE_SYMENGINE_PIRANHA}
 DEF HAVE_SYMENGINE_FLINT = ${HAVE_SYMENGINE_FLINT}
+DEF HAVE_SYMENGINE_LLVM = ${HAVE_SYMENGINE_LLVM}

symengine/lib/symengine_wrapper.pyx

@@ -2143,6 +2143,7 @@ have_mpfr = False
 have_mpc = False
 have_piranha = False
 have_flint = False
+have_llvm = False
 
 IF HAVE_SYMENGINE_MPFR:
     have_mpfr = True
@@ -2166,6 +2167,9 @@ IF HAVE_SYMENGINE_PIRANHA:
 IF HAVE_SYMENGINE_FLINT:
     have_flint = True
 
+IF HAVE_SYMENGINE_LLVM:
+    have_llvm = True
+
 def eval(x, long prec):
     if prec <= 53:
         return eval_complex_double(x)
@@ -2566,7 +2570,7 @@ ctypedef fused ValueType:
     cython.double
 
 
-cdef class Lambdify(object):
+cdef class _Lambdify(object):
     """
     Lambdify instances are callbacks that numerically evaluate their symbolic
     expressions from user provided input (real or complex) into (possibly user
@@ -2598,22 +2602,21 @@ cdef class Lambdify(object):
     cdef size_t args_size, out_size
     cdef tuple out_shape
     cdef readonly bool real
-    cdef vector[symengine.LambdaRealDoubleVisitor] lambda_double
-    cdef vector[symengine.LambdaComplexDoubleVisitor] lambda_double_complex
 
     def __cinit__(self, args, exprs, bool real=True):
+        self.real = real
+        self.out_shape = get_shape(exprs)
+        self.args_size = _size(args)
+        self.out_size = reduce(mul, self.out_shape)
+
+
+    def __init__(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
             RCP[const symengine.Basic] b_
-            int idx = 0
-        self.real = real
-        self.out_shape = get_shape(exprs)
-        self.args_size = _size(args)
-        self.out_size = reduce(mul, self.out_shape)
+            symengine.vec_basic args_, outs_
 
         if isinstance(args, DenseMatrix):
             nr = args.nrows()
@@ -2640,35 +2643,32 @@ cdef class Lambdify(object):
                 e_ = sympify(e)
                 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_)
+        self._init(args_, outs_)
+
+    cdef _init(self, symengine.vec_basic& args_, symengine.vec_basic& outs_):
+        raise ValueError("Not supported")
 
+    cpdef unsafe_real(self, double[::1] inp, double[::1] out):
+        raise ValueError("Not supported")
 
-    cdef void _eval(self, ValueType[::1] inp, ValueType[::1] out):
-        cdef size_t idx, ninp = inp.size, nout = out.size
+    cpdef unsafe_complex(self, double complex[::1] inp, double complex[::1] out):
+        raise ValueError("Not supported")
 
+    # the two cpdef:ed methods below may use void return type
+    # once Cython 0.23 (from 2015) is acceptable as requirement.
+    cpdef eval_real(self, double[::1] inp, double[::1] out):
         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.")
+        self.unsafe_real(inp, out)
 
-        # Convert expr_subs to doubles write to out
-        if ValueType == cython.double:
-            self.lambda_double[0].call(&out[0], &inp[0])
-        else:
-            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.
-    cpdef unsafe_real(self, double[::1] inp, double[::1] out):
-        self._eval(inp, out)
-
-    cpdef unsafe_complex(self, double complex[::1] inp, double complex[::1] out):
-        self._eval(inp, out)
+    cpdef eval_complex(self, double complex[::1] inp, double complex[::1] out):
+        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.")
+        self.unsafe_complex(inp, out)
 
     def __call__(self, inp, out=None, use_numpy=None):
         """
@@ -2712,18 +2712,16 @@ cdef class Lambdify(object):
             import numpy as np
 
         if use_numpy:
+            numpy_dtype = np.float64 if self.real else np.complex128
             if isinstance(inp, DenseMatrix):
+                arr = np.empty(inp_size, dtype=numpy_dtype)
                 if self.real:
-                    arr = np.empty(inp_size, dtype=np.float64)
                     inp.dump_real(arr)
-                    inp = arr
                 else:
-                    arr = np.empty(inp_size, dtype=np.complex128)
                     inp.dump_complex(arr)
-                    inp = arr
+                inp = arr
             else:
-                inp = np.ascontiguousarray(inp, dtype=np.float64 if
-                                           self.real else np.complex128)
+                inp = np.ascontiguousarray(inp, dtype=numpy_dtype)
             if inp.ndim > 1:
                 inp = inp.ravel()
         else:
@@ -2732,8 +2730,7 @@ cdef class Lambdify(object):
         if out is None:
             # allocate output container
             if use_numpy:
-                out = np.empty(new_out_size, dtype=np.float64 if
-                               self.real else np.complex128)
+                out = np.empty(new_out_size, dtype=numpy_dtype)
             else:
                 if self.real:
                     out = cython.view.array((new_out_size,),
@@ -2749,7 +2746,7 @@ cdef class Lambdify(object):
                 except AttributeError:
                     out = np.asarray(out)
                     out_dtype = out.dtype
-                if out_dtype != (np.float64 if self.real else np.complex128):
+                if out_dtype != numpy_dtype:
                     raise TypeError("Output array is of incorrect type")
                 if out.size < new_out_size:
                     raise ValueError("Incompatible size of output argument")
@@ -2801,6 +2798,48 @@ cdef class Lambdify(object):
                 out = tmp
         return out
 
+cdef class LambdaDouble(_Lambdify):
+
+    cdef vector[symengine.LambdaRealDoubleVisitor] lambda_double
+    cdef vector[symengine.LambdaComplexDoubleVisitor] lambda_double_complex
+
+    cdef _init(self, symengine.vec_basic& args_, symengine.vec_basic& outs_):
+        if self.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_)
+
+    cpdef unsafe_real(self, double[::1] inp, double[::1] out):
+        self.lambda_double[0].call(&out[0], &inp[0])
+
+    cpdef unsafe_complex(self, double complex[::1] inp, double complex[::1] out):
+        self.lambda_double_complex[0].call(&out[0], &inp[0])
+
+
+IF HAVE_SYMENGINE_LLVM:
+    cdef class LLVMDouble(_Lambdify):
+
+        cdef vector[symengine.LLVMDoubleVisitor] lambda_double
+
+        cdef _init(self, symengine.vec_basic& args_, symengine.vec_basic& outs_):
+            self.lambda_double.resize(1)
+            self.lambda_double[0].init(args_, outs_)
+
+        cpdef unsafe_real(self, double[::1] inp, double[::1] out):
+            self.lambda_double[0].call(&out[0], &inp[0])
+
+
+def Lambdify(args, exprs, bool real=True, backend="lambda"):
+    if backend == "llvm":
+        IF HAVE_SYMENGINE_LLVM:
+            return LLVMDouble(args, exprs, real)
+        ELSE:
+            raise ValueError("""llvm backend is chosen, but symengine is not compiled
+                                with llvm support.""")
+
+    return LambdaDouble(args, exprs, real)
 
 def LambdifyCSE(args, exprs, real=True, cse=None, concatenate=None):
     """

symengine/tests/test_lambdify.py

@@ -46,7 +46,18 @@ def allclose(vec1, vec2, rtol=1e-13, atol=1e-13):
 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])
+    l = se.Lambdify(args, [x+y+z, x**2, (x-y)/z, x*y*z], backend='lambda')
+    assert allclose(l(range(n, n+len(args))),
+                    [3*n+3, n**2, -1/(n+2), n*(n+1)*(n+2)])
+
+def test_Lambdify_LLVM():
+    n = 7
+    args = x, y, z = se.symbols('x y z')
+    if not se.have_llvm:
+        raises(ValueError, lambda: se.Lambdify(args, [x+y+z, x**2, (x-y)/z, x*y*z],
+                                                      backend='llvm'))
+        return
+    l = se.Lambdify(args, [x+y+z, x**2, (x-y)/z, x*y*z], backend='llvm')
     assert allclose(l(range(n, n+len(args))),
                     [3*n+3, n**2, -1/(n+2), n*(n+1)*(n+2)])