Added tests

symengine/__init__.py

@@ -7,7 +7,9 @@
         MatrixBase, Basic, Lambdify, LambdifyCSE, Lambdify as lambdify,
         DictBasic, symarray, series, diff, zeros, eye, diag, ones,
         Derivative, Subs, add, expand, has_symbol, UndefFunction,
-        Function, FunctionSymbol as AppliedUndef)
+        Function, FunctionSymbol as AppliedUndef, true, false, Equality,
+        Unequality, GreaterThan, LessThan, StrictGreaterThan, StrictLessThan,
+        Eq, Ne, Ge, Le, Gt, Lt)
 from .utilities import var, symbols
 from .functions import *
 

symengine/lib/symengine.pxd

@@ -153,7 +153,7 @@ cdef extern from "<symengine/symengine_rcp.h>" namespace "SymEngine":
     RCP[const RealMPFR] rcp_static_cast_RealMPFR "SymEngine::rcp_static_cast<const SymEngine::RealMPFR>"(RCP[const Basic] &b) nogil
     RCP[const ComplexMPC] rcp_static_cast_ComplexMPC "SymEngine::rcp_static_cast<const SymEngine::ComplexMPC>"(RCP[const Basic] &b) nogil
     RCP[const Log] rcp_static_cast_Log "SymEngine::rcp_static_cast<const SymEngine::Log>"(RCP[const Basic] &b) nogil
-    RCP[const Boolean] rcp_static_cast_Boolean "SymEngine::rcp_static_cast<const SymEngine::Boolean>"(RCP[const Basic] &b) nogil
+    RCP[const BooleanAtom] rcp_static_cast_BooleanAtom "SymEngine::rcp_static_cast<const SymEngine::BooleanAtom>"(RCP[const Basic] &b) nogil
     RCP[const PyNumber] rcp_static_cast_PyNumber "SymEngine::rcp_static_cast<const SymEngine::PyNumber>"(RCP[const Basic] &b) nogil
     RCP[const PyFunction] rcp_static_cast_PyFunction "SymEngine::rcp_static_cast<const SymEngine::PyFunction>"(RCP[const Basic] &b) nogil
     Ptr[RCP[Basic]] outArg(RCP[const Basic] &arg) nogil
@@ -766,7 +766,7 @@ cdef extern from "<symengine/logic.h>" namespace "SymEngine":
     cdef cppclass Boolean(Basic):
         pass
     cdef cppclass BooleanAtom(Boolean):
-        pass
+        bool get_val() nogil
     cdef cppclass Relational(Boolean):
         pass
     cdef cppclass Equality(Relational):
@@ -781,13 +781,13 @@ cdef extern from "<symengine/logic.h>" namespace "SymEngine":
     RCP[const Basic] boolTrue
     RCP[const Basic] boolFalse
     bool is_a_Relational(const Basic &b) nogil
-    RCP[const Boolean] Eq(const RCP[const Basic] &lhs) nogil
-    RCP[const Boolean] Eq(const RCP[const Basic] &lhs, const RCP[const Basic] &rhs) nogil
-    RCP[const Boolean] Ne(const RCP[const Basic] &lhs, const RCP[const Basic] &rhs) nogil
-    RCP[const Boolean] Ge(const RCP[const Basic] &lhs, const RCP[const Basic] &rhs) nogil
-    RCP[const Boolean] Gt(const RCP[const Basic] &lhs, const RCP[const Basic] &rhs) nogil
-    RCP[const Boolean] Le(const RCP[const Basic] &lhs, const RCP[const Basic] &rhs) nogil
-    RCP[const Boolean] Lt(const RCP[const Basic] &lhs, const RCP[const Basic] &rhs) 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+
 
 cdef extern from "<utility>" namespace "std":
     cdef integer_class std_move_mpz "std::move" (integer_class) nogil

symengine/lib/symengine_wrapper.pyx

@@ -60,7 +60,10 @@ cdef c2py(RCP[const symengine.Basic] o):
     elif (symengine.is_a_Min(deref(o))):
         r = Function.__new__(Min)
     elif (symengine.is_a_BooleanAtom(deref(o))):
-        r = BooleanAtom.__new__(BooleanAtom)
+        if (deref(symengine.rcp_static_cast_BooleanAtom(o)).get_val()):
+            r = BooleanAtom.__new__(BooleanTrue)
+        else:
+            r = BooleanAtom.__new__(BooleanFalse)
     elif (symengine.is_a_Equality(deref(o))):
         r = Equality.__new__(Equality)
     elif (symengine.is_a_Unequality(deref(o))):
