From a415b27ac875a2b376d2b7c1ac176d8a299b0d20 Mon Sep 17 00:00:00 2001 From: Shikhar Jaiswal Date: Fri, 16 Jun 2017 22:07:48 +0530 Subject: [PATCH] Added tests --- symengine/__init__.py | 4 +- symengine/lib/symengine.pxd | 18 +++--- symengine/lib/symengine_wrapper.pyx | 89 ++++++++++------------------- symengine/tests/CMakeLists.txt | 1 + symengine/tests/test_logic.py | 24 ++++++++ symengine/tests/test_sage.py | 7 ++- symengine/tests/test_sympify.py | 4 +- symengine/tests/test_sympy_conv.py | 16 ++++-- 8 files changed, 88 insertions(+), 75 deletions(-) create mode 100644 symengine/tests/test_logic.py diff --git a/symengine/__init__.py b/symengine/__init__.py index ca0a82d05..18bc04e9a 100644 --- a/symengine/__init__.py +++ b/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 * diff --git a/symengine/lib/symengine.pxd b/symengine/lib/symengine.pxd index 880768604..d45f36a86 100644 --- a/symengine/lib/symengine.pxd +++ b/symengine/lib/symengine.pxd @@ -153,7 +153,7 @@ cdef extern from "" namespace "SymEngine": RCP[const RealMPFR] rcp_static_cast_RealMPFR "SymEngine::rcp_static_cast"(RCP[const Basic] &b) nogil RCP[const ComplexMPC] rcp_static_cast_ComplexMPC "SymEngine::rcp_static_cast"(RCP[const Basic] &b) nogil RCP[const Log] rcp_static_cast_Log "SymEngine::rcp_static_cast"(RCP[const Basic] &b) nogil - RCP[const Boolean] rcp_static_cast_Boolean "SymEngine::rcp_static_cast"(RCP[const Basic] &b) nogil + RCP[const BooleanAtom] rcp_static_cast_BooleanAtom "SymEngine::rcp_static_cast"(RCP[const Basic] &b) nogil RCP[const PyNumber] rcp_static_cast_PyNumber "SymEngine::rcp_static_cast"(RCP[const Basic] &b) nogil RCP[const PyFunction] rcp_static_cast_PyFunction "SymEngine::rcp_static_cast"(RCP[const Basic] &b) nogil Ptr[RCP[Basic]] outArg(RCP[const Basic] &arg) nogil @@ -766,7 +766,7 @@ cdef extern from "" 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 "" 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 "" namespace "std": cdef integer_class std_move_mpz "std::move" (integer_class) nogil diff --git a/symengine/lib/symengine_wrapper.pyx b/symengine/lib/symengine_wrapper.pyx index 981edad97..ced66a750 100644 --- a/symengine/lib/symengine_wrapper.pyx +++ b/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((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((symengine.Gt(X.thisptr, Y.thisptr))) +Gt = StrictGreaterThan = gt + def le(lhs, rhs): cdef Basic X = sympify(lhs) cdef Basic Y = sympify(rhs) diff --git a/symengine/tests/CMakeLists.txt b/symengine/tests/CMakeLists.txt index 043643b0b..6152cbba5 100644 --- a/symengine/tests/CMakeLists.txt +++ b/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} ) diff --git a/symengine/tests/test_logic.py b/symengine/tests/test_logic.py new file mode 100644 index 000000000..4ec0c5c1c --- /dev/null +++ b/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 diff --git a/symengine/tests/test_sage.py b/symengine/tests/test_sage.py index c5a903b3f..2f6977252 100644 --- a/symengine/tests/test_sage.py +++ b/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) diff --git a/symengine/tests/test_sympify.py b/symengine/tests/test_sympify.py index d330aa296..09f5c8e90 100644 --- a/symengine/tests/test_sympify.py +++ b/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(): diff --git a/symengine/tests/test_sympy_conv.py b/symengine/tests/test_sympy_conv.py index f835f2cb2..b46a4e5b3 100644 --- a/symengine/tests/test_sympy_conv.py +++ b/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"))