Wrapped specific functions and constants

Author: ShikharJ

symengine/__init__.py

@@ -9,7 +9,7 @@
         UndefFunction, Function, FunctionSymbol as AppliedUndef,
         have_numpy, true, false, Equality, Unequality, GreaterThan,
         LessThan, StrictGreaterThan, StrictLessThan, Eq, Ne, Ge, Le,
-        Gt, Lt)
+        Gt, Lt, GoldenRatio, Catalan, EulerGamma)
 from .utilities import var, symbols
 from .functions import *
 

symengine/lib/symengine.pxd

@@ -274,6 +274,18 @@ cdef extern from "<symengine/basic.h>" namespace "SymEngine":
     bool is_a_StrictLessThan "SymEngine::is_a<SymEngine::StrictLessThan>"(const Basic &b) nogil
     bool is_a_PyNumber "SymEngine::is_a<SymEngine::PyNumber>"(const Basic &b) nogil
     bool is_a_ATan2 "SymEngine::is_a<SymEngine::ATan2>"(const Basic &b) nogil
+    bool is_a_LambertW "SymEngine::is_a<SymEngine::LambertW>"(const Basic &b) nogil
+    bool is_a_Zeta "SymEngine::is_a<SymEngine::Zeta>"(const Basic &b) nogil
+    bool is_a_DirichletEta "SymEngine::is_a<SymEngine::Dirichlet_eta>"(const Basic &b) nogil
+    bool is_a_KroneckerDelta "SymEngine::is_a<SymEngine::KroneckerDelta>"(const Basic &b) nogil
+    bool is_a_LeviCivita "SymEngine::is_a<SymEngine::LeviCivita>"(const Basic &b) nogil
+    bool is_a_Erf "SymEngine::is_a<SymEngine::Erf>"(const Basic &b) nogil
+    bool is_a_Erfc "SymEngine::is_a<SymEngine::Erfc>"(const Basic &b) nogil
+    bool is_a_LowerGamma "SymEngine::is_a<SymEngine::LowerGamma>"(const Basic &b) nogil
+    bool is_a_UpperGamma "SymEngine::is_a<SymEngine::UpperGamma>"(const Basic &b) nogil
+    bool is_a_LogGamma "SymEngine::is_a<SymEngine::LogGamma>"(const Basic &b) nogil
+    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
 
     RCP[const Basic] expand(RCP[const Basic] &o) nogil except +
@@ -357,6 +369,9 @@ cdef extern from "<symengine/constants.h>" namespace "SymEngine":
     RCP[const Basic] I
     RCP[const Basic] E
     RCP[const Basic] pi
+    RCP[const Basic] GoldenRatio
+    RCP[const Basic] Catalan
+    RCP[const Basic] EulerGamma
     RCP[const Basic] Inf
     RCP[const Basic] ComplexInf
     RCP[const Basic] Nan
@@ -461,6 +476,22 @@ cdef extern from "<symengine/functions.h>" namespace "SymEngine":
     cdef RCP[const Basic] min(const vec_basic &arg) nogil except+
     cdef RCP[const Basic] gamma(RCP[const Basic] &arg) nogil except+
     cdef RCP[const Basic] atan2(RCP[const Basic] &num, RCP[const Basic] &den) nogil except+
+    cdef RCP[const Basic] lambertw(RCP[const Basic] &arg) nogil except+
+    cdef RCP[const Basic] zeta(RCP[const Basic] &s) nogil except+
+    cdef RCP[const Basic] zeta(RCP[const Basic] &s, RCP[const Basic] &a) nogil except+
+    cdef RCP[const Basic] dirichlet_eta(RCP[const Basic] &s) nogil except+
+    cdef RCP[const Basic] kronecker_delta(RCP[const Basic] &i, RCP[const Basic] &j) nogil except+
+    cdef RCP[const Basic] levi_civita(const vec_basic &arg) nogil except+
+    cdef RCP[const Basic] erf(RCP[const Basic] &arg) nogil except+
+    cdef RCP[const Basic] erfc(RCP[const Basic] &arg) nogil except+
+    cdef RCP[const Basic] lowergamma(RCP[const Basic] &s, RCP[const Basic] &x) nogil except+
+    cdef RCP[const Basic] uppergamma(RCP[const Basic] &s, RCP[const Basic] &x) nogil except+
+    cdef RCP[const Basic] loggamma(RCP[const Basic] &arg) nogil except+
+    cdef RCP[const Basic] beta(RCP[const Basic] &x, RCP[const Basic] &y) nogil except+
+    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 cppclass Function(Basic):
         pass
