Merge branch 'u/rws/implement_symbolic_product' of trac.sagemath.org:sage into distribute

Author: EmmanuelCharpentier

src/sage/calculus/calculus.py

@@ -809,6 +809,103 @@ def nintegral(ex, x, a, b,
 
 nintegrate = nintegral
 
+def symbolic_product(expression, v, a, b, algorithm='maxima', hold=False):
+    r"""
+    Return the symbolic product `\prod_{v = a}^b expression` with respect
+    to the variable `v` with endpoints `a` and `b`.
+
+    INPUT:
+
+    - ``expression`` - a symbolic expression
+
+    - ``v`` - a variable or variable name
+
+    - ``a`` - lower endpoint of the product
+
+    - ``b`` - upper endpoint of the prduct
+
+    - ``algorithm`` - (default: ``'maxima'``)  one of
+
+      - ``'maxima'`` - use Maxima (the default)
+
+      - ``'giac'`` - (optional) use Giac
+
+      - ``'sympy'`` - use SymPy
+
+    - ``hold`` - (default: ``False``) if ``True`` don't evaluate
+
+    EXAMPLES::
+
+        sage: i, k, n = var('i,k,n')
+        sage: from sage.calculus.calculus import symbolic_product
+        sage: symbolic_product(k, k, 1, n)
+        factorial(n)
+        sage: symbolic_product(x + i*(i+1)/2, i, 1, 4)
+        x^4 + 20*x^3 + 127*x^2 + 288*x + 180
+        sage: symbolic_product(i^2, i, 1, 7)
+        25401600
+        sage: f = function('f')
+        sage: symbolic_product(f(i), i, 1, 7)
+        f(7)*f(6)*f(5)*f(4)*f(3)*f(2)*f(1)
+        sage: symbolic_product(f(i), i, 1, n)
+        product(f(i), i, 1, n)
+        sage: assume(k>0)
+        sage: symbolic_product(integrate (x^k, x, 0, 1), k, 1, n)
+        1/factorial(n + 1)
+        sage: symbolic_product(f(i), i, 1, n).log().log_expand()
+        sum(log(f(i)), i, 1, n)
+    """
+    if not is_SymbolicVariable(v):
+        if isinstance(v, str):
+            v = var(v)
+        else:
+            raise TypeError("need a multiplication variable")
+
+    if v in SR(a).variables() or v in SR(b).variables():
+        raise ValueError("product limits must not depend on the multiplication variable")
+
+    if hold == True:
+        from sage.functions.other import symbolic_prod as sprod
+        return sprod(expression, v, a, b)
+
+    if algorithm == 'maxima':
+        return maxima.sr_prod(expression,v,a,b)
+
+    elif algorithm == 'mathematica':
+        try:
+            prod = "Product[%s, {%s, %s, %s}]" % tuple([repr(expr._mathematica_()) for expr in (expression, v, a, b)])
+        except TypeError:
+            raise ValueError("Mathematica cannot make sense of input")
+        from sage.interfaces.mathematica import mathematica
+        try:
+            result = mathematica(prod)
+        except TypeError:
+            raise ValueError("Mathematica cannot make sense of: %s" % sum)
+        return result.sage()
+
+    elif algorithm == 'giac':
+        prod = "product(%s, %s, %s, %s)" % tuple([repr(expr._giac_()) for expr in (expression, v, a, b)])
+        from sage.interfaces.giac import giac
+        try:
+            result = giac(prod)
+        except TypeError:
+            raise ValueError("Giac cannot make sense of: %s" % sum)
+        return result.sage()
+
+    elif algorithm == 'sympy':
+        expression,v,a,b = [expr._sympy_() for expr in (expression, v, a, b)]
+        from sympy import product as sproduct
+        result = sproduct(expression, (v, a, b))
+        try:
+            return result._sage_()
+        except AttributeError:
+            raise AttributeError("Unable to convert SymPy result (={}) into"
+                    " Sage".format(result))
+
+    else:
+        raise ValueError("unknown algorithm: %s" % algorithm)
+
+
 def minpoly(ex, var='x', algorithm=None, bits=None, degree=None, epsilon=0):
     r"""
     Return the minimal polynomial of self, if possible.
@@ -2024,7 +2121,10 @@ def symbolic_expression_from_maxima_string(x, equals_sub=False, maxima=maxima):
     formal_functions = maxima_tick.findall(s)
     if len(formal_functions) > 0:
         for X in formal_functions:
-            syms[X[1:]] = function_factory(X[1:])
+            try:
+                syms[X[1:]] = _syms[X[1:]]
+            except KeyError:
+                syms[X[1:]] = function_factory(X[1:])
         # You might think there is a potential very subtle bug if 'foo
         # is in a string literal -- but string literals should *never*
         # ever be part of a symbolic expression.

src/sage/functions/other.py

@@ -2593,8 +2593,10 @@ class Function_sum(BuiltinFunction):
     EXAMPLES::
 
         sage: from sage.functions.other import symbolic_sum as ssum
-        sage: ssum(x, x, 1, 10)
+        sage: r = ssum(x, x, 1, 10); r
         sum(x, x, 1, 10)
+        sage: r.unhold()
+        55
     """
     def __init__(self):
         """
@@ -2607,4 +2609,61 @@ def __init__(self):
         BuiltinFunction.__init__(self, "sum", nargs=4,
                                conversions=dict(maxima='sum'))
 
+    def _print_latex_(self, x, var, a, b):
+        r"""
+        EXAMPLES::
+
+            sage: from sage.functions.other import symbolic_sum as ssum
+            sage: latex(ssum(x^2, x, 1, 10))
+            \sum_{x=1}^{10} x^2
+        """
+        return r"\sum_{{{}={}}}^{{{}}} {}".format(var, a, b, x)
+
 symbolic_sum = Function_sum()
+
+
+class Function_prod(BuiltinFunction):
+    """
+    Placeholder symbolic product function that is only accessible internally.
+
+    EXAMPLES::
+
+        sage: from sage.functions.other import symbolic_product as sprod
+        sage: r = sprod(x, x, 1, 10); r
+        product(x, x, 1, 10)
+        sage: r.unhold()
+        3628800
+    """
+    def __init__(self):
+        """
+        EXAMPLES::
+
+            sage: from sage.functions.other import symbolic_product as sprod
+            sage: _ = var('m n', domain='integer')
+            sage: r = maxima(sprod(sin(m), m, 1, n)).sage(); r
+            product(sin(m), m, 1, n)
+            sage: isinstance(r.operator(), sage.functions.other.Function_prod)
+            True
+            sage: r = sympy(sprod(sin(m), m, 1, n)).sage(); r # known bug
+            product(sin(m), m, 1, n)
+            sage: isinstance(r.operator(),
+            ....:     sage.functions.other.Function_prod) # known bug
+            True
+            sage: giac(sprod(m, m, 1, n))
+            n!
+        """
+        BuiltinFunction.__init__(self, "product", nargs=4,
+                               conversions=dict(maxima='product',
+                                   sympy='Product', giac='product'))
+
+    def _print_latex_(self, x, var, a, b):
+        r"""
+        EXAMPLES::
+
+            sage: from sage.functions.other import symbolic_product as sprod
+            sage: latex(sprod(x^2, x, 1, 10))
+            \prod_{x=1}^{10} x^2
+        """
+        return r"\prod_{{{}={}}}^{{{}}} {}".format(var, a, b, x)
+
+symbolic_product = Function_prod()

src/sage/interfaces/maxima_lib.py

@@ -232,6 +232,8 @@
 max_integrate=EclObject("$INTEGRATE")
 max_sum=EclObject("$SUM")
 max_simplify_sum=EclObject("$SIMPLIFY_SUM")
+max_prod=EclObject("$PRODUCT")
+max_simplify_prod=EclObject("$SIMPLIFY_PRODUCT")
 max_ratsimp=EclObject("$RATSIMP")
 max_limit=EclObject("$LIMIT")
 max_tlimit=EclObject("$TLIMIT")
@@ -898,6 +900,25 @@ def sr_sum(self,*args):
             else:
                 raise
 
+    def sr_prod(self,*args):
+        """
+        Helper function to wrap calculus use of Maxima's summation.
+        """
+        try:
+            return max_to_sr(maxima_eval([[max_ratsimp],[[max_simplify_prod],([max_prod],[sr_to_max(SR(a)) for a in args])]]));
+        except RuntimeError as error:
+            s = str(error)
+            if "divergent" in s:
+# in pexpect interface, one looks for this;
+# could not find an example where 'Pole encountered' occurred, though
+#            if "divergent" in s or 'Pole encountered' in s:
+                raise ValueError("Sum is divergent.")
+            elif "Is" in s: # Maxima asked for a condition
+                self._missing_assumption(s)
+            else:
+                raise
+
+
     def sr_limit(self, expr, v, a, dir=None):
         """
         Helper function to wrap calculus use of Maxima's limits.

src/sage/symbolic/expression_conversions.py

@@ -2008,12 +2008,14 @@ def composition(self, ex, operator):
             sage: h()
             0
         """
-        from sage.functions.other import Function_sum
-        from sage.calculus.calculus import symbolic_sum
+        from sage.functions.other import Function_sum, Function_prod
+        from sage.calculus.calculus import symbolic_sum, symbolic_product
         if not operator:
             return self
         if isinstance(operator, Function_sum):
             return symbolic_sum(*map(self, ex.operands()))
+        if isinstance(operator, Function_prod):
+            return symbolic_product(*map(self, ex.operands()))
         if operator in self._exclude:
             return operator(*map(self, ex.operands()), hold=True)
         else: