diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 6993dd9e..8b9877b1 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -132,11 +132,12 @@ jobs:
             CC: gcc
 
           - BUILD_TYPE: Release
-            PYTHON_VERSION: '3.8'
+            PYTHON_VERSION: '3.11'
             OS: ubuntu-20.04
             WITH_MPC: yes
             WITH_MPFR: yes
             WITH_FLINT: yes
+            WITH_FLINT_PY: yes
             WITH_SCIPY: yes
             WITH_DOCS: yes
             INTEGER_CLASS: flint
diff --git a/bin/install_travis.sh b/bin/install_travis.sh
index 581354a0..8176202d 100644
--- a/bin/install_travis.sh
+++ b/bin/install_travis.sh
@@ -16,6 +16,10 @@ if [[ "${WITH_DOCS}" == "yes" ]]; then
     export conda_pkgs="${conda_pkgs} sphinx recommonmark";
 fi
 
+if [[ "${WITH_FLINT_PY}" == "yes" ]]; then
+    export conda_pkgs="${conda_pkgs} python-flint";  # python-flint affects sympy, see e.g. sympy/sympy#26645
+fi
+
 if [[ "${WITH_SAGE}" == "yes" ]]; then
     # This is split to avoid the 10 minute limit
     conda install -q sagelib=8.1
diff --git a/symengine/__init__.py b/symengine/__init__.py
index b6002a28..1eabb110 100644
--- a/symengine/__init__.py
+++ b/symengine/__init__.py
@@ -52,14 +52,15 @@
     from .lib.symengine_wrapper import ComplexMPC
 
 if have_numpy:
-    from .lib.symengine_wrapper import (Lambdify, LambdifyCSE)
-
+    from .lib.symengine_wrapper import Lambdify, LambdifyCSE
     def lambdify(args, exprs, **kwargs):
+        if isinstance(exprs, Basic):
+            exprs = [exprs]
         return Lambdify(args, *exprs, **kwargs)
 else:
     def __getattr__(name):
-        if name == 'lambdify':
-            raise AttributeError("Cannot import numpy, which is required for `lambdify` to work")
+        if name in ('lambdify', 'Lambdify', 'LambdifyCSE'):
+            raise AttributeError(f"Cannot import numpy, which is required for `{name}` to work")
         raise AttributeError(f"module 'symengine' has no attribute '{name}'")
 
 
diff --git a/symengine/lib/symengine.pxd b/symengine/lib/symengine.pxd
index ee96731b..c93ae534 100644
--- a/symengine/lib/symengine.pxd
+++ b/symengine/lib/symengine.pxd
@@ -51,11 +51,11 @@ cdef extern from "<symengine/symengine_rcp.h>" namespace "SymEngine":
     cdef cppclass RCP[T]:
         T& operator*() nogil
         # Not yet supported in Cython:
-#        RCP[T]& operator=(RCP[T] &r_ptr) except+ nogil
-        void reset() except+ nogil
+#        RCP[T]& operator=(RCP[T] &r_ptr) nogil except +
+        void reset() nogil except +
 
     cdef cppclass Ptr[T]:
-        T& operator*() except+ nogil
+        T& operator*() nogil except +
 
     void print_stack_on_segfault() nogil
 
@@ -65,7 +65,7 @@ cdef extern from "<symengine/basic.h>" namespace "SymEngine":
     ctypedef RCP[const_Basic] rcp_const_basic "SymEngine::RCP<const SymEngine::Basic>"
     #cdef cppclass rcp_const_basic "SymEngine::RCP<const SymEngine::Basic>":
     #    Basic& operator*() nogil
-    #    void reset() except+ nogil
+    #    void reset() nogil except +
     #    pass
     # Cython has broken support for the following:
     # ctypedef map[rcp_const_basic, rcp_const_basic] map_basic_basic
@@ -112,8 +112,8 @@ cdef extern from "<symengine/basic.h>" namespace "SymEngine":
     ctypedef multiset[rcp_const_basic] multiset_basic "SymEngine::multiset_basic"
 
     cdef cppclass Basic:
-        string __str__() except+ nogil
-        unsigned int hash() except+ nogil
+        string __str__() nogil except +
+        unsigned int hash() nogil except +
         vec_basic get_args() nogil
         int __cmp__(const Basic &o) nogil
 
@@ -124,11 +124,11 @@ cdef extern from "<symengine/basic.h>" namespace "SymEngine":
     ctypedef unordered_map[rcp_const_basic, rcp_const_number].iterator umap_basic_num_iterator "SymEngine::umap_basic_num::iterator"
     ctypedef vector[pair[rcp_const_basic, rcp_const_basic]] vec_pair "SymEngine::vec_pair"
 
-    bool eq(const Basic &a, const Basic &b) except+ nogil
-    bool neq(const Basic &a, const Basic &b) except+ nogil
+    bool eq(const Basic &a, const Basic &b) nogil except +
+    bool neq(const Basic &a, const Basic &b) nogil except +
 
     RCP[const Symbol] rcp_static_cast_Symbol "SymEngine::rcp_static_cast<const SymEngine::Symbol>"(rcp_const_basic &b) nogil
-    RCP[const PySymbol] rcp_static_cast_PySymbol "SymEngine::rcp_static_cast<const SymEngine::PySymbol>"(rcp_const_basic &b) except+ nogil
+    RCP[const PySymbol] rcp_static_cast_PySymbol "SymEngine::rcp_static_cast<const SymEngine::PySymbol>"(rcp_const_basic &b) nogil except +
     RCP[const Integer] rcp_static_cast_Integer "SymEngine::rcp_static_cast<const SymEngine::Integer>"(rcp_const_basic &b) nogil
     RCP[const Rational] rcp_static_cast_Rational "SymEngine::rcp_static_cast<const SymEngine::Rational>"(rcp_const_basic &b) nogil
     RCP[const Complex] rcp_static_cast_Complex "SymEngine::rcp_static_cast<const SymEngine::Complex>"(rcp_const_basic &b) nogil
@@ -162,10 +162,10 @@ cdef extern from "<symengine/basic.h>" namespace "SymEngine":
 
     bool is_a[T] (const Basic &b) nogil
     bool is_a_sub[T] (const Basic &b) nogil
-    rcp_const_basic expand(rcp_const_basic &o, bool deep) except+ nogil
+    rcp_const_basic expand(rcp_const_basic &o, bool deep) nogil except +
     void as_numer_denom(rcp_const_basic &x, const Ptr[RCP[Basic]] &numer, const Ptr[RCP[Basic]] &denom) nogil
     void as_real_imag(rcp_const_basic &x, const Ptr[RCP[Basic]] &real, const Ptr[RCP[Basic]] &imag) nogil
-    void cse(vec_pair &replacements, vec_basic &reduced_exprs, const vec_basic &exprs) except+ nogil
+    void cse(vec_pair &replacements, vec_basic &reduced_exprs, const vec_basic &exprs) nogil except +
 
 cdef extern from "<symengine/subs.h>" namespace "SymEngine":
     rcp_const_basic msubs (rcp_const_basic &x, const map_basic_basic &x) nogil
@@ -173,7 +173,7 @@ cdef extern from "<symengine/subs.h>" namespace "SymEngine":
     rcp_const_basic xreplace (rcp_const_basic &x, const map_basic_basic &x) nogil
 
 cdef extern from "<symengine/derivative.h>" namespace "SymEngine":
