Wrapped Sign, Floor, Ceiling and Conjugate classes

Author: ShikharJ

symengine/functions.py

@@ -2,4 +2,9 @@
     asin, acos, atan, acot, acsc, asec,
     sinh, cosh, tanh, coth, sech, csch,
     asinh, acosh, atanh, acoth, asech, acsch,
-    gamma, log, atan2, sqrt, exp, Abs)
+    gamma, log, atan2, sqrt, exp, Abs,
+    LambertW, zeta, dirichlet_eta,
+    KroneckerDelta, LeviCivita, erf, erfc,
+    lowergamma, uppergamma, loggamma, beta,
+    polygamma, sign, floor, ceiling, 
+    conjugate, digamma, trigamma)

symengine/lib/symengine.pxd

@@ -287,6 +287,10 @@ cdef extern from "<symengine/basic.h>" namespace "SymEngine":
     bool is_a_Beta "SymEngine::is_a<SymEngine::Beta>"(const Basic &b) nogil
     bool is_a_PolyGamma "SymEngine::is_a<SymEngine::PolyGamma>"(const Basic &b) nogil
     bool is_a_PySymbol "SymEngine::is_a_sub<SymEngine::PySymbol>"(const Basic &b) nogil
+    bool is_a_Sign "SymEngine::is_a<SymEngine::Sign>"(const Basic &b) nogil
+    bool is_a_Floor "SymEngine::is_a<SymEngine::Floor>"(const Basic &b) nogil
+    bool is_a_Ceiling "SymEngine::is_a<SymEngine::Ceiling>"(const Basic &b) nogil
+    bool is_a_Conjugate "SymEngine::is_a<SymEngine::Conjugate>"(const Basic &b) nogil
 
     RCP[const Basic] expand(RCP[const Basic] &o) nogil except +
 
@@ -491,6 +495,10 @@ cdef extern from "<symengine/functions.h>" namespace "SymEngine":
     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 cppclass Function(Basic):
@@ -647,6 +655,17 @@ cdef extern from "<symengine/functions.h>" namespace "SymEngine":
     cdef cppclass PolyGamma(Function):
         pass
 
+    cdef cppclass Sign(OneArgFunction):
+        pass
+
+    cdef cppclass Floor(OneArgFunction):
+        pass
+
+    cdef cppclass Ceiling(OneArgFunction):
+        pass
+
+    cdef cppclass Conjugate(OneArgFunction):
+        pass
 
 IF HAVE_SYMENGINE_MPFR:
     cdef extern from "mpfr.h":

symengine/lib/symengine_wrapper.pyx

@@ -170,6 +170,14 @@ cdef c2py(RCP[const symengine.Basic] o):
         r = Function.__new__(beta)
     elif (symengine.is_a_PolyGamma(deref(o))):
         r = Function.__new__(polygamma)
+    elif (symengine.is_a_Sign(deref(o))):
+        r = Function.__new__(sign)
+    elif (symengine.is_a_Floor(deref(o))):
+        r = Function.__new__(floor)
+    elif (symengine.is_a_Ceiling(deref(o))):
+        r = Function.__new__(ceiling)
+    elif (symengine.is_a_Conjugate(deref(o))):
+        r = Function.__new__(conjugate)
     elif (symengine.is_a_PyNumber(deref(o))):
         r = PyNumber.__new__(PyNumber)
     else:
@@ -325,6 +333,14 @@ def sympy2symengine(a, raise_error=False):
         return beta(*a.args)
     elif isinstance(a, sympy.polygamma):
         return polygamma(*a.args)
+    elif isinstance(a, sympy.sign):
+        return sign(a.args[0])
+    elif isinstance(a, sympy.floor):
+        return floor(a.args[0])
+    elif isinstance(a, sympy.ceiling):
+        return ceiling(a.args[0])
+    elif isinstance(a, sympy.conjugate):
+        return conjugate(a.args[0])
     elif isinstance(a, sympy.gamma):
         return gamma(a.args[0])
     elif isinstance(a, sympy.Derivative):
@@ -1729,6 +1745,30 @@ class polygamma(Function):
         import sympy
         return sympy.polygamma(*self.args_as_sympy())
 
+class sign(OneArgFunction):
+    def __new__(cls, x):
+        cdef Basic X = sympify(x)
+        return c2py(symengine.sign(X.thisptr))
+
+class floor(OneArgFunction):
+    def __new__(cls, x):
+        cdef Basic X = sympify(x)
+        return c2py(symengine.floor(X.thisptr))
+
+class ceiling(OneArgFunction):
+    def __new__(cls, x):
+        cdef Basic X = sympify(x)
+        return c2py(symengine.ceiling(X.thisptr))
+
+    def _sage_(self):
+        import sage.all as sage
+        return sage.ceil(self.get_arg()._sage_())
+
+class conjugate(OneArgFunction):
+    def __new__(cls, x):
+        cdef Basic X = sympify(x)
+        return c2py(symengine.conjugate(X.thisptr))
+
 class log(OneArgFunction):
     def __new__(cls, x, y=None):
         cdef Basic X = sympify(x)

symengine/tests/test_functions.py

@@ -1,8 +1,10 @@
-from symengine import Symbol, sin, cos, sqrt, Add, Mul, function_symbol, Integer, log, E, symbols
+from symengine import (Symbol, sin, cos, sqrt, Add, Mul, function_symbol, Integer, log, E, symbols, I,
+                      Rational)
 from symengine.lib.symengine_wrapper import (Subs, Derivative, LambertW, zeta, dirichlet_eta,
                                             zoo, pi, KroneckerDelta, LeviCivita, erf, erfc,
                                             oo, lowergamma, uppergamma, exp, loggamma, beta,
-                                            polygamma, digamma, trigamma, EulerGamma)
+                                            polygamma, digamma, trigamma, EulerGamma, sign,
+                                            floor, ceiling, conjugate, nan, Float)
 
 
 def test_sin():
@@ -140,64 +142,230 @@ def test_log():
     assert log(x, x) == 1
     assert log(x, y) == log(x) / log(y)
 
+
 def test_lambertw():
     assert LambertW(0) == 0
     assert LambertW(E) == 1
+    assert LambertW(-1/E) == -1
+    assert LambertW(-log(2)/2) == -log(2)
+
 
 def test_zeta():
     x = Symbol("x")
     assert zeta(1) == zoo
     assert zeta(1, x) == zoo
 
+    assert zeta(0) == Rational(-1, 2)
+    assert zeta(0, x) == Rational(1, 2) - x
+
+    assert zeta(1, 2) == zoo
+    assert zeta(1, -7) == zoo
+
+    assert zeta(2, 1) == pi**2/6
+
+    assert zeta(2) == pi**2/6
+    assert zeta(4) == pi**4/90
+    assert zeta(6) == pi**6/945
+
+    assert zeta(2, 2) == pi**2/6 - 1
+    assert zeta(4, 3) == pi**4/90 - Rational(17, 16)
+    assert zeta(6, 4) == pi**6/945 - Rational(47449, 46656)
+
+    assert zeta(-1) == -Rational(1, 12)
+    assert zeta(-2) == 0
+    assert zeta(-3) == Rational(1, 120)
+    assert zeta(-4) == 0
+    assert zeta(-5) == -Rational(1, 252)
+
+    assert zeta(-1, 3) == -Rational(37, 12)
+    assert zeta(-1, 7) == -Rational(253, 12)
+    assert zeta(-1, -4) == Rational(119, 12)
+    assert zeta(-1, -9) == Rational(539, 12)
+
+    assert zeta(-4, 3) == -17
+    assert zeta(-4, -8) == 8772
+
+    assert zeta(0, 1) == -Rational(1, 2)
+    assert zeta(0, -1) == Rational(3, 2)
+
+    assert zeta(0, 2) == -Rational(3, 2)
+    assert zeta(0, -2) == Rational(5, 2)
+
+
 def test_dirichlet_eta():
+    assert dirichlet_eta(0) == Rational(1, 2)
+    assert dirichlet_eta(-1) == Rational(1, 4)
     assert dirichlet_eta(1) == log(2)
     assert dirichlet_eta(2) == pi**2/12
+    assert dirichlet_eta(4) == pi**4*Rational(7, 720)
+
 
 def test_kronecker_delta():
     x = Symbol("x")
+    y = Symbol("y")
     assert KroneckerDelta(1, 1) == 1
     assert KroneckerDelta(1, 2) == 0
     assert KroneckerDelta(x, x) == 1
+    assert KroneckerDelta(x**2 - y**2, x**2 - y**2) == 1
+    assert KroneckerDelta(0, 0) == 1
+    assert KroneckerDelta(0, 1) == 0
+
 
 def test_levi_civita():
+    i = Symbol("i")
+    j = Symbol("j")
     assert LeviCivita(1, 2, 3) == 1
     assert LeviCivita(1, 3, 2) == -1
     assert LeviCivita(1, 2, 2) == 0
+    assert LeviCivita(i, j, i) == 0
+    assert LeviCivita(1, i, i) == 0
+    assert LeviCivita(1, 2, 3, 1) == 0
+    assert LeviCivita(4, 5, 1, 2, 3) == 1
+    assert LeviCivita(4, 5, 2, 1, 3) == -1
+
 
 def test_erf():
-    assert erf(0) == 0
+    x = Symbol("x")
+    y = Symbol("y")
+    assert erf(nan) == nan
     assert erf(oo) == 1
+    assert erf(-oo) == -1
+    assert erf(0) == 0
+    assert erf(-2) == -erf(2)
+    assert erf(-x*y) == -erf(x*y)
+    assert erf(-x - y) == -erf(x + y)
+
 
 def test_erfc():
-    assert erfc(0) == 1
+    assert erfc(nan) == nan
     assert erfc(oo) == 0
+    assert erfc(-oo) == 2
+    assert erfc(0) == 1
+
 
 def test_lowergamma():
     assert lowergamma(1, 2) == 1 - exp(-2)
 
+
 def test_uppergamma():
     assert uppergamma(1, 2) == exp(-2)
     assert uppergamma(4, 0) == 6
 
+
 def test_loggamma():
     assert loggamma(-1) == oo
+    assert loggamma(-2) == oo
     assert loggamma(0) == oo
     assert loggamma(1) == 0
+    assert loggamma(2) == 0
     assert loggamma(3) == log(2)
 
+
 def test_beta():
     assert beta(3, 2) == beta(2, 3)
 
+
 def test_polygamma():
+    assert polygamma(0, -9) == zoo
+    assert polygamma(0, -9) == zoo
+    assert polygamma(0, -1) == zoo
     assert polygamma(0, 0) == zoo
+    assert polygamma(0, 1) == -EulerGamma
+    assert polygamma(0, 7) == Rational(49, 20) - EulerGamma
+    assert polygamma(1, 1) == pi**2/6
+    assert polygamma(1, 2) == pi**2/6 - 1
+    assert polygamma(1, 3) == pi**2/6 - Rational(5, 4)
+    assert polygamma(3, 1) == pi**4 / 15
+    assert polygamma(3, 5) == 6*(Rational(-22369, 20736) + pi**4/90)
+    assert polygamma(5, 1) == 8 * pi**6 / 63
+
 
 def test_digamma():
     x = Symbol("x")
     assert digamma(x) == polygamma(0, x)
     assert digamma(0) == zoo
     assert digamma(1) == -EulerGamma
 
+
 def test_trigamma():
     x = Symbol("x")
     assert trigamma(-2) == zoo
     assert trigamma(x) == polygamma(1, x)