@@ -580,6 +611,43 @@ cdef extern from "<symengine/functions.h>" namespace "SymEngine":
     cdef cppclass ATan2(Function):
         pass
 
+    cdef cppclass LambertW(OneArgFunction):
+        pass
+
+    cdef cppclass Zeta(Function):
+        pass
+
+    cdef cppclass Dirichlet_eta(OneArgFunction):
+        pass
+
+    cdef cppclass KroneckerDelta(Function):
+        pass
+
+    cdef cppclass LeviCivita(Function):
+        pass
+
+    cdef cppclass Erf(OneArgFunction):
+        pass
+
+    cdef cppclass Erfc(OneArgFunction):
+        pass
+
+    cdef cppclass LowerGamma(Function):
+        pass
+
+    cdef cppclass UpperGamma(Function):
+        pass
+
+    cdef cppclass LogGamma(OneArgFunction):
+        pass
+
+    cdef cppclass Beta(Function):
+        pass
+
+    cdef cppclass PolyGamma(Function):
+        pass
+
+
 IF HAVE_SYMENGINE_MPFR:
     cdef extern from "mpfr.h":
         ctypedef struct __mpfr_struct:

symengine/lib/symengine_wrapper.pyx

@@ -146,6 +146,30 @@ cdef c2py(RCP[const symengine.Basic] o):
         r = Function.__new__(ASech)
     elif (symengine.is_a_ATan2(deref(o))):
         r = Function.__new__(ATan2)
+    elif (symengine.is_a_LambertW(deref(o))):
+        r = Function.__new__(LambertW)
+    elif (symengine.is_a_Zeta(deref(o))):
+        r = Function.__new__(zeta)
+    elif (symengine.is_a_DirichletEta(deref(o))):
+        r = Function.__new__(dirichlet_eta)
+    elif (symengine.is_a_KroneckerDelta(deref(o))):
+        r = Function.__new__(KroneckerDelta)
+    elif (symengine.is_a_LeviCivita(deref(o))):
+        r = Function.__new__(LeviCivita)
+    elif (symengine.is_a_Erf(deref(o))):
+        r = Function.__new__(erf)
+    elif (symengine.is_a_Erfc(deref(o))):
+        r = Function.__new__(erfc)
+    elif (symengine.is_a_LowerGamma(deref(o))):
+        r = Function.__new__(lowergamma)
+    elif (symengine.is_a_UpperGamma(deref(o))):
+        r = Function.__new__(uppergamma)
+    elif (symengine.is_a_LogGamma(deref(o))):
+        r = Function.__new__(loggamma)
+    elif (symengine.is_a_Beta(deref(o))):
+        r = Function.__new__(beta)
+    elif (symengine.is_a_PolyGamma(deref(o))):
+        r = Function.__new__(polygamma)
     elif (symengine.is_a_PyNumber(deref(o))):
         r = PyNumber.__new__(PyNumber)
     else:
@@ -190,6 +214,12 @@ def sympy2symengine(a, raise_error=False):
         return E
     elif a is sympy.pi:
         return pi
+    elif a is sympy.GoldenRatio:
+        return GoldenRatio
+    elif a is sympy.Catalan:
+        return Catalan
+    elif a is sympy.EulerGamma:
+        return EulerGamma
     elif a is sympy.S.NegativeInfinity:
         return -oo
     elif a is sympy.S.Infinity:
@@ -271,6 +301,30 @@ def sympy2symengine(a, raise_error=False):
         return le(*a.args)
     elif isinstance(a, sympy.StrictLessThan):
         return lt(*a.args)
