17505: address reviewer's suggestions

Author: rwst

src/sage/calculus/calculus.py

@@ -809,7 +809,7 @@ def nintegral(ex, x, a, b,
 
 nintegrate = nintegral
 
-def symbolic_prod(expression, v, a, b, algorithm='maxima', hold=False):
+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`.
@@ -837,21 +837,23 @@ def symbolic_prod(expression, v, a, b, algorithm='maxima', hold=False):
     EXAMPLES::
 
         sage: i, k, n = var('i,k,n')
-        sage: from sage.calculus.calculus import symbolic_prod
-        sage: symbolic_prod(k, k, 1, n)
+        sage: from sage.calculus.calculus import symbolic_product
+        sage: symbolic_product(k, k, 1, n)
         factorial(n)
-        sage: symbolic_prod(x + i*(i+1)/2, i, 1, 4)
+        sage: symbolic_product(x + i*(i+1)/2, i, 1, 4)
         x^4 + 20*x^3 + 127*x^2 + 288*x + 180
-        sage: symbolic_prod(i^2, i, 1, 7)
+        sage: symbolic_product(i^2, i, 1, 7)
         25401600
         sage: f = function('f')
-        sage: symbolic_prod(f(i), i, 1, 7)
+        sage: symbolic_product(f(i), i, 1, 7)
         f(7)*f(6)*f(5)*f(4)*f(3)*f(2)*f(1)
-        sage: symbolic_prod(f(i), i, 1, n)
+        sage: symbolic_product(f(i), i, 1, n)
         product(f(i), i, 1, n)
         sage: assume(k>0)
-        sage: symbolic_prod(integrate (x^k, x, 0, 1), k, 1, n)
+        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):
@@ -869,11 +871,23 @@ def symbolic_prod(expression, v, a, b, algorithm='maxima', hold=False):
     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':
-        sum = "product(%s, %s, %s, %s)" % tuple([repr(expr._giac_()) for expr in (expression, v, a, b)])
+        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(sum)
+            result = giac(prod)
         except TypeError:
             raise ValueError("Giac cannot make sense of: %s" % sum)
         return result.sage()

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,6 +2609,16 @@ 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()
 
 

src/sage/symbolic/expression_conversions.py

@@ -2009,13 +2009,13 @@ def composition(self, ex, operator):
             0
         """
         from sage.functions.other import Function_sum, Function_prod
-        from sage.calculus.calculus import symbolic_sum, symbolic_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_prod(*map(self, ex.operands()))
+            return symbolic_product(*map(self, ex.operands()))
         if operator in self._exclude:
             return operator(*map(self, ex.operands()), hold=True)
         else: