Add tests for numbers and matrices and trace

Author: rikardn

symengine/lib/symengine.pxd

@@ -348,6 +348,11 @@ cdef extern from "<symengine/number.h>" namespace "SymEngine":
     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 extern from "pywrapper.h" namespace "SymEngine":
     cdef cppclass PyNumber(NumberWrapper):
@@ -814,6 +819,14 @@ cdef extern from "<symengine/matrix.h>" namespace "SymEngine":
         void col_insert(const DenseMatrix &B, unsigned pos) nogil
         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
 
     bool is_a_DenseMatrix "SymEngine::is_a<SymEngine::DenseMatrix>"(const MatrixBase &b) nogil
     DenseMatrix* static_cast_DenseMatrix "static_cast<SymEngine::DenseMatrix*>"(const MatrixBase *a)

symengine/lib/symengine_wrapper.pyx

@@ -1072,6 +1072,26 @@ cdef class Basic(object):
     def is_zero(self):
         return is_zero(self)
 
+    @property
+    def is_positive(self):
+        return is_positive(self)
+
+    @property
+    def is_negative(self):
+        return is_negative(self)
+
+    @property
+    def is_nonpositive(self):
+        return is_nonpositive(self)
+
+    @property
+    def is_nonnegative(self):
+        return is_nonnegative(self)
+
+    @property
+    def is_real(self):
+        return is_real(self)
+
     def copy(self):
         return self
 
@@ -3576,6 +3596,37 @@ cdef class DenseMatrixBase(MatrixBase):
     def H(self):
         return self.conjugate_transpose()
 
+    def trace(self):
+        return c2py(deref(symengine.static_cast_DenseMatrix(self.thisptr)).trace())
+
+    @property
+    def is_zero_matrix(self):
+        return tribool(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())
+
+    @property
+    def is_diagonal(self):
+        return tribool(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())
+
+    @property
+    def is_hermitian(self):
+        return tribool(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())
+
+    @property
+    def is_strongly_diagonally_dominant(self):
+        return tribool(deref(symengine.static_cast_DenseMatrix(self.thisptr)).is_strictly_diagonally_dominant())
+
     @property
     def T(self):
         return self.transpose()
@@ -5159,6 +5210,36 @@ def is_zero(expr):
     return tribool(tbool)
 
 
+def is_positive(expr):
+    cdef Basic expr_ = sympify(expr)
+    cdef int tbool = symengine.is_positive(deref(expr_.thisptr))
+    return tribool(tbool)
+
+
+def is_negative(expr):
+    cdef Basic expr_ = sympify(expr)
+    cdef int tbool = symengine.is_negative(deref(expr_.thisptr))
+    return tribool(tbool)
+
+
+def is_nonpositive(expr):
+    cdef Basic expr_ = sympify(expr)
+    cdef int tbool = symengine.is_nonpositive(deref(expr_.thisptr))
+    return tribool(tbool)
+
+
+def is_nonnegative(expr):
+    cdef Basic expr_ = sympify(expr)
+    cdef int tbool = symengine.is_nonnegative(deref(expr_.thisptr))
+    return tribool(tbool)
+
+
+def is_real(expr):
+    cdef Basic expr_ = sympify(expr)
+    cdef int tbool = symengine.is_real(deref(expr_.thisptr))
+    return tribool(tbool)
+
+
 def set_union(*args):
     cdef symengine.set_set s
     cdef Set e_

symengine/tests/test_matrices.py

@@ -321,6 +321,70 @@ def test_conjugate_transpose():
     assert A.conjugate_transpose() == DenseMatrix(2, 2, [1, 3, 2, -I])
 
 
