Add boostmp to test matrix, also bump llvm version tested. (#428)

* Add boostmp to test matrix, also bump llvm version tested.
* handle tribool explicitly (bool -> tribool)
* boost: skip test integer_nthroot (does not complete in 6h)

Author: bjodah

.github/workflows/ci.yml

@@ -90,13 +90,15 @@ jobs:
             CC: clang
 
           - BUILD_TYPE: Debug
-            PYTHON_VERSION: '3.8'
+            PYTHON_VERSION: '3.10'
             WITH_SYMPY: yes
-            WITH_LLVM: 13 
+            WITH_LLVM: 14
             WITH_SCIPY: yes
-            OS: ubuntu-20.04
-            EXTRA_APT_REPOSITORY: 'deb http://apt.llvm.org/focal/ llvm-toolchain-focal-13 main'
-            EXTRA_APT_PACKAGES: 'llvm-13'
+            INTEGER_CLASS: 'boostmp'
+            PYTEST_ADDOPTS: '-k "not integer_nthroot"'
+            OS: ubuntu-22.04
+            EXTRA_APT_REPOSITORY: 'deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-14 main'
+            EXTRA_APT_PACKAGES: 'llvm-14'
 
           - BUILD_TYPE: Debug
             PYTHON_VERSION: '3.7'
@@ -143,6 +145,7 @@ jobs:
       run: |
         source bin/test_symengine_unix.sh
       env:
+        PYTEST_ADDOPTS: ${{ matrix.PYTEST_ADDOPTS }}
         USE_GLIBCXX_DEBUG: ${{ matrix.USE_GLIBCXX_DEBUG }}
         WITH_MPFR: ${{ matrix.WITH_MPFR }}
         BUILD_BENCHMARKS: ${{ matrix.BUILD_BENCHMARKS }}

symengine/lib/symengine.pxd

@@ -350,12 +350,12 @@ cdef extern from "<symengine/number.h>" namespace "SymEngine":
         pass
     cdef cppclass NumberWrapper(Basic):
         pass
-    cdef int is_zero(const Basic &x) nogil
-    cdef int is_positive(const Basic &x) nogil
-    cdef int is_negative(const Basic &x) nogil
-    cdef int is_nonnegative(const Basic &x) nogil
-    cdef int is_nonpositive(const Basic &x) nogil
-    cdef int is_real(const Basic &x) nogil
+    cdef tribool is_zero(const Basic &x) nogil
+    cdef tribool is_positive(const Basic &x) nogil
+    cdef tribool is_negative(const Basic &x) nogil
+    cdef tribool is_nonnegative(const Basic &x) nogil
+    cdef tribool is_nonpositive(const Basic &x) nogil
+    cdef tribool is_real(const Basic &x) nogil
 
 cdef extern from "pywrapper.h" namespace "SymEngine":
     cdef cppclass PyNumber(NumberWrapper):
@@ -829,15 +829,15 @@ cdef extern from "<symengine/matrix.h>" namespace "SymEngine":
         void row_del(unsigned k) nogil
         void col_del(unsigned k) nogil
         rcp_const_basic trace() nogil
-        int is_zero() nogil
-        int is_real() nogil
-        int is_diagonal() nogil
-        int is_symmetric() nogil
-        int is_hermitian() nogil
-        int is_weakly_diagonally_dominant() nogil
-        int is_strictly_diagonally_dominant() nogil
-        int is_positive_definite() nogil
-        int is_negative_definite() nogil
+        tribool is_zero() nogil
+        tribool is_real() nogil
+        tribool is_diagonal() nogil
+        tribool is_symmetric() nogil
+        tribool is_hermitian() nogil
+        tribool is_weakly_diagonally_dominant() nogil
+        tribool is_strictly_diagonally_dominant() nogil
+        tribool is_positive_definite() nogil
+        tribool is_negative_definite() nogil
 
     bool is_a_DenseMatrix "SymEngine::is_a<SymEngine::DenseMatrix>"(const MatrixBase &b) nogil
     DenseMatrix* static_cast_DenseMatrix "static_cast<SymEngine::DenseMatrix*>"(const MatrixBase *a)
@@ -1104,6 +1104,19 @@ cdef extern from "<symengine/solve.h>" namespace "SymEngine":
     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:
+        pass  # tribool is an enum class
+
+    cdef bool is_true(tribool) nogil
+    cdef bool is_false(tribool) nogil
+    cdef bool is_indeterminate(tribool) nogil
+
+cdef extern from "symengine/tribool.h" namespace "SymEngine::tribool":
+    cdef tribool indeterminate
+    cdef tribool trifalse
+    cdef tribool tritrue
+
 cdef extern from "<symengine/printers.h>" namespace "SymEngine":
     string ccode(const Basic &x) nogil except +
     string latex(const Basic &x) nogil except +

symengine/lib/symengine_wrapper.pyx

@@ -3,7 +3,7 @@ cimport symengine
 from symengine cimport (RCP, pair, map_basic_basic, umap_int_basic,
     umap_int_basic_iterator, umap_basic_num, umap_basic_num_iterator,
     rcp_const_basic, std_pair_short_rcp_const_basic,
-    rcp_const_seriescoeffinterface, CRCPBasic)
+                        rcp_const_seriescoeffinterface, CRCPBasic, tribool, is_indeterminate, is_true, is_false)
 from libcpp cimport bool as cppbool
 from libcpp.string cimport string
 from libcpp.vector cimport vector