+    elif isinstance(a, sympy.LambertW):
+        return LambertW(a.args[0])
+    elif isinstance(a, sympy.zeta):
+        return zeta(*a.args)
+    elif isinstance(a, sympy.dirichlet_eta):
+        return dirichlet_eta(a.args[0])
+    elif isinstance(a, sympy.KroneckerDelta):
+        return KroneckerDelta(*a.args)
+    elif isinstance(a, sympy.LeviCivita):
+        return LeviCivita(*a.args)
+    elif isinstance(a, sympy.erf):
+        return erf(a.args[0])
+    elif isinstance(a, sympy.erfc):
+        return erfc(a.args[0])
+    elif isinstance(a, sympy.lowergamma):
+        return lowergamma(*a.args)
+    elif isinstance(a, sympy.uppergamma):
+        return uppergamma(*a.args)
+    elif isinstance(a, sympy.loggamma):
+        return loggamma(a.args[0])
+    elif isinstance(a, sympy.beta):
+        return beta(*a.args)
+    elif isinstance(a, sympy.polygamma):
+        return polygamma(*a.args)
     elif isinstance(a, sympy.gamma):
         return gamma(a.args[0])
     elif isinstance(a, sympy.Derivative):
@@ -860,6 +914,12 @@ cdef class Constant(Basic):
             return sympy.E
         elif self == pi:
             return sympy.pi
+        elif self == GoldenRatio:
+            return sympy.GoldenRatio
+        elif self == Catalan:
+            return sympy.Catalan
+        elif self == EulerGamma:
+            return sympy.EulerGamma
         else:
             raise Exception("Unknown Constant")
 
@@ -869,6 +929,12 @@ cdef class Constant(Basic):
             return sage.e
         elif self == pi:
             return sage.pi
+        elif self == GoldenRatio:
+            return sage.golden_ratio
+        elif self == Catalan:
+            return sage.catalan
+        elif self == EulerGamma:
+            return sage.euler_gamma
         else:
             raise Exception("Unknown Constant")
 
@@ -1521,7 +1587,7 @@ class OneArgFunction(Function):
 
     def _sympy_(self):
         import sympy
-        return getattr(sympy, self.__class__.__name__.lower())(self.get_arg()._sympy_())
+        return getattr(sympy, self.__class__.__name__)(self.get_arg()._sympy_())
 
     def _sage_(self):
         import sage.all as sage
@@ -1539,6 +1605,130 @@ class gamma(OneArgFunction):
         cdef Basic X = sympify(x)
         return c2py(symengine.gamma(X.thisptr))
 
