I am done

rl/Lib/site-packages/sympy/sandbox/__init__.py

@@ -0,0 +1,8 @@
+"""
+Sandbox module of SymPy.
+
+This module contains experimental code, use at your own risk!
+
+There is no warranty that this code will still be located here in future
+versions of SymPy.
+"""

rl/Lib/site-packages/sympy/sandbox/indexed_integrals.py

@@ -0,0 +1,72 @@
+from sympy.tensor import Indexed
+from sympy.core.containers import Tuple
+from sympy.core.symbol import Dummy
+from sympy.core.sympify import sympify
+from sympy.integrals.integrals import Integral
+
+
+class IndexedIntegral(Integral):
+    """
+    Experimental class to test integration by indexed variables.
+
+    Usage is analogue to ``Integral``, it simply adds awareness of
+    integration over indices.
+
+    Contraction of non-identical index symbols referring to the same
+    ``IndexedBase`` is not yet supported.
+
+    Examples
+    ========
+
+    >>> from sympy.sandbox.indexed_integrals import IndexedIntegral
+    >>> from sympy import IndexedBase, symbols
+    >>> A = IndexedBase('A')
+    >>> i, j = symbols('i j', integer=True)
+    >>> ii = IndexedIntegral(A[i], A[i])
+    >>> ii
+    Integral(_A[i], _A[i])
+    >>> ii.doit()
+    A[i]**2/2
+
+    If the indices are different, indexed objects are considered to be
+    different variables:
+
+    >>> i2 = IndexedIntegral(A[j], A[i])
+    >>> i2
+    Integral(A[j], _A[i])
+    >>> i2.doit()
+    A[i]*A[j]
+    """
+
+    def __new__(cls, function, *limits, **assumptions):
+        repl, limits = IndexedIntegral._indexed_process_limits(limits)
+        function = sympify(function)
+        function = function.xreplace(repl)
+        obj = Integral.__new__(cls, function, *limits, **assumptions)
+        obj._indexed_repl = repl
+        obj._indexed_reverse_repl = {val: key for key, val in repl.items()}
+        return obj
+
+    def doit(self):
+        res = super().doit()
+        return res.xreplace(self._indexed_reverse_repl)
+
+    @staticmethod
+    def _indexed_process_limits(limits):
+        repl = {}
+        newlimits = []
+        for i in limits:
+            if isinstance(i, (tuple, list, Tuple)):
+                v = i[0]
+                vrest = i[1:]
+            else:
+                v = i
+                vrest = ()
+            if isinstance(v, Indexed):
+                if v not in repl:
+                    r = Dummy(str(v))
+                    repl[v] = r
+                newlimits.append((r,)+vrest)
+            else:
+                newlimits.append(i)
+        return repl, newlimits

rl/Lib/site-packages/sympy/sandbox/tests/test_indexed_integrals.py

@@ -0,0 +1,25 @@
+from sympy.sandbox.indexed_integrals import IndexedIntegral
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.tensor.indexed import (Idx, IndexedBase)
+
+
+def test_indexed_integrals():
+    A = IndexedBase('A')
+    i, j = symbols('i j', integer=True)
+    a1, a2 = symbols('a1:3', cls=Idx)
+    assert isinstance(a1, Idx)
+
+    assert IndexedIntegral(1, A[i]).doit() == A[i]
+    assert IndexedIntegral(A[i], A[i]).doit() == A[i] ** 2 / 2
+    assert IndexedIntegral(A[j], A[i]).doit() == A[i] * A[j]
+    assert IndexedIntegral(A[i] * A[j], A[i]).doit() == A[i] ** 2 * A[j] / 2
+    assert IndexedIntegral(sin(A[i]), A[i]).doit() == -cos(A[i])
+    assert IndexedIntegral(sin(A[j]), A[i]).doit() == sin(A[j]) * A[i]
+
+    assert IndexedIntegral(1, A[a1]).doit() == A[a1]
+    assert IndexedIntegral(A[a1], A[a1]).doit() == A[a1] ** 2 / 2
+    assert IndexedIntegral(A[a2], A[a1]).doit() == A[a1] * A[a2]
+    assert IndexedIntegral(A[a1] * A[a2], A[a1]).doit() == A[a1] ** 2 * A[a2] / 2
+    assert IndexedIntegral(sin(A[a1]), A[a1]).doit() == -cos(A[a1])
+    assert IndexedIntegral(sin(A[a2]), A[a1]).doit() == sin(A[a2]) * A[a1]