Add files using upload-large-folder tool

env-llmeval/lib/python3.10/site-packages/sympy/external/__init__.py

@@ -0,0 +1,20 @@
+"""
+Unified place for determining if external dependencies are installed or not.
+
+You should import all external modules using the import_module() function.
+
+For example
+
+>>> from sympy.external import import_module
+>>> numpy = import_module('numpy')
+
+If the resulting library is not installed, or if the installed version
+is less than a given minimum version, the function will return None.
+Otherwise, it will return the library. See the docstring of
+import_module() for more information.
+
+"""
+
+from sympy.external.importtools import import_module
+
+__all__ = ['import_module']

env-llmeval/lib/python3.10/site-packages/sympy/external/pythonmpq.py

@@ -0,0 +1,341 @@
+"""
+PythonMPQ: Rational number type based on Python integers.
+
+This class is intended as a pure Python fallback for when gmpy2 is not
+installed. If gmpy2 is installed then its mpq type will be used instead. The
+mpq type is around 20x faster. We could just use the stdlib Fraction class
+here but that is slower:
+
+    from fractions import Fraction
+    from sympy.external.pythonmpq import PythonMPQ
+    nums = range(1000)
+    dens = range(5, 1005)
+    rats = [Fraction(n, d) for n, d in zip(nums, dens)]
+    sum(rats) # <--- 24 milliseconds
+    rats = [PythonMPQ(n, d) for n, d in zip(nums, dens)]
+    sum(rats) # <---  7 milliseconds
+
+Both mpq and Fraction have some awkward features like the behaviour of
+division with // and %:
+
+    >>> from fractions import Fraction
+    >>> Fraction(2, 3) % Fraction(1, 4)
+    1/6
+
+For the QQ domain we do not want this behaviour because there should be no
+remainder when dividing rational numbers. SymPy does not make use of this
+aspect of mpq when gmpy2 is installed. Since this class is a fallback for that
+case we do not bother implementing e.g. __mod__ so that we can be sure we
+are not using it when gmpy2 is installed either.
+"""
+
+
+import operator
+from math import gcd
+from decimal import Decimal
+from fractions import Fraction
+import sys
+from typing import Tuple as tTuple, Type
+
+
+# Used for __hash__
+_PyHASH_MODULUS = sys.hash_info.modulus
+_PyHASH_INF = sys.hash_info.inf
+
+
+class PythonMPQ:
+    """Rational number implementation that is intended to be compatible with
+    gmpy2's mpq.
+
+    Also slightly faster than fractions.Fraction.
+
+    PythonMPQ should be treated as immutable although no effort is made to
+    prevent mutation (since that might slow down calculations).
+    """
+    __slots__ = ('numerator', 'denominator')
+
+    def __new__(cls, numerator, denominator=None):
+        """Construct PythonMPQ with gcd computation and checks"""
+        if denominator is not None:
+            #
+            # PythonMPQ(n, d): require n and d to be int and d != 0
+            #
+            if isinstance(numerator, int) and isinstance(denominator, int):
+                # This is the slow part:
+                divisor = gcd(numerator, denominator)
+                numerator //= divisor
+                denominator //= divisor
+                return cls._new_check(numerator, denominator)
+        else:
+            #
+            # PythonMPQ(q)
+            #
+            # Here q can be PythonMPQ, int, Decimal, float, Fraction or str
+            #
+            if isinstance(numerator, int):
+                return cls._new(numerator, 1)
+            elif isinstance(numerator, PythonMPQ):
+                return cls._new(numerator.numerator, numerator.denominator)
+
+            # Let Fraction handle Decimal/float conversion and str parsing
+            if isinstance(numerator, (Decimal, float, str)):
+                numerator = Fraction(numerator)
+            if isinstance(numerator, Fraction):
+                return cls._new(numerator.numerator, numerator.denominator)
+        #
+        # Reject everything else. This is more strict than mpq which allows
+        # things like mpq(Fraction, Fraction) or mpq(Decimal, any). The mpq
+        # behaviour is somewhat inconsistent so we choose to accept only a
+        # more strict subset of what mpq allows.
+        #
+        raise TypeError("PythonMPQ() requires numeric or string argument")
+
+    @classmethod
+    def _new_check(cls, numerator, denominator):
+        """Construct PythonMPQ, check divide by zero and canonicalize signs"""
+        if not denominator:
+            raise ZeroDivisionError(f'Zero divisor {numerator}/{denominator}')
+        elif denominator < 0:
+            numerator = -numerator
+            denominator = -denominator
+        return cls._new(numerator, denominator)
+
+    @classmethod
+    def _new(cls, numerator, denominator):
+        """Construct PythonMPQ efficiently (no checks)"""
+        obj = super().__new__(cls)
+        obj.numerator = numerator
+        obj.denominator = denominator
+        return obj
+
+    def __int__(self):
+        """Convert to int (truncates towards zero)"""
+        p, q = self.numerator, self.denominator
+        if p < 0:
+            return -(-p//q)
+        return p//q
+
+    def __float__(self):
+        """Convert to float (approximately)"""
+        return self.numerator / self.denominator
+
+    def __bool__(self):
+        """True/False if nonzero/zero"""
+        return bool(self.numerator)
+
+    def __eq__(self, other):
+        """Compare equal with PythonMPQ, int, float, Decimal or Fraction"""
+        if isinstance(other, PythonMPQ):
+            return (self.numerator == other.numerator
+                and self.denominator == other.denominator)
+        elif isinstance(other, self._compatible_types):
+            return self.__eq__(PythonMPQ(other))
+        else:
+            return NotImplemented
+
+    def __hash__(self):
+        """hash - same as mpq/Fraction"""
+        try:
+            dinv = pow(self.denominator, -1, _PyHASH_MODULUS)
+        except ValueError:
+            hash_ = _PyHASH_INF
+        else:
+            hash_ = hash(hash(abs(self.numerator)) * dinv)
+        result = hash_ if self.numerator >= 0 else -hash_
+        return -2 if result == -1 else result
+
+    def __reduce__(self):
+        """Deconstruct for pickling"""
+        return type(self), (self.numerator, self.denominator)
+
+    def __str__(self):
+        """Convert to string"""
+        if self.denominator != 1:
+            return f"{self.numerator}/{self.denominator}"
+        else:
+            return f"{self.numerator}"
+
+    def __repr__(self):
+        """Convert to string"""
+        return f"MPQ({self.numerator},{self.denominator})"
+
+    def _cmp(self, other, op):
+        """Helper for lt/le/gt/ge"""
+        if not isinstance(other, self._compatible_types):
+            return NotImplemented
+        lhs = self.numerator * other.denominator
+        rhs = other.numerator * self.denominator
+        return op(lhs, rhs)
+
+    def __lt__(self, other):
+        """self < other"""
+        return self._cmp(other, operator.lt)
+
+    def __le__(self, other):
+        """self <= other"""
+        return self._cmp(other, operator.le)
+
+    def __gt__(self, other):
+        """self > other"""
+        return self._cmp(other, operator.gt)
+
+    def __ge__(self, other):
+        """self >= other"""
+        return self._cmp(other, operator.ge)
+
+    def __abs__(self):
+        """abs(q)"""
+        return self._new(abs(self.numerator), self.denominator)
+
+    def __pos__(self):
+        """+q"""
+        return self
+
+    def __neg__(self):
+        """-q"""
+        return self._new(-self.numerator, self.denominator)
+
+    def __add__(self, other):
+        """q1 + q2"""
+        if isinstance(other, PythonMPQ):
+            #
+            # This is much faster than the naive method used in the stdlib
+            # fractions module. Not sure where this method comes from
+            # though...
+            #
+            # Compare timings for something like:
+            #   nums = range(1000)
+            #   rats = [PythonMPQ(n, d) for n, d in zip(nums[:-5], nums[5:])]
+            #   sum(rats) # <-- time this
+            #
+            ap, aq = self.numerator, self.denominator
+            bp, bq = other.numerator, other.denominator
+            g = gcd(aq, bq)
+            if g == 1:
+                p = ap*bq + aq*bp
+                q = bq*aq
+            else:
+                q1, q2 = aq//g, bq//g
+                p, q = ap*q2 + bp*q1, q1*q2
+                g2 = gcd(p, g)
+                p, q = (p // g2), q * (g // g2)
+
+        elif isinstance(other, int):
+            p = self.numerator + self.denominator * other
+            q = self.denominator
+        else:
+            return NotImplemented
+
+        return self._new(p, q)
+
+    def __radd__(self, other):
+        """z1 + q2"""
+        if isinstance(other, int):
+            p = self.numerator + self.denominator * other
+            q = self.denominator
+            return self._new(p, q)
+        else:
+            return NotImplemented
+
+    def __sub__(self ,other):
+        """q1 - q2"""
+        if isinstance(other, PythonMPQ):
+            ap, aq = self.numerator, self.denominator
+            bp, bq = other.numerator, other.denominator
+            g = gcd(aq, bq)
+            if g == 1:
+                p = ap*bq - aq*bp
+                q = bq*aq
+            else:
+                q1, q2 = aq//g, bq//g
+                p, q = ap*q2 - bp*q1, q1*q2
+                g2 = gcd(p, g)
+                p, q = (p // g2), q * (g // g2)
+        elif isinstance(other, int):
+            p = self.numerator - self.denominator*other
+            q = self.denominator
+        else:
+            return NotImplemented
+
+        return self._new(p, q)
+
+    def __rsub__(self, other):
+        """z1 - q2"""
+        if isinstance(other, int):
+            p = self.denominator * other - self.numerator
+            q = self.denominator
+            return self._new(p, q)
+        else:
+            return NotImplemented
+
+    def __mul__(self, other):
+        """q1 * q2"""
+        if isinstance(other, PythonMPQ):
+            ap, aq = self.numerator, self.denominator
+            bp, bq = other.numerator, other.denominator
+            x1 = gcd(ap, bq)
+            x2 = gcd(bp, aq)
+            p, q = ((ap//x1)*(bp//x2), (aq//x2)*(bq//x1))
+        elif isinstance(other, int):
+            x = gcd(other, self.denominator)
+            p = self.numerator*(other//x)
+            q = self.denominator//x
+        else:
+            return NotImplemented
+
+        return self._new(p, q)
+
+    def __rmul__(self, other):
+        """z1 * q2"""
+        if isinstance(other, int):
+            x = gcd(self.denominator, other)
+            p = self.numerator*(other//x)
+            q = self.denominator//x
+            return self._new(p, q)
+        else:
+            return NotImplemented
+
+    def __pow__(self, exp):
+        """q ** z"""
+        p, q = self.numerator, self.denominator
+
+        if exp < 0:
+            p, q, exp = q, p, -exp
+
+        return self._new_check(p**exp, q**exp)
+
+    def __truediv__(self, other):
+        """q1 / q2"""
+        if isinstance(other, PythonMPQ):
+            ap, aq = self.numerator, self.denominator
+            bp, bq = other.numerator, other.denominator
+            x1 = gcd(ap, bp)
+            x2 = gcd(bq, aq)
+            p, q = ((ap//x1)*(bq//x2), (aq//x2)*(bp//x1))
+        elif isinstance(other, int):
+            x = gcd(other, self.numerator)
+            p = self.numerator//x
+            q = self.denominator*(other//x)
+        else:
+            return NotImplemented
+
+        return self._new_check(p, q)
+
+    def __rtruediv__(self, other):
+        """z / q"""
+        if isinstance(other, int):
+            x = gcd(self.numerator, other)
+            p = self.denominator*(other//x)
+            q = self.numerator//x
+            return self._new_check(p, q)
+        else:
+            return NotImplemented
+
+    _compatible_types: tTuple[Type, ...] = ()
+
+#
+# These are the types that PythonMPQ will interoperate with for operations
+# and comparisons such as ==, + etc. We define this down here so that we can
+# include PythonMPQ in the list as well.
+#
+PythonMPQ._compatible_types = (PythonMPQ, int, Decimal, Fraction)

env-llmeval/lib/python3.10/site-packages/sympy/external/tests/test_autowrap.py

@@ -0,0 +1,313 @@
+import sympy
+import tempfile
+import os
+from sympy.core.mod import Mod
+from sympy.core.relational import Eq
+from sympy.core.symbol import symbols
+from sympy.external import import_module
+from sympy.tensor import IndexedBase, Idx
+from sympy.utilities.autowrap import autowrap, ufuncify, CodeWrapError
+from sympy.testing.pytest import skip
+
+numpy = import_module('numpy', min_module_version='1.6.1')
+Cython = import_module('Cython', min_module_version='0.15.1')
+f2py = import_module('numpy.f2py', import_kwargs={'fromlist': ['f2py']})
+
+f2pyworks = False
+if f2py:
+    try:
+        autowrap(symbols('x'), 'f95', 'f2py')
+    except (CodeWrapError, ImportError, OSError):
+        f2pyworks = False
+    else:
+        f2pyworks = True
+
+a, b, c = symbols('a b c')
+n, m, d = symbols('n m d', integer=True)
+A, B, C = symbols('A B C', cls=IndexedBase)
+i = Idx('i', m)
+j = Idx('j', n)
+k = Idx('k', d)
+
+
+def has_module(module):
+    """
+    Return True if module exists, otherwise run skip().
+
+    module should be a string.
+    """
+    # To give a string of the module name to skip(), this function takes a
+    # string.  So we don't waste time running import_module() more than once,
+    # just map the three modules tested here in this dict.
+    modnames = {'numpy': numpy, 'Cython': Cython, 'f2py': f2py}
+
+    if modnames[module]:
+        if module == 'f2py' and not f2pyworks:
+            skip("Couldn't run f2py.")
+        return True
+    skip("Couldn't import %s." % module)
+
+#
+# test runners used by several language-backend combinations
+#
+
+def runtest_autowrap_twice(language, backend):
+    f = autowrap((((a + b)/c)**5).expand(), language, backend)
+    g = autowrap((((a + b)/c)**4).expand(), language, backend)
+
+    # check that autowrap updates the module name.  Else, g gives the same as f
+    assert f(1, -2, 1) == -1.0
+    assert g(1, -2, 1) == 1.0
+
+
+def runtest_autowrap_trace(language, backend):
+    has_module('numpy')
+    trace = autowrap(A[i, i], language, backend)
+    assert trace(numpy.eye(100)) == 100
+
+
+def runtest_autowrap_matrix_vector(language, backend):
+    has_module('numpy')
+    x, y = symbols('x y', cls=IndexedBase)
+    expr = Eq(y[i], A[i, j]*x[j])
+    mv = autowrap(expr, language, backend)
+
+    # compare with numpy's dot product
+    M = numpy.random.rand(10, 20)
+    x = numpy.random.rand(20)
+    y = numpy.dot(M, x)
+    assert numpy.sum(numpy.abs(y - mv(M, x))) < 1e-13
+
+
+def runtest_autowrap_matrix_matrix(language, backend):
+    has_module('numpy')
+    expr = Eq(C[i, j], A[i, k]*B[k, j])
+    matmat = autowrap(expr, language, backend)
+
+    # compare with numpy's dot product
+    M1 = numpy.random.rand(10, 20)
+    M2 = numpy.random.rand(20, 15)
+    M3 = numpy.dot(M1, M2)
+    assert numpy.sum(numpy.abs(M3 - matmat(M1, M2))) < 1e-13
+
+
+def runtest_ufuncify(language, backend):
+    has_module('numpy')
+    a, b, c = symbols('a b c')
+    fabc = ufuncify([a, b, c], a*b + c, backend=backend)
+    facb = ufuncify([a, c, b], a*b + c, backend=backend)
+    grid = numpy.linspace(-2, 2, 50)
+    b = numpy.linspace(-5, 4, 50)
+    c = numpy.linspace(-1, 1, 50)
+    expected = grid*b + c
+    numpy.testing.assert_allclose(fabc(grid, b, c), expected)
+    numpy.testing.assert_allclose(facb(grid, c, b), expected)
+
+
+def runtest_issue_10274(language, backend):
+    expr = (a - b + c)**(13)
+    tmp = tempfile.mkdtemp()
+    f = autowrap(expr, language, backend, tempdir=tmp,
+                 helpers=('helper', a - b + c, (a, b, c)))
+    assert f(1, 1, 1) == 1
+
+    for file in os.listdir(tmp):
+        if not (file.startswith("wrapped_code_") and file.endswith(".c")):
+            continue
+
+        with open(tmp + '/' + file) as fil:
+            lines = fil.readlines()
+            assert lines[0] == "/******************************************************************************\n"
+            assert "Code generated with SymPy " + sympy.__version__ in lines[1]
+            assert lines[2:] == [
+                " *                                                                            *\n",
+                " *              See http://www.sympy.org/ for more information.               *\n",
+                " *                                                                            *\n",
+                " *                      This file is part of 'autowrap'                       *\n",
+                " ******************************************************************************/\n",
+                "#include " + '"' + file[:-1]+ 'h"' + "\n",
+                "#include <math.h>\n",
+                "\n",
+                "double helper(double a, double b, double c) {\n",
+                "\n",
+                "   double helper_result;\n",
+                "   helper_result = a - b + c;\n",
+                "   return helper_result;\n",
+                "\n",
+                "}\n",
+                "\n",
+                "double autofunc(double a, double b, double c) {\n",
+                "\n",
+                "   double autofunc_result;\n",
+                "   autofunc_result = pow(helper(a, b, c), 13);\n",
+                "   return autofunc_result;\n",
+                "\n",
+                "}\n",
+                ]
+
+
+def runtest_issue_15337(language, backend):
+    has_module('numpy')
+    # NOTE : autowrap was originally designed to only accept an iterable for
+    # the kwarg "helpers", but in issue 10274 the user mistakenly thought that
+    # if there was only a single helper it did not need to be passed via an
+    # iterable that wrapped the helper tuple. There were no tests for this
+    # behavior so when the code was changed to accept a single tuple it broke
+    # the original behavior. These tests below ensure that both now work.
+    a, b, c, d, e = symbols('a, b, c, d, e')
+    expr = (a - b + c - d + e)**13
+    exp_res = (1. - 2. + 3. - 4. + 5.)**13
+
+    f = autowrap(expr, language, backend, args=(a, b, c, d, e),
+                 helpers=('f1', a - b + c, (a, b, c)))
+    numpy.testing.assert_allclose(f(1, 2, 3, 4, 5), exp_res)
+
+    f = autowrap(expr, language, backend, args=(a, b, c, d, e),
+                 helpers=(('f1', a - b, (a, b)), ('f2', c - d, (c, d))))
+    numpy.testing.assert_allclose(f(1, 2, 3, 4, 5), exp_res)
+
+
+def test_issue_15230():
+    has_module('f2py')
+
+    x, y = symbols('x, y')
+    expr = Mod(x, 3.0) - Mod(y, -2.0)
+    f = autowrap(expr, args=[x, y], language='F95')
+    exp_res = float(expr.xreplace({x: 3.5, y: 2.7}).evalf())
+    assert abs(f(3.5, 2.7) - exp_res) < 1e-14
+
+    x, y = symbols('x, y', integer=True)
+    expr = Mod(x, 3) - Mod(y, -2)
+    f = autowrap(expr, args=[x, y], language='F95')
+    assert f(3, 2) == expr.xreplace({x: 3, y: 2})
+
+#
+# tests of language-backend combinations
+#
+
+# f2py
+
+
+def test_wrap_twice_f95_f2py():
+    has_module('f2py')
+    runtest_autowrap_twice('f95', 'f2py')
+
+
+def test_autowrap_trace_f95_f2py():
+    has_module('f2py')
+    runtest_autowrap_trace('f95', 'f2py')
+
+
+def test_autowrap_matrix_vector_f95_f2py():
+    has_module('f2py')
+    runtest_autowrap_matrix_vector('f95', 'f2py')
+
+
+def test_autowrap_matrix_matrix_f95_f2py():
+    has_module('f2py')
+    runtest_autowrap_matrix_matrix('f95', 'f2py')
+
+
+def test_ufuncify_f95_f2py():
+    has_module('f2py')
+    runtest_ufuncify('f95', 'f2py')
+
+
+def test_issue_15337_f95_f2py():
+    has_module('f2py')
+    runtest_issue_15337('f95', 'f2py')
+
+# Cython
+
+
+def test_wrap_twice_c_cython():
+    has_module('Cython')
+    runtest_autowrap_twice('C', 'cython')
+
+
+def test_autowrap_trace_C_Cython():
+    has_module('Cython')
+    runtest_autowrap_trace('C99', 'cython')
+
+
+def test_autowrap_matrix_vector_C_cython():
+    has_module('Cython')
+    runtest_autowrap_matrix_vector('C99', 'cython')
+
+
+def test_autowrap_matrix_matrix_C_cython():
+    has_module('Cython')
+    runtest_autowrap_matrix_matrix('C99', 'cython')
+
+
+def test_ufuncify_C_Cython():
+    has_module('Cython')
+    runtest_ufuncify('C99', 'cython')
+
+
+def test_issue_10274_C_cython():
+    has_module('Cython')
+    runtest_issue_10274('C89', 'cython')
+
+
+def test_issue_15337_C_cython():
+    has_module('Cython')
+    runtest_issue_15337('C89', 'cython')
+
+
+def test_autowrap_custom_printer():
+    has_module('Cython')
+
+    from sympy.core.numbers import pi
+    from sympy.utilities.codegen import C99CodeGen
+    from sympy.printing.c import C99CodePrinter
+
+    class PiPrinter(C99CodePrinter):
+        def _print_Pi(self, expr):
+            return "S_PI"
+
+    printer = PiPrinter()
+    gen = C99CodeGen(printer=printer)
+    gen.preprocessor_statements.append('#include "shortpi.h"')
+
+    expr = pi * a
+
+    expected = (
+        '#include "%s"\n'
+        '#include <math.h>\n'
+        '#include "shortpi.h"\n'
+        '\n'
+        'double autofunc(double a) {\n'
+        '\n'
+        '   double autofunc_result;\n'
+        '   autofunc_result = S_PI*a;\n'
+        '   return autofunc_result;\n'
+        '\n'
+        '}\n'
+    )
+
+    tmpdir = tempfile.mkdtemp()
+    # write a trivial header file to use in the generated code
+    with open(os.path.join(tmpdir, 'shortpi.h'), 'w') as f:
+        f.write('#define S_PI 3.14')
+
+    func = autowrap(expr, backend='cython', tempdir=tmpdir, code_gen=gen)
+
+    assert func(4.2) == 3.14 * 4.2
+
+    # check that the generated code is correct
+    for filename in os.listdir(tmpdir):
+        if filename.startswith('wrapped_code') and filename.endswith('.c'):
+            with open(os.path.join(tmpdir, filename)) as f:
+                lines = f.readlines()
+                expected = expected % filename.replace('.c', '.h')
+                assert ''.join(lines[7:]) == expected
+
+
+# Numpy
+
+def test_ufuncify_numpy():
+    # This test doesn't use Cython, but if Cython works, then there is a valid
+    # C compiler, which is needed.
+    has_module('Cython')
+    runtest_ufuncify('C99', 'numpy')

env-llmeval/lib/python3.10/site-packages/sympy/external/tests/test_codegen.py

@@ -0,0 +1,379 @@
+# This tests the compilation and execution of the source code generated with
+# utilities.codegen. The compilation takes place in a temporary directory that
+# is removed after the test. By default the test directory is always removed,
+# but this behavior can be changed by setting the environment variable
+# SYMPY_TEST_CLEAN_TEMP to:
+#   export SYMPY_TEST_CLEAN_TEMP=always   : the default behavior.
+#   export SYMPY_TEST_CLEAN_TEMP=success  : only remove the directories of working tests.
+#   export SYMPY_TEST_CLEAN_TEMP=never    : never remove the directories with the test code.
+# When a directory is not removed, the necessary information is printed on
+# screen to find the files that belong to the (failed) tests. If a test does
+# not fail, py.test captures all the output and you will not see the directories
+# corresponding to the successful tests. Use the --nocapture option to see all
+# the output.
+
+# All tests below have a counterpart in utilities/test/test_codegen.py. In the
+# latter file, the resulting code is compared with predefined strings, without
+# compilation or execution.
+
+# All the generated Fortran code should conform with the Fortran 95 standard,
+# and all the generated C code should be ANSI C, which facilitates the
+# incorporation in various projects. The tests below assume that the binary cc
+# is somewhere in the path and that it can compile ANSI C code.
+
+from sympy.abc import x, y, z
+from sympy.external import import_module
+from sympy.testing.pytest import skip
+from sympy.utilities.codegen import codegen, make_routine, get_code_generator
+import sys
+import os
+import tempfile
+import subprocess
+
+
+pyodide_js = import_module('pyodide_js')
+
+# templates for the main program that will test the generated code.
+
+main_template = {}
+main_template['F95'] = """
+program main
+  include "codegen.h"
+  integer :: result;
+  result = 0
+
+  %(statements)s
+
+  call exit(result)
+end program
+"""
+
+main_template['C89'] = """
+#include "codegen.h"
+#include <stdio.h>
+#include <math.h>
+
+int main() {
+  int result = 0;
+
+  %(statements)s
+
+  return result;
+}
+"""
+main_template['C99'] = main_template['C89']
+# templates for the numerical tests
+
+numerical_test_template = {}
+numerical_test_template['C89'] = """
+  if (fabs(%(call)s)>%(threshold)s) {
+    printf("Numerical validation failed: %(call)s=%%e threshold=%(threshold)s\\n", %(call)s);
+    result = -1;
+  }
+"""
+numerical_test_template['C99'] = numerical_test_template['C89']
+
+numerical_test_template['F95'] = """
+  if (abs(%(call)s)>%(threshold)s) then
+    write(6,"('Numerical validation failed:')")
+    write(6,"('%(call)s=',e15.5,'threshold=',e15.5)") %(call)s, %(threshold)s
+    result = -1;
+  end if
+"""
+# command sequences for supported compilers
+
+compile_commands = {}
+compile_commands['cc'] = [
+    "cc -c codegen.c -o codegen.o",
+    "cc -c main.c -o main.o",
+    "cc main.o codegen.o -lm -o test.exe"
+]
+
+compile_commands['gfortran'] = [
+    "gfortran -c codegen.f90 -o codegen.o",
+    "gfortran -ffree-line-length-none -c main.f90 -o main.o",
+    "gfortran main.o codegen.o -o test.exe"
+]
+
+compile_commands['g95'] = [
+    "g95 -c codegen.f90 -o codegen.o",
+    "g95 -ffree-line-length-huge -c main.f90 -o main.o",
+    "g95 main.o codegen.o -o test.exe"
+]
+
+compile_commands['ifort'] = [
+    "ifort -c codegen.f90 -o codegen.o",
+    "ifort -c main.f90 -o main.o",
+    "ifort main.o codegen.o -o test.exe"
+]
+
+combinations_lang_compiler = [
+    ('C89', 'cc'),
+    ('C99', 'cc'),
+    ('F95', 'ifort'),
+    ('F95', 'gfortran'),
+    ('F95', 'g95')
+]
+
+
+def try_run(commands):
+    """Run a series of commands and only return True if all ran fine."""
+    if pyodide_js:
+        return False
+    with open(os.devnull, 'w') as null:
+        for command in commands:
+            retcode = subprocess.call(command, stdout=null, shell=True,
+                    stderr=subprocess.STDOUT)
+            if retcode != 0:
+                return False
+    return True
+
+
+def run_test(label, routines, numerical_tests, language, commands, friendly=True):
+    """A driver for the codegen tests.
+
+       This driver assumes that a compiler ifort is present in the PATH and that
+       ifort is (at least) a Fortran 90 compiler. The generated code is written in
+       a temporary directory, together with a main program that validates the
+       generated code. The test passes when the compilation and the validation
+       run correctly.
+    """
+
+    # Check input arguments before touching the file system
+    language = language.upper()
+    assert language in main_template
+    assert language in numerical_test_template
+
+    # Check that environment variable makes sense
+    clean = os.getenv('SYMPY_TEST_CLEAN_TEMP', 'always').lower()
+    if clean not in ('always', 'success', 'never'):
+        raise ValueError("SYMPY_TEST_CLEAN_TEMP must be one of the following: 'always', 'success' or 'never'.")
+
+    # Do all the magic to compile, run and validate the test code
+    # 1) prepare the temporary working directory, switch to that dir
+    work = tempfile.mkdtemp("_sympy_%s_test" % language, "%s_" % label)
+    oldwork = os.getcwd()
+    os.chdir(work)
+
+    # 2) write the generated code
+    if friendly:
+        # interpret the routines as a name_expr list and call the friendly
+        # function codegen
+        codegen(routines, language, "codegen", to_files=True)
+    else:
+        code_gen = get_code_generator(language, "codegen")
+        code_gen.write(routines, "codegen", to_files=True)
+
+    # 3) write a simple main program that links to the generated code, and that
+    #    includes the numerical tests
+    test_strings = []
+    for fn_name, args, expected, threshold in numerical_tests:
+        call_string = "%s(%s)-(%s)" % (
+            fn_name, ",".join(str(arg) for arg in args), expected)
+        if language == "F95":
+            call_string = fortranize_double_constants(call_string)
+            threshold = fortranize_double_constants(str(threshold))
+        test_strings.append(numerical_test_template[language] % {
+            "call": call_string,
+            "threshold": threshold,
+        })
+
+    if language == "F95":
+        f_name = "main.f90"
+    elif language.startswith("C"):
+        f_name = "main.c"
+    else:
+        raise NotImplementedError(
+            "FIXME: filename extension unknown for language: %s" % language)
+
+    with open(f_name, "w") as f:
+        f.write(
+            main_template[language] % {'statements': "".join(test_strings)})
+
+    # 4) Compile and link
+    compiled = try_run(commands)
+
+    # 5) Run if compiled
+    if compiled:
+        executed = try_run(["./test.exe"])
+    else:
+        executed = False
+
+    # 6) Clean up stuff
+    if clean == 'always' or (clean == 'success' and compiled and executed):
+        def safe_remove(filename):
+            if os.path.isfile(filename):
+                os.remove(filename)
+        safe_remove("codegen.f90")
+        safe_remove("codegen.c")
+        safe_remove("codegen.h")
+        safe_remove("codegen.o")
+        safe_remove("main.f90")
+        safe_remove("main.c")
+        safe_remove("main.o")
+        safe_remove("test.exe")
+        os.chdir(oldwork)
+        os.rmdir(work)
+    else:
+        print("TEST NOT REMOVED: %s" % work, file=sys.stderr)
+        os.chdir(oldwork)
+
+    # 7) Do the assertions in the end
+    assert compiled, "failed to compile %s code with:\n%s" % (
+        language, "\n".join(commands))
+    assert executed, "failed to execute %s code from:\n%s" % (
+        language, "\n".join(commands))
+
+
+def fortranize_double_constants(code_string):
+    """
+    Replaces every literal float with literal doubles
+    """
+    import re
+    pattern_exp = re.compile(r'\d+(\.)?\d*[eE]-?\d+')
+    pattern_float = re.compile(r'\d+\.\d*(?!\d*d)')
+
+    def subs_exp(matchobj):
+        return re.sub('[eE]', 'd', matchobj.group(0))
+
+    def subs_float(matchobj):
+        return "%sd0" % matchobj.group(0)
+
+    code_string = pattern_exp.sub(subs_exp, code_string)
+    code_string = pattern_float.sub(subs_float, code_string)
+
+    return code_string
+
+
+def is_feasible(language, commands):
+    # This test should always work, otherwise the compiler is not present.
+    routine = make_routine("test", x)
+    numerical_tests = [
+        ("test", ( 1.0,), 1.0, 1e-15),
+        ("test", (-1.0,), -1.0, 1e-15),
+    ]
+    try:
+        run_test("is_feasible", [routine], numerical_tests, language, commands,
+                 friendly=False)
+        return True
+    except AssertionError:
+        return False
+
+valid_lang_commands = []
+invalid_lang_compilers = []
+for lang, compiler in combinations_lang_compiler:
+    commands = compile_commands[compiler]
+    if is_feasible(lang, commands):
+        valid_lang_commands.append((lang, commands))
+    else:
+        invalid_lang_compilers.append((lang, compiler))
+
+# We test all language-compiler combinations, just to report what is skipped
+
+def test_C89_cc():
+    if ("C89", 'cc') in invalid_lang_compilers:
+        skip("`cc' command didn't work as expected (C89)")
+
+
+def test_C99_cc():
+    if ("C99", 'cc') in invalid_lang_compilers:
+        skip("`cc' command didn't work as expected (C99)")
+
+
+def test_F95_ifort():
+    if ("F95", 'ifort') in invalid_lang_compilers:
+        skip("`ifort' command didn't work as expected")
+
+
+def test_F95_gfortran():
+    if ("F95", 'gfortran') in invalid_lang_compilers:
+        skip("`gfortran' command didn't work as expected")
+
+
+def test_F95_g95():
+    if ("F95", 'g95') in invalid_lang_compilers:
+        skip("`g95' command didn't work as expected")
+
+# Here comes the actual tests
+
+
+def test_basic_codegen():
+    numerical_tests = [
+        ("test", (1.0, 6.0, 3.0), 21.0, 1e-15),
+        ("test", (-1.0, 2.0, -2.5), -2.5, 1e-15),
+    ]
+    name_expr = [("test", (x + y)*z)]
+    for lang, commands in valid_lang_commands:
+        run_test("basic_codegen", name_expr, numerical_tests, lang, commands)
+
+
+def test_intrinsic_math1_codegen():
+    # not included: log10
+    from sympy.core.evalf import N
+    from sympy.functions import ln
+    from sympy.functions.elementary.exponential import log
+    from sympy.functions.elementary.hyperbolic import (cosh, sinh, tanh)
+    from sympy.functions.elementary.integers import (ceiling, floor)
+    from sympy.functions.elementary.miscellaneous import sqrt
+    from sympy.functions.elementary.trigonometric import (acos, asin, atan, cos, sin, tan)
+    name_expr = [
+        ("test_fabs", abs(x)),
+        ("test_acos", acos(x)),
+        ("test_asin", asin(x)),
+        ("test_atan", atan(x)),
+        ("test_cos", cos(x)),
+        ("test_cosh", cosh(x)),
+        ("test_log", log(x)),
+        ("test_ln", ln(x)),
+        ("test_sin", sin(x)),
+        ("test_sinh", sinh(x)),
+        ("test_sqrt", sqrt(x)),
+        ("test_tan", tan(x)),
+        ("test_tanh", tanh(x)),
+    ]
+    numerical_tests = []
+    for name, expr in name_expr:
+        for xval in 0.2, 0.5, 0.8:
+            expected = N(expr.subs(x, xval))
+            numerical_tests.append((name, (xval,), expected, 1e-14))
+    for lang, commands in valid_lang_commands:
+        if lang.startswith("C"):
+            name_expr_C = [("test_floor", floor(x)), ("test_ceil", ceiling(x))]
+        else:
+            name_expr_C = []
+        run_test("intrinsic_math1", name_expr + name_expr_C,
+                 numerical_tests, lang, commands)
+
+
+def test_instrinsic_math2_codegen():
+    # not included: frexp, ldexp, modf, fmod
+    from sympy.core.evalf import N
+    from sympy.functions.elementary.trigonometric import atan2
+    name_expr = [
+        ("test_atan2", atan2(x, y)),
+        ("test_pow", x**y),
+    ]
+    numerical_tests = []
+    for name, expr in name_expr:
+        for xval, yval in (0.2, 1.3), (0.5, -0.2), (0.8, 0.8):
+            expected = N(expr.subs(x, xval).subs(y, yval))
+            numerical_tests.append((name, (xval, yval), expected, 1e-14))
+    for lang, commands in valid_lang_commands:
+        run_test("intrinsic_math2", name_expr, numerical_tests, lang, commands)
+
+
+def test_complicated_codegen():
+    from sympy.core.evalf import N
+    from sympy.functions.elementary.trigonometric import (cos, sin, tan)
+    name_expr = [
+        ("test1", ((sin(x) + cos(y) + tan(z))**7).expand()),
+        ("test2", cos(cos(cos(cos(cos(cos(cos(cos(x + y + z))))))))),
+    ]
+    numerical_tests = []
+    for name, expr in name_expr:
+        for xval, yval, zval in (0.2, 1.3, -0.3), (0.5, -0.2, 0.0), (0.8, 2.1, 0.8):
+            expected = N(expr.subs(x, xval).subs(y, yval).subs(z, zval))
+            numerical_tests.append((name, (xval, yval, zval), expected, 1e-12))
+    for lang, commands in valid_lang_commands:
+        run_test(
+            "complicated_codegen", name_expr, numerical_tests, lang, commands)

env-llmeval/lib/python3.10/site-packages/sympy/external/tests/test_importtools.py

@@ -0,0 +1,40 @@
+from sympy.external import import_module
+from sympy.testing.pytest import warns
+
+# fixes issue that arose in addressing issue 6533
+def test_no_stdlib_collections():
+    '''
+    make sure we get the right collections when it is not part of a
+    larger list
+    '''
+    import collections
+    matplotlib = import_module('matplotlib',
+        import_kwargs={'fromlist': ['cm', 'collections']},
+        min_module_version='1.1.0', catch=(RuntimeError,))
+    if matplotlib:
+        assert collections != matplotlib.collections
+
+def test_no_stdlib_collections2():
+    '''
+    make sure we get the right collections when it is not part of a
+    larger list
+    '''
+    import collections
+    matplotlib = import_module('matplotlib',
+        import_kwargs={'fromlist': ['collections']},
+        min_module_version='1.1.0', catch=(RuntimeError,))
+    if matplotlib:
+        assert collections != matplotlib.collections
+
+def test_no_stdlib_collections3():
+    '''make sure we get the right collections with no catch'''
+    import collections
+    matplotlib = import_module('matplotlib',
+        import_kwargs={'fromlist': ['cm', 'collections']},
+        min_module_version='1.1.0')
+    if matplotlib:
+        assert collections != matplotlib.collections
+
+def test_min_module_version_python3_basestring_error():
+    with warns(UserWarning):
+        import_module('mpmath', min_module_version='1000.0.1')

env-llmeval/lib/python3.10/site-packages/sympy/external/tests/test_numpy.py

@@ -0,0 +1,333 @@
+# This testfile tests SymPy <-> NumPy compatibility
+
+# Don't test any SymPy features here. Just pure interaction with NumPy.
+# Always write regular SymPy tests for anything, that can be tested in pure
+# Python (without numpy). Here we test everything, that a user may need when
+# using SymPy with NumPy
+from sympy.external.importtools import version_tuple
+from sympy.external import import_module
+
+numpy = import_module('numpy')
+if numpy:
+    array, matrix, ndarray = numpy.array, numpy.matrix, numpy.ndarray
+else:
+    #bin/test will not execute any tests now
+    disabled = True
+
+
+from sympy.core.numbers import (Float, Integer, Rational)
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.trigonometric import sin
+from sympy.matrices.dense import (Matrix, list2numpy, matrix2numpy, symarray)
+from sympy.utilities.lambdify import lambdify
+import sympy
+
+import mpmath
+from sympy.abc import x, y, z
+from sympy.utilities.decorator import conserve_mpmath_dps
+from sympy.utilities.exceptions import ignore_warnings
+from sympy.testing.pytest import raises
+
+
+# first, systematically check, that all operations are implemented and don't
+# raise an exception
+
+
+def test_systematic_basic():
+    def s(sympy_object, numpy_array):
+        _ = [sympy_object + numpy_array,
+        numpy_array + sympy_object,
+        sympy_object - numpy_array,
+        numpy_array - sympy_object,
+        sympy_object * numpy_array,
+        numpy_array * sympy_object,
+        sympy_object / numpy_array,
+        numpy_array / sympy_object,
+        sympy_object ** numpy_array,
+        numpy_array ** sympy_object]
+    x = Symbol("x")
+    y = Symbol("y")
+    sympy_objs = [
+        Rational(2, 3),
+        Float("1.3"),
+        x,
+        y,
+        pow(x, y)*y,
+        Integer(5),
+        Float(5.5),
+    ]
+    numpy_objs = [
+        array([1]),
+        array([3, 8, -1]),
+        array([x, x**2, Rational(5)]),
+        array([x/y*sin(y), 5, Rational(5)]),
+    ]
+    for x in sympy_objs:
+        for y in numpy_objs:
+            s(x, y)
+
+
+# now some random tests, that test particular problems and that also
+# check that the results of the operations are correct
+
+def test_basics():
+    one = Rational(1)
+    zero = Rational(0)
+    assert array(1) == array(one)
+    assert array([one]) == array([one])
+    assert array([x]) == array([x])
+    assert array(x) == array(Symbol("x"))
+    assert array(one + x) == array(1 + x)
+
+    X = array([one, zero, zero])
+    assert (X == array([one, zero, zero])).all()
+    assert (X == array([one, 0, 0])).all()
+
+
+def test_arrays():
+    one = Rational(1)
+    zero = Rational(0)
+    X = array([one, zero, zero])
+    Y = one*X
+    X = array([Symbol("a") + Rational(1, 2)])
+    Y = X + X
+    assert Y == array([1 + 2*Symbol("a")])
+    Y = Y + 1
+    assert Y == array([2 + 2*Symbol("a")])
+    Y = X - X
+    assert Y == array([0])
+
+
+def test_conversion1():
+    a = list2numpy([x**2, x])
+    #looks like an array?
+    assert isinstance(a, ndarray)
+    assert a[0] == x**2
+    assert a[1] == x
+    assert len(a) == 2
+    #yes, it's the array
+
+
+def test_conversion2():
+    a = 2*list2numpy([x**2, x])
+    b = list2numpy([2*x**2, 2*x])
+    assert (a == b).all()
+
+    one = Rational(1)
+    zero = Rational(0)
+    X = list2numpy([one, zero, zero])
+    Y = one*X
+    X = list2numpy([Symbol("a") + Rational(1, 2)])
+    Y = X + X
+    assert Y == array([1 + 2*Symbol("a")])
+    Y = Y + 1
+    assert Y == array([2 + 2*Symbol("a")])
+    Y = X - X
+    assert Y == array([0])
+
+
+def test_list2numpy():
+    assert (array([x**2, x]) == list2numpy([x**2, x])).all()
+
+
+def test_Matrix1():
+    m = Matrix([[x, x**2], [5, 2/x]])
+    assert (array(m.subs(x, 2)) == array([[2, 4], [5, 1]])).all()
+    m = Matrix([[sin(x), x**2], [5, 2/x]])
+    assert (array(m.subs(x, 2)) == array([[sin(2), 4], [5, 1]])).all()
+
+
+def test_Matrix2():
+    m = Matrix([[x, x**2], [5, 2/x]])
+    with ignore_warnings(PendingDeprecationWarning):
+        assert (matrix(m.subs(x, 2)) == matrix([[2, 4], [5, 1]])).all()
+    m = Matrix([[sin(x), x**2], [5, 2/x]])
+    with ignore_warnings(PendingDeprecationWarning):
+        assert (matrix(m.subs(x, 2)) == matrix([[sin(2), 4], [5, 1]])).all()
+
+
+def test_Matrix3():
+    a = array([[2, 4], [5, 1]])
+    assert Matrix(a) == Matrix([[2, 4], [5, 1]])
+    assert Matrix(a) != Matrix([[2, 4], [5, 2]])
+    a = array([[sin(2), 4], [5, 1]])
+    assert Matrix(a) == Matrix([[sin(2), 4], [5, 1]])
+    assert Matrix(a) != Matrix([[sin(0), 4], [5, 1]])
+
+
+def test_Matrix4():
+    with ignore_warnings(PendingDeprecationWarning):
+        a = matrix([[2, 4], [5, 1]])
+    assert Matrix(a) == Matrix([[2, 4], [5, 1]])
+    assert Matrix(a) != Matrix([[2, 4], [5, 2]])
+    with ignore_warnings(PendingDeprecationWarning):
+        a = matrix([[sin(2), 4], [5, 1]])
+    assert Matrix(a) == Matrix([[sin(2), 4], [5, 1]])
+    assert Matrix(a) != Matrix([[sin(0), 4], [5, 1]])
+
+
+def test_Matrix_sum():
+    M = Matrix([[1, 2, 3], [x, y, x], [2*y, -50, z*x]])
+    with ignore_warnings(PendingDeprecationWarning):
+        m = matrix([[2, 3, 4], [x, 5, 6], [x, y, z**2]])
+    assert M + m == Matrix([[3, 5, 7], [2*x, y + 5, x + 6], [2*y + x, y - 50, z*x + z**2]])
+    assert m + M == Matrix([[3, 5, 7], [2*x, y + 5, x + 6], [2*y + x, y - 50, z*x + z**2]])
+    assert M + m == M.add(m)
+
+
+def test_Matrix_mul():
+    M = Matrix([[1, 2, 3], [x, y, x]])
+    with ignore_warnings(PendingDeprecationWarning):
+        m = matrix([[2, 4], [x, 6], [x, z**2]])
+    assert M*m == Matrix([
+        [         2 + 5*x,        16 + 3*z**2],
+        [2*x + x*y + x**2, 4*x + 6*y + x*z**2],
+    ])
+
+    assert m*M == Matrix([
+        [   2 + 4*x,      4 + 4*y,      6 + 4*x],
+        [       7*x,    2*x + 6*y,          9*x],
+        [x + x*z**2, 2*x + y*z**2, 3*x + x*z**2],
+    ])
+    a = array([2])
+    assert a[0] * M == 2 * M
+    assert M * a[0] == 2 * M
+
+
+def test_Matrix_array():
+    class matarray:
+        def __array__(self):
+            from numpy import array
+            return array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    matarr = matarray()
+    assert Matrix(matarr) == Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+
+
+def test_matrix2numpy():
+    a = matrix2numpy(Matrix([[1, x**2], [3*sin(x), 0]]))
+    assert isinstance(a, ndarray)
+    assert a.shape == (2, 2)
+    assert a[0, 0] == 1
+    assert a[0, 1] == x**2
+    assert a[1, 0] == 3*sin(x)
+    assert a[1, 1] == 0
+
+
+def test_matrix2numpy_conversion():
+    a = Matrix([[1, 2, sin(x)], [x**2, x, Rational(1, 2)]])
+    b = array([[1, 2, sin(x)], [x**2, x, Rational(1, 2)]])
+    assert (matrix2numpy(a) == b).all()
+    assert matrix2numpy(a).dtype == numpy.dtype('object')
+
+    c = matrix2numpy(Matrix([[1, 2], [10, 20]]), dtype='int8')
+    d = matrix2numpy(Matrix([[1, 2], [10, 20]]), dtype='float64')
+    assert c.dtype == numpy.dtype('int8')
+    assert d.dtype == numpy.dtype('float64')
+
+
+def test_issue_3728():
+    assert (Rational(1, 2)*array([2*x, 0]) == array([x, 0])).all()
+    assert (Rational(1, 2) + array(
+        [2*x, 0]) == array([2*x + Rational(1, 2), Rational(1, 2)])).all()
+    assert (Float("0.5")*array([2*x, 0]) == array([Float("1.0")*x, 0])).all()
+    assert (Float("0.5") + array(
+        [2*x, 0]) == array([2*x + Float("0.5"), Float("0.5")])).all()
+
+
+@conserve_mpmath_dps
+def test_lambdify():
+    mpmath.mp.dps = 16
+    sin02 = mpmath.mpf("0.198669330795061215459412627")
+    f = lambdify(x, sin(x), "numpy")
+    prec = 1e-15
+    assert -prec < f(0.2) - sin02 < prec
+
+    # if this succeeds, it can't be a numpy function
+
+    if version_tuple(numpy.__version__) >= version_tuple('1.17'):
+        with raises(TypeError):
+            f(x)
+    else:
+        with raises(AttributeError):
+            f(x)
+
+
+def test_lambdify_matrix():
+    f = lambdify(x, Matrix([[x, 2*x], [1, 2]]), [{'ImmutableMatrix': numpy.array}, "numpy"])
+    assert (f(1) == array([[1, 2], [1, 2]])).all()
+
+
+def test_lambdify_matrix_multi_input():
+    M = sympy.Matrix([[x**2, x*y, x*z],
+                      [y*x, y**2, y*z],
+                      [z*x, z*y, z**2]])
+    f = lambdify((x, y, z), M, [{'ImmutableMatrix': numpy.array}, "numpy"])
+
+    xh, yh, zh = 1.0, 2.0, 3.0
+    expected = array([[xh**2, xh*yh, xh*zh],
+                      [yh*xh, yh**2, yh*zh],
+                      [zh*xh, zh*yh, zh**2]])
+    actual = f(xh, yh, zh)
+    assert numpy.allclose(actual, expected)
+
+
+def test_lambdify_matrix_vec_input():
+    X = sympy.DeferredVector('X')
+    M = Matrix([
+        [X[0]**2, X[0]*X[1], X[0]*X[2]],
+        [X[1]*X[0], X[1]**2, X[1]*X[2]],
+        [X[2]*X[0], X[2]*X[1], X[2]**2]])
+    f = lambdify(X, M, [{'ImmutableMatrix': numpy.array}, "numpy"])
+
+    Xh = array([1.0, 2.0, 3.0])
+    expected = array([[Xh[0]**2, Xh[0]*Xh[1], Xh[0]*Xh[2]],
+                      [Xh[1]*Xh[0], Xh[1]**2, Xh[1]*Xh[2]],
+                      [Xh[2]*Xh[0], Xh[2]*Xh[1], Xh[2]**2]])
+    actual = f(Xh)
+    assert numpy.allclose(actual, expected)
+
+
+def test_lambdify_transl():
+    from sympy.utilities.lambdify import NUMPY_TRANSLATIONS
+    for sym, mat in NUMPY_TRANSLATIONS.items():
+        assert sym in sympy.__dict__
+        assert mat in numpy.__dict__
+
+
+def test_symarray():
+    """Test creation of numpy arrays of SymPy symbols."""
+
+    import numpy as np
+    import numpy.testing as npt
+
+    syms = symbols('_0,_1,_2')
+    s1 = symarray("", 3)
+    s2 = symarray("", 3)
+    npt.assert_array_equal(s1, np.array(syms, dtype=object))
+    assert s1[0] == s2[0]
+
+    a = symarray('a', 3)
+    b = symarray('b', 3)
+    assert not(a[0] == b[0])
+
+    asyms = symbols('a_0,a_1,a_2')
+    npt.assert_array_equal(a, np.array(asyms, dtype=object))
+
+    # Multidimensional checks
+    a2d = symarray('a', (2, 3))
+    assert a2d.shape == (2, 3)
+    a00, a12 = symbols('a_0_0,a_1_2')
+    assert a2d[0, 0] == a00
+    assert a2d[1, 2] == a12
+
+    a3d = symarray('a', (2, 3, 2))
+    assert a3d.shape == (2, 3, 2)
+    a000, a120, a121 = symbols('a_0_0_0,a_1_2_0,a_1_2_1')
+    assert a3d[0, 0, 0] == a000
+    assert a3d[1, 2, 0] == a120
+    assert a3d[1, 2, 1] == a121
+
+
+def test_vectorize():
+    assert (numpy.vectorize(
+        sin)([1, 2, 3]) == numpy.array([sin(1), sin(2), sin(3)])).all()

env-llmeval/lib/python3.10/site-packages/sympy/external/tests/test_pythonmpq.py

@@ -0,0 +1,176 @@
+"""
+test_pythonmpq.py
+
+Test the PythonMPQ class for consistency with gmpy2's mpq type. If gmpy2 is
+installed run the same tests for both.
+"""
+from fractions import Fraction
+from decimal import Decimal
+import pickle
+from typing import Callable, List, Tuple, Type
+
+from sympy.testing.pytest import raises
+
+from sympy.external.pythonmpq import PythonMPQ
+
+#
+# If gmpy2 is installed then run the tests for both mpq and PythonMPQ.
+# That should ensure consistency between the implementation here and mpq.
+#
+rational_types: List[Tuple[Callable, Type, Callable, Type]]
+rational_types = [(PythonMPQ, PythonMPQ, int, int)]
+try:
+    from gmpy2 import mpq, mpz
+    rational_types.append((mpq, type(mpq(1)), mpz, type(mpz(1))))
+except ImportError:
+    pass
+
+
+def test_PythonMPQ():
+    #
+    # Test PythonMPQ and also mpq if gmpy/gmpy2 is installed.
+    #
+    for Q, TQ, Z, TZ in rational_types:
+
+        def check_Q(q):
+            assert isinstance(q, TQ)
+            assert isinstance(q.numerator, TZ)
+            assert isinstance(q.denominator, TZ)
+            return q.numerator, q.denominator
+
+        # Check construction from different types
+        assert check_Q(Q(3)) == (3, 1)
+        assert check_Q(Q(3, 5)) == (3, 5)
+        assert check_Q(Q(Q(3, 5))) == (3, 5)
+        assert check_Q(Q(0.5)) == (1, 2)
+        assert check_Q(Q('0.5')) == (1, 2)
+        assert check_Q(Q(Fraction(3, 5))) == (3, 5)
+
+        # https://github.com/aleaxit/gmpy/issues/327
+        if Q is PythonMPQ:
+            assert check_Q(Q(Decimal('0.6'))) == (3, 5)
+
+        # Invalid types
+        raises(TypeError, lambda: Q([]))
+        raises(TypeError, lambda: Q([], []))
+
+        # Check normalisation of signs
+        assert check_Q(Q(2, 3)) == (2, 3)
+        assert check_Q(Q(-2, 3)) == (-2, 3)
+        assert check_Q(Q(2, -3)) == (-2, 3)
+        assert check_Q(Q(-2, -3)) == (2, 3)
+
+        # Check gcd calculation
+        assert check_Q(Q(12, 8)) == (3, 2)
+
+        # __int__/__float__
+        assert int(Q(5, 3)) == 1
+        assert int(Q(-5, 3)) == -1
+        assert float(Q(5, 2)) == 2.5
+        assert float(Q(-5, 2)) == -2.5
+
+        # __str__/__repr__
+        assert str(Q(2, 1)) == "2"
+        assert str(Q(1, 2)) == "1/2"
+        if Q is PythonMPQ:
+            assert repr(Q(2, 1)) == "MPQ(2,1)"
+            assert repr(Q(1, 2)) == "MPQ(1,2)"
+        else:
+            assert repr(Q(2, 1)) == "mpq(2,1)"
+            assert repr(Q(1, 2)) == "mpq(1,2)"
+
+        # __bool__
+        assert bool(Q(1, 2)) is True
+        assert bool(Q(0)) is False
+
+        # __eq__/__ne__
+        assert (Q(2, 3) == Q(2, 3)) is True
+        assert (Q(2, 3) == Q(2, 5)) is False
+        assert (Q(2, 3) != Q(2, 3)) is False
+        assert (Q(2, 3) != Q(2, 5)) is True
+
+        # __hash__
+        assert hash(Q(3, 5)) == hash(Fraction(3, 5))
+
+        # __reduce__
+        q = Q(2, 3)
+        assert pickle.loads(pickle.dumps(q)) == q
+
+        # __ge__/__gt__/__le__/__lt__
+        assert (Q(1, 3) < Q(2, 3)) is True
+        assert (Q(2, 3) < Q(2, 3)) is False
+        assert (Q(2, 3) < Q(1, 3)) is False
+        assert (Q(-2, 3) < Q(1, 3)) is True
+        assert (Q(1, 3) < Q(-2, 3)) is False
+
+        assert (Q(1, 3) <= Q(2, 3)) is True
+        assert (Q(2, 3) <= Q(2, 3)) is True
+        assert (Q(2, 3) <= Q(1, 3)) is False
+        assert (Q(-2, 3) <= Q(1, 3)) is True
+        assert (Q(1, 3) <= Q(-2, 3)) is False
+
+        assert (Q(1, 3) > Q(2, 3)) is False
+        assert (Q(2, 3) > Q(2, 3)) is False
+        assert (Q(2, 3) > Q(1, 3)) is True
+        assert (Q(-2, 3) > Q(1, 3)) is False
+        assert (Q(1, 3) > Q(-2, 3)) is True
+
+        assert (Q(1, 3) >= Q(2, 3)) is False
+        assert (Q(2, 3) >= Q(2, 3)) is True
+        assert (Q(2, 3) >= Q(1, 3)) is True
+        assert (Q(-2, 3) >= Q(1, 3)) is False
+        assert (Q(1, 3) >= Q(-2, 3)) is True
+
+        # __abs__/__pos__/__neg__
+        assert abs(Q(2, 3)) == abs(Q(-2, 3)) == Q(2, 3)
+        assert +Q(2, 3) == Q(2, 3)
+        assert -Q(2, 3) == Q(-2, 3)
+
+        # __add__/__radd__
+        assert Q(2, 3) + Q(5, 7) == Q(29, 21)
+        assert Q(2, 3) + 1 == Q(5, 3)
+        assert 1 + Q(2, 3) == Q(5, 3)
+        raises(TypeError, lambda: [] + Q(1))
+        raises(TypeError, lambda: Q(1) + [])
+
+        # __sub__/__rsub__
+        assert Q(2, 3) - Q(5, 7) == Q(-1, 21)
+        assert Q(2, 3) - 1 == Q(-1, 3)
+        assert 1 - Q(2, 3) == Q(1, 3)
+        raises(TypeError, lambda: [] - Q(1))
+        raises(TypeError, lambda: Q(1) - [])
+
+        # __mul__/__rmul__
+        assert Q(2, 3) * Q(5, 7) == Q(10, 21)
+        assert Q(2, 3) * 1 == Q(2, 3)
+        assert 1 * Q(2, 3) == Q(2, 3)
+        raises(TypeError, lambda: [] * Q(1))
+        raises(TypeError, lambda: Q(1) * [])
+
+        # __pow__/__rpow__
+        assert Q(2, 3) ** 2 == Q(4, 9)
+        assert Q(2, 3) ** 1 == Q(2, 3)
+        assert Q(-2, 3) ** 2 == Q(4, 9)
+        assert Q(-2, 3) ** -1 == Q(-3, 2)
+        if Q is PythonMPQ:
+            raises(TypeError, lambda: 1 ** Q(2, 3))
+            raises(TypeError, lambda: Q(1, 4) ** Q(1, 2))
+        raises(TypeError, lambda: [] ** Q(1))
+        raises(TypeError, lambda: Q(1) ** [])
+
+        # __div__/__rdiv__
+        assert Q(2, 3) / Q(5, 7) == Q(14, 15)
+        assert Q(2, 3) / 1 == Q(2, 3)
+        assert 1 / Q(2, 3) == Q(3, 2)
+        raises(TypeError, lambda: [] / Q(1))
+        raises(TypeError, lambda: Q(1) / [])
+        raises(ZeroDivisionError, lambda: Q(1, 2) / Q(0))
+
+        # __divmod__
+        if Q is PythonMPQ:
+            raises(TypeError, lambda: Q(2, 3) // Q(1, 3))
+            raises(TypeError, lambda: Q(2, 3) % Q(1, 3))
+            raises(TypeError, lambda: 1 // Q(1, 3))
+            raises(TypeError, lambda: 1 % Q(1, 3))
+            raises(TypeError, lambda: Q(2, 3) // 1)
+            raises(TypeError, lambda: Q(2, 3) % 1)

env-llmeval/lib/python3.10/site-packages/sympy/external/tests/test_scipy.py

@@ -0,0 +1,35 @@
+# This testfile tests SymPy <-> SciPy compatibility
+
+# Don't test any SymPy features here. Just pure interaction with SciPy.
+# Always write regular SymPy tests for anything, that can be tested in pure
+# Python (without scipy). Here we test everything, that a user may need when
+# using SymPy with SciPy
+
+from sympy.external import import_module
+
+scipy = import_module('scipy')
+if not scipy:
+    #bin/test will not execute any tests now
+    disabled = True
+
+from sympy.functions.special.bessel import jn_zeros
+
+
+def eq(a, b, tol=1e-6):
+    for x, y in zip(a, b):
+        if not (abs(x - y) < tol):
+            return False
+    return True
+
+
+def test_jn_zeros():
+    assert eq(jn_zeros(0, 4, method="scipy"),
+            [3.141592, 6.283185, 9.424777, 12.566370])
+    assert eq(jn_zeros(1, 4, method="scipy"),
+            [4.493409, 7.725251, 10.904121, 14.066193])
+    assert eq(jn_zeros(2, 4, method="scipy"),
+            [5.763459, 9.095011, 12.322940, 15.514603])
+    assert eq(jn_zeros(3, 4, method="scipy"),
+            [6.987932, 10.417118, 13.698023, 16.923621])
+    assert eq(jn_zeros(4, 4, method="scipy"),
+            [8.182561, 11.704907, 15.039664, 18.301255])

env-llmeval/lib/python3.10/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.
+"""

env-llmeval/lib/python3.10/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

env-llmeval/lib/python3.10/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]

env-llmeval/lib/python3.10/site-packages/sympy/tensor/__init__.py

@@ -0,0 +1,23 @@
+"""A module to manipulate symbolic objects with indices including tensors
+
+"""
+from .indexed import IndexedBase, Idx, Indexed
+from .index_methods import get_contraction_structure, get_indices
+from .functions import shape
+from .array import (MutableDenseNDimArray, ImmutableDenseNDimArray,
+    MutableSparseNDimArray, ImmutableSparseNDimArray, NDimArray, tensorproduct,
+    tensorcontraction, tensordiagonal, derive_by_array, permutedims, Array,
+    DenseNDimArray, SparseNDimArray,)
+
+__all__ = [
+    'IndexedBase', 'Idx', 'Indexed',
+
+    'get_contraction_structure', 'get_indices',
+
+    'shape',
+
+    'MutableDenseNDimArray', 'ImmutableDenseNDimArray',
+    'MutableSparseNDimArray', 'ImmutableSparseNDimArray', 'NDimArray',
+    'tensorproduct', 'tensorcontraction', 'tensordiagonal', 'derive_by_array', 'permutedims',
+    'Array', 'DenseNDimArray', 'SparseNDimArray',
+]

env-llmeval/lib/python3.10/site-packages/sympy/tensor/array/__init__.py

@@ -0,0 +1,271 @@
+r"""
+N-dim array module for SymPy.
+
+Four classes are provided to handle N-dim arrays, given by the combinations
+dense/sparse (i.e. whether to store all elements or only the non-zero ones in
+memory) and mutable/immutable (immutable classes are SymPy objects, but cannot
+change after they have been created).
+
+Examples
+========
+
+The following examples show the usage of ``Array``. This is an abbreviation for
+``ImmutableDenseNDimArray``, that is an immutable and dense N-dim array, the
+other classes are analogous. For mutable classes it is also possible to change
+element values after the object has been constructed.
+
+Array construction can detect the shape of nested lists and tuples:
+
+>>> from sympy import Array
+>>> a1 = Array([[1, 2], [3, 4], [5, 6]])
+>>> a1
+[[1, 2], [3, 4], [5, 6]]
+>>> a1.shape
+(3, 2)
+>>> a1.rank()
+2
+>>> from sympy.abc import x, y, z
+>>> a2 = Array([[[x, y], [z, x*z]], [[1, x*y], [1/x, x/y]]])
+>>> a2
+[[[x, y], [z, x*z]], [[1, x*y], [1/x, x/y]]]
+>>> a2.shape
+(2, 2, 2)
+>>> a2.rank()
+3
+
+Otherwise one could pass a 1-dim array followed by a shape tuple:
+
+>>> m1 = Array(range(12), (3, 4))
+>>> m1
+[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]]
+>>> m2 = Array(range(12), (3, 2, 2))
+>>> m2
+[[[0, 1], [2, 3]], [[4, 5], [6, 7]], [[8, 9], [10, 11]]]
+>>> m2[1,1,1]
+7
+>>> m2.reshape(4, 3)
+[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]
+
+Slice support:
+
+>>> m2[:, 1, 1]
+[3, 7, 11]
+
+Elementwise derivative:
+
+>>> from sympy.abc import x, y, z
+>>> m3 = Array([x**3, x*y, z])
+>>> m3.diff(x)
+[3*x**2, y, 0]
+>>> m3.diff(z)
+[0, 0, 1]
+
+Multiplication with other SymPy expressions is applied elementwisely:
+
+>>> (1+x)*m3
+[x**3*(x + 1), x*y*(x + 1), z*(x + 1)]
+
+To apply a function to each element of the N-dim array, use ``applyfunc``:
+
+>>> m3.applyfunc(lambda x: x/2)
+[x**3/2, x*y/2, z/2]
+
+N-dim arrays can be converted to nested lists by the ``tolist()`` method:
+
+>>> m2.tolist()
+[[[0, 1], [2, 3]], [[4, 5], [6, 7]], [[8, 9], [10, 11]]]
+>>> isinstance(m2.tolist(), list)
+True
+
+If the rank is 2, it is possible to convert them to matrices with ``tomatrix()``:
+
+>>> m1.tomatrix()
+Matrix([
+[0, 1,  2,  3],
+[4, 5,  6,  7],
+[8, 9, 10, 11]])
+
+Products and contractions
+-------------------------
+
+Tensor product between arrays `A_{i_1,\ldots,i_n}` and `B_{j_1,\ldots,j_m}`
+creates the combined array `P = A \otimes B` defined as
+
+`P_{i_1,\ldots,i_n,j_1,\ldots,j_m} := A_{i_1,\ldots,i_n}\cdot B_{j_1,\ldots,j_m}.`
+
+It is available through ``tensorproduct(...)``:
+
+>>> from sympy import Array, tensorproduct
+>>> from sympy.abc import x,y,z,t
+>>> A = Array([x, y, z, t])
+>>> B = Array([1, 2, 3, 4])
+>>> tensorproduct(A, B)
+[[x, 2*x, 3*x, 4*x], [y, 2*y, 3*y, 4*y], [z, 2*z, 3*z, 4*z], [t, 2*t, 3*t, 4*t]]
+
+In case you don't want to evaluate the tensor product immediately, you can use
+``ArrayTensorProduct``, which creates an unevaluated tensor product expression:
+
+>>> from sympy.tensor.array.expressions import ArrayTensorProduct
+>>> ArrayTensorProduct(A, B)
+ArrayTensorProduct([x, y, z, t], [1, 2, 3, 4])
+
+Calling ``.as_explicit()`` on ``ArrayTensorProduct`` is equivalent to just calling
+``tensorproduct(...)``:
+
+>>> ArrayTensorProduct(A, B).as_explicit()
+[[x, 2*x, 3*x, 4*x], [y, 2*y, 3*y, 4*y], [z, 2*z, 3*z, 4*z], [t, 2*t, 3*t, 4*t]]
+
+Tensor product between a rank-1 array and a matrix creates a rank-3 array:
+
+>>> from sympy import eye
+>>> p1 = tensorproduct(A, eye(4))
+>>> p1
+[[[x, 0, 0, 0], [0, x, 0, 0], [0, 0, x, 0], [0, 0, 0, x]], [[y, 0, 0, 0], [0, y, 0, 0], [0, 0, y, 0], [0, 0, 0, y]], [[z, 0, 0, 0], [0, z, 0, 0], [0, 0, z, 0], [0, 0, 0, z]], [[t, 0, 0, 0], [0, t, 0, 0], [0, 0, t, 0], [0, 0, 0, t]]]
+
+Now, to get back `A_0 \otimes \mathbf{1}` one can access `p_{0,m,n}` by slicing:
+
+>>> p1[0,:,:]
+[[x, 0, 0, 0], [0, x, 0, 0], [0, 0, x, 0], [0, 0, 0, x]]
+
+Tensor contraction sums over the specified axes, for example contracting
+positions `a` and `b` means
+
+`A_{i_1,\ldots,i_a,\ldots,i_b,\ldots,i_n} \implies \sum_k A_{i_1,\ldots,k,\ldots,k,\ldots,i_n}`
+
+Remember that Python indexing is zero starting, to contract the a-th and b-th
+axes it is therefore necessary to specify `a-1` and `b-1`
+
+>>> from sympy import tensorcontraction
+>>> C = Array([[x, y], [z, t]])
+
+The matrix trace is equivalent to the contraction of a rank-2 array:
+
+`A_{m,n} \implies \sum_k A_{k,k}`
+
+>>> tensorcontraction(C, (0, 1))
+t + x
+
+To create an expression representing a tensor contraction that does not get
+evaluated immediately, use ``ArrayContraction``, which is equivalent to
+``tensorcontraction(...)`` if it is followed by ``.as_explicit()``:
+
+>>> from sympy.tensor.array.expressions import ArrayContraction
+>>> ArrayContraction(C, (0, 1))
+ArrayContraction([[x, y], [z, t]], (0, 1))
+>>> ArrayContraction(C, (0, 1)).as_explicit()
+t + x
+
+Matrix product is equivalent to a tensor product of two rank-2 arrays, followed
+by a contraction of the 2nd and 3rd axes (in Python indexing axes number 1, 2).
+
+`A_{m,n}\cdot B_{i,j} \implies \sum_k A_{m, k}\cdot B_{k, j}`
+
+>>> D = Array([[2, 1], [0, -1]])
+>>> tensorcontraction(tensorproduct(C, D), (1, 2))
+[[2*x, x - y], [2*z, -t + z]]
+
+One may verify that the matrix product is equivalent:
+
+>>> from sympy import Matrix
+>>> Matrix([[x, y], [z, t]])*Matrix([[2, 1], [0, -1]])
+Matrix([
+[2*x,  x - y],
+[2*z, -t + z]])
+
+or equivalently
+
+>>> C.tomatrix()*D.tomatrix()
+Matrix([
+[2*x,  x - y],
+[2*z, -t + z]])
+
+Diagonal operator
+-----------------
+
+The ``tensordiagonal`` function acts in a similar manner as ``tensorcontraction``,
+but the joined indices are not summed over, for example diagonalizing
+positions `a` and `b` means
+
+`A_{i_1,\ldots,i_a,\ldots,i_b,\ldots,i_n} \implies A_{i_1,\ldots,k,\ldots,k,\ldots,i_n}
+\implies \tilde{A}_{i_1,\ldots,i_{a-1},i_{a+1},\ldots,i_{b-1},i_{b+1},\ldots,i_n,k}`
+
+where `\tilde{A}` is the array equivalent to the diagonal of `A` at positions
+`a` and `b` moved to the last index slot.
+
+Compare the difference between contraction and diagonal operators:
+
+>>> from sympy import tensordiagonal
+>>> from sympy.abc import a, b, c, d
+>>> m = Matrix([[a, b], [c, d]])
+>>> tensorcontraction(m, [0, 1])
+a + d
+>>> tensordiagonal(m, [0, 1])
+[a, d]
+
+In short, no summation occurs with ``tensordiagonal``.
+
+
+Derivatives by array
+--------------------
+
+The usual derivative operation may be extended to support derivation with
+respect to arrays, provided that all elements in the that array are symbols or
+expressions suitable for derivations.
+
+The definition of a derivative by an array is as follows: given the array
+`A_{i_1, \ldots, i_N}` and the array `X_{j_1, \ldots, j_M}`
+the derivative of arrays will return a new array `B` defined by
+
+`B_{j_1,\ldots,j_M,i_1,\ldots,i_N} := \frac{\partial A_{i_1,\ldots,i_N}}{\partial X_{j_1,\ldots,j_M}}`
+
+The function ``derive_by_array`` performs such an operation:
+
+>>> from sympy import derive_by_array
+>>> from sympy.abc import x, y, z, t
+>>> from sympy import sin, exp
+
+With scalars, it behaves exactly as the ordinary derivative:
+
+>>> derive_by_array(sin(x*y), x)
+y*cos(x*y)
+
+Scalar derived by an array basis:
+
+>>> derive_by_array(sin(x*y), [x, y, z])
+[y*cos(x*y), x*cos(x*y), 0]
+
+Deriving array by an array basis: `B^{nm} := \frac{\partial A^m}{\partial x^n}`
+
+>>> basis = [x, y, z]
+>>> ax = derive_by_array([exp(x), sin(y*z), t], basis)
+>>> ax
+[[exp(x), 0, 0], [0, z*cos(y*z), 0], [0, y*cos(y*z), 0]]
+
+Contraction of the resulting array: `\sum_m \frac{\partial A^m}{\partial x^m}`
+
+>>> tensorcontraction(ax, (0, 1))
+z*cos(y*z) + exp(x)
+
+"""
+
+from .dense_ndim_array import MutableDenseNDimArray, ImmutableDenseNDimArray, DenseNDimArray
+from .sparse_ndim_array import MutableSparseNDimArray, ImmutableSparseNDimArray, SparseNDimArray
+from .ndim_array import NDimArray, ArrayKind
+from .arrayop import tensorproduct, tensorcontraction, tensordiagonal, derive_by_array, permutedims
+from .array_comprehension import ArrayComprehension, ArrayComprehensionMap
+
+Array = ImmutableDenseNDimArray
+
+__all__ = [
+    'MutableDenseNDimArray', 'ImmutableDenseNDimArray', 'DenseNDimArray',
+
+    'MutableSparseNDimArray', 'ImmutableSparseNDimArray', 'SparseNDimArray',
+
+    'NDimArray', 'ArrayKind',
+
+    'tensorproduct', 'tensorcontraction', 'tensordiagonal', 'derive_by_array',
+
+    'permutedims', 'ArrayComprehension', 'ArrayComprehensionMap',
+
+    'Array',
+]

env-llmeval/lib/python3.10/site-packages/sympy/tensor/array/array_comprehension.py

@@ -0,0 +1,399 @@
+import functools, itertools
+from sympy.core.sympify import _sympify, sympify
+from sympy.core.expr import Expr
+from sympy.core import Basic, Tuple
+from sympy.tensor.array import ImmutableDenseNDimArray
+from sympy.core.symbol import Symbol
+from sympy.core.numbers import Integer
+
+
+class ArrayComprehension(Basic):
+    """
+    Generate a list comprehension.
+
+    Explanation
+    ===========
+
+    If there is a symbolic dimension, for example, say [i for i in range(1, N)] where
+    N is a Symbol, then the expression will not be expanded to an array. Otherwise,
+    calling the doit() function will launch the expansion.
+
+    Examples
+    ========
+
+    >>> from sympy.tensor.array import ArrayComprehension
+    >>> from sympy import symbols
+    >>> i, j, k = symbols('i j k')
+    >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3))
+    >>> a
+    ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3))
+    >>> a.doit()
+    [[11, 12, 13], [21, 22, 23], [31, 32, 33], [41, 42, 43]]
+    >>> b = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, k))
+    >>> b.doit()
+    ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, k))
+    """
+    def __new__(cls, function, *symbols, **assumptions):
+        if any(len(l) != 3 or None for l in symbols):
+            raise ValueError('ArrayComprehension requires values lower and upper bound'
+                              ' for the expression')
+        arglist = [sympify(function)]
+        arglist.extend(cls._check_limits_validity(function, symbols))
+        obj = Basic.__new__(cls, *arglist, **assumptions)
+        obj._limits = obj._args[1:]
+        obj._shape = cls._calculate_shape_from_limits(obj._limits)
+        obj._rank = len(obj._shape)
+        obj._loop_size = cls._calculate_loop_size(obj._shape)
+        return obj
+
+    @property
+    def function(self):
+        """The function applied across limits.
+
+        Examples
+        ========
+
+        >>> from sympy.tensor.array import ArrayComprehension
+        >>> from sympy import symbols
+        >>> i, j = symbols('i j')
+        >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3))
+        >>> a.function
+        10*i + j
+        """
+        return self._args[0]
+
+    @property
+    def limits(self):
+        """
+        The list of limits that will be applied while expanding the array.
+
+        Examples
+        ========
+
+        >>> from sympy.tensor.array import ArrayComprehension
+        >>> from sympy import symbols
+        >>> i, j = symbols('i j')
+        >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3))
+        >>> a.limits
+        ((i, 1, 4), (j, 1, 3))
+        """
+        return self._limits
+
+    @property
+    def free_symbols(self):
+        """
+        The set of the free_symbols in the array.
+        Variables appeared in the bounds are supposed to be excluded
+        from the free symbol set.
+
+        Examples
+        ========
+
+        >>> from sympy.tensor.array import ArrayComprehension
+        >>> from sympy import symbols
+        >>> i, j, k = symbols('i j k')
+        >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3))
+        >>> a.free_symbols
+        set()
+        >>> b = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, k+3))
+        >>> b.free_symbols
+        {k}
+        """
+        expr_free_sym = self.function.free_symbols
+        for var, inf, sup in self._limits:
+            expr_free_sym.discard(var)
+            curr_free_syms = inf.free_symbols.union(sup.free_symbols)
+            expr_free_sym = expr_free_sym.union(curr_free_syms)
+        return expr_free_sym
+
+    @property
+    def variables(self):
+        """The tuples of the variables in the limits.
+
+        Examples
+        ========
+
+        >>> from sympy.tensor.array import ArrayComprehension
+        >>> from sympy import symbols
+        >>> i, j, k = symbols('i j k')
+        >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3))
+        >>> a.variables
+        [i, j]
+        """
+        return [l[0] for l in self._limits]
+
+    @property
+    def bound_symbols(self):
+        """The list of dummy variables.
+
+        Note
+        ====
+
+        Note that all variables are dummy variables since a limit without
+        lower bound or upper bound is not accepted.
+        """
+        return [l[0] for l in self._limits if len(l) != 1]
+
+    @property
+    def shape(self):
+        """
+        The shape of the expanded array, which may have symbols.
+
+        Note
+        ====
+
+        Both the lower and the upper bounds are included while
+        calculating the shape.
+
+        Examples
+        ========
+
+        >>> from sympy.tensor.array import ArrayComprehension
+        >>> from sympy import symbols
+        >>> i, j, k = symbols('i j k')
+        >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3))
+        >>> a.shape
+        (4, 3)
+        >>> b = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, k+3))
+        >>> b.shape
+        (4, k + 3)
+        """
+        return self._shape
+
+    @property
+    def is_shape_numeric(self):
+        """
+        Test if the array is shape-numeric which means there is no symbolic
+        dimension.
+
+        Examples
+        ========
+
+        >>> from sympy.tensor.array import ArrayComprehension
+        >>> from sympy import symbols
+        >>> i, j, k = symbols('i j k')
+        >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3))
+        >>> a.is_shape_numeric
+        True
+        >>> b = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, k+3))
+        >>> b.is_shape_numeric
+        False
+        """
+        for _, inf, sup in self._limits:
+            if Basic(inf, sup).atoms(Symbol):
+                return False
+        return True
+
+    def rank(self):
+        """The rank of the expanded array.
+
+        Examples
+        ========
+
+        >>> from sympy.tensor.array import ArrayComprehension
+        >>> from sympy import symbols
+        >>> i, j, k = symbols('i j k')
+        >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3))
+        >>> a.rank()
+        2
+        """
+        return self._rank
+
+    def __len__(self):
+        """
+        The length of the expanded array which means the number
+        of elements in the array.
+
+        Raises
+        ======
+
+        ValueError : When the length of the array is symbolic
+
+        Examples
+        ========
+
+        >>> from sympy.tensor.array import ArrayComprehension
+        >>> from sympy import symbols
+        >>> i, j = symbols('i j')
+        >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3))
+        >>> len(a)
+        12
+        """
+        if self._loop_size.free_symbols:
+            raise ValueError('Symbolic length is not supported')
+        return self._loop_size
+
+    @classmethod
+    def _check_limits_validity(cls, function, limits):
+        #limits = sympify(limits)
+        new_limits = []
+        for var, inf, sup in limits:
+            var = _sympify(var)
+            inf = _sympify(inf)
+            #since this is stored as an argument, it should be
+            #a Tuple
+            if isinstance(sup, list):
+                sup = Tuple(*sup)
+            else:
+                sup = _sympify(sup)
+            new_limits.append(Tuple(var, inf, sup))
+            if any((not isinstance(i, Expr)) or i.atoms(Symbol, Integer) != i.atoms()
+                                                                for i in [inf, sup]):
+                raise TypeError('Bounds should be an Expression(combination of Integer and Symbol)')
+            if (inf > sup) == True:
+                raise ValueError('Lower bound should be inferior to upper bound')
+            if var in inf.free_symbols or var in sup.free_symbols:
+                raise ValueError('Variable should not be part of its bounds')
+        return new_limits
+
+    @classmethod
+    def _calculate_shape_from_limits(cls, limits):
+        return tuple([sup - inf + 1 for _, inf, sup in limits])
+
+    @classmethod
+    def _calculate_loop_size(cls, shape):
+        if not shape:
+            return 0
+        loop_size = 1
+        for l in shape:
+            loop_size = loop_size * l
+
+        return loop_size
+
+    def doit(self, **hints):
+        if not self.is_shape_numeric:
+            return self
+
+        return self._expand_array()
+
+    def _expand_array(self):
+        res = []
+        for values in itertools.product(*[range(inf, sup+1)
+                                        for var, inf, sup
+                                        in self._limits]):
+            res.append(self._get_element(values))
+
+        return ImmutableDenseNDimArray(res, self.shape)
+
+    def _get_element(self, values):
+        temp = self.function
+        for var, val in zip(self.variables, values):
+            temp = temp.subs(var, val)
+        return temp
+
+    def tolist(self):
+        """Transform the expanded array to a list.
+
+        Raises
+        ======
+
+        ValueError : When there is a symbolic dimension
+
+        Examples
+        ========
+
+        >>> from sympy.tensor.array import ArrayComprehension
+        >>> from sympy import symbols
+        >>> i, j = symbols('i j')
+        >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3))
+        >>> a.tolist()
+        [[11, 12, 13], [21, 22, 23], [31, 32, 33], [41, 42, 43]]
+        """
+        if self.is_shape_numeric:
+            return self._expand_array().tolist()
+
+        raise ValueError("A symbolic array cannot be expanded to a list")
+
+    def tomatrix(self):
+        """Transform the expanded array to a matrix.
+
+        Raises
+        ======
+
+        ValueError : When there is a symbolic dimension
+        ValueError : When the rank of the expanded array is not equal to 2
+
+        Examples
+        ========
+
+        >>> from sympy.tensor.array import ArrayComprehension
+        >>> from sympy import symbols
+        >>> i, j = symbols('i j')
+        >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3))
+        >>> a.tomatrix()
+        Matrix([
+        [11, 12, 13],
+        [21, 22, 23],
+        [31, 32, 33],
+        [41, 42, 43]])
+        """
+        from sympy.matrices import Matrix
+
+        if not self.is_shape_numeric:
+            raise ValueError("A symbolic array cannot be expanded to a matrix")
+        if self._rank != 2:
+            raise ValueError('Dimensions must be of size of 2')
+
+        return Matrix(self._expand_array().tomatrix())
+
+
+def isLambda(v):
+    LAMBDA = lambda: 0
+    return isinstance(v, type(LAMBDA)) and v.__name__ == LAMBDA.__name__
+
+class ArrayComprehensionMap(ArrayComprehension):
+    '''
+    A subclass of ArrayComprehension dedicated to map external function lambda.
+
+    Notes
+    =====
+
+    Only the lambda function is considered.
+    At most one argument in lambda function is accepted in order to avoid ambiguity
+    in value assignment.
+
+    Examples
+    ========
+
+    >>> from sympy.tensor.array import ArrayComprehensionMap
+    >>> from sympy import symbols
+    >>> i, j, k = symbols('i j k')
+    >>> a = ArrayComprehensionMap(lambda: 1, (i, 1, 4))
+    >>> a.doit()
+    [1, 1, 1, 1]
+    >>> b = ArrayComprehensionMap(lambda a: a+1, (j, 1, 4))
+    >>> b.doit()
+    [2, 3, 4, 5]
+
+    '''
+    def __new__(cls, function, *symbols, **assumptions):
+        if any(len(l) != 3 or None for l in symbols):
+            raise ValueError('ArrayComprehension requires values lower and upper bound'
+                              ' for the expression')
+
+        if not isLambda(function):
+            raise ValueError('Data type not supported')
+
+        arglist = cls._check_limits_validity(function, symbols)
+        obj = Basic.__new__(cls, *arglist, **assumptions)
+        obj._limits = obj._args
+        obj._shape = cls._calculate_shape_from_limits(obj._limits)
+        obj._rank = len(obj._shape)
+        obj._loop_size = cls._calculate_loop_size(obj._shape)
+        obj._lambda = function
+        return obj
+
+    @property
+    def func(self):
+        class _(ArrayComprehensionMap):
+            def __new__(cls, *args, **kwargs):
+                return ArrayComprehensionMap(self._lambda, *args, **kwargs)
+        return _
+
+    def _get_element(self, values):
+        temp = self._lambda
+        if self._lambda.__code__.co_argcount == 0:
+            temp = temp()
+        elif self._lambda.__code__.co_argcount == 1:
+            temp = temp(functools.reduce(lambda a, b: a*b, values))
+        return temp

env-llmeval/lib/python3.10/site-packages/sympy/tensor/array/array_derivatives.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+from sympy.core.expr import Expr
+from sympy.core.function import Derivative
+from sympy.core.numbers import Integer
+from sympy.matrices.common import MatrixCommon
+from .ndim_array import NDimArray
+from .arrayop import derive_by_array
+from sympy.matrices.expressions.matexpr import MatrixExpr
+from sympy.matrices.expressions.special import ZeroMatrix
+from sympy.matrices.expressions.matexpr import _matrix_derivative
+
+
+class ArrayDerivative(Derivative):
+
+    is_scalar = False
+
+    def __new__(cls, expr, *variables, **kwargs):
+        obj = super().__new__(cls, expr, *variables, **kwargs)
+        if isinstance(obj, ArrayDerivative):
+            obj._shape = obj._get_shape()
+        return obj
+
+    def _get_shape(self):
+        shape = ()
+        for v, count in self.variable_count:
+            if hasattr(v, "shape"):
+                for i in range(count):
+                    shape += v.shape
+        if hasattr(self.expr, "shape"):
+            shape += self.expr.shape
+        return shape
+
+    @property
+    def shape(self):
+        return self._shape
+
+    @classmethod
+    def _get_zero_with_shape_like(cls, expr):
+        if isinstance(expr, (MatrixCommon, NDimArray)):
+            return expr.zeros(*expr.shape)
+        elif isinstance(expr, MatrixExpr):
+            return ZeroMatrix(*expr.shape)
+        else:
+            raise RuntimeError("Unable to determine shape of array-derivative.")
+
+    @staticmethod
+    def _call_derive_scalar_by_matrix(expr: Expr, v: MatrixCommon) -> Expr:
+        return v.applyfunc(lambda x: expr.diff(x))
+
+    @staticmethod
+    def _call_derive_scalar_by_matexpr(expr: Expr, v: MatrixExpr) -> Expr:
+        if expr.has(v):
+            return _matrix_derivative(expr, v)
+        else:
+            return ZeroMatrix(*v.shape)
+
+    @staticmethod
+    def _call_derive_scalar_by_array(expr: Expr, v: NDimArray) -> Expr:
+        return v.applyfunc(lambda x: expr.diff(x))
+
+    @staticmethod
+    def _call_derive_matrix_by_scalar(expr: MatrixCommon, v: Expr) -> Expr:
+        return _matrix_derivative(expr, v)
+
+    @staticmethod
+    def _call_derive_matexpr_by_scalar(expr: MatrixExpr, v: Expr) -> Expr:
+        return expr._eval_derivative(v)
+
+    @staticmethod
+    def _call_derive_array_by_scalar(expr: NDimArray, v: Expr) -> Expr:
+        return expr.applyfunc(lambda x: x.diff(v))
+
+    @staticmethod
+    def _call_derive_default(expr: Expr, v: Expr) -> Expr | None:
+        if expr.has(v):
+            return _matrix_derivative(expr, v)
+        else:
+            return None
+
+    @classmethod
+    def _dispatch_eval_derivative_n_times(cls, expr, v, count):
+        # Evaluate the derivative `n` times.  If
+        # `_eval_derivative_n_times` is not overridden by the current
+        # object, the default in `Basic` will call a loop over
+        # `_eval_derivative`:
+
+        if not isinstance(count, (int, Integer)) or ((count <= 0) == True):
+            return None
+
+        # TODO: this could be done with multiple-dispatching:
+        if expr.is_scalar:
+            if isinstance(v, MatrixCommon):
+                result = cls._call_derive_scalar_by_matrix(expr, v)
+            elif isinstance(v, MatrixExpr):
+                result = cls._call_derive_scalar_by_matexpr(expr, v)
+            elif isinstance(v, NDimArray):
+                result = cls._call_derive_scalar_by_array(expr, v)
+            elif v.is_scalar:
+                # scalar by scalar has a special
+                return super()._dispatch_eval_derivative_n_times(expr, v, count)
+            else:
+                return None
+        elif v.is_scalar:
+            if isinstance(expr, MatrixCommon):
+                result = cls._call_derive_matrix_by_scalar(expr, v)
+            elif isinstance(expr, MatrixExpr):
+                result = cls._call_derive_matexpr_by_scalar(expr, v)
+            elif isinstance(expr, NDimArray):
+                result = cls._call_derive_array_by_scalar(expr, v)
+            else:
+                return None
+        else:
+            # Both `expr` and `v` are some array/matrix type:
+            if isinstance(expr, MatrixCommon) or isinstance(expr, MatrixCommon):
+                result = derive_by_array(expr, v)
+            elif isinstance(expr, MatrixExpr) and isinstance(v, MatrixExpr):
+                result = cls._call_derive_default(expr, v)
+            elif isinstance(expr, MatrixExpr) or isinstance(v, MatrixExpr):
+                # if one expression is a symbolic matrix expression while the other isn't, don't evaluate:
+                return None
+            else:
+                result = derive_by_array(expr, v)
+        if result is None:
+            return None
+        if count == 1:
+            return result
+        else:
+            return cls._dispatch_eval_derivative_n_times(result, v, count - 1)

env-llmeval/lib/python3.10/site-packages/sympy/tensor/array/arrayop.py

@@ -0,0 +1,528 @@
+import itertools
+from collections.abc import Iterable
+
+from sympy.core._print_helpers import Printable
+from sympy.core.containers import Tuple
+from sympy.core.function import diff
+from sympy.core.singleton import S
+from sympy.core.sympify import _sympify
+
+from sympy.tensor.array.ndim_array import NDimArray
+from sympy.tensor.array.dense_ndim_array import DenseNDimArray, ImmutableDenseNDimArray
+from sympy.tensor.array.sparse_ndim_array import SparseNDimArray
+
+
+def _arrayfy(a):
+    from sympy.matrices import MatrixBase
+
+    if isinstance(a, NDimArray):
+        return a
+    if isinstance(a, (MatrixBase, list, tuple, Tuple)):
+        return ImmutableDenseNDimArray(a)
+    return a
+
+
+def tensorproduct(*args):
+    """
+    Tensor product among scalars or array-like objects.
+
+    The equivalent operator for array expressions is ``ArrayTensorProduct``,
+    which can be used to keep the expression unevaluated.
+
+    Examples
+    ========
+
+    >>> from sympy.tensor.array import tensorproduct, Array
+    >>> from sympy.abc import x, y, z, t
+    >>> A = Array([[1, 2], [3, 4]])
+    >>> B = Array([x, y])
+    >>> tensorproduct(A, B)
+    [[[x, y], [2*x, 2*y]], [[3*x, 3*y], [4*x, 4*y]]]
+    >>> tensorproduct(A, x)
+    [[x, 2*x], [3*x, 4*x]]
+    >>> tensorproduct(A, B, B)
+    [[[[x**2, x*y], [x*y, y**2]], [[2*x**2, 2*x*y], [2*x*y, 2*y**2]]], [[[3*x**2, 3*x*y], [3*x*y, 3*y**2]], [[4*x**2, 4*x*y], [4*x*y, 4*y**2]]]]
+
+    Applying this function on two matrices will result in a rank 4 array.
+
+    >>> from sympy import Matrix, eye
+    >>> m = Matrix([[x, y], [z, t]])
+    >>> p = tensorproduct(eye(3), m)
+    >>> p
+    [[[[x, y], [z, t]], [[0, 0], [0, 0]], [[0, 0], [0, 0]]], [[[0, 0], [0, 0]], [[x, y], [z, t]], [[0, 0], [0, 0]]], [[[0, 0], [0, 0]], [[0, 0], [0, 0]], [[x, y], [z, t]]]]
+
+    See Also
+    ========
+
+    sympy.tensor.array.expressions.array_expressions.ArrayTensorProduct
+
+    """
+    from sympy.tensor.array import SparseNDimArray, ImmutableSparseNDimArray
+
+    if len(args) == 0:
+        return S.One
+    if len(args) == 1:
+        return _arrayfy(args[0])
+    from sympy.tensor.array.expressions.array_expressions import _CodegenArrayAbstract
+    from sympy.tensor.array.expressions.array_expressions import ArrayTensorProduct
+    from sympy.tensor.array.expressions.array_expressions import _ArrayExpr
+    from sympy.matrices.expressions.matexpr import MatrixSymbol
+    if any(isinstance(arg, (_ArrayExpr, _CodegenArrayAbstract, MatrixSymbol)) for arg in args):
+        return ArrayTensorProduct(*args)
+    if len(args) > 2:
+        return tensorproduct(tensorproduct(args[0], args[1]), *args[2:])
+
+    # length of args is 2:
+    a, b = map(_arrayfy, args)
+
+    if not isinstance(a, NDimArray) or not isinstance(b, NDimArray):
+        return a*b
+
+    if isinstance(a, SparseNDimArray) and isinstance(b, SparseNDimArray):
+        lp = len(b)
+        new_array = {k1*lp + k2: v1*v2 for k1, v1 in a._sparse_array.items() for k2, v2 in b._sparse_array.items()}
+        return ImmutableSparseNDimArray(new_array, a.shape + b.shape)
+
+    product_list = [i*j for i in Flatten(a) for j in Flatten(b)]
+    return ImmutableDenseNDimArray(product_list, a.shape + b.shape)
+
+
+def _util_contraction_diagonal(array, *contraction_or_diagonal_axes):
+    array = _arrayfy(array)
+
+    # Verify contraction_axes:
+    taken_dims = set()
+    for axes_group in contraction_or_diagonal_axes:
+        if not isinstance(axes_group, Iterable):
+            raise ValueError("collections of contraction/diagonal axes expected")
+
+        dim = array.shape[axes_group[0]]
+
+        for d in axes_group:
+            if d in taken_dims:
+                raise ValueError("dimension specified more than once")
+            if dim != array.shape[d]:
+                raise ValueError("cannot contract or diagonalize between axes of different dimension")
+            taken_dims.add(d)
+
+    rank = array.rank()
+
+    remaining_shape = [dim for i, dim in enumerate(array.shape) if i not in taken_dims]
+    cum_shape = [0]*rank
+    _cumul = 1
+    for i in range(rank):
+        cum_shape[rank - i - 1] = _cumul
+        _cumul *= int(array.shape[rank - i - 1])
+
+    # DEFINITION: by absolute position it is meant the position along the one
+    # dimensional array containing all the tensor components.
+
+    # Possible future work on this module: move computation of absolute
+    # positions to a class method.
+
+    # Determine absolute positions of the uncontracted indices:
+    remaining_indices = [[cum_shape[i]*j for j in range(array.shape[i])]
+                         for i in range(rank) if i not in taken_dims]
+
+    # Determine absolute positions of the contracted indices:
+    summed_deltas = []
+    for axes_group in contraction_or_diagonal_axes:
+        lidx = []
+        for js in range(array.shape[axes_group[0]]):
+            lidx.append(sum([cum_shape[ig] * js for ig in axes_group]))
+        summed_deltas.append(lidx)
+
+    return array, remaining_indices, remaining_shape, summed_deltas
+
+
+def tensorcontraction(array, *contraction_axes):
+    """
+    Contraction of an array-like object on the specified axes.
+
+    The equivalent operator for array expressions is ``ArrayContraction``,
+    which can be used to keep the expression unevaluated.
+
+    Examples
+    ========
+
+    >>> from sympy import Array, tensorcontraction
+    >>> from sympy import Matrix, eye
+    >>> tensorcontraction(eye(3), (0, 1))
+    3
+    >>> A = Array(range(18), (3, 2, 3))
+    >>> A
+    [[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]], [[12, 13, 14], [15, 16, 17]]]
+    >>> tensorcontraction(A, (0, 2))
+    [21, 30]
+
+    Matrix multiplication may be emulated with a proper combination of
+    ``tensorcontraction`` and ``tensorproduct``
+
+    >>> from sympy import tensorproduct
+    >>> from sympy.abc import a,b,c,d,e,f,g,h
+    >>> m1 = Matrix([[a, b], [c, d]])
+    >>> m2 = Matrix([[e, f], [g, h]])
+    >>> p = tensorproduct(m1, m2)
+    >>> p
+    [[[[a*e, a*f], [a*g, a*h]], [[b*e, b*f], [b*g, b*h]]], [[[c*e, c*f], [c*g, c*h]], [[d*e, d*f], [d*g, d*h]]]]
+    >>> tensorcontraction(p, (1, 2))
+    [[a*e + b*g, a*f + b*h], [c*e + d*g, c*f + d*h]]
+    >>> m1*m2
+    Matrix([
+    [a*e + b*g, a*f + b*h],
+    [c*e + d*g, c*f + d*h]])
+
+    See Also
+    ========
+
+    sympy.tensor.array.expressions.array_expressions.ArrayContraction
+
+    """
+    from sympy.tensor.array.expressions.array_expressions import _array_contraction
+    from sympy.tensor.array.expressions.array_expressions import _CodegenArrayAbstract
+    from sympy.tensor.array.expressions.array_expressions import _ArrayExpr
+    from sympy.matrices.expressions.matexpr import MatrixSymbol
+    if isinstance(array, (_ArrayExpr, _CodegenArrayAbstract, MatrixSymbol)):
+        return _array_contraction(array, *contraction_axes)
+
+    array, remaining_indices, remaining_shape, summed_deltas = _util_contraction_diagonal(array, *contraction_axes)
+
+    # Compute the contracted array:
+    #
+    # 1. external for loops on all uncontracted indices.
+    #    Uncontracted indices are determined by the combinatorial product of
+    #    the absolute positions of the remaining indices.
+    # 2. internal loop on all contracted indices.
+    #    It sums the values of the absolute contracted index and the absolute
+    #    uncontracted index for the external loop.
+    contracted_array = []
+    for icontrib in itertools.product(*remaining_indices):
+        index_base_position = sum(icontrib)
+        isum = S.Zero
+        for sum_to_index in itertools.product(*summed_deltas):
+            idx = array._get_tuple_index(index_base_position + sum(sum_to_index))
+            isum += array[idx]
+
+        contracted_array.append(isum)
+
+    if len(remaining_indices) == 0:
+        assert len(contracted_array) == 1
+        return contracted_array[0]
+
+    return type(array)(contracted_array, remaining_shape)
+
+
+def tensordiagonal(array, *diagonal_axes):
+    """
+    Diagonalization of an array-like object on the specified axes.
+
+    This is equivalent to multiplying the expression by Kronecker deltas
+    uniting the axes.
+
+    The diagonal indices are put at the end of the axes.
+
+    The equivalent operator for array expressions is ``ArrayDiagonal``, which
+    can be used to keep the expression unevaluated.
+
+    Examples
+    ========
+
+    ``tensordiagonal`` acting on a 2-dimensional array by axes 0 and 1 is
+    equivalent to the diagonal of the matrix:
+
+    >>> from sympy import Array, tensordiagonal
+    >>> from sympy import Matrix, eye
+    >>> tensordiagonal(eye(3), (0, 1))
+    [1, 1, 1]
+
+    >>> from sympy.abc import a,b,c,d
+    >>> m1 = Matrix([[a, b], [c, d]])
+    >>> tensordiagonal(m1, [0, 1])
+    [a, d]
+
+    In case of higher dimensional arrays, the diagonalized out dimensions
+    are appended removed and appended as a single dimension at the end:
+
+    >>> A = Array(range(18), (3, 2, 3))
+    >>> A
+    [[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]], [[12, 13, 14], [15, 16, 17]]]
+    >>> tensordiagonal(A, (0, 2))
+    [[0, 7, 14], [3, 10, 17]]
+    >>> from sympy import permutedims
+    >>> tensordiagonal(A, (0, 2)) == permutedims(Array([A[0, :, 0], A[1, :, 1], A[2, :, 2]]), [1, 0])
+    True
+
+    See Also
+    ========
+
+    sympy.tensor.array.expressions.array_expressions.ArrayDiagonal
+
+    """
+    if any(len(i) <= 1 for i in diagonal_axes):
+        raise ValueError("need at least two axes to diagonalize")
+
+    from sympy.tensor.array.expressions.array_expressions import _ArrayExpr
+    from sympy.tensor.array.expressions.array_expressions import _CodegenArrayAbstract
+    from sympy.tensor.array.expressions.array_expressions import ArrayDiagonal, _array_diagonal
+    from sympy.matrices.expressions.matexpr import MatrixSymbol
+    if isinstance(array, (_ArrayExpr, _CodegenArrayAbstract, MatrixSymbol)):
+        return _array_diagonal(array, *diagonal_axes)
+
+    ArrayDiagonal._validate(array, *diagonal_axes)
+
+    array, remaining_indices, remaining_shape, diagonal_deltas = _util_contraction_diagonal(array, *diagonal_axes)
+
+    # Compute the diagonalized array:
+    #
+    # 1. external for loops on all undiagonalized indices.
+    #    Undiagonalized indices are determined by the combinatorial product of
+    #    the absolute positions of the remaining indices.
+    # 2. internal loop on all diagonal indices.
+    #    It appends the values of the absolute diagonalized index and the absolute
+    #    undiagonalized index for the external loop.
+    diagonalized_array = []
+    diagonal_shape = [len(i) for i in diagonal_deltas]
+    for icontrib in itertools.product(*remaining_indices):
+        index_base_position = sum(icontrib)
+        isum = []
+        for sum_to_index in itertools.product(*diagonal_deltas):
+            idx = array._get_tuple_index(index_base_position + sum(sum_to_index))
+            isum.append(array[idx])
+
+        isum = type(array)(isum).reshape(*diagonal_shape)
+        diagonalized_array.append(isum)
+
+    return type(array)(diagonalized_array, remaining_shape + diagonal_shape)
+
+
+def derive_by_array(expr, dx):
+    r"""
+    Derivative by arrays. Supports both arrays and scalars.
+
+    The equivalent operator for array expressions is ``array_derive``.
+
+    Explanation
+    ===========
+
+    Given the array `A_{i_1, \ldots, i_N}` and the array `X_{j_1, \ldots, j_M}`
+    this function will return a new array `B` defined by
+
+    `B_{j_1,\ldots,j_M,i_1,\ldots,i_N} := \frac{\partial A_{i_1,\ldots,i_N}}{\partial X_{j_1,\ldots,j_M}}`
+
+    Examples
+    ========
+
+    >>> from sympy import derive_by_array
+    >>> from sympy.abc import x, y, z, t
+    >>> from sympy import cos
+    >>> derive_by_array(cos(x*t), x)
+    -t*sin(t*x)
+    >>> derive_by_array(cos(x*t), [x, y, z, t])
+    [-t*sin(t*x), 0, 0, -x*sin(t*x)]
+    >>> derive_by_array([x, y**2*z], [[x, y], [z, t]])
+    [[[1, 0], [0, 2*y*z]], [[0, y**2], [0, 0]]]
+
+    """
+    from sympy.matrices import MatrixBase
+    from sympy.tensor.array import SparseNDimArray
+    array_types = (Iterable, MatrixBase, NDimArray)
+
+    if isinstance(dx, array_types):
+        dx = ImmutableDenseNDimArray(dx)
+        for i in dx:
+            if not i._diff_wrt:
+                raise ValueError("cannot derive by this array")
+
+    if isinstance(expr, array_types):
+        if isinstance(expr, NDimArray):
+            expr = expr.as_immutable()
+        else:
+            expr = ImmutableDenseNDimArray(expr)
+
+        if isinstance(dx, array_types):
+            if isinstance(expr, SparseNDimArray):
+                lp = len(expr)
+                new_array = {k + i*lp: v
+                             for i, x in enumerate(Flatten(dx))
+                             for k, v in expr.diff(x)._sparse_array.items()}
+            else:
+                new_array = [[y.diff(x) for y in Flatten(expr)] for x in Flatten(dx)]
+            return type(expr)(new_array, dx.shape + expr.shape)
+        else:
+            return expr.diff(dx)
+    else:
+        expr = _sympify(expr)
+        if isinstance(dx, array_types):
+            return ImmutableDenseNDimArray([expr.diff(i) for i in Flatten(dx)], dx.shape)
+        else:
+            dx = _sympify(dx)
+            return diff(expr, dx)
+
+
+def permutedims(expr, perm=None, index_order_old=None, index_order_new=None):
+    """
+    Permutes the indices of an array.
+
+    Parameter specifies the permutation of the indices.
+
+    The equivalent operator for array expressions is ``PermuteDims``, which can
+    be used to keep the expression unevaluated.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y, z, t
+    >>> from sympy import sin
+    >>> from sympy import Array, permutedims
+    >>> a = Array([[x, y, z], [t, sin(x), 0]])
+    >>> a
+    [[x, y, z], [t, sin(x), 0]]
+    >>> permutedims(a, (1, 0))
+    [[x, t], [y, sin(x)], [z, 0]]
+
+    If the array is of second order, ``transpose`` can be used:
+
+    >>> from sympy import transpose
+    >>> transpose(a)
+    [[x, t], [y, sin(x)], [z, 0]]
+
+    Examples on higher dimensions:
+
+    >>> b = Array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
+    >>> permutedims(b, (2, 1, 0))
+    [[[1, 5], [3, 7]], [[2, 6], [4, 8]]]
+    >>> permutedims(b, (1, 2, 0))
+    [[[1, 5], [2, 6]], [[3, 7], [4, 8]]]
+
+    An alternative way to specify the same permutations as in the previous
+    lines involves passing the *old* and *new* indices, either as a list or as
+    a string:
+
+    >>> permutedims(b, index_order_old="cba", index_order_new="abc")
+    [[[1, 5], [3, 7]], [[2, 6], [4, 8]]]
+    >>> permutedims(b, index_order_old="cab", index_order_new="abc")
+    [[[1, 5], [2, 6]], [[3, 7], [4, 8]]]
+
+    ``Permutation`` objects are also allowed:
+
+    >>> from sympy.combinatorics import Permutation
+    >>> permutedims(b, Permutation([1, 2, 0]))
+    [[[1, 5], [2, 6]], [[3, 7], [4, 8]]]
+
+    See Also
+    ========
+
+    sympy.tensor.array.expressions.array_expressions.PermuteDims
+
+    """
+    from sympy.tensor.array import SparseNDimArray
+
+    from sympy.tensor.array.expressions.array_expressions import _ArrayExpr
+    from sympy.tensor.array.expressions.array_expressions import _CodegenArrayAbstract
+    from sympy.tensor.array.expressions.array_expressions import _permute_dims
+    from sympy.matrices.expressions.matexpr import MatrixSymbol
+    from sympy.tensor.array.expressions import PermuteDims
+    from sympy.tensor.array.expressions.array_expressions import get_rank
+    perm = PermuteDims._get_permutation_from_arguments(perm, index_order_old, index_order_new, get_rank(expr))
+    if isinstance(expr, (_ArrayExpr, _CodegenArrayAbstract, MatrixSymbol)):
+        return _permute_dims(expr, perm)
+
+    if not isinstance(expr, NDimArray):
+        expr = ImmutableDenseNDimArray(expr)
+
+    from sympy.combinatorics import Permutation
+    if not isinstance(perm, Permutation):
+        perm = Permutation(list(perm))
+
+    if perm.size != expr.rank():
+        raise ValueError("wrong permutation size")
+
+    # Get the inverse permutation:
+    iperm = ~perm
+    new_shape = perm(expr.shape)
+
+    if isinstance(expr, SparseNDimArray):
+        return type(expr)({tuple(perm(expr._get_tuple_index(k))): v
+                           for k, v in expr._sparse_array.items()}, new_shape)
+
+    indices_span = perm([range(i) for i in expr.shape])
+
+    new_array = [None]*len(expr)
+    for i, idx in enumerate(itertools.product(*indices_span)):
+        t = iperm(idx)
+        new_array[i] = expr[t]
+
+    return type(expr)(new_array, new_shape)
+
+
+class Flatten(Printable):
+    """
+    Flatten an iterable object to a list in a lazy-evaluation way.
+
+    Notes
+    =====
+
+    This class is an iterator with which the memory cost can be economised.
+    Optimisation has been considered to ameliorate the performance for some
+    specific data types like DenseNDimArray and SparseNDimArray.
+
+    Examples
+    ========
+
+    >>> from sympy.tensor.array.arrayop import Flatten
+    >>> from sympy.tensor.array import Array
+    >>> A = Array(range(6)).reshape(2, 3)
+    >>> Flatten(A)
+    Flatten([[0, 1, 2], [3, 4, 5]])
+    >>> [i for i in Flatten(A)]
+    [0, 1, 2, 3, 4, 5]
+    """
+    def __init__(self, iterable):
+        from sympy.matrices.matrices import MatrixBase
+        from sympy.tensor.array import NDimArray
+
+        if not isinstance(iterable, (Iterable, MatrixBase)):
+            raise NotImplementedError("Data type not yet supported")
+
+        if isinstance(iterable, list):
+            iterable = NDimArray(iterable)
+
+        self._iter = iterable
+        self._idx = 0
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        from sympy.matrices.matrices import MatrixBase
+
+        if len(self._iter) > self._idx:
+            if isinstance(self._iter, DenseNDimArray):
+                result = self._iter._array[self._idx]
+
+            elif isinstance(self._iter, SparseNDimArray):
+                if self._idx in self._iter._sparse_array:
+                    result = self._iter._sparse_array[self._idx]
+                else:
+                    result = 0
+
+            elif isinstance(self._iter, MatrixBase):
+                result = self._iter[self._idx]
+
+            elif hasattr(self._iter, '__next__'):
+                result = next(self._iter)
+
+            else:
+                result = self._iter[self._idx]
+
+        else:
+            raise StopIteration
+
+        self._idx += 1
+        return result
+
+    def next(self):
+        return self.__next__()
+
+    def _sympystr(self, printer):
+        return type(self).__name__ + '(' + printer._print(self._iter) + ')'

env-llmeval/lib/python3.10/site-packages/sympy/tensor/array/dense_ndim_array.py

@@ -0,0 +1,206 @@
+import functools
+from typing import List
+
+from sympy.core.basic import Basic
+from sympy.core.containers import Tuple
+from sympy.core.singleton import S
+from sympy.core.sympify import _sympify
+from sympy.tensor.array.mutable_ndim_array import MutableNDimArray
+from sympy.tensor.array.ndim_array import NDimArray, ImmutableNDimArray, ArrayKind
+from sympy.utilities.iterables import flatten
+
+
+class DenseNDimArray(NDimArray):
+
+    _array: List[Basic]
+
+    def __new__(self, *args, **kwargs):
+        return ImmutableDenseNDimArray(*args, **kwargs)
+
+    @property
+    def kind(self) -> ArrayKind:
+        return ArrayKind._union(self._array)
+
+    def __getitem__(self, index):
+        """
+        Allows to get items from N-dim array.
+
+        Examples
+        ========
+
+        >>> from sympy import MutableDenseNDimArray
+        >>> a = MutableDenseNDimArray([0, 1, 2, 3], (2, 2))
+        >>> a
+        [[0, 1], [2, 3]]
+        >>> a[0, 0]
+        0
+        >>> a[1, 1]
+        3
+        >>> a[0]
+        [0, 1]
+        >>> a[1]
+        [2, 3]
+
+
+        Symbolic index:
+
+        >>> from sympy.abc import i, j
+        >>> a[i, j]
+        [[0, 1], [2, 3]][i, j]
+
+        Replace `i` and `j` to get element `(1, 1)`:
+
+        >>> a[i, j].subs({i: 1, j: 1})
+        3
+
+        """
+        syindex = self._check_symbolic_index(index)
+        if syindex is not None:
+            return syindex
+
+        index = self._check_index_for_getitem(index)
+
+        if isinstance(index, tuple) and any(isinstance(i, slice) for i in index):
+            sl_factors, eindices = self._get_slice_data_for_array_access(index)
+            array = [self._array[self._parse_index(i)] for i in eindices]
+            nshape = [len(el) for i, el in enumerate(sl_factors) if isinstance(index[i], slice)]
+            return type(self)(array, nshape)
+        else:
+            index = self._parse_index(index)
+            return self._array[index]
+
+    @classmethod
+    def zeros(cls, *shape):
+        list_length = functools.reduce(lambda x, y: x*y, shape, S.One)
+        return cls._new(([0]*list_length,), shape)
+
+    def tomatrix(self):
+        """
+        Converts MutableDenseNDimArray to Matrix. Can convert only 2-dim array, else will raise error.
+
+        Examples
+        ========
+
+        >>> from sympy import MutableDenseNDimArray
+        >>> a = MutableDenseNDimArray([1 for i in range(9)], (3, 3))
+        >>> b = a.tomatrix()
+        >>> b
+        Matrix([
+        [1, 1, 1],
+        [1, 1, 1],
+        [1, 1, 1]])
+
+        """
+        from sympy.matrices import Matrix
+
+        if self.rank() != 2:
+            raise ValueError('Dimensions must be of size of 2')
+
+        return Matrix(self.shape[0], self.shape[1], self._array)
+
+    def reshape(self, *newshape):
+        """
+        Returns MutableDenseNDimArray instance with new shape. Elements number
+        must be        suitable to new shape. The only argument of method sets
+        new shape.
+
+        Examples
+        ========
+
+        >>> from sympy import MutableDenseNDimArray
+        >>> a = MutableDenseNDimArray([1, 2, 3, 4, 5, 6], (2, 3))
+        >>> a.shape
+        (2, 3)
+        >>> a
+        [[1, 2, 3], [4, 5, 6]]
+        >>> b = a.reshape(3, 2)
+        >>> b.shape
+        (3, 2)
+        >>> b
+        [[1, 2], [3, 4], [5, 6]]
+
+        """
+        new_total_size = functools.reduce(lambda x,y: x*y, newshape)
+        if new_total_size != self._loop_size:
+            raise ValueError('Expecting reshape size to %d but got prod(%s) = %d' % (
+                self._loop_size, str(newshape), new_total_size))
+
+        # there is no `.func` as this class does not subtype `Basic`:
+        return type(self)(self._array, newshape)
+
+
+class ImmutableDenseNDimArray(DenseNDimArray, ImmutableNDimArray): # type: ignore
+    def __new__(cls, iterable, shape=None, **kwargs):
+        return cls._new(iterable, shape, **kwargs)
+
+    @classmethod
+    def _new(cls, iterable, shape, **kwargs):
+        shape, flat_list = cls._handle_ndarray_creation_inputs(iterable, shape, **kwargs)
+        shape = Tuple(*map(_sympify, shape))
+        cls._check_special_bounds(flat_list, shape)
+        flat_list = flatten(flat_list)
+        flat_list = Tuple(*flat_list)
+        self = Basic.__new__(cls, flat_list, shape, **kwargs)
+        self._shape = shape
+        self._array = list(flat_list)
+        self._rank = len(shape)
+        self._loop_size = functools.reduce(lambda x,y: x*y, shape, 1)
+        return self
+
+    def __setitem__(self, index, value):
+        raise TypeError('immutable N-dim array')
+
+    def as_mutable(self):
+        return MutableDenseNDimArray(self)
+
+    def _eval_simplify(self, **kwargs):
+        from sympy.simplify.simplify import simplify
+        return self.applyfunc(simplify)
+
+class MutableDenseNDimArray(DenseNDimArray, MutableNDimArray):
+
+    def __new__(cls, iterable=None, shape=None, **kwargs):
+        return cls._new(iterable, shape, **kwargs)
+
+    @classmethod
+    def _new(cls, iterable, shape, **kwargs):
+        shape, flat_list = cls._handle_ndarray_creation_inputs(iterable, shape, **kwargs)
+        flat_list = flatten(flat_list)
+        self = object.__new__(cls)
+        self._shape = shape
+        self._array = list(flat_list)
+        self._rank = len(shape)
+        self._loop_size = functools.reduce(lambda x,y: x*y, shape) if shape else len(flat_list)
+        return self
+
+    def __setitem__(self, index, value):
+        """Allows to set items to MutableDenseNDimArray.
+
+        Examples
+        ========
+
+        >>> from sympy import MutableDenseNDimArray
+        >>> a = MutableDenseNDimArray.zeros(2,  2)
+        >>> a[0,0] = 1
+        >>> a[1,1] = 1
+        >>> a
+        [[1, 0], [0, 1]]
+
+        """
+        if isinstance(index, tuple) and any(isinstance(i, slice) for i in index):
+            value, eindices, slice_offsets = self._get_slice_data_for_array_assignment(index, value)
+            for i in eindices:
+                other_i = [ind - j for ind, j in zip(i, slice_offsets) if j is not None]
+                self._array[self._parse_index(i)] = value[other_i]
+        else:
+            index = self._parse_index(index)
+            self._setter_iterable_check(value)
+            value = _sympify(value)
+            self._array[index] = value
+
+    def as_immutable(self):
+        return ImmutableDenseNDimArray(self)
+
+    @property
+    def free_symbols(self):
+        return {i for j in self._array for i in j.free_symbols}

env-llmeval/lib/python3.10/site-packages/sympy/tensor/array/expressions/__init__.py

@@ -0,0 +1,178 @@
+r"""
+Array expressions are expressions representing N-dimensional arrays, without
+evaluating them. These expressions represent in a certain way abstract syntax
+trees of operations on N-dimensional arrays.
+
+Every N-dimensional array operator has a corresponding array expression object.
+
+Table of correspondences:
+
+=============================== =============================
+         Array operator           Array expression operator
+=============================== =============================
+        tensorproduct                 ArrayTensorProduct
+        tensorcontraction             ArrayContraction
+        tensordiagonal                ArrayDiagonal
+        permutedims                   PermuteDims
+=============================== =============================
+
+Examples
+========
+
+``ArraySymbol`` objects are the N-dimensional equivalent of ``MatrixSymbol``
+objects in the matrix module:
+
+>>> from sympy.tensor.array.expressions import ArraySymbol
+>>> from sympy.abc import i, j, k
+>>> A = ArraySymbol("A", (3, 2, 4))
+>>> A.shape
+(3, 2, 4)
+>>> A[i, j, k]
+A[i, j, k]
+>>> A.as_explicit()
+[[[A[0, 0, 0], A[0, 0, 1], A[0, 0, 2], A[0, 0, 3]],
+  [A[0, 1, 0], A[0, 1, 1], A[0, 1, 2], A[0, 1, 3]]],
+ [[A[1, 0, 0], A[1, 0, 1], A[1, 0, 2], A[1, 0, 3]],
+  [A[1, 1, 0], A[1, 1, 1], A[1, 1, 2], A[1, 1, 3]]],
+ [[A[2, 0, 0], A[2, 0, 1], A[2, 0, 2], A[2, 0, 3]],
+  [A[2, 1, 0], A[2, 1, 1], A[2, 1, 2], A[2, 1, 3]]]]
+
+Component-explicit arrays can be added inside array expressions:
+
+>>> from sympy import Array
+>>> from sympy import tensorproduct
+>>> from sympy.tensor.array.expressions import ArrayTensorProduct
+>>> a = Array([1, 2, 3])
+>>> b = Array([i, j, k])
+>>> expr = ArrayTensorProduct(a, b, b)
+>>> expr
+ArrayTensorProduct([1, 2, 3], [i, j, k], [i, j, k])
+>>> expr.as_explicit() == tensorproduct(a, b, b)
+True
+
+Constructing array expressions from index-explicit forms
+--------------------------------------------------------
+
+Array expressions are index-implicit. This means they do not use any indices to
+represent array operations. The function ``convert_indexed_to_array( ... )``
+may be used to convert index-explicit expressions to array expressions.
+It takes as input two parameters: the index-explicit expression and the order
+of the indices:
+
+>>> from sympy.tensor.array.expressions import convert_indexed_to_array
+>>> from sympy import Sum
+>>> A = ArraySymbol("A", (3, 3))
+>>> B = ArraySymbol("B", (3, 3))
+>>> convert_indexed_to_array(A[i, j], [i, j])
+A
+>>> convert_indexed_to_array(A[i, j], [j, i])
+PermuteDims(A, (0 1))
+>>> convert_indexed_to_array(A[i, j] + B[j, i], [i, j])
+ArrayAdd(A, PermuteDims(B, (0 1)))
+>>> convert_indexed_to_array(Sum(A[i, j]*B[j, k], (j, 0, 2)), [i, k])
+ArrayContraction(ArrayTensorProduct(A, B), (1, 2))
+
+The diagonal of a matrix in the array expression form:
+
+>>> convert_indexed_to_array(A[i, i], [i])
+ArrayDiagonal(A, (0, 1))
+
+The trace of a matrix in the array expression form:
+
+>>> convert_indexed_to_array(Sum(A[i, i], (i, 0, 2)), [i])
+ArrayContraction(A, (0, 1))
+
+Compatibility with matrices
+---------------------------
+
+Array expressions can be mixed with objects from the matrix module:
+
+>>> from sympy import MatrixSymbol
+>>> from sympy.tensor.array.expressions import ArrayContraction
+>>> M = MatrixSymbol("M", 3, 3)
+>>> N = MatrixSymbol("N", 3, 3)
+
+Express the matrix product in the array expression form:
+
+>>> from sympy.tensor.array.expressions import convert_matrix_to_array
+>>> expr = convert_matrix_to_array(M*N)
+>>> expr
+ArrayContraction(ArrayTensorProduct(M, N), (1, 2))
+
+The expression can be converted back to matrix form:
+
+>>> from sympy.tensor.array.expressions import convert_array_to_matrix
+>>> convert_array_to_matrix(expr)
+M*N
+
+Add a second contraction on the remaining axes in order to get the trace of `M \cdot N`:
+
+>>> expr_tr = ArrayContraction(expr, (0, 1))
+>>> expr_tr
+ArrayContraction(ArrayContraction(ArrayTensorProduct(M, N), (1, 2)), (0, 1))
+
+Flatten the expression by calling ``.doit()`` and remove the nested array contraction operations:
+
+>>> expr_tr.doit()
+ArrayContraction(ArrayTensorProduct(M, N), (0, 3), (1, 2))
+
+Get the explicit form of the array expression:
+
+>>> expr.as_explicit()
+[[M[0, 0]*N[0, 0] + M[0, 1]*N[1, 0] + M[0, 2]*N[2, 0], M[0, 0]*N[0, 1] + M[0, 1]*N[1, 1] + M[0, 2]*N[2, 1], M[0, 0]*N[0, 2] + M[0, 1]*N[1, 2] + M[0, 2]*N[2, 2]],
+ [M[1, 0]*N[0, 0] + M[1, 1]*N[1, 0] + M[1, 2]*N[2, 0], M[1, 0]*N[0, 1] + M[1, 1]*N[1, 1] + M[1, 2]*N[2, 1], M[1, 0]*N[0, 2] + M[1, 1]*N[1, 2] + M[1, 2]*N[2, 2]],
+ [M[2, 0]*N[0, 0] + M[2, 1]*N[1, 0] + M[2, 2]*N[2, 0], M[2, 0]*N[0, 1] + M[2, 1]*N[1, 1] + M[2, 2]*N[2, 1], M[2, 0]*N[0, 2] + M[2, 1]*N[1, 2] + M[2, 2]*N[2, 2]]]
+
+Express the trace of a matrix:
+
+>>> from sympy import Trace
+>>> convert_matrix_to_array(Trace(M))
+ArrayContraction(M, (0, 1))
+>>> convert_matrix_to_array(Trace(M*N))
+ArrayContraction(ArrayTensorProduct(M, N), (0, 3), (1, 2))
+
+Express the transposition of a matrix (will be expressed as a permutation of the axes:
+
+>>> convert_matrix_to_array(M.T)
+PermuteDims(M, (0 1))
+
+Compute the derivative array expressions:
+
+>>> from sympy.tensor.array.expressions import array_derive
+>>> d = array_derive(M, M)
+>>> d
+PermuteDims(ArrayTensorProduct(I, I), (3)(1 2))
+
+Verify that the derivative corresponds to the form computed with explicit matrices:
+
+>>> d.as_explicit()
+[[[[1, 0, 0], [0, 0, 0], [0, 0, 0]], [[0, 1, 0], [0, 0, 0], [0, 0, 0]], [[0, 0, 1], [0, 0, 0], [0, 0, 0]]], [[[0, 0, 0], [1, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 1, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 1], [0, 0, 0]]], [[[0, 0, 0], [0, 0, 0], [1, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 1, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 1]]]]
+>>> Me = M.as_explicit()
+>>> Me.diff(Me)
+[[[[1, 0, 0], [0, 0, 0], [0, 0, 0]], [[0, 1, 0], [0, 0, 0], [0, 0, 0]], [[0, 0, 1], [0, 0, 0], [0, 0, 0]]], [[[0, 0, 0], [1, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 1, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 1], [0, 0, 0]]], [[[0, 0, 0], [0, 0, 0], [1, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 1, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 1]]]]
+
+"""
+
+__all__ = [
+    "ArraySymbol", "ArrayElement", "ZeroArray", "OneArray",
+    "ArrayTensorProduct",
+    "ArrayContraction",
+    "ArrayDiagonal",
+    "PermuteDims",
+    "ArrayAdd",
+    "ArrayElementwiseApplyFunc",
+    "Reshape",
+    "convert_array_to_matrix",
+    "convert_matrix_to_array",
+    "convert_array_to_indexed",
+    "convert_indexed_to_array",
+    "array_derive",
+]
+
+from sympy.tensor.array.expressions.array_expressions import ArrayTensorProduct, ArrayAdd, PermuteDims, ArrayDiagonal, \
+    ArrayContraction, Reshape, ArraySymbol, ArrayElement, ZeroArray, OneArray, ArrayElementwiseApplyFunc
+from sympy.tensor.array.expressions.arrayexpr_derivatives import array_derive
+from sympy.tensor.array.expressions.from_array_to_indexed import convert_array_to_indexed
+from sympy.tensor.array.expressions.from_array_to_matrix import convert_array_to_matrix
+from sympy.tensor.array.expressions.from_indexed_to_array import convert_indexed_to_array
+from sympy.tensor.array.expressions.from_matrix_to_array import convert_matrix_to_array

env-llmeval/lib/python3.10/site-packages/sympy/tensor/array/expressions/arrayexpr_derivatives.py

@@ -0,0 +1,194 @@
+import operator
+from functools import reduce, singledispatch
+
+from sympy.core.expr import Expr
+from sympy.core.singleton import S
+from sympy.matrices.expressions.hadamard import HadamardProduct
+from sympy.matrices.expressions.inverse import Inverse
+from sympy.matrices.expressions.matexpr import (MatrixExpr, MatrixSymbol)
+from sympy.matrices.expressions.special import Identity, OneMatrix
+from sympy.matrices.expressions.transpose import Transpose
+from sympy.combinatorics.permutations import _af_invert
+from sympy.matrices.expressions.applyfunc import ElementwiseApplyFunction
+from sympy.tensor.array.expressions.array_expressions import (
+    _ArrayExpr, ZeroArray, ArraySymbol, ArrayTensorProduct, ArrayAdd,
+    PermuteDims, ArrayDiagonal, ArrayElementwiseApplyFunc, get_rank,
+    get_shape, ArrayContraction, _array_tensor_product, _array_contraction,
+    _array_diagonal, _array_add, _permute_dims, Reshape)
+from sympy.tensor.array.expressions.from_matrix_to_array import convert_matrix_to_array
+
+
+@singledispatch
+def array_derive(expr, x):
+    """
+    Derivatives (gradients) for array expressions.
+    """
+    raise NotImplementedError(f"not implemented for type {type(expr)}")
+
+
+@array_derive.register(Expr)
+def _(expr: Expr, x: _ArrayExpr):
+    return ZeroArray(*x.shape)
+
+
+@array_derive.register(ArrayTensorProduct)
+def _(expr: ArrayTensorProduct, x: Expr):
+    args = expr.args
+    addend_list = []
+    for i, arg in enumerate(expr.args):
+        darg = array_derive(arg, x)
+        if darg == 0:
+            continue
+        args_prev = args[:i]
+        args_succ = args[i+1:]
+        shape_prev = reduce(operator.add, map(get_shape, args_prev), ())
+        shape_succ = reduce(operator.add, map(get_shape, args_succ), ())
+        addend = _array_tensor_product(*args_prev, darg, *args_succ)
+        tot1 = len(get_shape(x))
+        tot2 = tot1 + len(shape_prev)
+        tot3 = tot2 + len(get_shape(arg))
+        tot4 = tot3 + len(shape_succ)
+        perm = list(range(tot1, tot2)) + \
+               list(range(tot1)) + list(range(tot2, tot3)) + \
+               list(range(tot3, tot4))
+        addend = _permute_dims(addend, _af_invert(perm))
+        addend_list.append(addend)
+    if len(addend_list) == 1:
+        return addend_list[0]
+    elif len(addend_list) == 0:
+        return S.Zero
+    else:
+        return _array_add(*addend_list)
+
+
+@array_derive.register(ArraySymbol)
+def _(expr: ArraySymbol, x: _ArrayExpr):
+    if expr == x:
+        return _permute_dims(
+            ArrayTensorProduct.fromiter(Identity(i) for i in expr.shape),
+            [2*i for i in range(len(expr.shape))] + [2*i+1 for i in range(len(expr.shape))]
+        )
+    return ZeroArray(*(x.shape + expr.shape))
+
+
+@array_derive.register(MatrixSymbol)
+def _(expr: MatrixSymbol, x: _ArrayExpr):
+    m, n = expr.shape
+    if expr == x:
+        return _permute_dims(
+            _array_tensor_product(Identity(m), Identity(n)),
+            [0, 2, 1, 3]
+        )
+    return ZeroArray(*(x.shape + expr.shape))
+
+
+@array_derive.register(Identity)
+def _(expr: Identity, x: _ArrayExpr):
+    return ZeroArray(*(x.shape + expr.shape))
+
+
+@array_derive.register(OneMatrix)
+def _(expr: OneMatrix, x: _ArrayExpr):
+    return ZeroArray(*(x.shape + expr.shape))
+
+
+@array_derive.register(Transpose)
+def _(expr: Transpose, x: Expr):
+    # D(A.T, A) ==> (m,n,i,j) ==> D(A_ji, A_mn) = d_mj d_ni
+    # D(B.T, A) ==> (m,n,i,j) ==> D(B_ji, A_mn)
+    fd = array_derive(expr.arg, x)
+    return _permute_dims(fd, [0, 1, 3, 2])
+
+
+@array_derive.register(Inverse)
+def _(expr: Inverse, x: Expr):
+    mat = expr.I
+    dexpr = array_derive(mat, x)
+    tp = _array_tensor_product(-expr, dexpr, expr)
+    mp = _array_contraction(tp, (1, 4), (5, 6))
+    pp = _permute_dims(mp, [1, 2, 0, 3])
+    return pp
+
+
+@array_derive.register(ElementwiseApplyFunction)
+def _(expr: ElementwiseApplyFunction, x: Expr):
+    assert get_rank(expr) == 2
+    assert get_rank(x) == 2
+    fdiff = expr._get_function_fdiff()
+    dexpr = array_derive(expr.expr, x)
+    tp = _array_tensor_product(
+        ElementwiseApplyFunction(fdiff, expr.expr),
+        dexpr
+    )
+    td = _array_diagonal(
+        tp, (0, 4), (1, 5)
+    )
+    return td
+
+
+@array_derive.register(ArrayElementwiseApplyFunc)
+def _(expr: ArrayElementwiseApplyFunc, x: Expr):
+    fdiff = expr._get_function_fdiff()
+    subexpr = expr.expr
+    dsubexpr = array_derive(subexpr, x)
+    tp = _array_tensor_product(
+        dsubexpr,
+        ArrayElementwiseApplyFunc(fdiff, subexpr)
+    )
+    b = get_rank(x)
+    c = get_rank(expr)
+    diag_indices = [(b + i, b + c + i) for i in range(c)]
+    return _array_diagonal(tp, *diag_indices)
+
+
+@array_derive.register(MatrixExpr)
+def _(expr: MatrixExpr, x: Expr):
+    cg = convert_matrix_to_array(expr)
+    return array_derive(cg, x)
+
+
+@array_derive.register(HadamardProduct)
+def _(expr: HadamardProduct, x: Expr):
+    raise NotImplementedError()
+
+
+@array_derive.register(ArrayContraction)
+def _(expr: ArrayContraction, x: Expr):
+    fd = array_derive(expr.expr, x)
+    rank_x = len(get_shape(x))
+    contraction_indices = expr.contraction_indices
+    new_contraction_indices = [tuple(j + rank_x for j in i) for i in contraction_indices]
+    return _array_contraction(fd, *new_contraction_indices)
+
+
+@array_derive.register(ArrayDiagonal)
+def _(expr: ArrayDiagonal, x: Expr):
+    dsubexpr = array_derive(expr.expr, x)
+    rank_x = len(get_shape(x))
+    diag_indices = [[j + rank_x for j in i] for i in expr.diagonal_indices]
+    return _array_diagonal(dsubexpr, *diag_indices)
+
+
+@array_derive.register(ArrayAdd)
+def _(expr: ArrayAdd, x: Expr):
+    return _array_add(*[array_derive(arg, x) for arg in expr.args])
+
+
+@array_derive.register(PermuteDims)
+def _(expr: PermuteDims, x: Expr):
+    de = array_derive(expr.expr, x)
+    perm = [0, 1] + [i + 2 for i in expr.permutation.array_form]
+    return _permute_dims(de, perm)
+
+
+@array_derive.register(Reshape)
+def _(expr: Reshape, x: Expr):
+    de = array_derive(expr.expr, x)
+    return Reshape(de, get_shape(x) + expr.shape)
+
+
+def matrix_derive(expr, x):
+    from sympy.tensor.array.expressions.from_array_to_matrix import convert_array_to_matrix
+    ce = convert_matrix_to_array(expr)
+    dce = array_derive(ce, x)
+    return convert_array_to_matrix(dce).doit()