+
+
+def test_sign():
+    assert sign(1.2) == 1
+    assert sign(-1.2) == -1
+    assert sign(3*I) == I
+    assert sign(-3*I) == -I
+    assert sign(0) == 0
+    assert sign(nan) == nan
+
+
+def test_floor():
+    x = Symbol("x")
+    y = Symbol("y")
+    assert floor(nan) == nan
+    assert floor(oo) == oo
+    assert floor(-oo) == -oo
+    assert floor(0) == 0
+    assert floor(1) == 1
+    assert floor(-1) == -1
+    assert floor(E) == 2
+    assert floor(pi) == 3
+    assert floor(Rational(1, 2)) == 0
+    assert floor(-Rational(1, 2)) == -1
+    assert floor(Rational(7, 3)) == 2
+    assert floor(-Rational(7, 3)) == -3
+    assert floor(Float(17.0)) == 17
+    assert floor(-Float(17.0)) == -17
+    assert floor(Float(7.69)) == 7
+    assert floor(-Float(7.69)) == -8
+    assert floor(I) == I
+    assert floor(-I) == -I
+    assert floor(2*I) == 2*I
+    assert floor(-2*I) == -2*I
+    assert floor(E + pi) == floor(E + pi)
+    assert floor(I + pi) == floor(I + pi)
+    assert floor(floor(pi)) == 3
+    assert floor(floor(y)) == floor(y)
+    assert floor(floor(x)) == floor(floor(x))
+    assert floor(x) == floor(x)
+    assert floor(2*x) == floor(2*x)
+
+
+def test_ceiling():
+    x = Symbol("x")
+    y = Symbol("y")
+    assert ceiling(nan) == nan
+    assert ceiling(oo) == oo
+    assert ceiling(-oo) == -oo
+    assert ceiling(0) == 0
+    assert ceiling(1) == 1
+    assert ceiling(-1) == -1
+    assert ceiling(E) == 3
+    assert ceiling(pi) == 4
+    assert ceiling(Rational(1, 2)) == 1
+    assert ceiling(-Rational(1, 2)) == 0
+    assert ceiling(Rational(7, 3)) == 3
+    assert ceiling(-Rational(7, 3)) == -2
+    assert ceiling(Float(17.0)) == 17
+    assert ceiling(-Float(17.0)) == -17
+    assert ceiling(Float(7.69)) == 8
+    assert ceiling(-Float(7.69)) == -7
+    assert ceiling(I) == I
+    assert ceiling(-I) == -I
+    assert ceiling(2*I) == 2*I
+    assert ceiling(-2*I) == -2*I
+    assert ceiling(E + pi) == ceiling(E + pi)
+    assert ceiling(I + pi) == ceiling(I + pi)
+    assert ceiling(ceiling(pi)) == 4
+    assert ceiling(ceiling(y)) == ceiling(y)
+    assert ceiling(ceiling(x)) == ceiling(ceiling(x))
+    assert ceiling(x) == ceiling(x)
+    assert ceiling(2*x) == ceiling(2*x)
+
+
+def test_conjugate():
+    assert conjugate(pi) == pi
+    assert conjugate(I) == -I

symengine/tests/test_sage.py

@@ -3,8 +3,8 @@
     sympify, log)
 from symengine.lib.symengine_wrapper import (PyNumber, PyFunction,
     sage_module, wrap_sage_function, Catalan, GoldenRatio, EulerGamma,
-    LambertW, KroneckerDelta, erf, lowergamma,
-    uppergamma, loggamma, beta)
+    LambertW, KroneckerDelta, erf, lowergamma, uppergamma, loggamma,
+    beta, floor, ceiling, conjugate)
 
 
 def test_sage_conversions():
@@ -89,6 +89,15 @@ def test_sage_conversions():
     assert beta(x1, y1) == beta(x, y)
     assert beta(x1, y1)._sage_() == sage.beta(x, y)
 
+    assert floor(x1) == floor(x)
+    assert floor(x1)._sage_() == sage.floor(x)
+
+    assert ceiling(x1) == ceiling(x)
+    assert ceiling(x1)._sage_() == sage.ceil(x)
+
+    assert conjugate(x1) == conjugate(x)
+    assert conjugate(x1)._sage_() == sage.conjugate(x)
+
     # For the following test, sage needs to be modified
     # assert sage.sin(x) == sage.sin(x1)