Wrapped sech, csch, asech and acsch functions

Author: ShikharJ

symengine/lib/symengine.pxd

@@ -241,10 +241,14 @@ cdef extern from "<symengine/basic.h>" namespace "SymEngine":
     bool is_a_Cosh "SymEngine::is_a<SymEngine::Cosh>"(const Basic &b) nogil
     bool is_a_Tanh "SymEngine::is_a<SymEngine::Tanh>"(const Basic &b) nogil
     bool is_a_Coth "SymEngine::is_a<SymEngine::Coth>"(const Basic &b) nogil
+    bool is_a_Csch "SymEngine::is_a<SymEngine::Csch>"(const Basic &b) nogil
+    bool is_a_Sech "SymEngine::is_a<SymEngine::Sech>"(const Basic &b) nogil
     bool is_a_ASinh "SymEngine::is_a<SymEngine::ASinh>"(const Basic &b) nogil
     bool is_a_ACosh "SymEngine::is_a<SymEngine::ACosh>"(const Basic &b) nogil
     bool is_a_ATanh "SymEngine::is_a<SymEngine::ATanh>"(const Basic &b) nogil
     bool is_a_ACoth "SymEngine::is_a<SymEngine::ACoth>"(const Basic &b) nogil
+    bool is_a_ACsch "SymEngine::is_a<SymEngine::ACsch>"(const Basic &b) nogil
+    bool is_a_ASech "SymEngine::is_a<SymEngine::ASech>"(const Basic &b) nogil
     bool is_a_FunctionSymbol "SymEngine::is_a<SymEngine::FunctionSymbol>"(const Basic &b) nogil
     bool is_a_Abs "SymEngine::is_a<SymEngine::Abs>"(const Basic &b) nogil
     bool is_a_Gamma "SymEngine::is_a<SymEngine::Gamma>"(const Basic &b) nogil
@@ -419,10 +423,14 @@ cdef extern from "<symengine/functions.h>" namespace "SymEngine":
     cdef RCP[const Basic] cosh(RCP[const Basic] &arg) nogil except+
     cdef RCP[const Basic] tanh(RCP[const Basic] &arg) nogil except+
     cdef RCP[const Basic] coth(RCP[const Basic] &arg) nogil except+
+    cdef RCP[const Basic] csch(RCP[const Basic] &arg) nogil except+
+    cdef RCP[const Basic] sech(RCP[const Basic] &arg) nogil except+
     cdef RCP[const Basic] asinh(RCP[const Basic] &arg) nogil except+
     cdef RCP[const Basic] acosh(RCP[const Basic] &arg) nogil except+
     cdef RCP[const Basic] atanh(RCP[const Basic] &arg) nogil except+
     cdef RCP[const Basic] acoth(RCP[const Basic] &arg) nogil except+
+    cdef RCP[const Basic] acsch(RCP[const Basic] &arg) nogil except+
+    cdef RCP[const Basic] asech(RCP[const Basic] &arg) nogil except+
     cdef RCP[const Basic] function_symbol(string name, const vec_basic &arg) nogil except+
     cdef RCP[const Basic] abs(RCP[const Basic] &arg) nogil except+
     cdef RCP[const Basic] gamma(RCP[const Basic] &arg) nogil except+
@@ -485,6 +493,12 @@ cdef extern from "<symengine/functions.h>" namespace "SymEngine":
     cdef cppclass Coth(HyperbolicFunction):
         pass
 
+    cdef cppclass Csch(HyperbolicFunction):
+        pass
+
+    cdef cppclass Sech(HyperbolicFunction):
+        pass
+
     cdef cppclass ASinh(HyperbolicFunction):
         pass
 
@@ -497,6 +511,12 @@ cdef extern from "<symengine/functions.h>" namespace "SymEngine":
     cdef cppclass ACoth(HyperbolicFunction):
         pass
 
+    cdef cppclass ACsch(HyperbolicFunction):
+        pass
+
+    cdef cppclass ASech(HyperbolicFunction):
+        pass
+
     cdef cppclass FunctionSymbol(Function):
         string get_name() nogil
 

symengine/lib/symengine_wrapper.pxd

@@ -97,6 +97,12 @@ cdef class Tanh(HyperbolicFunction):
 cdef class Coth(HyperbolicFunction):
     pass
 
+cdef class Csch(HyperbolicFunction):
+    pass
+
+cdef class Sech(HyperbolicFunction):
+    pass
+
 cdef class ASinh(HyperbolicFunction):
     pass
 
@@ -109,6 +115,12 @@ cdef class ATanh(HyperbolicFunction):
 cdef class ACoth(HyperbolicFunction):
     pass
 
+cdef class ACsch(HyperbolicFunction):
+    pass
+
+cdef class ASech(HyperbolicFunction):
+    pass
+
 cdef class FunctionSymbol(Function):
     pass
 

symengine/lib/symengine_wrapper.pyx

@@ -93,6 +93,10 @@ cdef c2py(RCP[const symengine.Basic] o):
         r = Tanh.__new__(Tanh)
     elif (symengine.is_a_Coth(deref(o))):
         r = Coth.__new__(Coth)
+    elif (symengine.is_a_Csch(deref(o))):
+        r = Csch.__new__(Csch)
+    elif (symengine.is_a_Sech(deref(o))):
+        r = Sech.__new__(Sech)
     elif (symengine.is_a_ASinh(deref(o))):
         r = ASinh.__new__(ASinh)
     elif (symengine.is_a_ACosh(deref(o))):
@@ -101,6 +105,10 @@ cdef c2py(RCP[const symengine.Basic] o):
         r = ATanh.__new__(ATanh)
     elif (symengine.is_a_ACoth(deref(o))):
         r = ACoth.__new__(ACoth)
+    elif (symengine.is_a_ACsch(deref(o))):
+        r = ACsch.__new__(ACsch)
+    elif (symengine.is_a_ASech(deref(o))):
+        r = ASech.__new__(ASech)
     elif (symengine.is_a_ATan2(deref(o))):
         r = ATan2.__new__(ATan2)
     elif (symengine.is_a_PyNumber(deref(o))):
@@ -184,6 +192,10 @@ def sympy2symengine(a, raise_error=False):
             return tanh(a.args[0])
         elif isinstance(a, sympy.coth):
             return coth(a.args[0])
+        elif isinstance(a, sympy.csch):
+            return csch(a.args[0])
+        elif isinstance(a, sympy.sech):
+            return sech(a.args[0])
     elif isinstance(a, sympy.asinh):
         return asinh(a.args[0])
     elif isinstance(a, sympy.acosh):
@@ -192,6 +204,10 @@ def sympy2symengine(a, raise_error=False):
         return atanh(a.args[0])
     elif isinstance(a, sympy.acoth):
         return acoth(a.args[0])
+    elif isinstance(a, sympy.acsch):
+        return acsch(a.args[0])
+    elif isinstance(a, sympy.asech):
+        return asech(a.args[0])
     elif isinstance(a, sympy.log):
         return log(a.args[0])
     elif isinstance(a, sympy.Abs):
@@ -2207,6 +2223,14 @@ def coth(x):
     cdef Basic X = sympify(x)
     return c2py(symengine.coth(X.thisptr))
 
+def sech(x):
+    cdef Basic X = sympify(x)
+    return c2py(symengine.sech(X.thisptr))
+
+def csch(x):
+    cdef Basic X = sympify(x)
+    return c2py(symengine.csch(X.thisptr))
+
 def asinh(x):
     cdef Basic X = sympify(x)
     return c2py(symengine.asinh(X.thisptr))
@@ -2223,6 +2247,14 @@ def acoth(x):
     cdef Basic X = sympify(x)
     return c2py(symengine.acoth(X.thisptr))
 
+def asech(x):
+    cdef Basic X = sympify(x)
+    return c2py(symengine.asech(X.thisptr))
+
+def acsch(x):
+    cdef Basic X = sympify(x)
+    return c2py(symengine.acsch(X.thisptr))
+
 def function_symbol(name, *args):
     cdef symengine.vec_basic v
     cdef Basic e_

symengine/sympy_compat.py

@@ -216,6 +216,19 @@ class coth(_RegisteredFunction):
     def __new__(cls, a):
         return symengine.coth(a)
 
+class csch(_RegisteredFunction):
+    _classes = (symengine.Csch,)
+
+    def __new__(cls, a):
+        return symengine.csch(a)
+
+
+class sech(_RegisteredFunction):
+    _classes = (symengine.Sech,)
+
+    def __new__(cls, a):
+        return symengine.sech(a)
+
 
 class asinh(_RegisteredFunction):
     _classes = (symengine.ASinh,)
@@ -244,6 +257,18 @@ class acoth(_RegisteredFunction):
     def __new__(cls, a):
         return symengine.acoth(a)
 
+class acsch(_RegisteredFunction):
+    _classes = (symengine.ACsch,)
+
+    def __new__(cls, a):
+        return symengine.acsch(a)
+
+
+class asech(_RegisteredFunction):
+    _classes = (symengine.ASech,)
+
+    def __new__(cls, a):
+        return symengine.asech(a)
 
 class atan2(_RegisteredFunction):
     _classes = (symengine.ATan2,)