@@ -188,9 +191,9 @@ def sympy2symengine(a, raise_error=False):
     elif a is sympy.nan:
         return nan
     elif a is sympy.S.true:
-        return BooleanTrue
+        return true
     elif a is sympy.S.false:
-        return BooleanFalse
+        return false
     elif isinstance(a, sympy.functions.elementary.trigonometric.TrigonometricFunction):
         if isinstance(a, sympy.sin):
             return sin(a.args[0])
@@ -342,7 +345,7 @@ def _sympify(a, raise_error=True):
     if isinstance(a, (Basic, MatrixBase)):
         return a
     elif isinstance(a, bool):
-        return (BooleanTrue if a else BooleanFalse)
+        return (true if a else false)
     elif isinstance(a, (int, long)):
         return Integer(a)
     elif isinstance(a, float):
@@ -866,19 +869,27 @@ class Boolean(Basic):
 
 
 class BooleanAtom(Boolean):
+    pass
+
+
+class BooleanTrue(BooleanAtom):
 
     def _sympy_(self):
         import sympy
-        if self == BooleanTrue:
-            return sympy.S.true
-        else:
-            return sympy.S.false
+        return sympy.S.true
 
     def _sage_(self):
-        if self == BooleanTrue:
-            return True
-        else:
-            return False
+        return True
+
+
+class BooleanFalse(BooleanAtom):
+
+    def _sympy_(self):
+        import sympy
+        return sympy.S.false
+
+    def _sage_(self):
+        return False
 
 
 class Relational(Boolean):
@@ -929,48 +940,6 @@ class Unequality(Relational):
 Ne = Unequality
 
 
-class GreaterThan(Relational):
-
-    def __new__(cls, *args):
-        return ge(*args)
-
-    def _sympy_(self):
-        import sympy
-        s = self.args_as_sympy()
-        return sympy.GreaterThan(*s)
-
-    def _sage_(self):
-        import sage.all as sage
-        s = self.args_as_sage()
-        return sage.ge(*s)
-
-    func = __class__
-
-
-Ge = GreaterThan
-
-
-class StrictGreaterThan(Relational):
-
-    def __new__(cls, *args):
-        return gt(*args)
-
-    def _sympy_(self):
-        import sympy
-        s = self.args_as_sympy()
-        return sympy.StrictGreaterThan(*s)
-
-    def _sage_(self):
-        import sage.all as sage
-        s = self.args_as_sage()
-        return sage.gt(*s)
-
-    func = __class__
-
-
-Gt = StrictGreaterThan
-
-
 class LessThan(Relational):
 
     def __new__(cls, *args):
@@ -2708,12 +2677,12 @@ pi = c2py(symengine.pi)
 oo = c2py(symengine.Inf)
 zoo = c2py(symengine.ComplexInf)
 nan = c2py(symengine.Nan)
-BooleanTrue = c2py(symengine.boolTrue)
-BooleanFalse = c2py(symengine.boolFalse)
+true = c2py(symengine.boolTrue)
+false = c2py(symengine.boolFalse)
 
 def module_cleanup():
-    global I, E, pi, oo, zoo, nan, BooleanTrue, BooleanFalse, sympy_module, sage_module
-    del I, E, pi, oo, zoo, nan, BooleanTrue, BooleanFalse, sympy_module, sage_module
+    global I, E, pi, oo, zoo, nan, true, false, sympy_module, sage_module
+    del I, E, pi, oo, zoo, nan, true, false, sympy_module, sage_module
 
 import atexit
 atexit.register(module_cleanup)
@@ -2781,11 +2750,15 @@ def ge(lhs, rhs):
     cdef Basic Y = sympify(rhs)
     return c2py(<RCP[const symengine.Basic]>(symengine.Ge(X.thisptr, Y.thisptr)))
 
+Ge = GreaterThan = ge
+
 def gt(lhs, rhs):
     cdef Basic X = sympify(lhs)
     cdef Basic Y = sympify(rhs)
     return c2py(<RCP[const symengine.Basic]>(symengine.Gt(X.thisptr, Y.thisptr)))
 
+Gt = StrictGreaterThan = gt
+
 def le(lhs, rhs):
     cdef Basic X = sympify(lhs)
     cdef Basic Y = sympify(rhs)

symengine/tests/CMakeLists.txt