-    rcp_const_basic diff "SymEngine::sdiff"(rcp_const_basic &arg, rcp_const_basic &x) except+ nogil
+    rcp_const_basic diff "SymEngine::sdiff"(rcp_const_basic &arg, rcp_const_basic &x) nogil except +
 
 cdef extern from "<symengine/symbol.h>" namespace "SymEngine":
     cdef cppclass Symbol(Basic):
@@ -215,8 +215,8 @@ cdef extern from "pywrapper.h" namespace "SymEngine":
         PySymbol(string name, PyObject* pyobj, bool use_pickle) except +
         PyObject* get_py_object() except +
 
-    string wrapper_dumps(const Basic &x) except+ nogil
-    rcp_const_basic wrapper_loads(const string &s) except+ nogil
+    string wrapper_dumps(const Basic &x) nogil except +
+    rcp_const_basic wrapper_loads(const string &s) nogil except +
 
 cdef extern from "<symengine/integer.h>" namespace "SymEngine":
     cdef cppclass Integer(Number):
@@ -286,9 +286,9 @@ cdef extern from "<symengine/nan.h>" namespace "SymEngine":
         pass
 
 cdef extern from "<symengine/add.h>" namespace "SymEngine":
-    cdef rcp_const_basic add(rcp_const_basic &a, rcp_const_basic &b) except+ nogil
-    cdef rcp_const_basic sub(rcp_const_basic &a, rcp_const_basic &b) except+ nogil
-    cdef rcp_const_basic add(const vec_basic &a) except+ nogil
+    cdef rcp_const_basic add(rcp_const_basic &a, rcp_const_basic &b) nogil except +
+    cdef rcp_const_basic sub(rcp_const_basic &a, rcp_const_basic &b) nogil except +
+    cdef rcp_const_basic add(const vec_basic &a) nogil except +
 
     cdef cppclass Add(Basic):
         void as_two_terms(const Ptr[RCP[Basic]] &a, const Ptr[RCP[Basic]] &b)
@@ -296,10 +296,10 @@ cdef extern from "<symengine/add.h>" namespace "SymEngine":
         const umap_basic_num &get_dict()
 
 cdef extern from "<symengine/mul.h>" namespace "SymEngine":
-    cdef rcp_const_basic mul(rcp_const_basic &a, rcp_const_basic &b) except+ nogil
-    cdef rcp_const_basic div(rcp_const_basic &a, rcp_const_basic &b) except+ nogil
-    cdef rcp_const_basic neg(rcp_const_basic &a) except+ nogil
-    cdef rcp_const_basic mul(const vec_basic &a) except+ nogil
+    cdef rcp_const_basic mul(rcp_const_basic &a, rcp_const_basic &b) nogil except +
+    cdef rcp_const_basic div(rcp_const_basic &a, rcp_const_basic &b) nogil except +
+    cdef rcp_const_basic neg(rcp_const_basic &a) nogil except +
+    cdef rcp_const_basic mul(const vec_basic &a) nogil except +
 
     cdef cppclass Mul(Basic):
         void as_two_terms(const Ptr[RCP[Basic]] &a, const Ptr[RCP[Basic]] &b)
@@ -308,9 +308,9 @@ cdef extern from "<symengine/mul.h>" namespace "SymEngine":
     cdef RCP[const Mul] mul_from_dict "SymEngine::Mul::from_dict"(RCP[const Number] coef, map_basic_basic &d) nogil
 
 cdef extern from "<symengine/pow.h>" namespace "SymEngine":
-    cdef rcp_const_basic pow(rcp_const_basic &a, rcp_const_basic &b) except+ nogil
-    cdef rcp_const_basic sqrt(rcp_const_basic &x) except+ nogil
-    cdef rcp_const_basic exp(rcp_const_basic &x) except+ nogil
+    cdef rcp_const_basic pow(rcp_const_basic &a, rcp_const_basic &b) nogil except +
+    cdef rcp_const_basic sqrt(rcp_const_basic &x) nogil except +
+    cdef rcp_const_basic exp(rcp_const_basic &x) nogil except +
 
     cdef cppclass Pow(Basic):
         rcp_const_basic get_base() nogil
@@ -344,58 +344,58 @@ cdef extern from "<symengine/basic.h>" namespace "SymEngine":
             RCP[const PyFunctionClass] pyfunc_class, const PyObject* pyobject) nogil
 
 cdef extern from "<symengine/functions.h>" namespace "SymEngine":
