Add files using upload-large-folder tool

ckpts/universal/global_step80/zero/20.mlp.dense_h_to_4h.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:22fca2a333686e5de2f3b3e80533256452bbbd17bc1b55791ab9b55c33b9b53c
+size 33555612

venv/lib/python3.10/site-packages/sympy/utilities/__init__.py

@@ -0,0 +1,30 @@
+"""This module contains some general purpose utilities that are used across
+SymPy.
+"""
+from .iterables import (flatten, group, take, subsets,
+    variations, numbered_symbols, cartes, capture, dict_merge,
+    prefixes, postfixes, sift, topological_sort, unflatten,
+    has_dups, has_variety, reshape, rotations)
+
+from .misc import filldedent
+
+from .lambdify import lambdify
+
+from .decorator import threaded, xthreaded, public, memoize_property
+
+from .timeutils import timed
+
+__all__ = [
+    'flatten', 'group', 'take', 'subsets', 'variations', 'numbered_symbols',
+    'cartes', 'capture', 'dict_merge', 'prefixes', 'postfixes', 'sift',
+    'topological_sort', 'unflatten', 'has_dups', 'has_variety', 'reshape',
+    'rotations',
+
+    'filldedent',
+
+    'lambdify',
+
+    'threaded', 'xthreaded', 'public', 'memoize_property',
+
+    'timed',
+]

venv/lib/python3.10/site-packages/sympy/utilities/autowrap.py

@@ -0,0 +1,1129 @@
+"""Module for compiling codegen output, and wrap the binary for use in
+python.
+
+.. note:: To use the autowrap module it must first be imported
+
+   >>> from sympy.utilities.autowrap import autowrap
+
+This module provides a common interface for different external backends, such
+as f2py, fwrap, Cython, SWIG(?) etc. (Currently only f2py and Cython are
+implemented) The goal is to provide access to compiled binaries of acceptable
+performance with a one-button user interface, e.g.,
+
+    >>> from sympy.abc import x,y
+    >>> expr = (x - y)**25
+    >>> flat = expr.expand()
+    >>> binary_callable = autowrap(flat)
+    >>> binary_callable(2, 3)
+    -1.0
+
+Although a SymPy user might primarily be interested in working with
+mathematical expressions and not in the details of wrapping tools
+needed to evaluate such expressions efficiently in numerical form,
+the user cannot do so without some understanding of the
+limits in the target language. For example, the expanded expression
+contains large coefficients which result in loss of precision when
+computing the expression:
+
+    >>> binary_callable(3, 2)
+    0.0
+    >>> binary_callable(4, 5), binary_callable(5, 4)
+    (-22925376.0, 25165824.0)
+
+Wrapping the unexpanded expression gives the expected behavior:
+
+    >>> e = autowrap(expr)
+    >>> e(4, 5), e(5, 4)
+    (-1.0, 1.0)
+
+The callable returned from autowrap() is a binary Python function, not a
+SymPy object.  If it is desired to use the compiled function in symbolic
+expressions, it is better to use binary_function() which returns a SymPy
+Function object.  The binary callable is attached as the _imp_ attribute and
+invoked when a numerical evaluation is requested with evalf(), or with
+lambdify().
+
+    >>> from sympy.utilities.autowrap import binary_function
+    >>> f = binary_function('f', expr)
+    >>> 2*f(x, y) + y
+    y + 2*f(x, y)
+    >>> (2*f(x, y) + y).evalf(2, subs={x: 1, y:2})
+    0.e-110
+
+When is this useful?
+
+    1) For computations on large arrays, Python iterations may be too slow,
+       and depending on the mathematical expression, it may be difficult to
+       exploit the advanced index operations provided by NumPy.
+
+    2) For *really* long expressions that will be called repeatedly, the
+       compiled binary should be significantly faster than SymPy's .evalf()
+
+    3) If you are generating code with the codegen utility in order to use
+       it in another project, the automatic Python wrappers let you test the
+       binaries immediately from within SymPy.
+
+    4) To create customized ufuncs for use with numpy arrays.
+       See *ufuncify*.
+
+When is this module NOT the best approach?
+
+    1) If you are really concerned about speed or memory optimizations,
+       you will probably get better results by working directly with the
+       wrapper tools and the low level code.  However, the files generated
+       by this utility may provide a useful starting point and reference
+       code. Temporary files will be left intact if you supply the keyword
+       tempdir="path/to/files/".
+
+    2) If the array computation can be handled easily by numpy, and you
+       do not need the binaries for another project.
+
+"""
+
+import sys
+import os
+import shutil
+import tempfile
+from subprocess import STDOUT, CalledProcessError, check_output
+from string import Template
+from warnings import warn
+
+from sympy.core.cache import cacheit
+from sympy.core.function import Lambda
+from sympy.core.relational import Eq
+from sympy.core.symbol import Dummy, Symbol
+from sympy.tensor.indexed import Idx, IndexedBase
+from sympy.utilities.codegen import (make_routine, get_code_generator,
+                                     OutputArgument, InOutArgument,
+                                     InputArgument, CodeGenArgumentListError,
+                                     Result, ResultBase, C99CodeGen)
+from sympy.utilities.iterables import iterable
+from sympy.utilities.lambdify import implemented_function
+from sympy.utilities.decorator import doctest_depends_on
+
+_doctest_depends_on = {'exe': ('f2py', 'gfortran', 'gcc'),
+                       'modules': ('numpy',)}
+
+
+class CodeWrapError(Exception):
+    pass
+
+
+class CodeWrapper:
+    """Base Class for code wrappers"""
+    _filename = "wrapped_code"
+    _module_basename = "wrapper_module"
+    _module_counter = 0
+
+    @property
+    def filename(self):
+        return "%s_%s" % (self._filename, CodeWrapper._module_counter)
+
+    @property
+    def module_name(self):
+        return "%s_%s" % (self._module_basename, CodeWrapper._module_counter)
+
+    def __init__(self, generator, filepath=None, flags=[], verbose=False):
+        """
+        generator -- the code generator to use
+        """
+        self.generator = generator
+        self.filepath = filepath
+        self.flags = flags
+        self.quiet = not verbose
+
+    @property
+    def include_header(self):
+        return bool(self.filepath)
+
+    @property
+    def include_empty(self):
+        return bool(self.filepath)
+
+    def _generate_code(self, main_routine, routines):
+        routines.append(main_routine)
+        self.generator.write(
+            routines, self.filename, True, self.include_header,
+            self.include_empty)
+
+    def wrap_code(self, routine, helpers=None):
+        helpers = helpers or []
+        if self.filepath:
+            workdir = os.path.abspath(self.filepath)
+        else:
+            workdir = tempfile.mkdtemp("_sympy_compile")
+        if not os.access(workdir, os.F_OK):
+            os.mkdir(workdir)
+        oldwork = os.getcwd()
+        os.chdir(workdir)
+        try:
+            sys.path.append(workdir)
+            self._generate_code(routine, helpers)
+            self._prepare_files(routine)
+            self._process_files(routine)
+            mod = __import__(self.module_name)
+        finally:
+            sys.path.remove(workdir)
+            CodeWrapper._module_counter += 1
+            os.chdir(oldwork)
+            if not self.filepath:
+                try:
+                    shutil.rmtree(workdir)
+                except OSError:
+                    # Could be some issues on Windows
+                    pass
+
+        return self._get_wrapped_function(mod, routine.name)
+
+    def _process_files(self, routine):
+        command = self.command
+        command.extend(self.flags)
+        try:
+            retoutput = check_output(command, stderr=STDOUT)
+        except CalledProcessError as e:
+            raise CodeWrapError(
+                "Error while executing command: %s. Command output is:\n%s" % (
+                    " ".join(command), e.output.decode('utf-8')))
+        if not self.quiet:
+            print(retoutput)
+
+
+class DummyWrapper(CodeWrapper):
+    """Class used for testing independent of backends """
+
+    template = """# dummy module for testing of SymPy
+def %(name)s():
+    return "%(expr)s"
+%(name)s.args = "%(args)s"
+%(name)s.returns = "%(retvals)s"
+"""
+
+    def _prepare_files(self, routine):
+        return
+
+    def _generate_code(self, routine, helpers):
+        with open('%s.py' % self.module_name, 'w') as f:
+            printed = ", ".join(
+                [str(res.expr) for res in routine.result_variables])
+            # convert OutputArguments to return value like f2py
+            args = filter(lambda x: not isinstance(
+                x, OutputArgument), routine.arguments)
+            retvals = []
+            for val in routine.result_variables:
+                if isinstance(val, Result):
+                    retvals.append('nameless')
+                else:
+                    retvals.append(val.result_var)
+
+            print(DummyWrapper.template % {
+                'name': routine.name,
+                'expr': printed,
+                'args': ", ".join([str(a.name) for a in args]),
+                'retvals': ", ".join([str(val) for val in retvals])
+            }, end="", file=f)
+
+    def _process_files(self, routine):
+        return
+
+    @classmethod
+    def _get_wrapped_function(cls, mod, name):
+        return getattr(mod, name)
+
+
+class CythonCodeWrapper(CodeWrapper):
+    """Wrapper that uses Cython"""
+
+    setup_template = """\
+from setuptools import setup
+from setuptools import Extension
+from Cython.Build import cythonize
+cy_opts = {cythonize_options}
+{np_import}
+ext_mods = [Extension(
+    {ext_args},
+    include_dirs={include_dirs},
+    library_dirs={library_dirs},
+    libraries={libraries},
+    extra_compile_args={extra_compile_args},
+    extra_link_args={extra_link_args}
+)]
+setup(ext_modules=cythonize(ext_mods, **cy_opts))
+"""
+
+    _cythonize_options = {'compiler_directives':{'language_level' : "3"}}
+
+    pyx_imports = (
+        "import numpy as np\n"
+        "cimport numpy as np\n\n")
+
+    pyx_header = (
+        "cdef extern from '{header_file}.h':\n"
+        "    {prototype}\n\n")
+
+    pyx_func = (
+        "def {name}_c({arg_string}):\n"
+        "\n"
+        "{declarations}"
+        "{body}")
+
+    std_compile_flag = '-std=c99'
+
+    def __init__(self, *args, **kwargs):
+        """Instantiates a Cython code wrapper.
+
+        The following optional parameters get passed to ``setuptools.Extension``
+        for building the Python extension module. Read its documentation to
+        learn more.
+
+        Parameters
+        ==========
+        include_dirs : [list of strings]
+            A list of directories to search for C/C++ header files (in Unix
+            form for portability).
+        library_dirs : [list of strings]
+            A list of directories to search for C/C++ libraries at link time.
+        libraries : [list of strings]
+            A list of library names (not filenames or paths) to link against.
+        extra_compile_args : [list of strings]
+            Any extra platform- and compiler-specific information to use when
+            compiling the source files in 'sources'.  For platforms and
+            compilers where "command line" makes sense, this is typically a
+            list of command-line arguments, but for other platforms it could be
+            anything. Note that the attribute ``std_compile_flag`` will be
+            appended to this list.
+        extra_link_args : [list of strings]
+            Any extra platform- and compiler-specific information to use when
+            linking object files together to create the extension (or to create
+            a new static Python interpreter). Similar interpretation as for
+            'extra_compile_args'.
+        cythonize_options : [dictionary]
+            Keyword arguments passed on to cythonize.
+
+        """
+
+        self._include_dirs = kwargs.pop('include_dirs', [])
+        self._library_dirs = kwargs.pop('library_dirs', [])
+        self._libraries = kwargs.pop('libraries', [])
+        self._extra_compile_args = kwargs.pop('extra_compile_args', [])
+        self._extra_compile_args.append(self.std_compile_flag)
+        self._extra_link_args = kwargs.pop('extra_link_args', [])
+        self._cythonize_options = kwargs.pop('cythonize_options', self._cythonize_options)
+
+        self._need_numpy = False
+
+        super().__init__(*args, **kwargs)
+
+    @property
+    def command(self):
+        command = [sys.executable, "setup.py", "build_ext", "--inplace"]
+        return command
+
+    def _prepare_files(self, routine, build_dir=os.curdir):
+        # NOTE : build_dir is used for testing purposes.
+        pyxfilename = self.module_name + '.pyx'
+        codefilename = "%s.%s" % (self.filename, self.generator.code_extension)
+
+        # pyx
+        with open(os.path.join(build_dir, pyxfilename), 'w') as f:
+            self.dump_pyx([routine], f, self.filename)
+
+        # setup.py
+        ext_args = [repr(self.module_name), repr([pyxfilename, codefilename])]
+        if self._need_numpy:
+            np_import = 'import numpy as np\n'
+            self._include_dirs.append('np.get_include()')
+        else:
+            np_import = ''
+
+        with open(os.path.join(build_dir, 'setup.py'), 'w') as f:
+            includes = str(self._include_dirs).replace("'np.get_include()'",
+                                                       'np.get_include()')
+            f.write(self.setup_template.format(
+                ext_args=", ".join(ext_args),
+                np_import=np_import,
+                include_dirs=includes,
+                library_dirs=self._library_dirs,
+                libraries=self._libraries,
+                extra_compile_args=self._extra_compile_args,
+                extra_link_args=self._extra_link_args,
+                cythonize_options=self._cythonize_options
+            ))
+
+    @classmethod
+    def _get_wrapped_function(cls, mod, name):
+        return getattr(mod, name + '_c')
+
+    def dump_pyx(self, routines, f, prefix):
+        """Write a Cython file with Python wrappers
+
+        This file contains all the definitions of the routines in c code and
+        refers to the header file.
+
+        Arguments
+        ---------
+        routines
+            List of Routine instances
+        f
+            File-like object to write the file to
+        prefix
+            The filename prefix, used to refer to the proper header file.
+            Only the basename of the prefix is used.
+        """
+        headers = []
+        functions = []
+        for routine in routines:
+            prototype = self.generator.get_prototype(routine)
+
+            # C Function Header Import
+            headers.append(self.pyx_header.format(header_file=prefix,
+                                                  prototype=prototype))
+
+            # Partition the C function arguments into categories
+            py_rets, py_args, py_loc, py_inf = self._partition_args(routine.arguments)
+
+            # Function prototype
+            name = routine.name
+            arg_string = ", ".join(self._prototype_arg(arg) for arg in py_args)
+
+            # Local Declarations
+            local_decs = []
+            for arg, val in py_inf.items():
+                proto = self._prototype_arg(arg)
+                mat, ind = [self._string_var(v) for v in val]
+                local_decs.append("    cdef {} = {}.shape[{}]".format(proto, mat, ind))
+            local_decs.extend(["    cdef {}".format(self._declare_arg(a)) for a in py_loc])
+            declarations = "\n".join(local_decs)
+            if declarations:
+                declarations = declarations + "\n"
+
+            # Function Body
+            args_c = ", ".join([self._call_arg(a) for a in routine.arguments])
+            rets = ", ".join([self._string_var(r.name) for r in py_rets])
+            if routine.results:
+                body = '    return %s(%s)' % (routine.name, args_c)
+                if rets:
+                    body = body + ', ' + rets
+            else:
+                body = '    %s(%s)\n' % (routine.name, args_c)
+                body = body + '    return ' + rets
+
+            functions.append(self.pyx_func.format(name=name, arg_string=arg_string,
+                    declarations=declarations, body=body))
+
+        # Write text to file
+        if self._need_numpy:
+            # Only import numpy if required
+            f.write(self.pyx_imports)
+        f.write('\n'.join(headers))
+        f.write('\n'.join(functions))
+
+    def _partition_args(self, args):
+        """Group function arguments into categories."""
+        py_args = []
+        py_returns = []
+        py_locals = []
+        py_inferred = {}
+        for arg in args:
+            if isinstance(arg, OutputArgument):
+                py_returns.append(arg)
+                py_locals.append(arg)
+            elif isinstance(arg, InOutArgument):
+                py_returns.append(arg)
+                py_args.append(arg)
+            else:
+                py_args.append(arg)
+        # Find arguments that are array dimensions. These can be inferred
+        # locally in the Cython code.
+            if isinstance(arg, (InputArgument, InOutArgument)) and arg.dimensions:
+                dims = [d[1] + 1 for d in arg.dimensions]
+                sym_dims = [(i, d) for (i, d) in enumerate(dims) if
+                            isinstance(d, Symbol)]
+                for (i, d) in sym_dims:
+                    py_inferred[d] = (arg.name, i)
+        for arg in args:
+            if arg.name in py_inferred:
+                py_inferred[arg] = py_inferred.pop(arg.name)
+        # Filter inferred arguments from py_args
+        py_args = [a for a in py_args if a not in py_inferred]
+        return py_returns, py_args, py_locals, py_inferred
+
+    def _prototype_arg(self, arg):
+        mat_dec = "np.ndarray[{mtype}, ndim={ndim}] {name}"
+        np_types = {'double': 'np.double_t',
+                    'int': 'np.int_t'}
+        t = arg.get_datatype('c')
+        if arg.dimensions:
+            self._need_numpy = True
+            ndim = len(arg.dimensions)
+            mtype = np_types[t]
+            return mat_dec.format(mtype=mtype, ndim=ndim, name=self._string_var(arg.name))
+        else:
+            return "%s %s" % (t, self._string_var(arg.name))
+
+    def _declare_arg(self, arg):
+        proto = self._prototype_arg(arg)
+        if arg.dimensions:
+            shape = '(' + ','.join(self._string_var(i[1] + 1) for i in arg.dimensions) + ')'
+            return proto + " = np.empty({shape})".format(shape=shape)
+        else:
+            return proto + " = 0"
+
+    def _call_arg(self, arg):
+        if arg.dimensions:
+            t = arg.get_datatype('c')
+            return "<{}*> {}.data".format(t, self._string_var(arg.name))
+        elif isinstance(arg, ResultBase):
+            return "&{}".format(self._string_var(arg.name))
+        else:
+            return self._string_var(arg.name)
+
+    def _string_var(self, var):
+        printer = self.generator.printer.doprint
+        return printer(var)
+
+
+class F2PyCodeWrapper(CodeWrapper):
+    """Wrapper that uses f2py"""
+
+    def __init__(self, *args, **kwargs):
+
+        ext_keys = ['include_dirs', 'library_dirs', 'libraries',
+                    'extra_compile_args', 'extra_link_args']
+        msg = ('The compilation option kwarg {} is not supported with the f2py '
+               'backend.')
+
+        for k in ext_keys:
+            if k in kwargs.keys():
+                warn(msg.format(k))
+            kwargs.pop(k, None)
+
+        super().__init__(*args, **kwargs)
+
+    @property
+    def command(self):
+        filename = self.filename + '.' + self.generator.code_extension
+        args = ['-c', '-m', self.module_name, filename]
+        command = [sys.executable, "-c", "import numpy.f2py as f2py2e;f2py2e.main()"]+args
+        return command
+
+    def _prepare_files(self, routine):
+        pass
+
+    @classmethod
+    def _get_wrapped_function(cls, mod, name):
+        return getattr(mod, name)
+
+
+# Here we define a lookup of backends -> tuples of languages. For now, each
+# tuple is of length 1, but if a backend supports more than one language,
+# the most preferable language is listed first.
+_lang_lookup = {'CYTHON': ('C99', 'C89', 'C'),
+                'F2PY': ('F95',),
+                'NUMPY': ('C99', 'C89', 'C'),
+                'DUMMY': ('F95',)}     # Dummy here just for testing
+
+
+def _infer_language(backend):
+    """For a given backend, return the top choice of language"""
+    langs = _lang_lookup.get(backend.upper(), False)
+    if not langs:
+        raise ValueError("Unrecognized backend: " + backend)
+    return langs[0]
+
+
+def _validate_backend_language(backend, language):
+    """Throws error if backend and language are incompatible"""
+    langs = _lang_lookup.get(backend.upper(), False)
+    if not langs:
+        raise ValueError("Unrecognized backend: " + backend)
+    if language.upper() not in langs:
+        raise ValueError(("Backend {} and language {} are "
+                          "incompatible").format(backend, language))
+
+
+@cacheit
+@doctest_depends_on(exe=('f2py', 'gfortran'), modules=('numpy',))
+def autowrap(expr, language=None, backend='f2py', tempdir=None, args=None,
+             flags=None, verbose=False, helpers=None, code_gen=None, **kwargs):
+    """Generates Python callable binaries based on the math expression.
+
+    Parameters
+    ==========
+
+    expr
+        The SymPy expression that should be wrapped as a binary routine.
+    language : string, optional
+        If supplied, (options: 'C' or 'F95'), specifies the language of the
+        generated code. If ``None`` [default], the language is inferred based
+        upon the specified backend.
+    backend : string, optional
+        Backend used to wrap the generated code. Either 'f2py' [default],
+        or 'cython'.
+    tempdir : string, optional
+        Path to directory for temporary files. If this argument is supplied,
+        the generated code and the wrapper input files are left intact in the
+        specified path.
+    args : iterable, optional
+        An ordered iterable of symbols. Specifies the argument sequence for the
+        function.
+    flags : iterable, optional
+        Additional option flags that will be passed to the backend.
+    verbose : bool, optional
+        If True, autowrap will not mute the command line backends. This can be
+        helpful for debugging.
+    helpers : 3-tuple or iterable of 3-tuples, optional
+        Used to define auxiliary expressions needed for the main expr. If the
+        main expression needs to call a specialized function it should be
+        passed in via ``helpers``. Autowrap will then make sure that the
+        compiled main expression can link to the helper routine. Items should
+        be 3-tuples with (<function_name>, <sympy_expression>,
+        <argument_tuple>). It is mandatory to supply an argument sequence to
+        helper routines.
+    code_gen : CodeGen instance
+        An instance of a CodeGen subclass. Overrides ``language``.
+    include_dirs : [string]
+        A list of directories to search for C/C++ header files (in Unix form
+        for portability).
+    library_dirs : [string]
+        A list of directories to search for C/C++ libraries at link time.
+    libraries : [string]
+        A list of library names (not filenames or paths) to link against.
+    extra_compile_args : [string]
+        Any extra platform- and compiler-specific information to use when
+        compiling the source files in 'sources'.  For platforms and compilers
+        where "command line" makes sense, this is typically a list of
+        command-line arguments, but for other platforms it could be anything.
+    extra_link_args : [string]
+        Any extra platform- and compiler-specific information to use when
+        linking object files together to create the extension (or to create a
+        new static Python interpreter).  Similar interpretation as for
+        'extra_compile_args'.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y, z
+    >>> from sympy.utilities.autowrap import autowrap
+    >>> expr = ((x - y + z)**(13)).expand()
+    >>> binary_func = autowrap(expr)
+    >>> binary_func(1, 4, 2)
+    -1.0
+
+    """
+    if language:
+        if not isinstance(language, type):
+            _validate_backend_language(backend, language)
+    else:
+        language = _infer_language(backend)
+
+    # two cases 1) helpers is an iterable of 3-tuples and 2) helpers is a
+    # 3-tuple
+    if iterable(helpers) and len(helpers) != 0 and iterable(helpers[0]):
+        helpers = helpers if helpers else ()
+    else:
+        helpers = [helpers] if helpers else ()
+    args = list(args) if iterable(args, exclude=set) else args
+
+    if code_gen is None:
+        code_gen = get_code_generator(language, "autowrap")
+
+    CodeWrapperClass = {
+        'F2PY': F2PyCodeWrapper,
+        'CYTHON': CythonCodeWrapper,
+        'DUMMY': DummyWrapper
+    }[backend.upper()]
+    code_wrapper = CodeWrapperClass(code_gen, tempdir, flags if flags else (),
+                                    verbose, **kwargs)
+
+    helps = []
+    for name_h, expr_h, args_h in helpers:
+        helps.append(code_gen.routine(name_h, expr_h, args_h))
+
+    for name_h, expr_h, args_h in helpers:
+        if expr.has(expr_h):
+            name_h = binary_function(name_h, expr_h, backend='dummy')
+            expr = expr.subs(expr_h, name_h(*args_h))
+    try:
+        routine = code_gen.routine('autofunc', expr, args)
+    except CodeGenArgumentListError as e:
+        # if all missing arguments are for pure output, we simply attach them
+        # at the end and try again, because the wrappers will silently convert
+        # them to return values anyway.
+        new_args = []
+        for missing in e.missing_args:
+            if not isinstance(missing, OutputArgument):
+                raise
+            new_args.append(missing.name)
+        routine = code_gen.routine('autofunc', expr, args + new_args)
+
+    return code_wrapper.wrap_code(routine, helpers=helps)
+
+
+@doctest_depends_on(exe=('f2py', 'gfortran'), modules=('numpy',))
+def binary_function(symfunc, expr, **kwargs):
+    """Returns a SymPy function with expr as binary implementation
+
+    This is a convenience function that automates the steps needed to
+    autowrap the SymPy expression and attaching it to a Function object
+    with implemented_function().
+
+    Parameters
+    ==========
+
+    symfunc : SymPy Function
+        The function to bind the callable to.
+    expr : SymPy Expression
+        The expression used to generate the function.
+    kwargs : dict
+        Any kwargs accepted by autowrap.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y
+    >>> from sympy.utilities.autowrap import binary_function
+    >>> expr = ((x - y)**(25)).expand()
+    >>> f = binary_function('f', expr)
+    >>> type(f)
+    <class 'sympy.core.function.UndefinedFunction'>
+    >>> 2*f(x, y)
+    2*f(x, y)
+    >>> f(x, y).evalf(2, subs={x: 1, y: 2})
+    -1.0
+
+    """
+    binary = autowrap(expr, **kwargs)
+    return implemented_function(symfunc, binary)
+
+#################################################################
+#                           UFUNCIFY                            #
+#################################################################
+
+_ufunc_top = Template("""\
+#include "Python.h"
+#include "math.h"
+#include "numpy/ndarraytypes.h"
+#include "numpy/ufuncobject.h"
+#include "numpy/halffloat.h"
+#include ${include_file}
+
+static PyMethodDef ${module}Methods[] = {
+        {NULL, NULL, 0, NULL}
+};""")
+
+_ufunc_outcalls = Template("*((double *)out${outnum}) = ${funcname}(${call_args});")
+
+_ufunc_body = Template("""\
+static void ${funcname}_ufunc(char **args, npy_intp *dimensions, npy_intp* steps, void* data)
+{
+    npy_intp i;
+    npy_intp n = dimensions[0];
+    ${declare_args}
+    ${declare_steps}
+    for (i = 0; i < n; i++) {
+        ${outcalls}
+        ${step_increments}
+    }
+}
+PyUFuncGenericFunction ${funcname}_funcs[1] = {&${funcname}_ufunc};
+static char ${funcname}_types[${n_types}] = ${types}
+static void *${funcname}_data[1] = {NULL};""")
+
+_ufunc_bottom = Template("""\
+#if PY_VERSION_HEX >= 0x03000000
+static struct PyModuleDef moduledef = {
+    PyModuleDef_HEAD_INIT,
+    "${module}",
+    NULL,
+    -1,
+    ${module}Methods,
+    NULL,
+    NULL,
+    NULL,
+    NULL
+};
+
+PyMODINIT_FUNC PyInit_${module}(void)
+{
+    PyObject *m, *d;
+    ${function_creation}
+    m = PyModule_Create(&moduledef);
+    if (!m) {
+        return NULL;
+    }
+    import_array();
+    import_umath();
+    d = PyModule_GetDict(m);
+    ${ufunc_init}
+    return m;
+}
+#else
+PyMODINIT_FUNC init${module}(void)
+{
+    PyObject *m, *d;
+    ${function_creation}
+    m = Py_InitModule("${module}", ${module}Methods);
+    if (m == NULL) {
+        return;
+    }
+    import_array();
+    import_umath();
+    d = PyModule_GetDict(m);
+    ${ufunc_init}
+}
+#endif\
+""")
+
+_ufunc_init_form = Template("""\
+ufunc${ind} = PyUFunc_FromFuncAndData(${funcname}_funcs, ${funcname}_data, ${funcname}_types, 1, ${n_in}, ${n_out},
+            PyUFunc_None, "${module}", ${docstring}, 0);
+    PyDict_SetItemString(d, "${funcname}", ufunc${ind});
+    Py_DECREF(ufunc${ind});""")
+
+_ufunc_setup = Template("""\
+from setuptools.extension import Extension
+from setuptools import setup
+
+from numpy import get_include
+
+if __name__ == "__main__":
+    setup(ext_modules=[
+        Extension('${module}',
+                  sources=['${module}.c', '${filename}.c'],
+                  include_dirs=[get_include()])])
+""")
+
+
+class UfuncifyCodeWrapper(CodeWrapper):
+    """Wrapper for Ufuncify"""
+
+    def __init__(self, *args, **kwargs):
+
+        ext_keys = ['include_dirs', 'library_dirs', 'libraries',
+                    'extra_compile_args', 'extra_link_args']
+        msg = ('The compilation option kwarg {} is not supported with the numpy'
+               ' backend.')
+
+        for k in ext_keys:
+            if k in kwargs.keys():
+                warn(msg.format(k))
+            kwargs.pop(k, None)
+
+        super().__init__(*args, **kwargs)
+
+    @property
+    def command(self):
+        command = [sys.executable, "setup.py", "build_ext", "--inplace"]
+        return command
+
+    def wrap_code(self, routines, helpers=None):
+        # This routine overrides CodeWrapper because we can't assume funcname == routines[0].name
+        # Therefore we have to break the CodeWrapper private API.
+        # There isn't an obvious way to extend multi-expr support to
+        # the other autowrap backends, so we limit this change to ufuncify.
+        helpers = helpers if helpers is not None else []
+        # We just need a consistent name
+        funcname = 'wrapped_' + str(id(routines) + id(helpers))
+
+        workdir = self.filepath or tempfile.mkdtemp("_sympy_compile")
+        if not os.access(workdir, os.F_OK):
+            os.mkdir(workdir)
+        oldwork = os.getcwd()
+        os.chdir(workdir)
+        try:
+            sys.path.append(workdir)
+            self._generate_code(routines, helpers)
+            self._prepare_files(routines, funcname)
+            self._process_files(routines)
+            mod = __import__(self.module_name)
+        finally:
+            sys.path.remove(workdir)
+            CodeWrapper._module_counter += 1
+            os.chdir(oldwork)
+            if not self.filepath:
+                try:
+                    shutil.rmtree(workdir)
+                except OSError:
+                    # Could be some issues on Windows
+                    pass
+
+        return self._get_wrapped_function(mod, funcname)
+
+    def _generate_code(self, main_routines, helper_routines):
+        all_routines = main_routines + helper_routines
+        self.generator.write(
+            all_routines, self.filename, True, self.include_header,
+            self.include_empty)
+
+    def _prepare_files(self, routines, funcname):
+
+        # C
+        codefilename = self.module_name + '.c'
+        with open(codefilename, 'w') as f:
+            self.dump_c(routines, f, self.filename, funcname=funcname)
+
+        # setup.py
+        with open('setup.py', 'w') as f:
+            self.dump_setup(f)
+
+    @classmethod
+    def _get_wrapped_function(cls, mod, name):
+        return getattr(mod, name)
+
+    def dump_setup(self, f):
+        setup = _ufunc_setup.substitute(module=self.module_name,
+                                        filename=self.filename)
+        f.write(setup)
+
+    def dump_c(self, routines, f, prefix, funcname=None):
+        """Write a C file with Python wrappers
+
+        This file contains all the definitions of the routines in c code.
+
+        Arguments
+        ---------
+        routines
+            List of Routine instances
+        f
+            File-like object to write the file to
+        prefix
+            The filename prefix, used to name the imported module.
+        funcname
+            Name of the main function to be returned.
+        """
+        if funcname is None:
+            if len(routines) == 1:
+                funcname = routines[0].name
+            else:
+                msg = 'funcname must be specified for multiple output routines'
+                raise ValueError(msg)
+        functions = []
+        function_creation = []
+        ufunc_init = []
+        module = self.module_name
+        include_file = "\"{}.h\"".format(prefix)
+        top = _ufunc_top.substitute(include_file=include_file, module=module)
+
+        name = funcname
+
+        # Partition the C function arguments into categories
+        # Here we assume all routines accept the same arguments
+        r_index = 0
+        py_in, _ = self._partition_args(routines[0].arguments)
+        n_in = len(py_in)
+        n_out = len(routines)
+
+        # Declare Args
+        form = "char *{0}{1} = args[{2}];"
+        arg_decs = [form.format('in', i, i) for i in range(n_in)]
+        arg_decs.extend([form.format('out', i, i+n_in) for i in range(n_out)])
+        declare_args = '\n    '.join(arg_decs)
+
+        # Declare Steps
+        form = "npy_intp {0}{1}_step = steps[{2}];"
+        step_decs = [form.format('in', i, i) for i in range(n_in)]
+        step_decs.extend([form.format('out', i, i+n_in) for i in range(n_out)])
+        declare_steps = '\n    '.join(step_decs)
+
+        # Call Args
+        form = "*(double *)in{0}"
+        call_args = ', '.join([form.format(a) for a in range(n_in)])
+
+        # Step Increments
+        form = "{0}{1} += {0}{1}_step;"
+        step_incs = [form.format('in', i) for i in range(n_in)]
+        step_incs.extend([form.format('out', i, i) for i in range(n_out)])
+        step_increments = '\n        '.join(step_incs)
+
+        # Types
+        n_types = n_in + n_out
+        types = "{" + ', '.join(["NPY_DOUBLE"]*n_types) + "};"
+
+        # Docstring
+        docstring = '"Created in SymPy with Ufuncify"'
+
+        # Function Creation
+        function_creation.append("PyObject *ufunc{};".format(r_index))
+
+        # Ufunc initialization
+        init_form = _ufunc_init_form.substitute(module=module,
+                                                funcname=name,
+                                                docstring=docstring,
+                                                n_in=n_in, n_out=n_out,
+                                                ind=r_index)
+        ufunc_init.append(init_form)
+
+        outcalls = [_ufunc_outcalls.substitute(
+            outnum=i, call_args=call_args, funcname=routines[i].name) for i in
+            range(n_out)]
+
+        body = _ufunc_body.substitute(module=module, funcname=name,
+                                      declare_args=declare_args,
+                                      declare_steps=declare_steps,
+                                      call_args=call_args,
+                                      step_increments=step_increments,
+                                      n_types=n_types, types=types,
+                                      outcalls='\n        '.join(outcalls))
+        functions.append(body)
+
+        body = '\n\n'.join(functions)
+        ufunc_init = '\n    '.join(ufunc_init)
+        function_creation = '\n    '.join(function_creation)
+        bottom = _ufunc_bottom.substitute(module=module,
+                                          ufunc_init=ufunc_init,
+                                          function_creation=function_creation)
+        text = [top, body, bottom]
+        f.write('\n\n'.join(text))
+
+    def _partition_args(self, args):
+        """Group function arguments into categories."""
+        py_in = []
+        py_out = []
+        for arg in args:
+            if isinstance(arg, OutputArgument):
+                py_out.append(arg)
+            elif isinstance(arg, InOutArgument):
+                raise ValueError("Ufuncify doesn't support InOutArguments")
+            else:
+                py_in.append(arg)
+        return py_in, py_out
+
+
+@cacheit
+@doctest_depends_on(exe=('f2py', 'gfortran', 'gcc'), modules=('numpy',))
+def ufuncify(args, expr, language=None, backend='numpy', tempdir=None,
+             flags=None, verbose=False, helpers=None, **kwargs):
+    """Generates a binary function that supports broadcasting on numpy arrays.
+
+    Parameters
+    ==========
+
+    args : iterable
+        Either a Symbol or an iterable of symbols. Specifies the argument
+        sequence for the function.
+    expr
+        A SymPy expression that defines the element wise operation.
+    language : string, optional
+        If supplied, (options: 'C' or 'F95'), specifies the language of the
+        generated code. If ``None`` [default], the language is inferred based
+        upon the specified backend.
+    backend : string, optional
+        Backend used to wrap the generated code. Either 'numpy' [default],
+        'cython', or 'f2py'.
+    tempdir : string, optional
+        Path to directory for temporary files. If this argument is supplied,
+        the generated code and the wrapper input files are left intact in
+        the specified path.
+    flags : iterable, optional
+        Additional option flags that will be passed to the backend.
+    verbose : bool, optional
+        If True, autowrap will not mute the command line backends. This can
+        be helpful for debugging.
+    helpers : iterable, optional
+        Used to define auxiliary expressions needed for the main expr. If
+        the main expression needs to call a specialized function it should
+        be put in the ``helpers`` iterable. Autowrap will then make sure
+        that the compiled main expression can link to the helper routine.
+        Items should be tuples with (<funtion_name>, <sympy_expression>,
+        <arguments>). It is mandatory to supply an argument sequence to
+        helper routines.
+    kwargs : dict
+        These kwargs will be passed to autowrap if the `f2py` or `cython`
+        backend is used and ignored if the `numpy` backend is used.
+
+    Notes
+    =====
+
+    The default backend ('numpy') will create actual instances of
+    ``numpy.ufunc``. These support ndimensional broadcasting, and implicit type
+    conversion. Use of the other backends will result in a "ufunc-like"
+    function, which requires equal length 1-dimensional arrays for all
+    arguments, and will not perform any type conversions.
+
+    References
+    ==========
+
+    .. [1] https://numpy.org/doc/stable/reference/ufuncs.html
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.autowrap import ufuncify
+    >>> from sympy.abc import x, y
+    >>> import numpy as np
+    >>> f = ufuncify((x, y), y + x**2)
+    >>> type(f)
+    <class 'numpy.ufunc'>
+    >>> f([1, 2, 3], 2)
+    array([  3.,   6.,  11.])
+    >>> f(np.arange(5), 3)
+    array([  3.,   4.,   7.,  12.,  19.])
+
+    For the 'f2py' and 'cython' backends, inputs are required to be equal length
+    1-dimensional arrays. The 'f2py' backend will perform type conversion, but
+    the Cython backend will error if the inputs are not of the expected type.
+
+    >>> f_fortran = ufuncify((x, y), y + x**2, backend='f2py')
+    >>> f_fortran(1, 2)
+    array([ 3.])
+    >>> f_fortran(np.array([1, 2, 3]), np.array([1.0, 2.0, 3.0]))
+    array([  2.,   6.,  12.])
+    >>> f_cython = ufuncify((x, y), y + x**2, backend='Cython')
+    >>> f_cython(1, 2)  # doctest: +ELLIPSIS
+    Traceback (most recent call last):
+      ...
+    TypeError: Argument '_x' has incorrect type (expected numpy.ndarray, got int)
+    >>> f_cython(np.array([1.0]), np.array([2.0]))
+    array([ 3.])
+
+    """
+
+    if isinstance(args, Symbol):
+        args = (args,)
+    else:
+        args = tuple(args)
+
+    if language:
+        _validate_backend_language(backend, language)
+    else:
+        language = _infer_language(backend)
+
+    helpers = helpers if helpers else ()
+    flags = flags if flags else ()
+
+    if backend.upper() == 'NUMPY':
+        # maxargs is set by numpy compile-time constant NPY_MAXARGS
+        # If a future version of numpy modifies or removes this restriction
+        # this variable should be changed or removed
+        maxargs = 32
+        helps = []
+        for name, expr, args in helpers:
+            helps.append(make_routine(name, expr, args))
+        code_wrapper = UfuncifyCodeWrapper(C99CodeGen("ufuncify"), tempdir,
+                                           flags, verbose)
+        if not isinstance(expr, (list, tuple)):
+            expr = [expr]
+        if len(expr) == 0:
+            raise ValueError('Expression iterable has zero length')
+        if len(expr) + len(args) > maxargs:
+            msg = ('Cannot create ufunc with more than {0} total arguments: '
+                   'got {1} in, {2} out')
+            raise ValueError(msg.format(maxargs, len(args), len(expr)))
+        routines = [make_routine('autofunc{}'.format(idx), exprx, args) for
+                    idx, exprx in enumerate(expr)]
+        return code_wrapper.wrap_code(routines, helpers=helps)
+    else:
+        # Dummies are used for all added expressions to prevent name clashes
+        # within the original expression.
+        y = IndexedBase(Dummy('y'))
+        m = Dummy('m', integer=True)
+        i = Idx(Dummy('i', integer=True), m)
+        f_dummy = Dummy('f')
+        f = implemented_function('%s_%d' % (f_dummy.name, f_dummy.dummy_index), Lambda(args, expr))
+        # For each of the args create an indexed version.
+        indexed_args = [IndexedBase(Dummy(str(a))) for a in args]
+        # Order the arguments (out, args, dim)
+        args = [y] + indexed_args + [m]
+        args_with_indices = [a[i] for a in indexed_args]
+        return autowrap(Eq(y[i], f(*args_with_indices)), language, backend,
+                        tempdir, args, flags, verbose, helpers, **kwargs)

venv/lib/python3.10/site-packages/sympy/utilities/codegen.py

@@ -0,0 +1,2236 @@
+"""
+module for generating C, C++, Fortran77, Fortran90, Julia, Rust
+and Octave/Matlab routines that evaluate SymPy expressions.
+This module is work in progress.
+Only the milestones with a '+' character in the list below have been completed.
+
+--- How is sympy.utilities.codegen different from sympy.printing.ccode? ---
+
+We considered the idea to extend the printing routines for SymPy functions in
+such a way that it prints complete compilable code, but this leads to a few
+unsurmountable issues that can only be tackled with dedicated code generator:
+
+- For C, one needs both a code and a header file, while the printing routines
+  generate just one string. This code generator can be extended to support
+  .pyf files for f2py.
+
+- SymPy functions are not concerned with programming-technical issues, such
+  as input, output and input-output arguments. Other examples are contiguous
+  or non-contiguous arrays, including headers of other libraries such as gsl
+  or others.
+
+- It is highly interesting to evaluate several SymPy functions in one C
+  routine, eventually sharing common intermediate results with the help
+  of the cse routine. This is more than just printing.
+
+- From the programming perspective, expressions with constants should be
+  evaluated in the code generator as much as possible. This is different
+  for printing.
+
+--- Basic assumptions ---
+
+* A generic Routine data structure describes the routine that must be
+  translated into C/Fortran/... code. This data structure covers all
+  features present in one or more of the supported languages.
+
+* Descendants from the CodeGen class transform multiple Routine instances
+  into compilable code. Each derived class translates into a specific
+  language.
+
+* In many cases, one wants a simple workflow. The friendly functions in the
+  last part are a simple api on top of the Routine/CodeGen stuff. They are
+  easier to use, but are less powerful.
+
+--- Milestones ---
+
++ First working version with scalar input arguments, generating C code,
+  tests
++ Friendly functions that are easier to use than the rigorous
+  Routine/CodeGen workflow.
++ Integer and Real numbers as input and output
++ Output arguments
++ InputOutput arguments
++ Sort input/output arguments properly
++ Contiguous array arguments (numpy matrices)
++ Also generate .pyf code for f2py (in autowrap module)
++ Isolate constants and evaluate them beforehand in double precision
++ Fortran 90
++ Octave/Matlab
+
+- Common Subexpression Elimination
+- User defined comments in the generated code
+- Optional extra include lines for libraries/objects that can eval special
+  functions
+- Test other C compilers and libraries: gcc, tcc, libtcc, gcc+gsl, ...
+- Contiguous array arguments (SymPy matrices)
+- Non-contiguous array arguments (SymPy matrices)
+- ccode must raise an error when it encounters something that cannot be
+  translated into c. ccode(integrate(sin(x)/x, x)) does not make sense.
+- Complex numbers as input and output
+- A default complex datatype
+- Include extra information in the header: date, user, hostname, sha1
+  hash, ...
+- Fortran 77
+- C++
+- Python
+- Julia
+- Rust
+- ...
+
+"""
+
+import os
+import textwrap
+from io import StringIO
+
+from sympy import __version__ as sympy_version
+from sympy.core import Symbol, S, Tuple, Equality, Function, Basic
+from sympy.printing.c import c_code_printers
+from sympy.printing.codeprinter import AssignmentError
+from sympy.printing.fortran import FCodePrinter
+from sympy.printing.julia import JuliaCodePrinter
+from sympy.printing.octave import OctaveCodePrinter
+from sympy.printing.rust import RustCodePrinter
+from sympy.tensor import Idx, Indexed, IndexedBase
+from sympy.matrices import (MatrixSymbol, ImmutableMatrix, MatrixBase,
+                            MatrixExpr, MatrixSlice)
+from sympy.utilities.iterables import is_sequence
+
+
+__all__ = [
+    # description of routines
+    "Routine", "DataType", "default_datatypes", "get_default_datatype",
+    "Argument", "InputArgument", "OutputArgument", "Result",
+    # routines -> code
+    "CodeGen", "CCodeGen", "FCodeGen", "JuliaCodeGen", "OctaveCodeGen",
+    "RustCodeGen",
+    # friendly functions
+    "codegen", "make_routine",
+]
+
+
+#
+# Description of routines
+#
+
+
+class Routine:
+    """Generic description of evaluation routine for set of expressions.
+
+    A CodeGen class can translate instances of this class into code in a
+    particular language.  The routine specification covers all the features
+    present in these languages.  The CodeGen part must raise an exception
+    when certain features are not present in the target language.  For
+    example, multiple return values are possible in Python, but not in C or
+    Fortran.  Another example: Fortran and Python support complex numbers,
+    while C does not.
+
+    """
+
+    def __init__(self, name, arguments, results, local_vars, global_vars):
+        """Initialize a Routine instance.
+
+        Parameters
+        ==========
+
+        name : string
+            Name of the routine.
+
+        arguments : list of Arguments
+            These are things that appear in arguments of a routine, often
+            appearing on the right-hand side of a function call.  These are
+            commonly InputArguments but in some languages, they can also be
+            OutputArguments or InOutArguments (e.g., pass-by-reference in C
+            code).
+
+        results : list of Results
+            These are the return values of the routine, often appearing on
+            the left-hand side of a function call.  The difference between
+            Results and OutputArguments and when you should use each is
+            language-specific.
+
+        local_vars : list of Results
+            These are variables that will be defined at the beginning of the
+            function.
+
+        global_vars : list of Symbols
+            Variables which will not be passed into the function.
+
+        """
+
+        # extract all input symbols and all symbols appearing in an expression
+        input_symbols = set()
+        symbols = set()
+        for arg in arguments:
+            if isinstance(arg, OutputArgument):
+                symbols.update(arg.expr.free_symbols - arg.expr.atoms(Indexed))
+            elif isinstance(arg, InputArgument):
+                input_symbols.add(arg.name)
+            elif isinstance(arg, InOutArgument):
+                input_symbols.add(arg.name)
+                symbols.update(arg.expr.free_symbols - arg.expr.atoms(Indexed))
+            else:
+                raise ValueError("Unknown Routine argument: %s" % arg)
+
+        for r in results:
+            if not isinstance(r, Result):
+                raise ValueError("Unknown Routine result: %s" % r)
+            symbols.update(r.expr.free_symbols - r.expr.atoms(Indexed))
+
+        local_symbols = set()
+        for r in local_vars:
+            if isinstance(r, Result):
+                symbols.update(r.expr.free_symbols - r.expr.atoms(Indexed))
+                local_symbols.add(r.name)
+            else:
+                local_symbols.add(r)
+
+        symbols = {s.label if isinstance(s, Idx) else s for s in symbols}
+
+        # Check that all symbols in the expressions are covered by
+        # InputArguments/InOutArguments---subset because user could
+        # specify additional (unused) InputArguments or local_vars.
+        notcovered = symbols.difference(
+            input_symbols.union(local_symbols).union(global_vars))
+        if notcovered != set():
+            raise ValueError("Symbols needed for output are not in input " +
+                             ", ".join([str(x) for x in notcovered]))
+
+        self.name = name
+        self.arguments = arguments
+        self.results = results
+        self.local_vars = local_vars
+        self.global_vars = global_vars
+
+    def __str__(self):
+        return self.__class__.__name__ + "({name!r}, {arguments}, {results}, {local_vars}, {global_vars})".format(**self.__dict__)
+
+    __repr__ = __str__
+
+    @property
+    def variables(self):
+        """Returns a set of all variables possibly used in the routine.
+
+        For routines with unnamed return values, the dummies that may or
+        may not be used will be included in the set.
+
+        """
+        v = set(self.local_vars)
+        for arg in self.arguments:
+            v.add(arg.name)
+        for res in self.results:
+            v.add(res.result_var)
+        return v
+
+    @property
+    def result_variables(self):
+        """Returns a list of OutputArgument, InOutArgument and Result.
+
+        If return values are present, they are at the end of the list.
+        """
+        args = [arg for arg in self.arguments if isinstance(
+            arg, (OutputArgument, InOutArgument))]
+        args.extend(self.results)
+        return args
+
+
+class DataType:
+    """Holds strings for a certain datatype in different languages."""
+    def __init__(self, cname, fname, pyname, jlname, octname, rsname):
+        self.cname = cname
+        self.fname = fname
+        self.pyname = pyname
+        self.jlname = jlname
+        self.octname = octname
+        self.rsname = rsname
+
+
+default_datatypes = {
+    "int": DataType("int", "INTEGER*4", "int", "", "", "i32"),
+    "float": DataType("double", "REAL*8", "float", "", "", "f64"),
+    "complex": DataType("double", "COMPLEX*16", "complex", "", "", "float") #FIXME:
+       # complex is only supported in fortran, python, julia, and octave.
+       # So to not break c or rust code generation, we stick with double or
+       # float, respectively (but actually should raise an exception for
+       # explicitly complex variables (x.is_complex==True))
+}
+
+
+COMPLEX_ALLOWED = False
+def get_default_datatype(expr, complex_allowed=None):
+    """Derives an appropriate datatype based on the expression."""
+    if complex_allowed is None:
+        complex_allowed = COMPLEX_ALLOWED
+    if complex_allowed:
+        final_dtype = "complex"
+    else:
+        final_dtype = "float"
+    if expr.is_integer:
+        return default_datatypes["int"]
+    elif expr.is_real:
+        return default_datatypes["float"]
+    elif isinstance(expr, MatrixBase):
+        #check all entries
+        dt = "int"
+        for element in expr:
+            if dt == "int" and not element.is_integer:
+                dt = "float"
+            if dt == "float" and not element.is_real:
+                return default_datatypes[final_dtype]
+        return default_datatypes[dt]
+    else:
+        return default_datatypes[final_dtype]
+
+
+class Variable:
+    """Represents a typed variable."""
+
+    def __init__(self, name, datatype=None, dimensions=None, precision=None):
+        """Return a new variable.
+
+        Parameters
+        ==========
+
+        name : Symbol or MatrixSymbol
+
+        datatype : optional
+            When not given, the data type will be guessed based on the
+            assumptions on the symbol argument.
+
+        dimension : sequence containing tupes, optional
+            If present, the argument is interpreted as an array, where this
+            sequence of tuples specifies (lower, upper) bounds for each
+            index of the array.
+
+        precision : int, optional
+            Controls the precision of floating point constants.
+
+        """
+        if not isinstance(name, (Symbol, MatrixSymbol)):
+            raise TypeError("The first argument must be a SymPy symbol.")
+        if datatype is None:
+            datatype = get_default_datatype(name)
+        elif not isinstance(datatype, DataType):
+            raise TypeError("The (optional) `datatype' argument must be an "
+                            "instance of the DataType class.")
+        if dimensions and not isinstance(dimensions, (tuple, list)):
+            raise TypeError(
+                "The dimension argument must be a sequence of tuples")
+
+        self._name = name
+        self._datatype = {
+            'C': datatype.cname,
+            'FORTRAN': datatype.fname,
+            'JULIA': datatype.jlname,
+            'OCTAVE': datatype.octname,
+            'PYTHON': datatype.pyname,
+            'RUST': datatype.rsname,
+        }
+        self.dimensions = dimensions
+        self.precision = precision
+
+    def __str__(self):
+        return "%s(%r)" % (self.__class__.__name__, self.name)
+
+    __repr__ = __str__
+
+    @property
+    def name(self):
+        return self._name
+
+    def get_datatype(self, language):
+        """Returns the datatype string for the requested language.
+
+        Examples
+        ========
+
+        >>> from sympy import Symbol
+        >>> from sympy.utilities.codegen import Variable
+        >>> x = Variable(Symbol('x'))
+        >>> x.get_datatype('c')
+        'double'
+        >>> x.get_datatype('fortran')
+        'REAL*8'
+
+        """
+        try:
+            return self._datatype[language.upper()]
+        except KeyError:
+            raise CodeGenError("Has datatypes for languages: %s" %
+                    ", ".join(self._datatype))
+
+
+class Argument(Variable):
+    """An abstract Argument data structure: a name and a data type.
+
+    This structure is refined in the descendants below.
+
+    """
+    pass
+
+
+class InputArgument(Argument):
+    pass
+
+
+class ResultBase:
+    """Base class for all "outgoing" information from a routine.
+
+    Objects of this class stores a SymPy expression, and a SymPy object
+    representing a result variable that will be used in the generated code
+    only if necessary.
+
+    """
+    def __init__(self, expr, result_var):
+        self.expr = expr
+        self.result_var = result_var
+
+    def __str__(self):
+        return "%s(%r, %r)" % (self.__class__.__name__, self.expr,
+            self.result_var)
+
+    __repr__ = __str__
+
+
+class OutputArgument(Argument, ResultBase):
+    """OutputArgument are always initialized in the routine."""
+
+    def __init__(self, name, result_var, expr, datatype=None, dimensions=None, precision=None):
+        """Return a new variable.
+
+        Parameters
+        ==========
+
+        name : Symbol, MatrixSymbol
+            The name of this variable.  When used for code generation, this
+            might appear, for example, in the prototype of function in the
+            argument list.
+
+        result_var : Symbol, Indexed
+            Something that can be used to assign a value to this variable.
+            Typically the same as `name` but for Indexed this should be e.g.,
+            "y[i]" whereas `name` should be the Symbol "y".
+
+        expr : object
+            The expression that should be output, typically a SymPy
+            expression.
+
+        datatype : optional
+            When not given, the data type will be guessed based on the
+            assumptions on the symbol argument.
+
+        dimension : sequence containing tupes, optional
+            If present, the argument is interpreted as an array, where this
+            sequence of tuples specifies (lower, upper) bounds for each
+            index of the array.
+
+        precision : int, optional
+            Controls the precision of floating point constants.
+
+        """
+
+        Argument.__init__(self, name, datatype, dimensions, precision)
+        ResultBase.__init__(self, expr, result_var)
+
+    def __str__(self):
+        return "%s(%r, %r, %r)" % (self.__class__.__name__, self.name, self.result_var, self.expr)
+
+    __repr__ = __str__
+
+
+class InOutArgument(Argument, ResultBase):
+    """InOutArgument are never initialized in the routine."""
+
+    def __init__(self, name, result_var, expr, datatype=None, dimensions=None, precision=None):
+        if not datatype:
+            datatype = get_default_datatype(expr)
+        Argument.__init__(self, name, datatype, dimensions, precision)
+        ResultBase.__init__(self, expr, result_var)
+    __init__.__doc__ = OutputArgument.__init__.__doc__
+
+
+    def __str__(self):
+        return "%s(%r, %r, %r)" % (self.__class__.__name__, self.name, self.expr,
+            self.result_var)
+
+    __repr__ = __str__
+
+
+class Result(Variable, ResultBase):
+    """An expression for a return value.
+
+    The name result is used to avoid conflicts with the reserved word
+    "return" in the Python language.  It is also shorter than ReturnValue.
+
+    These may or may not need a name in the destination (e.g., "return(x*y)"
+    might return a value without ever naming it).
+
+    """
+
+    def __init__(self, expr, name=None, result_var=None, datatype=None,
+                 dimensions=None, precision=None):
+        """Initialize a return value.
+
+        Parameters
+        ==========
+
+        expr : SymPy expression
+
+        name : Symbol, MatrixSymbol, optional
+            The name of this return variable.  When used for code generation,
+            this might appear, for example, in the prototype of function in a
+            list of return values.  A dummy name is generated if omitted.
+
+        result_var : Symbol, Indexed, optional
+            Something that can be used to assign a value to this variable.
+            Typically the same as `name` but for Indexed this should be e.g.,
+            "y[i]" whereas `name` should be the Symbol "y".  Defaults to
+            `name` if omitted.
+
+        datatype : optional
+            When not given, the data type will be guessed based on the
+            assumptions on the expr argument.
+
+        dimension : sequence containing tupes, optional
+            If present, this variable is interpreted as an array,
+            where this sequence of tuples specifies (lower, upper)
+            bounds for each index of the array.
+
+        precision : int, optional
+            Controls the precision of floating point constants.
+
+        """
+        # Basic because it is the base class for all types of expressions
+        if not isinstance(expr, (Basic, MatrixBase)):
+            raise TypeError("The first argument must be a SymPy expression.")
+
+        if name is None:
+            name = 'result_%d' % abs(hash(expr))
+
+        if datatype is None:
+            #try to infer data type from the expression
+            datatype = get_default_datatype(expr)
+
+        if isinstance(name, str):
+            if isinstance(expr, (MatrixBase, MatrixExpr)):
+                name = MatrixSymbol(name, *expr.shape)
+            else:
+                name = Symbol(name)
+
+        if result_var is None:
+            result_var = name
+
+        Variable.__init__(self, name, datatype=datatype,
+                          dimensions=dimensions, precision=precision)
+        ResultBase.__init__(self, expr, result_var)
+
+    def __str__(self):
+        return "%s(%r, %r, %r)" % (self.__class__.__name__, self.expr, self.name,
+            self.result_var)
+
+    __repr__ = __str__
+
+
+#
+# Transformation of routine objects into code
+#
+
+class CodeGen:
+    """Abstract class for the code generators."""
+
+    printer = None  # will be set to an instance of a CodePrinter subclass
+
+    def _indent_code(self, codelines):
+        return self.printer.indent_code(codelines)
+
+    def _printer_method_with_settings(self, method, settings=None, *args, **kwargs):
+        settings = settings or {}
+        ori = {k: self.printer._settings[k] for k in settings}
+        for k, v in settings.items():
+            self.printer._settings[k] = v
+        result = getattr(self.printer, method)(*args, **kwargs)
+        for k, v in ori.items():
+            self.printer._settings[k] = v
+        return result
+
+    def _get_symbol(self, s):
+        """Returns the symbol as fcode prints it."""
+        if self.printer._settings['human']:
+            expr_str = self.printer.doprint(s)
+        else:
+            constants, not_supported, expr_str = self.printer.doprint(s)
+            if constants or not_supported:
+                raise ValueError("Failed to print %s" % str(s))
+        return expr_str.strip()
+
+    def __init__(self, project="project", cse=False):
+        """Initialize a code generator.
+
+        Derived classes will offer more options that affect the generated
+        code.
+
+        """
+        self.project = project
+        self.cse = cse
+
+    def routine(self, name, expr, argument_sequence=None, global_vars=None):
+        """Creates an Routine object that is appropriate for this language.
+
+        This implementation is appropriate for at least C/Fortran.  Subclasses
+        can override this if necessary.
+
+        Here, we assume at most one return value (the l-value) which must be
+        scalar.  Additional outputs are OutputArguments (e.g., pointers on
+        right-hand-side or pass-by-reference).  Matrices are always returned
+        via OutputArguments.  If ``argument_sequence`` is None, arguments will
+        be ordered alphabetically, but with all InputArguments first, and then
+        OutputArgument and InOutArguments.
+
+        """
+
+        if self.cse:
+            from sympy.simplify.cse_main import cse
+
+            if is_sequence(expr) and not isinstance(expr, (MatrixBase, MatrixExpr)):
+                if not expr:
+                    raise ValueError("No expression given")
+                for e in expr:
+                    if not e.is_Equality:
+                        raise CodeGenError("Lists of expressions must all be Equalities. {} is not.".format(e))
+
+                # create a list of right hand sides and simplify them
+                rhs = [e.rhs for e in expr]
+                common, simplified = cse(rhs)
+
+                # pack the simplified expressions back up with their left hand sides
+                expr = [Equality(e.lhs, rhs) for e, rhs in zip(expr, simplified)]
+            else:
+                if isinstance(expr, Equality):
+                    common, simplified = cse(expr.rhs) #, ignore=in_out_args)
+                    expr = Equality(expr.lhs, simplified[0])
+                else:
+                    common, simplified = cse(expr)
+                    expr = simplified
+
+            local_vars = [Result(b,a) for a,b in common]
+            local_symbols = {a for a,_ in common}
+            local_expressions = Tuple(*[b for _,b in common])
+        else:
+            local_expressions = Tuple()
+
+        if is_sequence(expr) and not isinstance(expr, (MatrixBase, MatrixExpr)):
+            if not expr:
+                raise ValueError("No expression given")
+            expressions = Tuple(*expr)
+        else:
+            expressions = Tuple(expr)
+
+        if self.cse:
+            if {i.label for i in expressions.atoms(Idx)} != set():
+                raise CodeGenError("CSE and Indexed expressions do not play well together yet")
+        else:
+            # local variables for indexed expressions
+            local_vars = {i.label for i in expressions.atoms(Idx)}
+            local_symbols = local_vars
+
+        # global variables
+        global_vars = set() if global_vars is None else set(global_vars)
+
+        # symbols that should be arguments
+        symbols = (expressions.free_symbols | local_expressions.free_symbols) - local_symbols - global_vars
+        new_symbols = set()
+        new_symbols.update(symbols)
+
+        for symbol in symbols:
+            if isinstance(symbol, Idx):
+                new_symbols.remove(symbol)
+                new_symbols.update(symbol.args[1].free_symbols)
+            if isinstance(symbol, Indexed):
+                new_symbols.remove(symbol)
+        symbols = new_symbols
+
+        # Decide whether to use output argument or return value
+        return_val = []
+        output_args = []
+        for expr in expressions:
+            if isinstance(expr, Equality):
+                out_arg = expr.lhs
+                expr = expr.rhs
+                if isinstance(out_arg, Indexed):
+                    dims = tuple([ (S.Zero, dim - 1) for dim in out_arg.shape])
+                    symbol = out_arg.base.label
+                elif isinstance(out_arg, Symbol):
+                    dims = []
+                    symbol = out_arg
+                elif isinstance(out_arg, MatrixSymbol):
+                    dims = tuple([ (S.Zero, dim - 1) for dim in out_arg.shape])
+                    symbol = out_arg
+                else:
+                    raise CodeGenError("Only Indexed, Symbol, or MatrixSymbol "
+                                       "can define output arguments.")
+
+                if expr.has(symbol):
+                    output_args.append(
+                        InOutArgument(symbol, out_arg, expr, dimensions=dims))
+                else:
+                    output_args.append(
+                        OutputArgument(symbol, out_arg, expr, dimensions=dims))
+
+                # remove duplicate arguments when they are not local variables
+                if symbol not in local_vars:
+                    # avoid duplicate arguments
+                    symbols.remove(symbol)
+            elif isinstance(expr, (ImmutableMatrix, MatrixSlice)):
+                # Create a "dummy" MatrixSymbol to use as the Output arg
+                out_arg = MatrixSymbol('out_%s' % abs(hash(expr)), *expr.shape)
+                dims = tuple([(S.Zero, dim - 1) for dim in out_arg.shape])
+                output_args.append(
+                    OutputArgument(out_arg, out_arg, expr, dimensions=dims))
+            else:
+                return_val.append(Result(expr))
+
+        arg_list = []
+
+        # setup input argument list
+
+        # helper to get dimensions for data for array-like args
+        def dimensions(s):
+            return [(S.Zero, dim - 1) for dim in s.shape]
+
+        array_symbols = {}
+        for array in expressions.atoms(Indexed) | local_expressions.atoms(Indexed):
+            array_symbols[array.base.label] = array
+        for array in expressions.atoms(MatrixSymbol) | local_expressions.atoms(MatrixSymbol):
+            array_symbols[array] = array
+
+        for symbol in sorted(symbols, key=str):
+            if symbol in array_symbols:
+                array = array_symbols[symbol]
+                metadata = {'dimensions': dimensions(array)}
+            else:
+                metadata = {}
+
+            arg_list.append(InputArgument(symbol, **metadata))
+
+        output_args.sort(key=lambda x: str(x.name))
+        arg_list.extend(output_args)
+
+        if argument_sequence is not None:
+            # if the user has supplied IndexedBase instances, we'll accept that
+            new_sequence = []
+            for arg in argument_sequence:
+                if isinstance(arg, IndexedBase):
+                    new_sequence.append(arg.label)
+                else:
+                    new_sequence.append(arg)
+            argument_sequence = new_sequence
+
+            missing = [x for x in arg_list if x.name not in argument_sequence]
+            if missing:
+                msg = "Argument list didn't specify: {0} "
+                msg = msg.format(", ".join([str(m.name) for m in missing]))
+                raise CodeGenArgumentListError(msg, missing)
+
+            # create redundant arguments to produce the requested sequence
+            name_arg_dict = {x.name: x for x in arg_list}
+            new_args = []
+            for symbol in argument_sequence:
+                try:
+                    new_args.append(name_arg_dict[symbol])
+                except KeyError:
+                    if isinstance(symbol, (IndexedBase, MatrixSymbol)):
+                        metadata = {'dimensions': dimensions(symbol)}
+                    else:
+                        metadata = {}
+                    new_args.append(InputArgument(symbol, **metadata))
+            arg_list = new_args
+
+        return Routine(name, arg_list, return_val, local_vars, global_vars)
+
+    def write(self, routines, prefix, to_files=False, header=True, empty=True):
+        """Writes all the source code files for the given routines.
+
+        The generated source is returned as a list of (filename, contents)
+        tuples, or is written to files (see below).  Each filename consists
+        of the given prefix, appended with an appropriate extension.
+
+        Parameters
+        ==========
+
+        routines : list
+            A list of Routine instances to be written
+
+        prefix : string
+            The prefix for the output files
+
+        to_files : bool, optional
+            When True, the output is written to files.  Otherwise, a list
+            of (filename, contents) tuples is returned.  [default: False]
+
+        header : bool, optional
+            When True, a header comment is included on top of each source
+            file. [default: True]
+
+        empty : bool, optional
+            When True, empty lines are included to structure the source
+            files. [default: True]
+
+        """
+        if to_files:
+            for dump_fn in self.dump_fns:
+                filename = "%s.%s" % (prefix, dump_fn.extension)
+                with open(filename, "w") as f:
+                    dump_fn(self, routines, f, prefix, header, empty)
+        else:
+            result = []
+            for dump_fn in self.dump_fns:
+                filename = "%s.%s" % (prefix, dump_fn.extension)
+                contents = StringIO()
+                dump_fn(self, routines, contents, prefix, header, empty)
+                result.append((filename, contents.getvalue()))
+            return result
+
+    def dump_code(self, routines, f, prefix, header=True, empty=True):
+        """Write the code by calling language specific methods.
+
+        The generated file contains all the definitions of the routines in
+        low-level code and refers to the header file if appropriate.
+
+        Parameters
+        ==========
+
+        routines : list
+            A list of Routine instances.
+
+        f : file-like
+            Where to write the file.
+
+        prefix : string
+            The filename prefix, used to refer to the proper header file.
+            Only the basename of the prefix is used.
+
+        header : bool, optional
+            When True, a header comment is included on top of each source
+            file.  [default : True]
+
+        empty : bool, optional
+            When True, empty lines are included to structure the source
+            files.  [default : True]
+
+        """
+
+        code_lines = self._preprocessor_statements(prefix)
+
+        for routine in routines:
+            if empty:
+                code_lines.append("\n")
+            code_lines.extend(self._get_routine_opening(routine))
+            code_lines.extend(self._declare_arguments(routine))
+            code_lines.extend(self._declare_globals(routine))
+            code_lines.extend(self._declare_locals(routine))
+            if empty:
+                code_lines.append("\n")
+            code_lines.extend(self._call_printer(routine))
+            if empty:
+                code_lines.append("\n")
+            code_lines.extend(self._get_routine_ending(routine))
+
+        code_lines = self._indent_code(''.join(code_lines))
+
+        if header:
+            code_lines = ''.join(self._get_header() + [code_lines])
+
+        if code_lines:
+            f.write(code_lines)
+
+
+class CodeGenError(Exception):
+    pass
+
+
+class CodeGenArgumentListError(Exception):
+    @property
+    def missing_args(self):
+        return self.args[1]
+
+
+header_comment = """Code generated with SymPy %(version)s
+
+See http://www.sympy.org/ for more information.
+
+This file is part of '%(project)s'
+"""
+
+
+class CCodeGen(CodeGen):
+    """Generator for C code.
+
+    The .write() method inherited from CodeGen will output a code file and
+    an interface file, <prefix>.c and <prefix>.h respectively.
+
+    """
+
+    code_extension = "c"
+    interface_extension = "h"
+    standard = 'c99'
+
+    def __init__(self, project="project", printer=None,
+                 preprocessor_statements=None, cse=False):
+        super().__init__(project=project, cse=cse)
+        self.printer = printer or c_code_printers[self.standard.lower()]()
+
+        self.preprocessor_statements = preprocessor_statements
+        if preprocessor_statements is None:
+            self.preprocessor_statements = ['#include <math.h>']
+
+    def _get_header(self):
+        """Writes a common header for the generated files."""
+        code_lines = []
+        code_lines.append("/" + "*"*78 + '\n')
+        tmp = header_comment % {"version": sympy_version,
+                                "project": self.project}
+        for line in tmp.splitlines():
+            code_lines.append(" *%s*\n" % line.center(76))
+        code_lines.append(" " + "*"*78 + "/\n")
+        return code_lines
+
+    def get_prototype(self, routine):
+        """Returns a string for the function prototype of the routine.
+
+        If the routine has multiple result objects, an CodeGenError is
+        raised.
+
+        See: https://en.wikipedia.org/wiki/Function_prototype
+
+        """
+        if len(routine.results) > 1:
+            raise CodeGenError("C only supports a single or no return value.")
+        elif len(routine.results) == 1:
+            ctype = routine.results[0].get_datatype('C')
+        else:
+            ctype = "void"
+
+        type_args = []
+        for arg in routine.arguments:
+            name = self.printer.doprint(arg.name)
+            if arg.dimensions or isinstance(arg, ResultBase):
+                type_args.append((arg.get_datatype('C'), "*%s" % name))
+            else:
+                type_args.append((arg.get_datatype('C'), name))
+        arguments = ", ".join([ "%s %s" % t for t in type_args])
+        return "%s %s(%s)" % (ctype, routine.name, arguments)
+
+    def _preprocessor_statements(self, prefix):
+        code_lines = []
+        code_lines.append('#include "{}.h"'.format(os.path.basename(prefix)))
+        code_lines.extend(self.preprocessor_statements)
+        code_lines = ['{}\n'.format(l) for l in code_lines]
+        return code_lines
+
+    def _get_routine_opening(self, routine):
+        prototype = self.get_prototype(routine)
+        return ["%s {\n" % prototype]
+
+    def _declare_arguments(self, routine):
+        # arguments are declared in prototype
+        return []
+
+    def _declare_globals(self, routine):
+        # global variables are not explicitly declared within C functions
+        return []
+
+    def _declare_locals(self, routine):
+
+        # Compose a list of symbols to be dereferenced in the function
+        # body. These are the arguments that were passed by a reference
+        # pointer, excluding arrays.
+        dereference = []
+        for arg in routine.arguments:
+            if isinstance(arg, ResultBase) and not arg.dimensions:
+                dereference.append(arg.name)
+
+        code_lines = []
+        for result in routine.local_vars:
+
+            # local variables that are simple symbols such as those used as indices into
+            # for loops are defined declared elsewhere.
+            if not isinstance(result, Result):
+                continue
+
+            if result.name != result.result_var:
+                raise CodeGen("Result variable and name should match: {}".format(result))
+            assign_to = result.name
+            t = result.get_datatype('c')
+            if isinstance(result.expr, (MatrixBase, MatrixExpr)):
+                dims = result.expr.shape
+                code_lines.append("{} {}[{}];\n".format(t, str(assign_to), dims[0]*dims[1]))
+                prefix = ""
+            else:
+                prefix = "const {} ".format(t)
+
+            constants, not_c, c_expr = self._printer_method_with_settings(
+                'doprint', {"human": False, "dereference": dereference},
+                result.expr, assign_to=assign_to)
+
+            for name, value in sorted(constants, key=str):
+                code_lines.append("double const %s = %s;\n" % (name, value))
+
+            code_lines.append("{}{}\n".format(prefix, c_expr))
+
+        return code_lines
+
+    def _call_printer(self, routine):
+        code_lines = []
+
+        # Compose a list of symbols to be dereferenced in the function
+        # body. These are the arguments that were passed by a reference
+        # pointer, excluding arrays.
+        dereference = []
+        for arg in routine.arguments:
+            if isinstance(arg, ResultBase) and not arg.dimensions:
+                dereference.append(arg.name)
+
+        return_val = None
+        for result in routine.result_variables:
+            if isinstance(result, Result):
+                assign_to = routine.name + "_result"
+                t = result.get_datatype('c')
+                code_lines.append("{} {};\n".format(t, str(assign_to)))
+                return_val = assign_to
+            else:
+                assign_to = result.result_var
+
+            try:
+                constants, not_c, c_expr = self._printer_method_with_settings(
+                    'doprint', {"human": False, "dereference": dereference},
+                    result.expr, assign_to=assign_to)
+            except AssignmentError:
+                assign_to = result.result_var
+                code_lines.append(
+                    "%s %s;\n" % (result.get_datatype('c'), str(assign_to)))
+                constants, not_c, c_expr = self._printer_method_with_settings(
+                    'doprint', {"human": False, "dereference": dereference},
+                    result.expr, assign_to=assign_to)
+
+            for name, value in sorted(constants, key=str):
+                code_lines.append("double const %s = %s;\n" % (name, value))
+            code_lines.append("%s\n" % c_expr)
+
+        if return_val:
+            code_lines.append("   return %s;\n" % return_val)
+        return code_lines
+
+    def _get_routine_ending(self, routine):
+        return ["}\n"]
+
+    def dump_c(self, routines, f, prefix, header=True, empty=True):
+        self.dump_code(routines, f, prefix, header, empty)
+    dump_c.extension = code_extension  # type: ignore
+    dump_c.__doc__ = CodeGen.dump_code.__doc__
+
+    def dump_h(self, routines, f, prefix, header=True, empty=True):
+        """Writes the C header file.
+
+        This file contains all the function declarations.
+
+        Parameters
+        ==========
+
+        routines : list
+            A list of Routine instances.
+
+        f : file-like
+            Where to write the file.
+
+        prefix : string
+            The filename prefix, used to construct the include guards.
+            Only the basename of the prefix is used.
+
+        header : bool, optional
+            When True, a header comment is included on top of each source
+            file.  [default : True]
+
+        empty : bool, optional
+            When True, empty lines are included to structure the source
+            files.  [default : True]
+
+        """
+        if header:
+            print(''.join(self._get_header()), file=f)
+        guard_name = "%s__%s__H" % (self.project.replace(
+            " ", "_").upper(), prefix.replace("/", "_").upper())
+        # include guards
+        if empty:
+            print(file=f)
+        print("#ifndef %s" % guard_name, file=f)
+        print("#define %s" % guard_name, file=f)
+        if empty:
+            print(file=f)
+        # declaration of the function prototypes
+        for routine in routines:
+            prototype = self.get_prototype(routine)
+            print("%s;" % prototype, file=f)
+        # end if include guards
+        if empty:
+            print(file=f)
+        print("#endif", file=f)
+        if empty:
+            print(file=f)
+    dump_h.extension = interface_extension  # type: ignore
+
+    # This list of dump functions is used by CodeGen.write to know which dump
+    # functions it has to call.
+    dump_fns = [dump_c, dump_h]
+
+class C89CodeGen(CCodeGen):
+    standard = 'C89'
+
+class C99CodeGen(CCodeGen):
+    standard = 'C99'
+
+class FCodeGen(CodeGen):
+    """Generator for Fortran 95 code
+
+    The .write() method inherited from CodeGen will output a code file and
+    an interface file, <prefix>.f90 and <prefix>.h respectively.
+
+    """
+
+    code_extension = "f90"
+    interface_extension = "h"
+
+    def __init__(self, project='project', printer=None):
+        super().__init__(project)
+        self.printer = printer or FCodePrinter()
+
+    def _get_header(self):
+        """Writes a common header for the generated files."""
+        code_lines = []
+        code_lines.append("!" + "*"*78 + '\n')
+        tmp = header_comment % {"version": sympy_version,
+            "project": self.project}
+        for line in tmp.splitlines():
+            code_lines.append("!*%s*\n" % line.center(76))
+        code_lines.append("!" + "*"*78 + '\n')
+        return code_lines
+
+    def _preprocessor_statements(self, prefix):
+        return []
+
+    def _get_routine_opening(self, routine):
+        """Returns the opening statements of the fortran routine."""
+        code_list = []
+        if len(routine.results) > 1:
+            raise CodeGenError(
+                "Fortran only supports a single or no return value.")
+        elif len(routine.results) == 1:
+            result = routine.results[0]
+            code_list.append(result.get_datatype('fortran'))
+            code_list.append("function")
+        else:
+            code_list.append("subroutine")
+
+        args = ", ".join("%s" % self._get_symbol(arg.name)
+                        for arg in routine.arguments)
+
+        call_sig = "{}({})\n".format(routine.name, args)
+        # Fortran 95 requires all lines be less than 132 characters, so wrap
+        # this line before appending.
+        call_sig = ' &\n'.join(textwrap.wrap(call_sig,
+                                             width=60,
+                                             break_long_words=False)) + '\n'
+        code_list.append(call_sig)
+        code_list = [' '.join(code_list)]
+        code_list.append('implicit none\n')
+        return code_list
+
+    def _declare_arguments(self, routine):
+        # argument type declarations
+        code_list = []
+        array_list = []
+        scalar_list = []
+        for arg in routine.arguments:
+
+            if isinstance(arg, InputArgument):
+                typeinfo = "%s, intent(in)" % arg.get_datatype('fortran')
+            elif isinstance(arg, InOutArgument):
+                typeinfo = "%s, intent(inout)" % arg.get_datatype('fortran')
+            elif isinstance(arg, OutputArgument):
+                typeinfo = "%s, intent(out)" % arg.get_datatype('fortran')
+            else:
+                raise CodeGenError("Unknown Argument type: %s" % type(arg))
+
+            fprint = self._get_symbol
+
+            if arg.dimensions:
+                # fortran arrays start at 1
+                dimstr = ", ".join(["%s:%s" % (
+                    fprint(dim[0] + 1), fprint(dim[1] + 1))
+                    for dim in arg.dimensions])
+                typeinfo += ", dimension(%s)" % dimstr
+                array_list.append("%s :: %s\n" % (typeinfo, fprint(arg.name)))
+            else:
+                scalar_list.append("%s :: %s\n" % (typeinfo, fprint(arg.name)))
+
+        # scalars first, because they can be used in array declarations
+        code_list.extend(scalar_list)
+        code_list.extend(array_list)
+
+        return code_list
+
+    def _declare_globals(self, routine):
+        # Global variables not explicitly declared within Fortran 90 functions.
+        # Note: a future F77 mode may need to generate "common" blocks.
+        return []
+
+    def _declare_locals(self, routine):
+        code_list = []
+        for var in sorted(routine.local_vars, key=str):
+            typeinfo = get_default_datatype(var)
+            code_list.append("%s :: %s\n" % (
+                typeinfo.fname, self._get_symbol(var)))
+        return code_list
+
+    def _get_routine_ending(self, routine):
+        """Returns the closing statements of the fortran routine."""
+        if len(routine.results) == 1:
+            return ["end function\n"]
+        else:
+            return ["end subroutine\n"]
+
+    def get_interface(self, routine):
+        """Returns a string for the function interface.
+
+        The routine should have a single result object, which can be None.
+        If the routine has multiple result objects, a CodeGenError is
+        raised.
+
+        See: https://en.wikipedia.org/wiki/Function_prototype
+
+        """
+        prototype = [ "interface\n" ]
+        prototype.extend(self._get_routine_opening(routine))
+        prototype.extend(self._declare_arguments(routine))
+        prototype.extend(self._get_routine_ending(routine))
+        prototype.append("end interface\n")
+
+        return "".join(prototype)
+
+    def _call_printer(self, routine):
+        declarations = []
+        code_lines = []
+        for result in routine.result_variables:
+            if isinstance(result, Result):
+                assign_to = routine.name
+            elif isinstance(result, (OutputArgument, InOutArgument)):
+                assign_to = result.result_var
+
+            constants, not_fortran, f_expr = self._printer_method_with_settings(
+                'doprint', {"human": False, "source_format": 'free', "standard": 95},
+                result.expr, assign_to=assign_to)
+
+            for obj, v in sorted(constants, key=str):
+                t = get_default_datatype(obj)
+                declarations.append(
+                    "%s, parameter :: %s = %s\n" % (t.fname, obj, v))
+            for obj in sorted(not_fortran, key=str):
+                t = get_default_datatype(obj)
+                if isinstance(obj, Function):
+                    name = obj.func
+                else:
+                    name = obj
+                declarations.append("%s :: %s\n" % (t.fname, name))
+
+            code_lines.append("%s\n" % f_expr)
+        return declarations + code_lines
+
+    def _indent_code(self, codelines):
+        return self._printer_method_with_settings(
+            'indent_code', {"human": False, "source_format": 'free'}, codelines)
+
+    def dump_f95(self, routines, f, prefix, header=True, empty=True):
+        # check that symbols are unique with ignorecase
+        for r in routines:
+            lowercase = {str(x).lower() for x in r.variables}
+            orig_case = {str(x) for x in r.variables}
+            if len(lowercase) < len(orig_case):
+                raise CodeGenError("Fortran ignores case. Got symbols: %s" %
+                        (", ".join([str(var) for var in r.variables])))
+        self.dump_code(routines, f, prefix, header, empty)
+    dump_f95.extension = code_extension  # type: ignore
+    dump_f95.__doc__ = CodeGen.dump_code.__doc__
+
+    def dump_h(self, routines, f, prefix, header=True, empty=True):
+        """Writes the interface to a header file.
+
+        This file contains all the function declarations.
+
+        Parameters
+        ==========
+
+        routines : list
+            A list of Routine instances.
+
+        f : file-like
+            Where to write the file.
+
+        prefix : string
+            The filename prefix.
+
+        header : bool, optional
+            When True, a header comment is included on top of each source
+            file.  [default : True]
+
+        empty : bool, optional
+            When True, empty lines are included to structure the source
+            files.  [default : True]
+
+        """
+        if header:
+            print(''.join(self._get_header()), file=f)
+        if empty:
+            print(file=f)
+        # declaration of the function prototypes
+        for routine in routines:
+            prototype = self.get_interface(routine)
+            f.write(prototype)
+        if empty:
+            print(file=f)
+    dump_h.extension = interface_extension  # type: ignore
+
+    # This list of dump functions is used by CodeGen.write to know which dump
+    # functions it has to call.
+    dump_fns = [dump_f95, dump_h]
+
+
+class JuliaCodeGen(CodeGen):
+    """Generator for Julia code.
+
+    The .write() method inherited from CodeGen will output a code file
+    <prefix>.jl.
+
+    """
+
+    code_extension = "jl"
+
+    def __init__(self, project='project', printer=None):
+        super().__init__(project)
+        self.printer = printer or JuliaCodePrinter()
+
+    def routine(self, name, expr, argument_sequence, global_vars):
+        """Specialized Routine creation for Julia."""
+
+        if is_sequence(expr) and not isinstance(expr, (MatrixBase, MatrixExpr)):
+            if not expr:
+                raise ValueError("No expression given")
+            expressions = Tuple(*expr)
+        else:
+            expressions = Tuple(expr)
+
+        # local variables
+        local_vars = {i.label for i in expressions.atoms(Idx)}
+
+        # global variables
+        global_vars = set() if global_vars is None else set(global_vars)
+
+        # symbols that should be arguments
+        old_symbols = expressions.free_symbols - local_vars - global_vars
+        symbols = set()
+        for s in old_symbols:
+            if isinstance(s, Idx):
+                symbols.update(s.args[1].free_symbols)
+            elif not isinstance(s, Indexed):
+                symbols.add(s)
+
+        # Julia supports multiple return values
+        return_vals = []
+        output_args = []
+        for (i, expr) in enumerate(expressions):
+            if isinstance(expr, Equality):
+                out_arg = expr.lhs
+                expr = expr.rhs
+                symbol = out_arg
+                if isinstance(out_arg, Indexed):
+                    dims = tuple([ (S.One, dim) for dim in out_arg.shape])
+                    symbol = out_arg.base.label
+                    output_args.append(InOutArgument(symbol, out_arg, expr, dimensions=dims))
+                if not isinstance(out_arg, (Indexed, Symbol, MatrixSymbol)):
+                    raise CodeGenError("Only Indexed, Symbol, or MatrixSymbol "
+                                       "can define output arguments.")
+
+                return_vals.append(Result(expr, name=symbol, result_var=out_arg))
+                if not expr.has(symbol):
+                    # this is a pure output: remove from the symbols list, so
+                    # it doesn't become an input.
+                    symbols.remove(symbol)
+
+            else:
+                # we have no name for this output
+                return_vals.append(Result(expr, name='out%d' % (i+1)))
+
+        # setup input argument list
+        output_args.sort(key=lambda x: str(x.name))
+        arg_list = list(output_args)
+        array_symbols = {}
+        for array in expressions.atoms(Indexed):
+            array_symbols[array.base.label] = array
+        for array in expressions.atoms(MatrixSymbol):
+            array_symbols[array] = array
+
+        for symbol in sorted(symbols, key=str):
+            arg_list.append(InputArgument(symbol))
+
+        if argument_sequence is not None:
+            # if the user has supplied IndexedBase instances, we'll accept that
+            new_sequence = []
+            for arg in argument_sequence:
+                if isinstance(arg, IndexedBase):
+                    new_sequence.append(arg.label)
+                else:
+                    new_sequence.append(arg)
+            argument_sequence = new_sequence
+
+            missing = [x for x in arg_list if x.name not in argument_sequence]
+            if missing:
+                msg = "Argument list didn't specify: {0} "
+                msg = msg.format(", ".join([str(m.name) for m in missing]))
+                raise CodeGenArgumentListError(msg, missing)
+
+            # create redundant arguments to produce the requested sequence
+            name_arg_dict = {x.name: x for x in arg_list}
+            new_args = []
+            for symbol in argument_sequence:
+                try:
+                    new_args.append(name_arg_dict[symbol])
+                except KeyError:
+                    new_args.append(InputArgument(symbol))
+            arg_list = new_args
+
+        return Routine(name, arg_list, return_vals, local_vars, global_vars)
+
+    def _get_header(self):
+        """Writes a common header for the generated files."""
+        code_lines = []
+        tmp = header_comment % {"version": sympy_version,
+            "project": self.project}
+        for line in tmp.splitlines():
+            if line == '':
+                code_lines.append("#\n")
+            else:
+                code_lines.append("#   %s\n" % line)
+        return code_lines
+
+    def _preprocessor_statements(self, prefix):
+        return []
+
+    def _get_routine_opening(self, routine):
+        """Returns the opening statements of the routine."""
+        code_list = []
+        code_list.append("function ")
+
+        # Inputs
+        args = []
+        for i, arg in enumerate(routine.arguments):
+            if isinstance(arg, OutputArgument):
+                raise CodeGenError("Julia: invalid argument of type %s" %
+                                   str(type(arg)))
+            if isinstance(arg, (InputArgument, InOutArgument)):
+                args.append("%s" % self._get_symbol(arg.name))
+        args = ", ".join(args)
+        code_list.append("%s(%s)\n" % (routine.name, args))
+        code_list = [ "".join(code_list) ]
+
+        return code_list
+
+    def _declare_arguments(self, routine):
+        return []
+
+    def _declare_globals(self, routine):
+        return []
+
+    def _declare_locals(self, routine):
+        return []
+
+    def _get_routine_ending(self, routine):
+        outs = []
+        for result in routine.results:
+            if isinstance(result, Result):
+                # Note: name not result_var; want `y` not `y[i]` for Indexed
+                s = self._get_symbol(result.name)
+            else:
+                raise CodeGenError("unexpected object in Routine results")
+            outs.append(s)
+        return ["return " + ", ".join(outs) + "\nend\n"]
+
+    def _call_printer(self, routine):
+        declarations = []
+        code_lines = []
+        for i, result in enumerate(routine.results):
+            if isinstance(result, Result):
+                assign_to = result.result_var
+            else:
+                raise CodeGenError("unexpected object in Routine results")
+
+            constants, not_supported, jl_expr = self._printer_method_with_settings(
+                'doprint', {"human": False}, result.expr, assign_to=assign_to)
+
+            for obj, v in sorted(constants, key=str):
+                declarations.append(
+                    "%s = %s\n" % (obj, v))
+            for obj in sorted(not_supported, key=str):
+                if isinstance(obj, Function):
+                    name = obj.func
+                else:
+                    name = obj
+                declarations.append(
+                    "# unsupported: %s\n" % (name))
+            code_lines.append("%s\n" % (jl_expr))
+        return declarations + code_lines
+
+    def _indent_code(self, codelines):
+        # Note that indenting seems to happen twice, first
+        # statement-by-statement by JuliaPrinter then again here.
+        p = JuliaCodePrinter({'human': False})
+        return p.indent_code(codelines)
+
+    def dump_jl(self, routines, f, prefix, header=True, empty=True):
+        self.dump_code(routines, f, prefix, header, empty)
+
+    dump_jl.extension = code_extension  # type: ignore
+    dump_jl.__doc__ = CodeGen.dump_code.__doc__
+
+    # This list of dump functions is used by CodeGen.write to know which dump
+    # functions it has to call.
+    dump_fns = [dump_jl]
+
+
+class OctaveCodeGen(CodeGen):
+    """Generator for Octave code.
+
+    The .write() method inherited from CodeGen will output a code file
+    <prefix>.m.
+
+    Octave .m files usually contain one function.  That function name should
+    match the filename (``prefix``).  If you pass multiple ``name_expr`` pairs,
+    the latter ones are presumed to be private functions accessed by the
+    primary function.
+
+    You should only pass inputs to ``argument_sequence``: outputs are ordered
+    according to their order in ``name_expr``.
+
+    """
+
+    code_extension = "m"
+
+    def __init__(self, project='project', printer=None):
+        super().__init__(project)
+        self.printer = printer or OctaveCodePrinter()
+
+    def routine(self, name, expr, argument_sequence, global_vars):
+        """Specialized Routine creation for Octave."""
+
+        # FIXME: this is probably general enough for other high-level
+        # languages, perhaps its the C/Fortran one that is specialized!
+
+        if is_sequence(expr) and not isinstance(expr, (MatrixBase, MatrixExpr)):
+            if not expr:
+                raise ValueError("No expression given")
+            expressions = Tuple(*expr)
+        else:
+            expressions = Tuple(expr)
+
+        # local variables
+        local_vars = {i.label for i in expressions.atoms(Idx)}
+
+        # global variables
+        global_vars = set() if global_vars is None else set(global_vars)
+
+        # symbols that should be arguments
+        old_symbols = expressions.free_symbols - local_vars - global_vars
+        symbols = set()
+        for s in old_symbols:
+            if isinstance(s, Idx):
+                symbols.update(s.args[1].free_symbols)
+            elif not isinstance(s, Indexed):
+                symbols.add(s)
+
+        # Octave supports multiple return values
+        return_vals = []
+        for (i, expr) in enumerate(expressions):
+            if isinstance(expr, Equality):
+                out_arg = expr.lhs
+                expr = expr.rhs
+                symbol = out_arg
+                if isinstance(out_arg, Indexed):
+                    symbol = out_arg.base.label
+                if not isinstance(out_arg, (Indexed, Symbol, MatrixSymbol)):
+                    raise CodeGenError("Only Indexed, Symbol, or MatrixSymbol "
+                                       "can define output arguments.")
+
+                return_vals.append(Result(expr, name=symbol, result_var=out_arg))
+                if not expr.has(symbol):
+                    # this is a pure output: remove from the symbols list, so
+                    # it doesn't become an input.
+                    symbols.remove(symbol)
+
+            else:
+                # we have no name for this output
+                return_vals.append(Result(expr, name='out%d' % (i+1)))
+
+        # setup input argument list
+        arg_list = []
+        array_symbols = {}
+        for array in expressions.atoms(Indexed):
+            array_symbols[array.base.label] = array
+        for array in expressions.atoms(MatrixSymbol):
+            array_symbols[array] = array
+
+        for symbol in sorted(symbols, key=str):
+            arg_list.append(InputArgument(symbol))
+
+        if argument_sequence is not None:
+            # if the user has supplied IndexedBase instances, we'll accept that
+            new_sequence = []
+            for arg in argument_sequence:
+                if isinstance(arg, IndexedBase):
+                    new_sequence.append(arg.label)
+                else:
+                    new_sequence.append(arg)
+            argument_sequence = new_sequence
+
+            missing = [x for x in arg_list if x.name not in argument_sequence]
+            if missing:
+                msg = "Argument list didn't specify: {0} "
+                msg = msg.format(", ".join([str(m.name) for m in missing]))
+                raise CodeGenArgumentListError(msg, missing)
+
+            # create redundant arguments to produce the requested sequence
+            name_arg_dict = {x.name: x for x in arg_list}
+            new_args = []
+            for symbol in argument_sequence:
+                try:
+                    new_args.append(name_arg_dict[symbol])
+                except KeyError:
+                    new_args.append(InputArgument(symbol))
+            arg_list = new_args
+
+        return Routine(name, arg_list, return_vals, local_vars, global_vars)
+
+    def _get_header(self):
+        """Writes a common header for the generated files."""
+        code_lines = []
+        tmp = header_comment % {"version": sympy_version,
+            "project": self.project}
+        for line in tmp.splitlines():
+            if line == '':
+                code_lines.append("%\n")
+            else:
+                code_lines.append("%%   %s\n" % line)
+        return code_lines
+
+    def _preprocessor_statements(self, prefix):
+        return []
+
+    def _get_routine_opening(self, routine):
+        """Returns the opening statements of the routine."""
+        code_list = []
+        code_list.append("function ")
+
+        # Outputs
+        outs = []
+        for i, result in enumerate(routine.results):
+            if isinstance(result, Result):
+                # Note: name not result_var; want `y` not `y(i)` for Indexed
+                s = self._get_symbol(result.name)
+            else:
+                raise CodeGenError("unexpected object in Routine results")
+            outs.append(s)
+        if len(outs) > 1:
+            code_list.append("[" + (", ".join(outs)) + "]")
+        else:
+            code_list.append("".join(outs))
+        code_list.append(" = ")
+
+        # Inputs
+        args = []
+        for i, arg in enumerate(routine.arguments):
+            if isinstance(arg, (OutputArgument, InOutArgument)):
+                raise CodeGenError("Octave: invalid argument of type %s" %
+                                   str(type(arg)))
+            if isinstance(arg, InputArgument):
+                args.append("%s" % self._get_symbol(arg.name))
+        args = ", ".join(args)
+        code_list.append("%s(%s)\n" % (routine.name, args))
+        code_list = [ "".join(code_list) ]
+
+        return code_list
+
+    def _declare_arguments(self, routine):
+        return []
+
+    def _declare_globals(self, routine):
+        if not routine.global_vars:
+            return []
+        s = " ".join(sorted([self._get_symbol(g) for g in routine.global_vars]))
+        return ["global " + s + "\n"]
+
+    def _declare_locals(self, routine):
+        return []
+
+    def _get_routine_ending(self, routine):
+        return ["end\n"]
+
+    def _call_printer(self, routine):
+        declarations = []
+        code_lines = []
+        for i, result in enumerate(routine.results):
+            if isinstance(result, Result):
+                assign_to = result.result_var
+            else:
+                raise CodeGenError("unexpected object in Routine results")
+
+            constants, not_supported, oct_expr = self._printer_method_with_settings(
+                'doprint', {"human": False}, result.expr, assign_to=assign_to)
+
+            for obj, v in sorted(constants, key=str):
+                declarations.append(
+                    "  %s = %s;  %% constant\n" % (obj, v))
+            for obj in sorted(not_supported, key=str):
+                if isinstance(obj, Function):
+                    name = obj.func
+                else:
+                    name = obj
+                declarations.append(
+                    "  %% unsupported: %s\n" % (name))
+            code_lines.append("%s\n" % (oct_expr))
+        return declarations + code_lines
+
+    def _indent_code(self, codelines):
+        return self._printer_method_with_settings(
+            'indent_code', {"human": False}, codelines)
+
+    def dump_m(self, routines, f, prefix, header=True, empty=True, inline=True):
+        # Note used to call self.dump_code() but we need more control for header
+
+        code_lines = self._preprocessor_statements(prefix)
+
+        for i, routine in enumerate(routines):
+            if i > 0:
+                if empty:
+                    code_lines.append("\n")
+            code_lines.extend(self._get_routine_opening(routine))
+            if i == 0:
+                if routine.name != prefix:
+                    raise ValueError('Octave function name should match prefix')
+                if header:
+                    code_lines.append("%" + prefix.upper() +
+                                      "  Autogenerated by SymPy\n")
+                    code_lines.append(''.join(self._get_header()))
+            code_lines.extend(self._declare_arguments(routine))
+            code_lines.extend(self._declare_globals(routine))
+            code_lines.extend(self._declare_locals(routine))
+            if empty:
+                code_lines.append("\n")
+            code_lines.extend(self._call_printer(routine))
+            if empty:
+                code_lines.append("\n")
+            code_lines.extend(self._get_routine_ending(routine))
+
+        code_lines = self._indent_code(''.join(code_lines))
+
+        if code_lines:
+            f.write(code_lines)
+
+    dump_m.extension = code_extension  # type: ignore
+    dump_m.__doc__ = CodeGen.dump_code.__doc__
+
+    # This list of dump functions is used by CodeGen.write to know which dump
+    # functions it has to call.
+    dump_fns = [dump_m]
+
+class RustCodeGen(CodeGen):
+    """Generator for Rust code.
+
+    The .write() method inherited from CodeGen will output a code file
+    <prefix>.rs
+
+    """
+
+    code_extension = "rs"
+
+    def __init__(self, project="project", printer=None):
+        super().__init__(project=project)
+        self.printer = printer or RustCodePrinter()
+
+    def routine(self, name, expr, argument_sequence, global_vars):
+        """Specialized Routine creation for Rust."""
+
+        if is_sequence(expr) and not isinstance(expr, (MatrixBase, MatrixExpr)):
+            if not expr:
+                raise ValueError("No expression given")
+            expressions = Tuple(*expr)
+        else:
+            expressions = Tuple(expr)
+
+        # local variables
+        local_vars = {i.label for i in expressions.atoms(Idx)}
+
+        # global variables
+        global_vars = set() if global_vars is None else set(global_vars)
+
+        # symbols that should be arguments
+        symbols = expressions.free_symbols - local_vars - global_vars - expressions.atoms(Indexed)
+
+        # Rust supports multiple return values
+        return_vals = []
+        output_args = []
+        for (i, expr) in enumerate(expressions):
+            if isinstance(expr, Equality):
+                out_arg = expr.lhs
+                expr = expr.rhs
+                symbol = out_arg
+                if isinstance(out_arg, Indexed):
+                    dims = tuple([ (S.One, dim) for dim in out_arg.shape])
+                    symbol = out_arg.base.label
+                    output_args.append(InOutArgument(symbol, out_arg, expr, dimensions=dims))
+                if not isinstance(out_arg, (Indexed, Symbol, MatrixSymbol)):
+                    raise CodeGenError("Only Indexed, Symbol, or MatrixSymbol "
+                                       "can define output arguments.")
+
+                return_vals.append(Result(expr, name=symbol, result_var=out_arg))
+                if not expr.has(symbol):
+                    # this is a pure output: remove from the symbols list, so
+                    # it doesn't become an input.
+                    symbols.remove(symbol)
+
+            else:
+                # we have no name for this output
+                return_vals.append(Result(expr, name='out%d' % (i+1)))
+
+        # setup input argument list
+        output_args.sort(key=lambda x: str(x.name))
+        arg_list = list(output_args)
+        array_symbols = {}
+        for array in expressions.atoms(Indexed):
+            array_symbols[array.base.label] = array
+        for array in expressions.atoms(MatrixSymbol):
+            array_symbols[array] = array
+
+        for symbol in sorted(symbols, key=str):
+            arg_list.append(InputArgument(symbol))
+
+        if argument_sequence is not None:
+            # if the user has supplied IndexedBase instances, we'll accept that
+            new_sequence = []
+            for arg in argument_sequence:
+                if isinstance(arg, IndexedBase):
+                    new_sequence.append(arg.label)
+                else:
+                    new_sequence.append(arg)
+            argument_sequence = new_sequence
+
+            missing = [x for x in arg_list if x.name not in argument_sequence]
+            if missing:
+                msg = "Argument list didn't specify: {0} "
+                msg = msg.format(", ".join([str(m.name) for m in missing]))
+                raise CodeGenArgumentListError(msg, missing)
+
+            # create redundant arguments to produce the requested sequence
+            name_arg_dict = {x.name: x for x in arg_list}
+            new_args = []
+            for symbol in argument_sequence:
+                try:
+                    new_args.append(name_arg_dict[symbol])
+                except KeyError:
+                    new_args.append(InputArgument(symbol))
+            arg_list = new_args
+
+        return Routine(name, arg_list, return_vals, local_vars, global_vars)
+
+
+    def _get_header(self):
+        """Writes a common header for the generated files."""
+        code_lines = []
+        code_lines.append("/*\n")
+        tmp = header_comment % {"version": sympy_version,
+                                "project": self.project}
+        for line in tmp.splitlines():
+            code_lines.append((" *%s" % line.center(76)).rstrip() + "\n")
+        code_lines.append(" */\n")
+        return code_lines
+
+    def get_prototype(self, routine):
+        """Returns a string for the function prototype of the routine.
+
+        If the routine has multiple result objects, an CodeGenError is
+        raised.
+
+        See: https://en.wikipedia.org/wiki/Function_prototype
+
+        """
+        results = [i.get_datatype('Rust') for i in routine.results]
+
+        if len(results) == 1:
+            rstype = " -> " + results[0]
+        elif len(routine.results) > 1:
+            rstype = " -> (" + ", ".join(results) + ")"
+        else:
+            rstype = ""
+
+        type_args = []
+        for arg in routine.arguments:
+            name = self.printer.doprint(arg.name)
+            if arg.dimensions or isinstance(arg, ResultBase):
+                type_args.append(("*%s" % name, arg.get_datatype('Rust')))
+            else:
+                type_args.append((name, arg.get_datatype('Rust')))
+        arguments = ", ".join([ "%s: %s" % t for t in type_args])
+        return "fn %s(%s)%s" % (routine.name, arguments, rstype)
+
+    def _preprocessor_statements(self, prefix):
+        code_lines = []
+        # code_lines.append("use std::f64::consts::*;\n")
+        return code_lines
+
+    def _get_routine_opening(self, routine):
+        prototype = self.get_prototype(routine)
+        return ["%s {\n" % prototype]
+
+    def _declare_arguments(self, routine):
+        # arguments are declared in prototype
+        return []
+
+    def _declare_globals(self, routine):
+        # global variables are not explicitly declared within C functions
+        return []
+
+    def _declare_locals(self, routine):
+        # loop variables are declared in loop statement
+        return []
+
+    def _call_printer(self, routine):
+
+        code_lines = []
+        declarations = []
+        returns = []
+
+        # Compose a list of symbols to be dereferenced in the function
+        # body. These are the arguments that were passed by a reference
+        # pointer, excluding arrays.
+        dereference = []
+        for arg in routine.arguments:
+            if isinstance(arg, ResultBase) and not arg.dimensions:
+                dereference.append(arg.name)
+
+        for i, result in enumerate(routine.results):
+            if isinstance(result, Result):
+                assign_to = result.result_var
+                returns.append(str(result.result_var))
+            else:
+                raise CodeGenError("unexpected object in Routine results")
+
+            constants, not_supported, rs_expr = self._printer_method_with_settings(
+                'doprint', {"human": False}, result.expr, assign_to=assign_to)
+
+            for name, value in sorted(constants, key=str):
+                declarations.append("const %s: f64 = %s;\n" % (name, value))
+
+            for obj in sorted(not_supported, key=str):
+                if isinstance(obj, Function):
+                    name = obj.func
+                else:
+                    name = obj
+                declarations.append("// unsupported: %s\n" % (name))
+
+            code_lines.append("let %s\n" % rs_expr);
+
+        if len(returns) > 1:
+            returns = ['(' + ', '.join(returns) + ')']
+
+        returns.append('\n')
+
+        return declarations + code_lines + returns
+
+    def _get_routine_ending(self, routine):
+        return ["}\n"]
+
+    def dump_rs(self, routines, f, prefix, header=True, empty=True):
+        self.dump_code(routines, f, prefix, header, empty)
+
+    dump_rs.extension = code_extension  # type: ignore
+    dump_rs.__doc__ = CodeGen.dump_code.__doc__
+
+    # This list of dump functions is used by CodeGen.write to know which dump
+    # functions it has to call.
+    dump_fns = [dump_rs]
+
+
+
+
+def get_code_generator(language, project=None, standard=None, printer = None):
+    if language == 'C':
+        if standard is None:
+            pass
+        elif standard.lower() == 'c89':
+            language = 'C89'
+        elif standard.lower() == 'c99':
+            language = 'C99'
+    CodeGenClass = {"C": CCodeGen, "C89": C89CodeGen, "C99": C99CodeGen,
+                    "F95": FCodeGen, "JULIA": JuliaCodeGen,
+                    "OCTAVE": OctaveCodeGen,
+                    "RUST": RustCodeGen}.get(language.upper())
+    if CodeGenClass is None:
+        raise ValueError("Language '%s' is not supported." % language)
+    return CodeGenClass(project, printer)
+
+
+#
+# Friendly functions
+#
+
+
+def codegen(name_expr, language=None, prefix=None, project="project",
+            to_files=False, header=True, empty=True, argument_sequence=None,
+            global_vars=None, standard=None, code_gen=None, printer = None):
+    """Generate source code for expressions in a given language.
+
+    Parameters
+    ==========
+
+    name_expr : tuple, or list of tuples
+        A single (name, expression) tuple or a list of (name, expression)
+        tuples.  Each tuple corresponds to a routine.  If the expression is
+        an equality (an instance of class Equality) the left hand side is
+        considered an output argument.  If expression is an iterable, then
+        the routine will have multiple outputs.
+
+    language : string,
+        A string that indicates the source code language.  This is case
+        insensitive.  Currently, 'C', 'F95' and 'Octave' are supported.
+        'Octave' generates code compatible with both Octave and Matlab.
+
+    prefix : string, optional
+        A prefix for the names of the files that contain the source code.
+        Language-dependent suffixes will be appended.  If omitted, the name
+        of the first name_expr tuple is used.
+
+    project : string, optional
+        A project name, used for making unique preprocessor instructions.
+        [default: "project"]
+
+    to_files : bool, optional
+        When True, the code will be written to one or more files with the
+        given prefix, otherwise strings with the names and contents of
+        these files are returned. [default: False]
+
+    header : bool, optional
+        When True, a header is written on top of each source file.
+        [default: True]
+
+    empty : bool, optional
+        When True, empty lines are used to structure the code.
+        [default: True]
+
+    argument_sequence : iterable, optional
+        Sequence of arguments for the routine in a preferred order.  A
+        CodeGenError is raised if required arguments are missing.
+        Redundant arguments are used without warning.  If omitted,
+        arguments will be ordered alphabetically, but with all input
+        arguments first, and then output or in-out arguments.
+
+    global_vars : iterable, optional
+        Sequence of global variables used by the routine.  Variables
+        listed here will not show up as function arguments.
+
+    standard : string
+
+    code_gen : CodeGen instance
+        An instance of a CodeGen subclass. Overrides ``language``.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.codegen import codegen
+    >>> from sympy.abc import x, y, z
+    >>> [(c_name, c_code), (h_name, c_header)] = codegen(
+    ...     ("f", x+y*z), "C89", "test", header=False, empty=False)
+    >>> print(c_name)
+    test.c
+    >>> print(c_code)
+    #include "test.h"
+    #include <math.h>
+    double f(double x, double y, double z) {
+       double f_result;
+       f_result = x + y*z;
+       return f_result;
+    }
+    <BLANKLINE>
+    >>> print(h_name)
+    test.h
+    >>> print(c_header)
+    #ifndef PROJECT__TEST__H
+    #define PROJECT__TEST__H
+    double f(double x, double y, double z);
+    #endif
+    <BLANKLINE>
+
+    Another example using Equality objects to give named outputs.  Here the
+    filename (prefix) is taken from the first (name, expr) pair.
+
+    >>> from sympy.abc import f, g
+    >>> from sympy import Eq
+    >>> [(c_name, c_code), (h_name, c_header)] = codegen(
+    ...      [("myfcn", x + y), ("fcn2", [Eq(f, 2*x), Eq(g, y)])],
+    ...      "C99", header=False, empty=False)
+    >>> print(c_name)
+    myfcn.c
+    >>> print(c_code)
+    #include "myfcn.h"
+    #include <math.h>
+    double myfcn(double x, double y) {
+       double myfcn_result;
+       myfcn_result = x + y;
+       return myfcn_result;
+    }
+    void fcn2(double x, double y, double *f, double *g) {
+       (*f) = 2*x;
+       (*g) = y;
+    }
+    <BLANKLINE>
+
+    If the generated function(s) will be part of a larger project where various
+    global variables have been defined, the 'global_vars' option can be used
+    to remove the specified variables from the function signature
+
+    >>> from sympy.utilities.codegen import codegen
+    >>> from sympy.abc import x, y, z
+    >>> [(f_name, f_code), header] = codegen(
+    ...     ("f", x+y*z), "F95", header=False, empty=False,
+    ...     argument_sequence=(x, y), global_vars=(z,))
+    >>> print(f_code)
+    REAL*8 function f(x, y)
+    implicit none
+    REAL*8, intent(in) :: x
+    REAL*8, intent(in) :: y
+    f = x + y*z
+    end function
+    <BLANKLINE>
+
+    """
+
+    # Initialize the code generator.
+    if language is None:
+        if code_gen is None:
+            raise ValueError("Need either language or code_gen")
+    else:
+        if code_gen is not None:
+            raise ValueError("You cannot specify both language and code_gen.")
+        code_gen = get_code_generator(language, project, standard, printer)
+
+    if isinstance(name_expr[0], str):
+        # single tuple is given, turn it into a singleton list with a tuple.
+        name_expr = [name_expr]
+
+    if prefix is None:
+        prefix = name_expr[0][0]
+
+    # Construct Routines appropriate for this code_gen from (name, expr) pairs.
+    routines = []
+    for name, expr in name_expr:
+        routines.append(code_gen.routine(name, expr, argument_sequence,
+                                         global_vars))
+
+    # Write the code.
+    return code_gen.write(routines, prefix, to_files, header, empty)
+
+
+def make_routine(name, expr, argument_sequence=None,
+                 global_vars=None, language="F95"):
+    """A factory that makes an appropriate Routine from an expression.
+
+    Parameters
+    ==========
+
+    name : string
+        The name of this routine in the generated code.
+
+    expr : expression or list/tuple of expressions
+        A SymPy expression that the Routine instance will represent.  If
+        given a list or tuple of expressions, the routine will be
+        considered to have multiple return values and/or output arguments.
+
+    argument_sequence : list or tuple, optional
+        List arguments for the routine in a preferred order.  If omitted,
+        the results are language dependent, for example, alphabetical order
+        or in the same order as the given expressions.
+
+    global_vars : iterable, optional
+        Sequence of global variables used by the routine.  Variables
+        listed here will not show up as function arguments.
+
+    language : string, optional
+        Specify a target language.  The Routine itself should be
+        language-agnostic but the precise way one is created, error
+        checking, etc depend on the language.  [default: "F95"].
+
+    Notes
+    =====
+
+    A decision about whether to use output arguments or return values is made
+    depending on both the language and the particular mathematical expressions.
+    For an expression of type Equality, the left hand side is typically made
+    into an OutputArgument (or perhaps an InOutArgument if appropriate).
+    Otherwise, typically, the calculated expression is made a return values of
+    the routine.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.codegen import make_routine
+    >>> from sympy.abc import x, y, f, g
+    >>> from sympy import Eq
+    >>> r = make_routine('test', [Eq(f, 2*x), Eq(g, x + y)])
+    >>> [arg.result_var for arg in r.results]
+    []
+    >>> [arg.name for arg in r.arguments]
+    [x, y, f, g]
+    >>> [arg.name for arg in r.result_variables]
+    [f, g]
+    >>> r.local_vars
+    set()
+
+    Another more complicated example with a mixture of specified and
+    automatically-assigned names.  Also has Matrix output.
+
+    >>> from sympy import Matrix
+    >>> r = make_routine('fcn', [x*y, Eq(f, 1), Eq(g, x + g), Matrix([[x, 2]])])
+    >>> [arg.result_var for arg in r.results]  # doctest: +SKIP
+    [result_5397460570204848505]
+    >>> [arg.expr for arg in r.results]
+    [x*y]
+    >>> [arg.name for arg in r.arguments]  # doctest: +SKIP
+    [x, y, f, g, out_8598435338387848786]
+
+    We can examine the various arguments more closely:
+
+    >>> from sympy.utilities.codegen import (InputArgument, OutputArgument,
+    ...                                      InOutArgument)
+    >>> [a.name for a in r.arguments if isinstance(a, InputArgument)]
+    [x, y]
+
+    >>> [a.name for a in r.arguments if isinstance(a, OutputArgument)]  # doctest: +SKIP
+    [f, out_8598435338387848786]
+    >>> [a.expr for a in r.arguments if isinstance(a, OutputArgument)]
+    [1, Matrix([[x, 2]])]
+
+    >>> [a.name for a in r.arguments if isinstance(a, InOutArgument)]
+    [g]
+    >>> [a.expr for a in r.arguments if isinstance(a, InOutArgument)]
+    [g + x]
+
+    """
+
+    # initialize a new code generator
+    code_gen = get_code_generator(language)
+
+    return code_gen.routine(name, expr, argument_sequence, global_vars)

venv/lib/python3.10/site-packages/sympy/utilities/decorator.py

@@ -0,0 +1,330 @@
+"""Useful utility decorators. """
+
+import sys
+import types
+import inspect
+from functools import wraps, update_wrapper
+
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+def threaded_factory(func, use_add):
+    """A factory for ``threaded`` decorators. """
+    from sympy.core import sympify
+    from sympy.matrices import MatrixBase
+    from sympy.utilities.iterables import iterable
+
+    @wraps(func)
+    def threaded_func(expr, *args, **kwargs):
+        if isinstance(expr, MatrixBase):
+            return expr.applyfunc(lambda f: func(f, *args, **kwargs))
+        elif iterable(expr):
+            try:
+                return expr.__class__([func(f, *args, **kwargs) for f in expr])
+            except TypeError:
+                return expr
+        else:
+            expr = sympify(expr)
+
+            if use_add and expr.is_Add:
+                return expr.__class__(*[ func(f, *args, **kwargs) for f in expr.args ])
+            elif expr.is_Relational:
+                return expr.__class__(func(expr.lhs, *args, **kwargs),
+                                      func(expr.rhs, *args, **kwargs))
+            else:
+                return func(expr, *args, **kwargs)
+
+    return threaded_func
+
+
+def threaded(func):
+    """Apply ``func`` to sub--elements of an object, including :class:`~.Add`.
+
+    This decorator is intended to make it uniformly possible to apply a
+    function to all elements of composite objects, e.g. matrices, lists, tuples
+    and other iterable containers, or just expressions.
+
+    This version of :func:`threaded` decorator allows threading over
+    elements of :class:`~.Add` class. If this behavior is not desirable
+    use :func:`xthreaded` decorator.
+
+    Functions using this decorator must have the following signature::
+
+      @threaded
+      def function(expr, *args, **kwargs):
+
+    """
+    return threaded_factory(func, True)
+
+
+def xthreaded(func):
+    """Apply ``func`` to sub--elements of an object, excluding :class:`~.Add`.
+
+    This decorator is intended to make it uniformly possible to apply a
+    function to all elements of composite objects, e.g. matrices, lists, tuples
+    and other iterable containers, or just expressions.
+
+    This version of :func:`threaded` decorator disallows threading over
+    elements of :class:`~.Add` class. If this behavior is not desirable
+    use :func:`threaded` decorator.
+
+    Functions using this decorator must have the following signature::
+
+      @xthreaded
+      def function(expr, *args, **kwargs):
+
+    """
+    return threaded_factory(func, False)
+
+
+def conserve_mpmath_dps(func):
+    """After the function finishes, resets the value of mpmath.mp.dps to
+    the value it had before the function was run."""
+    import mpmath
+
+    def func_wrapper(*args, **kwargs):
+        dps = mpmath.mp.dps
+        try:
+            return func(*args, **kwargs)
+        finally:
+            mpmath.mp.dps = dps
+
+    func_wrapper = update_wrapper(func_wrapper, func)
+    return func_wrapper
+
+
+class no_attrs_in_subclass:
+    """Don't 'inherit' certain attributes from a base class
+
+    >>> from sympy.utilities.decorator import no_attrs_in_subclass
+
+    >>> class A(object):
+    ...     x = 'test'
+
+    >>> A.x = no_attrs_in_subclass(A, A.x)
+
+    >>> class B(A):
+    ...     pass
+
+    >>> hasattr(A, 'x')
+    True
+    >>> hasattr(B, 'x')
+    False
+
+    """
+    def __init__(self, cls, f):
+        self.cls = cls
+        self.f = f
+
+    def __get__(self, instance, owner=None):
+        if owner == self.cls:
+            if hasattr(self.f, '__get__'):
+                return self.f.__get__(instance, owner)
+            return self.f
+        raise AttributeError
+
+
+def doctest_depends_on(exe=None, modules=None, disable_viewers=None, python_version=None):
+    """
+    Adds metadata about the dependencies which need to be met for doctesting
+    the docstrings of the decorated objects.
+
+    exe should be a list of executables
+
+    modules should be a list of modules
+
+    disable_viewers should be a list of viewers for preview() to disable
+
+    python_version should be the minimum Python version required, as a tuple
+    (like (3, 0))
+    """
+    dependencies = {}
+    if exe is not None:
+        dependencies['executables'] = exe
+    if modules is not None:
+        dependencies['modules'] = modules
+    if disable_viewers is not None:
+        dependencies['disable_viewers'] = disable_viewers
+    if python_version is not None:
+        dependencies['python_version'] = python_version
+
+    def skiptests():
+        from sympy.testing.runtests import DependencyError, SymPyDocTests, PyTestReporter # lazy import
+        r = PyTestReporter()
+        t = SymPyDocTests(r, None)
+        try:
+            t._check_dependencies(**dependencies)
+        except DependencyError:
+            return True  # Skip doctests
+        else:
+            return False # Run doctests
+
+    def depends_on_deco(fn):
+        fn._doctest_depends_on = dependencies
+        fn.__doctest_skip__ = skiptests
+
+        if inspect.isclass(fn):
+            fn._doctest_depdends_on = no_attrs_in_subclass(
+                fn, fn._doctest_depends_on)
+            fn.__doctest_skip__ = no_attrs_in_subclass(
+                fn, fn.__doctest_skip__)
+        return fn
+
+    return depends_on_deco
+
+
+def public(obj):
+    """
+    Append ``obj``'s name to global ``__all__`` variable (call site).
+
+    By using this decorator on functions or classes you achieve the same goal
+    as by filling ``__all__`` variables manually, you just do not have to repeat
+    yourself (object's name). You also know if object is public at definition
+    site, not at some random location (where ``__all__`` was set).
+
+    Note that in multiple decorator setup (in almost all cases) ``@public``
+    decorator must be applied before any other decorators, because it relies
+    on the pointer to object's global namespace. If you apply other decorators
+    first, ``@public`` may end up modifying the wrong namespace.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.decorator import public
+
+    >>> __all__ # noqa: F821
+    Traceback (most recent call last):
+    ...
+    NameError: name '__all__' is not defined
+
+    >>> @public
+    ... def some_function():
+    ...     pass
+
+    >>> __all__ # noqa: F821
+    ['some_function']
+
+    """
+    if isinstance(obj, types.FunctionType):
+        ns = obj.__globals__
+        name = obj.__name__
+    elif isinstance(obj, (type(type), type)):
+        ns = sys.modules[obj.__module__].__dict__
+        name = obj.__name__
+    else:
+        raise TypeError("expected a function or a class, got %s" % obj)
+
+    if "__all__" not in ns:
+        ns["__all__"] = [name]
+    else:
+        ns["__all__"].append(name)
+
+    return obj
+
+
+def memoize_property(propfunc):
+    """Property decorator that caches the value of potentially expensive
+    `propfunc` after the first evaluation. The cached value is stored in
+    the corresponding property name with an attached underscore."""
+    attrname = '_' + propfunc.__name__
+    sentinel = object()
+
+    @wraps(propfunc)
+    def accessor(self):
+        val = getattr(self, attrname, sentinel)
+        if val is sentinel:
+            val = propfunc(self)
+            setattr(self, attrname, val)
+        return val
+
+    return property(accessor)
+
+
+def deprecated(message, *, deprecated_since_version,
+               active_deprecations_target, stacklevel=3):
+    '''
+    Mark a function as deprecated.
+
+    This decorator should be used if an entire function or class is
+    deprecated. If only a certain functionality is deprecated, you should use
+    :func:`~.warns_deprecated_sympy` directly. This decorator is just a
+    convenience. There is no functional difference between using this
+    decorator and calling ``warns_deprecated_sympy()`` at the top of the
+    function.
+
+    The decorator takes the same arguments as
+    :func:`~.warns_deprecated_sympy`. See its
+    documentation for details on what the keywords to this decorator do.
+
+    See the :ref:`deprecation-policy` document for details on when and how
+    things should be deprecated in SymPy.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.decorator import deprecated
+    >>> from sympy import simplify
+    >>> @deprecated("""\
+    ... The simplify_this(expr) function is deprecated. Use simplify(expr)
+    ... instead.""", deprecated_since_version="1.1",
+    ... active_deprecations_target='simplify-this-deprecation')
+    ... def simplify_this(expr):
+    ...     """
+    ...     Simplify ``expr``.
+    ...
+    ...     .. deprecated:: 1.1
+    ...
+    ...        The ``simplify_this`` function is deprecated. Use :func:`simplify`
+    ...        instead. See its documentation for more information. See
+    ...        :ref:`simplify-this-deprecation` for details.
+    ...
+    ...     """
+    ...     return simplify(expr)
+    >>> from sympy.abc import x
+    >>> simplify_this(x*(x + 1) - x**2) # doctest: +SKIP
+    <stdin>:1: SymPyDeprecationWarning:
+    <BLANKLINE>
+    The simplify_this(expr) function is deprecated. Use simplify(expr)
+    instead.
+    <BLANKLINE>
+    See https://docs.sympy.org/latest/explanation/active-deprecations.html#simplify-this-deprecation
+    for details.
+    <BLANKLINE>
+    This has been deprecated since SymPy version 1.1. It
+    will be removed in a future version of SymPy.
+    <BLANKLINE>
+      simplify_this(x)
+    x
+
+    See Also
+    ========
+    sympy.utilities.exceptions.SymPyDeprecationWarning
+    sympy.utilities.exceptions.sympy_deprecation_warning
+    sympy.utilities.exceptions.ignore_warnings
+    sympy.testing.pytest.warns_deprecated_sympy
+
+    '''
+    decorator_kwargs = {"deprecated_since_version": deprecated_since_version,
+               "active_deprecations_target": active_deprecations_target}
+    def deprecated_decorator(wrapped):
+        if hasattr(wrapped, '__mro__'):  # wrapped is actually a class
+            class wrapper(wrapped):
+                __doc__ = wrapped.__doc__
+                __module__ = wrapped.__module__
+                _sympy_deprecated_func = wrapped
+                if '__new__' in wrapped.__dict__:
+                    def __new__(cls, *args, **kwargs):
+                        sympy_deprecation_warning(message, **decorator_kwargs, stacklevel=stacklevel)
+                        return super().__new__(cls, *args, **kwargs)
+                else:
+                    def __init__(self, *args, **kwargs):
+                        sympy_deprecation_warning(message, **decorator_kwargs, stacklevel=stacklevel)
+                        super().__init__(*args, **kwargs)
+            wrapper.__name__ = wrapped.__name__
+        else:
+            @wraps(wrapped)
+            def wrapper(*args, **kwargs):
+                sympy_deprecation_warning(message, **decorator_kwargs, stacklevel=stacklevel)
+                return wrapped(*args, **kwargs)
+            wrapper._sympy_deprecated_func = wrapped
+        return wrapper
+    return deprecated_decorator

venv/lib/python3.10/site-packages/sympy/utilities/enumerative.py

@@ -0,0 +1,1157 @@
+"""
+Algorithms and classes to support enumerative combinatorics.
+
+Currently just multiset partitions, but more could be added.
+
+Terminology (following Knuth, algorithm 7.1.2.5M TAOCP)
+*multiset* aaabbcccc has a *partition* aaabc | bccc
+
+The submultisets, aaabc and bccc of the partition are called
+*parts*, or sometimes *vectors*.  (Knuth notes that multiset
+partitions can be thought of as partitions of vectors of integers,
+where the ith element of the vector gives the multiplicity of
+element i.)
+
+The values a, b and c are *components* of the multiset.  These
+correspond to elements of a set, but in a multiset can be present
+with a multiplicity greater than 1.
+
+The algorithm deserves some explanation.
+
+Think of the part aaabc from the multiset above.  If we impose an
+ordering on the components of the multiset, we can represent a part
+with a vector, in which the value of the first element of the vector
+corresponds to the multiplicity of the first component in that
+part. Thus, aaabc can be represented by the vector [3, 1, 1].  We
+can also define an ordering on parts, based on the lexicographic
+ordering of the vector (leftmost vector element, i.e., the element
+with the smallest component number, is the most significant), so
+that [3, 1, 1] > [3, 1, 0] and [3, 1, 1] > [2, 1, 4].  The ordering
+on parts can be extended to an ordering on partitions: First, sort
+the parts in each partition, left-to-right in decreasing order. Then
+partition A is greater than partition B if A's leftmost/greatest
+part is greater than B's leftmost part.  If the leftmost parts are
+equal, compare the second parts, and so on.
+
+In this ordering, the greatest partition of a given multiset has only
+one part.  The least partition is the one in which the components
+are spread out, one per part.
+
+The enumeration algorithms in this file yield the partitions of the
+argument multiset in decreasing order.  The main data structure is a
+stack of parts, corresponding to the current partition.  An
+important invariant is that the parts on the stack are themselves in
+decreasing order.  This data structure is decremented to find the
+next smaller partition.  Most often, decrementing the partition will
+only involve adjustments to the smallest parts at the top of the
+stack, much as adjacent integers *usually* differ only in their last
+few digits.
+
+Knuth's algorithm uses two main operations on parts:
+
+Decrement - change the part so that it is smaller in the
+  (vector) lexicographic order, but reduced by the smallest amount possible.
+  For example, if the multiset has vector [5,
+  3, 1], and the bottom/greatest part is [4, 2, 1], this part would
+  decrement to [4, 2, 0], while [4, 0, 0] would decrement to [3, 3,
+  1].  A singleton part is never decremented -- [1, 0, 0] is not
+  decremented to [0, 3, 1].  Instead, the decrement operator needs
+  to fail for this case.  In Knuth's pseudocode, the decrement
+  operator is step m5.
+
+Spread unallocated multiplicity - Once a part has been decremented,
+  it cannot be the rightmost part in the partition.  There is some
+  multiplicity that has not been allocated, and new parts must be
+  created above it in the stack to use up this multiplicity.  To
+  maintain the invariant that the parts on the stack are in
+  decreasing order, these new parts must be less than or equal to
+  the decremented part.
+  For example, if the multiset is [5, 3, 1], and its most
+  significant part has just been decremented to [5, 3, 0], the
+  spread operation will add a new part so that the stack becomes
+  [[5, 3, 0], [0, 0, 1]].  If the most significant part (for the
+  same multiset) has been decremented to [2, 0, 0] the stack becomes
+  [[2, 0, 0], [2, 0, 0], [1, 3, 1]].  In the pseudocode, the spread
+  operation for one part is step m2.  The complete spread operation
+  is a loop of steps m2 and m3.
+
+In order to facilitate the spread operation, Knuth stores, for each
+component of each part, not just the multiplicity of that component
+in the part, but also the total multiplicity available for this
+component in this part or any lesser part above it on the stack.
+
+One added twist is that Knuth does not represent the part vectors as
+arrays. Instead, he uses a sparse representation, in which a
+component of a part is represented as a component number (c), plus
+the multiplicity of the component in that part (v) as well as the
+total multiplicity available for that component (u).  This saves
+time that would be spent skipping over zeros.
+
+"""
+
+class PartComponent:
+    """Internal class used in support of the multiset partitions
+    enumerators and the associated visitor functions.
+
+    Represents one component of one part of the current partition.
+
+    A stack of these, plus an auxiliary frame array, f, represents a
+    partition of the multiset.
+
+    Knuth's pseudocode makes c, u, and v separate arrays.
+    """
+
+    __slots__ = ('c', 'u', 'v')
+
+    def __init__(self):
+        self.c = 0   # Component number
+        self.u = 0   # The as yet unpartitioned amount in component c
+                     # *before* it is allocated by this triple
+        self.v = 0   # Amount of c component in the current part
+                     # (v<=u).  An invariant of the representation is
+                     # that the next higher triple for this component
+                     # (if there is one) will have a value of u-v in
+                     # its u attribute.
+
+    def __repr__(self):
+        "for debug/algorithm animation purposes"
+        return 'c:%d u:%d v:%d' % (self.c, self.u, self.v)
+
+    def __eq__(self, other):
+        """Define  value oriented equality, which is useful for testers"""
+        return (isinstance(other, self.__class__) and
+                self.c == other.c and
+                self.u == other.u and
+                self.v == other.v)
+
+    def __ne__(self, other):
+        """Defined for consistency with __eq__"""
+        return not self == other
+
+
+# This function tries to be a faithful implementation of algorithm
+# 7.1.2.5M in Volume 4A, Combinatoral Algorithms, Part 1, of The Art
+# of Computer Programming, by Donald Knuth.  This includes using
+# (mostly) the same variable names, etc.  This makes for rather
+# low-level Python.
+
+# Changes from Knuth's pseudocode include
+# - use PartComponent struct/object instead of 3 arrays
+# - make the function a generator
+# - map (with some difficulty) the GOTOs to Python control structures.
+# - Knuth uses 1-based numbering for components, this code is 0-based
+# - renamed variable l to lpart.
+# - flag variable x takes on values True/False instead of 1/0
+#
+def multiset_partitions_taocp(multiplicities):
+    """Enumerates partitions of a multiset.
+
+    Parameters
+    ==========
+
+    multiplicities
+         list of integer multiplicities of the components of the multiset.
+
+    Yields
+    ======
+
+    state
+        Internal data structure which encodes a particular partition.
+        This output is then usually processed by a visitor function
+        which combines the information from this data structure with
+        the components themselves to produce an actual partition.
+
+        Unless they wish to create their own visitor function, users will
+        have little need to look inside this data structure.  But, for
+        reference, it is a 3-element list with components:
+
+        f
+            is a frame array, which is used to divide pstack into parts.
+
+        lpart
+            points to the base of the topmost part.
+
+        pstack
+            is an array of PartComponent objects.
+
+        The ``state`` output offers a peek into the internal data
+        structures of the enumeration function.  The client should
+        treat this as read-only; any modification of the data
+        structure will cause unpredictable (and almost certainly
+        incorrect) results.  Also, the components of ``state`` are
+        modified in place at each iteration.  Hence, the visitor must
+        be called at each loop iteration.  Accumulating the ``state``
+        instances and processing them later will not work.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.enumerative import list_visitor
+    >>> from sympy.utilities.enumerative import multiset_partitions_taocp
+    >>> # variables components and multiplicities represent the multiset 'abb'
+    >>> components = 'ab'
+    >>> multiplicities = [1, 2]
+    >>> states = multiset_partitions_taocp(multiplicities)
+    >>> list(list_visitor(state, components) for state in states)
+    [[['a', 'b', 'b']],
+    [['a', 'b'], ['b']],
+    [['a'], ['b', 'b']],
+    [['a'], ['b'], ['b']]]
+
+    See Also
+    ========
+
+    sympy.utilities.iterables.multiset_partitions: Takes a multiset
+        as input and directly yields multiset partitions.  It
+        dispatches to a number of functions, including this one, for
+        implementation.  Most users will find it more convenient to
+        use than multiset_partitions_taocp.
+
+    """
+
+    # Important variables.
+    # m is the number of components, i.e., number of distinct elements
+    m = len(multiplicities)
+    # n is the cardinality, total number of elements whether or not distinct
+    n = sum(multiplicities)
+
+    # The main data structure, f segments pstack into parts.  See
+    # list_visitor() for example code indicating how this internal
+    # state corresponds to a partition.
+
+    # Note: allocation of space for stack is conservative.  Knuth's
+    # exercise 7.2.1.5.68 gives some indication of how to tighten this
+    # bound, but this is not implemented.
+    pstack = [PartComponent() for i in range(n * m + 1)]
+    f = [0] * (n + 1)
+
+    # Step M1 in Knuth (Initialize)
+    # Initial state - entire multiset in one part.
+    for j in range(m):
+        ps = pstack[j]
+        ps.c = j
+        ps.u = multiplicities[j]
+        ps.v = multiplicities[j]
+
+    # Other variables
+    f[0] = 0
+    a = 0
+    lpart = 0
+    f[1] = m
+    b = m  # in general, current stack frame is from a to b - 1
+
+    while True:
+        while True:
+            # Step M2 (Subtract v from u)
+            j = a
+            k = b
+            x = False
+            while j < b:
+                pstack[k].u = pstack[j].u - pstack[j].v
+                if pstack[k].u == 0:
+                    x = True
+                elif not x:
+                    pstack[k].c = pstack[j].c
+                    pstack[k].v = min(pstack[j].v, pstack[k].u)
+                    x = pstack[k].u < pstack[j].v
+                    k = k + 1
+                else:  # x is True
+                    pstack[k].c = pstack[j].c
+                    pstack[k].v = pstack[k].u
+                    k = k + 1
+                j = j + 1
+                # Note: x is True iff v has changed
+
+            # Step M3 (Push if nonzero.)
+            if k > b:
+                a = b
+                b = k
+                lpart = lpart + 1
+                f[lpart + 1] = b
+                # Return to M2
+            else:
+                break  # Continue to M4
+
+        # M4  Visit a partition
+        state = [f, lpart, pstack]
+        yield state
+
+        # M5 (Decrease v)
+        while True:
+            j = b-1
+            while (pstack[j].v == 0):
+                j = j - 1
+            if j == a and pstack[j].v == 1:
+                # M6 (Backtrack)
+                if lpart == 0:
+                    return
+                lpart = lpart - 1
+                b = a
+                a = f[lpart]
+                # Return to M5
+            else:
+                pstack[j].v = pstack[j].v - 1
+                for k in range(j + 1, b):
+                    pstack[k].v = pstack[k].u
+                break  # GOTO M2
+
+# --------------- Visitor functions for multiset partitions ---------------
+# A visitor takes the partition state generated by
+# multiset_partitions_taocp or other enumerator, and produces useful
+# output (such as the actual partition).
+
+
+def factoring_visitor(state, primes):
+    """Use with multiset_partitions_taocp to enumerate the ways a
+    number can be expressed as a product of factors.  For this usage,
+    the exponents of the prime factors of a number are arguments to
+    the partition enumerator, while the corresponding prime factors
+    are input here.
+
+    Examples
+    ========
+
+    To enumerate the factorings of a number we can think of the elements of the
+    partition as being the prime factors and the multiplicities as being their
+    exponents.
+
+    >>> from sympy.utilities.enumerative import factoring_visitor
+    >>> from sympy.utilities.enumerative import multiset_partitions_taocp
+    >>> from sympy import factorint
+    >>> primes, multiplicities = zip(*factorint(24).items())
+    >>> primes
+    (2, 3)
+    >>> multiplicities
+    (3, 1)
+    >>> states = multiset_partitions_taocp(multiplicities)
+    >>> list(factoring_visitor(state, primes) for state in states)
+    [[24], [8, 3], [12, 2], [4, 6], [4, 2, 3], [6, 2, 2], [2, 2, 2, 3]]
+    """
+    f, lpart, pstack = state
+    factoring = []
+    for i in range(lpart + 1):
+        factor = 1
+        for ps in pstack[f[i]: f[i + 1]]:
+            if ps.v > 0:
+                factor *= primes[ps.c] ** ps.v
+        factoring.append(factor)
+    return factoring
+
+
+def list_visitor(state, components):
+    """Return a list of lists to represent the partition.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.enumerative import list_visitor
+    >>> from sympy.utilities.enumerative import multiset_partitions_taocp
+    >>> states = multiset_partitions_taocp([1, 2, 1])
+    >>> s = next(states)
+    >>> list_visitor(s, 'abc')  # for multiset 'a b b c'
+    [['a', 'b', 'b', 'c']]
+    >>> s = next(states)
+    >>> list_visitor(s, [1, 2, 3])  # for multiset '1 2 2 3
+    [[1, 2, 2], [3]]
+    """
+    f, lpart, pstack = state
+
+    partition = []
+    for i in range(lpart+1):
+        part = []
+        for ps in pstack[f[i]:f[i+1]]:
+            if ps.v > 0:
+                part.extend([components[ps.c]] * ps.v)
+        partition.append(part)
+
+    return partition
+
+
+class MultisetPartitionTraverser():
+    """
+    Has methods to ``enumerate`` and ``count`` the partitions of a multiset.
+
+    This implements a refactored and extended version of Knuth's algorithm
+    7.1.2.5M [AOCP]_."
+
+    The enumeration methods of this class are generators and return
+    data structures which can be interpreted by the same visitor
+    functions used for the output of ``multiset_partitions_taocp``.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.enumerative import MultisetPartitionTraverser
+    >>> m = MultisetPartitionTraverser()
+    >>> m.count_partitions([4,4,4,2])
+    127750
+    >>> m.count_partitions([3,3,3])
+    686
+
+    See Also
+    ========
+
+    multiset_partitions_taocp
+    sympy.utilities.iterables.multiset_partitions
+
+    References
+    ==========
+
+    .. [AOCP] Algorithm 7.1.2.5M in Volume 4A, Combinatoral Algorithms,
+           Part 1, of The Art of Computer Programming, by Donald Knuth.
+
+    .. [Factorisatio] On a Problem of Oppenheim concerning
+           "Factorisatio Numerorum" E. R. Canfield, Paul Erdos, Carl
+           Pomerance, JOURNAL OF NUMBER THEORY, Vol. 17, No. 1. August
+           1983.  See section 7 for a description of an algorithm
+           similar to Knuth's.
+
+    .. [Yorgey] Generating Multiset Partitions, Brent Yorgey, The
+           Monad.Reader, Issue 8, September 2007.
+
+    """
+
+    def __init__(self):
+        self.debug = False
+        # TRACING variables.  These are useful for gathering
+        # statistics on the algorithm itself, but have no particular
+        # benefit to a user of the code.
+        self.k1 = 0
+        self.k2 = 0
+        self.p1 = 0
+        self.pstack = None
+        self.f = None
+        self.lpart = 0
+        self.discarded = 0
+        # dp_stack is list of lists of (part_key, start_count) pairs
+        self.dp_stack = []
+
+        # dp_map is map part_key-> count, where count represents the
+        # number of multiset which are descendants of a part with this
+        # key, **or any of its decrements**
+
+        # Thus, when we find a part in the map, we add its count
+        # value to the running total, cut off the enumeration, and
+        # backtrack
+
+        if not hasattr(self, 'dp_map'):
+            self.dp_map = {}
+
+    def db_trace(self, msg):
+        """Useful for understanding/debugging the algorithms.  Not
+        generally activated in end-user code."""
+        if self.debug:
+            # XXX: animation_visitor is undefined... Clearly this does not
+            # work and was not tested. Previous code in comments below.
+            raise RuntimeError
+            #letters = 'abcdefghijklmnopqrstuvwxyz'
+            #state = [self.f, self.lpart, self.pstack]
+            #print("DBG:", msg,
+            #      ["".join(part) for part in list_visitor(state, letters)],
+            #      animation_visitor(state))
+
+    #
+    # Helper methods for enumeration
+    #
+    def _initialize_enumeration(self, multiplicities):
+        """Allocates and initializes the partition stack.
+
+        This is called from the enumeration/counting routines, so
+        there is no need to call it separately."""
+
+        num_components = len(multiplicities)
+        # cardinality is the total number of elements, whether or not distinct
+        cardinality = sum(multiplicities)
+
+        # pstack is the partition stack, which is segmented by
+        # f into parts.
+        self.pstack = [PartComponent() for i in
+                       range(num_components * cardinality + 1)]
+        self.f = [0] * (cardinality + 1)
+
+        # Initial state - entire multiset in one part.
+        for j in range(num_components):
+            ps = self.pstack[j]
+            ps.c = j
+            ps.u = multiplicities[j]
+            ps.v = multiplicities[j]
+
+        self.f[0] = 0
+        self.f[1] = num_components
+        self.lpart = 0
+
+    # The decrement_part() method corresponds to step M5 in Knuth's
+    # algorithm.  This is the base version for enum_all().  Modified
+    # versions of this method are needed if we want to restrict
+    # sizes of the partitions produced.
+    def decrement_part(self, part):
+        """Decrements part (a subrange of pstack), if possible, returning
+        True iff the part was successfully decremented.
+
+        If you think of the v values in the part as a multi-digit
+        integer (least significant digit on the right) this is
+        basically decrementing that integer, but with the extra
+        constraint that the leftmost digit cannot be decremented to 0.
+
+        Parameters
+        ==========
+
+        part
+           The part, represented as a list of PartComponent objects,
+           which is to be decremented.
+
+        """
+        plen = len(part)
+        for j in range(plen - 1, -1, -1):
+            if j == 0 and part[j].v > 1 or j > 0 and part[j].v > 0:
+                # found val to decrement
+                part[j].v -= 1
+                # Reset trailing parts back to maximum
+                for k in range(j + 1, plen):
+                    part[k].v = part[k].u
+                return True
+        return False
+
+    # Version to allow number of parts to be bounded from above.
+    # Corresponds to (a modified) step M5.
+    def decrement_part_small(self, part, ub):
+        """Decrements part (a subrange of pstack), if possible, returning
+        True iff the part was successfully decremented.
+
+        Parameters
+        ==========
+
+        part
+            part to be decremented (topmost part on the stack)
+
+        ub
+            the maximum number of parts allowed in a partition
+            returned by the calling traversal.
+
+        Notes
+        =====
+
+        The goal of this modification of the ordinary decrement method
+        is to fail (meaning that the subtree rooted at this part is to
+        be skipped) when it can be proved that this part can only have
+        child partitions which are larger than allowed by ``ub``. If a
+        decision is made to fail, it must be accurate, otherwise the
+        enumeration will miss some partitions.  But, it is OK not to
+        capture all the possible failures -- if a part is passed that
+        should not be, the resulting too-large partitions are filtered
+        by the enumeration one level up.  However, as is usual in
+        constrained enumerations, failing early is advantageous.
+
+        The tests used by this method catch the most common cases,
+        although this implementation is by no means the last word on
+        this problem.  The tests include:
+
+        1) ``lpart`` must be less than ``ub`` by at least 2.  This is because
+           once a part has been decremented, the partition
+           will gain at least one child in the spread step.
+
+        2) If the leading component of the part is about to be
+           decremented, check for how many parts will be added in
+           order to use up the unallocated multiplicity in that
+           leading component, and fail if this number is greater than
+           allowed by ``ub``.  (See code for the exact expression.)  This
+           test is given in the answer to Knuth's problem 7.2.1.5.69.
+
+        3) If there is *exactly* enough room to expand the leading
+           component by the above test, check the next component (if
+           it exists) once decrementing has finished.  If this has
+           ``v == 0``, this next component will push the expansion over the
+           limit by 1, so fail.
+        """
+        if self.lpart >= ub - 1:
+            self.p1 += 1  # increment to keep track of usefulness of tests
+            return False
+        plen = len(part)
+        for j in range(plen - 1, -1, -1):
+            # Knuth's mod, (answer to problem 7.2.1.5.69)
+            if j == 0 and (part[0].v - 1)*(ub - self.lpart) < part[0].u:
+                self.k1 += 1
+                return False
+
+            if j == 0 and part[j].v > 1 or j > 0 and part[j].v > 0:
+                # found val to decrement
+                part[j].v -= 1
+                # Reset trailing parts back to maximum
+                for k in range(j + 1, plen):
+                    part[k].v = part[k].u
+
+                # Have now decremented part, but are we doomed to
+                # failure when it is expanded?  Check one oddball case
+                # that turns out to be surprisingly common - exactly
+                # enough room to expand the leading component, but no
+                # room for the second component, which has v=0.
+                if (plen > 1 and part[1].v == 0 and
+                    (part[0].u - part[0].v) ==
+                        ((ub - self.lpart - 1) * part[0].v)):
+                    self.k2 += 1
+                    self.db_trace("Decrement fails test 3")
+                    return False
+                return True
+        return False
+
+    def decrement_part_large(self, part, amt, lb):
+        """Decrements part, while respecting size constraint.
+
+        A part can have no children which are of sufficient size (as
+        indicated by ``lb``) unless that part has sufficient
+        unallocated multiplicity.  When enforcing the size constraint,
+        this method will decrement the part (if necessary) by an
+        amount needed to ensure sufficient unallocated multiplicity.
+
+        Returns True iff the part was successfully decremented.
+
+        Parameters
+        ==========
+
+        part
+            part to be decremented (topmost part on the stack)
+
+        amt
+            Can only take values 0 or 1.  A value of 1 means that the
+            part must be decremented, and then the size constraint is
+            enforced.  A value of 0 means just to enforce the ``lb``
+            size constraint.
+
+        lb
+            The partitions produced by the calling enumeration must
+            have more parts than this value.
+
+        """
+
+        if amt == 1:
+            # In this case we always need to increment, *before*
+            # enforcing the "sufficient unallocated multiplicity"
+            # constraint.  Easiest for this is just to call the
+            # regular decrement method.
+            if not self.decrement_part(part):
+                return False
+
+        # Next, perform any needed additional decrementing to respect
+        # "sufficient unallocated multiplicity" (or fail if this is
+        # not possible).
+        min_unalloc = lb - self.lpart
+        if min_unalloc <= 0:
+            return True
+        total_mult = sum(pc.u for pc in part)
+        total_alloc = sum(pc.v for pc in part)
+        if total_mult <= min_unalloc:
+            return False
+
+        deficit = min_unalloc - (total_mult - total_alloc)
+        if deficit <= 0:
+            return True
+
+        for i in range(len(part) - 1, -1, -1):
+            if i == 0:
+                if part[0].v > deficit:
+                    part[0].v -= deficit
+                    return True
+                else:
+                    return False  # This shouldn't happen, due to above check
+            else:
+                if part[i].v >= deficit:
+                    part[i].v -= deficit
+                    return True
+                else:
+                    deficit -= part[i].v
+                    part[i].v = 0
+
+    def decrement_part_range(self, part, lb, ub):
+        """Decrements part (a subrange of pstack), if possible, returning
+        True iff the part was successfully decremented.
+
+        Parameters
+        ==========
+
+         part
+            part to be decremented (topmost part on the stack)
+
+        ub
+            the maximum number of parts allowed in a partition
+            returned by the calling traversal.
+
+        lb
+            The partitions produced by the calling enumeration must
+            have more parts than this value.
+
+        Notes
+        =====
+
+        Combines the constraints of _small and _large decrement
+        methods.  If returns success, part has been decremented at
+        least once, but perhaps by quite a bit more if needed to meet
+        the lb constraint.
+        """
+
+        # Constraint in the range case is just enforcing both the
+        # constraints from _small and _large cases.  Note the 0 as the
+        # second argument to the _large call -- this is the signal to
+        # decrement only as needed to for constraint enforcement.  The
+        # short circuiting and left-to-right order of the 'and'
+        # operator is important for this to work correctly.
+        return self.decrement_part_small(part, ub) and \
+            self.decrement_part_large(part, 0, lb)
+
+    def spread_part_multiplicity(self):
+        """Returns True if a new part has been created, and
+        adjusts pstack, f and lpart as needed.
+
+        Notes
+        =====
+
+        Spreads unallocated multiplicity from the current top part
+        into a new part created above the current on the stack.  This
+        new part is constrained to be less than or equal to the old in
+        terms of the part ordering.
+
+        This call does nothing (and returns False) if the current top
+        part has no unallocated multiplicity.
+
+        """
+        j = self.f[self.lpart]  # base of current top part
+        k = self.f[self.lpart + 1]  # ub of current; potential base of next
+        base = k  # save for later comparison
+
+        changed = False  # Set to true when the new part (so far) is
+                         # strictly less than (as opposed to less than
+                         # or equal) to the old.
+        for j in range(self.f[self.lpart], self.f[self.lpart + 1]):
+            self.pstack[k].u = self.pstack[j].u - self.pstack[j].v
+            if self.pstack[k].u == 0:
+                changed = True
+            else:
+                self.pstack[k].c = self.pstack[j].c
+                if changed:  # Put all available multiplicity in this part
+                    self.pstack[k].v = self.pstack[k].u
+                else:  # Still maintaining ordering constraint
+                    if self.pstack[k].u < self.pstack[j].v:
+                        self.pstack[k].v = self.pstack[k].u
+                        changed = True
+                    else:
+                        self.pstack[k].v = self.pstack[j].v
+                k = k + 1
+        if k > base:
+            # Adjust for the new part on stack
+            self.lpart = self.lpart + 1
+            self.f[self.lpart + 1] = k
+            return True
+        return False
+
+    def top_part(self):
+        """Return current top part on the stack, as a slice of pstack.
+
+        """
+        return self.pstack[self.f[self.lpart]:self.f[self.lpart + 1]]
+
+    # Same interface and functionality as multiset_partitions_taocp(),
+    # but some might find this refactored version easier to follow.
+    def enum_all(self, multiplicities):
+        """Enumerate the partitions of a multiset.
+
+        Examples
+        ========
+
+        >>> from sympy.utilities.enumerative import list_visitor
+        >>> from sympy.utilities.enumerative import MultisetPartitionTraverser
+        >>> m = MultisetPartitionTraverser()
+        >>> states = m.enum_all([2,2])
+        >>> list(list_visitor(state, 'ab') for state in states)
+        [[['a', 'a', 'b', 'b']],
+        [['a', 'a', 'b'], ['b']],
+        [['a', 'a'], ['b', 'b']],
+        [['a', 'a'], ['b'], ['b']],
+        [['a', 'b', 'b'], ['a']],
+        [['a', 'b'], ['a', 'b']],
+        [['a', 'b'], ['a'], ['b']],
+        [['a'], ['a'], ['b', 'b']],
+        [['a'], ['a'], ['b'], ['b']]]
+
+        See Also
+        ========
+
+        multiset_partitions_taocp:
+            which provides the same result as this method, but is
+            about twice as fast.  Hence, enum_all is primarily useful
+            for testing.  Also see the function for a discussion of
+            states and visitors.
+
+        """
+        self._initialize_enumeration(multiplicities)
+        while True:
+            while self.spread_part_multiplicity():
+                pass
+
+            # M4  Visit a partition
+            state = [self.f, self.lpart, self.pstack]
+            yield state
+
+            # M5 (Decrease v)
+            while not self.decrement_part(self.top_part()):
+                # M6 (Backtrack)
+                if self.lpart == 0:
+                    return
+                self.lpart -= 1
+
+    def enum_small(self, multiplicities, ub):
+        """Enumerate multiset partitions with no more than ``ub`` parts.
+
+        Equivalent to enum_range(multiplicities, 0, ub)
+
+        Parameters
+        ==========
+
+        multiplicities
+             list of multiplicities of the components of the multiset.
+
+        ub
+            Maximum number of parts
+
+        Examples
+        ========
+
+        >>> from sympy.utilities.enumerative import list_visitor
+        >>> from sympy.utilities.enumerative import MultisetPartitionTraverser
+        >>> m = MultisetPartitionTraverser()
+        >>> states = m.enum_small([2,2], 2)
+        >>> list(list_visitor(state, 'ab') for state in states)
+        [[['a', 'a', 'b', 'b']],
+        [['a', 'a', 'b'], ['b']],
+        [['a', 'a'], ['b', 'b']],
+        [['a', 'b', 'b'], ['a']],
+        [['a', 'b'], ['a', 'b']]]
+
+        The implementation is based, in part, on the answer given to
+        exercise 69, in Knuth [AOCP]_.
+
+        See Also
+        ========
+
+        enum_all, enum_large, enum_range
+
+        """
+
+        # Keep track of iterations which do not yield a partition.
+        # Clearly, we would like to keep this number small.
+        self.discarded = 0
+        if ub <= 0:
+            return
+        self._initialize_enumeration(multiplicities)
+        while True:
+            while self.spread_part_multiplicity():
+                self.db_trace('spread 1')
+                if self.lpart >= ub:
+                    self.discarded += 1
+                    self.db_trace('  Discarding')
+                    self.lpart = ub - 2
+                    break
+            else:
+                # M4  Visit a partition
+                state = [self.f, self.lpart, self.pstack]
+                yield state
+
+            # M5 (Decrease v)
+            while not self.decrement_part_small(self.top_part(), ub):
+                self.db_trace("Failed decrement, going to backtrack")
+                # M6 (Backtrack)
+                if self.lpart == 0:
+                    return
+                self.lpart -= 1
+                self.db_trace("Backtracked to")
+            self.db_trace("decrement ok, about to expand")
+
+    def enum_large(self, multiplicities, lb):
+        """Enumerate the partitions of a multiset with lb < num(parts)
+
+        Equivalent to enum_range(multiplicities, lb, sum(multiplicities))
+
+        Parameters
+        ==========
+
+        multiplicities
+            list of multiplicities of the components of the multiset.
+
+        lb
+            Number of parts in the partition must be greater than
+            this lower bound.
+
+
+        Examples
+        ========
+
+        >>> from sympy.utilities.enumerative import list_visitor
+        >>> from sympy.utilities.enumerative import MultisetPartitionTraverser
+        >>> m = MultisetPartitionTraverser()
+        >>> states = m.enum_large([2,2], 2)
+        >>> list(list_visitor(state, 'ab') for state in states)
+        [[['a', 'a'], ['b'], ['b']],
+        [['a', 'b'], ['a'], ['b']],
+        [['a'], ['a'], ['b', 'b']],
+        [['a'], ['a'], ['b'], ['b']]]
+
+        See Also
+        ========
+
+        enum_all, enum_small, enum_range
+
+        """
+        self.discarded = 0
+        if lb >= sum(multiplicities):
+            return
+        self._initialize_enumeration(multiplicities)
+        self.decrement_part_large(self.top_part(), 0, lb)
+        while True:
+            good_partition = True
+            while self.spread_part_multiplicity():
+                if not self.decrement_part_large(self.top_part(), 0, lb):
+                    # Failure here should be rare/impossible
+                    self.discarded += 1
+                    good_partition = False
+                    break
+
+            # M4  Visit a partition
+            if good_partition:
+                state = [self.f, self.lpart, self.pstack]
+                yield state
+
+            # M5 (Decrease v)
+            while not self.decrement_part_large(self.top_part(), 1, lb):
+                # M6 (Backtrack)
+                if self.lpart == 0:
+                    return
+                self.lpart -= 1
+
+    def enum_range(self, multiplicities, lb, ub):
+
+        """Enumerate the partitions of a multiset with
+        ``lb < num(parts) <= ub``.
+
+        In particular, if partitions with exactly ``k`` parts are
+        desired, call with ``(multiplicities, k - 1, k)``.  This
+        method generalizes enum_all, enum_small, and enum_large.
+
+        Examples
+        ========
+
+        >>> from sympy.utilities.enumerative import list_visitor
+        >>> from sympy.utilities.enumerative import MultisetPartitionTraverser
+        >>> m = MultisetPartitionTraverser()
+        >>> states = m.enum_range([2,2], 1, 2)
+        >>> list(list_visitor(state, 'ab') for state in states)
+        [[['a', 'a', 'b'], ['b']],
+        [['a', 'a'], ['b', 'b']],
+        [['a', 'b', 'b'], ['a']],
+        [['a', 'b'], ['a', 'b']]]
+
+        """
+        # combine the constraints of the _large and _small
+        # enumerations.
+        self.discarded = 0
+        if ub <= 0 or lb >= sum(multiplicities):
+            return
+        self._initialize_enumeration(multiplicities)
+        self.decrement_part_large(self.top_part(), 0, lb)
+        while True:
+            good_partition = True
+            while self.spread_part_multiplicity():
+                self.db_trace("spread 1")
+                if not self.decrement_part_large(self.top_part(), 0, lb):
+                    # Failure here - possible in range case?
+                    self.db_trace("  Discarding (large cons)")
+                    self.discarded += 1
+                    good_partition = False
+                    break
+                elif self.lpart >= ub:
+                    self.discarded += 1
+                    good_partition = False
+                    self.db_trace("  Discarding small cons")
+                    self.lpart = ub - 2
+                    break
+
+            # M4  Visit a partition
+            if good_partition:
+                state = [self.f, self.lpart, self.pstack]
+                yield state
+
+            # M5 (Decrease v)
+            while not self.decrement_part_range(self.top_part(), lb, ub):
+                self.db_trace("Failed decrement, going to backtrack")
+                # M6 (Backtrack)
+                if self.lpart == 0:
+                    return
+                self.lpart -= 1
+                self.db_trace("Backtracked to")
+            self.db_trace("decrement ok, about to expand")
+
+    def count_partitions_slow(self, multiplicities):
+        """Returns the number of partitions of a multiset whose elements
+        have the multiplicities given in ``multiplicities``.
+
+        Primarily for comparison purposes.  It follows the same path as
+        enumerate, and counts, rather than generates, the partitions.
+
+        See Also
+        ========
+
+        count_partitions
+            Has the same calling interface, but is much faster.
+
+        """
+        # number of partitions so far in the enumeration
+        self.pcount = 0
+        self._initialize_enumeration(multiplicities)
+        while True:
+            while self.spread_part_multiplicity():
+                pass
+
+            # M4  Visit (count) a partition
+            self.pcount += 1
+
+            # M5 (Decrease v)
+            while not self.decrement_part(self.top_part()):
+                # M6 (Backtrack)
+                if self.lpart == 0:
+                    return self.pcount
+                self.lpart -= 1
+
+    def count_partitions(self, multiplicities):
+        """Returns the number of partitions of a multiset whose components
+        have the multiplicities given in ``multiplicities``.
+
+        For larger counts, this method is much faster than calling one
+        of the enumerators and counting the result.  Uses dynamic
+        programming to cut down on the number of nodes actually
+        explored.  The dictionary used in order to accelerate the
+        counting process is stored in the ``MultisetPartitionTraverser``
+        object and persists across calls.  If the user does not
+        expect to call ``count_partitions`` for any additional
+        multisets, the object should be cleared to save memory.  On
+        the other hand, the cache built up from one count run can
+        significantly speed up subsequent calls to ``count_partitions``,
+        so it may be advantageous not to clear the object.
+
+        Examples
+        ========
+
+        >>> from sympy.utilities.enumerative import MultisetPartitionTraverser
+        >>> m = MultisetPartitionTraverser()
+        >>> m.count_partitions([9,8,2])
+        288716
+        >>> m.count_partitions([2,2])
+        9
+        >>> del m
+
+        Notes
+        =====
+
+        If one looks at the workings of Knuth's algorithm M [AOCP]_, it
+        can be viewed as a traversal of a binary tree of parts.  A
+        part has (up to) two children, the left child resulting from
+        the spread operation, and the right child from the decrement
+        operation.  The ordinary enumeration of multiset partitions is
+        an in-order traversal of this tree, and with the partitions
+        corresponding to paths from the root to the leaves. The
+        mapping from paths to partitions is a little complicated,
+        since the partition would contain only those parts which are
+        leaves or the parents of a spread link, not those which are
+        parents of a decrement link.
+
+        For counting purposes, it is sufficient to count leaves, and
+        this can be done with a recursive in-order traversal.  The
+        number of leaves of a subtree rooted at a particular part is a
+        function only of that part itself, so memoizing has the
+        potential to speed up the counting dramatically.
+
+        This method follows a computational approach which is similar
+        to the hypothetical memoized recursive function, but with two
+        differences:
+
+        1) This method is iterative, borrowing its structure from the
+           other enumerations and maintaining an explicit stack of
+           parts which are in the process of being counted.  (There
+           may be multisets which can be counted reasonably quickly by
+           this implementation, but which would overflow the default
+           Python recursion limit with a recursive implementation.)
+
+        2) Instead of using the part data structure directly, a more
+           compact key is constructed.  This saves space, but more
+           importantly coalesces some parts which would remain
+           separate with physical keys.
+
+        Unlike the enumeration functions, there is currently no _range
+        version of count_partitions.  If someone wants to stretch
+        their brain, it should be possible to construct one by
+        memoizing with a histogram of counts rather than a single
+        count, and combining the histograms.
+        """
+        # number of partitions so far in the enumeration
+        self.pcount = 0
+
+        # dp_stack is list of lists of (part_key, start_count) pairs
+        self.dp_stack = []
+
+        self._initialize_enumeration(multiplicities)
+        pkey = part_key(self.top_part())
+        self.dp_stack.append([(pkey, 0), ])
+        while True:
+            while self.spread_part_multiplicity():
+                pkey = part_key(self.top_part())
+                if pkey in self.dp_map:
+                    # Already have a cached value for the count of the
+                    # subtree rooted at this part.  Add it to the
+                    # running counter, and break out of the spread
+                    # loop.  The -1 below is to compensate for the
+                    # leaf that this code path would otherwise find,
+                    # and which gets incremented for below.
+
+                    self.pcount += (self.dp_map[pkey] - 1)
+                    self.lpart -= 1
+                    break
+                else:
+                    self.dp_stack.append([(pkey, self.pcount), ])
+
+            # M4  count a leaf partition
+            self.pcount += 1
+
+            # M5 (Decrease v)
+            while not self.decrement_part(self.top_part()):
+                # M6 (Backtrack)
+                for key, oldcount in self.dp_stack.pop():
+                    self.dp_map[key] = self.pcount - oldcount
+                if self.lpart == 0:
+                    return self.pcount
+                self.lpart -= 1
+
+            # At this point have successfully decremented the part on
+            # the stack and it does not appear in the cache.  It needs
+            # to be added to the list at the top of dp_stack
+            pkey = part_key(self.top_part())
+            self.dp_stack[-1].append((pkey, self.pcount),)
+
+
+def part_key(part):
+    """Helper for MultisetPartitionTraverser.count_partitions that
+    creates a key for ``part``, that only includes information which can
+    affect the count for that part.  (Any irrelevant information just
+    reduces the effectiveness of dynamic programming.)
+
+    Notes
+    =====
+
+    This member function is a candidate for future exploration. There
+    are likely symmetries that can be exploited to coalesce some
+    ``part_key`` values, and thereby save space and improve
+    performance.
+
+    """
+    # The component number is irrelevant for counting partitions, so
+    # leave it out of the memo key.
+    rval = []
+    for ps in part:
+        rval.append(ps.u)
+        rval.append(ps.v)
+    return tuple(rval)

venv/lib/python3.10/site-packages/sympy/utilities/exceptions.py

@@ -0,0 +1,275 @@
+"""
+General SymPy exceptions and warnings.
+"""
+
+import warnings
+import contextlib
+
+from textwrap import dedent
+
+
+class SymPyDeprecationWarning(DeprecationWarning):
+    r"""
+    A warning for deprecated features of SymPy.
+
+    See the :ref:`deprecation-policy` document for details on when and how
+    things should be deprecated in SymPy.
+
+    Note that simply constructing this class will not cause a warning to be
+    issued. To do that, you must call the :func`sympy_deprecation_warning`
+    function. For this reason, it is not recommended to ever construct this
+    class directly.
+
+    Explanation
+    ===========
+
+    The ``SymPyDeprecationWarning`` class is a subclass of
+    ``DeprecationWarning`` that is used for all deprecations in SymPy. A
+    special subclass is used so that we can automatically augment the warning
+    message with additional metadata about the version the deprecation was
+    introduced in and a link to the documentation. This also allows users to
+    explicitly filter deprecation warnings from SymPy using ``warnings``
+    filters (see :ref:`silencing-sympy-deprecation-warnings`).
+
+    Additionally, ``SymPyDeprecationWarning`` is enabled to be shown by
+    default, unlike normal ``DeprecationWarning``\s, which are only shown by
+    default in interactive sessions. This ensures that deprecation warnings in
+    SymPy will actually be seen by users.
+
+    See the documentation of :func:`sympy_deprecation_warning` for a
+    description of the parameters to this function.
+
+    To mark a function as deprecated, you can use the :func:`@deprecated
+    <sympy.utilities.decorator.deprecated>` decorator.
+
+    See Also
+    ========
+    sympy.utilities.exceptions.sympy_deprecation_warning
+    sympy.utilities.exceptions.ignore_warnings
+    sympy.utilities.decorator.deprecated
+    sympy.testing.pytest.warns_deprecated_sympy
+
+    """
+    def __init__(self, message, *, deprecated_since_version, active_deprecations_target):
+
+        super().__init__(message, deprecated_since_version,
+                     active_deprecations_target)
+        self.message = message
+        if not isinstance(deprecated_since_version, str):
+            raise TypeError(f"'deprecated_since_version' should be a string, got {deprecated_since_version!r}")
+        self.deprecated_since_version = deprecated_since_version
+        self.active_deprecations_target = active_deprecations_target
+        if any(i in active_deprecations_target for i in '()='):
+            raise ValueError("active_deprecations_target be the part inside of the '(...)='")
+
+        self.full_message = f"""
+
+{dedent(message).strip()}
+
+See https://docs.sympy.org/latest/explanation/active-deprecations.html#{active_deprecations_target}
+for details.
+
+This has been deprecated since SymPy version {deprecated_since_version}. It
+will be removed in a future version of SymPy.
+"""
+
+    def __str__(self):
+        return self.full_message
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self.message!r}, deprecated_since_version={self.deprecated_since_version!r}, active_deprecations_target={self.active_deprecations_target!r})"
+
+    def __eq__(self, other):
+        return isinstance(other, SymPyDeprecationWarning) and self.args == other.args
+
+    # Make pickling work. The by default, it tries to recreate the expression
+    # from its args, but this doesn't work because of our keyword-only
+    # arguments.
+    @classmethod
+    def _new(cls, message, deprecated_since_version,
+              active_deprecations_target):
+        return cls(message, deprecated_since_version=deprecated_since_version, active_deprecations_target=active_deprecations_target)
+
+    def __reduce__(self):
+        return (self._new, (self.message, self.deprecated_since_version, self.active_deprecations_target))
+
+# Python by default hides DeprecationWarnings, which we do not want.
+warnings.simplefilter("once", SymPyDeprecationWarning)
+
+def sympy_deprecation_warning(message, *, deprecated_since_version,
+                              active_deprecations_target, stacklevel=3):
+    r'''
+    Warn that a feature is deprecated in SymPy.
+
+    See the :ref:`deprecation-policy` document for details on when and how
+    things should be deprecated in SymPy.
+
+    To mark an entire function or class as deprecated, you can use the
+    :func:`@deprecated <sympy.utilities.decorator.deprecated>` decorator.
+
+    Parameters
+    ==========
+
+    message: str
+
+         The deprecation message. This may span multiple lines and contain
+         code examples. Messages should be wrapped to 80 characters. The
+         message is automatically dedented and leading and trailing whitespace
+         stripped. Messages may include dynamic content based on the user
+         input, but avoid using ``str(expression)`` if an expression can be
+         arbitrary, as it might be huge and make the warning message
+         unreadable.
+
+    deprecated_since_version: str
+
+         The version of SymPy the feature has been deprecated since. For new
+         deprecations, this should be the version in `sympy/release.py
+         <https://github.com/sympy/sympy/blob/master/sympy/release.py>`_
+         without the ``.dev``. If the next SymPy version ends up being
+         different from this, the release manager will need to update any
+         ``SymPyDeprecationWarning``\s using the incorrect version. This
+         argument is required and must be passed as a keyword argument.
+         (example:  ``deprecated_since_version="1.10"``).
+
+    active_deprecations_target: str
+
+        The Sphinx target corresponding to the section for the deprecation in
+        the :ref:`active-deprecations` document (see
+        ``doc/src/explanation/active-deprecations.md``). This is used to
+        automatically generate a URL to the page in the warning message. This
+        argument is required and must be passed as a keyword argument.
+        (example: ``active_deprecations_target="deprecated-feature-abc"``)
+
+    stacklevel: int (default: 3)
+
+        The ``stacklevel`` parameter that is passed to ``warnings.warn``. If
+        you create a wrapper that calls this function, this should be
+        increased so that the warning message shows the user line of code that
+        produced the warning. Note that in some cases there will be multiple
+        possible different user code paths that could result in the warning.
+        In that case, just choose the smallest common stacklevel.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.exceptions import sympy_deprecation_warning
+    >>> def is_this_zero(x, y=0):
+    ...     """
+    ...     Determine if x = 0.
+    ...
+    ...     Parameters
+    ...     ==========
+    ...
+    ...     x : Expr
+    ...       The expression to check.
+    ...
+    ...     y : Expr, optional
+    ...       If provided, check if x = y.
+    ...
+    ...       .. deprecated:: 1.1
+    ...
+    ...          The ``y`` argument to ``is_this_zero`` is deprecated. Use
+    ...          ``is_this_zero(x - y)`` instead.
+    ...
+    ...     """
+    ...     from sympy import simplify
+    ...
+    ...     if y != 0:
+    ...         sympy_deprecation_warning("""
+    ...     The y argument to is_zero() is deprecated. Use is_zero(x - y) instead.""",
+    ...             deprecated_since_version="1.1",
+    ...             active_deprecations_target='is-this-zero-y-deprecation')
+    ...     return simplify(x - y) == 0
+    >>> is_this_zero(0)
+    True
+    >>> is_this_zero(1, 1) # doctest: +SKIP
+    <stdin>:1: SymPyDeprecationWarning:
+    <BLANKLINE>
+    The y argument to is_zero() is deprecated. Use is_zero(x - y) instead.
+    <BLANKLINE>
+    See https://docs.sympy.org/latest/explanation/active-deprecations.html#is-this-zero-y-deprecation
+    for details.
+    <BLANKLINE>
+    This has been deprecated since SymPy version 1.1. It
+    will be removed in a future version of SymPy.
+    <BLANKLINE>
+      is_this_zero(1, 1)
+    True
+
+    See Also
+    ========
+
+    sympy.utilities.exceptions.SymPyDeprecationWarning
+    sympy.utilities.exceptions.ignore_warnings
+    sympy.utilities.decorator.deprecated
+    sympy.testing.pytest.warns_deprecated_sympy
+
+    '''
+    w = SymPyDeprecationWarning(message,
+                            deprecated_since_version=deprecated_since_version,
+                                active_deprecations_target=active_deprecations_target)
+    warnings.warn(w, stacklevel=stacklevel)
+
+
+@contextlib.contextmanager
+def ignore_warnings(warningcls):
+    '''
+    Context manager to suppress warnings during tests.
+
+    .. note::
+
+       Do not use this with SymPyDeprecationWarning in the tests.
+       warns_deprecated_sympy() should be used instead.
+
+    This function is useful for suppressing warnings during tests. The warns
+    function should be used to assert that a warning is raised. The
+    ignore_warnings function is useful in situation when the warning is not
+    guaranteed to be raised (e.g. on importing a module) or if the warning
+    comes from third-party code.
+
+    This function is also useful to prevent the same or similar warnings from
+    being issue twice due to recursive calls.
+
+    When the warning is coming (reliably) from SymPy the warns function should
+    be preferred to ignore_warnings.
+
+    >>> from sympy.utilities.exceptions import ignore_warnings
+    >>> import warnings
+
+    Here's a warning:
+
+    >>> with warnings.catch_warnings():  # reset warnings in doctest
+    ...     warnings.simplefilter('error')
+    ...     warnings.warn('deprecated', UserWarning)
+    Traceback (most recent call last):
+      ...
+    UserWarning: deprecated
+
+    Let's suppress it with ignore_warnings:
+
+    >>> with warnings.catch_warnings():  # reset warnings in doctest
+    ...     warnings.simplefilter('error')
+    ...     with ignore_warnings(UserWarning):
+    ...         warnings.warn('deprecated', UserWarning)
+
+    (No warning emitted)
+
+    See Also
+    ========
+    sympy.utilities.exceptions.SymPyDeprecationWarning
+    sympy.utilities.exceptions.sympy_deprecation_warning
+    sympy.utilities.decorator.deprecated
+    sympy.testing.pytest.warns_deprecated_sympy
+
+    '''
+    # Absorbs all warnings in warnrec
+    with warnings.catch_warnings(record=True) as warnrec:
+        # Make sure our warning doesn't get filtered
+        warnings.simplefilter("always", warningcls)
+        # Now run the test
+        yield
+
+    # Reissue any warnings that we aren't testing for
+    for w in warnrec:
+        if not issubclass(w.category, warningcls):
+            warnings.warn_explicit(w.message, w.category, w.filename, w.lineno)

venv/lib/python3.10/site-packages/sympy/utilities/iterables.py

@@ -0,0 +1,3172 @@
+from collections import Counter, defaultdict, OrderedDict
+from itertools import (
+    chain, combinations, combinations_with_replacement, cycle, islice,
+    permutations, product, groupby
+)
+# For backwards compatibility
+from itertools import product as cartes # noqa: F401
+from operator import gt
+
+
+
+# this is the logical location of these functions
+from sympy.utilities.enumerative import (
+    multiset_partitions_taocp, list_visitor, MultisetPartitionTraverser)
+
+from sympy.utilities.misc import as_int
+from sympy.utilities.decorator import deprecated
+
+
+def is_palindromic(s, i=0, j=None):
+    """
+    Return True if the sequence is the same from left to right as it
+    is from right to left in the whole sequence (default) or in the
+    Python slice ``s[i: j]``; else False.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import is_palindromic
+    >>> is_palindromic([1, 0, 1])
+    True
+    >>> is_palindromic('abcbb')
+    False
+    >>> is_palindromic('abcbb', 1)
+    False
+
+    Normal Python slicing is performed in place so there is no need to
+    create a slice of the sequence for testing:
+
+    >>> is_palindromic('abcbb', 1, -1)
+    True
+    >>> is_palindromic('abcbb', -4, -1)
+    True
+
+    See Also
+    ========
+
+    sympy.ntheory.digits.is_palindromic: tests integers
+
+    """
+    i, j, _ = slice(i, j).indices(len(s))
+    m = (j - i)//2
+    # if length is odd, middle element will be ignored
+    return all(s[i + k] == s[j - 1 - k] for k in range(m))
+
+
+def flatten(iterable, levels=None, cls=None):  # noqa: F811
+    """
+    Recursively denest iterable containers.
+
+    >>> from sympy import flatten
+
+    >>> flatten([1, 2, 3])
+    [1, 2, 3]
+    >>> flatten([1, 2, [3]])
+    [1, 2, 3]
+    >>> flatten([1, [2, 3], [4, 5]])
+    [1, 2, 3, 4, 5]
+    >>> flatten([1.0, 2, (1, None)])
+    [1.0, 2, 1, None]
+
+    If you want to denest only a specified number of levels of
+    nested containers, then set ``levels`` flag to the desired
+    number of levels::
+
+    >>> ls = [[(-2, -1), (1, 2)], [(0, 0)]]
+
+    >>> flatten(ls, levels=1)
+    [(-2, -1), (1, 2), (0, 0)]
+
+    If cls argument is specified, it will only flatten instances of that
+    class, for example:
+
+    >>> from sympy import Basic, S
+    >>> class MyOp(Basic):
+    ...     pass
+    ...
+    >>> flatten([MyOp(S(1), MyOp(S(2), S(3)))], cls=MyOp)
+    [1, 2, 3]
+
+    adapted from https://kogs-www.informatik.uni-hamburg.de/~meine/python_tricks
+    """
+    from sympy.tensor.array import NDimArray
+    if levels is not None:
+        if not levels:
+            return iterable
+        elif levels > 0:
+            levels -= 1
+        else:
+            raise ValueError(
+                "expected non-negative number of levels, got %s" % levels)
+
+    if cls is None:
+        def reducible(x):
+            return is_sequence(x, set)
+    else:
+        def reducible(x):
+            return isinstance(x, cls)
+
+    result = []
+
+    for el in iterable:
+        if reducible(el):
+            if hasattr(el, 'args') and not isinstance(el, NDimArray):
+                el = el.args
+            result.extend(flatten(el, levels=levels, cls=cls))
+        else:
+            result.append(el)
+
+    return result
+
+
+def unflatten(iter, n=2):
+    """Group ``iter`` into tuples of length ``n``. Raise an error if
+    the length of ``iter`` is not a multiple of ``n``.
+    """
+    if n < 1 or len(iter) % n:
+        raise ValueError('iter length is not a multiple of %i' % n)
+    return list(zip(*(iter[i::n] for i in range(n))))
+
+
+def reshape(seq, how):
+    """Reshape the sequence according to the template in ``how``.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities import reshape
+    >>> seq = list(range(1, 9))
+
+    >>> reshape(seq, [4]) # lists of 4
+    [[1, 2, 3, 4], [5, 6, 7, 8]]
+
+    >>> reshape(seq, (4,)) # tuples of 4
+    [(1, 2, 3, 4), (5, 6, 7, 8)]
+
+    >>> reshape(seq, (2, 2)) # tuples of 4
+    [(1, 2, 3, 4), (5, 6, 7, 8)]
+
+    >>> reshape(seq, (2, [2])) # (i, i, [i, i])
+    [(1, 2, [3, 4]), (5, 6, [7, 8])]
+
+    >>> reshape(seq, ((2,), [2])) # etc....
+    [((1, 2), [3, 4]), ((5, 6), [7, 8])]
+
+    >>> reshape(seq, (1, [2], 1))
+    [(1, [2, 3], 4), (5, [6, 7], 8)]
+
+    >>> reshape(tuple(seq), ([[1], 1, (2,)],))
+    (([[1], 2, (3, 4)],), ([[5], 6, (7, 8)],))
+
+    >>> reshape(tuple(seq), ([1], 1, (2,)))
+    (([1], 2, (3, 4)), ([5], 6, (7, 8)))
+
+    >>> reshape(list(range(12)), [2, [3], {2}, (1, (3,), 1)])
+    [[0, 1, [2, 3, 4], {5, 6}, (7, (8, 9, 10), 11)]]
+
+    """
+    m = sum(flatten(how))
+    n, rem = divmod(len(seq), m)
+    if m < 0 or rem:
+        raise ValueError('template must sum to positive number '
+        'that divides the length of the sequence')
+    i = 0
+    container = type(how)
+    rv = [None]*n
+    for k in range(len(rv)):
+        _rv = []
+        for hi in how:
+            if isinstance(hi, int):
+                _rv.extend(seq[i: i + hi])
+                i += hi
+            else:
+                n = sum(flatten(hi))
+                hi_type = type(hi)
+                _rv.append(hi_type(reshape(seq[i: i + n], hi)[0]))
+                i += n
+        rv[k] = container(_rv)
+    return type(seq)(rv)
+
+
+def group(seq, multiple=True):
+    """
+    Splits a sequence into a list of lists of equal, adjacent elements.
+
+    Examples
+    ========
+
+    >>> from sympy import group
+
+    >>> group([1, 1, 1, 2, 2, 3])
+    [[1, 1, 1], [2, 2], [3]]
+    >>> group([1, 1, 1, 2, 2, 3], multiple=False)
+    [(1, 3), (2, 2), (3, 1)]
+    >>> group([1, 1, 3, 2, 2, 1], multiple=False)
+    [(1, 2), (3, 1), (2, 2), (1, 1)]
+
+    See Also
+    ========
+
+    multiset
+
+    """
+    if multiple:
+        return [(list(g)) for _, g in groupby(seq)]
+    return [(k, len(list(g))) for k, g in groupby(seq)]
+
+
+def _iproduct2(iterable1, iterable2):
+    '''Cartesian product of two possibly infinite iterables'''
+
+    it1 = iter(iterable1)
+    it2 = iter(iterable2)
+
+    elems1 = []
+    elems2 = []
+
+    sentinel = object()
+    def append(it, elems):
+        e = next(it, sentinel)
+        if e is not sentinel:
+            elems.append(e)
+
+    n = 0
+    append(it1, elems1)
+    append(it2, elems2)
+
+    while n <= len(elems1) + len(elems2):
+        for m in range(n-len(elems1)+1, len(elems2)):
+            yield (elems1[n-m], elems2[m])
+        n += 1
+        append(it1, elems1)
+        append(it2, elems2)
+
+
+def iproduct(*iterables):
+    '''
+    Cartesian product of iterables.
+
+    Generator of the Cartesian product of iterables. This is analogous to
+    itertools.product except that it works with infinite iterables and will
+    yield any item from the infinite product eventually.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import iproduct
+    >>> sorted(iproduct([1,2], [3,4]))
+    [(1, 3), (1, 4), (2, 3), (2, 4)]
+
+    With an infinite iterator:
+
+    >>> from sympy import S
+    >>> (3,) in iproduct(S.Integers)
+    True
+    >>> (3, 4) in iproduct(S.Integers, S.Integers)
+    True
+
+    .. seealso::
+
+       `itertools.product
+       <https://docs.python.org/3/library/itertools.html#itertools.product>`_
+    '''
+    if len(iterables) == 0:
+        yield ()
+        return
+    elif len(iterables) == 1:
+        for e in iterables[0]:
+            yield (e,)
+    elif len(iterables) == 2:
+        yield from _iproduct2(*iterables)
+    else:
+        first, others = iterables[0], iterables[1:]
+        for ef, eo in _iproduct2(first, iproduct(*others)):
+            yield (ef,) + eo
+
+
+def multiset(seq):
+    """Return the hashable sequence in multiset form with values being the
+    multiplicity of the item in the sequence.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import multiset
+    >>> multiset('mississippi')
+    {'i': 4, 'm': 1, 'p': 2, 's': 4}
+
+    See Also
+    ========
+
+    group
+
+    """
+    return dict(Counter(seq).items())
+
+
+
+
+def ibin(n, bits=None, str=False):
+    """Return a list of length ``bits`` corresponding to the binary value
+    of ``n`` with small bits to the right (last). If bits is omitted, the
+    length will be the number required to represent ``n``. If the bits are
+    desired in reversed order, use the ``[::-1]`` slice of the returned list.
+
+    If a sequence of all bits-length lists starting from ``[0, 0,..., 0]``
+    through ``[1, 1, ..., 1]`` are desired, pass a non-integer for bits, e.g.
+    ``'all'``.
+
+    If the bit *string* is desired pass ``str=True``.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import ibin
+    >>> ibin(2)
+    [1, 0]
+    >>> ibin(2, 4)
+    [0, 0, 1, 0]
+
+    If all lists corresponding to 0 to 2**n - 1, pass a non-integer
+    for bits:
+
+    >>> bits = 2
+    >>> for i in ibin(2, 'all'):
+    ...     print(i)
+    (0, 0)
+    (0, 1)
+    (1, 0)
+    (1, 1)
+
+    If a bit string is desired of a given length, use str=True:
+
+    >>> n = 123
+    >>> bits = 10
+    >>> ibin(n, bits, str=True)
+    '0001111011'
+    >>> ibin(n, bits, str=True)[::-1]  # small bits left
+    '1101111000'
+    >>> list(ibin(3, 'all', str=True))
+    ['000', '001', '010', '011', '100', '101', '110', '111']
+
+    """
+    if n < 0:
+        raise ValueError("negative numbers are not allowed")
+    n = as_int(n)
+
+    if bits is None:
+        bits = 0
+    else:
+        try:
+            bits = as_int(bits)
+        except ValueError:
+            bits = -1
+        else:
+            if n.bit_length() > bits:
+                raise ValueError(
+                    "`bits` must be >= {}".format(n.bit_length()))
+
+    if not str:
+        if bits >= 0:
+            return [1 if i == "1" else 0 for i in bin(n)[2:].rjust(bits, "0")]
+        else:
+            return variations(range(2), n, repetition=True)
+    else:
+        if bits >= 0:
+            return bin(n)[2:].rjust(bits, "0")
+        else:
+            return (bin(i)[2:].rjust(n, "0") for i in range(2**n))
+
+
+def variations(seq, n, repetition=False):
+    r"""Returns an iterator over the n-sized variations of ``seq`` (size N).
+    ``repetition`` controls whether items in ``seq`` can appear more than once;
+
+    Examples
+    ========
+
+    ``variations(seq, n)`` will return `\frac{N!}{(N - n)!}` permutations without
+    repetition of ``seq``'s elements:
+
+        >>> from sympy import variations
+        >>> list(variations([1, 2], 2))
+        [(1, 2), (2, 1)]
+
+    ``variations(seq, n, True)`` will return the `N^n` permutations obtained
+    by allowing repetition of elements:
+
+        >>> list(variations([1, 2], 2, repetition=True))
+        [(1, 1), (1, 2), (2, 1), (2, 2)]
+
+    If you ask for more items than are in the set you get the empty set unless
+    you allow repetitions:
+
+        >>> list(variations([0, 1], 3, repetition=False))
+        []
+        >>> list(variations([0, 1], 3, repetition=True))[:4]
+        [(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1)]
+
+    .. seealso::
+
+       `itertools.permutations
+       <https://docs.python.org/3/library/itertools.html#itertools.permutations>`_,
+       `itertools.product
+       <https://docs.python.org/3/library/itertools.html#itertools.product>`_
+    """
+    if not repetition:
+        seq = tuple(seq)
+        if len(seq) < n:
+            return iter(())  # 0 length iterator
+        return permutations(seq, n)
+    else:
+        if n == 0:
+            return iter(((),))  # yields 1 empty tuple
+        else:
+            return product(seq, repeat=n)
+
+
+def subsets(seq, k=None, repetition=False):
+    r"""Generates all `k`-subsets (combinations) from an `n`-element set, ``seq``.
+
+    A `k`-subset of an `n`-element set is any subset of length exactly `k`. The
+    number of `k`-subsets of an `n`-element set is given by ``binomial(n, k)``,
+    whereas there are `2^n` subsets all together. If `k` is ``None`` then all
+    `2^n` subsets will be returned from shortest to longest.
+
+    Examples
+    ========
+
+    >>> from sympy import subsets
+
+    ``subsets(seq, k)`` will return the
+    `\frac{n!}{k!(n - k)!}` `k`-subsets (combinations)
+    without repetition, i.e. once an item has been removed, it can no
+    longer be "taken":
+
+        >>> list(subsets([1, 2], 2))
+        [(1, 2)]
+        >>> list(subsets([1, 2]))
+        [(), (1,), (2,), (1, 2)]
+        >>> list(subsets([1, 2, 3], 2))
+        [(1, 2), (1, 3), (2, 3)]
+
+
+    ``subsets(seq, k, repetition=True)`` will return the
+    `\frac{(n - 1 + k)!}{k!(n - 1)!}`
+    combinations *with* repetition:
+
+        >>> list(subsets([1, 2], 2, repetition=True))
+        [(1, 1), (1, 2), (2, 2)]
+
+    If you ask for more items than are in the set you get the empty set unless
+    you allow repetitions:
+
+        >>> list(subsets([0, 1], 3, repetition=False))
+        []
+        >>> list(subsets([0, 1], 3, repetition=True))
+        [(0, 0, 0), (0, 0, 1), (0, 1, 1), (1, 1, 1)]
+
+    """
+    if k is None:
+        if not repetition:
+            return chain.from_iterable((combinations(seq, k)
+                                        for k in range(len(seq) + 1)))
+        else:
+            return chain.from_iterable((combinations_with_replacement(seq, k)
+                                        for k in range(len(seq) + 1)))
+    else:
+        if not repetition:
+            return combinations(seq, k)
+        else:
+            return combinations_with_replacement(seq, k)
+
+
+def filter_symbols(iterator, exclude):
+    """
+    Only yield elements from `iterator` that do not occur in `exclude`.
+
+    Parameters
+    ==========
+
+    iterator : iterable
+        iterator to take elements from
+
+    exclude : iterable
+        elements to exclude
+
+    Returns
+    =======
+
+    iterator : iterator
+        filtered iterator
+    """
+    exclude = set(exclude)
+    for s in iterator:
+        if s not in exclude:
+            yield s
+
+def numbered_symbols(prefix='x', cls=None, start=0, exclude=(), *args, **assumptions):
+    """
+    Generate an infinite stream of Symbols consisting of a prefix and
+    increasing subscripts provided that they do not occur in ``exclude``.
+
+    Parameters
+    ==========
+
+    prefix : str, optional
+        The prefix to use. By default, this function will generate symbols of
+        the form "x0", "x1", etc.
+
+    cls : class, optional
+        The class to use. By default, it uses ``Symbol``, but you can also use ``Wild``
+        or ``Dummy``.
+
+    start : int, optional
+        The start number.  By default, it is 0.
+
+    Returns
+    =======
+
+    sym : Symbol
+        The subscripted symbols.
+    """
+    exclude = set(exclude or [])
+    if cls is None:
+        # We can't just make the default cls=Symbol because it isn't
+        # imported yet.
+        from sympy.core import Symbol
+        cls = Symbol
+
+    while True:
+        name = '%s%s' % (prefix, start)
+        s = cls(name, *args, **assumptions)
+        if s not in exclude:
+            yield s
+        start += 1
+
+
+def capture(func):
+    """Return the printed output of func().
+
+    ``func`` should be a function without arguments that produces output with
+    print statements.
+
+    >>> from sympy.utilities.iterables import capture
+    >>> from sympy import pprint
+    >>> from sympy.abc import x
+    >>> def foo():
+    ...     print('hello world!')
+    ...
+    >>> 'hello' in capture(foo) # foo, not foo()
+    True
+    >>> capture(lambda: pprint(2/x))
+    '2\\n-\\nx\\n'
+
+    """
+    from io import StringIO
+    import sys
+
+    stdout = sys.stdout
+    sys.stdout = file = StringIO()
+    try:
+        func()
+    finally:
+        sys.stdout = stdout
+    return file.getvalue()
+
+
+def sift(seq, keyfunc, binary=False):
+    """
+    Sift the sequence, ``seq`` according to ``keyfunc``.
+
+    Returns
+    =======
+
+    When ``binary`` is ``False`` (default), the output is a dictionary
+    where elements of ``seq`` are stored in a list keyed to the value
+    of keyfunc for that element. If ``binary`` is True then a tuple
+    with lists ``T`` and ``F`` are returned where ``T`` is a list
+    containing elements of seq for which ``keyfunc`` was ``True`` and
+    ``F`` containing those elements for which ``keyfunc`` was ``False``;
+    a ValueError is raised if the ``keyfunc`` is not binary.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities import sift
+    >>> from sympy.abc import x, y
+    >>> from sympy import sqrt, exp, pi, Tuple
+
+    >>> sift(range(5), lambda x: x % 2)
+    {0: [0, 2, 4], 1: [1, 3]}
+
+    sift() returns a defaultdict() object, so any key that has no matches will
+    give [].
+
+    >>> sift([x], lambda x: x.is_commutative)
+    {True: [x]}
+    >>> _[False]
+    []
+
+    Sometimes you will not know how many keys you will get:
+
+    >>> sift([sqrt(x), exp(x), (y**x)**2],
+    ...      lambda x: x.as_base_exp()[0])
+    {E: [exp(x)], x: [sqrt(x)], y: [y**(2*x)]}
+
+    Sometimes you expect the results to be binary; the
+    results can be unpacked by setting ``binary`` to True:
+
+    >>> sift(range(4), lambda x: x % 2, binary=True)
+    ([1, 3], [0, 2])
+    >>> sift(Tuple(1, pi), lambda x: x.is_rational, binary=True)
+    ([1], [pi])
+
+    A ValueError is raised if the predicate was not actually binary
+    (which is a good test for the logic where sifting is used and
+    binary results were expected):
+
+    >>> unknown = exp(1) - pi  # the rationality of this is unknown
+    >>> args = Tuple(1, pi, unknown)
+    >>> sift(args, lambda x: x.is_rational, binary=True)
+    Traceback (most recent call last):
+    ...
+    ValueError: keyfunc gave non-binary output
+
+    The non-binary sifting shows that there were 3 keys generated:
+
+    >>> set(sift(args, lambda x: x.is_rational).keys())
+    {None, False, True}
+
+    If you need to sort the sifted items it might be better to use
+    ``ordered`` which can economically apply multiple sort keys
+    to a sequence while sorting.
+
+    See Also
+    ========
+
+    ordered
+
+    """
+    if not binary:
+        m = defaultdict(list)
+        for i in seq:
+            m[keyfunc(i)].append(i)
+        return m
+    sift = F, T = [], []
+    for i in seq:
+        try:
+            sift[keyfunc(i)].append(i)
+        except (IndexError, TypeError):
+            raise ValueError('keyfunc gave non-binary output')
+    return T, F
+
+
+def take(iter, n):
+    """Return ``n`` items from ``iter`` iterator. """
+    return [ value for _, value in zip(range(n), iter) ]
+
+
+def dict_merge(*dicts):
+    """Merge dictionaries into a single dictionary. """
+    merged = {}
+
+    for dict in dicts:
+        merged.update(dict)
+
+    return merged
+
+
+def common_prefix(*seqs):
+    """Return the subsequence that is a common start of sequences in ``seqs``.
+
+    >>> from sympy.utilities.iterables import common_prefix
+    >>> common_prefix(list(range(3)))
+    [0, 1, 2]
+    >>> common_prefix(list(range(3)), list(range(4)))
+    [0, 1, 2]
+    >>> common_prefix([1, 2, 3], [1, 2, 5])
+    [1, 2]
+    >>> common_prefix([1, 2, 3], [1, 3, 5])
+    [1]
+    """
+    if not all(seqs):
+        return []
+    elif len(seqs) == 1:
+        return seqs[0]
+    i = 0
+    for i in range(min(len(s) for s in seqs)):
+        if not all(seqs[j][i] == seqs[0][i] for j in range(len(seqs))):
+            break
+    else:
+        i += 1
+    return seqs[0][:i]
+
+
+def common_suffix(*seqs):
+    """Return the subsequence that is a common ending of sequences in ``seqs``.
+
+    >>> from sympy.utilities.iterables import common_suffix
+    >>> common_suffix(list(range(3)))
+    [0, 1, 2]
+    >>> common_suffix(list(range(3)), list(range(4)))
+    []
+    >>> common_suffix([1, 2, 3], [9, 2, 3])
+    [2, 3]
+    >>> common_suffix([1, 2, 3], [9, 7, 3])
+    [3]
+    """
+
+    if not all(seqs):
+        return []
+    elif len(seqs) == 1:
+        return seqs[0]
+    i = 0
+    for i in range(-1, -min(len(s) for s in seqs) - 1, -1):
+        if not all(seqs[j][i] == seqs[0][i] for j in range(len(seqs))):
+            break
+    else:
+        i -= 1
+    if i == -1:
+        return []
+    else:
+        return seqs[0][i + 1:]
+
+
+def prefixes(seq):
+    """
+    Generate all prefixes of a sequence.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import prefixes
+
+    >>> list(prefixes([1,2,3,4]))
+    [[1], [1, 2], [1, 2, 3], [1, 2, 3, 4]]
+
+    """
+    n = len(seq)
+
+    for i in range(n):
+        yield seq[:i + 1]
+
+
+def postfixes(seq):
+    """
+    Generate all postfixes of a sequence.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import postfixes
+
+    >>> list(postfixes([1,2,3,4]))
+    [[4], [3, 4], [2, 3, 4], [1, 2, 3, 4]]
+
+    """
+    n = len(seq)
+
+    for i in range(n):
+        yield seq[n - i - 1:]
+
+
+def topological_sort(graph, key=None):
+    r"""
+    Topological sort of graph's vertices.
+
+    Parameters
+    ==========
+
+    graph : tuple[list, list[tuple[T, T]]
+        A tuple consisting of a list of vertices and a list of edges of
+        a graph to be sorted topologically.
+
+    key : callable[T] (optional)
+        Ordering key for vertices on the same level. By default the natural
+        (e.g. lexicographic) ordering is used (in this case the base type
+        must implement ordering relations).
+
+    Examples
+    ========
+
+    Consider a graph::
+
+        +---+     +---+     +---+
+        | 7 |\    | 5 |     | 3 |
+        +---+ \   +---+     +---+
+          |   _\___/ ____   _/ |
+          |  /  \___/    \ /   |
+          V  V           V V   |
+         +----+         +---+  |
+         | 11 |         | 8 |  |
+         +----+         +---+  |
+          | | \____   ___/ _   |
+          | \      \ /    / \  |
+          V  \     V V   /  V  V
+        +---+ \   +---+ |  +----+
+        | 2 |  |  | 9 | |  | 10 |
+        +---+  |  +---+ |  +----+
+               \________/
+
+    where vertices are integers. This graph can be encoded using
+    elementary Python's data structures as follows::
+
+        >>> V = [2, 3, 5, 7, 8, 9, 10, 11]
+        >>> E = [(7, 11), (7, 8), (5, 11), (3, 8), (3, 10),
+        ...      (11, 2), (11, 9), (11, 10), (8, 9)]
+
+    To compute a topological sort for graph ``(V, E)`` issue::
+
+        >>> from sympy.utilities.iterables import topological_sort
+
+        >>> topological_sort((V, E))
+        [3, 5, 7, 8, 11, 2, 9, 10]
+
+    If specific tie breaking approach is needed, use ``key`` parameter::
+
+        >>> topological_sort((V, E), key=lambda v: -v)
+        [7, 5, 11, 3, 10, 8, 9, 2]
+
+    Only acyclic graphs can be sorted. If the input graph has a cycle,
+    then ``ValueError`` will be raised::
+
+        >>> topological_sort((V, E + [(10, 7)]))
+        Traceback (most recent call last):
+        ...
+        ValueError: cycle detected
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Topological_sorting
+
+    """
+    V, E = graph
+
+    L = []
+    S = set(V)
+    E = list(E)
+
+    for v, u in E:
+        S.discard(u)
+
+    if key is None:
+        def key(value):
+            return value
+
+    S = sorted(S, key=key, reverse=True)
+
+    while S:
+        node = S.pop()
+        L.append(node)
+
+        for u, v in list(E):
+            if u == node:
+                E.remove((u, v))
+
+                for _u, _v in E:
+                    if v == _v:
+                        break
+                else:
+                    kv = key(v)
+
+                    for i, s in enumerate(S):
+                        ks = key(s)
+
+                        if kv > ks:
+                            S.insert(i, v)
+                            break
+                    else:
+                        S.append(v)
+
+    if E:
+        raise ValueError("cycle detected")
+    else:
+        return L
+
+
+def strongly_connected_components(G):
+    r"""
+    Strongly connected components of a directed graph in reverse topological
+    order.
+
+
+    Parameters
+    ==========
+
+    graph : tuple[list, list[tuple[T, T]]
+        A tuple consisting of a list of vertices and a list of edges of
+        a graph whose strongly connected components are to be found.
+
+
+    Examples
+    ========
+
+    Consider a directed graph (in dot notation)::
+
+        digraph {
+            A -> B
+            A -> C
+            B -> C
+            C -> B
+            B -> D
+        }
+
+    .. graphviz::
+
+        digraph {
+            A -> B
+            A -> C
+            B -> C
+            C -> B
+            B -> D
+        }
+
+    where vertices are the letters A, B, C and D. This graph can be encoded
+    using Python's elementary data structures as follows::
+
+        >>> V = ['A', 'B', 'C', 'D']
+        >>> E = [('A', 'B'), ('A', 'C'), ('B', 'C'), ('C', 'B'), ('B', 'D')]
+
+    The strongly connected components of this graph can be computed as
+
+        >>> from sympy.utilities.iterables import strongly_connected_components
+
+        >>> strongly_connected_components((V, E))
+        [['D'], ['B', 'C'], ['A']]
+
+    This also gives the components in reverse topological order.
+
+    Since the subgraph containing B and C has a cycle they must be together in
+    a strongly connected component. A and D are connected to the rest of the
+    graph but not in a cyclic manner so they appear as their own strongly
+    connected components.
+
+
+    Notes
+    =====
+
+    The vertices of the graph must be hashable for the data structures used.
+    If the vertices are unhashable replace them with integer indices.
+
+    This function uses Tarjan's algorithm to compute the strongly connected
+    components in `O(|V|+|E|)` (linear) time.
+
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Strongly_connected_component
+    .. [2] https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
+
+
+    See Also
+    ========
+
+    sympy.utilities.iterables.connected_components
+
+    """
+    # Map from a vertex to its neighbours
+    V, E = G
+    Gmap = {vi: [] for vi in V}
+    for v1, v2 in E:
+        Gmap[v1].append(v2)
+    return _strongly_connected_components(V, Gmap)
+
+
+def _strongly_connected_components(V, Gmap):
+    """More efficient internal routine for strongly_connected_components"""
+    #
+    # Here V is an iterable of vertices and Gmap is a dict mapping each vertex
+    # to a list of neighbours e.g.:
+    #
+    #   V = [0, 1, 2, 3]
+    #   Gmap = {0: [2, 3], 1: [0]}
+    #
+    # For a large graph these data structures can often be created more
+    # efficiently then those expected by strongly_connected_components() which
+    # in this case would be
+    #
+    #   V = [0, 1, 2, 3]
+    #   Gmap = [(0, 2), (0, 3), (1, 0)]
+    #
+    # XXX: Maybe this should be the recommended function to use instead...
+    #
+
+    # Non-recursive Tarjan's algorithm:
+    lowlink = {}
+    indices = {}
+    stack = OrderedDict()
+    callstack = []
+    components = []
+    nomore = object()
+
+    def start(v):
+        index = len(stack)
+        indices[v] = lowlink[v] = index
+        stack[v] = None
+        callstack.append((v, iter(Gmap[v])))
+
+    def finish(v1):
+        # Finished a component?
+        if lowlink[v1] == indices[v1]:
+            component = [stack.popitem()[0]]
+            while component[-1] is not v1:
+                component.append(stack.popitem()[0])
+            components.append(component[::-1])
+        v2, _ = callstack.pop()
+        if callstack:
+            v1, _ = callstack[-1]
+            lowlink[v1] = min(lowlink[v1], lowlink[v2])
+
+    for v in V:
+        if v in indices:
+            continue
+        start(v)
+        while callstack:
+            v1, it1 = callstack[-1]
+            v2 = next(it1, nomore)
+            # Finished children of v1?
+            if v2 is nomore:
+                finish(v1)
+            # Recurse on v2
+            elif v2 not in indices:
+                start(v2)
+            elif v2 in stack:
+                lowlink[v1] = min(lowlink[v1], indices[v2])
+
+    # Reverse topological sort order:
+    return components
+
+
+def connected_components(G):
+    r"""
+    Connected components of an undirected graph or weakly connected components
+    of a directed graph.
+
+
+    Parameters
+    ==========
+
+    graph : tuple[list, list[tuple[T, T]]
+        A tuple consisting of a list of vertices and a list of edges of
+        a graph whose connected components are to be found.
+
+
+    Examples
+    ========
+
+
+    Given an undirected graph::
+
+        graph {
+            A -- B
+            C -- D
+        }
+
+    .. graphviz::
+
+        graph {
+            A -- B
+            C -- D
+        }
+
+    We can find the connected components using this function if we include
+    each edge in both directions::
+
+        >>> from sympy.utilities.iterables import connected_components
+
+        >>> V = ['A', 'B', 'C', 'D']
+        >>> E = [('A', 'B'), ('B', 'A'), ('C', 'D'), ('D', 'C')]
+        >>> connected_components((V, E))
+        [['A', 'B'], ['C', 'D']]
+
+    The weakly connected components of a directed graph can found the same
+    way.
+
+
+    Notes
+    =====
+
+    The vertices of the graph must be hashable for the data structures used.
+    If the vertices are unhashable replace them with integer indices.
+
+    This function uses Tarjan's algorithm to compute the connected components
+    in `O(|V|+|E|)` (linear) time.
+
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Component_%28graph_theory%29
+    .. [2] https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
+
+
+    See Also
+    ========
+
+    sympy.utilities.iterables.strongly_connected_components
+
+    """
+    # Duplicate edges both ways so that the graph is effectively undirected
+    # and return the strongly connected components:
+    V, E = G
+    E_undirected = []
+    for v1, v2 in E:
+        E_undirected.extend([(v1, v2), (v2, v1)])
+    return strongly_connected_components((V, E_undirected))
+
+
+def rotate_left(x, y):
+    """
+    Left rotates a list x by the number of steps specified
+    in y.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import rotate_left
+    >>> a = [0, 1, 2]
+    >>> rotate_left(a, 1)
+    [1, 2, 0]
+    """
+    if len(x) == 0:
+        return []
+    y = y % len(x)
+    return x[y:] + x[:y]
+
+
+def rotate_right(x, y):
+    """
+    Right rotates a list x by the number of steps specified
+    in y.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import rotate_right
+    >>> a = [0, 1, 2]
+    >>> rotate_right(a, 1)
+    [2, 0, 1]
+    """
+    if len(x) == 0:
+        return []
+    y = len(x) - y % len(x)
+    return x[y:] + x[:y]
+
+
+def least_rotation(x, key=None):
+    '''
+    Returns the number of steps of left rotation required to
+    obtain lexicographically minimal string/list/tuple, etc.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import least_rotation, rotate_left
+    >>> a = [3, 1, 5, 1, 2]
+    >>> least_rotation(a)
+    3
+    >>> rotate_left(a, _)
+    [1, 2, 3, 1, 5]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Lexicographically_minimal_string_rotation
+
+    '''
+    from sympy.functions.elementary.miscellaneous import Id
+    if key is None: key = Id
+    S = x + x      # Concatenate string to it self to avoid modular arithmetic
+    f = [-1] * len(S)     # Failure function
+    k = 0       # Least rotation of string found so far
+    for j in range(1,len(S)):
+        sj = S[j]
+        i = f[j-k-1]
+        while i != -1 and sj != S[k+i+1]:
+            if key(sj) < key(S[k+i+1]):
+                k = j-i-1
+            i = f[i]
+        if sj != S[k+i+1]:
+            if key(sj) < key(S[k]):
+                k = j
+            f[j-k] = -1
+        else:
+            f[j-k] = i+1
+    return k
+
+
+def multiset_combinations(m, n, g=None):
+    """
+    Return the unique combinations of size ``n`` from multiset ``m``.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import multiset_combinations
+    >>> from itertools import combinations
+    >>> [''.join(i) for i in  multiset_combinations('baby', 3)]
+    ['abb', 'aby', 'bby']
+
+    >>> def count(f, s): return len(list(f(s, 3)))
+
+    The number of combinations depends on the number of letters; the
+    number of unique combinations depends on how the letters are
+    repeated.
+
+    >>> s1 = 'abracadabra'
+    >>> s2 = 'banana tree'
+    >>> count(combinations, s1), count(multiset_combinations, s1)
+    (165, 23)
+    >>> count(combinations, s2), count(multiset_combinations, s2)
+    (165, 54)
+
+    """
+    from sympy.core.sorting import ordered
+    if g is None:
+        if isinstance(m, dict):
+            if any(as_int(v) < 0 for v in m.values()):
+                raise ValueError('counts cannot be negative')
+            N = sum(m.values())
+            if n > N:
+                return
+            g = [[k, m[k]] for k in ordered(m)]
+        else:
+            m = list(m)
+            N = len(m)
+            if n > N:
+                return
+            try:
+                m = multiset(m)
+                g = [(k, m[k]) for k in ordered(m)]
+            except TypeError:
+                m = list(ordered(m))
+                g = [list(i) for i in group(m, multiple=False)]
+        del m
+    else:
+        # not checking counts since g is intended for internal use
+        N = sum(v for k, v in g)
+    if n > N or not n:
+        yield []
+    else:
+        for i, (k, v) in enumerate(g):
+            if v >= n:
+                yield [k]*n
+                v = n - 1
+            for v in range(min(n, v), 0, -1):
+                for j in multiset_combinations(None, n - v, g[i + 1:]):
+                    rv = [k]*v + j
+                    if len(rv) == n:
+                        yield rv
+
+def multiset_permutations(m, size=None, g=None):
+    """
+    Return the unique permutations of multiset ``m``.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import multiset_permutations
+    >>> from sympy import factorial
+    >>> [''.join(i) for i in multiset_permutations('aab')]
+    ['aab', 'aba', 'baa']
+    >>> factorial(len('banana'))
+    720
+    >>> len(list(multiset_permutations('banana')))
+    60
+    """
+    from sympy.core.sorting import ordered
+    if g is None:
+        if isinstance(m, dict):
+            if any(as_int(v) < 0 for v in m.values()):
+                raise ValueError('counts cannot be negative')
+            g = [[k, m[k]] for k in ordered(m)]
+        else:
+            m = list(ordered(m))
+            g = [list(i) for i in group(m, multiple=False)]
+        del m
+    do = [gi for gi in g if gi[1] > 0]
+    SUM = sum([gi[1] for gi in do])
+    if not do or size is not None and (size > SUM or size < 1):
+        if not do and size is None or size == 0:
+            yield []
+        return
+    elif size == 1:
+        for k, v in do:
+            yield [k]
+    elif len(do) == 1:
+        k, v = do[0]
+        v = v if size is None else (size if size <= v else 0)
+        yield [k for i in range(v)]
+    elif all(v == 1 for k, v in do):
+        for p in permutations([k for k, v in do], size):
+            yield list(p)
+    else:
+        size = size if size is not None else SUM
+        for i, (k, v) in enumerate(do):
+            do[i][1] -= 1
+            for j in multiset_permutations(None, size - 1, do):
+                if j:
+                    yield [k] + j
+            do[i][1] += 1
+
+
+def _partition(seq, vector, m=None):
+    """
+    Return the partition of seq as specified by the partition vector.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import _partition
+    >>> _partition('abcde', [1, 0, 1, 2, 0])
+    [['b', 'e'], ['a', 'c'], ['d']]
+
+    Specifying the number of bins in the partition is optional:
+
+    >>> _partition('abcde', [1, 0, 1, 2, 0], 3)
+    [['b', 'e'], ['a', 'c'], ['d']]
+
+    The output of _set_partitions can be passed as follows:
+
+    >>> output = (3, [1, 0, 1, 2, 0])
+    >>> _partition('abcde', *output)
+    [['b', 'e'], ['a', 'c'], ['d']]
+
+    See Also
+    ========
+
+    combinatorics.partitions.Partition.from_rgs
+
+    """
+    if m is None:
+        m = max(vector) + 1
+    elif isinstance(vector, int):  # entered as m, vector
+        vector, m = m, vector
+    p = [[] for i in range(m)]
+    for i, v in enumerate(vector):
+        p[v].append(seq[i])
+    return p
+
+
+def _set_partitions(n):
+    """Cycle through all partitions of n elements, yielding the
+    current number of partitions, ``m``, and a mutable list, ``q``
+    such that ``element[i]`` is in part ``q[i]`` of the partition.
+
+    NOTE: ``q`` is modified in place and generally should not be changed
+    between function calls.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import _set_partitions, _partition
+    >>> for m, q in _set_partitions(3):
+    ...     print('%s %s %s' % (m, q, _partition('abc', q, m)))
+    1 [0, 0, 0] [['a', 'b', 'c']]
+    2 [0, 0, 1] [['a', 'b'], ['c']]
+    2 [0, 1, 0] [['a', 'c'], ['b']]
+    2 [0, 1, 1] [['a'], ['b', 'c']]
+    3 [0, 1, 2] [['a'], ['b'], ['c']]
+
+    Notes
+    =====
+
+    This algorithm is similar to, and solves the same problem as,
+    Algorithm 7.2.1.5H, from volume 4A of Knuth's The Art of Computer
+    Programming.  Knuth uses the term "restricted growth string" where
+    this code refers to a "partition vector". In each case, the meaning is
+    the same: the value in the ith element of the vector specifies to
+    which part the ith set element is to be assigned.
+
+    At the lowest level, this code implements an n-digit big-endian
+    counter (stored in the array q) which is incremented (with carries) to
+    get the next partition in the sequence.  A special twist is that a
+    digit is constrained to be at most one greater than the maximum of all
+    the digits to the left of it.  The array p maintains this maximum, so
+    that the code can efficiently decide when a digit can be incremented
+    in place or whether it needs to be reset to 0 and trigger a carry to
+    the next digit.  The enumeration starts with all the digits 0 (which
+    corresponds to all the set elements being assigned to the same 0th
+    part), and ends with 0123...n, which corresponds to each set element
+    being assigned to a different, singleton, part.
+
+    This routine was rewritten to use 0-based lists while trying to
+    preserve the beauty and efficiency of the original algorithm.
+
+    References
+    ==========
+
+    .. [1] Nijenhuis, Albert and Wilf, Herbert. (1978) Combinatorial Algorithms,
+        2nd Ed, p 91, algorithm "nexequ". Available online from
+        https://www.math.upenn.edu/~wilf/website/CombAlgDownld.html (viewed
+        November 17, 2012).
+
+    """
+    p = [0]*n
+    q = [0]*n
+    nc = 1
+    yield nc, q
+    while nc != n:
+        m = n
+        while 1:
+            m -= 1
+            i = q[m]
+            if p[i] != 1:
+                break
+            q[m] = 0
+        i += 1
+        q[m] = i
+        m += 1
+        nc += m - n
+        p[0] += n - m
+        if i == nc:
+            p[nc] = 0
+            nc += 1
+        p[i - 1] -= 1
+        p[i] += 1
+        yield nc, q
+
+
+def multiset_partitions(multiset, m=None):
+    """
+    Return unique partitions of the given multiset (in list form).
+    If ``m`` is None, all multisets will be returned, otherwise only
+    partitions with ``m`` parts will be returned.
+
+    If ``multiset`` is an integer, a range [0, 1, ..., multiset - 1]
+    will be supplied.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import multiset_partitions
+    >>> list(multiset_partitions([1, 2, 3, 4], 2))
+    [[[1, 2, 3], [4]], [[1, 2, 4], [3]], [[1, 2], [3, 4]],
+    [[1, 3, 4], [2]], [[1, 3], [2, 4]], [[1, 4], [2, 3]],
+    [[1], [2, 3, 4]]]
+    >>> list(multiset_partitions([1, 2, 3, 4], 1))
+    [[[1, 2, 3, 4]]]
+
+    Only unique partitions are returned and these will be returned in a
+    canonical order regardless of the order of the input:
+
+    >>> a = [1, 2, 2, 1]
+    >>> ans = list(multiset_partitions(a, 2))
+    >>> a.sort()
+    >>> list(multiset_partitions(a, 2)) == ans
+    True
+    >>> a = range(3, 1, -1)
+    >>> (list(multiset_partitions(a)) ==
+    ...  list(multiset_partitions(sorted(a))))
+    True
+
+    If m is omitted then all partitions will be returned:
+
+    >>> list(multiset_partitions([1, 1, 2]))
+    [[[1, 1, 2]], [[1, 1], [2]], [[1, 2], [1]], [[1], [1], [2]]]
+    >>> list(multiset_partitions([1]*3))
+    [[[1, 1, 1]], [[1], [1, 1]], [[1], [1], [1]]]
+
+    Counting
+    ========
+
+    The number of partitions of a set is given by the bell number:
+
+    >>> from sympy import bell
+    >>> len(list(multiset_partitions(5))) == bell(5) == 52
+    True
+
+    The number of partitions of length k from a set of size n is given by the
+    Stirling Number of the 2nd kind:
+
+    >>> from sympy.functions.combinatorial.numbers import stirling
+    >>> stirling(5, 2) == len(list(multiset_partitions(5, 2))) == 15
+    True
+
+    These comments on counting apply to *sets*, not multisets.
+
+    Notes
+    =====
+
+    When all the elements are the same in the multiset, the order
+    of the returned partitions is determined by the ``partitions``
+    routine. If one is counting partitions then it is better to use
+    the ``nT`` function.
+
+    See Also
+    ========
+
+    partitions
+    sympy.combinatorics.partitions.Partition
+    sympy.combinatorics.partitions.IntegerPartition
+    sympy.functions.combinatorial.numbers.nT
+
+    """
+    # This function looks at the supplied input and dispatches to
+    # several special-case routines as they apply.
+    if isinstance(multiset, int):
+        n = multiset
+        if m and m > n:
+            return
+        multiset = list(range(n))
+        if m == 1:
+            yield [multiset[:]]
+            return
+
+        # If m is not None, it can sometimes be faster to use
+        # MultisetPartitionTraverser.enum_range() even for inputs
+        # which are sets.  Since the _set_partitions code is quite
+        # fast, this is only advantageous when the overall set
+        # partitions outnumber those with the desired number of parts
+        # by a large factor.  (At least 60.)  Such a switch is not
+        # currently implemented.
+        for nc, q in _set_partitions(n):
+            if m is None or nc == m:
+                rv = [[] for i in range(nc)]
+                for i in range(n):
+                    rv[q[i]].append(multiset[i])
+                yield rv
+        return
+
+    if len(multiset) == 1 and isinstance(multiset, str):
+        multiset = [multiset]
+
+    if not has_variety(multiset):
+        # Only one component, repeated n times.  The resulting
+        # partitions correspond to partitions of integer n.
+        n = len(multiset)
+        if m and m > n:
+            return
+        if m == 1:
+            yield [multiset[:]]
+            return
+        x = multiset[:1]
+        for size, p in partitions(n, m, size=True):
+            if m is None or size == m:
+                rv = []
+                for k in sorted(p):
+                    rv.extend([x*k]*p[k])
+                yield rv
+    else:
+        from sympy.core.sorting import ordered
+        multiset = list(ordered(multiset))
+        n = len(multiset)
+        if m and m > n:
+            return
+        if m == 1:
+            yield [multiset[:]]
+            return
+
+        # Split the information of the multiset into two lists -
+        # one of the elements themselves, and one (of the same length)
+        # giving the number of repeats for the corresponding element.
+        elements, multiplicities = zip(*group(multiset, False))
+
+        if len(elements) < len(multiset):
+            # General case - multiset with more than one distinct element
+            # and at least one element repeated more than once.
+            if m:
+                mpt = MultisetPartitionTraverser()
+                for state in mpt.enum_range(multiplicities, m-1, m):
+                    yield list_visitor(state, elements)
+            else:
+                for state in multiset_partitions_taocp(multiplicities):
+                    yield list_visitor(state, elements)
+        else:
+            # Set partitions case - no repeated elements. Pretty much
+            # same as int argument case above, with same possible, but
+            # currently unimplemented optimization for some cases when
+            # m is not None
+            for nc, q in _set_partitions(n):
+                if m is None or nc == m:
+                    rv = [[] for i in range(nc)]
+                    for i in range(n):
+                        rv[q[i]].append(i)
+                    yield [[multiset[j] for j in i] for i in rv]
+
+
+def partitions(n, m=None, k=None, size=False):
+    """Generate all partitions of positive integer, n.
+
+    Parameters
+    ==========
+
+    m : integer (default gives partitions of all sizes)
+        limits number of parts in partition (mnemonic: m, maximum parts)
+    k : integer (default gives partitions number from 1 through n)
+        limits the numbers that are kept in the partition (mnemonic: k, keys)
+    size : bool (default False, only partition is returned)
+        when ``True`` then (M, P) is returned where M is the sum of the
+        multiplicities and P is the generated partition.
+
+    Each partition is represented as a dictionary, mapping an integer
+    to the number of copies of that integer in the partition.  For example,
+    the first partition of 4 returned is {4: 1}, "4: one of them".
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import partitions
+
+    The numbers appearing in the partition (the key of the returned dict)
+    are limited with k:
+
+    >>> for p in partitions(6, k=2):  # doctest: +SKIP
+    ...     print(p)
+    {2: 3}
+    {1: 2, 2: 2}
+    {1: 4, 2: 1}
+    {1: 6}
+
+    The maximum number of parts in the partition (the sum of the values in
+    the returned dict) are limited with m (default value, None, gives
+    partitions from 1 through n):
+
+    >>> for p in partitions(6, m=2):  # doctest: +SKIP
+    ...     print(p)
+    ...
+    {6: 1}
+    {1: 1, 5: 1}
+    {2: 1, 4: 1}
+    {3: 2}
+
+    References
+    ==========
+
+    .. [1] modified from Tim Peter's version to allow for k and m values:
+           https://code.activestate.com/recipes/218332-generator-for-integer-partitions/
+
+    See Also
+    ========
+
+    sympy.combinatorics.partitions.Partition
+    sympy.combinatorics.partitions.IntegerPartition
+
+    """
+    if (n <= 0 or
+        m is not None and m < 1 or
+        k is not None and k < 1 or
+        m and k and m*k < n):
+        # the empty set is the only way to handle these inputs
+        # and returning {} to represent it is consistent with
+        # the counting convention, e.g. nT(0) == 1.
+        if size:
+            yield 0, {}
+        else:
+            yield {}
+        return
+
+    if m is None:
+        m = n
+    else:
+        m = min(m, n)
+    k = min(k or n, n)
+
+    n, m, k = as_int(n), as_int(m), as_int(k)
+    q, r = divmod(n, k)
+    ms = {k: q}
+    keys = [k]  # ms.keys(), from largest to smallest
+    if r:
+        ms[r] = 1
+        keys.append(r)
+    room = m - q - bool(r)
+    if size:
+        yield sum(ms.values()), ms.copy()
+    else:
+        yield ms.copy()
+
+    while keys != [1]:
+        # Reuse any 1's.
+        if keys[-1] == 1:
+            del keys[-1]
+            reuse = ms.pop(1)
+            room += reuse
+        else:
+            reuse = 0
+
+        while 1:
+            # Let i be the smallest key larger than 1.  Reuse one
+            # instance of i.
+            i = keys[-1]
+            newcount = ms[i] = ms[i] - 1
+            reuse += i
+            if newcount == 0:
+                del keys[-1], ms[i]
+            room += 1
+
+            # Break the remainder into pieces of size i-1.
+            i -= 1
+            q, r = divmod(reuse, i)
+            need = q + bool(r)
+            if need > room:
+                if not keys:
+                    return
+                continue
+
+            ms[i] = q
+            keys.append(i)
+            if r:
+                ms[r] = 1
+                keys.append(r)
+            break
+        room -= need
+        if size:
+            yield sum(ms.values()), ms.copy()
+        else:
+            yield ms.copy()
+
+
+def ordered_partitions(n, m=None, sort=True):
+    """Generates ordered partitions of integer ``n``.
+
+    Parameters
+    ==========
+
+    m : integer (default None)
+        The default value gives partitions of all sizes else only
+        those with size m. In addition, if ``m`` is not None then
+        partitions are generated *in place* (see examples).
+    sort : bool (default True)
+        Controls whether partitions are
+        returned in sorted order when ``m`` is not None; when False,
+        the partitions are returned as fast as possible with elements
+        sorted, but when m|n the partitions will not be in
+        ascending lexicographical order.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import ordered_partitions
+
+    All partitions of 5 in ascending lexicographical:
+
+    >>> for p in ordered_partitions(5):
+    ...     print(p)
+    [1, 1, 1, 1, 1]
+    [1, 1, 1, 2]
+    [1, 1, 3]
+    [1, 2, 2]
+    [1, 4]
+    [2, 3]
+    [5]
+
+    Only partitions of 5 with two parts:
+
+    >>> for p in ordered_partitions(5, 2):
+    ...     print(p)
+    [1, 4]
+    [2, 3]
+
+    When ``m`` is given, a given list objects will be used more than
+    once for speed reasons so you will not see the correct partitions
+    unless you make a copy of each as it is generated:
+
+    >>> [p for p in ordered_partitions(7, 3)]
+    [[1, 1, 1], [1, 1, 1], [1, 1, 1], [2, 2, 2]]
+    >>> [list(p) for p in ordered_partitions(7, 3)]
+    [[1, 1, 5], [1, 2, 4], [1, 3, 3], [2, 2, 3]]
+
+    When ``n`` is a multiple of ``m``, the elements are still sorted
+    but the partitions themselves will be *unordered* if sort is False;
+    the default is to return them in ascending lexicographical order.
+
+    >>> for p in ordered_partitions(6, 2):
+    ...     print(p)
+    [1, 5]
+    [2, 4]
+    [3, 3]
+
+    But if speed is more important than ordering, sort can be set to
+    False:
+
+    >>> for p in ordered_partitions(6, 2, sort=False):
+    ...     print(p)
+    [1, 5]
+    [3, 3]
+    [2, 4]
+
+    References
+    ==========
+
+    .. [1] Generating Integer Partitions, [online],
+        Available: https://jeromekelleher.net/generating-integer-partitions.html
+    .. [2] Jerome Kelleher and Barry O'Sullivan, "Generating All
+        Partitions: A Comparison Of Two Encodings", [online],
+        Available: https://arxiv.org/pdf/0909.2331v2.pdf
+    """
+    if n < 1 or m is not None and m < 1:
+        # the empty set is the only way to handle these inputs
+        # and returning {} to represent it is consistent with
+        # the counting convention, e.g. nT(0) == 1.
+        yield []
+        return
+
+    if m is None:
+        # The list `a`'s leading elements contain the partition in which
+        # y is the biggest element and x is either the same as y or the
+        # 2nd largest element; v and w are adjacent element indices
+        # to which x and y are being assigned, respectively.
+        a = [1]*n
+        y = -1
+        v = n
+        while v > 0:
+            v -= 1
+            x = a[v] + 1
+            while y >= 2 * x:
+                a[v] = x
+                y -= x
+                v += 1
+            w = v + 1
+            while x <= y:
+                a[v] = x
+                a[w] = y
+                yield a[:w + 1]
+                x += 1
+                y -= 1
+            a[v] = x + y
+            y = a[v] - 1
+            yield a[:w]
+    elif m == 1:
+        yield [n]
+    elif n == m:
+        yield [1]*n
+    else:
+        # recursively generate partitions of size m
+        for b in range(1, n//m + 1):
+            a = [b]*m
+            x = n - b*m
+            if not x:
+                if sort:
+                    yield a
+            elif not sort and x <= m:
+                for ax in ordered_partitions(x, sort=False):
+                    mi = len(ax)
+                    a[-mi:] = [i + b for i in ax]
+                    yield a
+                    a[-mi:] = [b]*mi
+            else:
+                for mi in range(1, m):
+                    for ax in ordered_partitions(x, mi, sort=True):
+                        a[-mi:] = [i + b for i in ax]
+                        yield a
+                        a[-mi:] = [b]*mi
+
+
+def binary_partitions(n):
+    """
+    Generates the binary partition of n.
+
+    A binary partition consists only of numbers that are
+    powers of two. Each step reduces a `2^{k+1}` to `2^k` and
+    `2^k`. Thus 16 is converted to 8 and 8.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import binary_partitions
+    >>> for i in binary_partitions(5):
+    ...     print(i)
+    ...
+    [4, 1]
+    [2, 2, 1]
+    [2, 1, 1, 1]
+    [1, 1, 1, 1, 1]
+
+    References
+    ==========
+
+    .. [1] TAOCP 4, section 7.2.1.5, problem 64
+
+    """
+    from math import ceil, log
+    power = int(2**(ceil(log(n, 2))))
+    acc = 0
+    partition = []
+    while power:
+        if acc + power <= n:
+            partition.append(power)
+            acc += power
+        power >>= 1
+
+    last_num = len(partition) - 1 - (n & 1)
+    while last_num >= 0:
+        yield partition
+        if partition[last_num] == 2:
+            partition[last_num] = 1
+            partition.append(1)
+            last_num -= 1
+            continue
+        partition.append(1)
+        partition[last_num] >>= 1
+        x = partition[last_num + 1] = partition[last_num]
+        last_num += 1
+        while x > 1:
+            if x <= len(partition) - last_num - 1:
+                del partition[-x + 1:]
+                last_num += 1
+                partition[last_num] = x
+            else:
+                x >>= 1
+    yield [1]*n
+
+
+def has_dups(seq):
+    """Return True if there are any duplicate elements in ``seq``.
+
+    Examples
+    ========
+
+    >>> from sympy import has_dups, Dict, Set
+    >>> has_dups((1, 2, 1))
+    True
+    >>> has_dups(range(3))
+    False
+    >>> all(has_dups(c) is False for c in (set(), Set(), dict(), Dict()))
+    True
+    """
+    from sympy.core.containers import Dict
+    from sympy.sets.sets import Set
+    if isinstance(seq, (dict, set, Dict, Set)):
+        return False
+    unique = set()
+    try:
+        return any(True for s in seq if s in unique or unique.add(s))
+    except TypeError:
+        return len(seq) != len(list(uniq(seq)))
+
+
+def has_variety(seq):
+    """Return True if there are any different elements in ``seq``.
+
+    Examples
+    ========
+
+    >>> from sympy import has_variety
+
+    >>> has_variety((1, 2, 1))
+    True
+    >>> has_variety((1, 1, 1))
+    False
+    """
+    for i, s in enumerate(seq):
+        if i == 0:
+            sentinel = s
+        else:
+            if s != sentinel:
+                return True
+    return False
+
+
+def uniq(seq, result=None):
+    """
+    Yield unique elements from ``seq`` as an iterator. The second
+    parameter ``result``  is used internally; it is not necessary
+    to pass anything for this.
+
+    Note: changing the sequence during iteration will raise a
+    RuntimeError if the size of the sequence is known; if you pass
+    an iterator and advance the iterator you will change the
+    output of this routine but there will be no warning.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import uniq
+    >>> dat = [1, 4, 1, 5, 4, 2, 1, 2]
+    >>> type(uniq(dat)) in (list, tuple)
+    False
+
+    >>> list(uniq(dat))
+    [1, 4, 5, 2]
+    >>> list(uniq(x for x in dat))
+    [1, 4, 5, 2]
+    >>> list(uniq([[1], [2, 1], [1]]))
+    [[1], [2, 1]]
+    """
+    try:
+        n = len(seq)
+    except TypeError:
+        n = None
+    def check():
+        # check that size of seq did not change during iteration;
+        # if n == None the object won't support size changing, e.g.
+        # an iterator can't be changed
+        if n is not None and len(seq) != n:
+            raise RuntimeError('sequence changed size during iteration')
+    try:
+        seen = set()
+        result = result or []
+        for i, s in enumerate(seq):
+            if not (s in seen or seen.add(s)):
+                yield s
+                check()
+    except TypeError:
+        if s not in result:
+            yield s
+            check()
+            result.append(s)
+        if hasattr(seq, '__getitem__'):
+            yield from uniq(seq[i + 1:], result)
+        else:
+            yield from uniq(seq, result)
+
+
+def generate_bell(n):
+    """Return permutations of [0, 1, ..., n - 1] such that each permutation
+    differs from the last by the exchange of a single pair of neighbors.
+    The ``n!`` permutations are returned as an iterator. In order to obtain
+    the next permutation from a random starting permutation, use the
+    ``next_trotterjohnson`` method of the Permutation class (which generates
+    the same sequence in a different manner).
+
+    Examples
+    ========
+
+    >>> from itertools import permutations
+    >>> from sympy.utilities.iterables import generate_bell
+    >>> from sympy import zeros, Matrix
+
+    This is the sort of permutation used in the ringing of physical bells,
+    and does not produce permutations in lexicographical order. Rather, the
+    permutations differ from each other by exactly one inversion, and the
+    position at which the swapping occurs varies periodically in a simple
+    fashion. Consider the first few permutations of 4 elements generated
+    by ``permutations`` and ``generate_bell``:
+
+    >>> list(permutations(range(4)))[:5]
+    [(0, 1, 2, 3), (0, 1, 3, 2), (0, 2, 1, 3), (0, 2, 3, 1), (0, 3, 1, 2)]
+    >>> list(generate_bell(4))[:5]
+    [(0, 1, 2, 3), (0, 1, 3, 2), (0, 3, 1, 2), (3, 0, 1, 2), (3, 0, 2, 1)]
+
+    Notice how the 2nd and 3rd lexicographical permutations have 3 elements
+    out of place whereas each "bell" permutation always has only two
+    elements out of place relative to the previous permutation (and so the
+    signature (+/-1) of a permutation is opposite of the signature of the
+    previous permutation).
+
+    How the position of inversion varies across the elements can be seen
+    by tracing out where the largest number appears in the permutations:
+
+    >>> m = zeros(4, 24)
+    >>> for i, p in enumerate(generate_bell(4)):
+    ...     m[:, i] = Matrix([j - 3 for j in list(p)])  # make largest zero
+    >>> m.print_nonzero('X')
+    [XXX  XXXXXX  XXXXXX  XXX]
+    [XX XX XXXX XX XXXX XX XX]
+    [X XXXX XX XXXX XX XXXX X]
+    [ XXXXXX  XXXXXX  XXXXXX ]
+
+    See Also
+    ========
+
+    sympy.combinatorics.permutations.Permutation.next_trotterjohnson
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Method_ringing
+
+    .. [2] https://stackoverflow.com/questions/4856615/recursive-permutation/4857018
+
+    .. [3] https://web.archive.org/web/20160313023044/http://programminggeeks.com/bell-algorithm-for-permutation/
+
+    .. [4] https://en.wikipedia.org/wiki/Steinhaus%E2%80%93Johnson%E2%80%93Trotter_algorithm
+
+    .. [5] Generating involutions, derangements, and relatives by ECO
+           Vincent Vajnovszki, DMTCS vol 1 issue 12, 2010
+
+    """
+    n = as_int(n)
+    if n < 1:
+        raise ValueError('n must be a positive integer')
+    if n == 1:
+        yield (0,)
+    elif n == 2:
+        yield (0, 1)
+        yield (1, 0)
+    elif n == 3:
+        yield from [(0, 1, 2), (0, 2, 1), (2, 0, 1), (2, 1, 0), (1, 2, 0), (1, 0, 2)]
+    else:
+        m = n - 1
+        op = [0] + [-1]*m
+        l = list(range(n))
+        while True:
+            yield tuple(l)
+            # find biggest element with op
+            big = None, -1  # idx, value
+            for i in range(n):
+                if op[i] and l[i] > big[1]:
+                    big = i, l[i]
+            i, _ = big
+            if i is None:
+                break  # there are no ops left
+            # swap it with neighbor in the indicated direction
+            j = i + op[i]
+            l[i], l[j] = l[j], l[i]
+            op[i], op[j] = op[j], op[i]
+            # if it landed at the end or if the neighbor in the same
+            # direction is bigger then turn off op
+            if j == 0 or j == m or l[j + op[j]] > l[j]:
+                op[j] = 0
+            # any element bigger to the left gets +1 op
+            for i in range(j):
+                if l[i] > l[j]:
+                    op[i] = 1
+            # any element bigger to the right gets -1 op
+            for i in range(j + 1, n):
+                if l[i] > l[j]:
+                    op[i] = -1
+
+
+def generate_involutions(n):
+    """
+    Generates involutions.
+
+    An involution is a permutation that when multiplied
+    by itself equals the identity permutation. In this
+    implementation the involutions are generated using
+    Fixed Points.
+
+    Alternatively, an involution can be considered as
+    a permutation that does not contain any cycles with
+    a length that is greater than two.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import generate_involutions
+    >>> list(generate_involutions(3))
+    [(0, 1, 2), (0, 2, 1), (1, 0, 2), (2, 1, 0)]
+    >>> len(list(generate_involutions(4)))
+    10
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/PermutationInvolution.html
+
+    """
+    idx = list(range(n))
+    for p in permutations(idx):
+        for i in idx:
+            if p[p[i]] != i:
+                break
+        else:
+            yield p
+
+
+def multiset_derangements(s):
+    """Generate derangements of the elements of s *in place*.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import multiset_derangements, uniq
+
+    Because the derangements of multisets (not sets) are generated
+    in place, copies of the return value must be made if a collection
+    of derangements is desired or else all values will be the same:
+
+    >>> list(uniq([i for i in multiset_derangements('1233')]))
+    [[None, None, None, None]]
+    >>> [i.copy() for i in multiset_derangements('1233')]
+    [['3', '3', '1', '2'], ['3', '3', '2', '1']]
+    >>> [''.join(i) for i in multiset_derangements('1233')]
+    ['3312', '3321']
+    """
+    from sympy.core.sorting import ordered
+    # create multiset dictionary of hashable elements or else
+    # remap elements to integers
+    try:
+        ms = multiset(s)
+    except TypeError:
+        # give each element a canonical integer value
+        key = dict(enumerate(ordered(uniq(s))))
+        h = []
+        for si in s:
+            for k in key:
+                if key[k] == si:
+                    h.append(k)
+                    break
+        for i in multiset_derangements(h):
+            yield [key[j] for j in i]
+        return
+
+    mx = max(ms.values())  # max repetition of any element
+    n = len(s)  # the number of elements
+
+    ## special cases
+
+    # 1) one element has more than half the total cardinality of s: no
+    # derangements are possible.
+    if mx*2 > n:
+        return
+
+    # 2) all elements appear once: singletons
+    if len(ms) == n:
+        yield from _set_derangements(s)
+        return
+
+    # find the first element that is repeated the most to place
+    # in the following two special cases where the selection
+    # is unambiguous: either there are two elements with multiplicity
+    # of mx or else there is only one with multiplicity mx
+    for M in ms:
+        if ms[M] == mx:
+            break
+
+    inonM = [i for i in range(n) if s[i] != M]  # location of non-M
+    iM = [i for i in range(n) if s[i] == M]  # locations of M
+    rv = [None]*n
+
+    # 3) half are the same
+    if 2*mx == n:
+        # M goes into non-M locations
+        for i in inonM:
+            rv[i] = M
+        # permutations of non-M go to M locations
+        for p in multiset_permutations([s[i] for i in inonM]):
+            for i, pi in zip(iM, p):
+                rv[i] = pi
+            yield rv
+        # clean-up (and encourages proper use of routine)
+        rv[:] = [None]*n
+        return
+
+    # 4) single repeat covers all but 1 of the non-repeats:
+    # if there is one repeat then the multiset of the values
+    # of ms would be {mx: 1, 1: n - mx}, i.e. there would
+    # be n - mx + 1 values with the condition that n - 2*mx = 1
+    if n - 2*mx == 1 and len(ms.values()) == n - mx + 1:
+        for i, i1 in enumerate(inonM):
+            ifill = inonM[:i] + inonM[i+1:]
+            for j in ifill:
+                rv[j] = M
+            for p in permutations([s[j] for j in ifill]):
+                rv[i1] = s[i1]
+                for j, pi in zip(iM, p):
+                    rv[j] = pi
+                k = i1
+                for j in iM:
+                    rv[j], rv[k] = rv[k], rv[j]
+                    yield rv
+                    k = j
+        # clean-up (and encourages proper use of routine)
+        rv[:] = [None]*n
+        return
+
+    ## general case is handled with 3 helpers:
+    #    1) `finish_derangements` will place the last two elements
+    #       which have arbitrary multiplicities, e.g. for multiset
+    #       {c: 3, a: 2, b: 2}, the last two elements are a and b
+    #    2) `iopen` will tell where a given element can be placed
+    #    3) `do` will recursively place elements into subsets of
+    #        valid locations
+
+    def finish_derangements():
+        """Place the last two elements into the partially completed
+        derangement, and yield the results.
+        """
+
+        a = take[1][0]  # penultimate element
+        a_ct = take[1][1]
+        b = take[0][0]  # last element to be placed
+        b_ct = take[0][1]
+
+        # split the indexes of the not-already-assigned elements of rv into
+        # three categories
+        forced_a = []  # positions which must have an a
+        forced_b = []  # positions which must have a b
+        open_free = []  # positions which could take either
+        for i in range(len(s)):
+            if rv[i] is None:
+                if s[i] == a:
+                    forced_b.append(i)
+                elif s[i] == b:
+                    forced_a.append(i)
+                else:
+                    open_free.append(i)
+
+        if len(forced_a) > a_ct or len(forced_b) > b_ct:
+            # No derangement possible
+            return
+
+        for i in forced_a:
+            rv[i] = a
+        for i in forced_b:
+            rv[i] = b
+        for a_place in combinations(open_free, a_ct - len(forced_a)):
+            for a_pos in a_place:
+                rv[a_pos] = a
+            for i in open_free:
+                if rv[i] is None:  # anything not in the subset is set to b
+                    rv[i] = b
+            yield rv
+            # Clean up/undo the final placements
+            for i in open_free:
+                rv[i] = None
+
+        # additional cleanup - clear forced_a, forced_b
+        for i in forced_a:
+            rv[i] = None
+        for i in forced_b:
+            rv[i] = None
+
+    def iopen(v):
+        # return indices at which element v can be placed in rv:
+        # locations which are not already occupied if that location
+        # does not already contain v in the same location of s
+        return [i for i in range(n) if rv[i] is None and s[i] != v]
+
+    def do(j):
+        if j == 1:
+            # handle the last two elements (regardless of multiplicity)
+            # with a special method
+            yield from finish_derangements()
+        else:
+            # place the mx elements of M into a subset of places
+            # into which it can be replaced
+            M, mx = take[j]
+            for i in combinations(iopen(M), mx):
+                # place M
+                for ii in i:
+                    rv[ii] = M
+                # recursively place the next element
+                yield from do(j - 1)
+                # mark positions where M was placed as once again
+                # open for placement of other elements
+                for ii in i:
+                    rv[ii] = None
+
+    # process elements in order of canonically decreasing multiplicity
+    take = sorted(ms.items(), key=lambda x:(x[1], x[0]))
+    yield from do(len(take) - 1)
+    rv[:] = [None]*n
+
+
+def random_derangement(t, choice=None, strict=True):
+    """Return a list of elements in which none are in the same positions
+    as they were originally. If an element fills more than half of the positions
+    then an error will be raised since no derangement is possible. To obtain
+    a derangement of as many items as possible--with some of the most numerous
+    remaining in their original positions--pass `strict=False`. To produce a
+    pseudorandom derangment, pass a pseudorandom selector like `choice` (see
+    below).
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import random_derangement
+    >>> t = 'SymPy: a CAS in pure Python'
+    >>> d = random_derangement(t)
+    >>> all(i != j for i, j in zip(d, t))
+    True
+
+    A predictable result can be obtained by using a pseudorandom
+    generator for the choice:
+
+    >>> from sympy.core.random import seed, choice as c
+    >>> seed(1)
+    >>> d = [''.join(random_derangement(t, c)) for i in range(5)]
+    >>> assert len(set(d)) != 1  # we got different values
+
+    By reseeding, the same sequence can be obtained:
+
+    >>> seed(1)
+    >>> d2 = [''.join(random_derangement(t, c)) for i in range(5)]
+    >>> assert d == d2
+    """
+    if choice is None:
+        import secrets
+        choice = secrets.choice
+    def shuffle(rv):
+        '''Knuth shuffle'''
+        for i in range(len(rv) - 1, 0, -1):
+            x = choice(rv[:i + 1])
+            j = rv.index(x)
+            rv[i], rv[j] = rv[j], rv[i]
+    def pick(rv, n):
+        '''shuffle rv and return the first n values
+        '''
+        shuffle(rv)
+        return rv[:n]
+    ms = multiset(t)
+    tot = len(t)
+    ms = sorted(ms.items(), key=lambda x: x[1])
+  # if there are not enough spaces for the most
+  # plentiful element to move to then some of them
+  # will have to stay in place
+    M, mx = ms[-1]
+    n = len(t)
+    xs = 2*mx - tot
+    if xs > 0:
+        if strict:
+            raise ValueError('no derangement possible')
+        opts = [i for (i, c) in enumerate(t) if c == ms[-1][0]]
+        pick(opts, xs)
+        stay = sorted(opts[:xs])
+        rv = list(t)
+        for i in reversed(stay):
+            rv.pop(i)
+        rv = random_derangement(rv, choice)
+        for i in stay:
+            rv.insert(i, ms[-1][0])
+        return ''.join(rv) if type(t) is str else rv
+  # the normal derangement calculated from here
+    if n == len(ms):
+      # approx 1/3 will succeed
+        rv = list(t)
+        while True:
+            shuffle(rv)
+            if all(i != j for i,j in zip(rv, t)):
+                break
+    else:
+      # general case
+        rv = [None]*n
+        while True:
+            j = 0
+            while j > -len(ms):  # do most numerous first
+                j -= 1
+                e, c = ms[j]
+                opts = [i for i in range(n) if rv[i] is None and t[i] != e]
+                if len(opts) < c:
+                    for i in range(n):
+                        rv[i] = None
+                    break # try again
+                pick(opts, c)
+                for i in range(c):
+                    rv[opts[i]] = e
+            else:
+                return rv
+    return rv
+
+
+def _set_derangements(s):
+    """
+    yield derangements of items in ``s`` which are assumed to contain
+    no repeated elements
+    """
+    if len(s) < 2:
+        return
+    if len(s) == 2:
+        yield [s[1], s[0]]
+        return
+    if len(s) == 3:
+        yield [s[1], s[2], s[0]]
+        yield [s[2], s[0], s[1]]
+        return
+    for p in permutations(s):
+        if not any(i == j for i, j in zip(p, s)):
+            yield list(p)
+
+
+def generate_derangements(s):
+    """
+    Return unique derangements of the elements of iterable ``s``.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import generate_derangements
+    >>> list(generate_derangements([0, 1, 2]))
+    [[1, 2, 0], [2, 0, 1]]
+    >>> list(generate_derangements([0, 1, 2, 2]))
+    [[2, 2, 0, 1], [2, 2, 1, 0]]
+    >>> list(generate_derangements([0, 1, 1]))
+    []
+
+    See Also
+    ========
+
+    sympy.functions.combinatorial.factorials.subfactorial
+
+    """
+    if not has_dups(s):
+        yield from _set_derangements(s)
+    else:
+        for p in multiset_derangements(s):
+            yield list(p)
+
+
+def necklaces(n, k, free=False):
+    """
+    A routine to generate necklaces that may (free=True) or may not
+    (free=False) be turned over to be viewed. The "necklaces" returned
+    are comprised of ``n`` integers (beads) with ``k`` different
+    values (colors). Only unique necklaces are returned.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import necklaces, bracelets
+    >>> def show(s, i):
+    ...     return ''.join(s[j] for j in i)
+
+    The "unrestricted necklace" is sometimes also referred to as a
+    "bracelet" (an object that can be turned over, a sequence that can
+    be reversed) and the term "necklace" is used to imply a sequence
+    that cannot be reversed. So ACB == ABC for a bracelet (rotate and
+    reverse) while the two are different for a necklace since rotation
+    alone cannot make the two sequences the same.
+
+    (mnemonic: Bracelets can be viewed Backwards, but Not Necklaces.)
+
+    >>> B = [show('ABC', i) for i in bracelets(3, 3)]
+    >>> N = [show('ABC', i) for i in necklaces(3, 3)]
+    >>> set(N) - set(B)
+    {'ACB'}
+
+    >>> list(necklaces(4, 2))
+    [(0, 0, 0, 0), (0, 0, 0, 1), (0, 0, 1, 1),
+     (0, 1, 0, 1), (0, 1, 1, 1), (1, 1, 1, 1)]
+
+    >>> [show('.o', i) for i in bracelets(4, 2)]
+    ['....', '...o', '..oo', '.o.o', '.ooo', 'oooo']
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/Necklace.html
+
+    .. [2] Frank Ruskey, Carla Savage, and Terry Min Yih Wang,
+        Generating necklaces, Journal of Algorithms 13 (1992), 414-430;
+        https://doi.org/10.1016/0196-6774(92)90047-G
+
+    """
+    # The FKM algorithm
+    if k == 0 and n > 0:
+        return
+    a = [0]*n
+    yield tuple(a)
+    if n == 0:
+        return
+    while True:
+        i = n - 1
+        while a[i] == k - 1:
+            i -= 1
+            if i == -1:
+                return
+        a[i] += 1
+        for j in range(n - i - 1):
+            a[j + i + 1] = a[j]
+        if n % (i + 1) == 0 and (not free or all(a <= a[j::-1] + a[-1:j:-1] for j in range(n - 1))):
+            # No need to test j = n - 1.
+            yield tuple(a)
+
+
+def bracelets(n, k):
+    """Wrapper to necklaces to return a free (unrestricted) necklace."""
+    return necklaces(n, k, free=True)
+
+
+def generate_oriented_forest(n):
+    """
+    This algorithm generates oriented forests.
+
+    An oriented graph is a directed graph having no symmetric pair of directed
+    edges. A forest is an acyclic graph, i.e., it has no cycles. A forest can
+    also be described as a disjoint union of trees, which are graphs in which
+    any two vertices are connected by exactly one simple path.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import generate_oriented_forest
+    >>> list(generate_oriented_forest(4))
+    [[0, 1, 2, 3], [0, 1, 2, 2], [0, 1, 2, 1], [0, 1, 2, 0], \
+    [0, 1, 1, 1], [0, 1, 1, 0], [0, 1, 0, 1], [0, 1, 0, 0], [0, 0, 0, 0]]
+
+    References
+    ==========
+
+    .. [1] T. Beyer and S.M. Hedetniemi: constant time generation of
+           rooted trees, SIAM J. Computing Vol. 9, No. 4, November 1980
+
+    .. [2] https://stackoverflow.com/questions/1633833/oriented-forest-taocp-algorithm-in-python
+
+    """
+    P = list(range(-1, n))
+    while True:
+        yield P[1:]
+        if P[n] > 0:
+            P[n] = P[P[n]]
+        else:
+            for p in range(n - 1, 0, -1):
+                if P[p] != 0:
+                    target = P[p] - 1
+                    for q in range(p - 1, 0, -1):
+                        if P[q] == target:
+                            break
+                    offset = p - q
+                    for i in range(p, n + 1):
+                        P[i] = P[i - offset]
+                    break
+            else:
+                break
+
+
+def minlex(seq, directed=True, key=None):
+    r"""
+    Return the rotation of the sequence in which the lexically smallest
+    elements appear first, e.g. `cba \rightarrow acb`.
+
+    The sequence returned is a tuple, unless the input sequence is a string
+    in which case a string is returned.
+
+    If ``directed`` is False then the smaller of the sequence and the
+    reversed sequence is returned, e.g. `cba \rightarrow abc`.
+
+    If ``key`` is not None then it is used to extract a comparison key from each element in iterable.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.polyhedron import minlex
+    >>> minlex((1, 2, 0))
+    (0, 1, 2)
+    >>> minlex((1, 0, 2))
+    (0, 2, 1)
+    >>> minlex((1, 0, 2), directed=False)
+    (0, 1, 2)
+
+    >>> minlex('11010011000', directed=True)
+    '00011010011'
+    >>> minlex('11010011000', directed=False)
+    '00011001011'
+
+    >>> minlex(('bb', 'aaa', 'c', 'a'))
+    ('a', 'bb', 'aaa', 'c')
+    >>> minlex(('bb', 'aaa', 'c', 'a'), key=len)
+    ('c', 'a', 'bb', 'aaa')
+
+    """
+    from sympy.functions.elementary.miscellaneous import Id
+    if key is None: key = Id
+    best = rotate_left(seq, least_rotation(seq, key=key))
+    if not directed:
+        rseq = seq[::-1]
+        rbest = rotate_left(rseq, least_rotation(rseq, key=key))
+        best = min(best, rbest, key=key)
+
+    # Convert to tuple, unless we started with a string.
+    return tuple(best) if not isinstance(seq, str) else best
+
+
+def runs(seq, op=gt):
+    """Group the sequence into lists in which successive elements
+    all compare the same with the comparison operator, ``op``:
+    op(seq[i + 1], seq[i]) is True from all elements in a run.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import runs
+    >>> from operator import ge
+    >>> runs([0, 1, 2, 2, 1, 4, 3, 2, 2])
+    [[0, 1, 2], [2], [1, 4], [3], [2], [2]]
+    >>> runs([0, 1, 2, 2, 1, 4, 3, 2, 2], op=ge)
+    [[0, 1, 2, 2], [1, 4], [3], [2, 2]]
+    """
+    cycles = []
+    seq = iter(seq)
+    try:
+        run = [next(seq)]
+    except StopIteration:
+        return []
+    while True:
+        try:
+            ei = next(seq)
+        except StopIteration:
+            break
+        if op(ei, run[-1]):
+            run.append(ei)
+            continue
+        else:
+            cycles.append(run)
+            run = [ei]
+    if run:
+        cycles.append(run)
+    return cycles
+
+
+def sequence_partitions(l, n, /):
+    r"""Returns the partition of sequence $l$ into $n$ bins
+
+    Explanation
+    ===========
+
+    Given the sequence $l_1 \cdots l_m \in V^+$ where
+    $V^+$ is the Kleene plus of $V$
+
+    The set of $n$ partitions of $l$ is defined as:
+
+    .. math::
+        \{(s_1, \cdots, s_n) | s_1 \in V^+, \cdots, s_n \in V^+,
+        s_1 \cdots s_n = l_1 \cdots l_m\}
+
+    Parameters
+    ==========
+
+    l : Sequence[T]
+        A nonempty sequence of any Python objects
+
+    n : int
+        A positive integer
+
+    Yields
+    ======
+
+    out : list[Sequence[T]]
+        A list of sequences with concatenation equals $l$.
+        This should conform with the type of $l$.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import sequence_partitions
+    >>> for out in sequence_partitions([1, 2, 3, 4], 2):
+    ...     print(out)
+    [[1], [2, 3, 4]]
+    [[1, 2], [3, 4]]
+    [[1, 2, 3], [4]]
+
+    Notes
+    =====
+
+    This is modified version of EnricoGiampieri's partition generator
+    from https://stackoverflow.com/questions/13131491/partition-n-items-into-k-bins-in-python-lazily
+
+    See Also
+    ========
+
+    sequence_partitions_empty
+    """
+    # Asserting l is nonempty is done only for sanity check
+    if n == 1 and l:
+        yield [l]
+        return
+    for i in range(1, len(l)):
+        for part in sequence_partitions(l[i:], n - 1):
+            yield [l[:i]] + part
+
+
+def sequence_partitions_empty(l, n, /):
+    r"""Returns the partition of sequence $l$ into $n$ bins with
+    empty sequence
+
+    Explanation
+    ===========
+
+    Given the sequence $l_1 \cdots l_m \in V^*$ where
+    $V^*$ is the Kleene star of $V$
+
+    The set of $n$ partitions of $l$ is defined as:
+
+    .. math::
+        \{(s_1, \cdots, s_n) | s_1 \in V^*, \cdots, s_n \in V^*,
+        s_1 \cdots s_n = l_1 \cdots l_m\}
+
+    There are more combinations than :func:`sequence_partitions` because
+    empty sequence can fill everywhere, so we try to provide different
+    utility for this.
+
+    Parameters
+    ==========
+
+    l : Sequence[T]
+        A sequence of any Python objects (can be possibly empty)
+
+    n : int
+        A positive integer
+
+    Yields
+    ======
+
+    out : list[Sequence[T]]
+        A list of sequences with concatenation equals $l$.
+        This should conform with the type of $l$.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import sequence_partitions_empty
+    >>> for out in sequence_partitions_empty([1, 2, 3, 4], 2):
+    ...     print(out)
+    [[], [1, 2, 3, 4]]
+    [[1], [2, 3, 4]]
+    [[1, 2], [3, 4]]
+    [[1, 2, 3], [4]]
+    [[1, 2, 3, 4], []]
+
+    See Also
+    ========
+
+    sequence_partitions
+    """
+    if n < 1:
+        return
+    if n == 1:
+        yield [l]
+        return
+    for i in range(0, len(l) + 1):
+        for part in sequence_partitions_empty(l[i:], n - 1):
+            yield [l[:i]] + part
+
+
+def kbins(l, k, ordered=None):
+    """
+    Return sequence ``l`` partitioned into ``k`` bins.
+
+    Examples
+    ========
+
+    The default is to give the items in the same order, but grouped
+    into k partitions without any reordering:
+
+    >>> from sympy.utilities.iterables import kbins
+    >>> for p in kbins(list(range(5)), 2):
+    ...     print(p)
+    ...
+    [[0], [1, 2, 3, 4]]
+    [[0, 1], [2, 3, 4]]
+    [[0, 1, 2], [3, 4]]
+    [[0, 1, 2, 3], [4]]
+
+    The ``ordered`` flag is either None (to give the simple partition
+    of the elements) or is a 2 digit integer indicating whether the order of
+    the bins and the order of the items in the bins matters. Given::
+
+        A = [[0], [1, 2]]
+        B = [[1, 2], [0]]
+        C = [[2, 1], [0]]
+        D = [[0], [2, 1]]
+
+    the following values for ``ordered`` have the shown meanings::
+
+        00 means A == B == C == D
+        01 means A == B
+        10 means A == D
+        11 means A == A
+
+    >>> for ordered_flag in [None, 0, 1, 10, 11]:
+    ...     print('ordered = %s' % ordered_flag)
+    ...     for p in kbins(list(range(3)), 2, ordered=ordered_flag):
+    ...         print('     %s' % p)
+    ...
+    ordered = None
+         [[0], [1, 2]]
+         [[0, 1], [2]]
+    ordered = 0
+         [[0, 1], [2]]
+         [[0, 2], [1]]
+         [[0], [1, 2]]
+    ordered = 1
+         [[0], [1, 2]]
+         [[0], [2, 1]]
+         [[1], [0, 2]]
+         [[1], [2, 0]]
+         [[2], [0, 1]]
+         [[2], [1, 0]]
+    ordered = 10
+         [[0, 1], [2]]
+         [[2], [0, 1]]
+         [[0, 2], [1]]
+         [[1], [0, 2]]
+         [[0], [1, 2]]
+         [[1, 2], [0]]
+    ordered = 11
+         [[0], [1, 2]]
+         [[0, 1], [2]]
+         [[0], [2, 1]]
+         [[0, 2], [1]]
+         [[1], [0, 2]]
+         [[1, 0], [2]]
+         [[1], [2, 0]]
+         [[1, 2], [0]]
+         [[2], [0, 1]]
+         [[2, 0], [1]]
+         [[2], [1, 0]]
+         [[2, 1], [0]]
+
+    See Also
+    ========
+
+    partitions, multiset_partitions
+
+    """
+    if ordered is None:
+        yield from sequence_partitions(l, k)
+    elif ordered == 11:
+        for pl in multiset_permutations(l):
+            pl = list(pl)
+            yield from sequence_partitions(pl, k)
+    elif ordered == 00:
+        yield from multiset_partitions(l, k)
+    elif ordered == 10:
+        for p in multiset_partitions(l, k):
+            for perm in permutations(p):
+                yield list(perm)
+    elif ordered == 1:
+        for kgot, p in partitions(len(l), k, size=True):
+            if kgot != k:
+                continue
+            for li in multiset_permutations(l):
+                rv = []
+                i = j = 0
+                li = list(li)
+                for size, multiplicity in sorted(p.items()):
+                    for m in range(multiplicity):
+                        j = i + size
+                        rv.append(li[i: j])
+                        i = j
+                yield rv
+    else:
+        raise ValueError(
+            'ordered must be one of 00, 01, 10 or 11, not %s' % ordered)
+
+
+def permute_signs(t):
+    """Return iterator in which the signs of non-zero elements
+    of t are permuted.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import permute_signs
+    >>> list(permute_signs((0, 1, 2)))
+    [(0, 1, 2), (0, -1, 2), (0, 1, -2), (0, -1, -2)]
+    """
+    for signs in product(*[(1, -1)]*(len(t) - t.count(0))):
+        signs = list(signs)
+        yield type(t)([i*signs.pop() if i else i for i in t])
+
+
+def signed_permutations(t):
+    """Return iterator in which the signs of non-zero elements
+    of t and the order of the elements are permuted.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import signed_permutations
+    >>> list(signed_permutations((0, 1, 2)))
+    [(0, 1, 2), (0, -1, 2), (0, 1, -2), (0, -1, -2), (0, 2, 1),
+    (0, -2, 1), (0, 2, -1), (0, -2, -1), (1, 0, 2), (-1, 0, 2),
+    (1, 0, -2), (-1, 0, -2), (1, 2, 0), (-1, 2, 0), (1, -2, 0),
+    (-1, -2, 0), (2, 0, 1), (-2, 0, 1), (2, 0, -1), (-2, 0, -1),
+    (2, 1, 0), (-2, 1, 0), (2, -1, 0), (-2, -1, 0)]
+    """
+    return (type(t)(i) for j in permutations(t)
+        for i in permute_signs(j))
+
+
+def rotations(s, dir=1):
+    """Return a generator giving the items in s as list where
+    each subsequent list has the items rotated to the left (default)
+    or right (``dir=-1``) relative to the previous list.
+
+    Examples
+    ========
+
+    >>> from sympy import rotations
+    >>> list(rotations([1,2,3]))
+    [[1, 2, 3], [2, 3, 1], [3, 1, 2]]
+    >>> list(rotations([1,2,3], -1))
+    [[1, 2, 3], [3, 1, 2], [2, 3, 1]]
+    """
+    seq = list(s)
+    for i in range(len(seq)):
+        yield seq
+        seq = rotate_left(seq, dir)
+
+
+def roundrobin(*iterables):
+    """roundrobin recipe taken from itertools documentation:
+    https://docs.python.org/3/library/itertools.html#itertools-recipes
+
+    roundrobin('ABC', 'D', 'EF') --> A D E B F C
+
+    Recipe credited to George Sakkis
+    """
+    nexts = cycle(iter(it).__next__ for it in iterables)
+
+    pending = len(iterables)
+    while pending:
+        try:
+            for nxt in nexts:
+                yield nxt()
+        except StopIteration:
+            pending -= 1
+            nexts = cycle(islice(nexts, pending))
+
+
+
+class NotIterable:
+    """
+    Use this as mixin when creating a class which is not supposed to
+    return true when iterable() is called on its instances because
+    calling list() on the instance, for example, would result in
+    an infinite loop.
+    """
+    pass
+
+
+def iterable(i, exclude=(str, dict, NotIterable)):
+    """
+    Return a boolean indicating whether ``i`` is SymPy iterable.
+    True also indicates that the iterator is finite, e.g. you can
+    call list(...) on the instance.
+
+    When SymPy is working with iterables, it is almost always assuming
+    that the iterable is not a string or a mapping, so those are excluded
+    by default. If you want a pure Python definition, make exclude=None. To
+    exclude multiple items, pass them as a tuple.
+
+    You can also set the _iterable attribute to True or False on your class,
+    which will override the checks here, including the exclude test.
+
+    As a rule of thumb, some SymPy functions use this to check if they should
+    recursively map over an object. If an object is technically iterable in
+    the Python sense but does not desire this behavior (e.g., because its
+    iteration is not finite, or because iteration might induce an unwanted
+    computation), it should disable it by setting the _iterable attribute to False.
+
+    See also: is_sequence
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import iterable
+    >>> from sympy import Tuple
+    >>> things = [[1], (1,), set([1]), Tuple(1), (j for j in [1, 2]), {1:2}, '1', 1]
+    >>> for i in things:
+    ...     print('%s %s' % (iterable(i), type(i)))
+    True <... 'list'>
+    True <... 'tuple'>
+    True <... 'set'>
+    True <class 'sympy.core.containers.Tuple'>
+    True <... 'generator'>
+    False <... 'dict'>
+    False <... 'str'>
+    False <... 'int'>
+
+    >>> iterable({}, exclude=None)
+    True
+    >>> iterable({}, exclude=str)
+    True
+    >>> iterable("no", exclude=str)
+    False
+
+    """
+    if hasattr(i, '_iterable'):
+        return i._iterable
+    try:
+        iter(i)
+    except TypeError:
+        return False
+    if exclude:
+        return not isinstance(i, exclude)
+    return True
+
+
+def is_sequence(i, include=None):
+    """
+    Return a boolean indicating whether ``i`` is a sequence in the SymPy
+    sense. If anything that fails the test below should be included as
+    being a sequence for your application, set 'include' to that object's
+    type; multiple types should be passed as a tuple of types.
+
+    Note: although generators can generate a sequence, they often need special
+    handling to make sure their elements are captured before the generator is
+    exhausted, so these are not included by default in the definition of a
+    sequence.
+
+    See also: iterable
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import is_sequence
+    >>> from types import GeneratorType
+    >>> is_sequence([])
+    True
+    >>> is_sequence(set())
+    False
+    >>> is_sequence('abc')
+    False
+    >>> is_sequence('abc', include=str)
+    True
+    >>> generator = (c for c in 'abc')
+    >>> is_sequence(generator)
+    False
+    >>> is_sequence(generator, include=(str, GeneratorType))
+    True
+
+    """
+    return (hasattr(i, '__getitem__') and
+            iterable(i) or
+            bool(include) and
+            isinstance(i, include))
+
+
+@deprecated(
+    """
+    Using postorder_traversal from the sympy.utilities.iterables submodule is
+    deprecated.
+
+    Instead, use postorder_traversal from the top-level sympy namespace, like
+
+        sympy.postorder_traversal
+    """,
+    deprecated_since_version="1.10",
+    active_deprecations_target="deprecated-traversal-functions-moved")
+def postorder_traversal(node, keys=None):
+    from sympy.core.traversal import postorder_traversal as _postorder_traversal
+    return _postorder_traversal(node, keys=keys)
+
+
+@deprecated(
+    """
+    Using interactive_traversal from the sympy.utilities.iterables submodule
+    is deprecated.
+
+    Instead, use interactive_traversal from the top-level sympy namespace,
+    like
+
+        sympy.interactive_traversal
+    """,
+    deprecated_since_version="1.10",
+    active_deprecations_target="deprecated-traversal-functions-moved")
+def interactive_traversal(expr):
+    from sympy.interactive.traversal import interactive_traversal as _interactive_traversal
+    return _interactive_traversal(expr)
+
+
+@deprecated(
+    """
+    Importing default_sort_key from sympy.utilities.iterables is deprecated.
+    Use from sympy import default_sort_key instead.
+    """,
+    deprecated_since_version="1.10",
+active_deprecations_target="deprecated-sympy-core-compatibility",
+)
+def default_sort_key(*args, **kwargs):
+    from sympy import default_sort_key as _default_sort_key
+    return _default_sort_key(*args, **kwargs)
+
+
+@deprecated(
+    """
+    Importing default_sort_key from sympy.utilities.iterables is deprecated.
+    Use from sympy import default_sort_key instead.
+    """,
+    deprecated_since_version="1.10",
+active_deprecations_target="deprecated-sympy-core-compatibility",
+)
+def ordered(*args, **kwargs):
+    from sympy import ordered as _ordered
+    return _ordered(*args, **kwargs)

venv/lib/python3.10/site-packages/sympy/utilities/lambdify.py

@@ -0,0 +1,1526 @@
+"""
+This module provides convenient functions to transform SymPy expressions to
+lambda functions which can be used to calculate numerical values very fast.
+"""
+
+from __future__ import annotations
+from typing import Any
+
+import builtins
+import inspect
+import keyword
+import textwrap
+import linecache
+
+# Required despite static analysis claiming it is not used
+from sympy.external import import_module # noqa:F401
+from sympy.utilities.exceptions import sympy_deprecation_warning
+from sympy.utilities.decorator import doctest_depends_on
+from sympy.utilities.iterables import (is_sequence, iterable,
+    NotIterable, flatten)
+from sympy.utilities.misc import filldedent
+
+__doctest_requires__ = {('lambdify',): ['numpy', 'tensorflow']}
+
+# Default namespaces, letting us define translations that can't be defined
+# by simple variable maps, like I => 1j
+MATH_DEFAULT: dict[str, Any] = {}
+MPMATH_DEFAULT: dict[str, Any] = {}
+NUMPY_DEFAULT: dict[str, Any] = {"I": 1j}
+SCIPY_DEFAULT: dict[str, Any] = {"I": 1j}
+CUPY_DEFAULT: dict[str, Any] = {"I": 1j}
+JAX_DEFAULT: dict[str, Any] = {"I": 1j}
+TENSORFLOW_DEFAULT: dict[str, Any] = {}
+SYMPY_DEFAULT: dict[str, Any] = {}
+NUMEXPR_DEFAULT: dict[str, Any] = {}
+
+# These are the namespaces the lambda functions will use.
+# These are separate from the names above because they are modified
+# throughout this file, whereas the defaults should remain unmodified.
+
+MATH = MATH_DEFAULT.copy()
+MPMATH = MPMATH_DEFAULT.copy()
+NUMPY = NUMPY_DEFAULT.copy()
+SCIPY = SCIPY_DEFAULT.copy()
+CUPY = CUPY_DEFAULT.copy()
+JAX = JAX_DEFAULT.copy()
+TENSORFLOW = TENSORFLOW_DEFAULT.copy()
+SYMPY = SYMPY_DEFAULT.copy()
+NUMEXPR = NUMEXPR_DEFAULT.copy()
+
+
+# Mappings between SymPy and other modules function names.
+MATH_TRANSLATIONS = {
+    "ceiling": "ceil",
+    "E": "e",
+    "ln": "log",
+}
+
+# NOTE: This dictionary is reused in Function._eval_evalf to allow subclasses
+# of Function to automatically evalf.
+MPMATH_TRANSLATIONS = {
+    "Abs": "fabs",
+    "elliptic_k": "ellipk",
+    "elliptic_f": "ellipf",
+    "elliptic_e": "ellipe",
+    "elliptic_pi": "ellippi",
+    "ceiling": "ceil",
+    "chebyshevt": "chebyt",
+    "chebyshevu": "chebyu",
+    "E": "e",
+    "I": "j",
+    "ln": "log",
+    #"lowergamma":"lower_gamma",
+    "oo": "inf",
+    #"uppergamma":"upper_gamma",
+    "LambertW": "lambertw",
+    "MutableDenseMatrix": "matrix",
+    "ImmutableDenseMatrix": "matrix",
+    "conjugate": "conj",
+    "dirichlet_eta": "altzeta",
+    "Ei": "ei",
+    "Shi": "shi",
+    "Chi": "chi",
+    "Si": "si",
+    "Ci": "ci",
+    "RisingFactorial": "rf",
+    "FallingFactorial": "ff",
+    "betainc_regularized": "betainc",
+}
+
+NUMPY_TRANSLATIONS: dict[str, str] = {
+    "Heaviside": "heaviside",
+}
+SCIPY_TRANSLATIONS: dict[str, str] = {}
+CUPY_TRANSLATIONS: dict[str, str] = {}
+JAX_TRANSLATIONS: dict[str, str] = {}
+
+TENSORFLOW_TRANSLATIONS: dict[str, str] = {}
+
+NUMEXPR_TRANSLATIONS: dict[str, str] = {}
+
+# Available modules:
+MODULES = {
+    "math": (MATH, MATH_DEFAULT, MATH_TRANSLATIONS, ("from math import *",)),
+    "mpmath": (MPMATH, MPMATH_DEFAULT, MPMATH_TRANSLATIONS, ("from mpmath import *",)),
+    "numpy": (NUMPY, NUMPY_DEFAULT, NUMPY_TRANSLATIONS, ("import numpy; from numpy import *; from numpy.linalg import *",)),
+    "scipy": (SCIPY, SCIPY_DEFAULT, SCIPY_TRANSLATIONS, ("import scipy; import numpy; from scipy.special import *",)),
+    "cupy": (CUPY, CUPY_DEFAULT, CUPY_TRANSLATIONS, ("import cupy",)),
+    "jax": (JAX, JAX_DEFAULT, JAX_TRANSLATIONS, ("import jax",)),
+    "tensorflow": (TENSORFLOW, TENSORFLOW_DEFAULT, TENSORFLOW_TRANSLATIONS, ("import tensorflow",)),
+    "sympy": (SYMPY, SYMPY_DEFAULT, {}, (
+        "from sympy.functions import *",
+        "from sympy.matrices import *",
+        "from sympy import Integral, pi, oo, nan, zoo, E, I",)),
+    "numexpr" : (NUMEXPR, NUMEXPR_DEFAULT, NUMEXPR_TRANSLATIONS,
+                 ("import_module('numexpr')", )),
+}
+
+
+def _import(module, reload=False):
+    """
+    Creates a global translation dictionary for module.
+
+    The argument module has to be one of the following strings: "math",
+    "mpmath", "numpy", "sympy", "tensorflow", "jax".
+    These dictionaries map names of Python functions to their equivalent in
+    other modules.
+    """
+    try:
+        namespace, namespace_default, translations, import_commands = MODULES[
+            module]
+    except KeyError:
+        raise NameError(
+            "'%s' module cannot be used for lambdification" % module)
+
+    # Clear namespace or exit
+    if namespace != namespace_default:
+        # The namespace was already generated, don't do it again if not forced.
+        if reload:
+            namespace.clear()
+            namespace.update(namespace_default)
+        else:
+            return
+
+    for import_command in import_commands:
+        if import_command.startswith('import_module'):
+            module = eval(import_command)
+
+            if module is not None:
+                namespace.update(module.__dict__)
+                continue
+        else:
+            try:
+                exec(import_command, {}, namespace)
+                continue
+            except ImportError:
+                pass
+
+        raise ImportError(
+            "Cannot import '%s' with '%s' command" % (module, import_command))
+
+    # Add translated names to namespace
+    for sympyname, translation in translations.items():
+        namespace[sympyname] = namespace[translation]
+
+    # For computing the modulus of a SymPy expression we use the builtin abs
+    # function, instead of the previously used fabs function for all
+    # translation modules. This is because the fabs function in the math
+    # module does not accept complex valued arguments. (see issue 9474). The
+    # only exception, where we don't use the builtin abs function is the
+    # mpmath translation module, because mpmath.fabs returns mpf objects in
+    # contrast to abs().
+    if 'Abs' not in namespace:
+        namespace['Abs'] = abs
+
+# Used for dynamically generated filenames that are inserted into the
+# linecache.
+_lambdify_generated_counter = 1
+
+
+@doctest_depends_on(modules=('numpy', 'scipy', 'tensorflow',), python_version=(3,))
+def lambdify(args, expr, modules=None, printer=None, use_imps=True,
+             dummify=False, cse=False, docstring_limit=1000):
+    """Convert a SymPy expression into a function that allows for fast
+    numeric evaluation.
+
+    .. warning::
+       This function uses ``exec``, and thus should not be used on
+       unsanitized input.
+
+    .. deprecated:: 1.7
+       Passing a set for the *args* parameter is deprecated as sets are
+       unordered. Use an ordered iterable such as a list or tuple.
+
+    Explanation
+    ===========
+
+    For example, to convert the SymPy expression ``sin(x) + cos(x)`` to an
+    equivalent NumPy function that numerically evaluates it:
+
+    >>> from sympy import sin, cos, symbols, lambdify
+    >>> import numpy as np
+    >>> x = symbols('x')
+    >>> expr = sin(x) + cos(x)
+    >>> expr
+    sin(x) + cos(x)
+    >>> f = lambdify(x, expr, 'numpy')
+    >>> a = np.array([1, 2])
+    >>> f(a)
+    [1.38177329 0.49315059]
+
+    The primary purpose of this function is to provide a bridge from SymPy
+    expressions to numerical libraries such as NumPy, SciPy, NumExpr, mpmath,
+    and tensorflow. In general, SymPy functions do not work with objects from
+    other libraries, such as NumPy arrays, and functions from numeric
+    libraries like NumPy or mpmath do not work on SymPy expressions.
+    ``lambdify`` bridges the two by converting a SymPy expression to an
+    equivalent numeric function.
+
+    The basic workflow with ``lambdify`` is to first create a SymPy expression
+    representing whatever mathematical function you wish to evaluate. This
+    should be done using only SymPy functions and expressions. Then, use
+    ``lambdify`` to convert this to an equivalent function for numerical
+    evaluation. For instance, above we created ``expr`` using the SymPy symbol
+    ``x`` and SymPy functions ``sin`` and ``cos``, then converted it to an
+    equivalent NumPy function ``f``, and called it on a NumPy array ``a``.
+
+    Parameters
+    ==========
+
+    args : List[Symbol]
+        A variable or a list of variables whose nesting represents the
+        nesting of the arguments that will be passed to the function.
+
+        Variables can be symbols, undefined functions, or matrix symbols.
+
+        >>> from sympy import Eq
+        >>> from sympy.abc import x, y, z
+
+        The list of variables should match the structure of how the
+        arguments will be passed to the function. Simply enclose the
+        parameters as they will be passed in a list.
+
+        To call a function like ``f(x)`` then ``[x]``
+        should be the first argument to ``lambdify``; for this
+        case a single ``x`` can also be used:
+
+        >>> f = lambdify(x, x + 1)
+        >>> f(1)
+        2
+        >>> f = lambdify([x], x + 1)
+        >>> f(1)
+        2
+
+        To call a function like ``f(x, y)`` then ``[x, y]`` will
+        be the first argument of the ``lambdify``:
+
+        >>> f = lambdify([x, y], x + y)
+        >>> f(1, 1)
+        2
+
+        To call a function with a single 3-element tuple like
+        ``f((x, y, z))`` then ``[(x, y, z)]`` will be the first
+        argument of the ``lambdify``:
+
+        >>> f = lambdify([(x, y, z)], Eq(z**2, x**2 + y**2))
+        >>> f((3, 4, 5))
+        True
+
+        If two args will be passed and the first is a scalar but
+        the second is a tuple with two arguments then the items
+        in the list should match that structure:
+
+        >>> f = lambdify([x, (y, z)], x + y + z)
+        >>> f(1, (2, 3))
+        6
+
+    expr : Expr
+        An expression, list of expressions, or matrix to be evaluated.
+
+        Lists may be nested.
+        If the expression is a list, the output will also be a list.
+
+        >>> f = lambdify(x, [x, [x + 1, x + 2]])
+        >>> f(1)
+        [1, [2, 3]]
+
+        If it is a matrix, an array will be returned (for the NumPy module).
+
+        >>> from sympy import Matrix
+        >>> f = lambdify(x, Matrix([x, x + 1]))
+        >>> f(1)
+        [[1]
+        [2]]
+
+        Note that the argument order here (variables then expression) is used
+        to emulate the Python ``lambda`` keyword. ``lambdify(x, expr)`` works
+        (roughly) like ``lambda x: expr``
+        (see :ref:`lambdify-how-it-works` below).
+
+    modules : str, optional
+        Specifies the numeric library to use.
+
+        If not specified, *modules* defaults to:
+
+        - ``["scipy", "numpy"]`` if SciPy is installed
+        - ``["numpy"]`` if only NumPy is installed
+        - ``["math", "mpmath", "sympy"]`` if neither is installed.
+
+        That is, SymPy functions are replaced as far as possible by
+        either ``scipy`` or ``numpy`` functions if available, and Python's
+        standard library ``math``, or ``mpmath`` functions otherwise.
+
+        *modules* can be one of the following types:
+
+        - The strings ``"math"``, ``"mpmath"``, ``"numpy"``, ``"numexpr"``,
+          ``"scipy"``, ``"sympy"``, or ``"tensorflow"`` or ``"jax"``. This uses the
+          corresponding printer and namespace mapping for that module.
+        - A module (e.g., ``math``). This uses the global namespace of the
+          module. If the module is one of the above known modules, it will
+          also use the corresponding printer and namespace mapping
+          (i.e., ``modules=numpy`` is equivalent to ``modules="numpy"``).
+        - A dictionary that maps names of SymPy functions to arbitrary
+          functions
+          (e.g., ``{'sin': custom_sin}``).
+        - A list that contains a mix of the arguments above, with higher
+          priority given to entries appearing first
+          (e.g., to use the NumPy module but override the ``sin`` function
+          with a custom version, you can use
+          ``[{'sin': custom_sin}, 'numpy']``).
+
+    dummify : bool, optional
+        Whether or not the variables in the provided expression that are not
+        valid Python identifiers are substituted with dummy symbols.
+
+        This allows for undefined functions like ``Function('f')(t)`` to be
+        supplied as arguments. By default, the variables are only dummified
+        if they are not valid Python identifiers.
+
+        Set ``dummify=True`` to replace all arguments with dummy symbols
+        (if ``args`` is not a string) - for example, to ensure that the
+        arguments do not redefine any built-in names.
+
+    cse : bool, or callable, optional
+        Large expressions can be computed more efficiently when
+        common subexpressions are identified and precomputed before
+        being used multiple time. Finding the subexpressions will make
+        creation of the 'lambdify' function slower, however.
+
+        When ``True``, ``sympy.simplify.cse`` is used, otherwise (the default)
+        the user may pass a function matching the ``cse`` signature.
+
+    docstring_limit : int or None
+        When lambdifying large expressions, a significant proportion of the time
+        spent inside ``lambdify`` is spent producing a string representation of
+        the expression for use in the automatically generated docstring of the
+        returned function. For expressions containing hundreds or more nodes the
+        resulting docstring often becomes so long and dense that it is difficult
+        to read. To reduce the runtime of lambdify, the rendering of the full
+        expression inside the docstring can be disabled.
+
+        When ``None``, the full expression is rendered in the docstring. When
+        ``0`` or a negative ``int``, an ellipsis is rendering in the docstring
+        instead of the expression. When a strictly positive ``int``, if the
+        number of nodes in the expression exceeds ``docstring_limit`` an
+        ellipsis is rendered in the docstring, otherwise a string representation
+        of the expression is rendered as normal. The default is ``1000``.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.lambdify import implemented_function
+    >>> from sympy import sqrt, sin, Matrix
+    >>> from sympy import Function
+    >>> from sympy.abc import w, x, y, z
+
+    >>> f = lambdify(x, x**2)
+    >>> f(2)
+    4
+    >>> f = lambdify((x, y, z), [z, y, x])
+    >>> f(1,2,3)
+    [3, 2, 1]
+    >>> f = lambdify(x, sqrt(x))
+    >>> f(4)
+    2.0
+    >>> f = lambdify((x, y), sin(x*y)**2)
+    >>> f(0, 5)
+    0.0
+    >>> row = lambdify((x, y), Matrix((x, x + y)).T, modules='sympy')
+    >>> row(1, 2)
+    Matrix([[1, 3]])
+
+    ``lambdify`` can be used to translate SymPy expressions into mpmath
+    functions. This may be preferable to using ``evalf`` (which uses mpmath on
+    the backend) in some cases.
+
+    >>> f = lambdify(x, sin(x), 'mpmath')
+    >>> f(1)
+    0.8414709848078965
+
+    Tuple arguments are handled and the lambdified function should
+    be called with the same type of arguments as were used to create
+    the function:
+
+    >>> f = lambdify((x, (y, z)), x + y)
+    >>> f(1, (2, 4))
+    3
+
+    The ``flatten`` function can be used to always work with flattened
+    arguments:
+
+    >>> from sympy.utilities.iterables import flatten
+    >>> args = w, (x, (y, z))
+    >>> vals = 1, (2, (3, 4))
+    >>> f = lambdify(flatten(args), w + x + y + z)
+    >>> f(*flatten(vals))
+    10
+
+    Functions present in ``expr`` can also carry their own numerical
+    implementations, in a callable attached to the ``_imp_`` attribute. This
+    can be used with undefined functions using the ``implemented_function``
+    factory:
+
+    >>> f = implemented_function(Function('f'), lambda x: x+1)
+    >>> func = lambdify(x, f(x))
+    >>> func(4)
+    5
+
+    ``lambdify`` always prefers ``_imp_`` implementations to implementations
+    in other namespaces, unless the ``use_imps`` input parameter is False.
+
+    Usage with Tensorflow:
+
+    >>> import tensorflow as tf
+    >>> from sympy import Max, sin, lambdify
+    >>> from sympy.abc import x
+
+    >>> f = Max(x, sin(x))
+    >>> func = lambdify(x, f, 'tensorflow')
+
+    After tensorflow v2, eager execution is enabled by default.
+    If you want to get the compatible result across tensorflow v1 and v2
+    as same as this tutorial, run this line.
+
+    >>> tf.compat.v1.enable_eager_execution()
+
+    If you have eager execution enabled, you can get the result out
+    immediately as you can use numpy.
+
+    If you pass tensorflow objects, you may get an ``EagerTensor``
+    object instead of value.
+
+    >>> result = func(tf.constant(1.0))
+    >>> print(result)
+    tf.Tensor(1.0, shape=(), dtype=float32)
+    >>> print(result.__class__)
+    <class 'tensorflow.python.framework.ops.EagerTensor'>
+
+    You can use ``.numpy()`` to get the numpy value of the tensor.
+
+    >>> result.numpy()
+    1.0
+
+    >>> var = tf.Variable(2.0)
+    >>> result = func(var) # also works for tf.Variable and tf.Placeholder
+    >>> result.numpy()
+    2.0
+
+    And it works with any shape array.
+
+    >>> tensor = tf.constant([[1.0, 2.0], [3.0, 4.0]])
+    >>> result = func(tensor)
+    >>> result.numpy()
+    [[1. 2.]
+     [3. 4.]]
+
+    Notes
+    =====
+
+    - For functions involving large array calculations, numexpr can provide a
+      significant speedup over numpy. Please note that the available functions
+      for numexpr are more limited than numpy but can be expanded with
+      ``implemented_function`` and user defined subclasses of Function. If
+      specified, numexpr may be the only option in modules. The official list
+      of numexpr functions can be found at:
+      https://numexpr.readthedocs.io/projects/NumExpr3/en/latest/user_guide.html#supported-functions
+
+    - In the above examples, the generated functions can accept scalar
+      values or numpy arrays as arguments.  However, in some cases
+      the generated function relies on the input being a numpy array:
+
+      >>> import numpy
+      >>> from sympy import Piecewise
+      >>> from sympy.testing.pytest import ignore_warnings
+      >>> f = lambdify(x, Piecewise((x, x <= 1), (1/x, x > 1)), "numpy")
+
+      >>> with ignore_warnings(RuntimeWarning):
+      ...     f(numpy.array([-1, 0, 1, 2]))
+      [-1.   0.   1.   0.5]
+
+      >>> f(0)
+      Traceback (most recent call last):
+          ...
+      ZeroDivisionError: division by zero
+
+      In such cases, the input should be wrapped in a numpy array:
+
+      >>> with ignore_warnings(RuntimeWarning):
+      ...     float(f(numpy.array([0])))
+      0.0
+
+      Or if numpy functionality is not required another module can be used:
+
+      >>> f = lambdify(x, Piecewise((x, x <= 1), (1/x, x > 1)), "math")
+      >>> f(0)
+      0
+
+    .. _lambdify-how-it-works:
+
+    How it works
+    ============
+
+    When using this function, it helps a great deal to have an idea of what it
+    is doing. At its core, lambdify is nothing more than a namespace
+    translation, on top of a special printer that makes some corner cases work
+    properly.
+
+    To understand lambdify, first we must properly understand how Python
+    namespaces work. Say we had two files. One called ``sin_cos_sympy.py``,
+    with
+
+    .. code:: python
+
+        # sin_cos_sympy.py
+
+        from sympy.functions.elementary.trigonometric import (cos, sin)
+
+        def sin_cos(x):
+            return sin(x) + cos(x)
+
+
+    and one called ``sin_cos_numpy.py`` with
+
+    .. code:: python
+
+        # sin_cos_numpy.py
+
+        from numpy import sin, cos
+
+        def sin_cos(x):
+            return sin(x) + cos(x)
+
+    The two files define an identical function ``sin_cos``. However, in the
+    first file, ``sin`` and ``cos`` are defined as the SymPy ``sin`` and
+    ``cos``. In the second, they are defined as the NumPy versions.
+
+    If we were to import the first file and use the ``sin_cos`` function, we
+    would get something like
+
+    >>> from sin_cos_sympy import sin_cos # doctest: +SKIP
+    >>> sin_cos(1) # doctest: +SKIP
+    cos(1) + sin(1)
+
+    On the other hand, if we imported ``sin_cos`` from the second file, we
+    would get
+
+    >>> from sin_cos_numpy import sin_cos # doctest: +SKIP
+    >>> sin_cos(1) # doctest: +SKIP
+    1.38177329068
+
+    In the first case we got a symbolic output, because it used the symbolic
+    ``sin`` and ``cos`` functions from SymPy. In the second, we got a numeric
+    result, because ``sin_cos`` used the numeric ``sin`` and ``cos`` functions
+    from NumPy. But notice that the versions of ``sin`` and ``cos`` that were
+    used was not inherent to the ``sin_cos`` function definition. Both
+    ``sin_cos`` definitions are exactly the same. Rather, it was based on the
+    names defined at the module where the ``sin_cos`` function was defined.
+
+    The key point here is that when function in Python references a name that
+    is not defined in the function, that name is looked up in the "global"
+    namespace of the module where that function is defined.
+
+    Now, in Python, we can emulate this behavior without actually writing a
+    file to disk using the ``exec`` function. ``exec`` takes a string
+    containing a block of Python code, and a dictionary that should contain
+    the global variables of the module. It then executes the code "in" that
+    dictionary, as if it were the module globals. The following is equivalent
+    to the ``sin_cos`` defined in ``sin_cos_sympy.py``:
+
+    >>> import sympy
+    >>> module_dictionary = {'sin': sympy.sin, 'cos': sympy.cos}
+    >>> exec('''
+    ... def sin_cos(x):
+    ...     return sin(x) + cos(x)
+    ... ''', module_dictionary)
+    >>> sin_cos = module_dictionary['sin_cos']
+    >>> sin_cos(1)
+    cos(1) + sin(1)
+
+    and similarly with ``sin_cos_numpy``:
+
+    >>> import numpy
+    >>> module_dictionary = {'sin': numpy.sin, 'cos': numpy.cos}
+    >>> exec('''
+    ... def sin_cos(x):
+    ...     return sin(x) + cos(x)
+    ... ''', module_dictionary)
+    >>> sin_cos = module_dictionary['sin_cos']
+    >>> sin_cos(1)
+    1.38177329068
+
+    So now we can get an idea of how ``lambdify`` works. The name "lambdify"
+    comes from the fact that we can think of something like ``lambdify(x,
+    sin(x) + cos(x), 'numpy')`` as ``lambda x: sin(x) + cos(x)``, where
+    ``sin`` and ``cos`` come from the ``numpy`` namespace. This is also why
+    the symbols argument is first in ``lambdify``, as opposed to most SymPy
+    functions where it comes after the expression: to better mimic the
+    ``lambda`` keyword.
+
+    ``lambdify`` takes the input expression (like ``sin(x) + cos(x)``) and
+
+    1. Converts it to a string
+    2. Creates a module globals dictionary based on the modules that are
+       passed in (by default, it uses the NumPy module)
+    3. Creates the string ``"def func({vars}): return {expr}"``, where ``{vars}`` is the
+       list of variables separated by commas, and ``{expr}`` is the string
+       created in step 1., then ``exec``s that string with the module globals
+       namespace and returns ``func``.
+
+    In fact, functions returned by ``lambdify`` support inspection. So you can
+    see exactly how they are defined by using ``inspect.getsource``, or ``??`` if you
+    are using IPython or the Jupyter notebook.
+
+    >>> f = lambdify(x, sin(x) + cos(x))
+    >>> import inspect
+    >>> print(inspect.getsource(f))
+    def _lambdifygenerated(x):
+        return sin(x) + cos(x)
+
+    This shows us the source code of the function, but not the namespace it
+    was defined in. We can inspect that by looking at the ``__globals__``
+    attribute of ``f``:
+
+    >>> f.__globals__['sin']
+    <ufunc 'sin'>
+    >>> f.__globals__['cos']
+    <ufunc 'cos'>
+    >>> f.__globals__['sin'] is numpy.sin
+    True
+
+    This shows us that ``sin`` and ``cos`` in the namespace of ``f`` will be
+    ``numpy.sin`` and ``numpy.cos``.
+
+    Note that there are some convenience layers in each of these steps, but at
+    the core, this is how ``lambdify`` works. Step 1 is done using the
+    ``LambdaPrinter`` printers defined in the printing module (see
+    :mod:`sympy.printing.lambdarepr`). This allows different SymPy expressions
+    to define how they should be converted to a string for different modules.
+    You can change which printer ``lambdify`` uses by passing a custom printer
+    in to the ``printer`` argument.
+
+    Step 2 is augmented by certain translations. There are default
+    translations for each module, but you can provide your own by passing a
+    list to the ``modules`` argument. For instance,
+
+    >>> def mysin(x):
+    ...     print('taking the sin of', x)
+    ...     return numpy.sin(x)
+    ...
+    >>> f = lambdify(x, sin(x), [{'sin': mysin}, 'numpy'])
+    >>> f(1)
+    taking the sin of 1
+    0.8414709848078965
+
+    The globals dictionary is generated from the list by merging the
+    dictionary ``{'sin': mysin}`` and the module dictionary for NumPy. The
+    merging is done so that earlier items take precedence, which is why
+    ``mysin`` is used above instead of ``numpy.sin``.
+
+    If you want to modify the way ``lambdify`` works for a given function, it
+    is usually easiest to do so by modifying the globals dictionary as such.
+    In more complicated cases, it may be necessary to create and pass in a
+    custom printer.
+
+    Finally, step 3 is augmented with certain convenience operations, such as
+    the addition of a docstring.
+
+    Understanding how ``lambdify`` works can make it easier to avoid certain
+    gotchas when using it. For instance, a common mistake is to create a
+    lambdified function for one module (say, NumPy), and pass it objects from
+    another (say, a SymPy expression).
+
+    For instance, say we create
+
+    >>> from sympy.abc import x
+    >>> f = lambdify(x, x + 1, 'numpy')
+
+    Now if we pass in a NumPy array, we get that array plus 1
+
+    >>> import numpy
+    >>> a = numpy.array([1, 2])
+    >>> f(a)
+    [2 3]
+
+    But what happens if you make the mistake of passing in a SymPy expression
+    instead of a NumPy array:
+
+    >>> f(x + 1)
+    x + 2
+
+    This worked, but it was only by accident. Now take a different lambdified
+    function:
+
+    >>> from sympy import sin
+    >>> g = lambdify(x, x + sin(x), 'numpy')
+
+    This works as expected on NumPy arrays:
+
+    >>> g(a)
+    [1.84147098 2.90929743]
+
+    But if we try to pass in a SymPy expression, it fails
+
+    >>> try:
+    ...     g(x + 1)
+    ... # NumPy release after 1.17 raises TypeError instead of
+    ... # AttributeError
+    ... except (AttributeError, TypeError):
+    ...     raise AttributeError() # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+    ...
+    AttributeError:
+
+    Now, let's look at what happened. The reason this fails is that ``g``
+    calls ``numpy.sin`` on the input expression, and ``numpy.sin`` does not
+    know how to operate on a SymPy object. **As a general rule, NumPy
+    functions do not know how to operate on SymPy expressions, and SymPy
+    functions do not know how to operate on NumPy arrays. This is why lambdify
+    exists: to provide a bridge between SymPy and NumPy.**
+
+    However, why is it that ``f`` did work? That's because ``f`` does not call
+    any functions, it only adds 1. So the resulting function that is created,
+    ``def _lambdifygenerated(x): return x + 1`` does not depend on the globals
+    namespace it is defined in. Thus it works, but only by accident. A future
+    version of ``lambdify`` may remove this behavior.
+
+    Be aware that certain implementation details described here may change in
+    future versions of SymPy. The API of passing in custom modules and
+    printers will not change, but the details of how a lambda function is
+    created may change. However, the basic idea will remain the same, and
+    understanding it will be helpful to understanding the behavior of
+    lambdify.
+
+    **In general: you should create lambdified functions for one module (say,
+    NumPy), and only pass it input types that are compatible with that module
+    (say, NumPy arrays).** Remember that by default, if the ``module``
+    argument is not provided, ``lambdify`` creates functions using the NumPy
+    and SciPy namespaces.
+    """
+    from sympy.core.symbol import Symbol
+    from sympy.core.expr import Expr
+
+    # If the user hasn't specified any modules, use what is available.
+    if modules is None:
+        try:
+            _import("scipy")
+        except ImportError:
+            try:
+                _import("numpy")
+            except ImportError:
+                # Use either numpy (if available) or python.math where possible.
+                # XXX: This leads to different behaviour on different systems and
+                #      might be the reason for irreproducible errors.
+                modules = ["math", "mpmath", "sympy"]
+            else:
+                modules = ["numpy"]
+        else:
+            modules = ["numpy", "scipy"]
+
+    # Get the needed namespaces.
+    namespaces = []
+    # First find any function implementations
+    if use_imps:
+        namespaces.append(_imp_namespace(expr))
+    # Check for dict before iterating
+    if isinstance(modules, (dict, str)) or not hasattr(modules, '__iter__'):
+        namespaces.append(modules)
+    else:
+        # consistency check
+        if _module_present('numexpr', modules) and len(modules) > 1:
+            raise TypeError("numexpr must be the only item in 'modules'")
+        namespaces += list(modules)
+    # fill namespace with first having highest priority
+    namespace = {}
+    for m in namespaces[::-1]:
+        buf = _get_namespace(m)
+        namespace.update(buf)
+
+    if hasattr(expr, "atoms"):
+        #Try if you can extract symbols from the expression.
+        #Move on if expr.atoms in not implemented.
+        syms = expr.atoms(Symbol)
+        for term in syms:
+            namespace.update({str(term): term})
+
+    if printer is None:
+        if _module_present('mpmath', namespaces):
+            from sympy.printing.pycode import MpmathPrinter as Printer # type: ignore
+        elif _module_present('scipy', namespaces):
+            from sympy.printing.numpy import SciPyPrinter as Printer # type: ignore
+        elif _module_present('numpy', namespaces):
+            from sympy.printing.numpy import NumPyPrinter as Printer # type: ignore
+        elif _module_present('cupy', namespaces):
+            from sympy.printing.numpy import CuPyPrinter as Printer # type: ignore
+        elif _module_present('jax', namespaces):
+            from sympy.printing.numpy import JaxPrinter as Printer # type: ignore
+        elif _module_present('numexpr', namespaces):
+            from sympy.printing.lambdarepr import NumExprPrinter as Printer # type: ignore
+        elif _module_present('tensorflow', namespaces):
+            from sympy.printing.tensorflow import TensorflowPrinter as Printer # type: ignore
+        elif _module_present('sympy', namespaces):
+            from sympy.printing.pycode import SymPyPrinter as Printer # type: ignore
+        else:
+            from sympy.printing.pycode import PythonCodePrinter as Printer # type: ignore
+        user_functions = {}
+        for m in namespaces[::-1]:
+            if isinstance(m, dict):
+                for k in m:
+                    user_functions[k] = k
+        printer = Printer({'fully_qualified_modules': False, 'inline': True,
+                           'allow_unknown_functions': True,
+                           'user_functions': user_functions})
+
+    if isinstance(args, set):
+        sympy_deprecation_warning(
+            """
+Passing the function arguments to lambdify() as a set is deprecated. This
+leads to unpredictable results since sets are unordered. Instead, use a list
+or tuple for the function arguments.
+            """,
+            deprecated_since_version="1.6.3",
+            active_deprecations_target="deprecated-lambdify-arguments-set",
+                )
+
+    # Get the names of the args, for creating a docstring
+    iterable_args = (args,) if isinstance(args, Expr) else args
+    names = []
+
+    # Grab the callers frame, for getting the names by inspection (if needed)
+    callers_local_vars = inspect.currentframe().f_back.f_locals.items() # type: ignore
+    for n, var in enumerate(iterable_args):
+        if hasattr(var, 'name'):
+            names.append(var.name)
+        else:
+            # It's an iterable. Try to get name by inspection of calling frame.
+            name_list = [var_name for var_name, var_val in callers_local_vars
+                    if var_val is var]
+            if len(name_list) == 1:
+                names.append(name_list[0])
+            else:
+                # Cannot infer name with certainty. arg_# will have to do.
+                names.append('arg_' + str(n))
+
+    # Create the function definition code and execute it
+    funcname = '_lambdifygenerated'
+    if _module_present('tensorflow', namespaces):
+        funcprinter = _TensorflowEvaluatorPrinter(printer, dummify)
+    else:
+        funcprinter = _EvaluatorPrinter(printer, dummify)
+
+    if cse == True:
+        from sympy.simplify.cse_main import cse as _cse
+        cses, _expr = _cse(expr, list=False)
+    elif callable(cse):
+        cses, _expr = cse(expr)
+    else:
+        cses, _expr = (), expr
+    funcstr = funcprinter.doprint(funcname, iterable_args, _expr, cses=cses)
+
+    # Collect the module imports from the code printers.
+    imp_mod_lines = []
+    for mod, keys in (getattr(printer, 'module_imports', None) or {}).items():
+        for k in keys:
+            if k not in namespace:
+                ln = "from %s import %s" % (mod, k)
+                try:
+                    exec(ln, {}, namespace)
+                except ImportError:
+                    # Tensorflow 2.0 has issues with importing a specific
+                    # function from its submodule.
+                    # https://github.com/tensorflow/tensorflow/issues/33022
+                    ln = "%s = %s.%s" % (k, mod, k)
+                    exec(ln, {}, namespace)
+                imp_mod_lines.append(ln)
+
+    # Provide lambda expression with builtins, and compatible implementation of range
+    namespace.update({'builtins':builtins, 'range':range})
+
+    funclocals = {}
+    global _lambdify_generated_counter
+    filename = '<lambdifygenerated-%s>' % _lambdify_generated_counter
+    _lambdify_generated_counter += 1
+    c = compile(funcstr, filename, 'exec')
+    exec(c, namespace, funclocals)
+    # mtime has to be None or else linecache.checkcache will remove it
+    linecache.cache[filename] = (len(funcstr), None, funcstr.splitlines(True), filename) # type: ignore
+
+    func = funclocals[funcname]
+
+    # Apply the docstring
+    sig = "func({})".format(", ".join(str(i) for i in names))
+    sig = textwrap.fill(sig, subsequent_indent=' '*8)
+    if _too_large_for_docstring(expr, docstring_limit):
+        expr_str = 'EXPRESSION REDACTED DUE TO LENGTH'
+        src_str = 'SOURCE CODE REDACTED DUE TO LENGTH'
+    else:
+        expr_str = str(expr)
+        if len(expr_str) > 78:
+            expr_str = textwrap.wrap(expr_str, 75)[0] + '...'
+        src_str = funcstr
+    func.__doc__ = (
+        "Created with lambdify. Signature:\n\n"
+        "{sig}\n\n"
+        "Expression:\n\n"
+        "{expr}\n\n"
+        "Source code:\n\n"
+        "{src}\n\n"
+        "Imported modules:\n\n"
+        "{imp_mods}"
+        ).format(sig=sig, expr=expr_str, src=src_str, imp_mods='\n'.join(imp_mod_lines))
+    return func
+
+def _module_present(modname, modlist):
+    if modname in modlist:
+        return True
+    for m in modlist:
+        if hasattr(m, '__name__') and m.__name__ == modname:
+            return True
+    return False
+
+def _get_namespace(m):
+    """
+    This is used by _lambdify to parse its arguments.
+    """
+    if isinstance(m, str):
+        _import(m)
+        return MODULES[m][0]
+    elif isinstance(m, dict):
+        return m
+    elif hasattr(m, "__dict__"):
+        return m.__dict__
+    else:
+        raise TypeError("Argument must be either a string, dict or module but it is: %s" % m)
+
+
+def _recursive_to_string(doprint, arg):
+    """Functions in lambdify accept both SymPy types and non-SymPy types such as python
+    lists and tuples. This method ensures that we only call the doprint method of the
+    printer with SymPy types (so that the printer safely can use SymPy-methods)."""
+    from sympy.matrices.common import MatrixOperations
+    from sympy.core.basic import Basic
+
+    if isinstance(arg, (Basic, MatrixOperations)):
+        return doprint(arg)
+    elif iterable(arg):
+        if isinstance(arg, list):
+            left, right = "[", "]"
+        elif isinstance(arg, tuple):
+            left, right = "(", ",)"
+        else:
+            raise NotImplementedError("unhandled type: %s, %s" % (type(arg), arg))
+        return left +', '.join(_recursive_to_string(doprint, e) for e in arg) + right
+    elif isinstance(arg, str):
+        return arg
+    else:
+        return doprint(arg)
+
+
+def lambdastr(args, expr, printer=None, dummify=None):
+    """
+    Returns a string that can be evaluated to a lambda function.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y, z
+    >>> from sympy.utilities.lambdify import lambdastr
+    >>> lambdastr(x, x**2)
+    'lambda x: (x**2)'
+    >>> lambdastr((x,y,z), [z,y,x])
+    'lambda x,y,z: ([z, y, x])'
+
+    Although tuples may not appear as arguments to lambda in Python 3,
+    lambdastr will create a lambda function that will unpack the original
+    arguments so that nested arguments can be handled:
+
+    >>> lambdastr((x, (y, z)), x + y)
+    'lambda _0,_1: (lambda x,y,z: (x + y))(_0,_1[0],_1[1])'
+    """
+    # Transforming everything to strings.
+    from sympy.matrices import DeferredVector
+    from sympy.core.basic import Basic
+    from sympy.core.function import (Derivative, Function)
+    from sympy.core.symbol import (Dummy, Symbol)
+    from sympy.core.sympify import sympify
+
+    if printer is not None:
+        if inspect.isfunction(printer):
+            lambdarepr = printer
+        else:
+            if inspect.isclass(printer):
+                lambdarepr = lambda expr: printer().doprint(expr)
+            else:
+                lambdarepr = lambda expr: printer.doprint(expr)
+    else:
+        #XXX: This has to be done here because of circular imports
+        from sympy.printing.lambdarepr import lambdarepr
+
+    def sub_args(args, dummies_dict):
+        if isinstance(args, str):
+            return args
+        elif isinstance(args, DeferredVector):
+            return str(args)
+        elif iterable(args):
+            dummies = flatten([sub_args(a, dummies_dict) for a in args])
+            return ",".join(str(a) for a in dummies)
+        else:
+            # replace these with Dummy symbols
+            if isinstance(args, (Function, Symbol, Derivative)):
+                dummies = Dummy()
+                dummies_dict.update({args : dummies})
+                return str(dummies)
+            else:
+                return str(args)
+
+    def sub_expr(expr, dummies_dict):
+        expr = sympify(expr)
+        # dict/tuple are sympified to Basic
+        if isinstance(expr, Basic):
+            expr = expr.xreplace(dummies_dict)
+        # list is not sympified to Basic
+        elif isinstance(expr, list):
+            expr = [sub_expr(a, dummies_dict) for a in expr]
+        return expr
+
+    # Transform args
+    def isiter(l):
+        return iterable(l, exclude=(str, DeferredVector, NotIterable))
+
+    def flat_indexes(iterable):
+        n = 0
+
+        for el in iterable:
+            if isiter(el):
+                for ndeep in flat_indexes(el):
+                    yield (n,) + ndeep
+            else:
+                yield (n,)
+
+            n += 1
+
+    if dummify is None:
+        dummify = any(isinstance(a, Basic) and
+            a.atoms(Function, Derivative) for a in (
+            args if isiter(args) else [args]))
+
+    if isiter(args) and any(isiter(i) for i in args):
+        dum_args = [str(Dummy(str(i))) for i in range(len(args))]
+
+        indexed_args = ','.join([
+            dum_args[ind[0]] + ''.join(["[%s]" % k for k in ind[1:]])
+                    for ind in flat_indexes(args)])
+
+        lstr = lambdastr(flatten(args), expr, printer=printer, dummify=dummify)
+
+        return 'lambda %s: (%s)(%s)' % (','.join(dum_args), lstr, indexed_args)
+
+    dummies_dict = {}
+    if dummify:
+        args = sub_args(args, dummies_dict)
+    else:
+        if isinstance(args, str):
+            pass
+        elif iterable(args, exclude=DeferredVector):
+            args = ",".join(str(a) for a in args)
+
+    # Transform expr
+    if dummify:
+        if isinstance(expr, str):
+            pass
+        else:
+            expr = sub_expr(expr, dummies_dict)
+    expr = _recursive_to_string(lambdarepr, expr)
+    return "lambda %s: (%s)" % (args, expr)
+
+class _EvaluatorPrinter:
+    def __init__(self, printer=None, dummify=False):
+        self._dummify = dummify
+
+        #XXX: This has to be done here because of circular imports
+        from sympy.printing.lambdarepr import LambdaPrinter
+
+        if printer is None:
+            printer = LambdaPrinter()
+
+        if inspect.isfunction(printer):
+            self._exprrepr = printer
+        else:
+            if inspect.isclass(printer):
+                printer = printer()
+
+            self._exprrepr = printer.doprint
+
+            #if hasattr(printer, '_print_Symbol'):
+            #    symbolrepr = printer._print_Symbol
+
+            #if hasattr(printer, '_print_Dummy'):
+            #    dummyrepr = printer._print_Dummy
+
+        # Used to print the generated function arguments in a standard way
+        self._argrepr = LambdaPrinter().doprint
+
+    def doprint(self, funcname, args, expr, *, cses=()):
+        """
+        Returns the function definition code as a string.
+        """
+        from sympy.core.symbol import Dummy
+
+        funcbody = []
+
+        if not iterable(args):
+            args = [args]
+
+        if cses:
+            subvars, subexprs = zip(*cses)
+            exprs = [expr] + list(subexprs)
+            argstrs, exprs = self._preprocess(args, exprs)
+            expr, subexprs = exprs[0], exprs[1:]
+            cses = zip(subvars, subexprs)
+        else:
+            argstrs, expr = self._preprocess(args, expr)
+
+        # Generate argument unpacking and final argument list
+        funcargs = []
+        unpackings = []
+
+        for argstr in argstrs:
+            if iterable(argstr):
+                funcargs.append(self._argrepr(Dummy()))
+                unpackings.extend(self._print_unpacking(argstr, funcargs[-1]))
+            else:
+                funcargs.append(argstr)
+
+        funcsig = 'def {}({}):'.format(funcname, ', '.join(funcargs))
+
+        # Wrap input arguments before unpacking
+        funcbody.extend(self._print_funcargwrapping(funcargs))
+
+        funcbody.extend(unpackings)
+
+        for s, e in cses:
+            if e is None:
+                funcbody.append('del {}'.format(s))
+            else:
+                funcbody.append('{} = {}'.format(s, self._exprrepr(e)))
+
+        str_expr = _recursive_to_string(self._exprrepr, expr)
+
+        if '\n' in str_expr:
+            str_expr = '({})'.format(str_expr)
+        funcbody.append('return {}'.format(str_expr))
+
+        funclines = [funcsig]
+        funclines.extend(['    ' + line for line in funcbody])
+
+        return '\n'.join(funclines) + '\n'
+
+    @classmethod
+    def _is_safe_ident(cls, ident):
+        return isinstance(ident, str) and ident.isidentifier() \
+                and not keyword.iskeyword(ident)
+
+    def _preprocess(self, args, expr):
+        """Preprocess args, expr to replace arguments that do not map
+        to valid Python identifiers.
+
+        Returns string form of args, and updated expr.
+        """
+        from sympy.core.basic import Basic
+        from sympy.core.sorting import ordered
+        from sympy.core.function import (Derivative, Function)
+        from sympy.core.symbol import Dummy, uniquely_named_symbol
+        from sympy.matrices import DeferredVector
+        from sympy.core.expr import Expr
+
+        # Args of type Dummy can cause name collisions with args
+        # of type Symbol.  Force dummify of everything in this
+        # situation.
+        dummify = self._dummify or any(
+            isinstance(arg, Dummy) for arg in flatten(args))
+
+        argstrs = [None]*len(args)
+        for arg, i in reversed(list(ordered(zip(args, range(len(args)))))):
+            if iterable(arg):
+                s, expr = self._preprocess(arg, expr)
+            elif isinstance(arg, DeferredVector):
+                s = str(arg)
+            elif isinstance(arg, Basic) and arg.is_symbol:
+                s = self._argrepr(arg)
+                if dummify or not self._is_safe_ident(s):
+                    dummy = Dummy()
+                    if isinstance(expr, Expr):
+                        dummy = uniquely_named_symbol(
+                            dummy.name, expr, modify=lambda s: '_' + s)
+                    s = self._argrepr(dummy)
+                    expr = self._subexpr(expr, {arg: dummy})
+            elif dummify or isinstance(arg, (Function, Derivative)):
+                dummy = Dummy()
+                s = self._argrepr(dummy)
+                expr = self._subexpr(expr, {arg: dummy})
+            else:
+                s = str(arg)
+            argstrs[i] = s
+        return argstrs, expr
+
+    def _subexpr(self, expr, dummies_dict):
+        from sympy.matrices import DeferredVector
+        from sympy.core.sympify import sympify
+
+        expr = sympify(expr)
+        xreplace = getattr(expr, 'xreplace', None)
+        if xreplace is not None:
+            expr = xreplace(dummies_dict)
+        else:
+            if isinstance(expr, DeferredVector):
+                pass
+            elif isinstance(expr, dict):
+                k = [self._subexpr(sympify(a), dummies_dict) for a in expr.keys()]
+                v = [self._subexpr(sympify(a), dummies_dict) for a in expr.values()]
+                expr = dict(zip(k, v))
+            elif isinstance(expr, tuple):
+                expr = tuple(self._subexpr(sympify(a), dummies_dict) for a in expr)
+            elif isinstance(expr, list):
+                expr = [self._subexpr(sympify(a), dummies_dict) for a in expr]
+        return expr
+
+    def _print_funcargwrapping(self, args):
+        """Generate argument wrapping code.
+
+        args is the argument list of the generated function (strings).
+
+        Return value is a list of lines of code that will be inserted  at
+        the beginning of the function definition.
+        """
+        return []
+
+    def _print_unpacking(self, unpackto, arg):
+        """Generate argument unpacking code.
+
+        arg is the function argument to be unpacked (a string), and
+        unpackto is a list or nested lists of the variable names (strings) to
+        unpack to.
+        """
+        def unpack_lhs(lvalues):
+            return '[{}]'.format(', '.join(
+                unpack_lhs(val) if iterable(val) else val for val in lvalues))
+
+        return ['{} = {}'.format(unpack_lhs(unpackto), arg)]
+
+class _TensorflowEvaluatorPrinter(_EvaluatorPrinter):
+    def _print_unpacking(self, lvalues, rvalue):
+        """Generate argument unpacking code.
+
+        This method is used when the input value is not interable,
+        but can be indexed (see issue #14655).
+        """
+
+        def flat_indexes(elems):
+            n = 0
+
+            for el in elems:
+                if iterable(el):
+                    for ndeep in flat_indexes(el):
+                        yield (n,) + ndeep
+                else:
+                    yield (n,)
+
+                n += 1
+
+        indexed = ', '.join('{}[{}]'.format(rvalue, ']['.join(map(str, ind)))
+                                for ind in flat_indexes(lvalues))
+
+        return ['[{}] = [{}]'.format(', '.join(flatten(lvalues)), indexed)]
+
+def _imp_namespace(expr, namespace=None):
+    """ Return namespace dict with function implementations
+
+    We need to search for functions in anything that can be thrown at
+    us - that is - anything that could be passed as ``expr``.  Examples
+    include SymPy expressions, as well as tuples, lists and dicts that may
+    contain SymPy expressions.
+
+    Parameters
+    ----------
+    expr : object
+       Something passed to lambdify, that will generate valid code from
+       ``str(expr)``.
+    namespace : None or mapping
+       Namespace to fill.  None results in new empty dict
+
+    Returns
+    -------
+    namespace : dict
+       dict with keys of implemented function names within ``expr`` and
+       corresponding values being the numerical implementation of
+       function
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.utilities.lambdify import implemented_function, _imp_namespace
+    >>> from sympy import Function
+    >>> f = implemented_function(Function('f'), lambda x: x+1)
+    >>> g = implemented_function(Function('g'), lambda x: x*10)
+    >>> namespace = _imp_namespace(f(g(x)))
+    >>> sorted(namespace.keys())
+    ['f', 'g']
+    """
+    # Delayed import to avoid circular imports
+    from sympy.core.function import FunctionClass
+    if namespace is None:
+        namespace = {}
+    # tuples, lists, dicts are valid expressions
+    if is_sequence(expr):
+        for arg in expr:
+            _imp_namespace(arg, namespace)
+        return namespace
+    elif isinstance(expr, dict):
+        for key, val in expr.items():
+            # functions can be in dictionary keys
+            _imp_namespace(key, namespace)
+            _imp_namespace(val, namespace)
+        return namespace
+    # SymPy expressions may be Functions themselves
+    func = getattr(expr, 'func', None)
+    if isinstance(func, FunctionClass):
+        imp = getattr(func, '_imp_', None)
+        if imp is not None:
+            name = expr.func.__name__
+            if name in namespace and namespace[name] != imp:
+                raise ValueError('We found more than one '
+                                 'implementation with name '
+                                 '"%s"' % name)
+            namespace[name] = imp
+    # and / or they may take Functions as arguments
+    if hasattr(expr, 'args'):
+        for arg in expr.args:
+            _imp_namespace(arg, namespace)
+    return namespace
+
+
+def implemented_function(symfunc, implementation):
+    """ Add numerical ``implementation`` to function ``symfunc``.
+
+    ``symfunc`` can be an ``UndefinedFunction`` instance, or a name string.
+    In the latter case we create an ``UndefinedFunction`` instance with that
+    name.
+
+    Be aware that this is a quick workaround, not a general method to create
+    special symbolic functions. If you want to create a symbolic function to be
+    used by all the machinery of SymPy you should subclass the ``Function``
+    class.
+
+    Parameters
+    ----------
+    symfunc : ``str`` or ``UndefinedFunction`` instance
+       If ``str``, then create new ``UndefinedFunction`` with this as
+       name.  If ``symfunc`` is an Undefined function, create a new function
+       with the same name and the implemented function attached.
+    implementation : callable
+       numerical implementation to be called by ``evalf()`` or ``lambdify``
+
+    Returns
+    -------
+    afunc : sympy.FunctionClass instance
+       function with attached implementation
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.utilities.lambdify import implemented_function
+    >>> from sympy import lambdify
+    >>> f = implemented_function('f', lambda x: x+1)
+    >>> lam_f = lambdify(x, f(x))
+    >>> lam_f(4)
+    5
+    """
+    # Delayed import to avoid circular imports
+    from sympy.core.function import UndefinedFunction
+    # if name, create function to hold implementation
+    kwargs = {}
+    if isinstance(symfunc, UndefinedFunction):
+        kwargs = symfunc._kwargs
+        symfunc = symfunc.__name__
+    if isinstance(symfunc, str):
+        # Keyword arguments to UndefinedFunction are added as attributes to
+        # the created class.
+        symfunc = UndefinedFunction(
+            symfunc, _imp_=staticmethod(implementation), **kwargs)
+    elif not isinstance(symfunc, UndefinedFunction):
+        raise ValueError(filldedent('''
+            symfunc should be either a string or
+            an UndefinedFunction instance.'''))
+    return symfunc
+
+
+def _too_large_for_docstring(expr, limit):
+    """Decide whether an ``Expr`` is too large to be fully rendered in a
+    ``lambdify`` docstring.
+
+    This is a fast alternative to ``count_ops``, which can become prohibitively
+    slow for large expressions, because in this instance we only care whether
+    ``limit`` is exceeded rather than counting the exact number of nodes in the
+    expression.
+
+    Parameters
+    ==========
+    expr : ``Expr``, (nested) ``list`` of ``Expr``, or ``Matrix``
+        The same objects that can be passed to the ``expr`` argument of
+        ``lambdify``.
+    limit : ``int`` or ``None``
+        The threshold above which an expression contains too many nodes to be
+        usefully rendered in the docstring. If ``None`` then there is no limit.
+
+    Returns
+    =======
+    bool
+        ``True`` if the number of nodes in the expression exceeds the limit,
+        ``False`` otherwise.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y, z
+    >>> from sympy.utilities.lambdify import _too_large_for_docstring
+    >>> expr = x
+    >>> _too_large_for_docstring(expr, None)
+    False
+    >>> _too_large_for_docstring(expr, 100)
+    False
+    >>> _too_large_for_docstring(expr, 1)
+    False
+    >>> _too_large_for_docstring(expr, 0)
+    True
+    >>> _too_large_for_docstring(expr, -1)
+    True
+
+    Does this split it?
+
+    >>> expr = [x, y, z]
+    >>> _too_large_for_docstring(expr, None)
+    False
+    >>> _too_large_for_docstring(expr, 100)
+    False
+    >>> _too_large_for_docstring(expr, 1)
+    True
+    >>> _too_large_for_docstring(expr, 0)
+    True
+    >>> _too_large_for_docstring(expr, -1)
+    True
+
+    >>> expr = [x, [y], z, [[x+y], [x*y*z, [x+y+z]]]]
+    >>> _too_large_for_docstring(expr, None)
+    False
+    >>> _too_large_for_docstring(expr, 100)
+    False
+    >>> _too_large_for_docstring(expr, 1)
+    True
+    >>> _too_large_for_docstring(expr, 0)
+    True
+    >>> _too_large_for_docstring(expr, -1)
+    True
+
+    >>> expr = ((x + y + z)**5).expand()
+    >>> _too_large_for_docstring(expr, None)
+    False
+    >>> _too_large_for_docstring(expr, 100)
+    True
+    >>> _too_large_for_docstring(expr, 1)
+    True
+    >>> _too_large_for_docstring(expr, 0)
+    True
+    >>> _too_large_for_docstring(expr, -1)
+    True
+
+    >>> from sympy import Matrix
+    >>> expr = Matrix([[(x + y + z), ((x + y + z)**2).expand(),
+    ...                 ((x + y + z)**3).expand(), ((x + y + z)**4).expand()]])
+    >>> _too_large_for_docstring(expr, None)
+    False
+    >>> _too_large_for_docstring(expr, 1000)
+    False
+    >>> _too_large_for_docstring(expr, 100)
+    True
+    >>> _too_large_for_docstring(expr, 1)
+    True
+    >>> _too_large_for_docstring(expr, 0)
+    True
+    >>> _too_large_for_docstring(expr, -1)
+    True
+
+    """
+    # Must be imported here to avoid a circular import error
+    from sympy.core.traversal import postorder_traversal
+
+    if limit is None:
+        return False
+
+    i = 0
+    for _ in postorder_traversal(expr):
+        i += 1
+        if i > limit:
+            return True
+    return False

venv/lib/python3.10/site-packages/sympy/utilities/magic.py

@@ -0,0 +1,12 @@
+"""Functions that involve magic. """
+
+def pollute(names, objects):
+    """Pollute the global namespace with symbols -> objects mapping. """
+    from inspect import currentframe
+    frame = currentframe().f_back.f_back
+
+    try:
+        for name, obj in zip(names, objects):
+            frame.f_globals[name] = obj
+    finally:
+        del frame  # break cyclic dependencies as stated in inspect docs

venv/lib/python3.10/site-packages/sympy/utilities/matchpy_connector.py

@@ -0,0 +1,289 @@
+"""
+The objects in this module allow the usage of the MatchPy pattern matching
+library on SymPy expressions.
+"""
+import re
+from typing import List, Callable
+
+from sympy.core.sympify import _sympify
+from sympy.external import import_module
+from sympy.functions import (log, sin, cos, tan, cot, csc, sec, erf, gamma, uppergamma)
+from sympy.functions.elementary.hyperbolic import acosh, asinh, atanh, acoth, acsch, asech, cosh, sinh, tanh, coth, sech, csch
+from sympy.functions.elementary.trigonometric import atan, acsc, asin, acot, acos, asec
+from sympy.functions.special.error_functions import fresnelc, fresnels, erfc, erfi, Ei
+from sympy.core.add import Add
+from sympy.core.basic import Basic
+from sympy.core.expr import Expr
+from sympy.core.mul import Mul
+from sympy.core.power import Pow
+from sympy.core.relational import (Equality, Unequality)
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.exponential import exp
+from sympy.integrals.integrals import Integral
+from sympy.printing.repr import srepr
+from sympy.utilities.decorator import doctest_depends_on
+
+matchpy = import_module("matchpy")
+
+if matchpy:
+    from matchpy import Operation, CommutativeOperation, AssociativeOperation, OneIdentityOperation
+    from matchpy.expressions.functions import op_iter, create_operation_expression, op_len
+
+    Operation.register(Integral)
+    Operation.register(Pow)
+    OneIdentityOperation.register(Pow)
+
+    Operation.register(Add)
+    OneIdentityOperation.register(Add)
+    CommutativeOperation.register(Add)
+    AssociativeOperation.register(Add)
+
+    Operation.register(Mul)
+    OneIdentityOperation.register(Mul)
+    CommutativeOperation.register(Mul)
+    AssociativeOperation.register(Mul)
+
+    Operation.register(Equality)
+    CommutativeOperation.register(Equality)
+    Operation.register(Unequality)
+    CommutativeOperation.register(Unequality)
+
+    Operation.register(exp)
+    Operation.register(log)
+    Operation.register(gamma)
+    Operation.register(uppergamma)
+    Operation.register(fresnels)
+    Operation.register(fresnelc)
+    Operation.register(erf)
+    Operation.register(Ei)
+    Operation.register(erfc)
+    Operation.register(erfi)
+    Operation.register(sin)
+    Operation.register(cos)
+    Operation.register(tan)
+    Operation.register(cot)
+    Operation.register(csc)
+    Operation.register(sec)
+    Operation.register(sinh)
+    Operation.register(cosh)
+    Operation.register(tanh)
+    Operation.register(coth)
+    Operation.register(csch)
+    Operation.register(sech)
+    Operation.register(asin)
+    Operation.register(acos)
+    Operation.register(atan)
+    Operation.register(acot)
+    Operation.register(acsc)
+    Operation.register(asec)
+    Operation.register(asinh)
+    Operation.register(acosh)
+    Operation.register(atanh)
+    Operation.register(acoth)
+    Operation.register(acsch)
+    Operation.register(asech)
+
+    @op_iter.register(Integral)  # type: ignore
+    def _(operation):
+        return iter((operation._args[0],) + operation._args[1])
+
+    @op_iter.register(Basic)  # type: ignore
+    def _(operation):
+        return iter(operation._args)
+
+    @op_len.register(Integral)  # type: ignore
+    def _(operation):
+        return 1 + len(operation._args[1])
+
+    @op_len.register(Basic)  # type: ignore
+    def _(operation):
+        return len(operation._args)
+
+    @create_operation_expression.register(Basic)
+    def sympy_op_factory(old_operation, new_operands, variable_name=True):
+         return type(old_operation)(*new_operands)
+
+
+if matchpy:
+    from matchpy import Wildcard
+else:
+    class Wildcard: # type: ignore
+        def __init__(self, min_length, fixed_size, variable_name, optional):
+            self.min_count = min_length
+            self.fixed_size = fixed_size
+            self.variable_name = variable_name
+            self.optional = optional
+
+
+@doctest_depends_on(modules=('matchpy',))
+class _WildAbstract(Wildcard, Symbol):
+    min_length: int  # abstract field required in subclasses
+    fixed_size: bool  # abstract field required in subclasses
+
+    def __init__(self, variable_name=None, optional=None, **assumptions):
+        min_length = self.min_length
+        fixed_size = self.fixed_size
+        if optional is not None:
+            optional = _sympify(optional)
+        Wildcard.__init__(self, min_length, fixed_size, str(variable_name), optional)
+
+    def __getstate__(self):
+        return {
+            "min_length": self.min_length,
+            "fixed_size": self.fixed_size,
+            "min_count": self.min_count,
+            "variable_name": self.variable_name,
+            "optional": self.optional,
+        }
+
+    def __new__(cls, variable_name=None, optional=None, **assumptions):
+        cls._sanitize(assumptions, cls)
+        return _WildAbstract.__xnew__(cls, variable_name, optional, **assumptions)
+
+    def __getnewargs__(self):
+        return self.variable_name, self.optional
+
+    @staticmethod
+    def __xnew__(cls, variable_name=None, optional=None, **assumptions):
+        obj = Symbol.__xnew__(cls, variable_name, **assumptions)
+        return obj
+
+    def _hashable_content(self):
+        if self.optional:
+            return super()._hashable_content() + (self.min_count, self.fixed_size, self.variable_name, self.optional)
+        else:
+            return super()._hashable_content() + (self.min_count, self.fixed_size, self.variable_name)
+
+    def __copy__(self) -> '_WildAbstract':
+        return type(self)(variable_name=self.variable_name, optional=self.optional)
+
+    def __repr__(self):
+        return str(self)
+
+    def __str__(self):
+        return self.name
+
+
+@doctest_depends_on(modules=('matchpy',))
+class WildDot(_WildAbstract):
+    min_length = 1
+    fixed_size = True
+
+
+@doctest_depends_on(modules=('matchpy',))
+class WildPlus(_WildAbstract):
+    min_length = 1
+    fixed_size = False
+
+
+@doctest_depends_on(modules=('matchpy',))
+class WildStar(_WildAbstract):
+    min_length = 0
+    fixed_size = False
+
+
+def _get_srepr(expr):
+    s = srepr(expr)
+    s = re.sub(r"WildDot\('(\w+)'\)", r"\1", s)
+    s = re.sub(r"WildPlus\('(\w+)'\)", r"*\1", s)
+    s = re.sub(r"WildStar\('(\w+)'\)", r"*\1", s)
+    return s
+
+
+@doctest_depends_on(modules=('matchpy',))
+class Replacer:
+    """
+    Replacer object to perform multiple pattern matching and subexpression
+    replacements in SymPy expressions.
+
+    Examples
+    ========
+
+    Example to construct a simple first degree equation solver:
+
+    >>> from sympy.utilities.matchpy_connector import WildDot, Replacer
+    >>> from sympy import Equality, Symbol
+    >>> x = Symbol("x")
+    >>> a_ = WildDot("a_", optional=1)
+    >>> b_ = WildDot("b_", optional=0)
+
+    The lines above have defined two wildcards, ``a_`` and ``b_``, the
+    coefficients of the equation `a x + b = 0`. The optional values specified
+    indicate which expression to return in case no match is found, they are
+    necessary in equations like `a x = 0` and `x + b = 0`.
+
+    Create two constraints to make sure that ``a_`` and ``b_`` will not match
+    any expression containing ``x``:
+
+    >>> from matchpy import CustomConstraint
+    >>> free_x_a = CustomConstraint(lambda a_: not a_.has(x))
+    >>> free_x_b = CustomConstraint(lambda b_: not b_.has(x))
+
+    Now create the rule replacer with the constraints:
+
+    >>> replacer = Replacer(common_constraints=[free_x_a, free_x_b])
+
+    Add the matching rule:
+
+    >>> replacer.add(Equality(a_*x + b_, 0), -b_/a_)
+
+    Let's try it:
+
+    >>> replacer.replace(Equality(3*x + 4, 0))
+    -4/3
+
+    Notice that it will not match equations expressed with other patterns:
+
+    >>> eq = Equality(3*x, 4)
+    >>> replacer.replace(eq)
+    Eq(3*x, 4)
+
+    In order to extend the matching patterns, define another one (we also need
+    to clear the cache, because the previous result has already been memorized
+    and the pattern matcher will not iterate again if given the same expression)
+
+    >>> replacer.add(Equality(a_*x, b_), b_/a_)
+    >>> replacer._replacer.matcher.clear()
+    >>> replacer.replace(eq)
+    4/3
+    """
+
+    def __init__(self, common_constraints: list = []):
+        self._replacer = matchpy.ManyToOneReplacer()
+        self._common_constraint = common_constraints
+
+    def _get_lambda(self, lambda_str: str) -> Callable[..., Expr]:
+        exec("from sympy import *")
+        return eval(lambda_str, locals())
+
+    def _get_custom_constraint(self, constraint_expr: Expr, condition_template: str) -> Callable[..., Expr]:
+        wilds = [x.name for x in constraint_expr.atoms(_WildAbstract)]
+        lambdaargs = ', '.join(wilds)
+        fullexpr = _get_srepr(constraint_expr)
+        condition = condition_template.format(fullexpr)
+        return matchpy.CustomConstraint(
+            self._get_lambda(f"lambda {lambdaargs}: ({condition})"))
+
+    def _get_custom_constraint_nonfalse(self, constraint_expr: Expr) -> Callable[..., Expr]:
+        return self._get_custom_constraint(constraint_expr, "({}) != False")
+
+    def _get_custom_constraint_true(self, constraint_expr: Expr) -> Callable[..., Expr]:
+        return self._get_custom_constraint(constraint_expr, "({}) == True")
+
+    def add(self, expr: Expr, result: Expr, conditions_true: List[Expr] = [], conditions_nonfalse: List[Expr] = []) -> None:
+        expr = _sympify(expr)
+        result = _sympify(result)
+        lambda_str = f"lambda {', '.join((x.name for x in expr.atoms(_WildAbstract)))}: {_get_srepr(result)}"
+        lambda_expr = self._get_lambda(lambda_str)
+        constraints = self._common_constraint[:]
+        constraint_conditions_true = [
+            self._get_custom_constraint_true(cond) for cond in conditions_true]
+        constraint_conditions_nonfalse = [
+            self._get_custom_constraint_nonfalse(cond) for cond in conditions_nonfalse]
+        constraints.extend(constraint_conditions_true)
+        constraints.extend(constraint_conditions_nonfalse)
+        self._replacer.add(
+            matchpy.ReplacementRule(matchpy.Pattern(expr, *constraints), lambda_expr))
+
+    def replace(self, expr: Expr) -> Expr:
+        return self._replacer.replace(expr)

venv/lib/python3.10/site-packages/sympy/utilities/mathml/__init__.py

@@ -0,0 +1,79 @@
+"""Module with some functions for MathML, like transforming MathML
+content in MathML presentation.
+
+To use this module, you will need lxml.
+"""
+
+from sympy.utilities.pkgdata import get_resource
+from sympy.utilities.decorator import doctest_depends_on
+
+
+__doctest_requires__ = {('apply_xsl', 'c2p'): ['lxml']}
+
+
+def add_mathml_headers(s):
+    return """<math xmlns:mml="http://www.w3.org/1998/Math/MathML"
+      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+      xsi:schemaLocation="http://www.w3.org/1998/Math/MathML
+        http://www.w3.org/Math/XMLSchema/mathml2/mathml2.xsd">""" + s + "</math>"
+
+
+@doctest_depends_on(modules=('lxml',))
+def apply_xsl(mml, xsl):
+    """Apply a xsl to a MathML string.
+
+    Parameters
+    ==========
+
+    mml
+        A string with MathML code.
+    xsl
+        A string representing a path to a xsl (xml stylesheet) file.
+        This file name is relative to the PYTHONPATH.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.mathml import apply_xsl
+    >>> xsl = 'mathml/data/simple_mmlctop.xsl'
+    >>> mml = '<apply> <plus/> <ci>a</ci> <ci>b</ci> </apply>'
+    >>> res = apply_xsl(mml,xsl)
+    >>> ''.join(res.splitlines())
+    '<?xml version="1.0"?><mrow xmlns="http://www.w3.org/1998/Math/MathML">  <mi>a</mi>  <mo> + </mo>  <mi>b</mi></mrow>'
+    """
+    from lxml import etree
+
+    parser = etree.XMLParser(resolve_entities=False)
+    ac = etree.XSLTAccessControl.DENY_ALL
+
+    s = etree.XML(get_resource(xsl).read(), parser=parser)
+    transform = etree.XSLT(s, access_control=ac)
+    doc = etree.XML(mml, parser=parser)
+    result = transform(doc)
+    s = str(result)
+    return s
+
+
+@doctest_depends_on(modules=('lxml',))
+def c2p(mml, simple=False):
+    """Transforms a document in MathML content (like the one that sympy produces)
+    in one document in MathML presentation, more suitable for printing, and more
+    widely accepted
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.mathml import c2p
+    >>> mml = '<apply> <exp/> <cn>2</cn> </apply>'
+    >>> c2p(mml,simple=True) != c2p(mml,simple=False)
+    True
+
+    """
+
+    if not mml.startswith('<math'):
+        mml = add_mathml_headers(mml)
+
+    if simple:
+        return apply_xsl(mml, 'mathml/data/simple_mmlctop.xsl')
+
+    return apply_xsl(mml, 'mathml/data/mmlctop.xsl')

venv/lib/python3.10/site-packages/sympy/utilities/memoization.py

@@ -0,0 +1,59 @@
+from functools import wraps
+
+
+def recurrence_memo(initial):
+    """
+    Memo decorator for sequences defined by recurrence
+
+    See usage examples e.g. in the specfun/combinatorial module
+    """
+    cache = initial
+
+    def decorator(f):
+        @wraps(f)
+        def g(n):
+            L = len(cache)
+            if n <= L - 1:
+                return cache[n]
+            for i in range(L, n + 1):
+                cache.append(f(i, cache))
+            return cache[-1]
+        return g
+    return decorator
+
+
+def assoc_recurrence_memo(base_seq):
+    """
+    Memo decorator for associated sequences defined by recurrence starting from base
+
+    base_seq(n) -- callable to get base sequence elements
+
+    XXX works only for Pn0 = base_seq(0) cases
+    XXX works only for m <= n cases
+    """
+
+    cache = []
+
+    def decorator(f):
+        @wraps(f)
+        def g(n, m):
+            L = len(cache)
+            if n < L:
+                return cache[n][m]
+
+            for i in range(L, n + 1):
+                # get base sequence
+                F_i0 = base_seq(i)
+                F_i_cache = [F_i0]
+                cache.append(F_i_cache)
+
+                # XXX only works for m <= n cases
+                # generate assoc sequence
+                for j in range(1, i + 1):
+                    F_ij = f(i, j, cache)
+                    F_i_cache.append(F_ij)
+
+            return cache[n][m]
+
+        return g
+    return decorator

venv/lib/python3.10/site-packages/sympy/utilities/misc.py

@@ -0,0 +1,565 @@
+"""Miscellaneous stuff that does not really fit anywhere else."""
+
+from __future__ import annotations
+
+import operator
+import sys
+import os
+import re as _re
+import struct
+from textwrap import fill, dedent
+
+
+class Undecidable(ValueError):
+    # an error to be raised when a decision cannot be made definitively
+    # where a definitive answer is needed
+    pass
+
+
+def filldedent(s, w=70, **kwargs):
+    """
+    Strips leading and trailing empty lines from a copy of ``s``, then dedents,
+    fills and returns it.
+
+    Empty line stripping serves to deal with docstrings like this one that
+    start with a newline after the initial triple quote, inserting an empty
+    line at the beginning of the string.
+
+    Additional keyword arguments will be passed to ``textwrap.fill()``.
+
+    See Also
+    ========
+    strlines, rawlines
+
+    """
+    return '\n' + fill(dedent(str(s)).strip('\n'), width=w, **kwargs)
+
+
+def strlines(s, c=64, short=False):
+    """Return a cut-and-pastable string that, when printed, is
+    equivalent to the input.  The lines will be surrounded by
+    parentheses and no line will be longer than c (default 64)
+    characters. If the line contains newlines characters, the
+    `rawlines` result will be returned.  If ``short`` is True
+    (default is False) then if there is one line it will be
+    returned without bounding parentheses.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.misc import strlines
+    >>> q = 'this is a long string that should be broken into shorter lines'
+    >>> print(strlines(q, 40))
+    (
+    'this is a long string that should be b'
+    'roken into shorter lines'
+    )
+    >>> q == (
+    ... 'this is a long string that should be b'
+    ... 'roken into shorter lines'
+    ... )
+    True
+
+    See Also
+    ========
+    filldedent, rawlines
+    """
+    if not isinstance(s, str):
+        raise ValueError('expecting string input')
+    if '\n' in s:
+        return rawlines(s)
+    q = '"' if repr(s).startswith('"') else "'"
+    q = (q,)*2
+    if '\\' in s:  # use r-string
+        m = '(\nr%s%%s%s\n)' % q
+        j = '%s\nr%s' % q
+        c -= 3
+    else:
+        m = '(\n%s%%s%s\n)' % q
+        j = '%s\n%s' % q
+        c -= 2
+    out = []
+    while s:
+        out.append(s[:c])
+        s=s[c:]
+    if short and len(out) == 1:
+        return (m % out[0]).splitlines()[1]  # strip bounding (\n...\n)
+    return m % j.join(out)
+
+
+def rawlines(s):
+    """Return a cut-and-pastable string that, when printed, is equivalent
+    to the input. Use this when there is more than one line in the
+    string. The string returned is formatted so it can be indented
+    nicely within tests; in some cases it is wrapped in the dedent
+    function which has to be imported from textwrap.
+
+    Examples
+    ========
+
+    Note: because there are characters in the examples below that need
+    to be escaped because they are themselves within a triple quoted
+    docstring, expressions below look more complicated than they would
+    be if they were printed in an interpreter window.
+
+    >>> from sympy.utilities.misc import rawlines
+    >>> from sympy import TableForm
+    >>> s = str(TableForm([[1, 10]], headings=(None, ['a', 'bee'])))
+    >>> print(rawlines(s))
+    (
+        'a bee\\n'
+        '-----\\n'
+        '1 10 '
+    )
+    >>> print(rawlines('''this
+    ... that'''))
+    dedent('''\\
+        this
+        that''')
+
+    >>> print(rawlines('''this
+    ... that
+    ... '''))
+    dedent('''\\
+        this
+        that
+        ''')
+
+    >>> s = \"\"\"this
+    ... is a triple '''
+    ... \"\"\"
+    >>> print(rawlines(s))
+    dedent(\"\"\"\\
+        this
+        is a triple '''
+        \"\"\")
+
+    >>> print(rawlines('''this
+    ... that
+    ...     '''))
+    (
+        'this\\n'
+        'that\\n'
+        '    '
+    )
+
+    See Also
+    ========
+    filldedent, strlines
+    """
+    lines = s.split('\n')
+    if len(lines) == 1:
+        return repr(lines[0])
+    triple = ["'''" in s, '"""' in s]
+    if any(li.endswith(' ') for li in lines) or '\\' in s or all(triple):
+        rv = []
+        # add on the newlines
+        trailing = s.endswith('\n')
+        last = len(lines) - 1
+        for i, li in enumerate(lines):
+            if i != last or trailing:
+                rv.append(repr(li + '\n'))
+            else:
+                rv.append(repr(li))
+        return '(\n    %s\n)' % '\n    '.join(rv)
+    else:
+        rv = '\n    '.join(lines)
+        if triple[0]:
+            return 'dedent("""\\\n    %s""")' % rv
+        else:
+            return "dedent('''\\\n    %s''')" % rv
+
+ARCH = str(struct.calcsize('P') * 8) + "-bit"
+
+
+# XXX: PyPy does not support hash randomization
+HASH_RANDOMIZATION = getattr(sys.flags, 'hash_randomization', False)
+
+_debug_tmp: list[str] = []
+_debug_iter = 0
+
+def debug_decorator(func):
+    """If SYMPY_DEBUG is True, it will print a nice execution tree with
+    arguments and results of all decorated functions, else do nothing.
+    """
+    from sympy import SYMPY_DEBUG
+
+    if not SYMPY_DEBUG:
+        return func
+
+    def maketree(f, *args, **kw):
+        global _debug_tmp
+        global _debug_iter
+        oldtmp = _debug_tmp
+        _debug_tmp = []
+        _debug_iter += 1
+
+        def tree(subtrees):
+            def indent(s, variant=1):
+                x = s.split("\n")
+                r = "+-%s\n" % x[0]
+                for a in x[1:]:
+                    if a == "":
+                        continue
+                    if variant == 1:
+                        r += "| %s\n" % a
+                    else:
+                        r += "  %s\n" % a
+                return r
+            if len(subtrees) == 0:
+                return ""
+            f = []
+            for a in subtrees[:-1]:
+                f.append(indent(a))
+            f.append(indent(subtrees[-1], 2))
+            return ''.join(f)
+
+        # If there is a bug and the algorithm enters an infinite loop, enable the
+        # following lines. It will print the names and parameters of all major functions
+        # that are called, *before* they are called
+        #from functools import reduce
+        #print("%s%s %s%s" % (_debug_iter, reduce(lambda x, y: x + y, \
+        #    map(lambda x: '-', range(1, 2 + _debug_iter))), f.__name__, args))
+
+        r = f(*args, **kw)
+
+        _debug_iter -= 1
+        s = "%s%s = %s\n" % (f.__name__, args, r)
+        if _debug_tmp != []:
+            s += tree(_debug_tmp)
+        _debug_tmp = oldtmp
+        _debug_tmp.append(s)
+        if _debug_iter == 0:
+            print(_debug_tmp[0])
+            _debug_tmp = []
+        return r
+
+    def decorated(*args, **kwargs):
+        return maketree(func, *args, **kwargs)
+
+    return decorated
+
+
+def debug(*args):
+    """
+    Print ``*args`` if SYMPY_DEBUG is True, else do nothing.
+    """
+    from sympy import SYMPY_DEBUG
+    if SYMPY_DEBUG:
+        print(*args, file=sys.stderr)
+
+
+def debugf(string, args):
+    """
+    Print ``string%args`` if SYMPY_DEBUG is True, else do nothing. This is
+    intended for debug messages using formatted strings.
+    """
+    from sympy import SYMPY_DEBUG
+    if SYMPY_DEBUG:
+        print(string%args, file=sys.stderr)
+
+
+def find_executable(executable, path=None):
+    """Try to find 'executable' in the directories listed in 'path' (a
+    string listing directories separated by 'os.pathsep'; defaults to
+    os.environ['PATH']).  Returns the complete filename or None if not
+    found
+    """
+    from .exceptions import sympy_deprecation_warning
+    sympy_deprecation_warning(
+        """
+        sympy.utilities.misc.find_executable() is deprecated. Use the standard
+        library shutil.which() function instead.
+        """,
+        deprecated_since_version="1.7",
+        active_deprecations_target="deprecated-find-executable",
+    )
+    if path is None:
+        path = os.environ['PATH']
+    paths = path.split(os.pathsep)
+    extlist = ['']
+    if os.name == 'os2':
+        (base, ext) = os.path.splitext(executable)
+        # executable files on OS/2 can have an arbitrary extension, but
+        # .exe is automatically appended if no dot is present in the name
+        if not ext:
+            executable = executable + ".exe"
+    elif sys.platform == 'win32':
+        pathext = os.environ['PATHEXT'].lower().split(os.pathsep)
+        (base, ext) = os.path.splitext(executable)
+        if ext.lower() not in pathext:
+            extlist = pathext
+    for ext in extlist:
+        execname = executable + ext
+        if os.path.isfile(execname):
+            return execname
+        else:
+            for p in paths:
+                f = os.path.join(p, execname)
+                if os.path.isfile(f):
+                    return f
+
+    return None
+
+
+def func_name(x, short=False):
+    """Return function name of `x` (if defined) else the `type(x)`.
+    If short is True and there is a shorter alias for the result,
+    return the alias.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.misc import func_name
+    >>> from sympy import Matrix
+    >>> from sympy.abc import x
+    >>> func_name(Matrix.eye(3))
+    'MutableDenseMatrix'
+    >>> func_name(x < 1)
+    'StrictLessThan'
+    >>> func_name(x < 1, short=True)
+    'Lt'
+    """
+    alias = {
+    'GreaterThan': 'Ge',
+    'StrictGreaterThan': 'Gt',
+    'LessThan': 'Le',
+    'StrictLessThan': 'Lt',
+    'Equality': 'Eq',
+    'Unequality': 'Ne',
+    }
+    typ = type(x)
+    if str(typ).startswith("<type '"):
+        typ = str(typ).split("'")[1].split("'")[0]
+    elif str(typ).startswith("<class '"):
+        typ = str(typ).split("'")[1].split("'")[0]
+    rv = getattr(getattr(x, 'func', x), '__name__', typ)
+    if '.' in rv:
+        rv = rv.split('.')[-1]
+    if short:
+        rv = alias.get(rv, rv)
+    return rv
+
+
+def _replace(reps):
+    """Return a function that can make the replacements, given in
+    ``reps``, on a string. The replacements should be given as mapping.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.misc import _replace
+    >>> f = _replace(dict(foo='bar', d='t'))
+    >>> f('food')
+    'bart'
+    >>> f = _replace({})
+    >>> f('food')
+    'food'
+    """
+    if not reps:
+        return lambda x: x
+    D = lambda match: reps[match.group(0)]
+    pattern = _re.compile("|".join(
+        [_re.escape(k) for k, v in reps.items()]), _re.M)
+    return lambda string: pattern.sub(D, string)
+
+
+def replace(string, *reps):
+    """Return ``string`` with all keys in ``reps`` replaced with
+    their corresponding values, longer strings first, irrespective
+    of the order they are given.  ``reps`` may be passed as tuples
+    or a single mapping.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.misc import replace
+    >>> replace('foo', {'oo': 'ar', 'f': 'b'})
+    'bar'
+    >>> replace("spamham sha", ("spam", "eggs"), ("sha","md5"))
+    'eggsham md5'
+
+    There is no guarantee that a unique answer will be
+    obtained if keys in a mapping overlap (i.e. are the same
+    length and have some identical sequence at the
+    beginning/end):
+
+    >>> reps = [
+    ...     ('ab', 'x'),
+    ...     ('bc', 'y')]
+    >>> replace('abc', *reps) in ('xc', 'ay')
+    True
+
+    References
+    ==========
+
+    .. [1] https://stackoverflow.com/questions/6116978/how-to-replace-multiple-substrings-of-a-string
+    """
+    if len(reps) == 1:
+        kv = reps[0]
+        if isinstance(kv, dict):
+            reps = kv
+        else:
+            return string.replace(*kv)
+    else:
+        reps = dict(reps)
+    return _replace(reps)(string)
+
+
+def translate(s, a, b=None, c=None):
+    """Return ``s`` where characters have been replaced or deleted.
+
+    SYNTAX
+    ======
+
+    translate(s, None, deletechars):
+        all characters in ``deletechars`` are deleted
+    translate(s, map [,deletechars]):
+        all characters in ``deletechars`` (if provided) are deleted
+        then the replacements defined by map are made; if the keys
+        of map are strings then the longer ones are handled first.
+        Multicharacter deletions should have a value of ''.
+    translate(s, oldchars, newchars, deletechars)
+        all characters in ``deletechars`` are deleted
+        then each character in ``oldchars`` is replaced with the
+        corresponding character in ``newchars``
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.misc import translate
+    >>> abc = 'abc'
+    >>> translate(abc, None, 'a')
+    'bc'
+    >>> translate(abc, {'a': 'x'}, 'c')
+    'xb'
+    >>> translate(abc, {'abc': 'x', 'a': 'y'})
+    'x'
+
+    >>> translate('abcd', 'ac', 'AC', 'd')
+    'AbC'
+
+    There is no guarantee that a unique answer will be
+    obtained if keys in a mapping overlap are the same
+    length and have some identical sequences at the
+    beginning/end:
+
+    >>> translate(abc, {'ab': 'x', 'bc': 'y'}) in ('xc', 'ay')
+    True
+    """
+
+    mr = {}
+    if a is None:
+        if c is not None:
+            raise ValueError('c should be None when a=None is passed, instead got %s' % c)
+        if b is None:
+            return s
+        c = b
+        a = b = ''
+    else:
+        if isinstance(a, dict):
+            short = {}
+            for k in list(a.keys()):
+                if len(k) == 1 and len(a[k]) == 1:
+                    short[k] = a.pop(k)
+            mr = a
+            c = b
+            if short:
+                a, b = [''.join(i) for i in list(zip(*short.items()))]
+            else:
+                a = b = ''
+        elif len(a) != len(b):
+            raise ValueError('oldchars and newchars have different lengths')
+
+    if c:
+        val = str.maketrans('', '', c)
+        s = s.translate(val)
+    s = replace(s, mr)
+    n = str.maketrans(a, b)
+    return s.translate(n)
+
+
+def ordinal(num):
+    """Return ordinal number string of num, e.g. 1 becomes 1st.
+    """
+    # modified from https://codereview.stackexchange.com/questions/41298/producing-ordinal-numbers
+    n = as_int(num)
+    k = abs(n) % 100
+    if 11 <= k <= 13:
+        suffix = 'th'
+    elif k % 10 == 1:
+        suffix = 'st'
+    elif k % 10 == 2:
+        suffix = 'nd'
+    elif k % 10 == 3:
+        suffix = 'rd'
+    else:
+        suffix = 'th'
+    return str(n) + suffix
+
+
+def as_int(n, strict=True):
+    """
+    Convert the argument to a builtin integer.
+
+    The return value is guaranteed to be equal to the input. ValueError is
+    raised if the input has a non-integral value. When ``strict`` is True, this
+    uses `__index__ <https://docs.python.org/3/reference/datamodel.html#object.__index__>`_
+    and when it is False it uses ``int``.
+
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.misc import as_int
+    >>> from sympy import sqrt, S
+
+    The function is primarily concerned with sanitizing input for
+    functions that need to work with builtin integers, so anything that
+    is unambiguously an integer should be returned as an int:
+
+    >>> as_int(S(3))
+    3
+
+    Floats, being of limited precision, are not assumed to be exact and
+    will raise an error unless the ``strict`` flag is False. This
+    precision issue becomes apparent for large floating point numbers:
+
+    >>> big = 1e23
+    >>> type(big) is float
+    True
+    >>> big == int(big)
+    True
+    >>> as_int(big)
+    Traceback (most recent call last):
+    ...
+    ValueError: ... is not an integer
+    >>> as_int(big, strict=False)
+    99999999999999991611392
+
+    Input that might be a complex representation of an integer value is
+    also rejected by default:
+
+    >>> one = sqrt(3 + 2*sqrt(2)) - sqrt(2)
+    >>> int(one) == 1
+    True
+    >>> as_int(one)
+    Traceback (most recent call last):
+    ...
+    ValueError: ... is not an integer
+    """
+    if strict:
+        try:
+            if isinstance(n, bool):
+                raise TypeError
+            return operator.index(n)
+        except TypeError:
+            raise ValueError('%s is not an integer' % (n,))
+    else:
+        try:
+            result = int(n)
+        except TypeError:
+            raise ValueError('%s is not an integer' % (n,))
+        if n != result:
+            raise ValueError('%s is not an integer' % (n,))
+        return result

venv/lib/python3.10/site-packages/sympy/utilities/pkgdata.py

@@ -0,0 +1,56 @@
+"""
+pkgdata is a simple, extensible way for a package to acquire data file
+resources.
+
+The getResource function is equivalent to the standard idioms, such as
+the following minimal implementation::
+
+    import sys, os
+
+    def getResource(identifier, pkgname=__name__):
+        pkgpath = os.path.dirname(sys.modules[pkgname].__file__)
+        path = os.path.join(pkgpath, identifier)
+        return open(os.path.normpath(path), mode='rb')
+
+When a __loader__ is present on the module given by __name__, it will defer
+getResource to its get_data implementation and return it as a file-like
+object (such as StringIO).
+"""
+
+import sys
+import os
+from io import StringIO
+
+
+def get_resource(identifier, pkgname=__name__):
+    """
+    Acquire a readable object for a given package name and identifier.
+    An IOError will be raised if the resource cannot be found.
+
+    For example::
+
+        mydata = get_resource('mypkgdata.jpg').read()
+
+    Note that the package name must be fully qualified, if given, such
+    that it would be found in sys.modules.
+
+    In some cases, getResource will return a real file object.  In that
+    case, it may be useful to use its name attribute to get the path
+    rather than use it as a file-like object.  For example, you may
+    be handing data off to a C API.
+    """
+
+    mod = sys.modules[pkgname]
+    fn = getattr(mod, '__file__', None)
+    if fn is None:
+        raise OSError("%r has no __file__!")
+    path = os.path.join(os.path.dirname(fn), identifier)
+    loader = getattr(mod, '__loader__', None)
+    if loader is not None:
+        try:
+            data = loader.get_data(path)
+        except (OSError, AttributeError):
+            pass
+        else:
+            return StringIO(data.decode('utf-8'))
+    return open(os.path.normpath(path), 'rb')

venv/lib/python3.10/site-packages/sympy/utilities/pytest.py

@@ -0,0 +1,12 @@
+"""
+.. deprecated:: 1.6
+
+   sympy.utilities.pytest has been renamed to sympy.testing.pytest.
+"""
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+sympy_deprecation_warning("The sympy.utilities.pytest submodule is deprecated. Use sympy.testing.pytest instead.",
+    deprecated_since_version="1.6",
+    active_deprecations_target="deprecated-sympy-utilities-submodules")
+
+from sympy.testing.pytest import *  # noqa:F401

venv/lib/python3.10/site-packages/sympy/utilities/randtest.py

@@ -0,0 +1,12 @@
+"""
+.. deprecated:: 1.6
+
+   sympy.utilities.randtest has been renamed to sympy.core.random.
+"""
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+sympy_deprecation_warning("The sympy.utilities.randtest submodule is deprecated. Use sympy.core.random instead.",
+    deprecated_since_version="1.6",
+    active_deprecations_target="deprecated-sympy-utilities-submodules")
+
+from sympy.core.random import *  # noqa:F401

venv/lib/python3.10/site-packages/sympy/utilities/runtests.py

@@ -0,0 +1,13 @@
+"""
+.. deprecated:: 1.6
+
+   sympy.utilities.runtests has been renamed to sympy.testing.runtests.
+"""
+
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+sympy_deprecation_warning("The sympy.utilities.runtests submodule is deprecated. Use sympy.testing.runtests instead.",
+    deprecated_since_version="1.6",
+    active_deprecations_target="deprecated-sympy-utilities-submodules")
+
+from sympy.testing.runtests import *  # noqa:F401

venv/lib/python3.10/site-packages/sympy/utilities/source.py

@@ -0,0 +1,40 @@
+"""
+This module adds several functions for interactive source code inspection.
+"""
+
+
+def get_class(lookup_view):
+    """
+    Convert a string version of a class name to the object.
+
+    For example, get_class('sympy.core.Basic') will return
+    class Basic located in module sympy.core
+    """
+    if isinstance(lookup_view, str):
+        mod_name, func_name = get_mod_func(lookup_view)
+        if func_name != '':
+            lookup_view = getattr(
+                __import__(mod_name, {}, {}, ['*']), func_name)
+            if not callable(lookup_view):
+                raise AttributeError(
+                    "'%s.%s' is not a callable." % (mod_name, func_name))
+    return lookup_view
+
+
+def get_mod_func(callback):
+    """
+    splits the string path to a class into a string path to the module
+    and the name of the class.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.source import get_mod_func
+    >>> get_mod_func('sympy.core.basic.Basic')
+    ('sympy.core.basic', 'Basic')
+
+    """
+    dot = callback.rfind('.')
+    if dot == -1:
+        return callback, ''
+    return callback[:dot], callback[dot + 1:]