Wrapped Max() Function

Author: ShikharJ

symengine/lib/symengine.pxd

@@ -142,6 +142,7 @@ cdef extern from "<symengine/symengine_rcp.h>" namespace "SymEngine":
     RCP[const FunctionSymbol] rcp_static_cast_FunctionSymbol "SymEngine::rcp_static_cast<const SymEngine::FunctionSymbol>"(RCP[const Basic] &b) nogil
     RCP[const FunctionWrapper] rcp_static_cast_FunctionWrapper "SymEngine::rcp_static_cast<const SymEngine::FunctionWrapper>"(RCP[const Basic] &b) nogil
     RCP[const Abs] rcp_static_cast_Abs "SymEngine::rcp_static_cast<const SymEngine::Abs>"(RCP[const Basic] &b) nogil
+    RCP[const Max] rcp_static_cast_Max "SymEngine::rcp_static_cast<const SymEngine::Max>"(RCP[const Basic] &b) nogil
     RCP[const Gamma] rcp_static_cast_Gamma "SymEngine::rcp_static_cast<const SymEngine::Gamma>"(RCP[const Basic] &b) nogil
     RCP[const Derivative] rcp_static_cast_Derivative "SymEngine::rcp_static_cast<const SymEngine::Derivative>"(RCP[const Basic] &b) nogil
     RCP[const Subs] rcp_static_cast_Subs "SymEngine::rcp_static_cast<const SymEngine::Subs>"(RCP[const Basic] &b) nogil
@@ -246,6 +247,7 @@ cdef extern from "<symengine/basic.h>" namespace "SymEngine":
     bool is_a_ACoth "SymEngine::is_a<SymEngine::ACoth>"(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_Max "SymEngine::is_a<SymEngine::Max>"(const Basic &b) nogil
     bool is_a_Gamma "SymEngine::is_a<SymEngine::Gamma>"(const Basic &b) nogil
     bool is_a_Derivative "SymEngine::is_a<SymEngine::Derivative>"(const Basic &b) nogil
     bool is_a_Subs "SymEngine::is_a<SymEngine::Subs>"(const Basic &b) nogil
@@ -417,6 +419,7 @@ cdef extern from "<symengine/functions.h>" namespace "SymEngine":
     cdef RCP[const Basic] acoth(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] max(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+
 
@@ -511,6 +514,9 @@ cdef extern from "<symengine/functions.h>" namespace "SymEngine":
     cdef cppclass Abs(Function):
         RCP[const Basic] get_arg() nogil
 
+    cdef cppclass Max(Function):
+        pass
+
     cdef cppclass Gamma(Function):
         pass
 

symengine/lib/symengine_wrapper.pxd

@@ -118,6 +118,9 @@ cdef class PyFunction(FunctionSymbol):
 cdef class Abs(Function):
     pass
 
+cdef class Max(Function):
+    pass
+
 cdef class Gamma(Function):
     pass
 

symengine/lib/symengine_wrapper.pyx

@@ -43,6 +43,8 @@ cdef c2py(RCP[const symengine.Basic] o):
         r = FunctionSymbol.__new__(FunctionSymbol)
     elif (symengine.is_a_Abs(deref(o))):
         r = Abs.__new__(Abs)
+    elif (symengine.is_a_Max(deref(o))):
+        r = Max.__new__(Max)
     elif (symengine.is_a_Gamma(deref(o))):
         r = Gamma.__new__(Gamma)
     elif (symengine.is_a_Derivative(deref(o))):
@@ -194,6 +196,8 @@ def sympy2symengine(a, raise_error=False):
         return log(a.args[0])
     elif isinstance(a, sympy.Abs):
         return abs(sympy2symengine(a.args[0], raise_error))
+    elif isinstance(a, sympy.Max):
+        return max(*a.args)
     elif isinstance(a, sympy.gamma):
         return gamma(a.args[0])
     elif isinstance(a, sympy.Derivative):
@@ -1327,6 +1331,27 @@ cdef class Abs(Function):
         arg = c2py(deref(X).get_arg())._sage_()
         return abs(arg)
 
+cdef class Max(Function):
+
+    def _sympy_(self):
+        cdef RCP[const symengine.Max] X = \
+            symengine.rcp_static_cast_Max(self.thisptr)
+        cdef symengine.vec_basic Y = deref(X).get_args()
+        s = []
+        for i in range(Y.size()):
+            s.append(c2py(<RCP[const symengine.Basic]>(Y[i]))._sympy_())
+        import sympy
+        return sympy.Max(*s)
+
+    def _sage_(self):
+        import sage.all as sage
+        cdef RCP[const symengine.Max] X = \
+            symengine.rcp_static_cast_Max(self.thisptr)
+        cdef symengine.vec_basic Y = deref(X).get_args()
+        s = []
+        for i in range(Y.size()):
+            s.append(c2py(<RCP[const symengine.Basic]>(Y[i]))._sage_())
+        return sage.max(*s)
 
 cdef class Derivative(Basic):
 
@@ -2216,6 +2241,14 @@ def log(x, y = None):
     cdef Basic Y = sympify(y)
     return c2py(symengine.log(X.thisptr, Y.thisptr))
 
+def max(*args):
+    cdef symengine.vec_basic v
+    cdef Basic e_
+    for e in args:
+        e_ = sympify(e)
+        v.push_back(e_.thisptr)
+    return c2py(symengine.max(v))
+
 def gamma(x):
     cdef Basic X = sympify(x)
     return c2py(symengine.gamma(X.thisptr))