@@ -3696,39 +3696,39 @@ cdef class DenseMatrixBase(MatrixBase):
 
     @property
     def is_zero_matrix(self):
-        return tribool(deref(symengine.static_cast_DenseMatrix(self.thisptr)).is_zero())
+        return tribool_py(deref(symengine.static_cast_DenseMatrix(self.thisptr)).is_zero())
 
     @property
     def is_real_matrix(self):
-        return tribool(deref(symengine.static_cast_DenseMatrix(self.thisptr)).is_real())
+        return tribool_py(deref(symengine.static_cast_DenseMatrix(self.thisptr)).is_real())
 
     @property
     def is_diagonal(self):
-        return tribool(deref(symengine.static_cast_DenseMatrix(self.thisptr)).is_diagonal())
+        return tribool_py(deref(symengine.static_cast_DenseMatrix(self.thisptr)).is_diagonal())
 
     @property
     def is_symmetric(self):
-        return tribool(deref(symengine.static_cast_DenseMatrix(self.thisptr)).is_symmetric())
+        return tribool_py(deref(symengine.static_cast_DenseMatrix(self.thisptr)).is_symmetric())
 
     @property
     def is_hermitian(self):
-        return tribool(deref(symengine.static_cast_DenseMatrix(self.thisptr)).is_hermitian())
+        return tribool_py(deref(symengine.static_cast_DenseMatrix(self.thisptr)).is_hermitian())
 
     @property
     def is_weakly_diagonally_dominant(self):
-        return tribool(deref(symengine.static_cast_DenseMatrix(self.thisptr)).is_weakly_diagonally_dominant())
+        return tribool_py(deref(symengine.static_cast_DenseMatrix(self.thisptr)).is_weakly_diagonally_dominant())
 
     @property
     def is_strongly_diagonally_dominant(self):
-        return tribool(deref(symengine.static_cast_DenseMatrix(self.thisptr)).is_strictly_diagonally_dominant())
+        return tribool_py(deref(symengine.static_cast_DenseMatrix(self.thisptr)).is_strictly_diagonally_dominant())
 
     @property
     def is_positive_definite(self):
-        return tribool(deref(symengine.static_cast_DenseMatrix(self.thisptr)).is_positive_definite())
+        return tribool_py(deref(symengine.static_cast_DenseMatrix(self.thisptr)).is_positive_definite())
 
     @property
     def is_negative_definite(self):
-        return tribool(deref(symengine.static_cast_DenseMatrix(self.thisptr)).is_negative_definite())
+        return tribool_py(deref(symengine.static_cast_DenseMatrix(self.thisptr)).is_negative_definite())
 
     @property
     def T(self):
@@ -5347,47 +5347,51 @@ def contains(expr, sset):
     return c2py(<rcp_const_basic>(symengine.contains(expr_.thisptr, s)))
 
 
-def tribool(value):
-    if value == -1:
+cdef tribool_py(tribool value):
+    if is_indeterminate(value):
         return None
+    elif is_true(value):
+        return True
+    elif is_false(value):
+        return False
     else:
-        return bool(value)
+        raise RuntimeError("Internal error in symengine.py, tribool got a fourth value.")
 
 
 def is_zero(expr):
     cdef Basic expr_ = sympify(expr)
-    cdef int tbool = symengine.is_zero(deref(expr_.thisptr))
-    return tribool(tbool)
+    cdef tribool tbool = symengine.is_zero(deref(expr_.thisptr))
+    return tribool_py(tbool)
 
 
 def is_positive(expr):
     cdef Basic expr_ = sympify(expr)
-    cdef int tbool = symengine.is_positive(deref(expr_.thisptr))
-    return tribool(tbool)
+    cdef tribool tbool = symengine.is_positive(deref(expr_.thisptr))
+    return tribool_py(tbool)
 
 
 def is_negative(expr):
     cdef Basic expr_ = sympify(expr)
-    cdef int tbool = symengine.is_negative(deref(expr_.thisptr))
-    return tribool(tbool)
+    cdef tribool tbool = symengine.is_negative(deref(expr_.thisptr))
+    return tribool_py(tbool)
 
 
 def is_nonpositive(expr):
     cdef Basic expr_ = sympify(expr)
-    cdef int tbool = symengine.is_nonpositive(deref(expr_.thisptr))
-    return tribool(tbool)
+    cdef tribool tbool = symengine.is_nonpositive(deref(expr_.thisptr))
+    return tribool_py(tbool)
 
 
 def is_nonnegative(expr):
     cdef Basic expr_ = sympify(expr)
-    cdef int tbool = symengine.is_nonnegative(deref(expr_.thisptr))
-    return tribool(tbool)
+    cdef tribool tbool = symengine.is_nonnegative(deref(expr_.thisptr))
+    return tribool_py(tbool)
 
 
 def is_real(expr):
     cdef Basic expr_ = sympify(expr)
-    cdef int tbool = symengine.is_real(deref(expr_.thisptr))
-    return tribool(tbool)
+    cdef tribool tbool = symengine.is_real(deref(expr_.thisptr))
+    return tribool_py(tbool)
 
 
 def set_union(*args):

symengine_version.txt

@@ -1 +1 @@
-5a9d4fa8c769b2dc8d7904ec16d7ea76328c4565
+fcef5c7d6cc848e3f6c0b9ecc5a22d30e5e98f99