+def test_trace():
+    A = DenseMatrix(2, 2, [1, 2, 3, 4])
+    assert A.trace() == 5
+
+
+def test_is_zero_matrix():
+    A = DenseMatrix(2, 2, [1, 2, 3, I])
+    assert not A.is_zero_matrix
+    B = DenseMatrix(1, 1, [Symbol('x')])
+    assert B.is_zero_matrix is None
+    C = DenseMatrix(3, 3, [0, 0, 0, 0, 0, 0, 0, 0, 0])
+    assert C.is_zero_matrix
+
+
+def test_is_real_matrix():
+    A = DenseMatrix(2, 2, [1, 2, 3, I])
+    assert not A.is_real_matrix
+    B = DenseMatrix(1, 1, [Symbol('x')])
+    assert B.is_real_matrix is None
+    C = DenseMatrix(3, 3, [0, 0, 0, 0, 0, 0, 0, 0, 0])
+    assert C.is_real_matrix
+
+
+def test_is_diagonal():
+    A = DenseMatrix(2, 2, [1, 0, 0, I])
+    assert A.is_diagonal
+    B = DenseMatrix(1, 1, [Symbol('x')])
+    assert B.is_diagonal
+    C = DenseMatrix(3, 3, [0, 0, 0, 0, 0, 0, 0, 2, 0])
+    assert not C.is_diagonal
+
+
+def test_is_symmetric():
+    A = DenseMatrix(2, 2, [1, 3, 2, I])
+    assert not A.is_symmetric
+    B = DenseMatrix(1, 1, [Symbol('x')])
+    assert B.is_symmetric
+    C = DenseMatrix(3, 3, [0, 0, 0, 0, 0, 0, 0, 2, 0])
+    assert not C.is_symmetric
+
+
+def test_is_hermitian():
+    A = DenseMatrix(2, 2, [1, 3, 2, I])
+    assert not A.is_hermitian
+    B = DenseMatrix(1, 1, [Symbol('x')])
+    assert B.is_hermitian is None
+    C = DenseMatrix(3, 3, [0, I, 0, 0, 0, 0, 0, 2, 0])
+    assert not C.is_hermitian
+
+
+def test_is_weakly_diagonally_dominant():
+    A = DenseMatrix(2, 2, [2, 1, 1, 2])
+    assert A.is_weakly_diagonally_dominant
+    C = DenseMatrix(3, 3, [Symbol('x'), 0, 0, 0, 3, 0, 0, 0, 4])
+    assert C.is_weakly_diagonally_dominant is None
+
+
+def test_is_strongly_diagonally_dominant():
+    A = DenseMatrix(2, 2, [2, 1, 1, 2])
+    assert A.is_strongly_diagonally_dominant
+    C = DenseMatrix(3, 3, [Symbol('x'), 2, 0, 0, 4, 0, 0, 0, 4])
+    assert C.is_strongly_diagonally_dominant is None
+
+
 def test_LU():
     A = DenseMatrix(3, 3, [1, 3, 5, 2, 5, 6, 8, 3, 1])
     L, U = A.LU()

symengine/tests/test_number.py

@@ -1,6 +1,6 @@
 from symengine.utilities import raises
 
-from symengine import Integer, I, S, Symbol, pi
+from symengine import Integer, I, S, Symbol, pi, Rational
 from symengine.lib.symengine_wrapper import (perfect_power, is_square, integer_nthroot)
 
 
@@ -155,3 +155,32 @@ def test_integer_nthroot():
 
 def test_is_zero():
     assert Symbol('x').is_zero is None
+
+
+def test_is_positive():
+    assert Rational(1, 2).is_positive
+    assert not Rational(-2, 3).is_positive
+    assert Symbol('x').is_positive is None
+
+
+def test_is_negative():
+    assert not Rational(1, 2).is_negative
+    assert Rational(-2, 3).is_negative
+    assert Symbol('x').is_negative is None
+
+
+def test_is_nonpositive():
+    assert not Rational(1, 2).is_nonpositive
+    assert Rational(-2, 3).is_nonpositive
+    assert Symbol('x').is_nonpositive is None
+
+
+def test_is_nonnegative():
+    assert Rational(1, 2).is_nonnegative
+    assert not Rational(-2, 3).is_nonnegative
+    assert Symbol('x').is_nonnegative is None
+
+
+def test_is_real():
+    assert Rational(1, 2).is_real
+    assert Symbol('x').is_real is None

symengine_version.txt

@@ -1 +1 @@
-46090cfd20b92e73b6ddd8c203e3173b106adabb
+44eb47e3bbfa7e06718f2f65f3f41a0a9d133b70