@@ -18,5 +18,6 @@ install(FILES __init__.py
     test_var.py
     test_lambdify.py
     test_sympy_compat.py
+    test_logic.py
     DESTINATION ${PY_PATH}
     )

symengine/tests/test_logic.py

@@ -0,0 +1,24 @@
+from symengine.utilities import raises
+from symengine.lib.symengine_wrapper import (true, false, Eq, Ne,
+    Ge, Gt, Le, Lt, Symbol, I)
+
+x = Symbol("x")
+
+def test_relationals():
+    assert Eq(x, x) == true
+    assert Eq(0, 0) == true
+    assert Eq(1, 0) == false
+    assert Ne(0, 0) == false
+    assert Ne(1, 0) == true
+    assert Lt(0, 1) == true
+    assert Lt(1, 0) == false
+    assert Le(0, 1) == true
+    assert Le(1, 0) == false
+    assert Le(0, 0) == true
+    assert Gt(1, 0) == true
+    assert Gt(0, 1) == false
+    assert Ge(1, 0) == true
+    assert Ge(0, 1) == false
+    assert Ge(1, 1) == true
+    assert Eq(I, 2) == false
+    assert Ne(I, 2) == true

symengine/tests/test_sage.py

@@ -1,5 +1,6 @@
 from symengine import (Integer, symbols, sin, cos, pi, E, I, oo, zoo,
-    nan, Add, function_symbol, DenseMatrix, sympify, log)
+    nan, true, false, Add, function_symbol, DenseMatrix,
+    sympify, log)
 from symengine.lib.symengine_wrapper import (PyNumber, PyFunction,
     sage_module, wrap_sage_function)
 
@@ -68,13 +69,15 @@ def test_sage_conversions():
     # For the following test, sage needs to be modified
     # assert sage.sin(x) == sage.sin(x1)
 
-    # Constants
+    # Constants and Booleans
     assert pi._sage_() == sage.pi
     assert E._sage_() == sage.e
     assert I._sage_() == sage.I
     assert oo._sage_() == sage.oo
     assert zoo._sage_() == sage.unsigned_infinity
     assert nan._sage_() == sage.NaN
+    assert true._sage_() == True
+    assert false._sage_() == False
 
     assert pi == sympify(sage.pi)
     assert E == sympify(sage.e)

symengine/tests/test_sympify.py

@@ -1,6 +1,6 @@
 from symengine.utilities import raises
 
-from symengine import Symbol, Integer, sympify, SympifyError
+from symengine import Symbol, Integer, sympify, SympifyError, true, false
 from symengine.lib.symengine_wrapper import _sympify
 
 
@@ -10,6 +10,8 @@ def test_sympify1():
     assert sympify(-5) == Integer(-5)
     assert sympify(Integer(3)) == Integer(3)
     assert sympify("3+5") == Integer(8)
+    assert true == sympify(True)
+    assert false == sympify(False)
 
 
 def test_sympify_error1a():

symengine/tests/test_sympy_conv.py

@@ -1,8 +1,8 @@
 from symengine import (Symbol, Integer, sympify, SympifyError, log,
-        function_symbol, I, E, pi, oo, zoo, nan, exp, gamma, have_mpfr,
-        have_mpc, DenseMatrix, sin, cos, tan, cot, csc, sec, asin, acos,
-        atan, acot, acsc, asec, sinh, cosh, tanh, coth, asinh, acosh,
-        atanh, acoth, Add, Mul, Pow, diff)
+        function_symbol, I, E, pi, oo, zoo, nan, true, false,
+        exp, gamma, have_mpfr, have_mpc, DenseMatrix, sin, cos, tan, cot,
+        csc, sec, asin, acos, atan, acot, acsc, asec, sinh, cosh, tanh, coth,
+        asinh, acosh, atanh, acoth, Add, Mul, Pow, diff)
 from symengine.lib.symengine_wrapper import (Subs, Derivative, RealMPFR,
         ComplexMPC, PyNumber, Function)
 import sympy
@@ -380,6 +380,14 @@ def test_constants():
     assert sympy.nan == nan._sympy_()
 
 
+def test_booleans():
+    assert sympify(sympy.S.true) == true
+    assert sympy.S.true == true._sympy_()
+
+    assert sympify(sympy.S.false) == false
+    assert sympy.S.false == false._sympy_()
+
+
 def test_abs():
     x = Symbol("x")
     e1 = abs(sympy.Symbol("x"))