+class LambertW(OneArgFunction):
+    def __new__(cls, x):
+        cdef Basic X = sympify(x)
+        return c2py(symengine.lambertw(X.thisptr))
+
+    def _sage_(self):
+        import sage.all as sage
+        return sage.lambert_w(self.get_arg()._sage_())
+
+class zeta(Function):
+    def __new__(cls, s, a = None):
+        cdef Basic S = sympify(s)
+        if a == None:
+            return c2py(symengine.zeta(S.thisptr))
+        cdef Basic A = sympify(a)
+        return c2py(symengine.zeta(S.thisptr, A.thisptr))
+
+    def _sympy_(self):
+        import sympy
+        return sympy.zeta(*self.args_as_sympy())
+
+class dirichlet_eta(OneArgFunction):
+    def __new__(cls, x):
+        cdef Basic X = sympify(x)
+        return c2py(symengine.dirichlet_eta(X.thisptr))
+
+class KroneckerDelta(Function):
+    def __new__(cls, x, y):
+        cdef Basic X = sympify(x)
+        cdef Basic Y = sympify(y)
+        return c2py(symengine.kronecker_delta(X.thisptr, Y.thisptr))
+
+    def _sympy_(self):
+        import sympy
+        return sympy.KroneckerDelta(*self.args_as_sympy())
+
+    def _sage_(self):
+        import sage.all as sage
+        return sage.kronecker_delta(*self.args_as_sage())
+
+class LeviCivita(Function):
+    def __new__(cls, *args):
+        cdef symengine.vec_basic v
+        cdef Basic e_
+        for e in args:
+            e_ = sympify(e)
+            v.push_back(e_.thisptr)
+        return c2py(symengine.levi_civita(v))
+
+    def _sympy_(self):
+        import sympy
+        return sympy.LeviCivita(*self.args_as_sympy())
+
+class erf(OneArgFunction):
+    def __new__(cls, x):
+        cdef Basic X = sympify(x)
+        return c2py(symengine.erf(X.thisptr))
+
+class erfc(OneArgFunction):
+    def __new__(cls, x):
+        cdef Basic X = sympify(x)
+        return c2py(symengine.erfc(X.thisptr))
+
+class lowergamma(Function):
+    def __new__(cls, x, y):
+        cdef Basic X = sympify(x)
+        cdef Basic Y = sympify(y)
+        return c2py(symengine.lowergamma(X.thisptr, Y.thisptr))
+
+    def _sympy_(self):
+        import sympy
+        return sympy.lowergamma(*self.args_as_sympy())
+
+    def _sage_(self):
+        import sage.all as sage
+        return sage.gamma_inc_lower(*self.args_as_sage())
+
+class uppergamma(Function):
+    def __new__(cls, x, y):
+        cdef Basic X = sympify(x)
+        cdef Basic Y = sympify(y)
+        return c2py(symengine.uppergamma(X.thisptr, Y.thisptr))
+
+    def _sympy_(self):
+        import sympy
+        return sympy.uppergamma(*self.args_as_sympy())
+
+    def _sage_(self):
+        import sage.all as sage
+        return sage.gamma_inc(*self.args_as_sage())
+
+class loggamma(OneArgFunction):
+    def __new__(cls, x):
+        cdef Basic X = sympify(x)
+        return c2py(symengine.loggamma(X.thisptr))
+
+    def _sage_(self):
+        import sage.all as sage
+        return sage.log_gamma(self.get_arg()._sage_())
+
+class beta(Function):
+    def __new__(cls, x, y):
+        cdef Basic X = sympify(x)
+        cdef Basic Y = sympify(y)
+        return c2py(symengine.beta(X.thisptr, Y.thisptr))
+
+    def _sympy_(self):
+        import sympy
+        return sympy.beta(*self.args_as_sympy())
+
+    def _sage_(self):
+        import sage.all as sage
+        return sage.beta(*self.args_as_sage())
+
+class polygamma(Function):
+    def __new__(cls, x, y):
+        cdef Basic X = sympify(x)
+        cdef Basic Y = sympify(y)
+        return c2py(symengine.polygamma(X.thisptr, Y.thisptr))
+
+    def _sympy_(self):
+        import sympy
+        return sympy.polygamma(*self.args_as_sympy())
+
 class log(OneArgFunction):
     def __new__(cls, x, y=None):
         cdef Basic X = sympify(x)
@@ -2701,15 +2891,18 @@ cdef class Sieve_iterator:
 I = c2py(symengine.I)
 E = c2py(symengine.E)
 pi = c2py(symengine.pi)
+GoldenRatio = c2py(symengine.GoldenRatio)
+Catalan = c2py(symengine.Catalan)
+EulerGamma = c2py(symengine.EulerGamma)
 oo = c2py(symengine.Inf)
 zoo = c2py(symengine.ComplexInf)
 nan = c2py(symengine.Nan)
 true = c2py(symengine.boolTrue)
 false = c2py(symengine.boolFalse)
 
 def module_cleanup():
-    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
+    global I, E, pi, oo, zoo, nan, true, false, GoldenRatio, Catalan, EulerGamma, sympy_module, sage_module
+    del I, E, pi, oo, zoo, nan, true, false, GoldenRatio, Catalan, EulerGamma, sympy_module, sage_module
 
 import atexit
 atexit.register(module_cleanup)
@@ -2796,6 +2989,14 @@ def lt(lhs, rhs):
     cdef Basic Y = sympify(rhs)
     return c2py(<RCP[const symengine.Basic]>(symengine.Lt(X.thisptr, Y.thisptr)))
 
+def digamma(x):
+    cdef Basic X = sympify(x)
+    return c2py(symengine.digamma(X.thisptr))
+
+def trigamma(x):
+    cdef Basic X = sympify(x)
+    return c2py(symengine.trigamma(X.thisptr))
+
 def eval_double(x):
     cdef Basic X = sympify(x)
     return c2py(<RCP[const symengine.Basic]>(symengine.real_double(symengine.eval_double(deref(X.thisptr)))))