-    cdef rcp_const_basic sin(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic cos(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic tan(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic cot(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic csc(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic sec(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic asin(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic acos(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic atan(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic acot(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic acsc(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic asec(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic sinh(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic cosh(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic tanh(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic coth(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic csch(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic sech(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic asinh(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic acosh(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic atanh(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic acoth(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic acsch(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic asech(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic function_symbol(string name, const vec_basic &arg) except+ nogil
-    cdef rcp_const_basic abs(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic max(const vec_basic &arg) except+ nogil
-    cdef rcp_const_basic min(const vec_basic &arg) except+ nogil
-    cdef rcp_const_basic gamma(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic atan2(rcp_const_basic &num, rcp_const_basic &den) except+ nogil
-    cdef rcp_const_basic lambertw(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic zeta(rcp_const_basic &s) except+ nogil
-    cdef rcp_const_basic zeta(rcp_const_basic &s, rcp_const_basic &a) except+ nogil
-    cdef rcp_const_basic dirichlet_eta(rcp_const_basic &s) except+ nogil
-    cdef rcp_const_basic kronecker_delta(rcp_const_basic &i, rcp_const_basic &j) except+ nogil
-    cdef rcp_const_basic levi_civita(const vec_basic &arg) except+ nogil
-    cdef rcp_const_basic erf(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic erfc(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic lowergamma(rcp_const_basic &s, rcp_const_basic &x) except+ nogil
-    cdef rcp_const_basic uppergamma(rcp_const_basic &s, rcp_const_basic &x) except+ nogil
-    cdef rcp_const_basic loggamma(rcp_const_basic &arg) except+ nogil
-    cdef rcp_const_basic beta(rcp_const_basic &x, rcp_const_basic &y) except+ nogil
-    cdef rcp_const_basic polygamma(rcp_const_basic &n, rcp_const_basic &x) except+ nogil
-    cdef rcp_const_basic digamma(rcp_const_basic &x) except+ nogil
-    cdef rcp_const_basic trigamma(rcp_const_basic &x) except+ nogil
-    cdef rcp_const_basic sign(rcp_const_basic &x) except+ nogil
-    cdef rcp_const_basic floor(rcp_const_basic &x) except+ nogil
-    cdef rcp_const_basic ceiling(rcp_const_basic &x) except+ nogil
-    cdef rcp_const_basic conjugate(rcp_const_basic &x) except+ nogil
-    cdef rcp_const_basic log(rcp_const_basic &x) except+ nogil
-    cdef rcp_const_basic log(rcp_const_basic &x, rcp_const_basic &y) except+ nogil
-    cdef rcp_const_basic unevaluated_expr(rcp_const_basic &x) except+ nogil
+    cdef rcp_const_basic sin(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic cos(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic tan(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic cot(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic csc(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic sec(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic asin(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic acos(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic atan(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic acot(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic acsc(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic asec(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic sinh(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic cosh(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic tanh(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic coth(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic csch(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic sech(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic asinh(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic acosh(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic atanh(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic acoth(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic acsch(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic asech(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic function_symbol(string name, const vec_basic &arg) nogil except +
+    cdef rcp_const_basic abs(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic max(const vec_basic &arg) nogil except +
+    cdef rcp_const_basic min(const vec_basic &arg) nogil except +
+    cdef rcp_const_basic gamma(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic atan2(rcp_const_basic &num, rcp_const_basic &den) nogil except +
+    cdef rcp_const_basic lambertw(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic zeta(rcp_const_basic &s) nogil except +
+    cdef rcp_const_basic zeta(rcp_const_basic &s, rcp_const_basic &a) nogil except +
+    cdef rcp_const_basic dirichlet_eta(rcp_const_basic &s) nogil except +
+    cdef rcp_const_basic kronecker_delta(rcp_const_basic &i, rcp_const_basic &j) nogil except +
+    cdef rcp_const_basic levi_civita(const vec_basic &arg) nogil except +
+    cdef rcp_const_basic erf(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic erfc(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic lowergamma(rcp_const_basic &s, rcp_const_basic &x) nogil except +
+    cdef rcp_const_basic uppergamma(rcp_const_basic &s, rcp_const_basic &x) nogil except +
+    cdef rcp_const_basic loggamma(rcp_const_basic &arg) nogil except +
+    cdef rcp_const_basic beta(rcp_const_basic &x, rcp_const_basic &y) nogil except +
+    cdef rcp_const_basic polygamma(rcp_const_basic &n, rcp_const_basic &x) nogil except +
+    cdef rcp_const_basic digamma(rcp_const_basic &x) nogil except +
+    cdef rcp_const_basic trigamma(rcp_const_basic &x) nogil except +
+    cdef rcp_const_basic sign(rcp_const_basic &x) nogil except +
+    cdef rcp_const_basic floor(rcp_const_basic &x) nogil except +
+    cdef rcp_const_basic ceiling(rcp_const_basic &x) nogil except +
+    cdef rcp_const_basic conjugate(rcp_const_basic &x) nogil except +
+    cdef rcp_const_basic log(rcp_const_basic &x) nogil except +
+    cdef rcp_const_basic log(rcp_const_basic &x, rcp_const_basic &y) nogil except +
+    cdef rcp_const_basic unevaluated_expr(rcp_const_basic &x) nogil except +
 
     cdef cppclass Function(Basic):
         pass
@@ -632,7 +632,7 @@ cdef extern from "<symengine/matrix.h>" namespace "SymEngine":
         const unsigned ncols() nogil
         rcp_const_basic get(unsigned i, unsigned j) nogil
         rcp_const_basic set(unsigned i, unsigned j, rcp_const_basic e) nogil
-        string __str__() except+ nogil
+        string __str__() nogil except +
         bool eq(const MatrixBase &) nogil
         rcp_const_basic det() nogil
         void inv(MatrixBase &)
@@ -681,20 +681,20 @@ cdef extern from "<symengine/matrix.h>" namespace "SymEngine":
 
     DenseMatrix* static_cast_DenseMatrix "static_cast<SymEngine::DenseMatrix*>"(const MatrixBase *a)
     void inverse_FFLU "SymEngine::inverse_fraction_free_LU"(const DenseMatrix &A,
-        DenseMatrix &B) except+ nogil
-    void pivoted_LU_solve (const DenseMatrix &A, const DenseMatrix &b, DenseMatrix &x) except+ nogil
+        DenseMatrix &B) nogil except +
+    void pivoted_LU_solve (const DenseMatrix &A, const DenseMatrix &b, DenseMatrix &x) nogil except +
     void inverse_GJ "SymEngine::inverse_gauss_jordan"(const DenseMatrix &A,
-        DenseMatrix &B) except+ nogil
+        DenseMatrix &B) nogil except +
     void FFLU_solve "SymEngine::fraction_free_LU_solve"(const DenseMatrix &A,
-        const DenseMatrix &b, DenseMatrix &x) except+ nogil
-    void FFGJ_solve "SymEngine::fraction_free_gauss_jordan_solve"(const DenseMatrix &A,
-        const DenseMatrix &b, DenseMatrix &x) except+ nogil
+        const DenseMatrix &b, DenseMatrix &x) nogil except +
+    int FFGJ_solve "SymEngine::fraction_free_gauss_jordan_solve"(const DenseMatrix &A,
+        const DenseMatrix &b, DenseMatrix &x) nogil except +
     void LDL_solve "SymEngine::LDL_solve"(const DenseMatrix &A, const DenseMatrix &b,
-        DenseMatrix &x) except+ nogil
+        DenseMatrix &x) nogil except +
     void jacobian "SymEngine::sjacobian"(const DenseMatrix &A,
-            const DenseMatrix &x, DenseMatrix &result) except+ nogil
+            const DenseMatrix &x, DenseMatrix &result) nogil except +
     void diff "SymEngine::sdiff"(const DenseMatrix &A,
-            rcp_const_basic &x, DenseMatrix &result) except+ nogil
+            rcp_const_basic &x, DenseMatrix &result) nogil except +
     void eye (DenseMatrix &A, int k) nogil
     void diag(DenseMatrix &A, vec_basic &v, int k) nogil
     void ones(DenseMatrix &A) nogil
@@ -707,7 +707,7 @@ cdef extern from "<symengine/matrix.h>" namespace "SymEngine":
     void cross(const DenseMatrix &A, const DenseMatrix &B, DenseMatrix &C) nogil
 
 cdef extern from "<symengine/matrix.h>":
-    void pivoted_LU (const DenseMatrix &A, DenseMatrix &L, DenseMatrix &U, vector[pair[int, int]] &P) except+ nogil
+    void pivoted_LU (const DenseMatrix &A, DenseMatrix &L, DenseMatrix &U, vector[pair[int, int]] &P) nogil except +
 
 cdef extern from "<symengine/ntheory.h>" namespace "SymEngine":
     int probab_prime_p(const Integer &a, int reps)
@@ -716,10 +716,10 @@ cdef extern from "<symengine/ntheory.h>" namespace "SymEngine":
     RCP[const Integer] lcm(const Integer &a, const Integer &b) nogil
     void gcd_ext(const Ptr[RCP[Integer]] &g, const Ptr[RCP[Integer]] &s,
             const Ptr[RCP[Integer]] &t, const Integer &a, const Integer &b) nogil
-    RCP[const Integer] mod "SymEngine::mod_f"(const Integer &n, const Integer &d) except+ nogil
-    RCP[const Integer] quotient "SymEngine::quotient_f"(const Integer &n, const Integer &d) except+ nogil
+    RCP[const Integer] mod "SymEngine::mod_f"(const Integer &n, const Integer &d) nogil except +
+    RCP[const Integer] quotient "SymEngine::quotient_f"(const Integer &n, const Integer &d) nogil except +
     void quotient_mod "SymEngine::quotient_mod_f"(const Ptr[RCP[Integer]] &q, const Ptr[RCP[Integer]] &mod,
-            const Integer &n, const Integer &d) except+ nogil
+            const Integer &n, const Integer &d) nogil except +
     int mod_inverse(const Ptr[RCP[Integer]] &b, const Integer &a,
             const Integer &m) nogil
     bool crt(const Ptr[RCP[Integer]] &R, const vec_integer &rem,
@@ -739,9 +739,9 @@ cdef extern from "<symengine/ntheory.h>" namespace "SymEngine":
             unsigned B, unsigned retries) nogil
     int factor_pollard_rho_method(const Ptr[RCP[Integer]] &f, const Integer &n,
             unsigned retries) nogil
-    void prime_factors(vec_integer &primes, const Integer &n) except+ nogil
-    void prime_factor_multiplicities(map_integer_uint &primes, const Integer &n) except+ nogil
-    RCP[const Number] bernoulli(unsigned long n) except+ nogil
+    void prime_factors(vec_integer &primes, const Integer &n) nogil except +
+    void prime_factor_multiplicities(map_integer_uint &primes, const Integer &n) nogil except +
+    RCP[const Number] bernoulli(unsigned long n) nogil except +
     bool primitive_root(const Ptr[RCP[Integer]] &g, const Integer &n) nogil
     void primitive_root_list(vec_integer &roots, const Integer &n) nogil
     RCP[const Integer] totient(RCP[const Integer] n) nogil
@@ -769,15 +769,15 @@ cdef extern from "<symengine/prime_sieve.h>" namespace "SymEngine":
         unsigned next_prime() nogil
 
 cdef extern from "<symengine/visitor.h>" namespace "SymEngine":
-    bool has_symbol(const Basic &b, const Basic &x) except+ nogil
-    rcp_const_basic coeff(const Basic &b, const Basic &x, const Basic &n) except+ nogil
-    set_basic free_symbols(const Basic &b) except+ nogil
-    set_basic free_symbols(const MatrixBase &b) except+ nogil
+    bool has_symbol(const Basic &b, const Basic &x) nogil except +
+    rcp_const_basic coeff(const Basic &b, const Basic &x, const Basic &n) nogil except +
+    set_basic free_symbols(const Basic &b) nogil except +
+    set_basic free_symbols(const MatrixBase &b) nogil except +
     unsigned count_ops(const vec_basic &a) nogil
 
 cdef extern from "<symengine/logic.h>" namespace "SymEngine":
     cdef cppclass Boolean(Basic):
-        RCP[const Boolean] logical_not() except+ nogil
+        RCP[const Boolean] logical_not() nogil except +
     cdef cppclass BooleanAtom(Boolean):
         bool get_val() nogil
     cdef cppclass Relational(Boolean):
@@ -805,25 +805,25 @@ cdef extern from "<symengine/logic.h>" namespace "SymEngine":
 
     rcp_const_basic boolTrue
     rcp_const_basic boolFalse
-    cdef RCP[const Boolean] Eq(rcp_const_basic &lhs) except+ nogil
-    cdef RCP[const Boolean] Eq(rcp_const_basic &lhs, rcp_const_basic &rhs) except+ nogil
-    cdef RCP[const Boolean] Ne(rcp_const_basic &lhs, rcp_const_basic &rhs) except+ nogil
-    cdef RCP[const Boolean] Ge(rcp_const_basic &lhs, rcp_const_basic &rhs) except+ nogil
-    cdef RCP[const Boolean] Gt(rcp_const_basic &lhs, rcp_const_basic &rhs) except+ nogil
-    cdef RCP[const Boolean] Le(rcp_const_basic &lhs, rcp_const_basic &rhs) except+ nogil
-    cdef RCP[const Boolean] Lt(rcp_const_basic &lhs, rcp_const_basic &rhs) except+ nogil
+    cdef RCP[const Boolean] Eq(rcp_const_basic &lhs) nogil except +
+    cdef RCP[const Boolean] Eq(rcp_const_basic &lhs, rcp_const_basic &rhs) nogil except +
+    cdef RCP[const Boolean] Ne(rcp_const_basic &lhs, rcp_const_basic &rhs) nogil except +
+    cdef RCP[const Boolean] Ge(rcp_const_basic &lhs, rcp_const_basic &rhs) nogil except +
+    cdef RCP[const Boolean] Gt(rcp_const_basic &lhs, rcp_const_basic &rhs) nogil except +
+    cdef RCP[const Boolean] Le(rcp_const_basic &lhs, rcp_const_basic &rhs) nogil except +
+    cdef RCP[const Boolean] Lt(rcp_const_basic &lhs, rcp_const_basic &rhs) nogil except +
     ctypedef Boolean const_Boolean "const SymEngine::Boolean"
     ctypedef vector[pair[rcp_const_basic, RCP[const_Boolean]]] PiecewiseVec;
     ctypedef vector[RCP[Boolean]] vec_boolean "SymEngine::vec_boolean"
     ctypedef set[RCP[Boolean]] set_boolean "SymEngine::set_boolean"
-    cdef RCP[const Boolean] logical_and(set_boolean &s) except+ nogil
-    cdef RCP[const Boolean] logical_nand(set_boolean &s) except+ nogil
-    cdef RCP[const Boolean] logical_or(set_boolean &s) except+ nogil
-    cdef RCP[const Boolean] logical_not(RCP[const Boolean] &s) except+ nogil
-    cdef RCP[const Boolean] logical_nor(set_boolean &s) except+ nogil
-    cdef RCP[const Boolean] logical_xor(vec_boolean &s) except+ nogil
-    cdef RCP[const Boolean] logical_xnor(vec_boolean &s) except+ nogil
-    cdef rcp_const_basic piecewise(PiecewiseVec vec) except+ nogil
+    cdef RCP[const Boolean] logical_and(set_boolean &s) nogil except +
+    cdef RCP[const Boolean] logical_nand(set_boolean &s) nogil except +
+    cdef RCP[const Boolean] logical_or(set_boolean &s) nogil except +
+    cdef RCP[const Boolean] logical_not(RCP[const Boolean] &s) nogil except +
+    cdef RCP[const Boolean] logical_nor(set_boolean &s) nogil except +
+    cdef RCP[const Boolean] logical_xor(vec_boolean &s) nogil except +
+    cdef RCP[const Boolean] logical_xnor(vec_boolean &s) nogil except +
+    cdef rcp_const_basic piecewise(PiecewiseVec vec) nogil except +
     cdef RCP[const Boolean] contains(rcp_const_basic &expr,
                                      RCP[const Set] &set) nogil
 
@@ -833,26 +833,26 @@ cdef extern from "<symengine/eval.h>" namespace "SymEngine":
     cdef EvalfDomain EvalfComplex "SymEngine::EvalfDomain::Complex"
     cdef EvalfDomain EvalfReal "SymEngine::EvalfDomain::Real"
     cdef EvalfDomain EvalfSymbolic "SymEngine::EvalfDomain::Symbolic"
-    rcp_const_basic evalf(const Basic &b, unsigned long bits, EvalfDomain domain) except+ nogil
+    rcp_const_basic evalf(const Basic &b, unsigned long bits, EvalfDomain domain) nogil except +
 
 cdef extern from "<symengine/eval_double.h>" namespace "SymEngine":
-    double eval_double(const Basic &b) except+ nogil
-    double complex eval_complex_double(const Basic &b) except+ nogil
+    double eval_double(const Basic &b) nogil except +
+    double complex eval_complex_double(const Basic &b) nogil except +
 
 cdef extern from "<symengine/lambda_double.h>" namespace "SymEngine":
     cdef cppclass LambdaRealDoubleVisitor:
         LambdaRealDoubleVisitor() nogil
-        void init(const vec_basic &x, const vec_basic &b, bool cse) except+ nogil
+        void init(const vec_basic &x, const vec_basic &b, bool cse) nogil except +
         void call(double *r, const double *x) nogil
     cdef cppclass LambdaComplexDoubleVisitor:
         LambdaComplexDoubleVisitor() nogil
-        void init(const vec_basic &x, const vec_basic &b, bool cse) except+ nogil
+        void init(const vec_basic &x, const vec_basic &b, bool cse) nogil except +
         void call(double complex *r, const double complex *x) nogil
 
 cdef extern from "<symengine/llvm_double.h>" namespace "SymEngine":
     cdef cppclass LLVMVisitor:
         LLVMVisitor() nogil
-        void init(const vec_basic &x, const vec_basic &b, bool cse, int opt_level) except+ nogil
+        void init(const vec_basic &x, const vec_basic &b, bool cse, int opt_level) nogil except +
         const string& dumps() nogil
         void loads(const string&) nogil
 
@@ -868,27 +868,27 @@ cdef extern from "<symengine/llvm_double.h>" namespace "SymEngine":
 
 cdef extern from "<symengine/series.h>" namespace "SymEngine":
     cdef cppclass SeriesCoeffInterface:
-        rcp_const_basic as_basic() except+ nogil
-        umap_int_basic as_dict() except+ nogil
-        rcp_const_basic get_coeff(int) except+ nogil
+        rcp_const_basic as_basic() nogil except +
+        umap_int_basic as_dict() nogil except +
+        rcp_const_basic get_coeff(int) nogil except +
     ctypedef RCP[const SeriesCoeffInterface] rcp_const_seriescoeffinterface "SymEngine::RCP<const SymEngine::SeriesCoeffInterface>"
-    rcp_const_seriescoeffinterface series "SymEngine::series"(rcp_const_basic &ex, RCP[const Symbol] &var, unsigned int prec) except+ nogil
+    rcp_const_seriescoeffinterface series "SymEngine::series"(rcp_const_basic &ex, RCP[const Symbol] &var, unsigned int prec) nogil except +
 
 cdef extern from "<symengine/eval_mpfr.h>" namespace "SymEngine":
-    void eval_mpfr(mpfr_t result, const Basic &b, mpfr_rnd_t rnd) except+ nogil
+    void eval_mpfr(mpfr_t result, const Basic &b, mpfr_rnd_t rnd) nogil except +
 
 cdef extern from "<symengine/eval_mpc.h>" namespace "SymEngine":
-    void eval_mpc(mpc_t result, const Basic &b, mpfr_rnd_t rnd) except+ nogil
+    void eval_mpc(mpc_t result, const Basic &b, mpfr_rnd_t rnd) nogil except +
 
 cdef extern from "<symengine/parser.h>" namespace "SymEngine":
-    rcp_const_basic parse(const string &n) except+ nogil
+    rcp_const_basic parse(const string &n) nogil except +
 
 cdef extern from "<symengine/sets.h>" namespace "SymEngine":
     cdef cppclass Set(Basic):
-        RCP[const Set] set_intersection(RCP[const Set] &o) except+ nogil
-        RCP[const Set] set_union(RCP[const Set] &o) except+ nogil
-        RCP[const Set] set_complement(RCP[const Set] &o) except+ nogil
-        RCP[const Boolean] contains(rcp_const_basic &a) except+ nogil
+        RCP[const Set] set_intersection(RCP[const Set] &o) nogil except +
+        RCP[const Set] set_union(RCP[const Set] &o) nogil except +
+        RCP[const Set] set_complement(RCP[const Set] &o) nogil except +
+        RCP[const Boolean] contains(rcp_const_basic &a) nogil except +
     cdef cppclass Interval(Set):
         pass
     cdef cppclass EmptySet(Set):
@@ -912,24 +912,24 @@ cdef extern from "<symengine/sets.h>" namespace "SymEngine":
     cdef cppclass ImageSet(Set):
         pass
     ctypedef set[RCP[Set]] set_set "SymEngine::set_set"
-    cdef rcp_const_basic interval(RCP[const Number] &start, RCP[const Number] &end, bool l, bool r) except+ nogil
-    cdef RCP[const EmptySet] emptyset() except+ nogil
-    cdef RCP[const Reals] reals() except+ nogil
-    cdef RCP[const Rationals] rationals() except+ nogil
-    cdef RCP[const Integers] integers() except+ nogil
-    cdef RCP[const UniversalSet] universalset() except+ nogil
-    cdef RCP[const Set] finiteset(set_basic &container) except+ nogil
-    cdef RCP[const Set] set_union(set_set &a) except+ nogil
-    cdef RCP[const Set] set_intersection(set_set &a) except+ nogil
-    cdef RCP[const Set] set_complement_helper(RCP[const Set] &container, RCP[const Set] &universe) except+ nogil
-    cdef RCP[const Set] set_complement(RCP[const Set] &universe, RCP[const Set] &container) except+ nogil
-    cdef RCP[const Set] conditionset(rcp_const_basic &sym, RCP[const Boolean] &condition) except+ nogil
-    cdef RCP[const Set] imageset(rcp_const_basic &sym, rcp_const_basic &expr, RCP[const Set] &base) except+ nogil
+    cdef rcp_const_basic interval(RCP[const Number] &start, RCP[const Number] &end, bool l, bool r) nogil except +
+    cdef RCP[const EmptySet] emptyset() nogil except +
+    cdef RCP[const Reals] reals() nogil except +
+    cdef RCP[const Rationals] rationals() nogil except +
+    cdef RCP[const Integers] integers() nogil except +
+    cdef RCP[const UniversalSet] universalset() nogil except +
+    cdef RCP[const Set] finiteset(set_basic &container) nogil except +
+    cdef RCP[const Set] set_union(set_set &a) nogil except +
+    cdef RCP[const Set] set_intersection(set_set &a) nogil except +
+    cdef RCP[const Set] set_complement_helper(RCP[const Set] &container, RCP[const Set] &universe) nogil except +
+    cdef RCP[const Set] set_complement(RCP[const Set] &universe, RCP[const Set] &container) nogil except +
+    cdef RCP[const Set] conditionset(rcp_const_basic &sym, RCP[const Boolean] &condition) nogil except +
+    cdef RCP[const Set] imageset(rcp_const_basic &sym, rcp_const_basic &expr, RCP[const Set] &base) nogil except +
 
 cdef extern from "<symengine/solve.h>" namespace "SymEngine":
-    cdef RCP[const Set] solve(rcp_const_basic &f, RCP[const Symbol] &sym) except+ nogil
-    cdef RCP[const Set] solve(rcp_const_basic &f, RCP[const Symbol] &sym, RCP[const Set] &domain) except+ nogil
-    cdef vec_basic linsolve(const vec_basic &eqs, const vec_sym &syms) except+ nogil
+    cdef RCP[const Set] solve(rcp_const_basic &f, RCP[const Symbol] &sym) nogil except +
+    cdef RCP[const Set] solve(rcp_const_basic &f, RCP[const Symbol] &sym, RCP[const Set] &domain) nogil except +
+    cdef vec_basic linsolve(const vec_basic &eqs, const vec_sym &syms) nogil except +
 
 cdef extern from "symengine/tribool.h" namespace "SymEngine":
     cdef cppclass tribool:
@@ -945,10 +945,10 @@ cdef extern from "symengine/tribool.h" namespace "SymEngine::tribool":
     cdef tribool tritrue
 
 cdef extern from "<symengine/printers.h>" namespace "SymEngine":
-    string ccode(const Basic &x) except+ nogil
-    string latex(const Basic &x) except+ nogil
-    string latex(const DenseMatrix &x, unsigned max_rows, unsigned max_cols) except+ nogil
-    string unicode(const Basic &x) except+ nogil
+    string ccode(const Basic &x) nogil except +
+    string latex(const Basic &x) nogil except +
+    string latex(const DenseMatrix &x, unsigned max_rows, unsigned max_cols) nogil except +
+    string unicode(const Basic &x) nogil except +
 
 ## Defined in 'symengine/cwrapper.cpp'
 cdef struct CRCPBasic:
diff --git a/symengine/lib/symengine_wrapper.in.pxd b/symengine/lib/symengine_wrapper.in.pxd
index 3712e17c..03dbf1f0 100644
--- a/symengine/lib/symengine_wrapper.in.pxd
+++ b/symengine/lib/symengine_wrapper.in.pxd
@@ -2,6 +2,7 @@
 
 cimport symengine
 from symengine cimport RCP, map_basic_basic, rcp_const_basic
+from libcpp.memory cimport unique_ptr
 from libcpp.vector cimport vector
 from libcpp.string cimport string
 from libcpp cimport bool as cppbool
@@ -44,7 +45,7 @@ cdef class _Lambdify(object):
     cpdef unsafe_eval(sef, inp, out, unsigned nbroadcast=*)
 
 cdef class LambdaDouble(_Lambdify):
-    cdef vector[symengine.LambdaRealDoubleVisitor] lambda_double
+    cdef unique_ptr[symengine.LambdaRealDoubleVisitor] lambda_visitor
     cdef _init(self, symengine.vec_basic& args_, symengine.vec_basic& outs_, cppbool cse)
     cpdef unsafe_real(self, double[::1] inp, double[::1] out, int inp_offset=*, int out_offset=*)
     cpdef as_scipy_low_level_callable(self)
@@ -54,7 +55,7 @@ cdef class LambdaDouble(_Lambdify):
                       int inp_offset=*, int out_offset=*)
 
 cdef class LambdaComplexDouble(_Lambdify):
-    cdef vector[symengine.LambdaComplexDoubleVisitor] lambda_double
+    cdef unique_ptr[symengine.LambdaComplexDoubleVisitor] lambda_visitor
     cdef _init(self, symengine.vec_basic& args_, symengine.vec_basic& outs_, cppbool cse)
     cpdef unsafe_complex(self, double complex[::1] inp, double complex[::1] out, int inp_offset=*, int out_offset=*)
 
@@ -63,7 +64,7 @@ IF HAVE_SYMENGINE_LLVM:
         cdef int opt_level
 
     cdef class LLVMDouble(_LLVMLambdify):
-        cdef vector[symengine.LLVMDoubleVisitor] lambda_double
+        cdef unique_ptr[symengine.LLVMDoubleVisitor] lambda_visitor
         cdef _init(self, symengine.vec_basic& args_, symengine.vec_basic& outs_, cppbool cse)
         cdef _load(self, const string &s)
         cpdef unsafe_real(self, double[::1] inp, double[::1] out, int inp_offset=*, int out_offset=*)
@@ -71,14 +72,14 @@ IF HAVE_SYMENGINE_LLVM:
         cpdef as_ctypes(self)
 
     cdef class LLVMFloat(_LLVMLambdify):
-        cdef vector[symengine.LLVMFloatVisitor] lambda_double
+        cdef unique_ptr[symengine.LLVMFloatVisitor] lambda_visitor
         cdef _init(self, symengine.vec_basic& args_, symengine.vec_basic& outs_, cppbool cse)
         cdef _load(self, const string &s)
         cpdef unsafe_real(self, float[::1] inp, float[::1] out, int inp_offset=*, int out_offset=*)
 
     IF HAVE_SYMENGINE_LLVM_LONG_DOUBLE:
         cdef class LLVMLongDouble(_LLVMLambdify):
-            cdef vector[symengine.LLVMLongDoubleVisitor] lambda_double
+            cdef unique_ptr[symengine.LLVMLongDoubleVisitor] lambda_visitor
             cdef _init(self, symengine.vec_basic& args_, symengine.vec_basic& outs_, cppbool cse)
             cdef _load(self, const string &s)
             cpdef unsafe_real(self, long double[::1] inp, long double[::1] out, int inp_offset=*, int out_offset=*)
diff --git a/symengine/lib/symengine_wrapper.in.pyx b/symengine/lib/symengine_wrapper.in.pyx
index e10d1476..7b067cea 100644
--- a/symengine/lib/symengine_wrapper.in.pyx
+++ b/symengine/lib/symengine_wrapper.in.pyx
@@ -1211,7 +1211,7 @@ cdef class Basic(object):
         return int(float(self))
 
     def __long__(self):
-        return long(float(self))
+        return int(float(self))
 
     def __complex__(self):
         f = self.n(real=False)
@@ -1627,7 +1627,9 @@ class Equality(Relational):
     def is_Equality(self):
         return True
 
-    func = __class__
+    @property
+    def func(self):
+        return self.__class__
 
 
 Eq = Equality
@@ -1648,7 +1650,9 @@ class Unequality(Relational):
         s = self.args_as_sage()
         return sage.ne(*s)
 
-    func = __class__
+    @property
+    def func(self):
+        return self.__class__
 
 
 Ne = Unequality
@@ -3529,6 +3533,9 @@ cdef class DenseMatrixBase(MatrixBase):
     def __neg__(self):
         return self.mul_scalar(-1)
 
+    def __abs__(self):
+        return self.applyfunc(abs)
+
     def __getitem__(self, item):
         if isinstance(item, slice):
             if (self.ncols() == 0 or self.nrows() == 0):
@@ -3998,9 +4005,11 @@ cdef class DenseMatrixBase(MatrixBase):
                 deref(symengine.static_cast_DenseMatrix(b_.thisptr)),
                 deref(symengine.static_cast_DenseMatrix(x.thisptr)))
         elif method.upper() == 'FFGJ':
-            symengine.FFGJ_solve(deref(symengine.static_cast_DenseMatrix(self.thisptr)),
+            failure = symengine.FFGJ_solve(deref(symengine.static_cast_DenseMatrix(self.thisptr)),
                 deref(symengine.static_cast_DenseMatrix(b_.thisptr)),
                 deref(symengine.static_cast_DenseMatrix(x.thisptr)))
+            if (failure != 0):
+                raise Exception("Underdetermined system. Failed to find non-zero pivot in column: %d" % failure)
         else:
             raise Exception("Unsupported method.")
 
@@ -5152,11 +5161,11 @@ cdef class LambdaDouble(_Lambdify):
         pass
 
     cdef _init(self, symengine.vec_basic& args_, symengine.vec_basic& outs_, cppbool cse):
-        self.lambda_double.resize(1)
-        self.lambda_double[0].init(args_, outs_, cse)
+        self.lambda_visitor.reset(new symengine.LambdaRealDoubleVisitor())
+        deref(self.lambda_visitor).init(args_, outs_, cse)
 
     cpdef unsafe_real(self, double[::1] inp, double[::1] out, int inp_offset=0, int out_offset=0):
-        self.lambda_double[0].call(&out[out_offset], &inp[inp_offset])
+        deref(self.lambda_visitor).call(&out[out_offset], &inp[inp_offset])
 
     cpdef unsafe_eval(self, inp, out, unsigned nbroadcast=1):
         cdef double[::1] c_inp, c_out
@@ -5164,7 +5173,7 @@ cdef class LambdaDouble(_Lambdify):
         c_inp = np.ascontiguousarray(inp.ravel(order=self.order), dtype=self.numpy_dtype)
         c_out = out
         for idx in range(nbroadcast):
-            self.lambda_double[0].call(&c_out[idx*self.tot_out_size], &c_inp[idx*self.args_size])
+            deref(self.lambda_visitor).call(&c_out[idx*self.tot_out_size], &c_inp[idx*self.args_size])
 
     cpdef as_scipy_low_level_callable(self):
         from ctypes import c_double, c_void_p, c_int, cast, POINTER, CFUNCTYPE
@@ -5172,7 +5181,7 @@ cdef class LambdaDouble(_Lambdify):
             raise RuntimeError("SciPy LowLevelCallable supports only functions with 1 output")
         addr1 = cast(<size_t>&_scipy_callback_lambda_real,
                         CFUNCTYPE(c_double, c_int, POINTER(c_double), c_void_p))
-        addr2 = cast(<size_t>&self.lambda_double[0], c_void_p)
+        addr2 = cast(<size_t>self.lambda_visitor.get(), c_void_p)
         return create_low_level_callable(self, addr1, addr2)
 
     cpdef as_ctypes(self):
@@ -5187,7 +5196,7 @@ cdef class LambdaDouble(_Lambdify):
         from ctypes import c_double, c_void_p, c_int, cast, POINTER, CFUNCTYPE
         addr1 = cast(<size_t>&_ctypes_callback_lambda_real,
                         CFUNCTYPE(c_void_p, POINTER(c_double), POINTER(c_double), c_void_p))
-        addr2 = cast(<size_t>&self.lambda_double[0], c_void_p)
+        addr2 = cast(<size_t>self.lambda_visitor.get(), c_void_p)
         return addr1, addr2
 
 
@@ -5197,11 +5206,11 @@ cdef class LambdaComplexDouble(_Lambdify):
         pass
 
     cdef _init(self, symengine.vec_basic& args_, symengine.vec_basic& outs_, cppbool cse):
-        self.lambda_double.resize(1)
-        self.lambda_double[0].init(args_, outs_, cse)
+        self.lambda_visitor.reset(new symengine.LambdaComplexDoubleVisitor())
+        deref(self.lambda_visitor).init(args_, outs_, cse)
 
     cpdef unsafe_complex(self, double complex[::1] inp, double complex[::1] out, int inp_offset=0, int out_offset=0):
-        self.lambda_double[0].call(&out[out_offset], &inp[inp_offset])
+        deref(self.lambda_visitor).call(&out[out_offset], &inp[inp_offset])
 
     cpdef unsafe_eval(self, inp, out, unsigned nbroadcast=1):
         cdef double complex[::1] c_inp, c_out
@@ -5209,7 +5218,7 @@ cdef class LambdaComplexDouble(_Lambdify):
         c_inp = np.ascontiguousarray(inp.ravel(order=self.order), dtype=self.numpy_dtype)
         c_out = out
         for idx in range(nbroadcast):
-            self.lambda_double[0].call(&c_out[idx*self.tot_out_size], &c_inp[idx*self.args_size])
+            deref(self.lambda_visitor).call(&c_out[idx*self.tot_out_size], &c_inp[idx*self.args_size])
 
 
 IF HAVE_SYMENGINE_LLVM:
@@ -5218,23 +5227,23 @@ IF HAVE_SYMENGINE_LLVM:
             self.opt_level = opt_level
 
         cdef _init(self, symengine.vec_basic& args_, symengine.vec_basic& outs_, cppbool cse):
-            self.lambda_double.resize(1)
-            self.lambda_double[0].init(args_, outs_, cse, self.opt_level)
+            self.lambda_visitor.reset(new symengine.LLVMDoubleVisitor())
+            deref(self.lambda_visitor).init(args_, outs_, cse, self.opt_level)
 
         cdef _load(self, const string &s):
-            self.lambda_double.resize(1)
-            self.lambda_double[0].loads(s)
+            self.lambda_visitor.reset(new symengine.LLVMDoubleVisitor())
+            deref(self.lambda_visitor).loads(s)
 
         def __reduce__(self):
             """
             Interface for pickle. Note that the resulting object is platform dependent.
             """
-            cdef bytes s = self.lambda_double[0].dumps()
+            cdef bytes s = deref(self.lambda_visitor).dumps()
             return llvm_loading_func, (self.args_size, self.tot_out_size, self.out_shapes, self.real, \
                 self.n_exprs, self.order, self.accum_out_sizes, self.numpy_dtype, s)
 
         cpdef unsafe_real(self, double[::1] inp, double[::1] out, int inp_offset=0, int out_offset=0):
-            self.lambda_double[0].call(&out[out_offset], &inp[inp_offset])
+            deref(self.lambda_visitor).call(&out[out_offset], &inp[inp_offset])
 
         cpdef unsafe_eval(self, inp, out, unsigned nbroadcast=1):
             cdef double[::1] c_inp, c_out
@@ -5242,7 +5251,7 @@ IF HAVE_SYMENGINE_LLVM:
             c_inp = np.ascontiguousarray(inp.ravel(order=self.order), dtype=self.numpy_dtype)
             c_out = out
             for idx in range(nbroadcast):
-                self.lambda_double[0].call(&c_out[idx*self.tot_out_size], &c_inp[idx*self.args_size])
+                deref(self.lambda_visitor).call(&c_out[idx*self.tot_out_size], &c_inp[idx*self.args_size])
 
         cpdef as_scipy_low_level_callable(self):
             from ctypes import c_double, c_void_p, c_int, cast, POINTER, CFUNCTYPE
@@ -5252,7 +5261,7 @@ IF HAVE_SYMENGINE_LLVM:
                 raise RuntimeError("SciPy LowLevelCallable supports only functions with 1 output")
             addr1 = cast(<size_t>&_scipy_callback_llvm_real,
                             CFUNCTYPE(c_double, c_int, POINTER(c_double), c_void_p))
-            addr2 = cast(<size_t>&self.lambda_double[0], c_void_p)
+            addr2 = cast(<size_t>self.lambda_visitor.get(), c_void_p)
             return create_low_level_callable(self, addr1, addr2)
 
         cpdef as_ctypes(self):
@@ -5269,7 +5278,7 @@ IF HAVE_SYMENGINE_LLVM:
                 raise RuntimeError("Lambda function has to be real")
             addr1 = cast(<size_t>&_ctypes_callback_llvm_real,
                             CFUNCTYPE(c_void_p, POINTER(c_double), POINTER(c_double), c_void_p))
-            addr2 = cast(<size_t>&self.lambda_double[0], c_void_p)
+            addr2 = cast(<size_t>self.lambda_visitor.get(), c_void_p)
             return addr1, addr2
 
     cdef class LLVMFloat(_LLVMLambdify):
@@ -5277,23 +5286,23 @@ IF HAVE_SYMENGINE_LLVM:
             self.opt_level = opt_level
 
         cdef _init(self, symengine.vec_basic& args_, symengine.vec_basic& outs_, cppbool cse):
-            self.lambda_double.resize(1)
-            self.lambda_double[0].init(args_, outs_, cse, self.opt_level)
+            self.lambda_visitor.reset(new symengine.LLVMFloatVisitor())
+            deref(self.lambda_visitor).init(args_, outs_, cse, self.opt_level)
 
         cdef _load(self, const string &s):
-            self.lambda_double.resize(1)
-            self.lambda_double[0].loads(s)
+            self.lambda_visitor.reset(new symengine.LLVMFloatVisitor())
+            deref(self.lambda_visitor).loads(s)
 
         def __reduce__(self):
             """
             Interface for pickle. Note that the resulting object is platform dependent.
             """
-            cdef bytes s = self.lambda_double[0].dumps()
+            cdef bytes s = deref(self.lambda_visitor).dumps()
             return llvm_float_loading_func, (self.args_size, self.tot_out_size, self.out_shapes, self.real, \
                 self.n_exprs, self.order, self.accum_out_sizes, self.numpy_dtype, s)
 
         cpdef unsafe_real(self, float[::1] inp, float[::1] out, int inp_offset=0, int out_offset=0):
-            self.lambda_double[0].call(&out[out_offset], &inp[inp_offset])
+            deref(self.lambda_visitor).call(&out[out_offset], &inp[inp_offset])
 
         cpdef unsafe_eval(self, inp, out, unsigned nbroadcast=1):
             cdef float[::1] c_inp, c_out
@@ -5301,7 +5310,7 @@ IF HAVE_SYMENGINE_LLVM:
             c_inp = np.ascontiguousarray(inp.ravel(order=self.order), dtype=self.numpy_dtype)
             c_out = out
             for idx in range(nbroadcast):
-                self.lambda_double[0].call(&c_out[idx*self.tot_out_size], &c_inp[idx*self.args_size])
+                deref(self.lambda_visitor).call(&c_out[idx*self.tot_out_size], &c_inp[idx*self.args_size])
 
     IF HAVE_SYMENGINE_LLVM_LONG_DOUBLE:
         cdef class LLVMLongDouble(_LLVMLambdify):
@@ -5309,23 +5318,23 @@ IF HAVE_SYMENGINE_LLVM:
                 self.opt_level = opt_level
 
             cdef _init(self, symengine.vec_basic& args_, symengine.vec_basic& outs_, cppbool cse):
-                self.lambda_double.resize(1)
-                self.lambda_double[0].init(args_, outs_, cse, self.opt_level)
+                self.lambda_visitor.reset(new symengine.LLVMLongDoubleVisitor())
+                deref(self.lambda_visitor).init(args_, outs_, cse, self.opt_level)
 
             cdef _load(self, const string &s):
-                self.lambda_double.resize(1)
-                self.lambda_double[0].loads(s)
+                self.lambda_visitor.reset(new symengine.LLVMLongDoubleVisitor())
+                deref(self.lambda_visitor).loads(s)
 
             def __reduce__(self):
                 """
                 Interface for pickle. Note that the resulting object is platform dependent.
                 """
-                cdef bytes s = self.lambda_double[0].dumps()
+                cdef bytes s = deref(self.lambda_visitor).dumps()
                 return llvm_long_double_loading_func, (self.args_size, self.tot_out_size, self.out_shapes, self.real, \
                     self.n_exprs, self.order, self.accum_out_sizes, self.numpy_dtype, s)
 
             cpdef unsafe_real(self, long double[::1] inp, long double[::1] out, int inp_offset=0, int out_offset=0):
-                self.lambda_double[0].call(&out[out_offset], &inp[inp_offset])
+                deref(self.lambda_visitor).call(&out[out_offset], &inp[inp_offset])
 
             cpdef unsafe_eval(self, inp, out, unsigned nbroadcast=1):
                 cdef long double[::1] c_inp, c_out
@@ -5333,7 +5342,7 @@ IF HAVE_SYMENGINE_LLVM:
                 c_inp = np.ascontiguousarray(inp.ravel(order=self.order), dtype=self.numpy_dtype)
                 c_out = out
                 for idx in range(nbroadcast):
-                    self.lambda_double[0].call(&c_out[idx*self.tot_out_size], &c_inp[idx*self.args_size])
+                    deref(self.lambda_visitor).call(&c_out[idx*self.tot_out_size], &c_inp[idx*self.args_size])
 
     def llvm_loading_func(*args):
         return LLVMDouble(args, _load=True)
diff --git a/symengine/tests/test_logic.py b/symengine/tests/test_logic.py
index 7c01f8e9..3d0c3391 100644
--- a/symengine/tests/test_logic.py
+++ b/symengine/tests/test_logic.py
@@ -27,6 +27,10 @@ def test_relationals():
     assert Ge(1, 1) == true
     assert Eq(I, 2) == false
     assert Ne(I, 2) == true
+    eq = Eq(x, y)
+    assert eq.func(*eq.args) == eq
+    ne = Ne(x, y)
+    assert ne.func(*ne.args) == ne
 
 
 def test_rich_cmp():
@@ -118,4 +122,3 @@ def test_Contains():
     assert Contains(x, Interval(1, 1)) != false
     assert Contains(oo, Interval(-oo, oo)) == false
     assert Contains(-oo, Interval(-oo, oo)) == false
-
diff --git a/symengine/tests/test_matrices.py b/symengine/tests/test_matrices.py
index de997529..5e6821c4 100644
--- a/symengine/tests/test_matrices.py
+++ b/symengine/tests/test_matrices.py
@@ -11,7 +11,7 @@
     have_numpy = True
 except ImportError:
     have_numpy = False
-    
+
 try:
     import sympy
     from sympy.core.cache import clear_cache
@@ -286,11 +286,13 @@ def test_mul_scalar():
     assert a * A == DenseMatrix(2, 2, [a, 2*a, 3*a, 4*a])
 
 
-def test_neg():
+def test_neg_abs():
     A = DenseMatrix(2, 3, [1, 2, 3, 4, 5, 6])
     B = DenseMatrix(2, 3, [-1, -2, -3, -4, -5, -6])
     assert -A == B
 
+    assert A == abs(B)
+
 
 def test_sub():
     A = DenseMatrix(2, 2, [1, 2, 3, 4])
@@ -444,6 +446,15 @@ def test_solve():
     x = A.solve(b, 'FFGJ')
     assert x == y
 
+    B = DenseMatrix(2, 2, [0]*4)
+    try:
+        B.solve(b, 'FFGJ')
+    except Exception:
+        pass
+    else:
+        raise Exception("this operation should have raised an exception")
+
+
 
 def test_FFLU():
     A = DenseMatrix(4, 4, [1, 2, 3, 4, 2, 2, 3, 4, 3, 3, 3, 4, 9, 8, 7, 6])
diff --git a/symengine/utilities.py b/symengine/utilities.py
index a64ea15e..1d186707 100644
--- a/symengine/utilities.py
+++ b/symengine/utilities.py
@@ -1,4 +1,5 @@
 from .lib.symengine_wrapper import Symbol, Basic
+
 from itertools import combinations, permutations, product, product as cartes
 import re as _re
 import string
diff --git a/symengine_version.txt b/symengine_version.txt
index 4f7638fd..87a1cf59 100644
--- a/symengine_version.txt
+++ b/symengine_version.txt
@@ -1 +1 @@
-v0.11.1
+v0.12.0