Add files using upload-large-folder tool

.venv/lib/python3.13/site-packages/sympy/testing/tests/test_code_quality.py

@@ -0,0 +1,510 @@
+# coding=utf-8
+from os import walk, sep, pardir
+from os.path import split, join, abspath, exists, isfile
+from glob import glob
+import re
+import random
+import ast
+
+from sympy.testing.pytest import raises
+from sympy.testing.quality_unicode import _test_this_file_encoding
+
+# System path separator (usually slash or backslash) to be
+# used with excluded files, e.g.
+#     exclude = set([
+#                    "%(sep)smpmath%(sep)s" % sepd,
+#                   ])
+sepd = {"sep": sep}
+
+# path and sympy_path
+SYMPY_PATH = abspath(join(split(__file__)[0], pardir, pardir))  # go to sympy/
+assert exists(SYMPY_PATH)
+
+TOP_PATH = abspath(join(SYMPY_PATH, pardir))
+BIN_PATH = join(TOP_PATH, "bin")
+EXAMPLES_PATH = join(TOP_PATH, "examples")
+
+# Error messages
+message_space = "File contains trailing whitespace: %s, line %s."
+message_implicit = "File contains an implicit import: %s, line %s."
+message_tabs = "File contains tabs instead of spaces: %s, line %s."
+message_carriage = "File contains carriage returns at end of line: %s, line %s"
+message_str_raise = "File contains string exception: %s, line %s"
+message_gen_raise = "File contains generic exception: %s, line %s"
+message_old_raise = "File contains old-style raise statement: %s, line %s, \"%s\""
+message_eof = "File does not end with a newline: %s, line %s"
+message_multi_eof = "File ends with more than 1 newline: %s, line %s"
+message_test_suite_def = "Function should start with 'test_' or '_': %s, line %s"
+message_duplicate_test = "This is a duplicate test function: %s, line %s"
+message_self_assignments = "File contains assignments to self/cls: %s, line %s."
+message_func_is = "File contains '.func is': %s, line %s."
+message_bare_expr = "File contains bare expression: %s, line %s."
+
+implicit_test_re = re.compile(r'^\s*(>>> )?(\.\.\. )?from .* import .*\*')
+str_raise_re = re.compile(
+    r'^\s*(>>> )?(\.\.\. )?raise(\s+(\'|\")|\s*(\(\s*)+(\'|\"))')
+gen_raise_re = re.compile(
+    r'^\s*(>>> )?(\.\.\. )?raise(\s+Exception|\s*(\(\s*)+Exception)')
+old_raise_re = re.compile(r'^\s*(>>> )?(\.\.\. )?raise((\s*\(\s*)|\s+)\w+\s*,')
+test_suite_def_re = re.compile(r'^def\s+(?!(_|test))[^(]*\(\s*\)\s*:$')
+test_ok_def_re = re.compile(r'^def\s+test_.*:$')
+test_file_re = re.compile(r'.*[/\\]test_.*\.py$')
+func_is_re = re.compile(r'\.\s*func\s+is')
+
+
+def tab_in_leading(s):
+    """Returns True if there are tabs in the leading whitespace of a line,
+    including the whitespace of docstring code samples."""
+    n = len(s) - len(s.lstrip())
+    if not s[n:n + 3] in ['...', '>>>']:
+        check = s[:n]
+    else:
+        smore = s[n + 3:]
+        check = s[:n] + smore[:len(smore) - len(smore.lstrip())]
+    return not (check.expandtabs() == check)
+
+
+def find_self_assignments(s):
+    """Returns a list of "bad" assignments: if there are instances
+    of assigning to the first argument of the class method (except
+    for staticmethod's).
+    """
+    t = [n for n in ast.parse(s).body if isinstance(n, ast.ClassDef)]
+
+    bad = []
+    for c in t:
+        for n in c.body:
+            if not isinstance(n, ast.FunctionDef):
+                continue
+            if any(d.id == 'staticmethod'
+                   for d in n.decorator_list if isinstance(d, ast.Name)):
+                continue
+            if n.name == '__new__':
+                continue
+            if not n.args.args:
+                continue
+            first_arg = n.args.args[0].arg
+
+            for m in ast.walk(n):
+                if isinstance(m, ast.Assign):
+                    for a in m.targets:
+                        if isinstance(a, ast.Name) and a.id == first_arg:
+                            bad.append(m)
+                        elif (isinstance(a, ast.Tuple) and
+                              any(q.id == first_arg for q in a.elts
+                                  if isinstance(q, ast.Name))):
+                            bad.append(m)
+
+    return bad
+
+
+def check_directory_tree(base_path, file_check, exclusions=set(), pattern="*.py"):
+    """
+    Checks all files in the directory tree (with base_path as starting point)
+    with the file_check function provided, skipping files that contain
+    any of the strings in the set provided by exclusions.
+    """
+    if not base_path:
+        return
+    for root, dirs, files in walk(base_path):
+        check_files(glob(join(root, pattern)), file_check, exclusions)
+
+
+def check_files(files, file_check, exclusions=set(), pattern=None):
+    """
+    Checks all files with the file_check function provided, skipping files
+    that contain any of the strings in the set provided by exclusions.
+    """
+    if not files:
+        return
+    for fname in files:
+        if not exists(fname) or not isfile(fname):
+            continue
+        if any(ex in fname for ex in exclusions):
+            continue
+        if pattern is None or re.match(pattern, fname):
+            file_check(fname)
+
+
+class _Visit(ast.NodeVisitor):
+    """return the line number corresponding to the
+    line on which a bare expression appears if it is a binary op
+    or a comparison that is not in a with block.
+
+    EXAMPLES
+    ========
+
+    >>> import ast
+    >>> class _Visit(ast.NodeVisitor):
+    ...     def visit_Expr(self, node):
+    ...         if isinstance(node.value, (ast.BinOp, ast.Compare)):
+    ...             print(node.lineno)
+    ...     def visit_With(self, node):
+    ...         pass  # no checking there
+    ...
+    >>> code='''x = 1    # line 1
+    ... for i in range(3):
+    ...     x == 2       # <-- 3
+    ... if x == 2:
+    ...     x == 3       # <-- 5
+    ...     x + 1        # <-- 6
+    ...     x = 1
+    ...     if x == 1:
+    ...         print(1)
+    ... while x != 1:
+    ...     x == 1       # <-- 11
+    ... with raises(TypeError):
+    ...     c == 1
+    ...     raise TypeError
+    ... assert x == 1
+    ... '''
+    >>> _Visit().visit(ast.parse(code))
+    3
+    5
+    6
+    11
+    """
+    def visit_Expr(self, node):
+        if isinstance(node.value, (ast.BinOp, ast.Compare)):
+            assert None, message_bare_expr % ('', node.lineno)
+    def visit_With(self, node):
+        pass
+
+
+BareExpr = _Visit()
+
+
+def line_with_bare_expr(code):
+    """return None or else 0-based line number of code on which
+    a bare expression appeared.
+    """
+    tree = ast.parse(code)
+    try:
+        BareExpr.visit(tree)
+    except AssertionError as msg:
+        assert msg.args
+        msg = msg.args[0]
+        assert msg.startswith(message_bare_expr.split(':', 1)[0])
+        return int(msg.rsplit(' ', 1)[1].rstrip('.'))  # the line number
+
+
+def test_files():
+    """
+    This test tests all files in SymPy and checks that:
+      o no lines contains a trailing whitespace
+      o no lines end with \r\n
+      o no line uses tabs instead of spaces
+      o that the file ends with a single newline
+      o there are no general or string exceptions
+      o there are no old style raise statements
+      o name of arg-less test suite functions start with _ or test_
+      o no duplicate function names that start with test_
+      o no assignments to self variable in class methods
+      o no lines contain ".func is" except in the test suite
+      o there is no do-nothing expression like `a == b` or `x + 1`
+    """
+
+    def test(fname):
+        with open(fname, encoding="utf8") as test_file:
+            test_this_file(fname, test_file)
+        with open(fname, encoding='utf8') as test_file:
+            _test_this_file_encoding(fname, test_file)
+
+    def test_this_file(fname, test_file):
+        idx = None
+        code = test_file.read()
+        test_file.seek(0)  # restore reader to head
+        py = fname if sep not in fname else fname.rsplit(sep, 1)[-1]
+        if py.startswith('test_'):
+            idx = line_with_bare_expr(code)
+        if idx is not None:
+            assert False, message_bare_expr % (fname, idx + 1)
+
+        line = None  # to flag the case where there were no lines in file
+        tests = 0
+        test_set = set()
+        for idx, line in enumerate(test_file):
+            if test_file_re.match(fname):
+                if test_suite_def_re.match(line):
+                    assert False, message_test_suite_def % (fname, idx + 1)
+                if test_ok_def_re.match(line):
+                    tests += 1
+                    test_set.add(line[3:].split('(')[0].strip())
+                    if len(test_set) != tests:
+                        assert False, message_duplicate_test % (fname, idx + 1)
+            if line.endswith((" \n", "\t\n")):
+                assert False, message_space % (fname, idx + 1)
+            if line.endswith("\r\n"):
+                assert False, message_carriage % (fname, idx + 1)
+            if tab_in_leading(line):
+                assert False, message_tabs % (fname, idx + 1)
+            if str_raise_re.search(line):
+                assert False, message_str_raise % (fname, idx + 1)
+            if gen_raise_re.search(line):
+                assert False, message_gen_raise % (fname, idx + 1)
+            if (implicit_test_re.search(line) and
+                    not list(filter(lambda ex: ex in fname, import_exclude))):
+                assert False, message_implicit % (fname, idx + 1)
+            if func_is_re.search(line) and not test_file_re.search(fname):
+                assert False, message_func_is % (fname, idx + 1)
+
+            result = old_raise_re.search(line)
+
+            if result is not None:
+                assert False, message_old_raise % (
+                    fname, idx + 1, result.group(2))
+
+        if line is not None:
+            if line == '\n' and idx > 0:
+                assert False, message_multi_eof % (fname, idx + 1)
+            elif not line.endswith('\n'):
+                # eof newline check
+                assert False, message_eof % (fname, idx + 1)
+
+
+    # Files to test at top level
+    top_level_files = [join(TOP_PATH, file) for file in [
+        "isympy.py",
+        "build.py",
+        "setup.py",
+    ]]
+    # Files to exclude from all tests
+    exclude = {
+        "%(sep)ssympy%(sep)sparsing%(sep)sautolev%(sep)s_antlr%(sep)sautolevparser.py" % sepd,
+        "%(sep)ssympy%(sep)sparsing%(sep)sautolev%(sep)s_antlr%(sep)sautolevlexer.py" % sepd,
+        "%(sep)ssympy%(sep)sparsing%(sep)sautolev%(sep)s_antlr%(sep)sautolevlistener.py" % sepd,
+        "%(sep)ssympy%(sep)sparsing%(sep)slatex%(sep)s_antlr%(sep)slatexparser.py" % sepd,
+        "%(sep)ssympy%(sep)sparsing%(sep)slatex%(sep)s_antlr%(sep)slatexlexer.py" % sepd,
+    }
+    # Files to exclude from the implicit import test
+    import_exclude = {
+        # glob imports are allowed in top-level __init__.py:
+        "%(sep)ssympy%(sep)s__init__.py" % sepd,
+        # these __init__.py should be fixed:
+        # XXX: not really, they use useful import pattern (DRY)
+        "%(sep)svector%(sep)s__init__.py" % sepd,
+        "%(sep)smechanics%(sep)s__init__.py" % sepd,
+        "%(sep)squantum%(sep)s__init__.py" % sepd,
+        "%(sep)spolys%(sep)s__init__.py" % sepd,
+        "%(sep)spolys%(sep)sdomains%(sep)s__init__.py" % sepd,
+        # interactive SymPy executes ``from sympy import *``:
+        "%(sep)sinteractive%(sep)ssession.py" % sepd,
+        # isympy.py executes ``from sympy import *``:
+        "%(sep)sisympy.py" % sepd,
+        # these two are import timing tests:
+        "%(sep)sbin%(sep)ssympy_time.py" % sepd,
+        "%(sep)sbin%(sep)ssympy_time_cache.py" % sepd,
+        # Taken from Python stdlib:
+        "%(sep)sparsing%(sep)ssympy_tokenize.py" % sepd,
+        # this one should be fixed:
+        "%(sep)splotting%(sep)spygletplot%(sep)s" % sepd,
+        # False positive in the docstring
+        "%(sep)sbin%(sep)stest_external_imports.py" % sepd,
+        "%(sep)sbin%(sep)stest_submodule_imports.py" % sepd,
+        # These are deprecated stubs that can be removed at some point:
+        "%(sep)sutilities%(sep)sruntests.py" % sepd,
+        "%(sep)sutilities%(sep)spytest.py" % sepd,
+        "%(sep)sutilities%(sep)srandtest.py" % sepd,
+        "%(sep)sutilities%(sep)stmpfiles.py" % sepd,
+        "%(sep)sutilities%(sep)squality_unicode.py" % sepd,
+    }
+    check_files(top_level_files, test)
+    check_directory_tree(BIN_PATH, test, {"~", ".pyc", ".sh"}, "*")
+    check_directory_tree(SYMPY_PATH, test, exclude)
+    check_directory_tree(EXAMPLES_PATH, test, exclude)
+
+
+def _with_space(c):
+    # return c with a random amount of leading space
+    return random.randint(0, 10)*' ' + c
+
+
+def test_raise_statement_regular_expression():
+    candidates_ok = [
+        "some text # raise Exception, 'text'",
+        "raise ValueError('text') # raise Exception, 'text'",
+        "raise ValueError('text')",
+        "raise ValueError",
+        "raise ValueError('text')",
+        "raise ValueError('text') #,",
+        # Talking about an exception in a docstring
+        ''''"""This function will raise ValueError, except when it doesn't"""''',
+        "raise (ValueError('text')",
+    ]
+    str_candidates_fail = [
+        "raise 'exception'",
+        "raise 'Exception'",
+        'raise "exception"',
+        'raise "Exception"',
+        "raise 'ValueError'",
+    ]
+    gen_candidates_fail = [
+        "raise Exception('text') # raise Exception, 'text'",
+        "raise Exception('text')",
+        "raise Exception",
+        "raise Exception('text')",
+        "raise Exception('text') #,",
+        "raise Exception, 'text'",
+        "raise Exception, 'text' # raise Exception('text')",
+        "raise Exception, 'text' # raise Exception, 'text'",
+        ">>> raise Exception, 'text'",
+        ">>> raise Exception, 'text' # raise Exception('text')",
+        ">>> raise Exception, 'text' # raise Exception, 'text'",
+    ]
+    old_candidates_fail = [
+        "raise Exception, 'text'",
+        "raise Exception, 'text' # raise Exception('text')",
+        "raise Exception, 'text' # raise Exception, 'text'",
+        ">>> raise Exception, 'text'",
+        ">>> raise Exception, 'text' # raise Exception('text')",
+        ">>> raise Exception, 'text' # raise Exception, 'text'",
+        "raise ValueError, 'text'",
+        "raise ValueError, 'text' # raise Exception('text')",
+        "raise ValueError, 'text' # raise Exception, 'text'",
+        ">>> raise ValueError, 'text'",
+        ">>> raise ValueError, 'text' # raise Exception('text')",
+        ">>> raise ValueError, 'text' # raise Exception, 'text'",
+        "raise(ValueError,",
+        "raise (ValueError,",
+        "raise( ValueError,",
+        "raise ( ValueError,",
+        "raise(ValueError ,",
+        "raise (ValueError ,",
+        "raise( ValueError ,",
+        "raise ( ValueError ,",
+    ]
+
+    for c in candidates_ok:
+        assert str_raise_re.search(_with_space(c)) is None, c
+        assert gen_raise_re.search(_with_space(c)) is None, c
+        assert old_raise_re.search(_with_space(c)) is None, c
+    for c in str_candidates_fail:
+        assert str_raise_re.search(_with_space(c)) is not None, c
+    for c in gen_candidates_fail:
+        assert gen_raise_re.search(_with_space(c)) is not None, c
+    for c in old_candidates_fail:
+        assert old_raise_re.search(_with_space(c)) is not None, c
+
+
+def test_implicit_imports_regular_expression():
+    candidates_ok = [
+        "from sympy import something",
+        ">>> from sympy import something",
+        "from sympy.somewhere import something",
+        ">>> from sympy.somewhere import something",
+        "import sympy",
+        ">>> import sympy",
+        "import sympy.something.something",
+        "... import sympy",
+        "... import sympy.something.something",
+        "... from sympy import something",
+        "... from sympy.somewhere import something",
+        ">> from sympy import *",  # To allow 'fake' docstrings
+        "# from sympy import *",
+        "some text # from sympy import *",
+    ]
+    candidates_fail = [
+        "from sympy import *",
+        ">>> from sympy import *",
+        "from sympy.somewhere import *",
+        ">>> from sympy.somewhere import *",
+        "... from sympy import *",
+        "... from sympy.somewhere import *",
+    ]
+    for c in candidates_ok:
+        assert implicit_test_re.search(_with_space(c)) is None, c
+    for c in candidates_fail:
+        assert implicit_test_re.search(_with_space(c)) is not None, c
+
+
+def test_test_suite_defs():
+    candidates_ok = [
+        "    def foo():\n",
+        "def foo(arg):\n",
+        "def _foo():\n",
+        "def test_foo():\n",
+    ]
+    candidates_fail = [
+        "def foo():\n",
+        "def foo() :\n",
+        "def foo( ):\n",
+        "def  foo():\n",
+    ]
+    for c in candidates_ok:
+        assert test_suite_def_re.search(c) is None, c
+    for c in candidates_fail:
+        assert test_suite_def_re.search(c) is not None, c
+
+
+def test_test_duplicate_defs():
+    candidates_ok = [
+        "def foo():\ndef foo():\n",
+        "def test():\ndef test_():\n",
+        "def test_():\ndef test__():\n",
+    ]
+    candidates_fail = [
+        "def test_():\ndef test_ ():\n",
+        "def test_1():\ndef  test_1():\n",
+    ]
+    ok = (None, 'check')
+    def check(file):
+        tests = 0
+        test_set = set()
+        for idx, line in enumerate(file.splitlines()):
+            if test_ok_def_re.match(line):
+                tests += 1
+                test_set.add(line[3:].split('(')[0].strip())
+                if len(test_set) != tests:
+                    return False, message_duplicate_test % ('check', idx + 1)
+        return None, 'check'
+    for c in candidates_ok:
+        assert check(c) == ok
+    for c in candidates_fail:
+        assert check(c) != ok
+
+
+def test_find_self_assignments():
+    candidates_ok = [
+        "class A(object):\n    def foo(self, arg): arg = self\n",
+        "class A(object):\n    def foo(self, arg): self.prop = arg\n",
+        "class A(object):\n    def foo(self, arg): obj, obj2 = arg, self\n",
+        "class A(object):\n    @classmethod\n    def bar(cls, arg): arg = cls\n",
+        "class A(object):\n    def foo(var, arg): arg = var\n",
+    ]
+    candidates_fail = [
+        "class A(object):\n    def foo(self, arg): self = arg\n",
+        "class A(object):\n    def foo(self, arg): obj, self = arg, arg\n",
+        "class A(object):\n    def foo(self, arg):\n        if arg: self = arg",
+        "class A(object):\n    @classmethod\n    def foo(cls, arg): cls = arg\n",
+        "class A(object):\n    def foo(var, arg): var = arg\n",
+    ]
+
+    for c in candidates_ok:
+        assert find_self_assignments(c) == []
+    for c in candidates_fail:
+        assert find_self_assignments(c) != []
+
+
+def test_test_unicode_encoding():
+    unicode_whitelist = ['foo']
+    unicode_strict_whitelist = ['bar']
+
+    fname = 'abc'
+    test_file = ['α']
+    raises(AssertionError, lambda: _test_this_file_encoding(
+        fname, test_file, unicode_whitelist, unicode_strict_whitelist))
+
+    fname = 'abc'
+    test_file = ['abc']
+    _test_this_file_encoding(
+        fname, test_file, unicode_whitelist, unicode_strict_whitelist)
+
+    fname = 'foo'
+    test_file = ['abc']
+    raises(AssertionError, lambda: _test_this_file_encoding(
+        fname, test_file, unicode_whitelist, unicode_strict_whitelist))
+
+    fname = 'bar'
+    test_file = ['abc']
+    _test_this_file_encoding(
+        fname, test_file, unicode_whitelist, unicode_strict_whitelist)

.venv/lib/python3.13/site-packages/sympy/testing/tests/test_deprecated.py

@@ -0,0 +1,5 @@
+from sympy.testing.pytest import warns_deprecated_sympy
+
+def test_deprecated_testing_randtest():
+    with warns_deprecated_sympy():
+        import sympy.testing.randtest  # noqa:F401

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

@@ -0,0 +1,122 @@
+"""Module with some functions for MathML, like transforming MathML
+content in MathML presentation.
+
+To use this module, you will need lxml.
+"""
+
+from pathlib import Path
+
+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>"
+
+
+def _read_binary(pkgname, filename):
+    import sys
+
+    if sys.version_info >= (3, 10):
+        # files was added in Python 3.9 but only seems to work here in 3.10+
+        from importlib.resources import files
+        return files(pkgname).joinpath(filename).read_bytes()
+    else:
+        # read_binary was deprecated in Python 3.11
+        from importlib.resources import read_binary
+        return read_binary(pkgname, filename)
+
+
+def _read_xsl(xsl):
+    # Previously these values were allowed:
+    if xsl == 'mathml/data/simple_mmlctop.xsl':
+        xsl = 'simple_mmlctop.xsl'
+    elif xsl == 'mathml/data/mmlctop.xsl':
+        xsl = 'mmlctop.xsl'
+    elif xsl == 'mathml/data/mmltex.xsl':
+        xsl = 'mmltex.xsl'
+
+    if xsl in ['simple_mmlctop.xsl', 'mmlctop.xsl', 'mmltex.xsl']:
+        xslbytes = _read_binary('sympy.utilities.mathml.data', xsl)
+    else:
+        xslbytes = Path(xsl).read_bytes()
+
+    return xslbytes
+
+
+@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 giving the name of an xsl (xml stylesheet) file which can be
+        found in sympy/utilities/mathml/data. The following files are supplied
+        with SymPy:
+
+        - mmlctop.xsl
+        - mmltex.xsl
+        - simple_mmlctop.xsl
+
+        Alternatively, a full path to an xsl file can be given.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.mathml import apply_xsl
+    >>> xsl = 'simple_mmlctop.xsl'
+    >>> mml = '<apply> <plus/> <ci>a</ci> <ci>b</ci> </apply>'
+    >>> res = apply_xsl(mml,xsl)
+    >>> print(res)
+    <?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(_read_xsl(xsl), 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.13/site-packages/sympy/utilities/tests/test_autowrap.py

@@ -0,0 +1,467 @@
+# Tests that require installed backends go into
+# sympy/test_external/test_autowrap
+
+import os
+import tempfile
+import shutil
+from io import StringIO
+from pathlib import Path
+
+from sympy.core import symbols, Eq
+from sympy.utilities.autowrap import (autowrap, binary_function,
+            CythonCodeWrapper, UfuncifyCodeWrapper, CodeWrapper)
+from sympy.utilities.codegen import (
+    CCodeGen, C99CodeGen, CodeGenArgumentListError, make_routine
+)
+from sympy.testing.pytest import raises
+from sympy.testing.tmpfiles import TmpFileManager
+
+
+def get_string(dump_fn, routines, prefix="file", **kwargs):
+    """Wrapper for dump_fn. dump_fn writes its results to a stream object and
+       this wrapper returns the contents of that stream as a string. This
+       auxiliary function is used by many tests below.
+
+       The header and the empty lines are not generator to facilitate the
+       testing of the output.
+    """
+    output = StringIO()
+    dump_fn(routines, output, prefix, **kwargs)
+    source = output.getvalue()
+    output.close()
+    return source
+
+
+def test_cython_wrapper_scalar_function():
+    x, y, z = symbols('x,y,z')
+    expr = (x + y)*z
+    routine = make_routine("test", expr)
+    code_gen = CythonCodeWrapper(CCodeGen())
+    source = get_string(code_gen.dump_pyx, [routine])
+
+    expected = (
+        "cdef extern from 'file.h':\n"
+        "    double test(double x, double y, double z)\n"
+        "\n"
+        "def test_c(double x, double y, double z):\n"
+        "\n"
+        "    return test(x, y, z)")
+    assert source == expected
+
+
+def test_cython_wrapper_outarg():
+    from sympy.core.relational import Equality
+    x, y, z = symbols('x,y,z')
+    code_gen = CythonCodeWrapper(C99CodeGen())
+
+    routine = make_routine("test", Equality(z, x + y))
+    source = get_string(code_gen.dump_pyx, [routine])
+    expected = (
+        "cdef extern from 'file.h':\n"
+        "    void test(double x, double y, double *z)\n"
+        "\n"
+        "def test_c(double x, double y):\n"
+        "\n"
+        "    cdef double z = 0\n"
+        "    test(x, y, &z)\n"
+        "    return z")
+    assert source == expected
+
+
+def test_cython_wrapper_inoutarg():
+    from sympy.core.relational import Equality
+    x, y, z = symbols('x,y,z')
+    code_gen = CythonCodeWrapper(C99CodeGen())
+    routine = make_routine("test", Equality(z, x + y + z))
+    source = get_string(code_gen.dump_pyx, [routine])
+    expected = (
+        "cdef extern from 'file.h':\n"
+        "    void test(double x, double y, double *z)\n"
+        "\n"
+        "def test_c(double x, double y, double z):\n"
+        "\n"
+        "    test(x, y, &z)\n"
+        "    return z")
+    assert source == expected
+
+
+def test_cython_wrapper_compile_flags():
+    from sympy.core.relational import Equality
+    x, y, z = symbols('x,y,z')
+    routine = make_routine("test", Equality(z, x + y))
+
+    code_gen = CythonCodeWrapper(CCodeGen())
+
+    expected = """\
+from setuptools import setup
+from setuptools import Extension
+from Cython.Build import cythonize
+cy_opts = {'compiler_directives': {'language_level': '3'}}
+
+ext_mods = [Extension(
+    'wrapper_module_%(num)s', ['wrapper_module_%(num)s.pyx', 'wrapped_code_%(num)s.c'],
+    include_dirs=[],
+    library_dirs=[],
+    libraries=[],
+    extra_compile_args=['-std=c99'],
+    extra_link_args=[]
+)]
+setup(ext_modules=cythonize(ext_mods, **cy_opts))
+""" % {'num': CodeWrapper._module_counter}
+
+    temp_dir = tempfile.mkdtemp()
+    TmpFileManager.tmp_folder(temp_dir)
+    setup_file_path = os.path.join(temp_dir, 'setup.py')
+
+    code_gen._prepare_files(routine, build_dir=temp_dir)
+    setup_text = Path(setup_file_path).read_text()
+    assert setup_text == expected
+
+    code_gen = CythonCodeWrapper(CCodeGen(),
+                                 include_dirs=['/usr/local/include', '/opt/booger/include'],
+                                 library_dirs=['/user/local/lib'],
+                                 libraries=['thelib', 'nilib'],
+                                 extra_compile_args=['-slow-math'],
+                                 extra_link_args=['-lswamp', '-ltrident'],
+                                 cythonize_options={'compiler_directives': {'boundscheck': False}}
+                                 )
+    expected = """\
+from setuptools import setup
+from setuptools import Extension
+from Cython.Build import cythonize
+cy_opts = {'compiler_directives': {'boundscheck': False}}
+
+ext_mods = [Extension(
+    'wrapper_module_%(num)s', ['wrapper_module_%(num)s.pyx', 'wrapped_code_%(num)s.c'],
+    include_dirs=['/usr/local/include', '/opt/booger/include'],
+    library_dirs=['/user/local/lib'],
+    libraries=['thelib', 'nilib'],
+    extra_compile_args=['-slow-math', '-std=c99'],
+    extra_link_args=['-lswamp', '-ltrident']
+)]
+setup(ext_modules=cythonize(ext_mods, **cy_opts))
+""" % {'num': CodeWrapper._module_counter}
+
+    code_gen._prepare_files(routine, build_dir=temp_dir)
+    setup_text = Path(setup_file_path).read_text()
+    assert setup_text == expected
+
+    expected = """\
+from setuptools import setup
+from setuptools import Extension
+from Cython.Build import cythonize
+cy_opts = {'compiler_directives': {'boundscheck': False}}
+import numpy as np
+
+ext_mods = [Extension(
+    'wrapper_module_%(num)s', ['wrapper_module_%(num)s.pyx', 'wrapped_code_%(num)s.c'],
+    include_dirs=['/usr/local/include', '/opt/booger/include', np.get_include()],
+    library_dirs=['/user/local/lib'],
+    libraries=['thelib', 'nilib'],
+    extra_compile_args=['-slow-math', '-std=c99'],
+    extra_link_args=['-lswamp', '-ltrident']
+)]
+setup(ext_modules=cythonize(ext_mods, **cy_opts))
+""" % {'num': CodeWrapper._module_counter}
+
+    code_gen._need_numpy = True
+    code_gen._prepare_files(routine, build_dir=temp_dir)
+    setup_text = Path(setup_file_path).read_text()
+    assert setup_text == expected
+
+    TmpFileManager.cleanup()
+
+def test_cython_wrapper_unique_dummyvars():
+    from sympy.core.relational import Equality
+    from sympy.core.symbol import Dummy
+    x, y, z = Dummy('x'), Dummy('y'), Dummy('z')
+    x_id, y_id, z_id = [str(d.dummy_index) for d in [x, y, z]]
+    expr = Equality(z, x + y)
+    routine = make_routine("test", expr)
+    code_gen = CythonCodeWrapper(CCodeGen())
+    source = get_string(code_gen.dump_pyx, [routine])
+    expected_template = (
+        "cdef extern from 'file.h':\n"
+        "    void test(double x_{x_id}, double y_{y_id}, double *z_{z_id})\n"
+        "\n"
+        "def test_c(double x_{x_id}, double y_{y_id}):\n"
+        "\n"
+        "    cdef double z_{z_id} = 0\n"
+        "    test(x_{x_id}, y_{y_id}, &z_{z_id})\n"
+        "    return z_{z_id}")
+    expected = expected_template.format(x_id=x_id, y_id=y_id, z_id=z_id)
+    assert source == expected
+
+def test_autowrap_dummy():
+    x, y, z = symbols('x y z')
+
+    # Uses DummyWrapper to test that codegen works as expected
+
+    f = autowrap(x + y, backend='dummy')
+    assert f() == str(x + y)
+    assert f.args == "x, y"
+    assert f.returns == "nameless"
+    f = autowrap(Eq(z, x + y), backend='dummy')
+    assert f() == str(x + y)
+    assert f.args == "x, y"
+    assert f.returns == "z"
+    f = autowrap(Eq(z, x + y + z), backend='dummy')
+    assert f() == str(x + y + z)
+    assert f.args == "x, y, z"
+    assert f.returns == "z"
+
+
+def test_autowrap_args():
+    x, y, z = symbols('x y z')
+
+    raises(CodeGenArgumentListError, lambda: autowrap(Eq(z, x + y),
+           backend='dummy', args=[x]))
+    f = autowrap(Eq(z, x + y), backend='dummy', args=[y, x])
+    assert f() == str(x + y)
+    assert f.args == "y, x"
+    assert f.returns == "z"
+
+    raises(CodeGenArgumentListError, lambda: autowrap(Eq(z, x + y + z),
+           backend='dummy', args=[x, y]))
+    f = autowrap(Eq(z, x + y + z), backend='dummy', args=[y, x, z])
+    assert f() == str(x + y + z)
+    assert f.args == "y, x, z"
+    assert f.returns == "z"
+
+    f = autowrap(Eq(z, x + y + z), backend='dummy', args=(y, x, z))
+    assert f() == str(x + y + z)
+    assert f.args == "y, x, z"
+    assert f.returns == "z"
+
+def test_autowrap_store_files():
+    x, y = symbols('x y')
+    tmp = tempfile.mkdtemp()
+    TmpFileManager.tmp_folder(tmp)
+
+    f = autowrap(x + y, backend='dummy', tempdir=tmp)
+    assert f() == str(x + y)
+    assert os.access(tmp, os.F_OK)
+
+    TmpFileManager.cleanup()
+
+def test_autowrap_store_files_issue_gh12939():
+    x, y = symbols('x y')
+    tmp = './tmp'
+    saved_cwd = os.getcwd()
+    temp_cwd = tempfile.mkdtemp()
+    try:
+        os.chdir(temp_cwd)
+        f = autowrap(x + y, backend='dummy', tempdir=tmp)
+        assert f() == str(x + y)
+        assert os.access(tmp, os.F_OK)
+    finally:
+        os.chdir(saved_cwd)
+        shutil.rmtree(temp_cwd)
+
+
+def test_binary_function():
+    x, y = symbols('x y')
+    f = binary_function('f', x + y, backend='dummy')
+    assert f._imp_() == str(x + y)
+
+
+def test_ufuncify_source():
+    x, y, z = symbols('x,y,z')
+    code_wrapper = UfuncifyCodeWrapper(C99CodeGen("ufuncify"))
+    routine = make_routine("test", x + y + z)
+    source = get_string(code_wrapper.dump_c, [routine])
+    expected = """\
+#include "Python.h"
+#include "math.h"
+#include "numpy/ndarraytypes.h"
+#include "numpy/ufuncobject.h"
+#include "numpy/halffloat.h"
+#include "file.h"
+
+static PyMethodDef wrapper_module_%(num)sMethods[] = {
+        {NULL, NULL, 0, NULL}
+};
+
+#ifdef NPY_1_19_API_VERSION
+static void test_ufunc(char **args, const npy_intp *dimensions, const npy_intp* steps, void* data)
+#else
+static void test_ufunc(char **args, npy_intp *dimensions, npy_intp* steps, void* data)
+#endif
+{
+    npy_intp i;
+    npy_intp n = dimensions[0];
+    char *in0 = args[0];
+    char *in1 = args[1];
+    char *in2 = args[2];
+    char *out0 = args[3];
+    npy_intp in0_step = steps[0];
+    npy_intp in1_step = steps[1];
+    npy_intp in2_step = steps[2];
+    npy_intp out0_step = steps[3];
+    for (i = 0; i < n; i++) {
+        *((double *)out0) = test(*(double *)in0, *(double *)in1, *(double *)in2);
+        in0 += in0_step;
+        in1 += in1_step;
+        in2 += in2_step;
+        out0 += out0_step;
+    }
+}
+PyUFuncGenericFunction test_funcs[1] = {&test_ufunc};
+static char test_types[4] = {NPY_DOUBLE, NPY_DOUBLE, NPY_DOUBLE, NPY_DOUBLE};
+static void *test_data[1] = {NULL};
+
+#if PY_VERSION_HEX >= 0x03000000
+static struct PyModuleDef moduledef = {
+    PyModuleDef_HEAD_INIT,
+    "wrapper_module_%(num)s",
+    NULL,
+    -1,
+    wrapper_module_%(num)sMethods,
+    NULL,
+    NULL,
+    NULL,
+    NULL
+};
+
+PyMODINIT_FUNC PyInit_wrapper_module_%(num)s(void)
+{
+    PyObject *m, *d;
+    PyObject *ufunc0;
+    m = PyModule_Create(&moduledef);
+    if (!m) {
+        return NULL;
+    }
+    import_array();
+    import_umath();
+    d = PyModule_GetDict(m);
+    ufunc0 = PyUFunc_FromFuncAndData(test_funcs, test_data, test_types, 1, 3, 1,
+            PyUFunc_None, "wrapper_module_%(num)s", "Created in SymPy with Ufuncify", 0);
+    PyDict_SetItemString(d, "test", ufunc0);
+    Py_DECREF(ufunc0);
+    return m;
+}
+#else
+PyMODINIT_FUNC initwrapper_module_%(num)s(void)
+{
+    PyObject *m, *d;
+    PyObject *ufunc0;
+    m = Py_InitModule("wrapper_module_%(num)s", wrapper_module_%(num)sMethods);
+    if (m == NULL) {
+        return;
+    }
+    import_array();
+    import_umath();
+    d = PyModule_GetDict(m);
+    ufunc0 = PyUFunc_FromFuncAndData(test_funcs, test_data, test_types, 1, 3, 1,
+            PyUFunc_None, "wrapper_module_%(num)s", "Created in SymPy with Ufuncify", 0);
+    PyDict_SetItemString(d, "test", ufunc0);
+    Py_DECREF(ufunc0);
+}
+#endif""" % {'num': CodeWrapper._module_counter}
+    assert source == expected
+
+
+def test_ufuncify_source_multioutput():
+    x, y, z = symbols('x,y,z')
+    var_symbols = (x, y, z)
+    expr = x + y**3 + 10*z**2
+    code_wrapper = UfuncifyCodeWrapper(C99CodeGen("ufuncify"))
+    routines = [make_routine("func{}".format(i), expr.diff(var_symbols[i]), var_symbols) for i in range(len(var_symbols))]
+    source = get_string(code_wrapper.dump_c, routines, funcname='multitest')
+    expected = """\
+#include "Python.h"
+#include "math.h"
+#include "numpy/ndarraytypes.h"
+#include "numpy/ufuncobject.h"
+#include "numpy/halffloat.h"
+#include "file.h"
+
+static PyMethodDef wrapper_module_%(num)sMethods[] = {
+        {NULL, NULL, 0, NULL}
+};
+
+#ifdef NPY_1_19_API_VERSION
+static void multitest_ufunc(char **args, const npy_intp *dimensions, const npy_intp* steps, void* data)
+#else
+static void multitest_ufunc(char **args, npy_intp *dimensions, npy_intp* steps, void* data)
+#endif
+{
+    npy_intp i;
+    npy_intp n = dimensions[0];
+    char *in0 = args[0];
+    char *in1 = args[1];
+    char *in2 = args[2];
+    char *out0 = args[3];
+    char *out1 = args[4];
+    char *out2 = args[5];
+    npy_intp in0_step = steps[0];
+    npy_intp in1_step = steps[1];
+    npy_intp in2_step = steps[2];
+    npy_intp out0_step = steps[3];
+    npy_intp out1_step = steps[4];
+    npy_intp out2_step = steps[5];
+    for (i = 0; i < n; i++) {
+        *((double *)out0) = func0(*(double *)in0, *(double *)in1, *(double *)in2);
+        *((double *)out1) = func1(*(double *)in0, *(double *)in1, *(double *)in2);
+        *((double *)out2) = func2(*(double *)in0, *(double *)in1, *(double *)in2);
+        in0 += in0_step;
+        in1 += in1_step;
+        in2 += in2_step;
+        out0 += out0_step;
+        out1 += out1_step;
+        out2 += out2_step;
+    }
+}
+PyUFuncGenericFunction multitest_funcs[1] = {&multitest_ufunc};
+static char multitest_types[6] = {NPY_DOUBLE, NPY_DOUBLE, NPY_DOUBLE, NPY_DOUBLE, NPY_DOUBLE, NPY_DOUBLE};
+static void *multitest_data[1] = {NULL};
+
+#if PY_VERSION_HEX >= 0x03000000
+static struct PyModuleDef moduledef = {
+    PyModuleDef_HEAD_INIT,
+    "wrapper_module_%(num)s",
+    NULL,
+    -1,
+    wrapper_module_%(num)sMethods,
+    NULL,
+    NULL,
+    NULL,
+    NULL
+};
+
+PyMODINIT_FUNC PyInit_wrapper_module_%(num)s(void)
+{
+    PyObject *m, *d;
+    PyObject *ufunc0;
+    m = PyModule_Create(&moduledef);
+    if (!m) {
+        return NULL;
+    }
+    import_array();
+    import_umath();
+    d = PyModule_GetDict(m);
+    ufunc0 = PyUFunc_FromFuncAndData(multitest_funcs, multitest_data, multitest_types, 1, 3, 3,
+            PyUFunc_None, "wrapper_module_%(num)s", "Created in SymPy with Ufuncify", 0);
+    PyDict_SetItemString(d, "multitest", ufunc0);
+    Py_DECREF(ufunc0);
+    return m;
+}
+#else
+PyMODINIT_FUNC initwrapper_module_%(num)s(void)
+{
+    PyObject *m, *d;
+    PyObject *ufunc0;
+    m = Py_InitModule("wrapper_module_%(num)s", wrapper_module_%(num)sMethods);
+    if (m == NULL) {
+        return;
+    }
+    import_array();
+    import_umath();
+    d = PyModule_GetDict(m);
+    ufunc0 = PyUFunc_FromFuncAndData(multitest_funcs, multitest_data, multitest_types, 1, 3, 3,
+            PyUFunc_None, "wrapper_module_%(num)s", "Created in SymPy with Ufuncify", 0);
+    PyDict_SetItemString(d, "multitest", ufunc0);
+    Py_DECREF(ufunc0);
+}
+#endif""" % {'num': CodeWrapper._module_counter}
+    assert source == expected

.venv/lib/python3.13/site-packages/sympy/utilities/tests/test_codegen_octave.py

@@ -0,0 +1,589 @@
+from io import StringIO
+
+from sympy.core import S, symbols, Eq, pi, Catalan, EulerGamma, Function
+from sympy.core.relational import Equality
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.matrices import Matrix, MatrixSymbol
+from sympy.utilities.codegen import OctaveCodeGen, codegen, make_routine
+from sympy.testing.pytest import raises
+from sympy.testing.pytest import XFAIL
+import sympy
+
+
+x, y, z = symbols('x,y,z')
+
+
+def test_empty_m_code():
+    code_gen = OctaveCodeGen()
+    output = StringIO()
+    code_gen.dump_m([], output, "file", header=False, empty=False)
+    source = output.getvalue()
+    assert source == ""
+
+
+def test_m_simple_code():
+    name_expr = ("test", (x + y)*z)
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    assert result[0] == "test.m"
+    source = result[1]
+    expected = (
+        "function out1 = test(x, y, z)\n"
+        "  out1 = z.*(x + y);\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_simple_code_with_header():
+    name_expr = ("test", (x + y)*z)
+    result, = codegen(name_expr, "Octave", header=True, empty=False)
+    assert result[0] == "test.m"
+    source = result[1]
+    expected = (
+        "function out1 = test(x, y, z)\n"
+        "  %TEST  Autogenerated by SymPy\n"
+        "  %   Code generated with SymPy " + sympy.__version__ + "\n"
+        "  %\n"
+        "  %   See http://www.sympy.org/ for more information.\n"
+        "  %\n"
+        "  %   This file is part of 'project'\n"
+        "  out1 = z.*(x + y);\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_simple_code_nameout():
+    expr = Equality(z, (x + y))
+    name_expr = ("test", expr)
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function z = test(x, y)\n"
+        "  z = x + y;\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_numbersymbol():
+    name_expr = ("test", pi**Catalan)
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function out1 = test()\n"
+        "  out1 = pi^%s;\n"
+        "end\n"
+    ) % Catalan.evalf(17)
+    assert source == expected
+
+
+@XFAIL
+def test_m_numbersymbol_no_inline():
+    # FIXME: how to pass inline=False to the OctaveCodePrinter?
+    name_expr = ("test", [pi**Catalan, EulerGamma])
+    result, = codegen(name_expr, "Octave", header=False,
+                      empty=False, inline=False)
+    source = result[1]
+    expected = (
+        "function [out1, out2] = test()\n"
+        "  Catalan = 0.915965594177219;  % constant\n"
+        "  EulerGamma = 0.5772156649015329;  % constant\n"
+        "  out1 = pi^Catalan;\n"
+        "  out2 = EulerGamma;\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_code_argument_order():
+    expr = x + y
+    routine = make_routine("test", expr, argument_sequence=[z, x, y], language="octave")
+    code_gen = OctaveCodeGen()
+    output = StringIO()
+    code_gen.dump_m([routine], output, "test", header=False, empty=False)
+    source = output.getvalue()
+    expected = (
+        "function out1 = test(z, x, y)\n"
+        "  out1 = x + y;\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_multiple_results_m():
+    # Here the output order is the input order
+    expr1 = (x + y)*z
+    expr2 = (x - y)*z
+    name_expr = ("test", [expr1, expr2])
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function [out1, out2] = test(x, y, z)\n"
+        "  out1 = z.*(x + y);\n"
+        "  out2 = z.*(x - y);\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_results_named_unordered():
+    # Here output order is based on name_expr
+    A, B, C = symbols('A,B,C')
+    expr1 = Equality(C, (x + y)*z)
+    expr2 = Equality(A, (x - y)*z)
+    expr3 = Equality(B, 2*x)
+    name_expr = ("test", [expr1, expr2, expr3])
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function [C, A, B] = test(x, y, z)\n"
+        "  C = z.*(x + y);\n"
+        "  A = z.*(x - y);\n"
+        "  B = 2*x;\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_results_named_ordered():
+    A, B, C = symbols('A,B,C')
+    expr1 = Equality(C, (x + y)*z)
+    expr2 = Equality(A, (x - y)*z)
+    expr3 = Equality(B, 2*x)
+    name_expr = ("test", [expr1, expr2, expr3])
+    result = codegen(name_expr, "Octave", header=False, empty=False,
+                     argument_sequence=(x, z, y))
+    assert result[0][0] == "test.m"
+    source = result[0][1]
+    expected = (
+        "function [C, A, B] = test(x, z, y)\n"
+        "  C = z.*(x + y);\n"
+        "  A = z.*(x - y);\n"
+        "  B = 2*x;\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_complicated_m_codegen():
+    from sympy.functions.elementary.trigonometric import (cos, sin, tan)
+    name_expr = ("testlong",
+            [ ((sin(x) + cos(y) + tan(z))**3).expand(),
+            cos(cos(cos(cos(cos(cos(cos(cos(x + y + z))))))))
+    ])
+    result = codegen(name_expr, "Octave", header=False, empty=False)
+    assert result[0][0] == "testlong.m"
+    source = result[0][1]
+    expected = (
+        "function [out1, out2] = testlong(x, y, z)\n"
+        "  out1 = sin(x).^3 + 3*sin(x).^2.*cos(y) + 3*sin(x).^2.*tan(z)"
+        " + 3*sin(x).*cos(y).^2 + 6*sin(x).*cos(y).*tan(z) + 3*sin(x).*tan(z).^2"
+        " + cos(y).^3 + 3*cos(y).^2.*tan(z) + 3*cos(y).*tan(z).^2 + tan(z).^3;\n"
+        "  out2 = cos(cos(cos(cos(cos(cos(cos(cos(x + y + z))))))));\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_output_arg_mixed_unordered():
+    # named outputs are alphabetical, unnamed output appear in the given order
+    from sympy.functions.elementary.trigonometric import (cos, sin)
+    a = symbols("a")
+    name_expr = ("foo", [cos(2*x), Equality(y, sin(x)), cos(x), Equality(a, sin(2*x))])
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    assert result[0] == "foo.m"
+    source = result[1]
+    expected = (
+        'function [out1, y, out3, a] = foo(x)\n'
+        '  out1 = cos(2*x);\n'
+        '  y = sin(x);\n'
+        '  out3 = cos(x);\n'
+        '  a = sin(2*x);\n'
+        'end\n'
+    )
+    assert source == expected
+
+
+def test_m_piecewise_():
+    pw = Piecewise((0, x < -1), (x**2, x <= 1), (-x+2, x > 1), (1, True), evaluate=False)
+    name_expr = ("pwtest", pw)
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function out1 = pwtest(x)\n"
+        "  out1 = ((x < -1).*(0) + (~(x < -1)).*( ...\n"
+        "  (x <= 1).*(x.^2) + (~(x <= 1)).*( ...\n"
+        "  (x > 1).*(2 - x) + (~(x > 1)).*(1))));\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+@XFAIL
+def test_m_piecewise_no_inline():
+    # FIXME: how to pass inline=False to the OctaveCodePrinter?
+    pw = Piecewise((0, x < -1), (x**2, x <= 1), (-x+2, x > 1), (1, True))
+    name_expr = ("pwtest", pw)
+    result, = codegen(name_expr, "Octave", header=False, empty=False,
+                      inline=False)
+    source = result[1]
+    expected = (
+        "function out1 = pwtest(x)\n"
+        "  if (x < -1)\n"
+        "    out1 = 0;\n"
+        "  elseif (x <= 1)\n"
+        "    out1 = x.^2;\n"
+        "  elseif (x > 1)\n"
+        "    out1 = -x + 2;\n"
+        "  else\n"
+        "    out1 = 1;\n"
+        "  end\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_multifcns_per_file():
+    name_expr = [ ("foo", [2*x, 3*y]), ("bar", [y**2, 4*y]) ]
+    result = codegen(name_expr, "Octave", header=False, empty=False)
+    assert result[0][0] == "foo.m"
+    source = result[0][1]
+    expected = (
+        "function [out1, out2] = foo(x, y)\n"
+        "  out1 = 2*x;\n"
+        "  out2 = 3*y;\n"
+        "end\n"
+        "function [out1, out2] = bar(y)\n"
+        "  out1 = y.^2;\n"
+        "  out2 = 4*y;\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_multifcns_per_file_w_header():
+    name_expr = [ ("foo", [2*x, 3*y]), ("bar", [y**2, 4*y]) ]
+    result = codegen(name_expr, "Octave", header=True, empty=False)
+    assert result[0][0] == "foo.m"
+    source = result[0][1]
+    expected = (
+        "function [out1, out2] = foo(x, y)\n"
+        "  %FOO  Autogenerated by SymPy\n"
+        "  %   Code generated with SymPy " + sympy.__version__ + "\n"
+        "  %\n"
+        "  %   See http://www.sympy.org/ for more information.\n"
+        "  %\n"
+        "  %   This file is part of 'project'\n"
+        "  out1 = 2*x;\n"
+        "  out2 = 3*y;\n"
+        "end\n"
+        "function [out1, out2] = bar(y)\n"
+        "  out1 = y.^2;\n"
+        "  out2 = 4*y;\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_filename_match_first_fcn():
+    name_expr = [ ("foo", [2*x, 3*y]), ("bar", [y**2, 4*y]) ]
+    raises(ValueError, lambda: codegen(name_expr,
+                        "Octave", prefix="bar", header=False, empty=False))
+
+
+def test_m_matrix_named():
+    e2 = Matrix([[x, 2*y, pi*z]])
+    name_expr = ("test", Equality(MatrixSymbol('myout1', 1, 3), e2))
+    result = codegen(name_expr, "Octave", header=False, empty=False)
+    assert result[0][0] == "test.m"
+    source = result[0][1]
+    expected = (
+        "function myout1 = test(x, y, z)\n"
+        "  myout1 = [x 2*y pi*z];\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_matrix_named_matsym():
+    myout1 = MatrixSymbol('myout1', 1, 3)
+    e2 = Matrix([[x, 2*y, pi*z]])
+    name_expr = ("test", Equality(myout1, e2, evaluate=False))
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function myout1 = test(x, y, z)\n"
+        "  myout1 = [x 2*y pi*z];\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_matrix_output_autoname():
+    expr = Matrix([[x, x+y, 3]])
+    name_expr = ("test", expr)
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function out1 = test(x, y)\n"
+        "  out1 = [x x + y 3];\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_matrix_output_autoname_2():
+    e1 = (x + y)
+    e2 = Matrix([[2*x, 2*y, 2*z]])
+    e3 = Matrix([[x], [y], [z]])
+    e4 = Matrix([[x, y], [z, 16]])
+    name_expr = ("test", (e1, e2, e3, e4))
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function [out1, out2, out3, out4] = test(x, y, z)\n"
+        "  out1 = x + y;\n"
+        "  out2 = [2*x 2*y 2*z];\n"
+        "  out3 = [x; y; z];\n"
+        "  out4 = [x y; z 16];\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_results_matrix_named_ordered():
+    B, C = symbols('B,C')
+    A = MatrixSymbol('A', 1, 3)
+    expr1 = Equality(C, (x + y)*z)
+    expr2 = Equality(A, Matrix([[1, 2, x]]))
+    expr3 = Equality(B, 2*x)
+    name_expr = ("test", [expr1, expr2, expr3])
+    result, = codegen(name_expr, "Octave", header=False, empty=False,
+                     argument_sequence=(x, z, y))
+    source = result[1]
+    expected = (
+        "function [C, A, B] = test(x, z, y)\n"
+        "  C = z.*(x + y);\n"
+        "  A = [1 2 x];\n"
+        "  B = 2*x;\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_matrixsymbol_slice():
+    A = MatrixSymbol('A', 2, 3)
+    B = MatrixSymbol('B', 1, 3)
+    C = MatrixSymbol('C', 1, 3)
+    D = MatrixSymbol('D', 2, 1)
+    name_expr = ("test", [Equality(B, A[0, :]),
+                          Equality(C, A[1, :]),
+                          Equality(D, A[:, 2])])
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function [B, C, D] = test(A)\n"
+        "  B = A(1, :);\n"
+        "  C = A(2, :);\n"
+        "  D = A(:, 3);\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_matrixsymbol_slice2():
+    A = MatrixSymbol('A', 3, 4)
+    B = MatrixSymbol('B', 2, 2)
+    C = MatrixSymbol('C', 2, 2)
+    name_expr = ("test", [Equality(B, A[0:2, 0:2]),
+                          Equality(C, A[0:2, 1:3])])
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function [B, C] = test(A)\n"
+        "  B = A(1:2, 1:2);\n"
+        "  C = A(1:2, 2:3);\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_matrixsymbol_slice3():
+    A = MatrixSymbol('A', 8, 7)
+    B = MatrixSymbol('B', 2, 2)
+    C = MatrixSymbol('C', 4, 2)
+    name_expr = ("test", [Equality(B, A[6:, 1::3]),
+                          Equality(C, A[::2, ::3])])
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function [B, C] = test(A)\n"
+        "  B = A(7:end, 2:3:end);\n"
+        "  C = A(1:2:end, 1:3:end);\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_matrixsymbol_slice_autoname():
+    A = MatrixSymbol('A', 2, 3)
+    B = MatrixSymbol('B', 1, 3)
+    name_expr = ("test", [Equality(B, A[0,:]), A[1,:], A[:,0], A[:,1]])
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function [B, out2, out3, out4] = test(A)\n"
+        "  B = A(1, :);\n"
+        "  out2 = A(2, :);\n"
+        "  out3 = A(:, 1);\n"
+        "  out4 = A(:, 2);\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_loops():
+    # Note: an Octave programmer would probably vectorize this across one or
+    # more dimensions.  Also, size(A) would be used rather than passing in m
+    # and n.  Perhaps users would expect us to vectorize automatically here?
+    # Or is it possible to represent such things using IndexedBase?
+    from sympy.tensor import IndexedBase, Idx
+    from sympy.core.symbol import symbols
+    n, m = symbols('n m', integer=True)
+    A = IndexedBase('A')
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i = Idx('i', m)
+    j = Idx('j', n)
+    result, = codegen(('mat_vec_mult', Eq(y[i], A[i, j]*x[j])), "Octave",
+                      header=False, empty=False)
+    source = result[1]
+    expected = (
+        'function y = mat_vec_mult(A, m, n, x)\n'
+        '  for i = 1:m\n'
+        '    y(i) = 0;\n'
+        '  end\n'
+        '  for i = 1:m\n'
+        '    for j = 1:n\n'
+        '      y(i) = %(rhs)s + y(i);\n'
+        '    end\n'
+        '  end\n'
+        'end\n'
+    )
+    assert (source == expected % {'rhs': 'A(%s, %s).*x(j)' % (i, j)} or
+            source == expected % {'rhs': 'x(j).*A(%s, %s)' % (i, j)})
+
+
+def test_m_tensor_loops_multiple_contractions():
+    # see comments in previous test about vectorizing
+    from sympy.tensor import IndexedBase, Idx
+    from sympy.core.symbol import symbols
+    n, m, o, p = symbols('n m o p', integer=True)
+    A = IndexedBase('A')
+    B = IndexedBase('B')
+    y = IndexedBase('y')
+    i = Idx('i', m)
+    j = Idx('j', n)
+    k = Idx('k', o)
+    l = Idx('l', p)
+    result, = codegen(('tensorthing', Eq(y[i], B[j, k, l]*A[i, j, k, l])),
+                      "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        'function y = tensorthing(A, B, m, n, o, p)\n'
+        '  for i = 1:m\n'
+        '    y(i) = 0;\n'
+        '  end\n'
+        '  for i = 1:m\n'
+        '    for j = 1:n\n'
+        '      for k = 1:o\n'
+        '        for l = 1:p\n'
+        '          y(i) = A(i, j, k, l).*B(j, k, l) + y(i);\n'
+        '        end\n'
+        '      end\n'
+        '    end\n'
+        '  end\n'
+        'end\n'
+    )
+    assert source == expected
+
+
+def test_m_InOutArgument():
+    expr = Equality(x, x**2)
+    name_expr = ("mysqr", expr)
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function x = mysqr(x)\n"
+        "  x = x.^2;\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_InOutArgument_order():
+    # can specify the order as (x, y)
+    expr = Equality(x, x**2 + y)
+    name_expr = ("test", expr)
+    result, = codegen(name_expr, "Octave", header=False,
+                      empty=False, argument_sequence=(x,y))
+    source = result[1]
+    expected = (
+        "function x = test(x, y)\n"
+        "  x = x.^2 + y;\n"
+        "end\n"
+    )
+    assert source == expected
+    # make sure it gives (x, y) not (y, x)
+    expr = Equality(x, x**2 + y)
+    name_expr = ("test", expr)
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function x = test(x, y)\n"
+        "  x = x.^2 + y;\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_not_supported():
+    f = Function('f')
+    name_expr = ("test", [f(x).diff(x), S.ComplexInfinity])
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function [out1, out2] = test(x)\n"
+        "  % unsupported: Derivative(f(x), x)\n"
+        "  % unsupported: zoo\n"
+        "  out1 = Derivative(f(x), x);\n"
+        "  out2 = zoo;\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_global_vars_octave():
+    x, y, z, t = symbols("x y z t")
+    result = codegen(('f', x*y), "Octave", header=False, empty=False,
+                     global_vars=(y,))
+    source = result[0][1]
+    expected = (
+        "function out1 = f(x)\n"
+        "  global y\n"
+        "  out1 = x.*y;\n"
+        "end\n"
+        )
+    assert source == expected
+
+    result = codegen(('f', x*y+z), "Octave", header=False, empty=False,
+                     argument_sequence=(x, y), global_vars=(z, t))
+    source = result[0][1]
+    expected = (
+        "function out1 = f(x, y)\n"
+        "  global t z\n"
+        "  out1 = x.*y + z;\n"
+        "end\n"
+    )
+    assert source == expected

.venv/lib/python3.13/site-packages/sympy/utilities/tests/test_codegen_rust.py

@@ -0,0 +1,401 @@
+from io import StringIO
+
+from sympy.core import S, symbols, pi, Catalan, EulerGamma, Function
+from sympy.core.relational import Equality
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.utilities.codegen import RustCodeGen, codegen, make_routine
+from sympy.testing.pytest import XFAIL
+import sympy
+
+
+x, y, z = symbols('x,y,z')
+
+
+def test_empty_rust_code():
+    code_gen = RustCodeGen()
+    output = StringIO()
+    code_gen.dump_rs([], output, "file", header=False, empty=False)
+    source = output.getvalue()
+    assert source == ""
+
+
+def test_simple_rust_code():
+    name_expr = ("test", (x + y)*z)
+    result, = codegen(name_expr, "Rust", header=False, empty=False)
+    assert result[0] == "test.rs"
+    source = result[1]
+    expected = (
+        "fn test(x: f64, y: f64, z: f64) -> f64 {\n"
+        "    let out1 = z*(x + y);\n"
+        "    out1\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_simple_code_with_header():
+    name_expr = ("test", (x + y)*z)
+    result, = codegen(name_expr, "Rust", header=True, empty=False)
+    assert result[0] == "test.rs"
+    source = result[1]
+    version_str = "Code generated with SymPy %s" % sympy.__version__
+    version_line = version_str.center(76).rstrip()
+    expected = (
+        "/*\n"
+        " *%(version_line)s\n"
+        " *\n"
+        " *              See http://www.sympy.org/ for more information.\n"
+        " *\n"
+        " *                       This file is part of 'project'\n"
+        " */\n"
+        "fn test(x: f64, y: f64, z: f64) -> f64 {\n"
+        "    let out1 = z*(x + y);\n"
+        "    out1\n"
+        "}\n"
+    ) % {'version_line': version_line}
+    assert source == expected
+
+
+def test_simple_code_nameout():
+    expr = Equality(z, (x + y))
+    name_expr = ("test", expr)
+    result, = codegen(name_expr, "Rust", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "fn test(x: f64, y: f64) -> f64 {\n"
+        "    let z = x + y;\n"
+        "    z\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_numbersymbol():
+    name_expr = ("test", pi**Catalan)
+    result, = codegen(name_expr, "Rust", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "fn test() -> f64 {\n"
+        "    const Catalan: f64 = %s;\n"
+        "    let out1 = PI.powf(Catalan);\n"
+        "    out1\n"
+        "}\n"
+    ) % Catalan.evalf(17)
+    assert source == expected
+
+
+@XFAIL
+def test_numbersymbol_inline():
+    # FIXME: how to pass inline to the RustCodePrinter?
+    name_expr = ("test", [pi**Catalan, EulerGamma])
+    result, = codegen(name_expr, "Rust", header=False,
+                      empty=False, inline=True)
+    source = result[1]
+    expected = (
+        "fn test() -> (f64, f64) {\n"
+        "    const Catalan: f64 = %s;\n"
+        "    const EulerGamma: f64 = %s;\n"
+        "    let out1 = PI.powf(Catalan);\n"
+        "    let out2 = EulerGamma);\n"
+        "    (out1, out2)\n"
+        "}\n"
+    ) % (Catalan.evalf(17), EulerGamma.evalf(17))
+    assert source == expected
+
+
+def test_argument_order():
+    expr = x + y
+    routine = make_routine("test", expr, argument_sequence=[z, x, y], language="rust")
+    code_gen = RustCodeGen()
+    output = StringIO()
+    code_gen.dump_rs([routine], output, "test", header=False, empty=False)
+    source = output.getvalue()
+    expected = (
+        "fn test(z: f64, x: f64, y: f64) -> f64 {\n"
+        "    let out1 = x + y;\n"
+        "    out1\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_multiple_results_rust():
+    # Here the output order is the input order
+    expr1 = (x + y)*z
+    expr2 = (x - y)*z
+    name_expr = ("test", [expr1, expr2])
+    result, = codegen(name_expr, "Rust", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "fn test(x: f64, y: f64, z: f64) -> (f64, f64) {\n"
+        "    let out1 = z*(x + y);\n"
+        "    let out2 = z*(x - y);\n"
+        "    (out1, out2)\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_results_named_unordered():
+    # Here output order is based on name_expr
+    A, B, C = symbols('A,B,C')
+    expr1 = Equality(C, (x + y)*z)
+    expr2 = Equality(A, (x - y)*z)
+    expr3 = Equality(B, 2*x)
+    name_expr = ("test", [expr1, expr2, expr3])
+    result, = codegen(name_expr, "Rust", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "fn test(x: f64, y: f64, z: f64) -> (f64, f64, f64) {\n"
+        "    let C = z*(x + y);\n"
+        "    let A = z*(x - y);\n"
+        "    let B = 2*x;\n"
+        "    (C, A, B)\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_results_named_ordered():
+    A, B, C = symbols('A,B,C')
+    expr1 = Equality(C, (x + y)*z)
+    expr2 = Equality(A, (x - y)*z)
+    expr3 = Equality(B, 2*x)
+    name_expr = ("test", [expr1, expr2, expr3])
+    result = codegen(name_expr, "Rust", header=False, empty=False,
+                     argument_sequence=(x, z, y))
+    assert result[0][0] == "test.rs"
+    source = result[0][1]
+    expected = (
+        "fn test(x: f64, z: f64, y: f64) -> (f64, f64, f64) {\n"
+        "    let C = z*(x + y);\n"
+        "    let A = z*(x - y);\n"
+        "    let B = 2*x;\n"
+        "    (C, A, B)\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_complicated_rs_codegen():
+    from sympy.functions.elementary.trigonometric import (cos, sin, tan)
+    name_expr = ("testlong",
+            [ ((sin(x) + cos(y) + tan(z))**3).expand(),
+            cos(cos(cos(cos(cos(cos(cos(cos(x + y + z))))))))
+    ])
+    result = codegen(name_expr, "Rust", header=False, empty=False)
+    assert result[0][0] == "testlong.rs"
+    source = result[0][1]
+    expected = (
+        "fn testlong(x: f64, y: f64, z: f64) -> (f64, f64) {\n"
+        "    let out1 = x.sin().powi(3) + 3*x.sin().powi(2)*y.cos()"
+        " + 3*x.sin().powi(2)*z.tan() + 3*x.sin()*y.cos().powi(2)"
+        " + 6*x.sin()*y.cos()*z.tan() + 3*x.sin()*z.tan().powi(2)"
+        " + y.cos().powi(3) + 3*y.cos().powi(2)*z.tan()"
+        " + 3*y.cos()*z.tan().powi(2) + z.tan().powi(3);\n"
+        "    let out2 = (x + y + z).cos().cos().cos().cos()"
+        ".cos().cos().cos().cos();\n"
+        "    (out1, out2)\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_output_arg_mixed_unordered():
+    # named outputs are alphabetical, unnamed output appear in the given order
+    from sympy.functions.elementary.trigonometric import (cos, sin)
+    a = symbols("a")
+    name_expr = ("foo", [cos(2*x), Equality(y, sin(x)), cos(x), Equality(a, sin(2*x))])
+    result, = codegen(name_expr, "Rust", header=False, empty=False)
+    assert result[0] == "foo.rs"
+    source = result[1]
+    expected = (
+        "fn foo(x: f64) -> (f64, f64, f64, f64) {\n"
+        "    let out1 = (2*x).cos();\n"
+        "    let y = x.sin();\n"
+        "    let out3 = x.cos();\n"
+        "    let a = (2*x).sin();\n"
+        "    (out1, y, out3, a)\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_piecewise_():
+    pw = Piecewise((0, x < -1), (x**2, x <= 1), (-x+2, x > 1), (1, True), evaluate=False)
+    name_expr = ("pwtest", pw)
+    result, = codegen(name_expr, "Rust", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "fn pwtest(x: f64) -> f64 {\n"
+        "    let out1 = if (x < -1.0) {\n"
+        "        0\n"
+        "    } else if (x <= 1.0) {\n"
+        "        x.powi(2)\n"
+        "    } else if (x > 1.0) {\n"
+        "        2 - x\n"
+        "    } else {\n"
+        "        1\n"
+        "    };\n"
+        "    out1\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+@XFAIL
+def test_piecewise_inline():
+    # FIXME: how to pass inline to the RustCodePrinter?
+    pw = Piecewise((0, x < -1), (x**2, x <= 1), (-x+2, x > 1), (1, True))
+    name_expr = ("pwtest", pw)
+    result, = codegen(name_expr, "Rust", header=False, empty=False,
+                      inline=True)
+    source = result[1]
+    expected = (
+        "fn pwtest(x: f64) -> f64 {\n"
+        "    let out1 = if (x < -1) { 0 } else if (x <= 1) { x.powi(2) }"
+        " else if (x > 1) { -x + 2 } else { 1 };\n"
+        "    out1\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_multifcns_per_file():
+    name_expr = [ ("foo", [2*x, 3*y]), ("bar", [y**2, 4*y]) ]
+    result = codegen(name_expr, "Rust", header=False, empty=False)
+    assert result[0][0] == "foo.rs"
+    source = result[0][1]
+    expected = (
+        "fn foo(x: f64, y: f64) -> (f64, f64) {\n"
+        "    let out1 = 2*x;\n"
+        "    let out2 = 3*y;\n"
+        "    (out1, out2)\n"
+        "}\n"
+        "fn bar(y: f64) -> (f64, f64) {\n"
+        "    let out1 = y.powi(2);\n"
+        "    let out2 = 4*y;\n"
+        "    (out1, out2)\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_multifcns_per_file_w_header():
+    name_expr = [ ("foo", [2*x, 3*y]), ("bar", [y**2, 4*y]) ]
+    result = codegen(name_expr, "Rust", header=True, empty=False)
+    assert result[0][0] == "foo.rs"
+    source = result[0][1]
+    version_str = "Code generated with SymPy %s" % sympy.__version__
+    version_line = version_str.center(76).rstrip()
+    expected = (
+        "/*\n"
+        " *%(version_line)s\n"
+        " *\n"
+        " *              See http://www.sympy.org/ for more information.\n"
+        " *\n"
+        " *                       This file is part of 'project'\n"
+        " */\n"
+        "fn foo(x: f64, y: f64) -> (f64, f64) {\n"
+        "    let out1 = 2*x;\n"
+        "    let out2 = 3*y;\n"
+        "    (out1, out2)\n"
+        "}\n"
+        "fn bar(y: f64) -> (f64, f64) {\n"
+        "    let out1 = y.powi(2);\n"
+        "    let out2 = 4*y;\n"
+        "    (out1, out2)\n"
+        "}\n"
+    ) % {'version_line': version_line}
+    assert source == expected
+
+
+def test_filename_match_prefix():
+    name_expr = [ ("foo", [2*x, 3*y]), ("bar", [y**2, 4*y]) ]
+    result, = codegen(name_expr, "Rust", prefix="baz", header=False,
+                     empty=False)
+    assert result[0] == "baz.rs"
+
+
+def test_InOutArgument():
+    expr = Equality(x, x**2)
+    name_expr = ("mysqr", expr)
+    result, = codegen(name_expr, "Rust", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "fn mysqr(x: f64) -> f64 {\n"
+        "    let x = x.powi(2);\n"
+        "    x\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_InOutArgument_order():
+    # can specify the order as (x, y)
+    expr = Equality(x, x**2 + y)
+    name_expr = ("test", expr)
+    result, = codegen(name_expr, "Rust", header=False,
+                      empty=False, argument_sequence=(x,y))
+    source = result[1]
+    expected = (
+        "fn test(x: f64, y: f64) -> f64 {\n"
+        "    let x = x.powi(2) + y;\n"
+        "    x\n"
+        "}\n"
+    )
+    assert source == expected
+    # make sure it gives (x, y) not (y, x)
+    expr = Equality(x, x**2 + y)
+    name_expr = ("test", expr)
+    result, = codegen(name_expr, "Rust", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "fn test(x: f64, y: f64) -> f64 {\n"
+        "    let x = x.powi(2) + y;\n"
+        "    x\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_not_supported():
+    f = Function('f')
+    name_expr = ("test", [f(x).diff(x), S.ComplexInfinity])
+    result, = codegen(name_expr, "Rust", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "fn test(x: f64) -> (f64, f64) {\n"
+        "    // unsupported: Derivative(f(x), x)\n"
+        "    // unsupported: zoo\n"
+        "    let out1 = Derivative(f(x), x);\n"
+        "    let out2 = zoo;\n"
+        "    (out1, out2)\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_global_vars_rust():
+    x, y, z, t = symbols("x y z t")
+    result = codegen(('f', x*y), "Rust", header=False, empty=False,
+                     global_vars=(y,))
+    source = result[0][1]
+    expected = (
+        "fn f(x: f64) -> f64 {\n"
+        "    let out1 = x*y;\n"
+        "    out1\n"
+        "}\n"
+        )
+    assert source == expected
+
+    result = codegen(('f', x*y+z), "Rust", header=False, empty=False,
+                     argument_sequence=(x, y), global_vars=(z, t))
+    source = result[0][1]
+    expected = (
+        "fn f(x: f64, y: f64) -> f64 {\n"
+        "    let out1 = x*y + z;\n"
+        "    out1\n"
+        "}\n"
+    )
+    assert source == expected

.venv/lib/python3.13/site-packages/sympy/utilities/tests/test_deprecated.py

@@ -0,0 +1,13 @@
+from sympy.testing.pytest import warns_deprecated_sympy
+
+# See https://github.com/sympy/sympy/pull/18095
+
+def test_deprecated_utilities():
+    with warns_deprecated_sympy():
+        import sympy.utilities.pytest  # noqa:F401
+    with warns_deprecated_sympy():
+        import sympy.utilities.runtests  # noqa:F401
+    with warns_deprecated_sympy():
+        import sympy.utilities.randtest  # noqa:F401
+    with warns_deprecated_sympy():
+        import sympy.utilities.tmpfiles  # noqa:F401

.venv/lib/python3.13/site-packages/sympy/utilities/tests/test_exceptions.py

@@ -0,0 +1,12 @@
+from sympy.testing.pytest import raises
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+# Only test exceptions here because the other cases are tested in the
+# warns_deprecated_sympy tests
+def test_sympy_deprecation_warning():
+    raises(TypeError, lambda: sympy_deprecation_warning('test',
+                                                        deprecated_since_version=1.10,
+                                                        active_deprecations_target='active-deprecations'))
+
+    raises(ValueError, lambda: sympy_deprecation_warning('test',
+                                                            deprecated_since_version="1.10", active_deprecations_target='(active-deprecations)='))

.venv/lib/python3.13/site-packages/sympy/utilities/tests/test_iterables.py

@@ -0,0 +1,945 @@
+from textwrap import dedent
+from itertools import islice, product
+
+from sympy.core.basic import Basic
+from sympy.core.numbers import Integer
+from sympy.core.sorting import ordered
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.matrices.dense import Matrix
+from sympy.combinatorics import RGS_enum, RGS_unrank, Permutation
+from sympy.utilities.iterables import (
+    _partition, _set_partitions, binary_partitions, bracelets, capture,
+    cartes, common_prefix, common_suffix, connected_components, dict_merge,
+    filter_symbols, flatten, generate_bell, generate_derangements,
+    generate_involutions, generate_oriented_forest, group, has_dups, ibin,
+    iproduct, kbins, minlex, multiset, multiset_combinations,
+    multiset_partitions, multiset_permutations, necklaces, numbered_symbols,
+    partitions, permutations, postfixes,
+    prefixes, reshape, rotate_left, rotate_right, runs, sift,
+    strongly_connected_components, subsets, take, topological_sort, unflatten,
+    uniq, variations, ordered_partitions, rotations, is_palindromic, iterable,
+    NotIterable, multiset_derangements, signed_permutations,
+    sequence_partitions, sequence_partitions_empty)
+from sympy.utilities.enumerative import (
+    factoring_visitor, multiset_partitions_taocp )
+
+from sympy.core.singleton import S
+from sympy.testing.pytest import raises, warns_deprecated_sympy
+
+w, x, y, z = symbols('w,x,y,z')
+
+
+def test_deprecated_iterables():
+    from sympy.utilities.iterables import default_sort_key, ordered
+    with warns_deprecated_sympy():
+        assert list(ordered([y, x])) == [x, y]
+    with warns_deprecated_sympy():
+        assert sorted([y, x], key=default_sort_key) == [x, y]
+
+
+def test_is_palindromic():
+    assert is_palindromic('')
+    assert is_palindromic('x')
+    assert is_palindromic('xx')
+    assert is_palindromic('xyx')
+    assert not is_palindromic('xy')
+    assert not is_palindromic('xyzx')
+    assert is_palindromic('xxyzzyx', 1)
+    assert not is_palindromic('xxyzzyx', 2)
+    assert is_palindromic('xxyzzyx', 2, -1)
+    assert is_palindromic('xxyzzyx', 2, 6)
+    assert is_palindromic('xxyzyx', 1)
+    assert not is_palindromic('xxyzyx', 2)
+    assert is_palindromic('xxyzyx', 2, 2 + 3)
+
+
+def test_flatten():
+    assert flatten((1, (1,))) == [1, 1]
+    assert flatten((x, (x,))) == [x, x]
+
+    ls = [[(-2, -1), (1, 2)], [(0, 0)]]
+
+    assert flatten(ls, levels=0) == ls
+    assert flatten(ls, levels=1) == [(-2, -1), (1, 2), (0, 0)]
+    assert flatten(ls, levels=2) == [-2, -1, 1, 2, 0, 0]
+    assert flatten(ls, levels=3) == [-2, -1, 1, 2, 0, 0]
+
+    raises(ValueError, lambda: flatten(ls, levels=-1))
+
+    class MyOp(Basic):
+        pass
+
+    assert flatten([MyOp(x, y), z]) == [MyOp(x, y), z]
+    assert flatten([MyOp(x, y), z], cls=MyOp) == [x, y, z]
+
+    assert flatten({1, 11, 2}) == list({1, 11, 2})
+
+
+def test_iproduct():
+    assert list(iproduct()) == [()]
+    assert list(iproduct([])) == []
+    assert list(iproduct([1,2,3])) == [(1,),(2,),(3,)]
+    assert sorted(iproduct([1, 2], [3, 4, 5])) == [
+        (1,3),(1,4),(1,5),(2,3),(2,4),(2,5)]
+    assert sorted(iproduct([0,1],[0,1],[0,1])) == [
+        (0,0,0),(0,0,1),(0,1,0),(0,1,1),(1,0,0),(1,0,1),(1,1,0),(1,1,1)]
+    assert iterable(iproduct(S.Integers)) is True
+    assert iterable(iproduct(S.Integers, S.Integers)) is True
+    assert (3,) in iproduct(S.Integers)
+    assert (4, 5) in iproduct(S.Integers, S.Integers)
+    assert (1, 2, 3) in iproduct(S.Integers, S.Integers, S.Integers)
+    triples  = set(islice(iproduct(S.Integers, S.Integers, S.Integers), 1000))
+    for n1, n2, n3 in triples:
+        assert isinstance(n1, Integer)
+        assert isinstance(n2, Integer)
+        assert isinstance(n3, Integer)
+    for t in set(product(*([range(-2, 3)]*3))):
+        assert t in iproduct(S.Integers, S.Integers, S.Integers)
+
+
+def test_group():
+    assert group([]) == []
+    assert group([], multiple=False) == []
+
+    assert group([1]) == [[1]]
+    assert group([1], multiple=False) == [(1, 1)]
+
+    assert group([1, 1]) == [[1, 1]]
+    assert group([1, 1], multiple=False) == [(1, 2)]
+
+    assert group([1, 1, 1]) == [[1, 1, 1]]
+    assert group([1, 1, 1], multiple=False) == [(1, 3)]
+
+    assert group([1, 2, 1]) == [[1], [2], [1]]
+    assert group([1, 2, 1], multiple=False) == [(1, 1), (2, 1), (1, 1)]
+
+    assert group([1, 1, 2, 2, 2, 1, 3, 3]) == [[1, 1], [2, 2, 2], [1], [3, 3]]
+    assert group([1, 1, 2, 2, 2, 1, 3, 3], multiple=False) == [(1, 2),
+                 (2, 3), (1, 1), (3, 2)]
+
+
+def test_subsets():
+    # combinations
+    assert list(subsets([1, 2, 3], 0)) == [()]
+    assert list(subsets([1, 2, 3], 1)) == [(1,), (2,), (3,)]
+    assert list(subsets([1, 2, 3], 2)) == [(1, 2), (1, 3), (2, 3)]
+    assert list(subsets([1, 2, 3], 3)) == [(1, 2, 3)]
+    l = list(range(4))
+    assert list(subsets(l, 0, repetition=True)) == [()]
+    assert list(subsets(l, 1, repetition=True)) == [(0,), (1,), (2,), (3,)]
+    assert list(subsets(l, 2, repetition=True)) == [(0, 0), (0, 1), (0, 2),
+                                                    (0, 3), (1, 1), (1, 2),
+                                                    (1, 3), (2, 2), (2, 3),
+                                                    (3, 3)]
+    assert list(subsets(l, 3, repetition=True)) == [(0, 0, 0), (0, 0, 1),
+                                                    (0, 0, 2), (0, 0, 3),
+                                                    (0, 1, 1), (0, 1, 2),
+                                                    (0, 1, 3), (0, 2, 2),
+                                                    (0, 2, 3), (0, 3, 3),
+                                                    (1, 1, 1), (1, 1, 2),
+                                                    (1, 1, 3), (1, 2, 2),
+                                                    (1, 2, 3), (1, 3, 3),
+                                                    (2, 2, 2), (2, 2, 3),
+                                                    (2, 3, 3), (3, 3, 3)]
+    assert len(list(subsets(l, 4, repetition=True))) == 35
+
+    assert list(subsets(l[:2], 3, repetition=False)) == []
+    assert list(subsets(l[:2], 3, repetition=True)) == [(0, 0, 0),
+                                                        (0, 0, 1),
+                                                        (0, 1, 1),
+                                                        (1, 1, 1)]
+    assert list(subsets([1, 2], repetition=True)) == \
+        [(), (1,), (2,), (1, 1), (1, 2), (2, 2)]
+    assert list(subsets([1, 2], repetition=False)) == \
+        [(), (1,), (2,), (1, 2)]
+    assert list(subsets([1, 2, 3], 2)) == \
+        [(1, 2), (1, 3), (2, 3)]
+    assert list(subsets([1, 2, 3], 2, repetition=True)) == \
+        [(1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (3, 3)]
+
+
+def test_variations():
+    # permutations
+    l = list(range(4))
+    assert list(variations(l, 0, repetition=False)) == [()]
+    assert list(variations(l, 1, repetition=False)) == [(0,), (1,), (2,), (3,)]
+    assert list(variations(l, 2, repetition=False)) == [(0, 1), (0, 2), (0, 3), (1, 0), (1, 2), (1, 3), (2, 0), (2, 1), (2, 3), (3, 0), (3, 1), (3, 2)]
+    assert list(variations(l, 3, repetition=False)) == [(0, 1, 2), (0, 1, 3), (0, 2, 1), (0, 2, 3), (0, 3, 1), (0, 3, 2), (1, 0, 2), (1, 0, 3), (1, 2, 0), (1, 2, 3), (1, 3, 0), (1, 3, 2), (2, 0, 1), (2, 0, 3), (2, 1, 0), (2, 1, 3), (2, 3, 0), (2, 3, 1), (3, 0, 1), (3, 0, 2), (3, 1, 0), (3, 1, 2), (3, 2, 0), (3, 2, 1)]
+    assert list(variations(l, 0, repetition=True)) == [()]
+    assert list(variations(l, 1, repetition=True)) == [(0,), (1,), (2,), (3,)]
+    assert list(variations(l, 2, repetition=True)) == [(0, 0), (0, 1), (0, 2),
+                                                       (0, 3), (1, 0), (1, 1),
+                                                       (1, 2), (1, 3), (2, 0),
+                                                       (2, 1), (2, 2), (2, 3),
+                                                       (3, 0), (3, 1), (3, 2),
+                                                       (3, 3)]
+    assert len(list(variations(l, 3, repetition=True))) == 64
+    assert len(list(variations(l, 4, repetition=True))) == 256
+    assert list(variations(l[:2], 3, repetition=False)) == []
+    assert list(variations(l[:2], 3, repetition=True)) == [
+        (0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1),
+        (1, 0, 0), (1, 0, 1), (1, 1, 0), (1, 1, 1)
+    ]
+
+
+def test_cartes():
+    assert list(cartes([1, 2], [3, 4, 5])) == \
+        [(1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5)]
+    assert list(cartes()) == [()]
+    assert list(cartes('a')) == [('a',)]
+    assert list(cartes('a', repeat=2)) == [('a', 'a')]
+    assert list(cartes(list(range(2)))) == [(0,), (1,)]
+
+
+def test_filter_symbols():
+    s = numbered_symbols()
+    filtered = filter_symbols(s, symbols("x0 x2 x3"))
+    assert take(filtered, 3) == list(symbols("x1 x4 x5"))
+
+
+def test_numbered_symbols():
+    s = numbered_symbols(cls=Dummy)
+    assert isinstance(next(s), Dummy)
+    assert next(numbered_symbols('C', start=1, exclude=[symbols('C1')])) == \
+        symbols('C2')
+
+
+def test_sift():
+    assert sift(list(range(5)), lambda _: _ % 2) == {1: [1, 3], 0: [0, 2, 4]}
+    assert sift([x, y], lambda _: _.has(x)) == {False: [y], True: [x]}
+    assert sift([S.One], lambda _: _.has(x)) == {False: [1]}
+    assert sift([0, 1, 2, 3], lambda x: x % 2, binary=True) == (
+        [1, 3], [0, 2])
+    assert sift([0, 1, 2, 3], lambda x: x % 3 == 1, binary=True) == (
+        [1], [0, 2, 3])
+    raises(ValueError, lambda:
+        sift([0, 1, 2, 3], lambda x: x % 3, binary=True))
+
+
+def test_take():
+    X = numbered_symbols()
+
+    assert take(X, 5) == list(symbols('x0:5'))
+    assert take(X, 5) == list(symbols('x5:10'))
+
+    assert take([1, 2, 3, 4, 5], 5) == [1, 2, 3, 4, 5]
+
+
+def test_dict_merge():
+    assert dict_merge({}, {1: x, y: z}) == {1: x, y: z}
+    assert dict_merge({1: x, y: z}, {}) == {1: x, y: z}
+
+    assert dict_merge({2: z}, {1: x, y: z}) == {1: x, 2: z, y: z}
+    assert dict_merge({1: x, y: z}, {2: z}) == {1: x, 2: z, y: z}
+
+    assert dict_merge({1: y, 2: z}, {1: x, y: z}) == {1: x, 2: z, y: z}
+    assert dict_merge({1: x, y: z}, {1: y, 2: z}) == {1: y, 2: z, y: z}
+
+
+def test_prefixes():
+    assert list(prefixes([])) == []
+    assert list(prefixes([1])) == [[1]]
+    assert list(prefixes([1, 2])) == [[1], [1, 2]]
+
+    assert list(prefixes([1, 2, 3, 4, 5])) == \
+        [[1], [1, 2], [1, 2, 3], [1, 2, 3, 4], [1, 2, 3, 4, 5]]
+
+
+def test_postfixes():
+    assert list(postfixes([])) == []
+    assert list(postfixes([1])) == [[1]]
+    assert list(postfixes([1, 2])) == [[2], [1, 2]]
+
+    assert list(postfixes([1, 2, 3, 4, 5])) == \
+        [[5], [4, 5], [3, 4, 5], [2, 3, 4, 5], [1, 2, 3, 4, 5]]
+
+
+def test_topological_sort():
+    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)]
+
+    assert topological_sort((V, E)) == [3, 5, 7, 8, 11, 2, 9, 10]
+    assert topological_sort((V, E), key=lambda v: -v) == \
+        [7, 5, 11, 3, 10, 8, 9, 2]
+
+    raises(ValueError, lambda: topological_sort((V, E + [(10, 7)])))
+
+
+def test_strongly_connected_components():
+    assert strongly_connected_components(([], [])) == []
+    assert strongly_connected_components(([1, 2, 3], [])) == [[1], [2], [3]]
+
+    V = [1, 2, 3]
+    E = [(1, 2), (1, 3), (2, 1), (2, 3), (3, 1)]
+    assert strongly_connected_components((V, E)) == [[1, 2, 3]]
+
+    V = [1, 2, 3, 4]
+    E = [(1, 2), (2, 3), (3, 2), (3, 4)]
+    assert strongly_connected_components((V, E)) == [[4], [2, 3], [1]]
+
+    V = [1, 2, 3, 4]
+    E = [(1, 2), (2, 1), (3, 4), (4, 3)]
+    assert strongly_connected_components((V, E)) == [[1, 2], [3, 4]]
+
+
+def test_connected_components():
+    assert connected_components(([], [])) == []
+    assert connected_components(([1, 2, 3], [])) == [[1], [2], [3]]
+
+    V = [1, 2, 3]
+    E = [(1, 2), (1, 3), (2, 1), (2, 3), (3, 1)]
+    assert connected_components((V, E)) == [[1, 2, 3]]
+
+    V = [1, 2, 3, 4]
+    E = [(1, 2), (2, 3), (3, 2), (3, 4)]
+    assert connected_components((V, E)) == [[1, 2, 3, 4]]
+
+    V = [1, 2, 3, 4]
+    E = [(1, 2), (3, 4)]
+    assert connected_components((V, E)) == [[1, 2], [3, 4]]
+
+
+def test_rotate():
+    A = [0, 1, 2, 3, 4]
+
+    assert rotate_left(A, 2) == [2, 3, 4, 0, 1]
+    assert rotate_right(A, 1) == [4, 0, 1, 2, 3]
+    A = []
+    B = rotate_right(A, 1)
+    assert B == []
+    B.append(1)
+    assert A == []
+    B = rotate_left(A, 1)
+    assert B == []
+    B.append(1)
+    assert A == []
+
+
+def test_multiset_partitions():
+    A = [0, 1, 2, 3, 4]
+
+    assert list(multiset_partitions(A, 5)) == [[[0], [1], [2], [3], [4]]]
+    assert len(list(multiset_partitions(A, 4))) == 10
+    assert len(list(multiset_partitions(A, 3))) == 25
+
+    assert list(multiset_partitions([1, 1, 1, 2, 2], 2)) == [
+        [[1, 1, 1, 2], [2]], [[1, 1, 1], [2, 2]], [[1, 1, 2, 2], [1]],
+        [[1, 1, 2], [1, 2]], [[1, 1], [1, 2, 2]]]
+
+    assert list(multiset_partitions([1, 1, 2, 2], 2)) == [
+        [[1, 1, 2], [2]], [[1, 1], [2, 2]], [[1, 2, 2], [1]],
+        [[1, 2], [1, 2]]]
+
+    assert 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]]]
+
+    assert list(multiset_partitions([1, 2, 2], 2)) == [
+        [[1, 2], [2]], [[1], [2, 2]]]
+
+    assert list(multiset_partitions(3)) == [
+        [[0, 1, 2]], [[0, 1], [2]], [[0, 2], [1]], [[0], [1, 2]],
+        [[0], [1], [2]]]
+    assert list(multiset_partitions(3, 2)) == [
+        [[0, 1], [2]], [[0, 2], [1]], [[0], [1, 2]]]
+    assert list(multiset_partitions([1] * 3, 2)) == [[[1], [1, 1]]]
+    assert list(multiset_partitions([1] * 3)) == [
+        [[1, 1, 1]], [[1], [1, 1]], [[1], [1], [1]]]
+    a = [3, 2, 1]
+    assert list(multiset_partitions(a)) == \
+        list(multiset_partitions(sorted(a)))
+    assert list(multiset_partitions(a, 5)) == []
+    assert list(multiset_partitions(a, 1)) == [[[1, 2, 3]]]
+    assert list(multiset_partitions(a + [4], 5)) == []
+    assert list(multiset_partitions(a + [4], 1)) == [[[1, 2, 3, 4]]]
+    assert list(multiset_partitions(2, 5)) == []
+    assert list(multiset_partitions(2, 1)) == [[[0, 1]]]
+    assert list(multiset_partitions('a')) == [[['a']]]
+    assert list(multiset_partitions('a', 2)) == []
+    assert list(multiset_partitions('ab')) == [[['a', 'b']], [['a'], ['b']]]
+    assert list(multiset_partitions('ab', 1)) == [[['a', 'b']]]
+    assert list(multiset_partitions('aaa', 1)) == [['aaa']]
+    assert list(multiset_partitions([1, 1], 1)) == [[[1, 1]]]
+    ans = [('mpsyy',), ('mpsy', 'y'), ('mps', 'yy'), ('mps', 'y', 'y'),
+           ('mpyy', 's'), ('mpy', 'sy'), ('mpy', 's', 'y'), ('mp', 'syy'),
+           ('mp', 'sy', 'y'), ('mp', 's', 'yy'), ('mp', 's', 'y', 'y'),
+           ('msyy', 'p'), ('msy', 'py'), ('msy', 'p', 'y'), ('ms', 'pyy'),
+           ('ms', 'py', 'y'), ('ms', 'p', 'yy'), ('ms', 'p', 'y', 'y'),
+           ('myy', 'ps'), ('myy', 'p', 's'), ('my', 'psy'), ('my', 'ps', 'y'),
+           ('my', 'py', 's'), ('my', 'p', 'sy'), ('my', 'p', 's', 'y'),
+           ('m', 'psyy'), ('m', 'psy', 'y'), ('m', 'ps', 'yy'),
+           ('m', 'ps', 'y', 'y'), ('m', 'pyy', 's'), ('m', 'py', 'sy'),
+           ('m', 'py', 's', 'y'), ('m', 'p', 'syy'),
+           ('m', 'p', 'sy', 'y'), ('m', 'p', 's', 'yy'),
+           ('m', 'p', 's', 'y', 'y')]
+    assert [tuple("".join(part) for part in p)
+                for p in multiset_partitions('sympy')] == ans
+    factorings = [[24], [8, 3], [12, 2], [4, 6], [4, 2, 3],
+                  [6, 2, 2], [2, 2, 2, 3]]
+    assert [factoring_visitor(p, [2,3]) for
+                p in multiset_partitions_taocp([3, 1])] == factorings
+
+
+def test_multiset_combinations():
+    ans = ['iii', 'iim', 'iip', 'iis', 'imp', 'ims', 'ipp', 'ips',
+           'iss', 'mpp', 'mps', 'mss', 'pps', 'pss', 'sss']
+    assert [''.join(i) for i in
+            list(multiset_combinations('mississippi', 3))] == ans
+    M = multiset('mississippi')
+    assert [''.join(i) for i in
+            list(multiset_combinations(M, 3))] == ans
+    assert [''.join(i) for i in multiset_combinations(M, 30)] == []
+    assert list(multiset_combinations([[1], [2, 3]], 2)) == [[[1], [2, 3]]]
+    assert len(list(multiset_combinations('a', 3))) == 0
+    assert len(list(multiset_combinations('a', 0))) == 1
+    assert list(multiset_combinations('abc', 1)) == [['a'], ['b'], ['c']]
+    raises(ValueError, lambda: list(multiset_combinations({0: 3, 1: -1}, 2)))
+
+
+def test_multiset_permutations():
+    ans = ['abby', 'abyb', 'aybb', 'baby', 'bayb', 'bbay', 'bbya', 'byab',
+           'byba', 'yabb', 'ybab', 'ybba']
+    assert [''.join(i) for i in multiset_permutations('baby')] == ans
+    assert [''.join(i) for i in multiset_permutations(multiset('baby'))] == ans
+    assert list(multiset_permutations([0, 0, 0], 2)) == [[0, 0]]
+    assert list(multiset_permutations([0, 2, 1], 2)) == [
+        [0, 1], [0, 2], [1, 0], [1, 2], [2, 0], [2, 1]]
+    assert len(list(multiset_permutations('a', 0))) == 1
+    assert len(list(multiset_permutations('a', 3))) == 0
+    for nul in ([], {}, ''):
+        assert list(multiset_permutations(nul)) == [[]]
+    assert list(multiset_permutations(nul, 0)) == [[]]
+    # impossible requests give no result
+    assert list(multiset_permutations(nul, 1)) == []
+    assert list(multiset_permutations(nul, -1)) == []
+
+    def test():
+        for i in range(1, 7):
+            print(i)
+            for p in multiset_permutations([0, 0, 1, 0, 1], i):
+                print(p)
+    assert capture(lambda: test()) == dedent('''\
+        1
+        [0]
+        [1]
+        2
+        [0, 0]
+        [0, 1]
+        [1, 0]
+        [1, 1]
+        3
+        [0, 0, 0]
+        [0, 0, 1]
+        [0, 1, 0]
+        [0, 1, 1]
+        [1, 0, 0]
+        [1, 0, 1]
+        [1, 1, 0]
+        4
+        [0, 0, 0, 1]
+        [0, 0, 1, 0]
+        [0, 0, 1, 1]
+        [0, 1, 0, 0]
+        [0, 1, 0, 1]
+        [0, 1, 1, 0]
+        [1, 0, 0, 0]
+        [1, 0, 0, 1]
+        [1, 0, 1, 0]
+        [1, 1, 0, 0]
+        5
+        [0, 0, 0, 1, 1]
+        [0, 0, 1, 0, 1]
+        [0, 0, 1, 1, 0]
+        [0, 1, 0, 0, 1]
+        [0, 1, 0, 1, 0]
+        [0, 1, 1, 0, 0]
+        [1, 0, 0, 0, 1]
+        [1, 0, 0, 1, 0]
+        [1, 0, 1, 0, 0]
+        [1, 1, 0, 0, 0]
+        6\n''')
+    raises(ValueError, lambda: list(multiset_permutations({0: 3, 1: -1})))
+
+
+def test_partitions():
+    ans = [[{}], [(0, {})]]
+    for i in range(2):
+        assert list(partitions(0, size=i)) == ans[i]
+        assert list(partitions(1, 0, size=i)) == ans[i]
+        assert list(partitions(6, 2, 2, size=i)) == ans[i]
+        assert list(partitions(6, 2, None, size=i)) != ans[i]
+        assert list(partitions(6, None, 2, size=i)) != ans[i]
+        assert list(partitions(6, 2, 0, size=i)) == ans[i]
+
+    assert list(partitions(6, k=2)) == [
+        {2: 3}, {1: 2, 2: 2}, {1: 4, 2: 1}, {1: 6}]
+
+    assert list(partitions(6, k=3)) == [
+        {3: 2}, {1: 1, 2: 1, 3: 1}, {1: 3, 3: 1}, {2: 3}, {1: 2, 2: 2},
+        {1: 4, 2: 1}, {1: 6}]
+
+    assert list(partitions(8, k=4, m=3)) == [
+        {4: 2}, {1: 1, 3: 1, 4: 1}, {2: 2, 4: 1}, {2: 1, 3: 2}] == [
+        i for i in partitions(8, k=4, m=3) if all(k <= 4 for k in i)
+        and sum(i.values()) <=3]
+
+    assert list(partitions(S(3), m=2)) == [
+        {3: 1}, {1: 1, 2: 1}]
+
+    assert list(partitions(4, k=3)) == [
+        {1: 1, 3: 1}, {2: 2}, {1: 2, 2: 1}, {1: 4}] == [
+        i for i in partitions(4) if all(k <= 3 for k in i)]
+
+
+    # Consistency check on output of _partitions and RGS_unrank.
+    # This provides a sanity test on both routines.  Also verifies that
+    # the total number of partitions is the same in each case.
+    #    (from pkrathmann2)
+
+    for n in range(2, 6):
+        i  = 0
+        for m, q  in _set_partitions(n):
+            assert  q == RGS_unrank(i, n)
+            i += 1
+        assert i == RGS_enum(n)
+
+
+def test_binary_partitions():
+    assert [i[:] for i in binary_partitions(10)] == [[8, 2], [8, 1, 1],
+        [4, 4, 2], [4, 4, 1, 1], [4, 2, 2, 2], [4, 2, 2, 1, 1],
+        [4, 2, 1, 1, 1, 1], [4, 1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 2],
+        [2, 2, 2, 2, 1, 1], [2, 2, 2, 1, 1, 1, 1], [2, 2, 1, 1, 1, 1, 1, 1],
+        [2, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]
+
+    assert len([j[:] for j in binary_partitions(16)]) == 36
+
+
+def test_bell_perm():
+    assert [len(set(generate_bell(i))) for i in range(1, 7)] == [
+        factorial(i) for i in range(1, 7)]
+    assert list(generate_bell(3)) == [
+        (0, 1, 2), (0, 2, 1), (2, 0, 1), (2, 1, 0), (1, 2, 0), (1, 0, 2)]
+    # generate_bell and trotterjohnson are advertised to return the same
+    # permutations; this is not technically necessary so this test could
+    # be removed
+    for n in range(1, 5):
+        p = Permutation(range(n))
+        b = generate_bell(n)
+        for bi in b:
+            assert bi == tuple(p.array_form)
+            p = p.next_trotterjohnson()
+    raises(ValueError, lambda: list(generate_bell(0)))  # XXX is this consistent with other permutation algorithms?
+
+
+def test_involutions():
+    lengths = [1, 2, 4, 10, 26, 76]
+    for n, N in enumerate(lengths):
+        i = list(generate_involutions(n + 1))
+        assert len(i) == N
+        assert len({Permutation(j)**2 for j in i}) == 1
+
+
+def test_derangements():
+    assert len(list(generate_derangements(list(range(6))))) == 265
+    assert ''.join(''.join(i) for i in generate_derangements('abcde')) == (
+    'badecbaecdbcaedbcdeabceadbdaecbdeacbdecabeacdbedacbedcacabedcadebcaebd'
+    'cdaebcdbeacdeabcdebaceabdcebadcedabcedbadabecdaebcdaecbdcaebdcbeadceab'
+    'dcebadeabcdeacbdebacdebcaeabcdeadbceadcbecabdecbadecdabecdbaedabcedacb'
+    'edbacedbca')
+    assert list(generate_derangements([0, 1, 2, 3])) == [
+        [1, 0, 3, 2], [1, 2, 3, 0], [1, 3, 0, 2], [2, 0, 3, 1],
+        [2, 3, 0, 1], [2, 3, 1, 0], [3, 0, 1, 2], [3, 2, 0, 1], [3, 2, 1, 0]]
+    assert list(generate_derangements([0, 1, 2, 2])) == [
+        [2, 2, 0, 1], [2, 2, 1, 0]]
+    assert list(generate_derangements('ba')) == [list('ab')]
+    # multiset_derangements
+    D = multiset_derangements
+    assert list(D('abb')) == []
+    assert [''.join(i) for i in D('ab')] == ['ba']
+    assert [''.join(i) for i in D('abc')] == ['bca', 'cab']
+    assert [''.join(i) for i in D('aabb')] == ['bbaa']
+    assert [''.join(i) for i in D('aabbcccc')] == [
+        'ccccaabb', 'ccccabab', 'ccccabba', 'ccccbaab', 'ccccbaba',
+        'ccccbbaa']
+    assert [''.join(i) for i in D('aabbccc')] == [
+        'cccabba', 'cccabab', 'cccaabb', 'ccacbba', 'ccacbab',
+        'ccacabb', 'cbccbaa', 'cbccaba', 'cbccaab', 'bcccbaa',
+        'bcccaba', 'bcccaab']
+    assert [''.join(i) for i in D('books')] == ['kbsoo', 'ksboo',
+        'sbkoo', 'skboo', 'oksbo', 'oskbo', 'okbso', 'obkso', 'oskob',
+        'oksob', 'osbok', 'obsok']
+    assert list(generate_derangements([[3], [2], [2], [1]])) == [
+        [[2], [1], [3], [2]], [[2], [3], [1], [2]]]
+
+
+def test_necklaces():
+    def count(n, k, f):
+        return len(list(necklaces(n, k, f)))
+    m = []
+    for i in range(1, 8):
+        m.append((
+        i, count(i, 2, 0), count(i, 2, 1), count(i, 3, 1)))
+    assert Matrix(m) == Matrix([
+        [1,   2,   2,   3],
+        [2,   3,   3,   6],
+        [3,   4,   4,  10],
+        [4,   6,   6,  21],
+        [5,   8,   8,  39],
+        [6,  14,  13,  92],
+        [7,  20,  18, 198]])
+
+
+def test_bracelets():
+    bc = list(bracelets(2, 4))
+    assert Matrix(bc) == Matrix([
+        [0, 0],
+        [0, 1],
+        [0, 2],
+        [0, 3],
+        [1, 1],
+        [1, 2],
+        [1, 3],
+        [2, 2],
+        [2, 3],
+        [3, 3]
+        ])
+    bc = list(bracelets(4, 2))
+    assert Matrix(bc) == Matrix([
+        [0, 0, 0, 0],
+        [0, 0, 0, 1],
+        [0, 0, 1, 1],
+        [0, 1, 0, 1],
+        [0, 1, 1, 1],
+        [1, 1, 1, 1]
+    ])
+
+
+def test_generate_oriented_forest():
+    assert list(generate_oriented_forest(5)) == [[0, 1, 2, 3, 4],
+        [0, 1, 2, 3, 3], [0, 1, 2, 3, 2], [0, 1, 2, 3, 1], [0, 1, 2, 3, 0],
+        [0, 1, 2, 2, 2], [0, 1, 2, 2, 1], [0, 1, 2, 2, 0], [0, 1, 2, 1, 2],
+        [0, 1, 2, 1, 1], [0, 1, 2, 1, 0], [0, 1, 2, 0, 1], [0, 1, 2, 0, 0],
+        [0, 1, 1, 1, 1], [0, 1, 1, 1, 0], [0, 1, 1, 0, 1], [0, 1, 1, 0, 0],
+        [0, 1, 0, 1, 0], [0, 1, 0, 0, 0], [0, 0, 0, 0, 0]]
+    assert len(list(generate_oriented_forest(10))) == 1842
+
+
+def test_unflatten():
+    r = list(range(10))
+    assert unflatten(r) == list(zip(r[::2], r[1::2]))
+    assert unflatten(r, 5) == [tuple(r[:5]), tuple(r[5:])]
+    raises(ValueError, lambda: unflatten(list(range(10)), 3))
+    raises(ValueError, lambda: unflatten(list(range(10)), -2))
+
+
+def test_common_prefix_suffix():
+    assert common_prefix([], [1]) == []
+    assert common_prefix(list(range(3))) == [0, 1, 2]
+    assert common_prefix(list(range(3)), list(range(4))) == [0, 1, 2]
+    assert common_prefix([1, 2, 3], [1, 2, 5]) == [1, 2]
+    assert common_prefix([1, 2, 3], [1, 3, 5]) == [1]
+
+    assert common_suffix([], [1]) == []
+    assert common_suffix(list(range(3))) == [0, 1, 2]
+    assert common_suffix(list(range(3)), list(range(3))) == [0, 1, 2]
+    assert common_suffix(list(range(3)), list(range(4))) == []
+    assert common_suffix([1, 2, 3], [9, 2, 3]) == [2, 3]
+    assert common_suffix([1, 2, 3], [9, 7, 3]) == [3]
+
+
+def test_minlex():
+    assert minlex([1, 2, 0]) == (0, 1, 2)
+    assert minlex((1, 2, 0)) == (0, 1, 2)
+    assert minlex((1, 0, 2)) == (0, 2, 1)
+    assert minlex((1, 0, 2), directed=False) == (0, 1, 2)
+    assert minlex('aba') == 'aab'
+    assert minlex(('bb', 'aaa', 'c', 'a'), key=len) == ('c', 'a', 'bb', 'aaa')
+
+
+def test_ordered():
+    assert list(ordered((x, y), hash, default=False)) in [[x, y], [y, x]]
+    assert list(ordered((x, y), hash, default=False)) == \
+        list(ordered((y, x), hash, default=False))
+    assert list(ordered((x, y))) == [x, y]
+
+    seq, keys = [[[1, 2, 1], [0, 3, 1], [1, 1, 3], [2], [1]],
+                 (lambda x: len(x), lambda x: sum(x))]
+    assert list(ordered(seq, keys, default=False, warn=False)) == \
+        [[1], [2], [1, 2, 1], [0, 3, 1], [1, 1, 3]]
+    raises(ValueError, lambda:
+           list(ordered(seq, keys, default=False, warn=True)))
+
+
+def test_runs():
+    assert runs([]) == []
+    assert runs([1]) == [[1]]
+    assert runs([1, 1]) == [[1], [1]]
+    assert runs([1, 1, 2]) == [[1], [1, 2]]
+    assert runs([1, 2, 1]) == [[1, 2], [1]]
+    assert runs([2, 1, 1]) == [[2], [1], [1]]
+    from operator import lt
+    assert runs([2, 1, 1], lt) == [[2, 1], [1]]
+
+
+def test_reshape():
+    seq = list(range(1, 9))
+    assert reshape(seq, [4]) == \
+        [[1, 2, 3, 4], [5, 6, 7, 8]]
+    assert reshape(seq, (4,)) == \
+        [(1, 2, 3, 4), (5, 6, 7, 8)]
+    assert reshape(seq, (2, 2)) == \
+        [(1, 2, 3, 4), (5, 6, 7, 8)]
+    assert reshape(seq, (2, [2])) == \
+        [(1, 2, [3, 4]), (5, 6, [7, 8])]
+    assert reshape(seq, ((2,), [2])) == \
+        [((1, 2), [3, 4]), ((5, 6), [7, 8])]
+    assert reshape(seq, (1, [2], 1)) == \
+        [(1, [2, 3], 4), (5, [6, 7], 8)]
+    assert reshape(tuple(seq), ([[1], 1, (2,)],)) == \
+        (([[1], 2, (3, 4)],), ([[5], 6, (7, 8)],))
+    assert reshape(tuple(seq), ([1], 1, (2,))) == \
+        (([1], 2, (3, 4)), ([5], 6, (7, 8)))
+    assert reshape(list(range(12)), [2, [3], {2}, (1, (3,), 1)]) == \
+        [[0, 1, [2, 3, 4], {5, 6}, (7, (8, 9, 10), 11)]]
+    raises(ValueError, lambda: reshape([0, 1], [-1]))
+    raises(ValueError, lambda: reshape([0, 1], [3]))
+
+
+def test_uniq():
+    assert list(uniq(p for p in partitions(4))) == \
+        [{4: 1}, {1: 1, 3: 1}, {2: 2}, {1: 2, 2: 1}, {1: 4}]
+    assert list(uniq(x % 2 for x in range(5))) == [0, 1]
+    assert list(uniq('a')) == ['a']
+    assert list(uniq('ababc')) == list('abc')
+    assert list(uniq([[1], [2, 1], [1]])) == [[1], [2, 1]]
+    assert list(uniq(permutations(i for i in [[1], 2, 2]))) == \
+        [([1], 2, 2), (2, [1], 2), (2, 2, [1])]
+    assert list(uniq([2, 3, 2, 4, [2], [1], [2], [3], [1]])) == \
+        [2, 3, 4, [2], [1], [3]]
+    f = [1]
+    raises(RuntimeError, lambda: [f.remove(i) for i in uniq(f)])
+    f = [[1]]
+    raises(RuntimeError, lambda: [f.remove(i) for i in uniq(f)])
+
+
+def test_kbins():
+    assert len(list(kbins('1123', 2, ordered=1))) == 24
+    assert len(list(kbins('1123', 2, ordered=11))) == 36
+    assert len(list(kbins('1123', 2, ordered=10))) == 10
+    assert len(list(kbins('1123', 2, ordered=0))) == 5
+    assert len(list(kbins('1123', 2, ordered=None))) == 3
+
+    def test1():
+        for orderedval in [None, 0, 1, 10, 11]:
+            print('ordered =', orderedval)
+            for p in kbins([0, 0, 1], 2, ordered=orderedval):
+                print('   ', p)
+    assert capture(lambda : test1()) == dedent('''\
+        ordered = None
+            [[0], [0, 1]]
+            [[0, 0], [1]]
+        ordered = 0
+            [[0, 0], [1]]
+            [[0, 1], [0]]
+        ordered = 1
+            [[0], [0, 1]]
+            [[0], [1, 0]]
+            [[1], [0, 0]]
+        ordered = 10
+            [[0, 0], [1]]
+            [[1], [0, 0]]
+            [[0, 1], [0]]
+            [[0], [0, 1]]
+        ordered = 11
+            [[0], [0, 1]]
+            [[0, 0], [1]]
+            [[0], [1, 0]]
+            [[0, 1], [0]]
+            [[1], [0, 0]]
+            [[1, 0], [0]]\n''')
+
+    def test2():
+        for orderedval in [None, 0, 1, 10, 11]:
+            print('ordered =', orderedval)
+            for p in kbins(list(range(3)), 2, ordered=orderedval):
+                print('   ', p)
+    assert capture(lambda : test2()) == dedent('''\
+        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]]\n''')
+
+
+def test_has_dups():
+    assert has_dups(set()) is False
+    assert has_dups(list(range(3))) is False
+    assert has_dups([1, 2, 1]) is True
+    assert has_dups([[1], [1]]) is True
+    assert has_dups([[1], [2]]) is False
+
+
+def test__partition():
+    assert _partition('abcde', [1, 0, 1, 2, 0]) == [
+        ['b', 'e'], ['a', 'c'], ['d']]
+    assert _partition('abcde', [1, 0, 1, 2, 0], 3) == [
+        ['b', 'e'], ['a', 'c'], ['d']]
+    output = (3, [1, 0, 1, 2, 0])
+    assert _partition('abcde', *output) == [['b', 'e'], ['a', 'c'], ['d']]
+
+
+def test_ordered_partitions():
+    from sympy.functions.combinatorial.numbers import nT
+    f = ordered_partitions
+    assert list(f(0, 1)) == [[]]
+    assert list(f(1, 0)) == [[]]
+    for i in range(1, 7):
+        for j in [None] + list(range(1, i)):
+            assert (
+                sum(1 for p in f(i, j, 1)) ==
+                sum(1 for p in f(i, j, 0)) ==
+                nT(i, j))
+
+
+def test_rotations():
+    assert list(rotations('ab')) == [['a', 'b'], ['b', 'a']]
+    assert list(rotations(range(3))) == [[0, 1, 2], [1, 2, 0], [2, 0, 1]]
+    assert list(rotations(range(3), dir=-1)) == [[0, 1, 2], [2, 0, 1], [1, 2, 0]]
+
+
+def test_ibin():
+    assert ibin(3) == [1, 1]
+    assert ibin(3, 3) == [0, 1, 1]
+    assert ibin(3, str=True) == '11'
+    assert ibin(3, 3, str=True) == '011'
+    assert list(ibin(2, 'all')) == [(0, 0), (0, 1), (1, 0), (1, 1)]
+    assert list(ibin(2, '', str=True)) == ['00', '01', '10', '11']
+    raises(ValueError, lambda: ibin(-.5))
+    raises(ValueError, lambda: ibin(2, 1))
+
+
+def test_iterable():
+    assert iterable(0) is False
+    assert iterable(1) is False
+    assert iterable(None) is False
+
+    class Test1(NotIterable):
+        pass
+
+    assert iterable(Test1()) is False
+
+    class Test2(NotIterable):
+        _iterable = True
+
+    assert iterable(Test2()) is True
+
+    class Test3:
+        pass
+
+    assert iterable(Test3()) is False
+
+    class Test4:
+        _iterable = True
+
+    assert iterable(Test4()) is True
+
+    class Test5:
+        def __iter__(self):
+            yield 1
+
+    assert iterable(Test5()) is True
+
+    class Test6(Test5):
+        _iterable = False
+
+    assert iterable(Test6()) is False
+
+
+def test_sequence_partitions():
+    assert list(sequence_partitions([1], 1)) == [[[1]]]
+    assert list(sequence_partitions([1, 2], 1)) == [[[1, 2]]]
+    assert list(sequence_partitions([1, 2], 2)) == [[[1], [2]]]
+    assert list(sequence_partitions([1, 2, 3], 1)) == [[[1, 2, 3]]]
+    assert list(sequence_partitions([1, 2, 3], 2)) == \
+        [[[1], [2, 3]], [[1, 2], [3]]]
+    assert list(sequence_partitions([1, 2, 3], 3)) == [[[1], [2], [3]]]
+
+    # Exceptional cases
+    assert list(sequence_partitions([], 0)) == []
+    assert list(sequence_partitions([], 1)) == []
+    assert list(sequence_partitions([1, 2], 0)) == []
+    assert list(sequence_partitions([1, 2], 3)) == []
+
+
+def test_sequence_partitions_empty():
+    assert list(sequence_partitions_empty([], 1)) == [[[]]]
+    assert list(sequence_partitions_empty([], 2)) == [[[], []]]
+    assert list(sequence_partitions_empty([], 3)) == [[[], [], []]]
+    assert list(sequence_partitions_empty([1], 1)) == [[[1]]]
+    assert list(sequence_partitions_empty([1], 2)) == [[[], [1]], [[1], []]]
+    assert list(sequence_partitions_empty([1], 3)) == \
+        [[[], [], [1]], [[], [1], []], [[1], [], []]]
+    assert list(sequence_partitions_empty([1, 2], 1)) == [[[1, 2]]]
+    assert list(sequence_partitions_empty([1, 2], 2)) == \
+        [[[], [1, 2]], [[1], [2]], [[1, 2], []]]
+    assert list(sequence_partitions_empty([1, 2], 3)) == [
+        [[], [], [1, 2]], [[], [1], [2]], [[], [1, 2], []],
+        [[1], [], [2]], [[1], [2], []], [[1, 2], [], []]
+    ]
+    assert list(sequence_partitions_empty([1, 2, 3], 1)) == [[[1, 2, 3]]]
+    assert list(sequence_partitions_empty([1, 2, 3], 2)) == \
+        [[[], [1, 2, 3]], [[1], [2, 3]], [[1, 2], [3]], [[1, 2, 3], []]]
+    assert list(sequence_partitions_empty([1, 2, 3], 3)) == [
+        [[], [], [1, 2, 3]], [[], [1], [2, 3]],
+        [[], [1, 2], [3]], [[], [1, 2, 3], []],
+        [[1], [], [2, 3]], [[1], [2], [3]],
+        [[1], [2, 3], []], [[1, 2], [], [3]],
+        [[1, 2], [3], []], [[1, 2, 3], [], []]
+    ]
+
+    # Exceptional cases
+    assert list(sequence_partitions([], 0)) == []
+    assert list(sequence_partitions([1], 0)) == []
+    assert list(sequence_partitions([1, 2], 0)) == []
+
+
+def test_signed_permutations():
+    ans = [(0, 1, 1), (0, -1, 1), (0, 1, -1), (0, -1, -1),
+    (1, 0, 1), (-1, 0, 1), (1, 0, -1), (-1, 0, -1),
+    (1, 1, 0), (-1, 1, 0), (1, -1, 0), (-1, -1, 0)]
+    assert list(signed_permutations((0, 1, 1))) == ans
+    assert list(signed_permutations((1, 0, 1))) == ans
+    assert list(signed_permutations((1, 1, 0))) == ans

.venv/lib/python3.13/site-packages/sympy/utilities/tests/test_lambdify.py

@@ -0,0 +1,2263 @@
+from itertools import product
+import math
+import inspect
+import linecache
+import gc
+
+import mpmath
+import cmath
+
+from sympy.testing.pytest import raises, warns_deprecated_sympy
+from sympy.concrete.summations import Sum
+from sympy.core.function import (Function, Lambda, diff)
+from sympy.core.numbers import (E, Float, I, Rational, all_close, oo, pi)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.functions.combinatorial.factorials import (RisingFactorial, factorial)
+from sympy.functions.combinatorial.numbers import bernoulli, harmonic
+from sympy.functions.elementary.complexes import Abs, sign
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.elementary.hyperbolic import asinh,acosh,atanh
+from sympy.functions.elementary.integers import floor
+from sympy.functions.elementary.miscellaneous import (Max, Min, sqrt)
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (asin, acos, atan, cos, cot, sin,
+                                                      sinc, tan)
+from sympy.functions import sinh,cosh,tanh
+from sympy.functions.special.bessel import (besseli, besselj, besselk, bessely, jn, yn)
+from sympy.functions.special.beta_functions import (beta, betainc, betainc_regularized)
+from sympy.functions.special.delta_functions import (Heaviside)
+from sympy.functions.special.error_functions import (Ei, erf, erfc, fresnelc, fresnels, Si, Ci)
+from sympy.functions.special.gamma_functions import (digamma, gamma, loggamma, polygamma)
+from sympy.functions.special.zeta_functions import zeta
+from sympy.integrals.integrals import Integral
+from sympy.logic.boolalg import (And, false, ITE, Not, Or, true)
+from sympy.matrices.expressions.dotproduct import DotProduct
+from sympy.simplify.cse_main import cse
+from sympy.tensor.array import derive_by_array, Array
+from sympy.tensor.array.expressions import ArraySymbol
+from sympy.tensor.indexed import IndexedBase, Idx
+from sympy.utilities.lambdify import lambdify
+from sympy.utilities.iterables import numbered_symbols
+from sympy.vector import CoordSys3D
+from sympy.core.expr import UnevaluatedExpr
+from sympy.codegen.cfunctions import expm1, log1p, exp2, log2, log10, hypot, isnan, isinf
+from sympy.codegen.numpy_nodes import logaddexp, logaddexp2, amin, amax, minimum, maximum
+from sympy.codegen.scipy_nodes import cosm1, powm1
+from sympy.functions.elementary.complexes import re, im, arg
+from sympy.functions.special.polynomials import \
+    chebyshevt, chebyshevu, legendre, hermite, laguerre, gegenbauer, \
+    assoc_legendre, assoc_laguerre, jacobi
+from sympy.matrices import Matrix, MatrixSymbol, SparseMatrix
+from sympy.printing.codeprinter import PrintMethodNotImplementedError
+from sympy.printing.lambdarepr import LambdaPrinter
+from sympy.printing.numpy import NumPyPrinter
+from sympy.utilities.lambdify import implemented_function, lambdastr
+from sympy.testing.pytest import skip
+from sympy.utilities.decorator import conserve_mpmath_dps
+from sympy.utilities.exceptions import ignore_warnings
+from sympy.external import import_module
+from sympy.functions.special.gamma_functions import uppergamma, lowergamma
+
+
+import sympy
+
+
+MutableDenseMatrix = Matrix
+
+numpy = import_module('numpy')
+scipy = import_module('scipy', import_kwargs={'fromlist': ['sparse']})
+numexpr = import_module('numexpr')
+tensorflow = import_module('tensorflow')
+cupy = import_module('cupy')
+jax = import_module('jax')
+numba = import_module('numba')
+
+if tensorflow:
+    # Hide Tensorflow warnings
+    import os
+    os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+
+w, x, y, z = symbols('w,x,y,z')
+
+#================== Test different arguments =======================
+
+
+def test_no_args():
+    f = lambdify([], 1)
+    raises(TypeError, lambda: f(-1))
+    assert f() == 1
+
+
+def test_single_arg():
+    f = lambdify(x, 2*x)
+    assert f(1) == 2
+
+
+def test_list_args():
+    f = lambdify([x, y], x + y)
+    assert f(1, 2) == 3
+
+
+def test_nested_args():
+    f1 = lambdify([[w, x]], [w, x])
+    assert f1([91, 2]) == [91, 2]
+    raises(TypeError, lambda: f1(1, 2))
+
+    f2 = lambdify([(w, x), (y, z)], [w, x, y, z])
+    assert f2((18, 12), (73, 4)) == [18, 12, 73, 4]
+    raises(TypeError, lambda: f2(3, 4))
+
+    f3 = lambdify([w, [[[x]], y], z], [w, x, y, z])
+    assert f3(10, [[[52]], 31], 44) == [10, 52, 31, 44]
+
+
+def test_str_args():
+    f = lambdify('x,y,z', 'z,y,x')
+    assert f(3, 2, 1) == (1, 2, 3)
+    assert f(1.0, 2.0, 3.0) == (3.0, 2.0, 1.0)
+    # make sure correct number of args required
+    raises(TypeError, lambda: f(0))
+
+
+def test_own_namespace_1():
+    myfunc = lambda x: 1
+    f = lambdify(x, sin(x), {"sin": myfunc})
+    assert f(0.1) == 1
+    assert f(100) == 1
+
+
+def test_own_namespace_2():
+    def myfunc(x):
+        return 1
+    f = lambdify(x, sin(x), {'sin': myfunc})
+    assert f(0.1) == 1
+    assert f(100) == 1
+
+
+def test_own_module():
+    f = lambdify(x, sin(x), math)
+    assert f(0) == 0.0
+
+    p, q, r = symbols("p q r", real=True)
+    ae = abs(exp(p+UnevaluatedExpr(q+r)))
+    f = lambdify([p, q, r], [ae, ae], modules=math)
+    results = f(1.0, 1e18, -1e18)
+    refvals = [math.exp(1.0)]*2
+    for res, ref in zip(results, refvals):
+        assert abs((res-ref)/ref) < 1e-15
+
+
+def test_bad_args():
+    # no vargs given
+    raises(TypeError, lambda: lambdify(1))
+    # same with vector exprs
+    raises(TypeError, lambda: lambdify([1, 2]))
+
+
+def test_atoms():
+    # Non-Symbol atoms should not be pulled out from the expression namespace
+    f = lambdify(x, pi + x, {"pi": 3.14})
+    assert f(0) == 3.14
+    f = lambdify(x, I + x, {"I": 1j})
+    assert f(1) == 1 + 1j
+
+#================== Test different modules =========================
+
+# high precision output of sin(0.2*pi) is used to detect if precision is lost unwanted
+
+
+@conserve_mpmath_dps
+def test_sympy_lambda():
+    mpmath.mp.dps = 50
+    sin02 = mpmath.mpf("0.19866933079506121545941262711838975037020672954020")
+    f = lambdify(x, sin(x), "sympy")
+    assert f(x) == sin(x)
+    prec = 1e-15
+    assert -prec < f(Rational(1, 5)).evalf() - Float(str(sin02)) < prec
+    # arctan is in numpy module and should not be available
+    # The arctan below gives NameError. What is this supposed to test?
+    # raises(NameError, lambda: lambdify(x, arctan(x), "sympy"))
+
+
+@conserve_mpmath_dps
+def test_math_lambda():
+    mpmath.mp.dps = 50
+    sin02 = mpmath.mpf("0.19866933079506121545941262711838975037020672954020")
+    f = lambdify(x, sin(x), "math")
+    prec = 1e-15
+    assert -prec < f(0.2) - sin02 < prec
+    raises(TypeError, lambda: f(x))
+           # if this succeeds, it can't be a Python math function
+
+
+@conserve_mpmath_dps
+def test_mpmath_lambda():
+    mpmath.mp.dps = 50
+    sin02 = mpmath.mpf("0.19866933079506121545941262711838975037020672954020")
+    f = lambdify(x, sin(x), "mpmath")
+    prec = 1e-49  # mpmath precision is around 50 decimal places
+    assert -prec < f(mpmath.mpf("0.2")) - sin02 < prec
+    raises(TypeError, lambda: f(x))
+           # if this succeeds, it can't be a mpmath function
+
+    ref2 = (mpmath.mpf("1e-30")
+            - mpmath.mpf("1e-45")/2
+            + 5*mpmath.mpf("1e-60")/6
+            - 3*mpmath.mpf("1e-75")/4
+            + 33*mpmath.mpf("1e-90")/40
+            )
+    f2a = lambdify((x, y), x**y - 1, "mpmath")
+    f2b = lambdify((x, y), powm1(x, y), "mpmath")
+    f2c = lambdify((x,), expm1(x*log1p(x)), "mpmath")
+    ans2a = f2a(mpmath.mpf("1")+mpmath.mpf("1e-15"), mpmath.mpf("1e-15"))
+    ans2b = f2b(mpmath.mpf("1")+mpmath.mpf("1e-15"), mpmath.mpf("1e-15"))
+    ans2c = f2c(mpmath.mpf("1e-15"))
+    assert abs(ans2a - ref2) < 1e-51
+    assert abs(ans2b - ref2) < 1e-67
+    assert abs(ans2c - ref2) < 1e-80
+
+
+@conserve_mpmath_dps
+def test_number_precision():
+    mpmath.mp.dps = 50
+    sin02 = mpmath.mpf("0.19866933079506121545941262711838975037020672954020")
+    f = lambdify(x, sin02, "mpmath")
+    prec = 1e-49  # mpmath precision is around 50 decimal places
+    assert -prec < f(0) - sin02 < prec
+
+@conserve_mpmath_dps
+def test_mpmath_precision():
+    mpmath.mp.dps = 100
+    assert str(lambdify((), pi.evalf(100), 'mpmath')()) == str(pi.evalf(100))
+
+#================== Test Translations ==============================
+# We can only check if all translated functions are valid. It has to be checked
+# by hand if they are complete.
+
+
+def test_math_transl():
+    from sympy.utilities.lambdify import MATH_TRANSLATIONS
+    for sym, mat in MATH_TRANSLATIONS.items():
+        assert sym in sympy.__dict__
+        assert mat in math.__dict__
+
+
+def test_mpmath_transl():
+    from sympy.utilities.lambdify import MPMATH_TRANSLATIONS
+    for sym, mat in MPMATH_TRANSLATIONS.items():
+        assert sym in sympy.__dict__ or sym == 'Matrix'
+        assert mat in mpmath.__dict__
+
+
+def test_numpy_transl():
+    if not numpy:
+        skip("numpy not installed.")
+
+    from sympy.utilities.lambdify import NUMPY_TRANSLATIONS
+    for sym, nump in NUMPY_TRANSLATIONS.items():
+        assert sym in sympy.__dict__
+        assert nump in numpy.__dict__
+
+
+def test_scipy_transl():
+    if not scipy:
+        skip("scipy not installed.")
+
+    from sympy.utilities.lambdify import SCIPY_TRANSLATIONS
+    for sym, scip in SCIPY_TRANSLATIONS.items():
+        assert sym in sympy.__dict__
+        assert scip in scipy.__dict__ or scip in scipy.special.__dict__
+
+
+def test_numpy_translation_abs():
+    if not numpy:
+        skip("numpy not installed.")
+
+    f = lambdify(x, Abs(x), "numpy")
+    assert f(-1) == 1
+    assert f(1) == 1
+
+
+def test_numexpr_printer():
+    if not numexpr:
+        skip("numexpr not installed.")
+
+    # if translation/printing is done incorrectly then evaluating
+    # a lambdified numexpr expression will throw an exception
+    from sympy.printing.lambdarepr import NumExprPrinter
+
+    blacklist = ('where', 'complex', 'contains')
+    arg_tuple = (x, y, z) # some functions take more than one argument
+    for sym in NumExprPrinter._numexpr_functions.keys():
+        if sym in blacklist:
+            continue
+        ssym = S(sym)
+        if hasattr(ssym, '_nargs'):
+            nargs = ssym._nargs[0]
+        else:
+            nargs = 1
+        args = arg_tuple[:nargs]
+        f = lambdify(args, ssym(*args), modules='numexpr')
+        assert f(*(1, )*nargs) is not None
+
+
+def test_cmath_sqrt():
+    f = lambdify(x, sqrt(x), "cmath")
+    assert f(0) == 0
+    assert f(1) == 1
+    assert f(4) == 2
+    assert abs(f(2) - 1.414) < 0.001
+    assert f(-1) == 1j
+    assert f(-4) == 2j
+
+
+def test_cmath_log():
+    f = lambdify(x, log(x), "cmath")
+    assert abs(f(1) - 0) < 1e-15
+    assert abs(f(cmath.e) - 1) < 1e-15
+    assert abs(f(-1) - cmath.log(-1)) < 1e-15
+
+
+def test_cmath_sinh():
+    f = lambdify(x, sinh(x), "cmath")
+    assert abs(f(0) - cmath.sinh(0)) < 1e-15
+    assert abs(f(pi) - cmath.sinh(pi)) < 1e-15
+    assert abs(f(-pi) - cmath.sinh(-pi)) < 1e-15
+    assert abs(f(1j) - cmath.sinh(1j)) < 1e-15
+
+
+def test_cmath_cosh():
+    f = lambdify(x, cosh(x), "cmath")
+    assert abs(f(0) - cmath.cosh(0)) < 1e-15
+    assert abs(f(pi) - cmath.cosh(pi)) < 1e-15
+    assert abs(f(-pi) - cmath.cosh(-pi)) < 1e-15
+    assert abs(f(1j) - cmath.cosh(1j)) < 1e-15
+
+
+def test_cmath_tanh():
+    f = lambdify(x, tanh(x), "cmath")
+    assert abs(f(0) - cmath.tanh(0)) < 1e-15
+    assert abs(f(pi) - cmath.tanh(pi)) < 1e-15
+    assert abs(f(-pi) - cmath.tanh(-pi)) < 1e-15
+    assert abs(f(1j) - cmath.tanh(1j)) < 1e-15
+
+
+def test_cmath_sin():
+    f = lambdify(x, sin(x), "cmath")
+    assert abs(f(0) - cmath.sin(0)) < 1e-15
+    assert abs(f(pi) - cmath.sin(pi)) < 1e-15
+    assert abs(f(-pi) - cmath.sin(-pi)) < 1e-15
+    assert abs(f(1j) - cmath.sin(1j)) < 1e-15
+
+
+def test_cmath_cos():
+    f = lambdify(x, cos(x), "cmath")
+    assert abs(f(0) - cmath.cos(0)) < 1e-15
+    assert abs(f(pi) - cmath.cos(pi)) < 1e-15
+    assert abs(f(-pi) - cmath.cos(-pi)) < 1e-15
+    assert abs(f(1j) - cmath.cos(1j)) < 1e-15
+
+
+def test_cmath_tan():
+    f = lambdify(x, tan(x), "cmath")
+    assert abs(f(0) - cmath.tan(0)) < 1e-15
+    assert abs(f(1j) - cmath.tan(1j)) < 1e-15
+
+
+def test_cmath_asin():
+    f = lambdify(x, asin(x), "cmath")
+    assert abs(f(0) - cmath.asin(0)) < 1e-15
+    assert abs(f(1) - cmath.asin(1)) < 1e-15
+    assert abs(f(-1) - cmath.asin(-1)) < 1e-15
+    assert abs(f(2) - cmath.asin(2)) < 1e-15
+    assert abs(f(1j) - cmath.asin(1j)) < 1e-15
+
+
+def test_cmath_acos():
+    f = lambdify(x, acos(x), "cmath")
+    assert abs(f(1) - cmath.acos(1)) < 1e-15
+    assert abs(f(-1) - cmath.acos(-1)) < 1e-15
+    assert abs(f(2) - cmath.acos(2)) < 1e-15
+    assert abs(f(1j) - cmath.acos(1j)) < 1e-15
+
+
+def test_cmath_atan():
+    f = lambdify(x, atan(x), "cmath")
+    assert abs(f(0) - cmath.atan(0)) < 1e-15
+    assert abs(f(1) - cmath.atan(1)) < 1e-15
+    assert abs(f(-1) - cmath.atan(-1)) < 1e-15
+    assert abs(f(2) - cmath.atan(2)) < 1e-15
+    assert abs(f(2j) - cmath.atan(2j)) < 1e-15
+
+
+def test_cmath_asinh():
+    f = lambdify(x, asinh(x), "cmath")
+    assert abs(f(0) - cmath.asinh(0)) < 1e-15
+    assert abs(f(1) - cmath.asinh(1)) < 1e-15
+    assert abs(f(-1) - cmath.asinh(-1)) < 1e-15
+    assert abs(f(2) - cmath.asinh(2)) < 1e-15
+    assert abs(f(2j) - cmath.asinh(2j)) < 1e-15
+
+
+def test_cmath_acosh():
+    f = lambdify(x, acosh(x), "cmath")
+    assert abs(f(1) - cmath.acosh(1)) < 1e-15
+    assert abs(f(2) - cmath.acosh(2)) < 1e-15
+    assert abs(f(-1) - cmath.acosh(-1)) < 1e-15
+    assert abs(f(2j) - cmath.acosh(2j)) < 1e-15
+
+
+def test_cmath_atanh():
+    f = lambdify(x, atanh(x), "cmath")
+    assert abs(f(0) - cmath.atanh(0)) < 1e-15
+    assert abs(f(0.5) - cmath.atanh(0.5)) < 1e-15
+    assert abs(f(-0.5) - cmath.atanh(-0.5)) < 1e-15
+    assert abs(f(2) - cmath.atanh(2)) < 1e-15
+    assert abs(f(-2) - cmath.atanh(-2)) < 1e-15
+    assert abs(f(2j) - cmath.atanh(2j)) < 1e-15
+
+
+def test_cmath_complex_identities():
+    # Define symbol
+    z = symbols('z')
+
+    # Trigonometric identity using re(z) and im(z)
+    expr = cos(z) - cos(re(z)) * cosh(im(z)) + I * sin(re(z)) * sinh(im(z))
+    func = lambdify([z], expr, modules=["cmath", "math"])
+    hpi = math.pi / 2
+    assert abs(func(hpi + 1j * hpi)) < 4e-16
+
+    # Euler's Formula: e^(i*z) = cos(z) + i*sin(z)
+    func = lambdify([z], exp(I * z) - (cos(z) + I * sin(z)), modules=["cmath", "math"])
+    assert abs(func(hpi)) < 4e-16
+
+    # Exponential Identity: e^z = e^(Re(z)) * (cos(Im(z)) + i*sin(Im(z)))
+    func_exp = lambdify([z], exp(z) - exp(re(z)) * (cos(im(z)) + I * sin(im(z))),
+                        modules=["cmath", "math"])
+    assert abs(func_exp(hpi + 1j * hpi)) < 4e-16
+
+    # Complex Cosine Identity: cos(z) = cos(Re(z)) * cosh(Im(z)) - i*sin(Re(z)) * sinh(Im(z))
+    func_cos = lambdify([z], cos(z) - (cos(re(z)) * cosh(im(z)) - I * sin(re(z)) * sinh(im(z))),
+                        modules=["cmath", "math"])
+    assert abs(func_cos(hpi + 1j * hpi)) < 4e-16
+
+    # Complex Sine Identity: sin(z) = sin(Re(z)) * cosh(Im(z)) + i*cos(Re(z)) * sinh(Im(z))
+    func_sin = lambdify([z], sin(z) - (sin(re(z)) * cosh(im(z)) + I * cos(re(z)) * sinh(im(z))),
+                        modules=["cmath", "math"])
+    assert abs(func_sin(hpi + 1j * hpi)) < 4e-16
+
+    # Complex Hyperbolic Cosine Identity: cosh(z) = cosh(Re(z)) * cos(Im(z)) + i*sinh(Re(z)) * sin(Im(z))
+    func_cosh_1 = lambdify([z], cosh(z) - (cosh(re(z)) * cos(im(z)) + I * sinh(re(z)) * sin(im(z))),
+                         modules=["cmath", "math"])
+    assert abs(func_cosh_1(hpi + 1j * hpi)) < 4e-16
+
+    # Complex Hyperbolic Sine Identity: sinh(z) = sinh(Re(z)) * cos(Im(z)) + i*cosh(Re(z)) * sin(Im(z))
+    func_sinh = lambdify([z], sinh(z) - (sinh(re(z)) * cos(im(z)) + I * cosh(re(z)) * sin(im(z))),
+                         modules=["cmath", "math"])
+    assert abs(func_sinh(hpi + 1j * hpi)) < 4e-16
+
+    # cosh(z) = (e^z + e^(-z)) / 2
+    func_cosh_2 = lambdify([z], cosh(z) - (exp(z) + exp(-z)) / 2, modules=["cmath", "math"])
+    assert abs(func_cosh_2(hpi)) < 4e-16
+
+    # Additional expressions testing log and exp with real and imaginary parts
+    expr1 = log(re(z)) + log(im(z)) - log(re(z) * im(z))
+    expr2 = exp(re(z)) * exp(im(z) * I) - exp(z)
+    expr3 = log(exp(re(z))) - re(z)
+    expr4 = exp(log(re(z))) - re(z)
+    expr5 = log(exp(re(z) + im(z))) - (re(z) + im(z))
+    expr6 = exp(log(re(z) + im(z))) - (re(z) + im(z))
+    func1 = lambdify([z], expr1, modules=["cmath", "math"])
+    func2 = lambdify([z], expr2, modules=["cmath", "math"])
+    func3 = lambdify([z], expr3, modules=["cmath", "math"])
+    func4 = lambdify([z], expr4, modules=["cmath", "math"])
+    func5 = lambdify([z], expr5, modules=["cmath", "math"])
+    func6 = lambdify([z], expr6, modules=["cmath", "math"])
+    test_value = 3 + 4j
+    assert abs(func1(test_value)) < 4e-16
+    assert abs(func2(test_value)) < 4e-16
+    assert abs(func3(test_value)) < 4e-16
+    assert abs(func4(test_value)) < 4e-16
+    assert abs(func5(test_value)) < 4e-16
+    assert abs(func6(test_value)) < 4e-16
+
+
+def test_issue_9334():
+    if not numexpr:
+        skip("numexpr not installed.")
+    if not numpy:
+        skip("numpy not installed.")
+    expr = S('b*a - sqrt(a**2)')
+    a, b = sorted(expr.free_symbols, key=lambda s: s.name)
+    func_numexpr = lambdify((a,b), expr, modules=[numexpr], dummify=False)
+    foo, bar = numpy.random.random((2, 4))
+    func_numexpr(foo, bar)
+
+
+def test_issue_12984():
+    if not numexpr:
+        skip("numexpr not installed.")
+    func_numexpr = lambdify((x,y,z), Piecewise((y, x >= 0), (z, x > -1)), numexpr)
+    with ignore_warnings(RuntimeWarning):
+        assert func_numexpr(1, 24, 42) == 24
+        assert str(func_numexpr(-1, 24, 42)) == 'nan'
+
+
+def test_empty_modules():
+    x, y = symbols('x y')
+    expr = -(x % y)
+
+    no_modules = lambdify([x, y], expr)
+    empty_modules = lambdify([x, y], expr, modules=[])
+    assert no_modules(3, 7) == empty_modules(3, 7)
+    assert no_modules(3, 7) == -3
+
+
+def test_exponentiation():
+    f = lambdify(x, x**2)
+    assert f(-1) == 1
+    assert f(0) == 0
+    assert f(1) == 1
+    assert f(-2) == 4
+    assert f(2) == 4
+    assert f(2.5) == 6.25
+
+
+def test_sqrt():
+    f = lambdify(x, sqrt(x))
+    assert f(0) == 0.0
+    assert f(1) == 1.0
+    assert f(4) == 2.0
+    assert abs(f(2) - 1.414) < 0.001
+    assert f(6.25) == 2.5
+
+
+def test_trig():
+    f = lambdify([x], [cos(x), sin(x)], 'math')
+    d = f(pi)
+    prec = 1e-11
+    assert -prec < d[0] + 1 < prec
+    assert -prec < d[1] < prec
+    d = f(3.14159)
+    prec = 1e-5
+    assert -prec < d[0] + 1 < prec
+    assert -prec < d[1] < prec
+
+
+def test_integral():
+    if numpy and not scipy:
+        skip("scipy not installed.")
+    f = Lambda(x, exp(-x**2))
+    l = lambdify(y, Integral(f(x), (x, y, oo)))
+    d = l(-oo)
+    assert 1.77245385 < d < 1.772453851
+
+
+def test_double_integral():
+    if numpy and not scipy:
+        skip("scipy not installed.")
+    # example from http://mpmath.org/doc/current/calculus/integration.html
+    i = Integral(1/(1 - x**2*y**2), (x, 0, 1), (y, 0, z))
+    l = lambdify([z], i)
+    d = l(1)
+    assert 1.23370055 < d < 1.233700551
+
+def test_spherical_bessel():
+    if numpy and not scipy:
+        skip("scipy not installed.")
+    test_point = 4.2 #randomly selected
+    x = symbols("x")
+    jtest = jn(2, x)
+    assert abs(lambdify(x,jtest)(test_point) -
+            jtest.subs(x,test_point).evalf()) < 1e-8
+    ytest = yn(2, x)
+    assert abs(lambdify(x,ytest)(test_point) -
+            ytest.subs(x,test_point).evalf()) < 1e-8
+
+
+#================== Test vectors ===================================
+
+
+def test_vector_simple():
+    f = lambdify((x, y, z), (z, y, x))
+    assert f(3, 2, 1) == (1, 2, 3)
+    assert f(1.0, 2.0, 3.0) == (3.0, 2.0, 1.0)
+    # make sure correct number of args required
+    raises(TypeError, lambda: f(0))
+
+
+def test_vector_discontinuous():
+    f = lambdify(x, (-1/x, 1/x))
+    raises(ZeroDivisionError, lambda: f(0))
+    assert f(1) == (-1.0, 1.0)
+    assert f(2) == (-0.5, 0.5)
+    assert f(-2) == (0.5, -0.5)
+
+
+def test_trig_symbolic():
+    f = lambdify([x], [cos(x), sin(x)], 'math')
+    d = f(pi)
+    assert abs(d[0] + 1) < 0.0001
+    assert abs(d[1] - 0) < 0.0001
+
+
+def test_trig_float():
+    f = lambdify([x], [cos(x), sin(x)])
+    d = f(3.14159)
+    assert abs(d[0] + 1) < 0.0001
+    assert abs(d[1] - 0) < 0.0001
+
+
+def test_docs():
+    f = lambdify(x, x**2)
+    assert f(2) == 4
+    f = lambdify([x, y, z], [z, y, x])
+    assert f(1, 2, 3) == [3, 2, 1]
+    f = lambdify(x, sqrt(x))
+    assert f(4) == 2.0
+    f = lambdify((x, y), sin(x*y)**2)
+    assert f(0, 5) == 0
+
+
+def test_math():
+    f = lambdify((x, y), sin(x), modules="math")
+    assert f(0, 5) == 0
+
+
+def test_sin():
+    f = lambdify(x, sin(x)**2)
+    assert isinstance(f(2), float)
+    f = lambdify(x, sin(x)**2, modules="math")
+    assert isinstance(f(2), float)
+
+
+def test_matrix():
+    A = Matrix([[x, x*y], [sin(z) + 4, x**z]])
+    sol = Matrix([[1, 2], [sin(3) + 4, 1]])
+    f = lambdify((x, y, z), A, modules="sympy")
+    assert f(1, 2, 3) == sol
+    f = lambdify((x, y, z), (A, [A]), modules="sympy")
+    assert f(1, 2, 3) == (sol, [sol])
+    J = Matrix((x, x + y)).jacobian((x, y))
+    v = Matrix((x, y))
+    sol = Matrix([[1, 0], [1, 1]])
+    assert lambdify(v, J, modules='sympy')(1, 2) == sol
+    assert lambdify(v.T, J, modules='sympy')(1, 2) == sol
+
+
+def test_numpy_matrix():
+    if not numpy:
+        skip("numpy not installed.")
+    A = Matrix([[x, x*y], [sin(z) + 4, x**z]])
+    sol_arr = numpy.array([[1, 2], [numpy.sin(3) + 4, 1]])
+    #Lambdify array first, to ensure return to array as default
+    f = lambdify((x, y, z), A, ['numpy'])
+    numpy.testing.assert_allclose(f(1, 2, 3), sol_arr)
+    #Check that the types are arrays and matrices
+    assert isinstance(f(1, 2, 3), numpy.ndarray)
+
+    # gh-15071
+    class dot(Function):
+        pass
+    x_dot_mtx = dot(x, Matrix([[2], [1], [0]]))
+    f_dot1 = lambdify(x, x_dot_mtx)
+    inp = numpy.zeros((17, 3))
+    assert numpy.all(f_dot1(inp) == 0)
+
+    strict_kw = {"allow_unknown_functions": False, "inline": True, "fully_qualified_modules": False}
+    p2 = NumPyPrinter(dict(user_functions={'dot': 'dot'}, **strict_kw))
+    f_dot2 = lambdify(x, x_dot_mtx, printer=p2)
+    assert numpy.all(f_dot2(inp) == 0)
+
+    p3 = NumPyPrinter(strict_kw)
+    # The line below should probably fail upon construction (before calling with "(inp)"):
+    raises(Exception, lambda: lambdify(x, x_dot_mtx, printer=p3)(inp))
+
+
+def test_numpy_transpose():
+    if not numpy:
+        skip("numpy not installed.")
+    A = Matrix([[1, x], [0, 1]])
+    f = lambdify((x), A.T, modules="numpy")
+    numpy.testing.assert_array_equal(f(2), numpy.array([[1, 0], [2, 1]]))
+
+
+def test_numpy_dotproduct():
+    if not numpy:
+        skip("numpy not installed")
+    A = Matrix([x, y, z])
+    f1 = lambdify([x, y, z], DotProduct(A, A), modules='numpy')
+    f2 = lambdify([x, y, z], DotProduct(A, A.T), modules='numpy')
+    f3 = lambdify([x, y, z], DotProduct(A.T, A), modules='numpy')
+    f4 = lambdify([x, y, z], DotProduct(A, A.T), modules='numpy')
+
+    assert f1(1, 2, 3) == \
+           f2(1, 2, 3) == \
+           f3(1, 2, 3) == \
+           f4(1, 2, 3) == \
+           numpy.array([14])
+
+
+def test_numpy_inverse():
+    if not numpy:
+        skip("numpy not installed.")
+    A = Matrix([[1, x], [0, 1]])
+    f = lambdify((x), A**-1, modules="numpy")
+    numpy.testing.assert_array_equal(f(2), numpy.array([[1, -2], [0,  1]]))
+
+
+def test_numpy_old_matrix():
+    if not numpy:
+        skip("numpy not installed.")
+    A = Matrix([[x, x*y], [sin(z) + 4, x**z]])
+    sol_arr = numpy.array([[1, 2], [numpy.sin(3) + 4, 1]])
+    f = lambdify((x, y, z), A, [{'ImmutableDenseMatrix': numpy.matrix}, 'numpy'])
+    with ignore_warnings(PendingDeprecationWarning):
+        numpy.testing.assert_allclose(f(1, 2, 3), sol_arr)
+        assert isinstance(f(1, 2, 3), numpy.matrix)
+
+
+def test_scipy_sparse_matrix():
+    if not scipy:
+        skip("scipy not installed.")
+    A = SparseMatrix([[x, 0], [0, y]])
+    f = lambdify((x, y), A, modules="scipy")
+    B = f(1, 2)
+    assert isinstance(B, scipy.sparse.coo_matrix)
+
+
+def test_python_div_zero_issue_11306():
+    if not numpy:
+        skip("numpy not installed.")
+    p = Piecewise((1 / x, y < -1), (x, y < 1), (1 / x, True))
+    f = lambdify([x, y], p, modules='numpy')
+    with numpy.errstate(divide='ignore'):
+        assert float(f(numpy.array(0), numpy.array(0.5))) == 0
+        assert float(f(numpy.array(0), numpy.array(1))) == float('inf')
+
+
+def test_issue9474():
+    mods = [None, 'math']
+    if numpy:
+        mods.append('numpy')
+    if mpmath:
+        mods.append('mpmath')
+    for mod in mods:
+        f = lambdify(x, S.One/x, modules=mod)
+        assert f(2) == 0.5
+        f = lambdify(x, floor(S.One/x), modules=mod)
+        assert f(2) == 0
+
+    for absfunc, modules in product([Abs, abs], mods):
+        f = lambdify(x, absfunc(x), modules=modules)
+        assert f(-1) == 1
+        assert f(1) == 1
+        assert f(3+4j) == 5
+
+
+def test_issue_9871():
+    if not numexpr:
+        skip("numexpr not installed.")
+    if not numpy:
+        skip("numpy not installed.")
+
+    r = sqrt(x**2 + y**2)
+    expr = diff(1/r, x)
+
+    xn = yn = numpy.linspace(1, 10, 16)
+    # expr(xn, xn) = -xn/(sqrt(2)*xn)^3
+    fv_exact = -numpy.sqrt(2.)**-3 * xn**-2
+
+    fv_numpy = lambdify((x, y), expr, modules='numpy')(xn, yn)
+    fv_numexpr = lambdify((x, y), expr, modules='numexpr')(xn, yn)
+    numpy.testing.assert_allclose(fv_numpy, fv_exact, rtol=1e-10)
+    numpy.testing.assert_allclose(fv_numexpr, fv_exact, rtol=1e-10)
+
+
+def test_numpy_piecewise():
+    if not numpy:
+        skip("numpy not installed.")
+    pieces = Piecewise((x, x < 3), (x**2, x > 5), (0, True))
+    f = lambdify(x, pieces, modules="numpy")
+    numpy.testing.assert_array_equal(f(numpy.arange(10)),
+                                     numpy.array([0, 1, 2, 0, 0, 0, 36, 49, 64, 81]))
+    # If we evaluate somewhere all conditions are False, we should get back NaN
+    nodef_func = lambdify(x, Piecewise((x, x > 0), (-x, x < 0)))
+    numpy.testing.assert_array_equal(nodef_func(numpy.array([-1, 0, 1])),
+                                     numpy.array([1, numpy.nan, 1]))
+
+
+def test_numpy_logical_ops():
+    if not numpy:
+        skip("numpy not installed.")
+    and_func = lambdify((x, y), And(x, y), modules="numpy")
+    and_func_3 = lambdify((x, y, z), And(x, y, z), modules="numpy")
+    or_func = lambdify((x, y), Or(x, y), modules="numpy")
+    or_func_3 = lambdify((x, y, z), Or(x, y, z), modules="numpy")
+    not_func = lambdify((x), Not(x), modules="numpy")
+    arr1 = numpy.array([True, True])
+    arr2 = numpy.array([False, True])
+    arr3 = numpy.array([True, False])
+    numpy.testing.assert_array_equal(and_func(arr1, arr2), numpy.array([False, True]))
+    numpy.testing.assert_array_equal(and_func_3(arr1, arr2, arr3), numpy.array([False, False]))
+    numpy.testing.assert_array_equal(or_func(arr1, arr2), numpy.array([True, True]))
+    numpy.testing.assert_array_equal(or_func_3(arr1, arr2, arr3), numpy.array([True, True]))
+    numpy.testing.assert_array_equal(not_func(arr2), numpy.array([True, False]))
+
+
+def test_numpy_matmul():
+    if not numpy:
+        skip("numpy not installed.")
+    xmat = Matrix([[x, y], [z, 1+z]])
+    ymat = Matrix([[x**2], [Abs(x)]])
+    mat_func = lambdify((x, y, z), xmat*ymat, modules="numpy")
+    numpy.testing.assert_array_equal(mat_func(0.5, 3, 4), numpy.array([[1.625], [3.5]]))
+    numpy.testing.assert_array_equal(mat_func(-0.5, 3, 4), numpy.array([[1.375], [3.5]]))
+    # Multiple matrices chained together in multiplication
+    f = lambdify((x, y, z), xmat*xmat*xmat, modules="numpy")
+    numpy.testing.assert_array_equal(f(0.5, 3, 4), numpy.array([[72.125, 119.25],
+                                                                [159, 251]]))
+
+
+def test_numpy_numexpr():
+    if not numpy:
+        skip("numpy not installed.")
+    if not numexpr:
+        skip("numexpr not installed.")
+    a, b, c = numpy.random.randn(3, 128, 128)
+    # ensure that numpy and numexpr return same value for complicated expression
+    expr = sin(x) + cos(y) + tan(z)**2 + Abs(z-y)*acos(sin(y*z)) + \
+           Abs(y-z)*acosh(2+exp(y-x))- sqrt(x**2+I*y**2)
+    npfunc = lambdify((x, y, z), expr, modules='numpy')
+    nefunc = lambdify((x, y, z), expr, modules='numexpr')
+    assert numpy.allclose(npfunc(a, b, c), nefunc(a, b, c))
+
+
+def test_numexpr_userfunctions():
+    if not numpy:
+        skip("numpy not installed.")
+    if not numexpr:
+        skip("numexpr not installed.")
+    a, b = numpy.random.randn(2, 10)
+    uf = type('uf', (Function, ),
+              {'eval' : classmethod(lambda x, y : y**2+1)})
+    func = lambdify(x, 1-uf(x), modules='numexpr')
+    assert numpy.allclose(func(a), -(a**2))
+
+    uf = implemented_function(Function('uf'), lambda x, y : 2*x*y+1)
+    func = lambdify((x, y), uf(x, y), modules='numexpr')
+    assert numpy.allclose(func(a, b), 2*a*b+1)
+
+
+def test_tensorflow_basic_math():
+    if not tensorflow:
+        skip("tensorflow not installed.")
+    expr = Max(sin(x), Abs(1/(x+2)))
+    func = lambdify(x, expr, modules="tensorflow")
+
+    with tensorflow.compat.v1.Session() as s:
+        a = tensorflow.constant(0, dtype=tensorflow.float32)
+        assert func(a).eval(session=s) == 0.5
+
+
+def test_tensorflow_placeholders():
+    if not tensorflow:
+        skip("tensorflow not installed.")
+    expr = Max(sin(x), Abs(1/(x+2)))
+    func = lambdify(x, expr, modules="tensorflow")
+
+    with tensorflow.compat.v1.Session() as s:
+        a = tensorflow.compat.v1.placeholder(dtype=tensorflow.float32)
+        assert func(a).eval(session=s, feed_dict={a: 0}) == 0.5
+
+
+def test_tensorflow_variables():
+    if not tensorflow:
+        skip("tensorflow not installed.")
+    expr = Max(sin(x), Abs(1/(x+2)))
+    func = lambdify(x, expr, modules="tensorflow")
+
+    with tensorflow.compat.v1.Session() as s:
+        a = tensorflow.Variable(0, dtype=tensorflow.float32)
+        s.run(a.initializer)
+        assert func(a).eval(session=s, feed_dict={a: 0}) == 0.5
+
+
+def test_tensorflow_logical_operations():
+    if not tensorflow:
+        skip("tensorflow not installed.")
+    expr = Not(And(Or(x, y), y))
+    func = lambdify([x, y], expr, modules="tensorflow")
+
+    with tensorflow.compat.v1.Session() as s:
+        assert func(False, True).eval(session=s) == False
+
+
+def test_tensorflow_piecewise():
+    if not tensorflow:
+        skip("tensorflow not installed.")
+    expr = Piecewise((0, Eq(x,0)), (-1, x < 0), (1, x > 0))
+    func = lambdify(x, expr, modules="tensorflow")
+
+    with tensorflow.compat.v1.Session() as s:
+        assert func(-1).eval(session=s) == -1
+        assert func(0).eval(session=s) == 0
+        assert func(1).eval(session=s) == 1
+
+
+def test_tensorflow_multi_max():
+    if not tensorflow:
+        skip("tensorflow not installed.")
+    expr = Max(x, -x, x**2)
+    func = lambdify(x, expr, modules="tensorflow")
+
+    with tensorflow.compat.v1.Session() as s:
+        assert func(-2).eval(session=s) == 4
+
+
+def test_tensorflow_multi_min():
+    if not tensorflow:
+        skip("tensorflow not installed.")
+    expr = Min(x, -x, x**2)
+    func = lambdify(x, expr, modules="tensorflow")
+
+    with tensorflow.compat.v1.Session() as s:
+        assert func(-2).eval(session=s) == -2
+
+
+def test_tensorflow_relational():
+    if not tensorflow:
+        skip("tensorflow not installed.")
+    expr = x >= 0
+    func = lambdify(x, expr, modules="tensorflow")
+
+    with tensorflow.compat.v1.Session() as s:
+        assert func(1).eval(session=s) == True
+
+
+def test_tensorflow_complexes():
+    if not tensorflow:
+        skip("tensorflow not installed")
+
+    func1 = lambdify(x, re(x), modules="tensorflow")
+    func2 = lambdify(x, im(x), modules="tensorflow")
+    func3 = lambdify(x, Abs(x), modules="tensorflow")
+    func4 = lambdify(x, arg(x), modules="tensorflow")
+
+    with tensorflow.compat.v1.Session() as s:
+        # For versions before
+        # https://github.com/tensorflow/tensorflow/issues/30029
+        # resolved, using Python numeric types may not work
+        a = tensorflow.constant(1+2j)
+        assert func1(a).eval(session=s) == 1
+        assert func2(a).eval(session=s) == 2
+
+        tensorflow_result = func3(a).eval(session=s)
+        sympy_result = Abs(1 + 2j).evalf()
+        assert abs(tensorflow_result-sympy_result) < 10**-6
+
+        tensorflow_result = func4(a).eval(session=s)
+        sympy_result = arg(1 + 2j).evalf()
+        assert abs(tensorflow_result-sympy_result) < 10**-6
+
+
+def test_tensorflow_array_arg():
+    # Test for issue 14655 (tensorflow part)
+    if not tensorflow:
+        skip("tensorflow not installed.")
+
+    f = lambdify([[x, y]], x*x + y, 'tensorflow')
+
+    with tensorflow.compat.v1.Session() as s:
+        fcall = f(tensorflow.constant([2.0, 1.0]))
+        assert fcall.eval(session=s) == 5.0
+
+
+#================== Test symbolic ==================================
+
+
+def test_sym_single_arg():
+    f = lambdify(x, x * y)
+    assert f(z) == z * y
+
+
+def test_sym_list_args():
+    f = lambdify([x, y], x + y + z)
+    assert f(1, 2) == 3 + z
+
+
+def test_sym_integral():
+    f = Lambda(x, exp(-x**2))
+    l = lambdify(x, Integral(f(x), (x, -oo, oo)), modules="sympy")
+    assert l(y) == Integral(exp(-y**2), (y, -oo, oo))
+    assert l(y).doit() == sqrt(pi)
+
+
+def test_namespace_order():
+    # lambdify had a bug, such that module dictionaries or cached module
+    # dictionaries would pull earlier namespaces into themselves.
+    # Because the module dictionaries form the namespace of the
+    # generated lambda, this meant that the behavior of a previously
+    # generated lambda function could change as a result of later calls
+    # to lambdify.
+    n1 = {'f': lambda x: 'first f'}
+    n2 = {'f': lambda x: 'second f',
+          'g': lambda x: 'function g'}
+    f = sympy.Function('f')
+    g = sympy.Function('g')
+    if1 = lambdify(x, f(x), modules=(n1, "sympy"))
+    assert if1(1) == 'first f'
+    if2 = lambdify(x, g(x), modules=(n2, "sympy"))
+    # previously gave 'second f'
+    assert if1(1) == 'first f'
+
+    assert if2(1) == 'function g'
+
+
+def test_imps():
+    # Here we check if the default returned functions are anonymous - in
+    # the sense that we can have more than one function with the same name
+    f = implemented_function('f', lambda x: 2*x)
+    g = implemented_function('f', lambda x: math.sqrt(x))
+    l1 = lambdify(x, f(x))
+    l2 = lambdify(x, g(x))
+    assert str(f(x)) == str(g(x))
+    assert l1(3) == 6
+    assert l2(3) == math.sqrt(3)
+    # check that we can pass in a Function as input
+    func = sympy.Function('myfunc')
+    assert not hasattr(func, '_imp_')
+    my_f = implemented_function(func, lambda x: 2*x)
+    assert hasattr(my_f, '_imp_')
+    # Error for functions with same name and different implementation
+    f2 = implemented_function("f", lambda x: x + 101)
+    raises(ValueError, lambda: lambdify(x, f(f2(x))))
+
+
+def test_imps_errors():
+    # Test errors that implemented functions can return, and still be able to
+    # form expressions.
+    # See: https://github.com/sympy/sympy/issues/10810
+    #
+    # XXX: Removed AttributeError here. This test was added due to issue 10810
+    # but that issue was about ValueError. It doesn't seem reasonable to
+    # "support" catching AttributeError in the same context...
+    for val, error_class in product((0, 0., 2, 2.0), (TypeError, ValueError)):
+
+        def myfunc(a):
+            if a == 0:
+                raise error_class
+            return 1
+
+        f = implemented_function('f', myfunc)
+        expr = f(val)
+        assert expr == f(val)
+
+
+def test_imps_wrong_args():
+    raises(ValueError, lambda: implemented_function(sin, lambda x: x))
+
+
+def test_lambdify_imps():
+    # Test lambdify with implemented functions
+    # first test basic (sympy) lambdify
+    f = sympy.cos
+    assert lambdify(x, f(x))(0) == 1
+    assert lambdify(x, 1 + f(x))(0) == 2
+    assert lambdify((x, y), y + f(x))(0, 1) == 2
+    # make an implemented function and test
+    f = implemented_function("f", lambda x: x + 100)
+    assert lambdify(x, f(x))(0) == 100
+    assert lambdify(x, 1 + f(x))(0) == 101
+    assert lambdify((x, y), y + f(x))(0, 1) == 101
+    # Can also handle tuples, lists, dicts as expressions
+    lam = lambdify(x, (f(x), x))
+    assert lam(3) == (103, 3)
+    lam = lambdify(x, [f(x), x])
+    assert lam(3) == [103, 3]
+    lam = lambdify(x, [f(x), (f(x), x)])
+    assert lam(3) == [103, (103, 3)]
+    lam = lambdify(x, {f(x): x})
+    assert lam(3) == {103: 3}
+    lam = lambdify(x, {f(x): x})
+    assert lam(3) == {103: 3}
+    lam = lambdify(x, {x: f(x)})
+    assert lam(3) == {3: 103}
+    # Check that imp preferred to other namespaces by default
+    d = {'f': lambda x: x + 99}
+    lam = lambdify(x, f(x), d)
+    assert lam(3) == 103
+    # Unless flag passed
+    lam = lambdify(x, f(x), d, use_imps=False)
+    assert lam(3) == 102
+
+
+def test_dummification():
+    t = symbols('t')
+    F = Function('F')
+    G = Function('G')
+    #"\alpha" is not a valid Python variable name
+    #lambdify should sub in a dummy for it, and return
+    #without a syntax error
+    alpha = symbols(r'\alpha')
+    some_expr = 2 * F(t)**2 / G(t)
+    lam = lambdify((F(t), G(t)), some_expr)
+    assert lam(3, 9) == 2
+    lam = lambdify(sin(t), 2 * sin(t)**2)
+    assert lam(F(t)) == 2 * F(t)**2
+    #Test that \alpha was properly dummified
+    lam = lambdify((alpha, t), 2*alpha + t)
+    assert lam(2, 1) == 5
+    raises(SyntaxError, lambda: lambdify(F(t) * G(t), F(t) * G(t) + 5))
+    raises(SyntaxError, lambda: lambdify(2 * F(t), 2 * F(t) + 5))
+    raises(SyntaxError, lambda: lambdify(2 * F(t), 4 * F(t) + 5))
+
+
+def test_lambdify__arguments_with_invalid_python_identifiers():
+    # see sympy/sympy#26690
+    N = CoordSys3D('N')
+    xn, yn, zn = N.base_scalars()
+    expr = xn + yn
+    f = lambdify([xn, yn], expr)
+    res = f(0.2, 0.3)
+    ref = 0.2 + 0.3
+    assert abs(res-ref) < 1e-15
+
+
+def test_curly_matrix_symbol():
+    # Issue #15009
+    curlyv = sympy.MatrixSymbol("{v}", 2, 1)
+    lam = lambdify(curlyv, curlyv)
+    assert lam(1)==1
+    lam = lambdify(curlyv, curlyv, dummify=True)
+    assert lam(1)==1
+
+
+def test_python_keywords():
+    # Test for issue 7452. The automatic dummification should ensure use of
+    # Python reserved keywords as symbol names will create valid lambda
+    # functions. This is an additional regression test.
+    python_if = symbols('if')
+    expr = python_if / 2
+    f = lambdify(python_if, expr)
+    assert f(4.0) == 2.0
+
+
+def test_lambdify_docstring():
+    func = lambdify((w, x, y, z), w + x + y + z)
+    ref = (
+        "Created with lambdify. Signature:\n\n"
+        "func(w, x, y, z)\n\n"
+        "Expression:\n\n"
+        "w + x + y + z"
+    ).splitlines()
+    assert func.__doc__.splitlines()[:len(ref)] == ref
+    syms = symbols('a1:26')
+    func = lambdify(syms, sum(syms))
+    ref = (
+        "Created with lambdify. Signature:\n\n"
+        "func(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,\n"
+        "        a16, a17, a18, a19, a20, a21, a22, a23, a24, a25)\n\n"
+        "Expression:\n\n"
+        "a1 + a10 + a11 + a12 + a13 + a14 + a15 + a16 + a17 + a18 + a19 + a2 + a20 +..."
+    ).splitlines()
+    assert func.__doc__.splitlines()[:len(ref)] == ref
+
+
+def test_lambdify_linecache():
+    func = lambdify(x, x + 1)
+    source = 'def _lambdifygenerated(x):\n    return x + 1\n'
+    assert inspect.getsource(func) == source
+    filename = inspect.getsourcefile(func)
+    assert filename.startswith('<lambdifygenerated-')
+    assert filename in linecache.cache
+    assert linecache.cache[filename] == (len(source), None, source.splitlines(True), filename)
+    del func
+    gc.collect()
+    assert filename not in linecache.cache
+
+#================== Test special printers ==========================
+
+
+def test_special_printers():
+    from sympy.printing.lambdarepr import IntervalPrinter
+
+    def intervalrepr(expr):
+        return IntervalPrinter().doprint(expr)
+
+    expr = sqrt(sqrt(2) + sqrt(3)) + S.Half
+
+    func0 = lambdify((), expr, modules="mpmath", printer=intervalrepr)
+    func1 = lambdify((), expr, modules="mpmath", printer=IntervalPrinter)
+    func2 = lambdify((), expr, modules="mpmath", printer=IntervalPrinter())
+
+    mpi = type(mpmath.mpi(1, 2))
+
+    assert isinstance(func0(), mpi)
+    assert isinstance(func1(), mpi)
+    assert isinstance(func2(), mpi)
+
+    # To check Is lambdify loggamma works for mpmath or not
+    exp1 = lambdify(x, loggamma(x), 'mpmath')(5)
+    exp2 = lambdify(x, loggamma(x), 'mpmath')(1.8)
+    exp3 = lambdify(x, loggamma(x), 'mpmath')(15)
+    exp_ls = [exp1, exp2, exp3]
+
+    sol1 = mpmath.loggamma(5)
+    sol2 = mpmath.loggamma(1.8)
+    sol3 = mpmath.loggamma(15)
+    sol_ls = [sol1, sol2, sol3]
+
+    assert exp_ls == sol_ls
+
+
+def test_true_false():
+    # We want exact is comparison here, not just ==
+    assert lambdify([], true)() is True
+    assert lambdify([], false)() is False
+
+
+def test_issue_2790():
+    assert lambdify((x, (y, z)), x + y)(1, (2, 4)) == 3
+    assert lambdify((x, (y, (w, z))), w + x + y + z)(1, (2, (3, 4))) == 10
+    assert lambdify(x, x + 1, dummify=False)(1) == 2
+
+
+def test_issue_12092():
+    f = implemented_function('f', lambda x: x**2)
+    assert f(f(2)).evalf() == Float(16)
+
+
+def test_issue_14911():
+    class Variable(sympy.Symbol):
+        def _sympystr(self, printer):
+            return printer.doprint(self.name)
+
+        _lambdacode = _sympystr
+        _numpycode = _sympystr
+
+    x = Variable('x')
+    y = 2 * x
+    code = LambdaPrinter().doprint(y)
+    assert code.replace(' ', '') == '2*x'
+
+
+def test_ITE():
+    assert lambdify((x, y, z), ITE(x, y, z))(True, 5, 3) == 5
+    assert lambdify((x, y, z), ITE(x, y, z))(False, 5, 3) == 3
+
+
+def test_Min_Max():
+    # see gh-10375
+    assert lambdify((x, y, z), Min(x, y, z))(1, 2, 3) == 1
+    assert lambdify((x, y, z), Max(x, y, z))(1, 2, 3) == 3
+
+
+def test_amin_amax_minimum_maximum():
+    if not numpy:
+        skip("numpy not installed")
+
+    a234 = numpy.array([2, 3, 4])
+    a152 = numpy.array([1, 5, 2])
+
+    a254 = numpy.array([2, 5, 4])
+    a132 = numpy.array([1, 3, 2])
+    # 2 args
+    assert numpy.all(lambdify((x, y), maximum(x, y))(a234, a152) == a254)
+    assert numpy.all(lambdify((x, y), minimum(x, y))(a234, a152) == a132)
+
+    # 3 args
+    assert numpy.all(lambdify((x, y, z), maximum(x, y, z))(a234, a152, a234) == a254)
+    assert numpy.all(lambdify((x, y, z), minimum(x, y, z))(a234, a152, a234) == a132)
+
+    # 1 arg
+    assert numpy.all(lambdify((x,), maximum(x))(a234) == a234)
+    assert numpy.all(lambdify((x,), minimum(x))(a234) == a234)
+
+    # 4 args, mixed length
+    assert numpy.all(lambdify((x, y, z, w), maximum(x, y, z, w))(a234, a152, a234, 3) == [3, 5, 4])
+    assert numpy.all(lambdify((x, y, z, w), minimum(x, y, z, w))(a234, a152, a234, 2) == [1, 2, 2])
+
+    # amin & amax
+    assert lambdify((x, y), [amin(x), amax(y)])(a234, a152) == [2, 5]
+    A = numpy.array([
+        [0, 4, 8],
+        [1, 5, 9],
+        [2, 6, 10],
+    ])
+    min_, max_ = lambdify((x,), [amin(x, axis=0), amax(x, axis=1)])(A)
+    assert numpy.all(min_ == numpy.amin(A, axis=0))
+    assert numpy.all(max_ == numpy.amax(A, axis=1))
+
+    # see gh-25659
+    assert numpy.all(lambdify((x, y), Max(x, y))([1, 2, 3], [3, 2, 1]) == [3, 2, 3])
+    assert numpy.all(lambdify((x), Min(2, x))([1, 2, 3]) == [1, 2, 2])
+
+
+
+def test_Indexed():
+    # Issue #10934
+    if not numpy:
+        skip("numpy not installed")
+
+    a = IndexedBase('a')
+    i, j = symbols('i j')
+    b = numpy.array([[1, 2], [3, 4]])
+    assert lambdify(a, Sum(a[x, y], (x, 0, 1), (y, 0, 1)))(b) == 10
+
+def test_Sum():
+    e = Sum(z, (y, 0, x), (x, 0, 10))
+    ref = 66*z
+    assert e.doit() == ref
+    assert lambdify([z], e)(7) == ref.subs(z, 7)
+
+def test_Idx():
+    # Issue 26888
+    a = IndexedBase('a')
+    i = Idx('i')
+    b = [1,2,3]
+    assert lambdify([a, i], a[i])(b, 2) == 3
+
+
+def test_issue_12173():
+    #test for issue 12173
+    expr1 = lambdify((x, y), uppergamma(x, y),"mpmath")(1, 2)
+    expr2 = lambdify((x, y), lowergamma(x, y),"mpmath")(1, 2)
+    assert expr1 == uppergamma(1, 2).evalf()
+    assert expr2 == lowergamma(1, 2).evalf()
+
+
+def test_issue_13642():
+    if not numpy:
+        skip("numpy not installed")
+    f = lambdify(x, sinc(x))
+    assert Abs(f(1) - sinc(1)).n() < 1e-15
+
+
+def test_sinc_mpmath():
+    f = lambdify(x, sinc(x), "mpmath")
+    assert Abs(f(1) - sinc(1)).n() < 1e-15
+
+
+def test_lambdify_dummy_arg():
+    d1 = Dummy()
+    f1 = lambdify(d1, d1 + 1, dummify=False)
+    assert f1(2) == 3
+    f1b = lambdify(d1, d1 + 1)
+    assert f1b(2) == 3
+    d2 = Dummy('x')
+    f2 = lambdify(d2, d2 + 1)
+    assert f2(2) == 3
+    f3 = lambdify([[d2]], d2 + 1)
+    assert f3([2]) == 3
+
+
+def test_lambdify_mixed_symbol_dummy_args():
+    d = Dummy()
+    # Contrived example of name clash
+    dsym = symbols(str(d))
+    f = lambdify([d, dsym], d - dsym)
+    assert f(4, 1) == 3
+
+
+def test_numpy_array_arg():
+    # Test for issue 14655 (numpy part)
+    if not numpy:
+        skip("numpy not installed")
+
+    f = lambdify([[x, y]], x*x + y, 'numpy')
+
+    assert f(numpy.array([2.0, 1.0])) == 5
+
+
+def test_scipy_fns():
+    if not scipy:
+        skip("scipy not installed")
+
+    single_arg_sympy_fns = [Ei, erf, erfc, factorial, gamma, loggamma, digamma, Si, Ci]
+    single_arg_scipy_fns = [scipy.special.expi, scipy.special.erf, scipy.special.erfc,
+        scipy.special.factorial, scipy.special.gamma, scipy.special.gammaln,
+                            scipy.special.psi, scipy.special.sici, scipy.special.sici]
+    numpy.random.seed(0)
+    for (sympy_fn, scipy_fn) in zip(single_arg_sympy_fns, single_arg_scipy_fns):
+        f = lambdify(x, sympy_fn(x), modules="scipy")
+        for i in range(20):
+            tv = numpy.random.uniform(-10, 10) + 1j*numpy.random.uniform(-5, 5)
+            # SciPy thinks that factorial(z) is 0 when re(z) < 0 and
+            # does not support complex numbers.
+            # SymPy does not think so.
+            if sympy_fn == factorial:
+                tv = numpy.abs(tv)
+            # SciPy supports gammaln for real arguments only,
+            # and there is also a branch cut along the negative real axis
+            if sympy_fn == loggamma:
+                tv = numpy.abs(tv)
+            # SymPy's digamma evaluates as polygamma(0, z)
+            # which SciPy supports for real arguments only
+            if sympy_fn == digamma:
+                tv = numpy.real(tv)
+            sympy_result = sympy_fn(tv).evalf()
+            scipy_result = scipy_fn(tv)
+            # SciPy's sici returns a tuple with both Si and Ci present in it
+            # which needs to be unpacked
+            if sympy_fn == Si:
+                scipy_result = scipy_fn(tv)[0]
+            if sympy_fn == Ci:
+                scipy_result = scipy_fn(tv)[1]
+            assert abs(f(tv) - sympy_result) < 1e-13*(1 + abs(sympy_result))
+            assert abs(f(tv) - scipy_result) < 1e-13*(1 + abs(sympy_result))
+
+    double_arg_sympy_fns = [RisingFactorial, besselj, bessely, besseli,
+                            besselk, polygamma]
+    double_arg_scipy_fns = [scipy.special.poch, scipy.special.jv,
+                            scipy.special.yv, scipy.special.iv, scipy.special.kv, scipy.special.polygamma]
+    for (sympy_fn, scipy_fn) in zip(double_arg_sympy_fns, double_arg_scipy_fns):
+        f = lambdify((x, y), sympy_fn(x, y), modules="scipy")
+        for i in range(20):
+            # SciPy supports only real orders of Bessel functions
+            tv1 = numpy.random.uniform(-10, 10)
+            tv2 = numpy.random.uniform(-10, 10) + 1j*numpy.random.uniform(-5, 5)
+            # SciPy requires a real valued 2nd argument for: poch, polygamma
+            if sympy_fn in (RisingFactorial, polygamma):
+                tv2 = numpy.real(tv2)
+            if sympy_fn == polygamma:
+                tv1 = abs(int(tv1))  # first argument to polygamma must be a non-negative integer.
+            sympy_result = sympy_fn(tv1, tv2).evalf()
+            assert abs(f(tv1, tv2) - sympy_result) < 1e-13*(1 + abs(sympy_result))
+            assert abs(f(tv1, tv2) - scipy_fn(tv1, tv2)) < 1e-13*(1 + abs(sympy_result))
+
+
+def test_scipy_polys():
+    if not scipy:
+        skip("scipy not installed")
+    numpy.random.seed(0)
+
+    params = symbols('n k a b')
+    # list polynomials with the number of parameters
+    polys = [
+        (chebyshevt, 1),
+        (chebyshevu, 1),
+        (legendre, 1),
+        (hermite, 1),
+        (laguerre, 1),
+        (gegenbauer, 2),
+        (assoc_legendre, 2),
+        (assoc_laguerre, 2),
+        (jacobi, 3)
+    ]
+
+    msg = \
+        "The random test of the function {func} with the arguments " \
+        "{args} had failed because the SymPy result {sympy_result} " \
+        "and SciPy result {scipy_result} had failed to converge " \
+        "within the tolerance {tol} " \
+        "(Actual absolute difference : {diff})"
+
+    for sympy_fn, num_params in polys:
+        args = params[:num_params] + (x,)
+        f = lambdify(args, sympy_fn(*args))
+        for _ in range(10):
+            tn = numpy.random.randint(3, 10)
+            tparams = tuple(numpy.random.uniform(0, 5, size=num_params-1))
+            tv = numpy.random.uniform(-10, 10) + 1j*numpy.random.uniform(-5, 5)
+            # SciPy supports hermite for real arguments only
+            if sympy_fn == hermite:
+                tv = numpy.real(tv)
+            # assoc_legendre needs x in (-1, 1) and integer param at most n
+            if sympy_fn == assoc_legendre:
+                tv = numpy.random.uniform(-1, 1)
+                tparams = tuple(numpy.random.randint(1, tn, size=1))
+
+            vals = (tn,) + tparams + (tv,)
+            scipy_result = f(*vals)
+            sympy_result = sympy_fn(*vals).evalf()
+            atol = 1e-9*(1 + abs(sympy_result))
+            diff = abs(scipy_result - sympy_result)
+            try:
+                assert diff < atol
+            except TypeError:
+                raise AssertionError(
+                    msg.format(
+                        func=repr(sympy_fn),
+                        args=repr(vals),
+                        sympy_result=repr(sympy_result),
+                        scipy_result=repr(scipy_result),
+                        diff=diff,
+                        tol=atol)
+                    )
+
+
+def test_lambdify_inspect():
+    f = lambdify(x, x**2)
+    # Test that inspect.getsource works but don't hard-code implementation
+    # details
+    assert 'x**2' in inspect.getsource(f)
+
+
+def test_issue_14941():
+    x, y = Dummy(), Dummy()
+
+    # test dict
+    f1 = lambdify([x, y], {x: 3, y: 3}, 'sympy')
+    assert f1(2, 3) == {2: 3, 3: 3}
+
+    # test tuple
+    f2 = lambdify([x, y], (y, x), 'sympy')
+    assert f2(2, 3) == (3, 2)
+    f2b = lambdify([], (1,))  # gh-23224
+    assert f2b() == (1,)
+
+    # test list
+    f3 = lambdify([x, y], [y, x], 'sympy')
+    assert f3(2, 3) == [3, 2]
+
+
+def test_lambdify_Derivative_arg_issue_16468():
+    f = Function('f')(x)
+    fx = f.diff()
+    assert lambdify((f, fx), f + fx)(10, 5) == 15
+    assert eval(lambdastr((f, fx), f/fx))(10, 5) == 2
+    raises(Exception, lambda:
+        eval(lambdastr((f, fx), f/fx, dummify=False)))
+    assert eval(lambdastr((f, fx), f/fx, dummify=True))(10, 5) == 2
+    assert eval(lambdastr((fx, f), f/fx, dummify=True))(S(10), 5) == S.Half
+    assert lambdify(fx, 1 + fx)(41) == 42
+    assert eval(lambdastr(fx, 1 + fx, dummify=True))(41) == 42
+
+
+def test_lambdify_Derivative_zeta():
+    # This is related to gh-11802 (and to lesser extent gh-26663)
+    expr1 = zeta(x).diff(x, evaluate=False)
+    f1 = lambdify(x, expr1, modules=['mpmath'])
+    ans1 = f1(2)
+    ref1 = (zeta(2+1e-8).evalf()-zeta(2).evalf())/1e-8
+    assert abs(ans1 - ref1)/abs(ref1) < 1e-7
+
+    expr2 = zeta(x**2).diff(x)
+    f2 = lambdify(x, expr2, modules=['mpmath'])
+    ans2 = f2(2**0.5)
+    ref2 = 2*2**0.5*ref1
+    assert abs(ans2-ref2)/abs(ref2) < 1e-7
+
+
+def test_lambdify_Derivative_custom_printer():
+    func1 = Function('func1')
+    func2 = Function('func2')
+
+    class MyPrinter(NumPyPrinter):
+
+        def _print_Derivative_func1(self, args, seq_orders):
+            arg, = args
+            order, = seq_orders
+            return '42'
+
+    expr1 = func1(x).diff(x)
+    raises(PrintMethodNotImplementedError, lambda: lambdify([x], expr1))
+    f1 = lambdify([x], expr1, printer=MyPrinter)
+    assert f1(7) == 42
+
+    expr2 = func2(x).diff(x)
+    raises(PrintMethodNotImplementedError, lambda: lambdify([x], expr2, printer=MyPrinter))
+
+
+def test_lambdify_derivative_and_functions_as_arguments():
+    # see: https://github.com/sympy/sympy/issues/26663#issuecomment-2157179517
+    t, a, b = symbols('t, a, b')
+    f = Function('f')(t)
+    args = f.diff(t, 2), f.diff(t), f, a, b
+    expr1 = a*f.diff(t, 2) + b*f.diff(t) + a*b*f + a**2
+    num_args = 2.0, 3.0, 4.0, 5.0, 6.0
+    ref1 = 5*2 + 6*3 + 5*6*4 + 5**2
+
+    expr2 = a*f.diff(t, 2) + b*f.diff(t) - a*b*f + b**2 - a**2
+    ref2 = 5*2 + 6*3 - 5*6*4 + 6**2 - 5**2
+
+    for dummify, _cse in product([False, None, True], [False, True]):
+        func1 = lambdify(args, expr1, cse=_cse, dummify=dummify)
+        res1 = func1(*num_args)
+        assert abs(res1 - ref1) < 1e-12
+
+        func12 = lambdify(args, [expr1, expr2], cse=_cse, dummify=dummify)
+        res12 = func12(*num_args)
+        assert len(res12) == 2
+        assert abs(res12[0] - ref1) < 1e-12
+        assert abs(res12[1] - ref2) < 1e-12
+
+
+def test_imag_real():
+    f_re = lambdify([z], sympy.re(z))
+    val = 3+2j
+    assert f_re(val) == val.real
+
+    f_im = lambdify([z], sympy.im(z))  # see #15400
+    assert f_im(val) == val.imag
+
+
+def test_MatrixSymbol_issue_15578():
+    if not numpy:
+        skip("numpy not installed")
+    A = MatrixSymbol('A', 2, 2)
+    A0 = numpy.array([[1, 2], [3, 4]])
+    f = lambdify(A, A**(-1))
+    assert numpy.allclose(f(A0), numpy.array([[-2., 1.], [1.5, -0.5]]))
+    g = lambdify(A, A**3)
+    assert numpy.allclose(g(A0), numpy.array([[37, 54], [81, 118]]))
+
+
+def test_issue_15654():
+    if not scipy:
+        skip("scipy not installed")
+    from sympy.abc import n, l, r, Z
+    from sympy.physics import hydrogen
+    nv, lv, rv, Zv = 1, 0, 3, 1
+    sympy_value = hydrogen.R_nl(nv, lv, rv, Zv).evalf()
+    f = lambdify((n, l, r, Z), hydrogen.R_nl(n, l, r, Z))
+    scipy_value = f(nv, lv, rv, Zv)
+    assert abs(sympy_value - scipy_value) < 1e-15
+
+
+def test_issue_15827():
+    if not numpy:
+        skip("numpy not installed")
+    A = MatrixSymbol("A", 3, 3)
+    B = MatrixSymbol("B", 2, 3)
+    C = MatrixSymbol("C", 3, 4)
+    D = MatrixSymbol("D", 4, 5)
+    k=symbols("k")
+    f = lambdify(A, (2*k)*A)
+    g = lambdify(A, (2+k)*A)
+    h = lambdify(A, 2*A)
+    i = lambdify((B, C, D), 2*B*C*D)
+    assert numpy.array_equal(f(numpy.array([[1, 2, 3], [1, 2, 3], [1, 2, 3]])), \
+    numpy.array([[2*k, 4*k, 6*k], [2*k, 4*k, 6*k], [2*k, 4*k, 6*k]], dtype=object))
+
+    assert numpy.array_equal(g(numpy.array([[1, 2, 3], [1, 2, 3], [1, 2, 3]])), \
+    numpy.array([[k + 2, 2*k + 4, 3*k + 6], [k + 2, 2*k + 4, 3*k + 6], \
+    [k + 2, 2*k + 4, 3*k + 6]], dtype=object))
+
+    assert numpy.array_equal(h(numpy.array([[1, 2, 3], [1, 2, 3], [1, 2, 3]])), \
+    numpy.array([[2, 4, 6], [2, 4, 6], [2, 4, 6]]))
+
+    assert numpy.array_equal(i(numpy.array([[1, 2, 3], [1, 2, 3]]), numpy.array([[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]]), \
+    numpy.array([[1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5]])), numpy.array([[ 120, 240, 360, 480, 600], \
+    [ 120, 240, 360, 480, 600]]))
+
+
+def test_issue_16930():
+    if not scipy:
+        skip("scipy not installed")
+
+    x = symbols("x")
+    f = lambda x:  S.GoldenRatio * x**2
+    f_ = lambdify(x, f(x), modules='scipy')
+    assert f_(1) == scipy.constants.golden_ratio
+
+def test_issue_17898():
+    if not scipy:
+        skip("scipy not installed")
+    x = symbols("x")
+    f_ = lambdify([x], sympy.LambertW(x,-1), modules='scipy')
+    assert f_(0.1) == mpmath.lambertw(0.1, -1)
+
+def test_issue_13167_21411():
+    if not numpy:
+        skip("numpy not installed")
+    f1 = lambdify(x, sympy.Heaviside(x))
+    f2 = lambdify(x, sympy.Heaviside(x, 1))
+    res1 = f1([-1, 0, 1])
+    res2 = f2([-1, 0, 1])
+    assert Abs(res1[0]).n() < 1e-15        # First functionality: only one argument passed
+    assert Abs(res1[1] - 1/2).n() < 1e-15
+    assert Abs(res1[2] - 1).n() < 1e-15
+    assert Abs(res2[0]).n() < 1e-15        # Second functionality: two arguments passed
+    assert Abs(res2[1] - 1).n() < 1e-15
+    assert Abs(res2[2] - 1).n() < 1e-15
+
+def test_single_e():
+    f = lambdify(x, E)
+    assert f(23) == exp(1.0)
+
+def test_issue_16536():
+    if not scipy:
+        skip("scipy not installed")
+
+    a = symbols('a')
+    f1 = lowergamma(a, x)
+    F = lambdify((a, x), f1, modules='scipy')
+    assert abs(lowergamma(1, 3) - F(1, 3)) <= 1e-10
+
+    f2 = uppergamma(a, x)
+    F = lambdify((a, x), f2, modules='scipy')
+    assert abs(uppergamma(1, 3) - F(1, 3)) <= 1e-10
+
+
+def test_issue_22726():
+    if not numpy:
+        skip("numpy not installed")
+
+    x1, x2 = symbols('x1 x2')
+    f = Max(S.Zero, Min(x1, x2))
+    g = derive_by_array(f, (x1, x2))
+    G = lambdify((x1, x2), g, modules='numpy')
+    point = {x1: 1, x2: 2}
+    assert (abs(g.subs(point) - G(*point.values())) <= 1e-10).all()
+
+
+def test_issue_22739():
+    if not numpy:
+        skip("numpy not installed")
+
+    x1, x2 = symbols('x1 x2')
+    f = Heaviside(Min(x1, x2))
+    F = lambdify((x1, x2), f, modules='numpy')
+    point = {x1: 1, x2: 2}
+    assert abs(f.subs(point) - F(*point.values())) <= 1e-10
+
+
+def test_issue_22992():
+    if not numpy:
+        skip("numpy not installed")
+
+    a, t = symbols('a t')
+    expr = a*(log(cot(t/2)) - cos(t))
+    F = lambdify([a, t], expr, 'numpy')
+
+    point = {a: 10, t: 2}
+
+    assert abs(expr.subs(point) - F(*point.values())) <= 1e-10
+
+    # Standard math
+    F = lambdify([a, t], expr)
+
+    assert abs(expr.subs(point) - F(*point.values())) <= 1e-10
+
+
+def test_issue_19764():
+    if not numpy:
+        skip("numpy not installed")
+
+    expr = Array([x, x**2])
+    f = lambdify(x, expr, 'numpy')
+
+    assert f(1).__class__ == numpy.ndarray
+
+def test_issue_20070():
+    if not numba:
+        skip("numba not installed")
+
+    f = lambdify(x, sin(x), 'numpy')
+    assert numba.jit(f, nopython=True)(1)==0.8414709848078965
+
+
+def test_fresnel_integrals_scipy():
+    if not scipy:
+        skip("scipy not installed")
+
+    f1 = fresnelc(x)
+    f2 = fresnels(x)
+    F1 = lambdify(x, f1, modules='scipy')
+    F2 = lambdify(x, f2, modules='scipy')
+
+    assert abs(fresnelc(1.3) - F1(1.3)) <= 1e-10
+    assert abs(fresnels(1.3) - F2(1.3)) <= 1e-10
+
+
+def test_beta_scipy():
+    if not scipy:
+        skip("scipy not installed")
+
+    f = beta(x, y)
+    F = lambdify((x, y), f, modules='scipy')
+
+    assert abs(beta(1.3, 2.3) - F(1.3, 2.3)) <= 1e-10
+
+
+def test_beta_math():
+    f = beta(x, y)
+    F = lambdify((x, y), f, modules='math')
+
+    assert abs(beta(1.3, 2.3) - F(1.3, 2.3)) <= 1e-10
+
+
+def test_betainc_scipy():
+    if not scipy:
+        skip("scipy not installed")
+
+    f = betainc(w, x, y, z)
+    F = lambdify((w, x, y, z), f, modules='scipy')
+
+    assert abs(betainc(1.4, 3.1, 0.1, 0.5) - F(1.4, 3.1, 0.1, 0.5)) <= 1e-10
+
+
+def test_betainc_regularized_scipy():
+    if not scipy:
+        skip("scipy not installed")
+
+    f = betainc_regularized(w, x, y, z)
+    F = lambdify((w, x, y, z), f, modules='scipy')
+
+    assert abs(betainc_regularized(0.2, 3.5, 0.1, 1) - F(0.2, 3.5, 0.1, 1)) <= 1e-10
+
+
+def test_numpy_special_math():
+    if not numpy:
+        skip("numpy not installed")
+
+    funcs = [expm1, log1p, exp2, log2, log10, hypot, logaddexp, logaddexp2]
+    for func in funcs:
+        if 2 in func.nargs:
+            expr = func(x, y)
+            args = (x, y)
+            num_args = (0.3, 0.4)
+        elif 1 in func.nargs:
+            expr = func(x)
+            args = (x,)
+            num_args = (0.3,)
+        else:
+            raise NotImplementedError("Need to handle other than unary & binary functions in test")
+        f = lambdify(args, expr)
+        result = f(*num_args)
+        reference = expr.subs(dict(zip(args, num_args))).evalf()
+        assert numpy.allclose(result, float(reference))
+
+    lae2 = lambdify((x, y), logaddexp2(log2(x), log2(y)))
+    assert abs(2.0**lae2(1e-50, 2.5e-50) - 3.5e-50) < 1e-62  # from NumPy's docstring
+
+
+def test_scipy_special_math():
+    if not scipy:
+        skip("scipy not installed")
+
+    cm1 = lambdify((x,), cosm1(x), modules='scipy')
+    assert abs(cm1(1e-20) + 5e-41) < 1e-200
+
+    have_scipy_1_10plus = tuple(map(int, scipy.version.version.split('.')[:2])) >= (1, 10)
+
+    if have_scipy_1_10plus:
+        cm2 = lambdify((x, y), powm1(x, y), modules='scipy')
+        assert abs(cm2(1.2, 1e-9) - 1.82321557e-10)  < 1e-17
+
+
+def test_scipy_bernoulli():
+    if not scipy:
+        skip("scipy not installed")
+
+    bern = lambdify((x,), bernoulli(x), modules='scipy')
+    assert bern(1) == 0.5
+
+
+def test_scipy_harmonic():
+    if not scipy:
+        skip("scipy not installed")
+
+    hn = lambdify((x,), harmonic(x), modules='scipy')
+    assert hn(2) == 1.5
+    hnm = lambdify((x, y), harmonic(x, y), modules='scipy')
+    assert hnm(2, 2) == 1.25
+
+
+def test_cupy_array_arg():
+    if not cupy:
+        skip("CuPy not installed")
+
+    f = lambdify([[x, y]], x*x + y, 'cupy')
+    result = f(cupy.array([2.0, 1.0]))
+    assert result == 5
+    assert "cupy" in str(type(result))
+
+
+def test_cupy_array_arg_using_numpy():
+    # numpy functions can be run on cupy arrays
+    # unclear if we can "officially" support this,
+    # depends on numpy __array_function__ support
+    if not cupy:
+        skip("CuPy not installed")
+
+    f = lambdify([[x, y]], x*x + y, 'numpy')
+    result = f(cupy.array([2.0, 1.0]))
+    assert result == 5
+    assert "cupy" in str(type(result))
+
+def test_cupy_dotproduct():
+    if not cupy:
+        skip("CuPy not installed")
+
+    A = Matrix([x, y, z])
+    f1 = lambdify([x, y, z], DotProduct(A, A), modules='cupy')
+    f2 = lambdify([x, y, z], DotProduct(A, A.T), modules='cupy')
+    f3 = lambdify([x, y, z], DotProduct(A.T, A), modules='cupy')
+    f4 = lambdify([x, y, z], DotProduct(A, A.T), modules='cupy')
+
+    assert f1(1, 2, 3) == \
+        f2(1, 2, 3) == \
+        f3(1, 2, 3) == \
+        f4(1, 2, 3) == \
+        cupy.array([14])
+
+
+def test_jax_array_arg():
+    if not jax:
+        skip("JAX not installed")
+
+    f = lambdify([[x, y]], x*x + y, 'jax')
+    result = f(jax.numpy.array([2.0, 1.0]))
+    assert result == 5
+    assert "jax" in str(type(result))
+
+
+def test_jax_array_arg_using_numpy():
+    if not jax:
+        skip("JAX not installed")
+
+    f = lambdify([[x, y]], x*x + y, 'numpy')
+    result = f(jax.numpy.array([2.0, 1.0]))
+    assert result == 5
+    assert "jax" in str(type(result))
+
+
+def test_jax_dotproduct():
+    if not jax:
+        skip("JAX not installed")
+
+    A = Matrix([x, y, z])
+    f1 = lambdify([x, y, z], DotProduct(A, A), modules='jax')
+    f2 = lambdify([x, y, z], DotProduct(A, A.T), modules='jax')
+    f3 = lambdify([x, y, z], DotProduct(A.T, A), modules='jax')
+    f4 = lambdify([x, y, z], DotProduct(A, A.T), modules='jax')
+
+    assert f1(1, 2, 3) == \
+        f2(1, 2, 3) == \
+        f3(1, 2, 3) == \
+        f4(1, 2, 3) == \
+        jax.numpy.array([14])
+
+
+def test_lambdify_cse():
+    def no_op_cse(exprs):
+        return (), exprs
+
+    def dummy_cse(exprs):
+        from sympy.simplify.cse_main import cse
+        return cse(exprs, symbols=numbered_symbols(cls=Dummy))
+
+    def minmem(exprs):
+        from sympy.simplify.cse_main import cse_release_variables, cse
+        return cse(exprs, postprocess=cse_release_variables)
+
+    class Case:
+        def __init__(self, *, args, exprs, num_args, requires_numpy=False):
+            self.args = args
+            self.exprs = exprs
+            self.num_args = num_args
+            subs_dict = dict(zip(self.args, self.num_args))
+            self.ref = [e.subs(subs_dict).evalf() for e in exprs]
+            self.requires_numpy = requires_numpy
+
+        def lambdify(self, *, cse):
+            return lambdify(self.args, self.exprs, cse=cse)
+
+        def assertAllClose(self, result, *, abstol=1e-15, reltol=1e-15):
+            if self.requires_numpy:
+                assert all(numpy.allclose(result[i], numpy.asarray(r, dtype=float),
+                                          rtol=reltol, atol=abstol)
+                           for i, r in enumerate(self.ref))
+                return
+
+            for i, r in enumerate(self.ref):
+                abs_err = abs(result[i] - r)
+                if r == 0:
+                    assert abs_err < abstol
+                else:
+                    assert abs_err/abs(r) < reltol
+
+    cases = [
+        Case(
+            args=(x, y, z),
+            exprs=[
+             x + y + z,
+             x + y - z,
+             2*x + 2*y - z,
+             (x+y)**2 + (y+z)**2,
+            ],
+            num_args=(2., 3., 4.)
+        ),
+        Case(
+            args=(x, y, z),
+            exprs=[
+            x + sympy.Heaviside(x),
+            y + sympy.Heaviside(x),
+            z + sympy.Heaviside(x, 1),
+            z/sympy.Heaviside(x, 1)
+            ],
+            num_args=(0., 3., 4.)
+        ),
+        Case(
+            args=(x, y, z),
+            exprs=[
+            x + sinc(y),
+            y + sinc(y),
+            z - sinc(y)
+            ],
+            num_args=(0.1, 0.2, 0.3)
+        ),
+        Case(
+            args=(x, y, z),
+            exprs=[
+                Matrix([[x, x*y], [sin(z) + 4, x**z]]),
+                x*y+sin(z)-x**z,
+                Matrix([x*x, sin(z), x**z])
+            ],
+            num_args=(1.,2.,3.),
+            requires_numpy=True
+        ),
+        Case(
+            args=(x, y),
+            exprs=[(x + y - 1)**2, x, x + y,
+            (x + y)/(2*x + 1) + (x + y - 1)**2, (2*x + 1)**(x + y)],
+            num_args=(1,2)
+        )
+    ]
+    for case in cases:
+        if not numpy and case.requires_numpy:
+            continue
+        for _cse in [False, True, minmem, no_op_cse, dummy_cse]:
+            f = case.lambdify(cse=_cse)
+            result = f(*case.num_args)
+            case.assertAllClose(result)
+
+def test_issue_25288():
+    syms = numbered_symbols(cls=Dummy)
+    ok = lambdify(x, [x**2, sin(x**2)], cse=lambda e: cse(e, symbols=syms))(2)
+    assert ok
+
+
+def test_deprecated_set():
+    with warns_deprecated_sympy():
+        lambdify({x, y}, x + y)
+
+def test_issue_13881():
+    if not numpy:
+        skip("numpy not installed.")
+
+    X = MatrixSymbol('X', 3, 1)
+
+    f = lambdify(X, X.T*X, 'numpy')
+    assert f(numpy.array([1, 2, 3])) == 14
+    assert f(numpy.array([3, 2, 1])) == 14
+
+    f = lambdify(X, X*X.T, 'numpy')
+    assert f(numpy.array([1, 2, 3])) == 14
+    assert f(numpy.array([3, 2, 1])) == 14
+
+    f = lambdify(X, (X*X.T)*X, 'numpy')
+    arr1 = numpy.array([[1], [2], [3]])
+    arr2 = numpy.array([[14],[28],[42]])
+
+    assert numpy.array_equal(f(arr1), arr2)
+
+
+def test_23536_lambdify_cse_dummy():
+
+    f = Function('x')(y)
+    g = Function('w')(y)
+    expr = z + (f**4 + g**5)*(f**3 + (g*f)**3)
+    expr = expr.expand()
+    eval_expr = lambdify(((f, g), z), expr, cse=True)
+    ans = eval_expr((1.0, 2.0), 3.0)  # shouldn't raise NameError
+    assert ans == 300.0  # not a list and value is 300
+
+
+class LambdifyDocstringTestCase:
+    SIGNATURE = None
+    EXPR = None
+    SRC = None
+
+    def __init__(self, docstring_limit, expected_redacted):
+        self.docstring_limit = docstring_limit
+        self.expected_redacted = expected_redacted
+
+    @property
+    def expected_expr(self):
+        expr_redacted_msg = "EXPRESSION REDACTED DUE TO LENGTH, (see lambdify's `docstring_limit`)"
+        return self.EXPR if not self.expected_redacted else expr_redacted_msg
+
+    @property
+    def expected_src(self):
+        src_redacted_msg = "SOURCE CODE REDACTED DUE TO LENGTH, (see lambdify's `docstring_limit`)"
+        return self.SRC if not self.expected_redacted else src_redacted_msg
+
+    @property
+    def expected_docstring(self):
+        expected_docstring = (
+            f'Created with lambdify. Signature:\n\n'
+            f'func({self.SIGNATURE})\n\n'
+            f'Expression:\n\n'
+            f'{self.expected_expr}\n\n'
+            f'Source code:\n\n'
+            f'{self.expected_src}\n\n'
+            f'Imported modules:\n\n'
+        )
+        return expected_docstring
+
+    def __len__(self):
+        return len(self.expected_docstring)
+
+    def __repr__(self):
+        return (
+            f'{self.__class__.__name__}('
+            f'docstring_limit={self.docstring_limit}, '
+            f'expected_redacted={self.expected_redacted})'
+        )
+
+
+def test_lambdify_docstring_size_limit_simple_symbol():
+
+    class SimpleSymbolTestCase(LambdifyDocstringTestCase):
+        SIGNATURE = 'x'
+        EXPR = 'x'
+        SRC = (
+            'def _lambdifygenerated(x):\n'
+            '    return x\n'
+        )
+
+    x = symbols('x')
+
+    test_cases = (
+        SimpleSymbolTestCase(docstring_limit=None, expected_redacted=False),
+        SimpleSymbolTestCase(docstring_limit=100, expected_redacted=False),
+        SimpleSymbolTestCase(docstring_limit=1, expected_redacted=False),
+        SimpleSymbolTestCase(docstring_limit=0, expected_redacted=True),
+        SimpleSymbolTestCase(docstring_limit=-1, expected_redacted=True),
+    )
+    for test_case in test_cases:
+        lambdified_expr = lambdify(
+            [x],
+            x,
+            'sympy',
+            docstring_limit=test_case.docstring_limit,
+        )
+        assert lambdified_expr.__doc__ == test_case.expected_docstring
+
+
+def test_lambdify_docstring_size_limit_nested_expr():
+
+    class ExprListTestCase(LambdifyDocstringTestCase):
+        SIGNATURE = 'x, y, z'
+        EXPR = (
+            '[x, [y], z, x**3 + 3*x**2*y + 3*x**2*z + 3*x*y**2 + 6*x*y*z '
+            '+ 3*x*z**2 +...'
+        )
+        SRC = (
+            'def _lambdifygenerated(x, y, z):\n'
+            '    return [x, [y], z, x**3 + 3*x**2*y + 3*x**2*z + 3*x*y**2 '
+            '+ 6*x*y*z + 3*x*z**2 + y**3 + 3*y**2*z + 3*y*z**2 + z**3]\n'
+        )
+
+    x, y, z = symbols('x, y, z')
+    expr = [x, [y], z, ((x + y + z)**3).expand()]
+
+    test_cases = (
+        ExprListTestCase(docstring_limit=None, expected_redacted=False),
+        ExprListTestCase(docstring_limit=200, expected_redacted=False),
+        ExprListTestCase(docstring_limit=50, expected_redacted=True),
+        ExprListTestCase(docstring_limit=0, expected_redacted=True),
+        ExprListTestCase(docstring_limit=-1, expected_redacted=True),
+    )
+    for test_case in test_cases:
+        lambdified_expr = lambdify(
+            [x, y, z],
+            expr,
+            'sympy',
+            docstring_limit=test_case.docstring_limit,
+        )
+        assert lambdified_expr.__doc__ == test_case.expected_docstring
+
+
+def test_lambdify_docstring_size_limit_matrix():
+
+    class MatrixTestCase(LambdifyDocstringTestCase):
+        SIGNATURE = 'x, y, z'
+        EXPR = (
+            'Matrix([[0, x], [x + y + z, x**3 + 3*x**2*y + 3*x**2*z + 3*x*y**2 '
+            '+ 6*x*y*z...'
+        )
+        SRC = (
+            'def _lambdifygenerated(x, y, z):\n'
+            '    return ImmutableDenseMatrix([[0, x], [x + y + z, x**3 '
+            '+ 3*x**2*y + 3*x**2*z + 3*x*y**2 + 6*x*y*z + 3*x*z**2 + y**3 '
+            '+ 3*y**2*z + 3*y*z**2 + z**3]])\n'
+        )
+
+    x, y, z = symbols('x, y, z')
+    expr = Matrix([[S.Zero, x], [x + y + z, ((x + y + z)**3).expand()]])
+
+    test_cases = (
+        MatrixTestCase(docstring_limit=None, expected_redacted=False),
+        MatrixTestCase(docstring_limit=200, expected_redacted=False),
+        MatrixTestCase(docstring_limit=50, expected_redacted=True),
+        MatrixTestCase(docstring_limit=0, expected_redacted=True),
+        MatrixTestCase(docstring_limit=-1, expected_redacted=True),
+    )
+    for test_case in test_cases:
+        lambdified_expr = lambdify(
+            [x, y, z],
+            expr,
+            'sympy',
+            docstring_limit=test_case.docstring_limit,
+        )
+        assert lambdified_expr.__doc__ == test_case.expected_docstring
+
+
+def test_lambdify_empty_tuple():
+    a = symbols("a")
+    expr = ((), (a,))
+    f = lambdify(a, expr)
+    result = f(1)
+    assert result == ((), (1,)), "Lambdify did not handle the empty tuple correctly."
+
+
+def test_assoc_legendre_numerical_evaluation():
+
+    tol = 1e-10
+
+    sympy_result_integer = assoc_legendre(1, 1/2, 0.1).evalf()
+    sympy_result_complex = assoc_legendre(2, 1, 3).evalf()
+    mpmath_result_integer = -0.474572528387641
+    mpmath_result_complex = -25.45584412271571*I
+
+    assert all_close(sympy_result_integer, mpmath_result_integer, tol)
+    assert all_close(sympy_result_complex, mpmath_result_complex, tol)
+
+
+def test_Piecewise():
+
+    modules = [math]
+    if numpy:
+        modules.append('numpy')
+
+    for mod in modules:
+        # test isinf
+        f = lambdify(x, Piecewise((7.0, isinf(x)), (3.0, True)), mod)
+        assert f(+float('inf')) == +7.0
+        assert f(-float('inf')) == +7.0
+        assert f(42.) == 3.0
+
+        f2 = lambdify(x, Piecewise((7.0*sign(x), isinf(x)), (3.0, True)), mod)
+        assert f2(+float('inf')) == +7.0
+        assert f2(-float('inf')) == -7.0
+        assert f2(42.) == 3.0
+
+        # test isnan (gh-26784)
+        g = lambdify(x, Piecewise((7.0, isnan(x)), (3.0, True)), mod)
+        assert g(float('nan')) == 7.0
+        assert g(42.) == 3.0
+
+
+def test_array_symbol():
+    if not numpy:
+        skip("numpy not installed.")
+    a = ArraySymbol('a', (3,))
+    f = lambdify((a), a)
+    assert numpy.all(f(numpy.array([1,2,3])) == numpy.array([1,2,3]))

.venv/lib/python3.13/site-packages/sympy/utilities/tests/test_matchpy_connector.py

@@ -0,0 +1,164 @@
+import pickle
+
+from sympy.core.relational import (Eq, Ne)
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.external import import_module
+from sympy.testing.pytest import skip
+from sympy.utilities.matchpy_connector import WildDot, WildPlus, WildStar, Replacer
+
+matchpy = import_module("matchpy")
+
+x, y, z = symbols("x y z")
+
+
+def _get_first_match(expr, pattern):
+    from matchpy import ManyToOneMatcher, Pattern
+
+    matcher = ManyToOneMatcher()
+    matcher.add(Pattern(pattern))
+    return next(iter(matcher.match(expr)))
+
+
+def test_matchpy_connector():
+    if matchpy is None:
+        skip("matchpy not installed")
+
+    from multiset import Multiset
+    from matchpy import Pattern, Substitution
+
+    w_ = WildDot("w_")
+    w__ = WildPlus("w__")
+    w___ = WildStar("w___")
+
+    expr = x + y
+    pattern = x + w_
+    p, subst = _get_first_match(expr, pattern)
+    assert p == Pattern(pattern)
+    assert subst == Substitution({'w_': y})
+
+    expr = x + y + z
+    pattern = x + w__
+    p, subst = _get_first_match(expr, pattern)
+    assert p == Pattern(pattern)
+    assert subst == Substitution({'w__': Multiset([y, z])})
+
+    expr = x + y + z
+    pattern = x + y + z + w___
+    p, subst = _get_first_match(expr, pattern)
+    assert p == Pattern(pattern)
+    assert subst == Substitution({'w___': Multiset()})
+
+
+def test_matchpy_optional():
+    if matchpy is None:
+        skip("matchpy not installed")
+
+    from matchpy import Pattern, Substitution
+    from matchpy import ManyToOneReplacer, ReplacementRule
+
+    p = WildDot("p", optional=1)
+    q = WildDot("q", optional=0)
+
+    pattern = p*x + q
+
+    expr1 = 2*x
+    pa, subst = _get_first_match(expr1, pattern)
+    assert pa == Pattern(pattern)
+    assert subst == Substitution({'p': 2, 'q': 0})
+
+    expr2 = x + 3
+    pa, subst = _get_first_match(expr2, pattern)
+    assert pa == Pattern(pattern)
+    assert subst == Substitution({'p': 1, 'q': 3})
+
+    expr3 = x
+    pa, subst = _get_first_match(expr3, pattern)
+    assert pa == Pattern(pattern)
+    assert subst == Substitution({'p': 1, 'q': 0})
+
+    expr4 = x*y + z
+    pa, subst = _get_first_match(expr4, pattern)
+    assert pa == Pattern(pattern)
+    assert subst == Substitution({'p': y, 'q': z})
+
+    replacer = ManyToOneReplacer()
+    replacer.add(ReplacementRule(Pattern(pattern), lambda p, q: sin(p)*cos(q)))
+    assert replacer.replace(expr1) == sin(2)*cos(0)
+    assert replacer.replace(expr2) == sin(1)*cos(3)
+    assert replacer.replace(expr3) == sin(1)*cos(0)
+    assert replacer.replace(expr4) == sin(y)*cos(z)
+
+
+def test_replacer():
+    if matchpy is None:
+        skip("matchpy not installed")
+
+    for info in [True, False]:
+        for lambdify in [True, False]:
+            _perform_test_replacer(info, lambdify)
+
+
+def _perform_test_replacer(info, lambdify):
+
+    x1_ = WildDot("x1_")
+    x2_ = WildDot("x2_")
+
+    a_ = WildDot("a_", optional=S.One)
+    b_ = WildDot("b_", optional=S.One)
+    c_ = WildDot("c_", optional=S.Zero)
+
+    replacer = Replacer(common_constraints=[
+        matchpy.CustomConstraint(lambda a_: not a_.has(x)),
+        matchpy.CustomConstraint(lambda b_: not b_.has(x)),
+        matchpy.CustomConstraint(lambda c_: not c_.has(x)),
+    ], lambdify=lambdify, info=info)
+
+    # Rewrite the equation into implicit form, unless it's already solved:
+    replacer.add(Eq(x1_, x2_), Eq(x1_ - x2_, 0), conditions_nonfalse=[Ne(x2_, 0), Ne(x1_, 0), Ne(x1_, x), Ne(x2_, x)], info=1)
+
+    # Simple equation solver for real numbers:
+    replacer.add(Eq(a_*x + b_, 0), Eq(x, -b_/a_), info=2)
+    disc = b_**2 - 4*a_*c_
+    replacer.add(
+        Eq(a_*x**2 + b_*x + c_, 0),
+        Eq(x, (-b_ - sqrt(disc))/(2*a_)) | Eq(x, (-b_ + sqrt(disc))/(2*a_)),
+        conditions_nonfalse=[disc >= 0],
+        info=3
+    )
+    replacer.add(
+        Eq(a_*x**2 + c_, 0),
+        Eq(x, sqrt(-c_/a_)) | Eq(x, -sqrt(-c_/a_)),
+        conditions_nonfalse=[-c_*a_ > 0],
+        info=4
+    )
+
+    g = lambda expr, infos: (expr, infos) if info else expr
+
+    assert replacer.replace(Eq(3*x, y)) == g(Eq(x, y/3), [1, 2])
+    assert replacer.replace(Eq(x**2 + 1, 0)) == g(Eq(x**2 + 1, 0), [])
+    assert replacer.replace(Eq(x**2, 4)) == g((Eq(x, 2) | Eq(x, -2)), [1, 4])
+    assert replacer.replace(Eq(x**2 + 4*y*x + 4*y**2, 0)) == g(Eq(x, -2*y), [3])
+
+
+def test_matchpy_object_pickle():
+    if matchpy is None:
+        return
+
+    a1 = WildDot("a")
+    a2 = pickle.loads(pickle.dumps(a1))
+    assert a1 == a2
+
+    a1 = WildDot("a", S(1))
+    a2 = pickle.loads(pickle.dumps(a1))
+    assert a1 == a2
+
+    a1 = WildPlus("a", S(1))
+    a2 = pickle.loads(pickle.dumps(a1))
+    assert a1 == a2
+
+    a1 = WildStar("a", S(1))
+    a2 = pickle.loads(pickle.dumps(a1))
+    assert a1 == a2

.venv/lib/python3.13/site-packages/sympy/utilities/tests/test_mathml.py

@@ -0,0 +1,33 @@
+import os
+from textwrap import dedent
+from sympy.external import import_module
+from sympy.testing.pytest import skip
+from sympy.utilities.mathml import apply_xsl
+
+
+
+lxml = import_module('lxml')
+
+path = os.path.abspath(os.path.join(os.path.dirname(__file__), "test_xxe.py"))
+
+
+def test_xxe():
+    assert os.path.isfile(path)
+    if not lxml:
+        skip("lxml not installed.")
+
+    mml = dedent(
+        rf"""
+        <!--?xml version="1.0" ?-->
+        <!DOCTYPE replace [<!ENTITY ent SYSTEM "file://{path}"> ]>
+        <userInfo>
+        <firstName>John</firstName>
+        <lastName>&ent;</lastName>
+        </userInfo>
+        """
+    )
+    xsl = 'mathml/data/simple_mmlctop.xsl'
+
+    res = apply_xsl(mml, xsl)
+    assert res == \
+        '<?xml version="1.0"?>\n<userInfo>\n<firstName>John</firstName>\n<lastName/>\n</userInfo>\n'

.venv/lib/python3.13/site-packages/sympy/utilities/tests/test_misc.py

@@ -0,0 +1,148 @@
+from textwrap import dedent
+import sys
+from subprocess import Popen, PIPE
+import os
+
+from sympy.core.singleton import S
+from sympy.testing.pytest import (raises, warns_deprecated_sympy,
+                                  skip_under_pyodide)
+from sympy.utilities.misc import (translate, replace, ordinal, rawlines,
+                                  strlines, as_int, find_executable)
+
+
+def test_translate():
+    abc = 'abc'
+    assert translate(abc, None, 'a') == 'bc'
+    assert translate(abc, None, '') == 'abc'
+    assert translate(abc, {'a': 'x'}, 'c') == 'xb'
+    assert translate(abc, {'a': 'bc'}, 'c') == 'bcb'
+    assert translate(abc, {'ab': 'x'}, 'c') == 'x'
+    assert translate(abc, {'ab': ''}, 'c') == ''
+    assert translate(abc, {'bc': 'x'}, 'c') == 'ab'
+    assert translate(abc, {'abc': 'x', 'a': 'y'}) == 'x'
+    u = chr(4096)
+    assert translate(abc, 'a', 'x', u) == 'xbc'
+    assert (u in translate(abc, 'a', u, u)) is True
+
+
+def test_replace():
+    assert replace('abc', ('a', 'b')) == 'bbc'
+    assert replace('abc', {'a': 'Aa'}) == 'Aabc'
+    assert replace('abc', ('a', 'b'), ('c', 'C')) == 'bbC'
+
+
+def test_ordinal():
+    assert ordinal(-1) == '-1st'
+    assert ordinal(0) == '0th'
+    assert ordinal(1) == '1st'
+    assert ordinal(2) == '2nd'
+    assert ordinal(3) == '3rd'
+    assert all(ordinal(i).endswith('th') for i in range(4, 21))
+    assert ordinal(100) == '100th'
+    assert ordinal(101) == '101st'
+    assert ordinal(102) == '102nd'
+    assert ordinal(103) == '103rd'
+    assert ordinal(104) == '104th'
+    assert ordinal(200) == '200th'
+    assert all(ordinal(i) == str(i) + 'th' for i in range(-220, -203))
+
+
+def test_rawlines():
+    assert rawlines('a a\na') == "dedent('''\\\n    a a\n    a''')"
+    assert rawlines('a a') == "'a a'"
+    assert rawlines(strlines('\\le"ft')) == (
+        '(\n'
+        "    '(\\n'\n"
+        '    \'r\\\'\\\\le"ft\\\'\\n\'\n'
+        "    ')'\n"
+        ')')
+
+
+def test_strlines():
+    q = 'this quote (") is in the middle'
+    # the following assert rhs was prepared with
+    # print(rawlines(strlines(q, 10)))
+    assert strlines(q, 10) == dedent('''\
+        (
+        'this quo'
+        'te (") i'
+        's in the'
+        ' middle'
+        )''')
+    assert q == (
+        'this quo'
+        'te (") i'
+        's in the'
+        ' middle'
+        )
+    q = "this quote (') is in the middle"
+    assert strlines(q, 20) == dedent('''\
+        (
+        "this quote (') is "
+        "in the middle"
+        )''')
+    assert strlines('\\left') == (
+        '(\n'
+        "r'\\left'\n"
+        ')')
+    assert strlines('\\left', short=True) == r"r'\left'"
+    assert strlines('\\le"ft') == (
+        '(\n'
+        'r\'\\le"ft\'\n'
+        ')')
+    q = 'this\nother line'
+    assert strlines(q) == rawlines(q)
+
+
+def test_translate_args():
+    try:
+        translate(None, None, None, 'not_none')
+    except ValueError:
+        pass # Exception raised successfully
+    else:
+        assert False
+
+    assert translate('s', None, None, None) == 's'
+
+    try:
+        translate('s', 'a', 'bc')
+    except ValueError:
+        pass # Exception raised successfully
+    else:
+        assert False
+
+
+@skip_under_pyodide("Cannot create subprocess under pyodide.")
+def test_debug_output():
+    env = os.environ.copy()
+    env['SYMPY_DEBUG'] = 'True'
+    cmd = 'from sympy import *; x = Symbol("x"); print(integrate((1-cos(x))/x, x))'
+    cmdline = [sys.executable, '-c', cmd]
+    proc = Popen(cmdline, env=env, stdout=PIPE, stderr=PIPE)
+    out, err = proc.communicate()
+    out = out.decode('ascii') # utf-8?
+    err = err.decode('ascii')
+    expected = 'substituted: -x*(1 - cos(x)), u: 1/x, u_var: _u'
+    assert expected in err, err
+
+
+def test_as_int():
+    raises(ValueError, lambda : as_int(True))
+    raises(ValueError, lambda : as_int(1.1))
+    raises(ValueError, lambda : as_int([]))
+    raises(ValueError, lambda : as_int(S.NaN))
+    raises(ValueError, lambda : as_int(S.Infinity))
+    raises(ValueError, lambda : as_int(S.NegativeInfinity))
+    raises(ValueError, lambda : as_int(S.ComplexInfinity))
+    # for the following, limited precision makes int(arg) == arg
+    # but the int value is not necessarily what a user might have
+    # expected; Q.prime is more nuanced in its response for
+    # expressions which might be complex representations of an
+    # integer. This is not -- by design -- as_ints role.
+    raises(ValueError, lambda : as_int(1e23))
+    raises(ValueError, lambda : as_int(S('1.'+'0'*20+'1')))
+    assert as_int(True, strict=False) == 1
+
+def test_deprecated_find_executable():
+    with warns_deprecated_sympy():
+        find_executable('python')

.venv/lib/python3.13/site-packages/sympy/utilities/tests/test_pickling.py

@@ -0,0 +1,723 @@
+import inspect
+import copy
+import pickle
+
+from sympy.physics.units import meter
+
+from sympy.testing.pytest import XFAIL, raises, ignore_warnings
+
+from sympy.core.basic import Atom, Basic
+from sympy.core.singleton import SingletonRegistry
+from sympy.core.symbol import Str, Dummy, Symbol, Wild
+from sympy.core.numbers import (E, I, pi, oo, zoo, nan, Integer,
+        Rational, Float, AlgebraicNumber)
+from sympy.core.relational import (Equality, GreaterThan, LessThan, Relational,
+        StrictGreaterThan, StrictLessThan, Unequality)
+from sympy.core.add import Add
+from sympy.core.mul import Mul
+from sympy.core.power import Pow
+from sympy.core.function import Derivative, Function, FunctionClass, Lambda, \
+    WildFunction
+from sympy.sets.sets import Interval
+from sympy.core.multidimensional import vectorize
+
+from sympy.external.gmpy import gmpy as _gmpy
+from sympy.utilities.exceptions import SymPyDeprecationWarning
+
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+
+from sympy.external import import_module
+cloudpickle = import_module('cloudpickle')
+
+
+not_equal_attrs = {
+    '_assumptions',  # This is a local cache that isn't automatically filled on creation
+    '_mhash',   # Cached after __hash__ is called but set to None after creation
+}
+
+
+deprecated_attrs = {
+    'is_EmptySet',  # Deprecated from SymPy 1.5. This can be removed when is_EmptySet is removed.
+    'expr_free_symbols',  # Deprecated from SymPy 1.9. This can be removed when exr_free_symbols is removed.
+}
+
+dont_check_attrs = {
+    '_sage_',  # Fails because Sage is not installed
+}
+
+
+def check(a, exclude=[], check_attr=True, deprecated=()):
+    """ Check that pickling and copying round-trips.
+    """
+    # Pickling with protocols 0 and 1 is disabled for Basic instances:
+    if isinstance(a, Basic):
+        for protocol in [0, 1]:
+            raises(NotImplementedError, lambda: pickle.dumps(a, protocol))
+
+    protocols = [2, copy.copy, copy.deepcopy, 3, 4]
+    if cloudpickle:
+        protocols.extend([cloudpickle])
+
+    for protocol in protocols:
+        if protocol in exclude:
+            continue
+
+        if callable(protocol):
+            if isinstance(a, type):
+                # Classes can't be copied, but that's okay.
+                continue
+            b = protocol(a)
+        elif inspect.ismodule(protocol):
+            b = protocol.loads(protocol.dumps(a))
+        else:
+            b = pickle.loads(pickle.dumps(a, protocol))
+
+        d1 = dir(a)
+        d2 = dir(b)
+        assert set(d1) == set(d2)
+
+        if not check_attr:
+            continue
+
+        def c(a, b, d):
+            for i in d:
+                if i in dont_check_attrs:
+                    continue
+                elif i in not_equal_attrs:
+                    if hasattr(a, i):
+                        assert hasattr(b, i), i
+                elif i in deprecated_attrs or i in deprecated:
+                    with ignore_warnings(SymPyDeprecationWarning):
+                        assert getattr(a, i) == getattr(b, i), i
+                elif not hasattr(a, i):
+                    continue
+                else:
+                    attr = getattr(a, i)
+                    if not hasattr(attr, "__call__"):
+                        assert hasattr(b, i), i
+                        assert getattr(b, i) == attr, "%s != %s, protocol: %s" % (getattr(b, i), attr, protocol)
+
+        c(a, b, d1)
+        c(b, a, d2)
+
+
+
+#================== core =========================
+
+
+def test_core_basic():
+    for c in (Atom, Atom(), Basic, Basic(), SingletonRegistry, S):
+        check(c)
+
+def test_core_Str():
+    check(Str('x'))
+
+def test_core_symbol():
+    # make the Symbol a unique name that doesn't class with any other
+    # testing variable in this file since after this test the symbol
+    # having the same name will be cached as noncommutative
+    for c in (Dummy, Dummy("x", commutative=False), Symbol,
+            Symbol("_issue_3130", commutative=False), Wild, Wild("x")):
+        check(c)
+
+
+def test_core_numbers():
+    for c in (Integer(2), Rational(2, 3), Float("1.2")):
+        check(c)
+    for c in (AlgebraicNumber, AlgebraicNumber(sqrt(3))):
+        check(c, check_attr=False)
+
+
+def test_core_float_copy():
+    # See gh-7457
+    y = Symbol("x") + 1.0
+    check(y)  # does not raise TypeError ("argument is not an mpz")
+
+
+def test_core_relational():
+    x = Symbol("x")
+    y = Symbol("y")
+    for c in (Equality, Equality(x, y), GreaterThan, GreaterThan(x, y),
+              LessThan, LessThan(x, y), Relational, Relational(x, y),
+              StrictGreaterThan, StrictGreaterThan(x, y), StrictLessThan,
+              StrictLessThan(x, y), Unequality, Unequality(x, y)):
+        check(c)
+
+
+def test_core_add():
+    x = Symbol("x")
+    for c in (Add, Add(x, 4)):
+        check(c)
+
+
+def test_core_mul():
+    x = Symbol("x")
+    for c in (Mul, Mul(x, 4)):
+        check(c)
+
+
+def test_core_power():
+    x = Symbol("x")
+    for c in (Pow, Pow(x, 4)):
+        check(c)
+
+
+def test_core_function():
+    x = Symbol("x")
+    for f in (Derivative, Derivative(x), Function, FunctionClass, Lambda,
+              WildFunction):
+        check(f)
+
+
+def test_core_undefinedfunctions():
+    f = Function("f")
+    check(f)
+
+
+def test_core_appliedundef():
+    x = Symbol("_long_unique_name_1")
+    f = Function("_long_unique_name_2")
+    check(f(x))
+
+
+def test_core_interval():
+    for c in (Interval, Interval(0, 2)):
+        check(c)
+
+
+def test_core_multidimensional():
+    for c in (vectorize, vectorize(0)):
+        check(c)
+
+
+def test_Singletons():
+    protocols = [0, 1, 2, 3, 4]
+    copiers = [copy.copy, copy.deepcopy]
+    copiers += [lambda x: pickle.loads(pickle.dumps(x, proto))
+            for proto in protocols]
+    if cloudpickle:
+        copiers += [lambda x: cloudpickle.loads(cloudpickle.dumps(x))]
+
+    for obj in (Integer(-1), Integer(0), Integer(1), Rational(1, 2), pi, E, I,
+            oo, -oo, zoo, nan, S.GoldenRatio, S.TribonacciConstant,
+            S.EulerGamma, S.Catalan, S.EmptySet, S.IdentityFunction):
+        for func in copiers:
+            assert func(obj) is obj
+
+#================== combinatorics ===================
+from sympy.combinatorics.free_groups import FreeGroup
+
+def test_free_group():
+    check(FreeGroup("x, y, z"), check_attr=False)
+
+#================== functions ===================
+from sympy.functions import (Piecewise, lowergamma, acosh, chebyshevu,
+        chebyshevt, ln, chebyshevt_root, legendre, Heaviside, bernoulli, coth,
+        tanh, assoc_legendre, sign, arg, asin, DiracDelta, re, rf, Abs,
+        uppergamma, binomial, sinh, cos, cot, acos, acot, gamma, bell,
+        hermite, harmonic, LambertW, zeta, log, factorial, asinh, acoth, cosh,
+        dirichlet_eta, Eijk, loggamma, erf, ceiling, im, fibonacci,
+        tribonacci, conjugate, tan, chebyshevu_root, floor, atanh, sqrt, sin,
+        atan, ff, lucas, atan2, polygamma, exp)
+
+
+def test_functions():
+    one_var = (acosh, ln, Heaviside, factorial, bernoulli, coth, tanh,
+            sign, arg, asin, DiracDelta, re, Abs, sinh, cos, cot, acos, acot,
+            gamma, bell, harmonic, LambertW, zeta, log, factorial, asinh,
+            acoth, cosh, dirichlet_eta, loggamma, erf, ceiling, im, fibonacci,
+            tribonacci, conjugate, tan, floor, atanh, sin, atan, lucas, exp)
+    two_var = (rf, ff, lowergamma, chebyshevu, chebyshevt, binomial,
+            atan2, polygamma, hermite, legendre, uppergamma)
+    x, y, z = symbols("x,y,z")
+    others = (chebyshevt_root, chebyshevu_root, Eijk(x, y, z),
+            Piecewise( (0, x < -1), (x**2, x <= 1), (x**3, True)),
+            assoc_legendre)
+    for cls in one_var:
+        check(cls)
+        c = cls(x)
+        check(c)
+    for cls in two_var:
+        check(cls)
+        c = cls(x, y)
+        check(c)
+    for cls in others:
+        check(cls)
+
+#================== geometry ====================
+from sympy.geometry.entity import GeometryEntity
+from sympy.geometry.point import Point
+from sympy.geometry.ellipse import Circle, Ellipse
+from sympy.geometry.line import Line, LinearEntity, Ray, Segment
+from sympy.geometry.polygon import Polygon, RegularPolygon, Triangle
+
+
+def test_geometry():
+    p1 = Point(1, 2)
+    p2 = Point(2, 3)
+    p3 = Point(0, 0)
+    p4 = Point(0, 1)
+    for c in (
+        GeometryEntity, GeometryEntity(), Point, p1, Circle, Circle(p1, 2),
+        Ellipse, Ellipse(p1, 3, 4), Line, Line(p1, p2), LinearEntity,
+        LinearEntity(p1, p2), Ray, Ray(p1, p2), Segment, Segment(p1, p2),
+        Polygon, Polygon(p1, p2, p3, p4), RegularPolygon,
+            RegularPolygon(p1, 4, 5), Triangle, Triangle(p1, p2, p3)):
+        check(c, check_attr=False)
+
+#================== integrals ====================
+from sympy.integrals.integrals import Integral
+
+
+def test_integrals():
+    x = Symbol("x")
+    for c in (Integral, Integral(x)):
+        check(c)
+
+#==================== logic =====================
+from sympy.core.logic import Logic
+
+
+def test_logic():
+    for c in (Logic, Logic(1)):
+        check(c)
+
+#================== matrices ====================
+from sympy.matrices import Matrix, SparseMatrix
+
+
+def test_matrices():
+    for c in (Matrix, Matrix([1, 2, 3]), SparseMatrix, SparseMatrix([[1, 2], [3, 4]])):
+        check(c, deprecated=['_smat', '_mat'])
+
+#================== ntheory =====================
+from sympy.ntheory.generate import Sieve
+
+
+def test_ntheory():
+    for c in (Sieve, Sieve()):
+        check(c)
+
+#================== physics =====================
+from sympy.physics.paulialgebra import Pauli
+from sympy.physics.units import Unit
+
+
+def test_physics():
+    for c in (Unit, meter, Pauli, Pauli(1)):
+        check(c)
+
+#================== plotting ====================
+# XXX: These tests are not complete, so XFAIL them
+
+
+@XFAIL
+def test_plotting():
+    from sympy.plotting.pygletplot.color_scheme import ColorGradient, ColorScheme
+    from sympy.plotting.pygletplot.managed_window import ManagedWindow
+    from sympy.plotting.plot import Plot, ScreenShot
+    from sympy.plotting.pygletplot.plot_axes import PlotAxes, PlotAxesBase, PlotAxesFrame, PlotAxesOrdinate
+    from sympy.plotting.pygletplot.plot_camera import PlotCamera
+    from sympy.plotting.pygletplot.plot_controller import PlotController
+    from sympy.plotting.pygletplot.plot_curve import PlotCurve
+    from sympy.plotting.pygletplot.plot_interval import PlotInterval
+    from sympy.plotting.pygletplot.plot_mode import PlotMode
+    from sympy.plotting.pygletplot.plot_modes import Cartesian2D, Cartesian3D, Cylindrical, \
+        ParametricCurve2D, ParametricCurve3D, ParametricSurface, Polar, Spherical
+    from sympy.plotting.pygletplot.plot_object import PlotObject
+    from sympy.plotting.pygletplot.plot_surface import PlotSurface
+    from sympy.plotting.pygletplot.plot_window import PlotWindow
+    for c in (
+        ColorGradient, ColorGradient(0.2, 0.4), ColorScheme, ManagedWindow,
+        ManagedWindow, Plot, ScreenShot, PlotAxes, PlotAxesBase,
+        PlotAxesFrame, PlotAxesOrdinate, PlotCamera, PlotController,
+        PlotCurve, PlotInterval, PlotMode, Cartesian2D, Cartesian3D,
+        Cylindrical, ParametricCurve2D, ParametricCurve3D,
+        ParametricSurface, Polar, Spherical, PlotObject, PlotSurface,
+            PlotWindow):
+        check(c)
+
+
+@XFAIL
+def test_plotting2():
+    #from sympy.plotting.color_scheme import ColorGradient
+    from sympy.plotting.pygletplot.color_scheme import ColorScheme
+    #from sympy.plotting.managed_window import ManagedWindow
+    from sympy.plotting.plot import Plot
+    #from sympy.plotting.plot import ScreenShot
+    from sympy.plotting.pygletplot.plot_axes import PlotAxes
+    #from sympy.plotting.plot_axes import PlotAxesBase, PlotAxesFrame, PlotAxesOrdinate
+    #from sympy.plotting.plot_camera import PlotCamera
+    #from sympy.plotting.plot_controller import PlotController
+    #from sympy.plotting.plot_curve import PlotCurve
+    #from sympy.plotting.plot_interval import PlotInterval
+    #from sympy.plotting.plot_mode import PlotMode
+    #from sympy.plotting.plot_modes import Cartesian2D, Cartesian3D, Cylindrical, \
+    #    ParametricCurve2D, ParametricCurve3D, ParametricSurface, Polar, Spherical
+    #from sympy.plotting.plot_object import PlotObject
+    #from sympy.plotting.plot_surface import PlotSurface
+    # from sympy.plotting.plot_window import PlotWindow
+    check(ColorScheme("rainbow"))
+    check(Plot(1, visible=False))
+    check(PlotAxes())
+
+#================== polys =======================
+from sympy.polys.domains.integerring import ZZ
+from sympy.polys.domains.rationalfield import QQ
+from sympy.polys.orderings import lex
+from sympy.polys.polytools import Poly
+
+def test_pickling_polys_polytools():
+    from sympy.polys.polytools import PurePoly
+    # from sympy.polys.polytools import GroebnerBasis
+    x = Symbol('x')
+
+    for c in (Poly, Poly(x, x)):
+        check(c)
+
+    for c in (PurePoly, PurePoly(x)):
+        check(c)
+
+    # TODO: fix pickling of Options class (see GroebnerBasis._options)
+    # for c in (GroebnerBasis, GroebnerBasis([x**2 - 1], x, order=lex)):
+    #     check(c)
+
+def test_pickling_polys_polyclasses():
+    from sympy.polys.polyclasses import DMP, DMF, ANP
+
+    for c in (DMP, DMP([[ZZ(1)], [ZZ(2)], [ZZ(3)]], ZZ)):
+        check(c, deprecated=['rep'])
+    for c in (DMF, DMF(([ZZ(1), ZZ(2)], [ZZ(1), ZZ(3)]), ZZ)):
+        check(c)
+    for c in (ANP, ANP([QQ(1), QQ(2)], [QQ(1), QQ(2), QQ(3)], QQ)):
+        check(c)
+
+@XFAIL
+def test_pickling_polys_rings():
+    # NOTE: can't use protocols < 2 because we have to execute __new__ to
+    # make sure caching of rings works properly.
+
+    from sympy.polys.rings import PolyRing
+
+    ring = PolyRing("x,y,z", ZZ, lex)
+
+    for c in (PolyRing, ring):
+        check(c, exclude=[0, 1])
+
+    for c in (ring.dtype, ring.one):
+        check(c, exclude=[0, 1], check_attr=False) # TODO: Py3k
+
+def test_pickling_polys_fields():
+    pass
+    # NOTE: can't use protocols < 2 because we have to execute __new__ to
+    # make sure caching of fields works properly.
+
+    # from sympy.polys.fields import FracField
+
+    # field = FracField("x,y,z", ZZ, lex)
+
+    # TODO: AssertionError: assert id(obj) not in self.memo
+    # for c in (FracField, field):
+    #     check(c, exclude=[0, 1])
+
+    # TODO: AssertionError: assert id(obj) not in self.memo
+    # for c in (field.dtype, field.one):
+    #     check(c, exclude=[0, 1])
+
+def test_pickling_polys_elements():
+    from sympy.polys.domains.pythonrational import PythonRational
+    #from sympy.polys.domains.pythonfinitefield import PythonFiniteField
+    #from sympy.polys.domains.mpelements import MPContext
+
+    for c in (PythonRational, PythonRational(1, 7)):
+        check(c)
+
+    #gf = PythonFiniteField(17)
+
+    # TODO: fix pickling of ModularInteger
+    # for c in (gf.dtype, gf(5)):
+    #     check(c)
+
+    #mp = MPContext()
+
+    # TODO: fix pickling of RealElement
+    # for c in (mp.mpf, mp.mpf(1.0)):
+    #     check(c)
+
+    # TODO: fix pickling of ComplexElement
+    # for c in (mp.mpc, mp.mpc(1.0, -1.5)):
+    #     check(c)
+
+def test_pickling_polys_domains():
+    # from sympy.polys.domains.pythonfinitefield import PythonFiniteField
+    from sympy.polys.domains.pythonintegerring import PythonIntegerRing
+    from sympy.polys.domains.pythonrationalfield import PythonRationalField
+
+    # TODO: fix pickling of ModularInteger
+    # for c in (PythonFiniteField, PythonFiniteField(17)):
+    #     check(c)
+
+    for c in (PythonIntegerRing, PythonIntegerRing()):
+        check(c, check_attr=False)
+
+    for c in (PythonRationalField, PythonRationalField()):
+        check(c, check_attr=False)
+
+    if _gmpy is not None:
+        # from sympy.polys.domains.gmpyfinitefield import GMPYFiniteField
+        from sympy.polys.domains.gmpyintegerring import GMPYIntegerRing
+        from sympy.polys.domains.gmpyrationalfield import GMPYRationalField
+
+        # TODO: fix pickling of ModularInteger
+        # for c in (GMPYFiniteField, GMPYFiniteField(17)):
+        #     check(c)
+
+        for c in (GMPYIntegerRing, GMPYIntegerRing()):
+            check(c, check_attr=False)
+
+        for c in (GMPYRationalField, GMPYRationalField()):
+            check(c, check_attr=False)
+
+    #from sympy.polys.domains.realfield import RealField
+    #from sympy.polys.domains.complexfield import ComplexField
+    from sympy.polys.domains.algebraicfield import AlgebraicField
+    #from sympy.polys.domains.polynomialring import PolynomialRing
+    #from sympy.polys.domains.fractionfield import FractionField
+    from sympy.polys.domains.expressiondomain import ExpressionDomain
+
+    # TODO: fix pickling of RealElement
+    # for c in (RealField, RealField(100)):
+    #     check(c)
+
+    # TODO: fix pickling of ComplexElement
+    # for c in (ComplexField, ComplexField(100)):
+    #     check(c)
+
+    for c in (AlgebraicField, AlgebraicField(QQ, sqrt(3))):
+        check(c, check_attr=False)
+
+    # TODO: AssertionError
+    # for c in (PolynomialRing, PolynomialRing(ZZ, "x,y,z")):
+    #     check(c)
+
+    # TODO: AttributeError: 'PolyElement' object has no attribute 'ring'
+    # for c in (FractionField, FractionField(ZZ, "x,y,z")):
+    #     check(c)
+
+    for c in (ExpressionDomain, ExpressionDomain()):
+        check(c, check_attr=False)
+
+
+def test_pickling_polys_orderings():
+    from sympy.polys.orderings import (LexOrder, GradedLexOrder,
+        ReversedGradedLexOrder, InverseOrder)
+    # from sympy.polys.orderings import ProductOrder
+
+    for c in (LexOrder, LexOrder()):
+        check(c)
+
+    for c in (GradedLexOrder, GradedLexOrder()):
+        check(c)
+
+    for c in (ReversedGradedLexOrder, ReversedGradedLexOrder()):
+        check(c)
+
+    # TODO: Argh, Python is so naive. No lambdas nor inner function support in
+    # pickling module. Maybe someone could figure out what to do with this.
+    #
+    # for c in (ProductOrder, ProductOrder((LexOrder(),       lambda m: m[:2]),
+    #                                      (GradedLexOrder(), lambda m: m[2:]))):
+    #     check(c)
+
+    for c in (InverseOrder, InverseOrder(LexOrder())):
+        check(c)
+
+def test_pickling_polys_monomials():
+    from sympy.polys.monomials import MonomialOps, Monomial
+    x, y, z = symbols("x,y,z")
+
+    for c in (MonomialOps, MonomialOps(3)):
+        check(c)
+
+    for c in (Monomial, Monomial((1, 2, 3), (x, y, z))):
+        check(c)
+
+def test_pickling_polys_errors():
+    from sympy.polys.polyerrors import (HeuristicGCDFailed,
+        HomomorphismFailed, IsomorphismFailed, ExtraneousFactors,
+        EvaluationFailed, RefinementFailed, CoercionFailed, NotInvertible,
+        NotReversible, NotAlgebraic, DomainError, PolynomialError,
+        UnificationFailed, GeneratorsError, GeneratorsNeeded,
+        UnivariatePolynomialError, MultivariatePolynomialError, OptionError,
+        FlagError)
+    # from sympy.polys.polyerrors import (ExactQuotientFailed,
+    #         OperationNotSupported, ComputationFailed, PolificationFailed)
+
+    # x = Symbol('x')
+
+    # TODO: TypeError: __init__() takes at least 3 arguments (1 given)
+    # for c in (ExactQuotientFailed, ExactQuotientFailed(x, 3*x, ZZ)):
+    #    check(c)
+
+    # TODO: TypeError: can't pickle instancemethod objects
+    # for c in (OperationNotSupported, OperationNotSupported(Poly(x), Poly.gcd)):
+    #    check(c)
+
+    for c in (HeuristicGCDFailed, HeuristicGCDFailed()):
+        check(c)
+
+    for c in (HomomorphismFailed, HomomorphismFailed()):
+        check(c)
+
+    for c in (IsomorphismFailed, IsomorphismFailed()):
+        check(c)
+
+    for c in (ExtraneousFactors, ExtraneousFactors()):
+        check(c)
+
+    for c in (EvaluationFailed, EvaluationFailed()):
+        check(c)
+
+    for c in (RefinementFailed, RefinementFailed()):
+        check(c)
+
+    for c in (CoercionFailed, CoercionFailed()):
+        check(c)
+
+    for c in (NotInvertible, NotInvertible()):
+        check(c)
+
+    for c in (NotReversible, NotReversible()):
+        check(c)
+
+    for c in (NotAlgebraic, NotAlgebraic()):
+        check(c)
+
+    for c in (DomainError, DomainError()):
+        check(c)
+
+    for c in (PolynomialError, PolynomialError()):
+        check(c)
+
+    for c in (UnificationFailed, UnificationFailed()):
+        check(c)
+
+    for c in (GeneratorsError, GeneratorsError()):
+        check(c)
+
+    for c in (GeneratorsNeeded, GeneratorsNeeded()):
+        check(c)
+
+    # TODO: PicklingError: Can't pickle <function <lambda> at 0x38578c0>: it's not found as __main__.<lambda>
+    # for c in (ComputationFailed, ComputationFailed(lambda t: t, 3, None)):
+    #    check(c)
+
+    for c in (UnivariatePolynomialError, UnivariatePolynomialError()):
+        check(c)
+
+    for c in (MultivariatePolynomialError, MultivariatePolynomialError()):
+        check(c)
+
+    # TODO: TypeError: __init__() takes at least 3 arguments (1 given)
+    # for c in (PolificationFailed, PolificationFailed({}, x, x, False)):
+    #    check(c)
+
+    for c in (OptionError, OptionError()):
+        check(c)
+
+    for c in (FlagError, FlagError()):
+        check(c)
+
+#def test_pickling_polys_options():
+    #from sympy.polys.polyoptions import Options
+
+    # TODO: fix pickling of `symbols' flag
+    # for c in (Options, Options((), dict(domain='ZZ', polys=False))):
+    #    check(c)
+
+# TODO: def test_pickling_polys_rootisolation():
+#    RealInterval
+#    ComplexInterval
+
+def test_pickling_polys_rootoftools():
+    from sympy.polys.rootoftools import CRootOf, RootSum
+
+    x = Symbol('x')
+    f = x**3 + x + 3
+
+    for c in (CRootOf, CRootOf(f, 0)):
+        check(c)
+
+    for c in (RootSum, RootSum(f, exp)):
+        check(c)
+
+#================== printing ====================
+from sympy.printing.latex import LatexPrinter
+from sympy.printing.mathml import MathMLContentPrinter, MathMLPresentationPrinter
+from sympy.printing.pretty.pretty import PrettyPrinter
+from sympy.printing.pretty.stringpict import prettyForm, stringPict
+from sympy.printing.printer import Printer
+from sympy.printing.python import PythonPrinter
+
+
+def test_printing():
+    for c in (LatexPrinter, LatexPrinter(), MathMLContentPrinter,
+              MathMLPresentationPrinter, PrettyPrinter, prettyForm, stringPict,
+              stringPict("a"), Printer, Printer(), PythonPrinter,
+              PythonPrinter()):
+        check(c)
+
+
+@XFAIL
+def test_printing1():
+    check(MathMLContentPrinter())
+
+
+@XFAIL
+def test_printing2():
+    check(MathMLPresentationPrinter())
+
+
+@XFAIL
+def test_printing3():
+    check(PrettyPrinter())
+
+#================== series ======================
+from sympy.series.limits import Limit
+from sympy.series.order import Order
+
+
+def test_series():
+    e = Symbol("e")
+    x = Symbol("x")
+    for c in (Limit, Limit(e, x, 1), Order, Order(e)):
+        check(c)
+
+#================== concrete ==================
+from sympy.concrete.products import Product
+from sympy.concrete.summations import Sum
+
+
+def test_concrete():
+    x = Symbol("x")
+    for c in (Product, Product(x, (x, 2, 4)), Sum, Sum(x, (x, 2, 4))):
+        check(c)
+
+def test_deprecation_warning():
+    w = SymPyDeprecationWarning("message", deprecated_since_version='1.0', active_deprecations_target="active-deprecations")
+    check(w)
+
+def test_issue_18438():
+    assert pickle.loads(pickle.dumps(S.Half)) == S.Half
+
+
+#================= old pickles =================
+def test_unpickle_from_older_versions():
+    data = (
+        b'\x80\x04\x95^\x00\x00\x00\x00\x00\x00\x00\x8c\x10sympy.core.power'
+        b'\x94\x8c\x03Pow\x94\x93\x94\x8c\x12sympy.core.numbers\x94\x8c'
+        b'\x07Integer\x94\x93\x94K\x02\x85\x94R\x94}\x94bh\x03\x8c\x04Half'
+        b'\x94\x93\x94)R\x94}\x94b\x86\x94R\x94}\x94b.'
+    )
+    assert pickle.loads(data) == sqrt(2)

.venv/lib/python3.13/site-packages/sympy/utilities/tests/test_source.py

@@ -0,0 +1,11 @@
+from sympy.utilities.source import get_mod_func, get_class
+
+
+def test_get_mod_func():
+    assert get_mod_func(
+        'sympy.core.basic.Basic') == ('sympy.core.basic', 'Basic')
+
+
+def test_get_class():
+    _basic = get_class('sympy.core.basic.Basic')
+    assert _basic.__name__ == 'Basic'

.venv/lib/python3.13/site-packages/sympy/utilities/tests/test_timeutils.py

@@ -0,0 +1,10 @@
+"""Tests for simple tools for timing functions' execution. """
+
+from sympy.utilities.timeutils import timed
+
+def test_timed():
+    result = timed(lambda: 1 + 1, limit=100000)
+    assert result[0] == 100000 and result[3] == "ns", str(result)
+
+    result = timed("1 + 1", limit=100000)
+    assert result[0] == 100000 and result[3] == "ns"

.venv/lib/python3.13/site-packages/sympy/utilities/tests/test_wester.py

@@ -0,0 +1,3104 @@
+""" Tests from Michael Wester's 1999 paper "Review of CAS mathematical
+capabilities".
+
+http://www.math.unm.edu/~wester/cas/book/Wester.pdf
+See also http://math.unm.edu/~wester/cas_review.html for detailed output of
+each tested system.
+"""
+
+from sympy.assumptions.ask import Q, ask
+from sympy.assumptions.refine import refine
+from sympy.concrete.products import product
+from sympy.core import EulerGamma
+from sympy.core.evalf import N
+from sympy.core.function import (Derivative, Function, Lambda, Subs,
+    diff, expand, expand_func)
+from sympy.core.mul import Mul
+from sympy.core.intfunc import igcd
+from sympy.core.numbers import (AlgebraicNumber, E, I, Rational,
+    nan, oo, pi, zoo)
+from sympy.core.relational import Eq, Lt
+from sympy.core.singleton import S
+from sympy.core.symbol import Dummy, Symbol, symbols
+from sympy.functions.combinatorial.factorials import (rf, binomial,
+    factorial, factorial2)
+from sympy.functions.combinatorial.numbers import bernoulli, fibonacci, totient, partition
+from sympy.functions.elementary.complexes import (conjugate, im, re,
+    sign)
+from sympy.functions.elementary.exponential import LambertW, exp, log
+from sympy.functions.elementary.hyperbolic import (asinh, cosh, sinh,
+    tanh)
+from sympy.functions.elementary.integers import ceiling, floor
+from sympy.functions.elementary.miscellaneous import Max, Min, sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (acos, acot, asin,
+    atan, cos, cot, csc, sec, sin, tan)
+from sympy.functions.special.bessel import besselj
+from sympy.functions.special.delta_functions import DiracDelta
+from sympy.functions.special.elliptic_integrals import (elliptic_e,
+    elliptic_f)
+from sympy.functions.special.gamma_functions import gamma, polygamma
+from sympy.functions.special.hyper import hyper
+from sympy.functions.special.polynomials import (assoc_legendre,
+    chebyshevt)
+from sympy.functions.special.zeta_functions import polylog
+from sympy.geometry.util import idiff
+from sympy.logic.boolalg import And
+from sympy.matrices.dense import hessian, wronskian
+from sympy.matrices.expressions.matmul import MatMul
+from sympy.ntheory.continued_fraction import (
+    continued_fraction_convergents as cf_c,
+    continued_fraction_iterator as cf_i, continued_fraction_periodic as
+    cf_p, continued_fraction_reduce as cf_r)
+from sympy.ntheory.factor_ import factorint
+from sympy.ntheory.generate import primerange
+from sympy.polys.domains.integerring import ZZ
+from sympy.polys.orthopolys import legendre_poly
+from sympy.polys.partfrac import apart
+from sympy.polys.polytools import Poly, factor, gcd, resultant
+from sympy.series.limits import limit
+from sympy.series.order import O
+from sympy.series.residues import residue
+from sympy.series.series import series
+from sympy.sets.fancysets import ImageSet
+from sympy.sets.sets import FiniteSet, Intersection, Interval, Union
+from sympy.simplify.combsimp import combsimp
+from sympy.simplify.hyperexpand import hyperexpand
+from sympy.simplify.powsimp import powdenest, powsimp
+from sympy.simplify.radsimp import radsimp
+from sympy.simplify.simplify import logcombine, simplify
+from sympy.simplify.sqrtdenest import sqrtdenest
+from sympy.simplify.trigsimp import trigsimp
+from sympy.solvers.solvers import solve
+
+import mpmath
+from sympy.functions.combinatorial.numbers import stirling
+from sympy.functions.special.delta_functions import Heaviside
+from sympy.functions.special.error_functions import Ci, Si, erf
+from sympy.functions.special.zeta_functions import zeta
+from sympy.testing.pytest import (XFAIL, slow, SKIP, tooslow, raises)
+from sympy.utilities.iterables import partitions
+from mpmath import mpi, mpc
+from sympy.matrices import Matrix, GramSchmidt, eye
+from sympy.matrices.expressions.blockmatrix import BlockMatrix, block_collapse
+from sympy.matrices.expressions import MatrixSymbol, ZeroMatrix
+from sympy.physics.quantum import Commutator
+from sympy.polys.rings import PolyRing
+from sympy.polys.fields import FracField
+from sympy.polys.solvers import solve_lin_sys
+from sympy.concrete import Sum
+from sympy.concrete.products import Product
+from sympy.integrals import integrate
+from sympy.integrals.transforms import laplace_transform,\
+    inverse_laplace_transform, LaplaceTransform, fourier_transform,\
+    mellin_transform, laplace_correspondence, laplace_initial_conds
+from sympy.solvers.recurr import rsolve
+from sympy.solvers.solveset import solveset, solveset_real, linsolve
+from sympy.solvers.ode import dsolve
+from sympy.core.relational import Equality
+from itertools import islice, takewhile
+from sympy.series.formal import fps
+from sympy.series.fourier import fourier_series
+from sympy.calculus.util import minimum
+
+
+EmptySet = S.EmptySet
+R = Rational
+x, y, z = symbols('x y z')
+i, j, k, l, m, n = symbols('i j k l m n', integer=True)
+f = Function('f')
+g = Function('g')
+
+# A. Boolean Logic and Quantifier Elimination
+#   Not implemented.
+
+# B. Set Theory
+
+
+def test_B1():
+    assert (FiniteSet(i, j, j, k, k, k) | FiniteSet(l, k, j) |
+            FiniteSet(j, m, j)) == FiniteSet(i, j, k, l, m)
+
+
+def test_B2():
+    assert (FiniteSet(i, j, j, k, k, k) & FiniteSet(l, k, j) &
+            FiniteSet(j, m, j)) == Intersection({j, m}, {i, j, k}, {j, k, l})
+    # Previous output below. Not sure why that should be the expected output.
+    # There should probably be a way to rewrite Intersections that way but I
+    # don't see why an Intersection should evaluate like that:
+    #
+    # == Union({j}, Intersection({m}, Union({j, k}, Intersection({i}, {l}))))
+
+
+def test_B3():
+    assert (FiniteSet(i, j, k, l, m) - FiniteSet(j) ==
+            FiniteSet(i, k, l, m))
+
+
+def test_B4():
+    assert (FiniteSet(*(FiniteSet(i, j)*FiniteSet(k, l))) ==
+            FiniteSet((i, k), (i, l), (j, k), (j, l)))
+
+
+# C. Numbers
+
+
+def test_C1():
+    assert (factorial(50) ==
+        30414093201713378043612608166064768844377641568960512000000000000)
+
+
+def test_C2():
+    assert (factorint(factorial(50)) == {2: 47, 3: 22, 5: 12, 7: 8,
+        11: 4, 13: 3, 17: 2, 19: 2, 23: 2, 29: 1, 31: 1, 37: 1,
+        41: 1, 43: 1, 47: 1})
+
+
+def test_C3():
+    assert (factorial2(10), factorial2(9)) == (3840, 945)
+
+
+# Base conversions; not really implemented by SymPy
+# Whatever. Take credit!
+def test_C4():
+    assert 0xABC == 2748
+
+
+def test_C5():
+    assert 123 == int('234', 7)
+
+
+def test_C6():
+    assert int('677', 8) == int('1BF', 16) == 447
+
+
+def test_C7():
+    assert log(32768, 8) == 5
+
+
+def test_C8():
+    # Modular multiplicative inverse. Would be nice if divmod could do this.
+    assert ZZ.invert(5, 7) == 3
+    assert ZZ.invert(5, 6) == 5
+
+
+def test_C9():
+    assert igcd(igcd(1776, 1554), 5698) == 74
+
+
+def test_C10():
+    x = 0
+    for n in range(2, 11):
+        x += R(1, n)
+    assert x == R(4861, 2520)
+
+
+def test_C11():
+    assert R(1, 7) == S('0.[142857]')
+
+
+def test_C12():
+    assert R(7, 11) * R(22, 7) == 2
+
+
+def test_C13():
+    test = R(10, 7) * (1 + R(29, 1000)) ** R(1, 3)
+    good = 3 ** R(1, 3)
+    assert test == good
+
+
+def test_C14():
+    assert sqrtdenest(sqrt(2*sqrt(3) + 4)) == 1 + sqrt(3)
+
+
+def test_C15():
+    test = sqrtdenest(sqrt(14 + 3*sqrt(3 + 2*sqrt(5 - 12*sqrt(3 - 2*sqrt(2))))))
+    good = sqrt(2) + 3
+    assert test == good
+
+
+def test_C16():
+    test = sqrtdenest(sqrt(10 + 2*sqrt(6) + 2*sqrt(10) + 2*sqrt(15)))
+    good = sqrt(2) + sqrt(3) + sqrt(5)
+    assert test == good
+
+
+def test_C17():
+    test = radsimp((sqrt(3) + sqrt(2)) / (sqrt(3) - sqrt(2)))
+    good = 5 + 2*sqrt(6)
+    assert test == good
+
+
+def test_C18():
+    assert simplify((sqrt(-2 + sqrt(-5)) * sqrt(-2 - sqrt(-5))).expand(complex=True)) == 3
+
+
+@XFAIL
+def test_C19():
+    assert radsimp(simplify((90 + 34*sqrt(7)) ** R(1, 3))) == 3 + sqrt(7)
+
+
+def test_C20():
+    inside = (135 + 78*sqrt(3))
+    test = AlgebraicNumber((inside**R(2, 3) + 3) * sqrt(3) / inside**R(1, 3))
+    assert simplify(test) == AlgebraicNumber(12)
+
+
+def test_C21():
+    assert simplify(AlgebraicNumber((41 + 29*sqrt(2)) ** R(1, 5))) == \
+        AlgebraicNumber(1 + sqrt(2))
+
+
+@XFAIL
+def test_C22():
+    test = simplify(((6 - 4*sqrt(2))*log(3 - 2*sqrt(2)) + (3 - 2*sqrt(2))*log(17
+        - 12*sqrt(2)) + 32 - 24*sqrt(2)) / (48*sqrt(2) - 72))
+    good = sqrt(2)/3 - log(sqrt(2) - 1)/3
+    assert test == good
+
+
+def test_C23():
+    assert 2 * oo - 3 is oo
+
+
+@XFAIL
+def test_C24():
+    raise NotImplementedError("2**aleph_null == aleph_1")
+
+# D. Numerical Analysis
+
+
+def test_D1():
+    assert 0.0 / sqrt(2) == 0
+
+
+def test_D2():
+    assert str(exp(-1000000).evalf()) == '3.29683147808856e-434295'
+
+
+def test_D3():
+    assert exp(pi*sqrt(163)).evalf(50).num.ae(262537412640768744)
+
+
+def test_D4():
+    assert floor(R(-5, 3)) == -2
+    assert ceiling(R(-5, 3)) == -1
+
+
+@XFAIL
+def test_D5():
+    raise NotImplementedError("cubic_spline([1, 2, 4, 5], [1, 4, 2, 3], x)(3) == 27/8")
+
+
+@XFAIL
+def test_D6():
+    raise NotImplementedError("translate sum(a[i]*x**i, (i,1,n)) to FORTRAN")
+
+
+@XFAIL
+def test_D7():
+    raise NotImplementedError("translate sum(a[i]*x**i, (i,1,n)) to C")
+
+
+@XFAIL
+def test_D8():
+    # One way is to cheat by converting the sum to a string,
+    # and replacing the '[' and ']' with ''.
+    # E.g., horner(S(str(_).replace('[','').replace(']','')))
+    raise NotImplementedError("apply Horner's rule to sum(a[i]*x**i, (i,1,5))")
+
+
+@XFAIL
+def test_D9():
+    raise NotImplementedError("translate D8 to FORTRAN")
+
+
+@XFAIL
+def test_D10():
+    raise NotImplementedError("translate D8 to C")
+
+
+@XFAIL
+def test_D11():
+    #Is there a way to use count_ops?
+    raise NotImplementedError("flops(sum(product(f[i][k], (i,1,k)), (k,1,n)))")
+
+
+@XFAIL
+def test_D12():
+    assert (mpi(-4, 2) * x + mpi(1, 3)) ** 2 == mpi(-8, 16)*x**2 + mpi(-24, 12)*x + mpi(1, 9)
+
+
+@XFAIL
+def test_D13():
+    raise NotImplementedError("discretize a PDE: diff(f(x,t),t) == diff(diff(f(x,t),x),x)")
+
+# E. Statistics
+#   See scipy; all of this is numerical.
+
+# F. Combinatorial Theory.
+
+
+def test_F1():
+    assert rf(x, 3) == x*(1 + x)*(2 + x)
+
+
+def test_F2():
+    assert expand_func(binomial(n, 3)) == n*(n - 1)*(n - 2)/6
+
+
+@XFAIL
+def test_F3():
+    assert combsimp(2**n * factorial(n) * factorial2(2*n - 1)) == factorial(2*n)
+
+
+@XFAIL
+def test_F4():
+    assert combsimp(2**n * factorial(n) * product(2*k - 1, (k, 1, n))) == factorial(2*n)
+
+
+@XFAIL
+def test_F5():
+    assert gamma(n + R(1, 2)) / sqrt(pi) / factorial(n) == factorial(2*n)/2**(2*n)/factorial(n)**2
+
+
+def test_F6():
+    partTest = [p.copy() for p in partitions(4)]
+    partDesired = [{4: 1}, {1: 1, 3: 1}, {2: 2}, {1: 2, 2:1}, {1: 4}]
+    assert partTest == partDesired
+
+
+def test_F7():
+    assert partition(4) == 5
+
+
+def test_F8():
+    assert stirling(5, 2, signed=True) == -50  # if signed, then kind=1
+
+
+def test_F9():
+    assert totient(1776) == 576
+
+# G. Number Theory
+
+
+def test_G1():
+    assert list(primerange(999983, 1000004)) == [999983, 1000003]
+
+
+@XFAIL
+def test_G2():
+    raise NotImplementedError("find the primitive root of 191 == 19")
+
+
+@XFAIL
+def test_G3():
+    raise NotImplementedError("(a+b)**p mod p == a**p + b**p mod p; p prime")
+
+# ... G14 Modular equations are not implemented.
+
+def test_G15():
+    assert Rational(sqrt(3).evalf()).limit_denominator(15) == R(26, 15)
+    assert list(takewhile(lambda x: x.q <= 15, cf_c(cf_i(sqrt(3)))))[-1] == \
+        R(26, 15)
+
+
+def test_G16():
+    assert list(islice(cf_i(pi),10)) == [3, 7, 15, 1, 292, 1, 1, 1, 2, 1]
+
+
+def test_G17():
+    assert cf_p(0, 1, 23) == [4, [1, 3, 1, 8]]
+
+
+def test_G18():
+    assert cf_p(1, 2, 5) == [[1]]
+    assert cf_r([[1]]).expand() == S.Half + sqrt(5)/2
+
+
+@XFAIL
+def test_G19():
+    s = symbols('s', integer=True, positive=True)
+    it = cf_i((exp(1/s) - 1)/(exp(1/s) + 1))
+    assert list(islice(it, 5)) == [0, 2*s, 6*s, 10*s, 14*s]
+
+
+def test_G20():
+    s = symbols('s', integer=True, positive=True)
+    # Wester erroneously has this as -s + sqrt(s**2 + 1)
+    assert cf_r([[2*s]]) == s + sqrt(s**2 + 1)
+
+
+@XFAIL
+def test_G20b():
+    s = symbols('s', integer=True, positive=True)
+    assert cf_p(s, 1, s**2 + 1) == [[2*s]]
+
+
+# H. Algebra
+
+
+def test_H1():
+    assert simplify(2*2**n) == simplify(2**(n + 1))
+    assert powdenest(2*2**n) == simplify(2**(n + 1))
+
+
+def test_H2():
+    assert powsimp(4 * 2**n) == 2**(n + 2)
+
+
+def test_H3():
+    assert (-1)**(n*(n + 1)) == 1
+
+
+def test_H4():
+    expr = factor(6*x - 10)
+    assert type(expr) is Mul
+    assert expr.args[0] == 2
+    assert expr.args[1] == 3*x - 5
+
+p1 = 64*x**34 - 21*x**47 - 126*x**8 - 46*x**5 - 16*x**60 - 81
+p2 = 72*x**60 - 25*x**25 - 19*x**23 - 22*x**39 - 83*x**52 + 54*x**10 + 81
+q = 34*x**19 - 25*x**16 + 70*x**7 + 20*x**3 - 91*x - 86
+
+
+def test_H5():
+    assert gcd(p1, p2, x) == 1
+
+
+def test_H6():
+    assert gcd(expand(p1 * q), expand(p2 * q)) == q
+
+
+def test_H7():
+    p1 = 24*x*y**19*z**8 - 47*x**17*y**5*z**8 + 6*x**15*y**9*z**2 - 3*x**22 + 5
+    p2 = 34*x**5*y**8*z**13 + 20*x**7*y**7*z**7 + 12*x**9*y**16*z**4 + 80*y**14*z
+    assert gcd(p1, p2, x, y, z) == 1
+
+
+def test_H8():
+    p1 = 24*x*y**19*z**8 - 47*x**17*y**5*z**8 + 6*x**15*y**9*z**2 - 3*x**22 + 5
+    p2 = 34*x**5*y**8*z**13 + 20*x**7*y**7*z**7 + 12*x**9*y**16*z**4 + 80*y**14*z
+    q = 11*x**12*y**7*z**13 - 23*x**2*y**8*z**10 + 47*x**17*y**5*z**8
+    assert gcd(p1 * q, p2 * q, x, y, z) == q
+
+
+def test_H9():
+    x = Symbol('x', zero=False)
+    p1 = 2*x**(n + 4) - x**(n + 2)
+    p2 = 4*x**(n + 1) + 3*x**n
+    assert gcd(p1, p2) == x**n
+
+
+def test_H10():
+    p1 = 3*x**4 + 3*x**3 + x**2 - x - 2
+    p2 = x**3 - 3*x**2 + x + 5
+    assert resultant(p1, p2, x) == 0
+
+
+def test_H11():
+    assert resultant(p1 * q, p2 * q, x) == 0
+
+
+def test_H12():
+    num = x**2 - 4
+    den = x**2 + 4*x + 4
+    assert simplify(num/den) == (x - 2)/(x + 2)
+
+
+@XFAIL
+def test_H13():
+    assert simplify((exp(x) - 1) / (exp(x/2) + 1)) == exp(x/2) - 1
+
+
+def test_H14():
+    p = (x + 1) ** 20
+    ep = expand(p)
+    assert ep == (1 + 20*x + 190*x**2 + 1140*x**3 + 4845*x**4 + 15504*x**5
+        + 38760*x**6 + 77520*x**7 + 125970*x**8 + 167960*x**9 + 184756*x**10
+        + 167960*x**11 + 125970*x**12 + 77520*x**13 + 38760*x**14 + 15504*x**15
+        + 4845*x**16 + 1140*x**17 + 190*x**18 + 20*x**19 + x**20)
+    dep = diff(ep, x)
+    assert dep == (20 + 380*x + 3420*x**2 + 19380*x**3 + 77520*x**4
+        + 232560*x**5 + 542640*x**6 + 1007760*x**7 + 1511640*x**8 + 1847560*x**9
+        + 1847560*x**10 + 1511640*x**11 + 1007760*x**12 + 542640*x**13
+        + 232560*x**14 + 77520*x**15 + 19380*x**16 + 3420*x**17 + 380*x**18
+        + 20*x**19)
+    assert factor(dep) == 20*(1 + x)**19
+
+
+def test_H15():
+    assert simplify(Mul(*[x - r for r in solveset(x**3 + x**2 - 7)])) == x**3 + x**2 - 7
+
+
+def test_H16():
+    assert factor(x**100 - 1) == ((x - 1)*(x + 1)*(x**2 + 1)*(x**4 - x**3
+        + x**2 - x + 1)*(x**4 + x**3 + x**2 + x + 1)*(x**8 - x**6 + x**4
+        - x**2 + 1)*(x**20 - x**15 + x**10 - x**5 + 1)*(x**20 + x**15 + x**10
+        + x**5 + 1)*(x**40 - x**30 + x**20 - x**10 + 1))
+
+
+def test_H17():
+    assert simplify(factor(expand(p1 * p2)) - p1*p2) == 0
+
+
+@XFAIL
+def test_H18():
+    # Factor over complex rationals.
+    test = factor(4*x**4 + 8*x**3 + 77*x**2 + 18*x + 153)
+    good = (2*x + 3*I)*(2*x - 3*I)*(x + 1 - 4*I)*(x + 1 + 4*I)
+    assert test == good
+
+
+def test_H19():
+    a = symbols('a')
+    # The idea is to let a**2 == 2, then solve 1/(a-1). Answer is a+1")
+    assert Poly(a - 1).invert(Poly(a**2 - 2)) == a + 1
+
+
+@XFAIL
+def test_H20():
+    raise NotImplementedError("let a**2==2; (x**3 + (a-2)*x**2 - "
+        + "(2*a+3)*x - 3*a) / (x**2-2) = (x**2 - 2*x - 3) / (x-a)")
+
+
+@XFAIL
+def test_H21():
+    raise NotImplementedError("evaluate (b+c)**4 assuming b**3==2, c**2==3. \
+                              Answer is 2*b + 8*c + 18*b**2 + 12*b*c + 9")
+
+
+def test_H22():
+    assert factor(x**4 - 3*x**2 + 1, modulus=5) == (x - 2)**2 * (x + 2)**2
+
+
+def test_H23():
+    f = x**11 + x + 1
+    g = (x**2 + x + 1) * (x**9 - x**8 + x**6 - x**5 + x**3 - x**2 + 1)
+    assert factor(f, modulus=65537) == g
+
+
+def test_H24():
+    phi = AlgebraicNumber(S.GoldenRatio.expand(func=True), alias='phi')
+    assert factor(x**4 - 3*x**2 + 1, extension=phi) == \
+        (x - phi)*(x + 1 - phi)*(x - 1 + phi)*(x + phi)
+
+
+def test_H25():
+    e = (x - 2*y**2 + 3*z**3) ** 20
+    assert factor(expand(e)) == e
+
+
+def test_H26():
+    g = expand((sin(x) - 2*cos(y)**2 + 3*tan(z)**3)**20)
+    assert factor(g, expand=False) == (-sin(x) + 2*cos(y)**2 - 3*tan(z)**3)**20
+
+
+def test_H27():
+    f = 24*x*y**19*z**8 - 47*x**17*y**5*z**8 + 6*x**15*y**9*z**2 - 3*x**22 + 5
+    g = 34*x**5*y**8*z**13 + 20*x**7*y**7*z**7 + 12*x**9*y**16*z**4 + 80*y**14*z
+    h = -2*z*y**7 \
+        *(6*x**9*y**9*z**3 + 10*x**7*z**6 + 17*y*x**5*z**12 + 40*y**7) \
+        *(3*x**22 + 47*x**17*y**5*z**8 - 6*x**15*y**9*z**2 - 24*x*y**19*z**8 - 5)
+    assert factor(expand(f*g)) == h
+
+
+@XFAIL
+def test_H28():
+    raise NotImplementedError("expand ((1 - c**2)**5 * (1 - s**2)**5 * "
+        + "(c**2 + s**2)**10) with c**2 + s**2 = 1. Answer is c**10*s**10.")
+
+
+@XFAIL
+def test_H29():
+    assert factor(4*x**2 - 21*x*y + 20*y**2, modulus=3) == (x + y)*(x - y)
+
+
+def test_H30():
+    test = factor(x**3 + y**3, extension=sqrt(-3))
+    answer = (x + y)*(x + y*(-R(1, 2) - sqrt(3)/2*I))*(x + y*(-R(1, 2) + sqrt(3)/2*I))
+    assert answer == test
+
+
+def test_H31():
+    f = (x**2 + 2*x + 3)/(x**3 + 4*x**2 + 5*x + 2)
+    g = 2 / (x + 1)**2 - 2 / (x + 1) + 3 / (x + 2)
+    assert apart(f) == g
+
+
+@XFAIL
+def test_H32():  # issue 6558
+    raise NotImplementedError("[A*B*C - (A*B*C)**(-1)]*A*C*B (product \
+                              of a non-commuting product and its inverse)")
+
+
+def test_H33():
+    A, B, C = symbols('A, B, C', commutative=False)
+    assert (Commutator(A, Commutator(B, C))
+        + Commutator(B, Commutator(C, A))
+        + Commutator(C, Commutator(A, B))).doit().expand() == 0
+
+
+# I. Trigonometry
+
+def test_I1():
+    assert tan(pi*R(7, 10)) == -sqrt(1 + 2/sqrt(5))
+
+
+@XFAIL
+def test_I2():
+    assert sqrt((1 + cos(6))/2) == -cos(3)
+
+
+def test_I3():
+    assert cos(n*pi) + sin((4*n - 1)*pi/2) == (-1)**n - 1
+
+
+def test_I4():
+    assert refine(cos(pi*cos(n*pi)) + sin(pi/2*cos(n*pi)), Q.integer(n)) == (-1)**n - 1
+
+
+@XFAIL
+def test_I5():
+    assert sin((n**5/5 + n**4/2 + n**3/3 - n/30) * pi) == 0
+
+
+@XFAIL
+def test_I6():
+    raise NotImplementedError("assuming -3*pi<x<-5*pi/2, abs(cos(x)) == -cos(x), abs(sin(x)) == -sin(x)")
+
+
+@XFAIL
+def test_I7():
+    assert cos(3*x)/cos(x) == cos(x)**2 - 3*sin(x)**2
+
+
+@XFAIL
+def test_I8():
+    assert cos(3*x)/cos(x) == 2*cos(2*x) - 1
+
+
+@XFAIL
+def test_I9():
+    # Supposed to do this with rewrite rules.
+    assert cos(3*x)/cos(x) == cos(x)**2 - 3*sin(x)**2
+
+
+def test_I10():
+    assert trigsimp((tan(x)**2 + 1 - cos(x)**-2) / (sin(x)**2 + cos(x)**2 - 1)) is nan
+
+
+@SKIP("hangs")
+@XFAIL
+def test_I11():
+    assert limit((tan(x)**2 + 1 - cos(x)**-2) / (sin(x)**2 + cos(x)**2 - 1), x, 0) != 0
+
+
+@XFAIL
+def test_I12():
+    # This should fail or return nan or something.
+    res = diff((tan(x)**2 + 1 - cos(x)**-2) / (sin(x)**2 + cos(x)**2 - 1), x)
+    assert res is nan # trigsimp(res) gives nan
+
+# J. Special functions.
+
+
+def test_J1():
+    assert bernoulli(16) == R(-3617, 510)
+
+
+def test_J2():
+    assert diff(elliptic_e(x, y**2), y) == (elliptic_e(x, y**2) - elliptic_f(x, y**2))/y
+
+
+@XFAIL
+def test_J3():
+    raise NotImplementedError("Jacobi elliptic functions: diff(dn(u,k), u) == -k**2*sn(u,k)*cn(u,k)")
+
+
+def test_J4():
+    assert gamma(R(-1, 2)) == -2*sqrt(pi)
+
+
+def test_J5():
+    assert polygamma(0, R(1, 3)) == -log(3) - sqrt(3)*pi/6 - EulerGamma - log(sqrt(3))
+
+
+def test_J6():
+    assert mpmath.besselj(2, 1 + 1j).ae(mpc('0.04157988694396212', '0.24739764151330632'))
+
+
+def test_J7():
+    assert simplify(besselj(R(-5,2), pi/2)) == 12/(pi**2)
+
+
+def test_J8():
+    p = besselj(R(3,2), z)
+    q = (sin(z)/z - cos(z))/sqrt(pi*z/2)
+    assert simplify(expand_func(p) -q) == 0
+
+
+def test_J9():
+    assert besselj(0, z).diff(z) == - besselj(1, z)
+
+
+def test_J10():
+    mu, nu = symbols('mu, nu', integer=True)
+    assert assoc_legendre(nu, mu, 0) == 2**mu*sqrt(pi)/gamma((nu - mu)/2 + 1)/gamma((-nu - mu + 1)/2)
+
+
+def test_J11():
+    assert simplify(assoc_legendre(3, 1, x)) == simplify(-R(3, 2)*sqrt(1 - x**2)*(5*x**2 - 1))
+
+
+@slow
+def test_J12():
+    assert simplify(chebyshevt(1008, x) - 2*x*chebyshevt(1007, x) + chebyshevt(1006, x)) == 0
+
+
+def test_J13():
+    a = symbols('a', integer=True, negative=False)
+    assert chebyshevt(a, -1) == (-1)**a
+
+
+def test_J14():
+    p = hyper([S.Half, S.Half], [R(3, 2)], z**2)
+    assert hyperexpand(p) == asin(z)/z
+
+
+@XFAIL
+def test_J15():
+    raise NotImplementedError("F((n+2)/2,-(n-2)/2,R(3,2),sin(z)**2) == sin(n*z)/(n*sin(z)*cos(z)); F(.) is hypergeometric function")
+
+
+@XFAIL
+def test_J16():
+    raise NotImplementedError("diff(zeta(x), x) @ x=0 == -log(2*pi)/2")
+
+
+def test_J17():
+    assert integrate(f((x + 2)/5)*DiracDelta((x - 2)/3) - g(x)*diff(DiracDelta(x - 1), x), (x, 0, 3)) == 3*f(R(4, 5)) + Subs(Derivative(g(x), x), x, 1)
+
+
+@XFAIL
+def test_J18():
+    raise NotImplementedError("define an antisymmetric function")
+
+
+# K. The Complex Domain
+
+def test_K1():
+    z1, z2 = symbols('z1, z2', complex=True)
+    assert re(z1 + I*z2) == -im(z2) + re(z1)
+    assert im(z1 + I*z2) == im(z1) + re(z2)
+
+
+def test_K2():
+    assert abs(3 - sqrt(7) + I*sqrt(6*sqrt(7) - 15)) == 1
+
+
+@XFAIL
+def test_K3():
+    a, b = symbols('a, b', real=True)
+    assert simplify(abs(1/(a + I/a + I*b))) == 1/sqrt(a**2 + (I/a + b)**2)
+
+
+def test_K4():
+    assert log(3 + 4*I).expand(complex=True) == log(5) + I*atan(R(4, 3))
+
+
+def test_K5():
+    x, y = symbols('x, y', real=True)
+    assert tan(x + I*y).expand(complex=True) == (sin(2*x)/(cos(2*x) +
+        cosh(2*y)) + I*sinh(2*y)/(cos(2*x) + cosh(2*y)))
+
+
+def test_K6():
+    assert sqrt(x*y*abs(z)**2)/(sqrt(x)*abs(z)) == sqrt(x*y)/sqrt(x)
+    assert sqrt(x*y*abs(z)**2)/(sqrt(x)*abs(z)) != sqrt(y)
+
+
+def test_K7():
+    y = symbols('y', real=True, negative=False)
+    expr = sqrt(x*y*abs(z)**2)/(sqrt(x)*abs(z))
+    sexpr = simplify(expr)
+    assert sexpr == sqrt(y)
+
+
+def test_K8():
+    z = symbols('z', complex=True)
+    assert simplify(sqrt(1/z) - 1/sqrt(z)) != 0  # Passes
+    z = symbols('z', complex=True, negative=False)
+    assert simplify(sqrt(1/z) - 1/sqrt(z)) == 0  # Fails
+
+
+def test_K9():
+    z = symbols('z', positive=True)
+    assert simplify(sqrt(1/z) - 1/sqrt(z)) == 0
+
+
+def test_K10():
+    z = symbols('z', negative=True)
+    assert simplify(sqrt(1/z) + 1/sqrt(z)) == 0
+
+# This goes up to K25
+
+# L. Determining Zero Equivalence
+
+
+def test_L1():
+    assert sqrt(997) - (997**3)**R(1, 6) == 0
+
+
+def test_L2():
+    assert sqrt(999983) - (999983**3)**R(1, 6) == 0
+
+
+def test_L3():
+    assert simplify((2**R(1, 3) + 4**R(1, 3))**3 - 6*(2**R(1, 3) + 4**R(1, 3)) - 6) == 0
+
+
+def test_L4():
+    assert trigsimp(cos(x)**3 + cos(x)*sin(x)**2 - cos(x)) == 0
+
+
+@XFAIL
+def test_L5():
+    assert log(tan(R(1, 2)*x + pi/4)) - asinh(tan(x)) == 0
+
+
+def test_L6():
+    assert (log(tan(x/2 + pi/4)) - asinh(tan(x))).diff(x).subs({x: 0}) == 0
+
+
+@XFAIL
+def test_L7():
+    assert simplify(log((2*sqrt(x) + 1)/(sqrt(4*x + 4*sqrt(x) + 1)))) == 0
+
+
+@XFAIL
+def test_L8():
+    assert simplify((4*x + 4*sqrt(x) + 1)**(sqrt(x)/(2*sqrt(x) + 1)) \
+        *(2*sqrt(x) + 1)**(1/(2*sqrt(x) + 1)) - 2*sqrt(x) - 1) == 0
+
+
+@XFAIL
+def test_L9():
+    z = symbols('z', complex=True)
+    assert simplify(2**(1 - z)*gamma(z)*zeta(z)*cos(z*pi/2) - pi**2*zeta(1 - z)) == 0
+
+# M. Equations
+
+
+@XFAIL
+def test_M1():
+    assert Equality(x, 2)/2 + Equality(1, 1) == Equality(x/2 + 1, 2)
+
+
+def test_M2():
+    # The roots of this equation should all be real. Note that this
+    # doesn't test that they are correct.
+    sol = solveset(3*x**3 - 18*x**2 + 33*x - 19, x)
+    assert all(s.expand(complex=True).is_real for s in sol)
+
+
+@XFAIL
+def test_M5():
+    assert solveset(x**6 - 9*x**4 - 4*x**3 + 27*x**2 - 36*x - 23, x) == FiniteSet(2**(1/3) + sqrt(3), 2**(1/3) - sqrt(3), +sqrt(3) - 1/2**(2/3) + I*sqrt(3)/2**(2/3), +sqrt(3) - 1/2**(2/3) - I*sqrt(3)/2**(2/3), -sqrt(3) - 1/2**(2/3) + I*sqrt(3)/2**(2/3), -sqrt(3) - 1/2**(2/3) - I*sqrt(3)/2**(2/3))
+
+
+def test_M6():
+    assert set(solveset(x**7 - 1, x)) == \
+        {cos(n*pi*R(2, 7)) + I*sin(n*pi*R(2, 7)) for n in range(0, 7)}
+    # The paper asks for exp terms, but sin's and cos's may be acceptable;
+    # if the results are simplified, exp terms appear for all but
+    # -sin(pi/14) - I*cos(pi/14) and -sin(pi/14) + I*cos(pi/14) which
+    # will simplify if you apply the transformation foo.rewrite(exp).expand()
+
+
+def test_M7():
+    # TODO: Replace solve with solveset, as of now test fails for solveset
+    assert set(solve(x**8 - 8*x**7 + 34*x**6 - 92*x**5 + 175*x**4 - 236*x**3 +
+        226*x**2 - 140*x + 46, x)) == {
+        1 - sqrt(2)*I*sqrt(-sqrt(-3 + 4*sqrt(3)) + 3)/2,
+        1 - sqrt(2)*sqrt(-3 + I*sqrt(3 + 4*sqrt(3)))/2,
+        1 - sqrt(2)*I*sqrt(sqrt(-3 + 4*sqrt(3)) + 3)/2,
+        1 - sqrt(2)*sqrt(-3 - I*sqrt(3 + 4*sqrt(3)))/2,
+        1 + sqrt(2)*I*sqrt(sqrt(-3 + 4*sqrt(3)) + 3)/2,
+        1 + sqrt(2)*sqrt(-3 - I*sqrt(3 + 4*sqrt(3)))/2,
+        1 + sqrt(2)*sqrt(-3 + I*sqrt(3 + 4*sqrt(3)))/2,
+        1 + sqrt(2)*I*sqrt(-sqrt(-3 + 4*sqrt(3)) + 3)/2,
+        }
+
+
+@XFAIL  # There are an infinite number of solutions.
+def test_M8():
+    x = Symbol('x')
+    z = symbols('z', complex=True)
+    assert solveset(exp(2*x) + 2*exp(x) + 1 - z, x, S.Reals) == \
+        FiniteSet(log(1 + z - 2*sqrt(z))/2, log(1 + z + 2*sqrt(z))/2)
+    # This one could be simplified better (the 1/2 could be pulled into the log
+    # as a sqrt, and the function inside the log can be factored as a square,
+    # giving [log(sqrt(z) - 1), log(sqrt(z) + 1)]). Also, there should be an
+    # infinite number of solutions.
+    # x = {log(sqrt(z) - 1), log(sqrt(z) + 1) + i pi} [+ n 2 pi i, + n 2 pi i]
+    # where n is an arbitrary integer.  See url of detailed output above.
+
+
+@XFAIL
+def test_M9():
+    # x = symbols('x')
+    # solutions are 1/2*(1 +/- sqrt(9 + 8*I*pi*n)) for integer n
+    raise NotImplementedError("solveset(exp(2-x**2)-exp(-x),x) has complex solutions.")
+
+
+def test_M10():
+    # TODO: Replace solve with solveset when it gives Lambert solution
+    assert solve(exp(x) - x, x) == [-LambertW(-1)]
+
+
+@XFAIL
+def test_M11():
+    assert solveset(x**x - x, x) == FiniteSet(-1, 1)
+
+
+def test_M12():
+    # TODO: x = [-1, 2*(+/-asinh(1)*I + n*pi}, 3*(pi/6 + n*pi/3)]
+    # TODO: Replace solve with solveset, as of now test fails for solveset
+    assert solve((x + 1)*(sin(x)**2 + 1)**2*cos(3*x)**3, x) == [
+        -1, pi/6, pi/2,
+           - I*log(1 + sqrt(2)),      I*log(1 + sqrt(2)),
+        pi - I*log(1 + sqrt(2)), pi + I*log(1 + sqrt(2)),
+    ]
+
+
+@XFAIL
+def test_M13():
+    n = Dummy('n')
+    assert solveset_real(sin(x) - cos(x), x) == ImageSet(Lambda(n, n*pi - pi*R(7, 4)), S.Integers)
+
+
+@XFAIL
+def test_M14():
+    n = Dummy('n')
+    assert solveset_real(tan(x) - 1, x) == ImageSet(Lambda(n, n*pi + pi/4), S.Integers)
+
+
+def test_M15():
+    n = Dummy('n')
+    got = solveset(sin(x) - S.Half)
+    assert any(got.dummy_eq(i) for i in (
+        Union(ImageSet(Lambda(n, 2*n*pi + pi/6), S.Integers),
+        ImageSet(Lambda(n, 2*n*pi + pi*R(5, 6)), S.Integers)),
+        Union(ImageSet(Lambda(n, 2*n*pi + pi*R(5, 6)), S.Integers),
+        ImageSet(Lambda(n, 2*n*pi + pi/6), S.Integers))))
+
+
+@XFAIL
+def test_M16():
+    n = Dummy('n')
+    assert solveset(sin(x) - tan(x), x) == ImageSet(Lambda(n, n*pi), S.Integers)
+
+
+@XFAIL
+def test_M17():
+    assert solveset_real(asin(x) - atan(x), x) == FiniteSet(0)
+
+
+@XFAIL
+def test_M18():
+    assert solveset_real(acos(x) - atan(x), x) == FiniteSet(sqrt((sqrt(5) - 1)/2))
+
+
+def test_M19():
+    # TODO: Replace solve with solveset, as of now test fails for solveset
+    assert solve((x - 2)/x**R(1, 3), x) == [2]
+
+
+def test_M20():
+    assert solveset(sqrt(x**2 + 1) - x + 2, x) == EmptySet
+
+
+def test_M21():
+    assert solveset(x + sqrt(x) - 2) == FiniteSet(1)
+
+
+def test_M22():
+    assert solveset(2*sqrt(x) + 3*x**R(1, 4) - 2) == FiniteSet(R(1, 16))
+
+
+def test_M23():
+    x = symbols('x', complex=True)
+    # TODO: Replace solve with solveset, as of now test fails for solveset
+    assert solve(x - 1/sqrt(1 + x**2)) == [
+        -I*sqrt(S.Half + sqrt(5)/2), sqrt(Rational(-1, 2) + sqrt(5)/2)]
+
+
+def test_M24():
+    # TODO: Replace solve with solveset, as of now test fails for solveset
+    solution = solve(1 - binomial(m, 2)*2**k, k)
+    answer = log(2/(m*(m - 1)), 2)
+    assert solution[0].expand() == answer.expand()
+
+
+def test_M25():
+    a, b, c, d = symbols(':d', positive=True)
+    x = symbols('x')
+    # TODO: Replace solve with solveset, as of now test fails for solveset
+    assert solve(a*b**x - c*d**x, x)[0].expand() == (log(c/a)/log(b/d)).expand()
+
+
+def test_M26():
+    # TODO: Replace solve with solveset, as of now test fails for solveset
+    assert solve(sqrt(log(x)) - log(sqrt(x))) == [1, exp(4)]
+
+
+def test_M27():
+    x = symbols('x', real=True)
+    b = symbols('b', real=True)
+    # TODO: Replace solve with solveset which gives both [+/- current answer]
+    # note that there is a typo in this test in the wester.pdf; there is no
+    # real solution for the equation as it appears in wester.pdf
+    assert solve(log(acos(asin(x**R(2, 3) - b)) - 1) + 2, x
+        ) == [(b + sin(cos(exp(-2) + 1)))**R(3, 2)]
+
+
+@XFAIL
+def test_M28():
+    assert solveset_real(5*x + exp((x - 5)/2) - 8*x**3, x, assume=Q.real(x)) == [-0.784966, -0.016291, 0.802557]
+
+
+def test_M29():
+    x = symbols('x')
+    assert solveset(abs(x - 1) - 2, domain=S.Reals) == FiniteSet(-1, 3)
+
+
+def test_M30():
+    # TODO: Replace solve with solveset, as of now
+    # solveset doesn't supports assumptions
+    # assert solve(abs(2*x + 5) - abs(x - 2),x, assume=Q.real(x)) == [-1, -7]
+    assert solveset_real(abs(2*x + 5) - abs(x - 2), x) == FiniteSet(-1, -7)
+
+
+def test_M31():
+    # TODO: Replace solve with solveset, as of now
+    # solveset doesn't supports assumptions
+    # assert solve(1 - abs(x) - max(-x - 2, x - 2),x, assume=Q.real(x)) == [-3/2, 3/2]
+    assert solveset_real(1 - abs(x) - Max(-x - 2, x - 2), x) == FiniteSet(R(-3, 2), R(3, 2))
+
+
+@XFAIL
+def test_M32():
+    # TODO: Replace solve with solveset, as of now
+    # solveset doesn't supports assumptions
+    assert solveset_real(Max(2 - x**2, x)- Max(-x, (x**3)/9), x) == FiniteSet(-1, 3)
+
+
+@XFAIL
+def test_M33():
+    # TODO: Replace solve with solveset, as of now
+    # solveset doesn't supports assumptions
+
+    # Second answer can be written in another form. The second answer is the root of x**3 + 9*x**2 - 18 = 0 in the interval (-2, -1).
+    assert solveset_real(Max(2 - x**2, x) - x**3/9, x) == FiniteSet(-3, -1.554894, 3)
+
+
+@XFAIL
+def test_M34():
+    z = symbols('z', complex=True)
+    assert solveset((1 + I) * z + (2 - I) * conjugate(z) + 3*I, z) == FiniteSet(2 + 3*I)
+
+
+def test_M35():
+    x, y = symbols('x y', real=True)
+    assert linsolve((3*x - 2*y - I*y + 3*I).as_real_imag(), y, x) == FiniteSet((3, 2))
+
+
+def test_M36():
+    # TODO: Replace solve with solveset, as of now
+    # solveset doesn't supports solving for function
+    # assert solve(f**2 + f - 2, x) == [Eq(f(x), 1), Eq(f(x), -2)]
+    assert solveset(f(x)**2 + f(x) - 2, f(x)) == FiniteSet(-2, 1)
+
+
+def test_M37():
+    assert linsolve([x + y + z - 6, 2*x + y + 2*z - 10, x + 3*y + z - 10 ], x, y, z) == \
+        FiniteSet((-z + 4, 2, z))
+
+
+def test_M38():
+    a, b, c = symbols('a, b, c')
+    domain = FracField([a, b, c], ZZ).to_domain()
+    ring = PolyRing('k1:50', domain)
+    (k1, k2, k3, k4, k5, k6, k7, k8, k9, k10,
+    k11, k12, k13, k14, k15, k16, k17, k18, k19, k20,
+    k21, k22, k23, k24, k25, k26, k27, k28, k29, k30,
+    k31, k32, k33, k34, k35, k36, k37, k38, k39, k40,
+    k41, k42, k43, k44, k45, k46, k47, k48, k49) = ring.gens
+
+    system = [
+        -b*k8/a + c*k8/a, -b*k11/a + c*k11/a, -b*k10/a + c*k10/a + k2, -k3 - b*k9/a + c*k9/a,
+        -b*k14/a + c*k14/a, -b*k15/a + c*k15/a, -b*k18/a + c*k18/a - k2, -b*k17/a + c*k17/a,
+        -b*k16/a + c*k16/a + k4, -b*k13/a + c*k13/a - b*k21/a + c*k21/a + b*k5/a - c*k5/a,
+        b*k44/a - c*k44/a, -b*k45/a + c*k45/a, -b*k20/a + c*k20/a, -b*k44/a + c*k44/a,
+        b*k46/a - c*k46/a, b**2*k47/a**2 - 2*b*c*k47/a**2 + c**2*k47/a**2, k3, -k4,
+        -b*k12/a + c*k12/a - a*k6/b + c*k6/b, -b*k19/a + c*k19/a + a*k7/c - b*k7/c,
+        b*k45/a - c*k45/a, -b*k46/a + c*k46/a, -k48 + c*k48/a + c*k48/b - c**2*k48/(a*b),
+        -k49 + b*k49/a + b*k49/c - b**2*k49/(a*c), a*k1/b - c*k1/b, a*k4/b - c*k4/b,
+        a*k3/b - c*k3/b + k9, -k10 + a*k2/b - c*k2/b, a*k7/b - c*k7/b, -k9, k11,
+        b*k12/a - c*k12/a + a*k6/b - c*k6/b, a*k15/b - c*k15/b, k10 + a*k18/b - c*k18/b,
+        -k11 + a*k17/b - c*k17/b, a*k16/b - c*k16/b, -a*k13/b + c*k13/b + a*k21/b - c*k21/b + a*k5/b - c*k5/b,
+        -a*k44/b + c*k44/b, a*k45/b - c*k45/b, a*k14/c - b*k14/c + a*k20/b - c*k20/b,
+        a*k44/b - c*k44/b, -a*k46/b + c*k46/b, -k47 + c*k47/a + c*k47/b - c**2*k47/(a*b),
+        a*k19/b - c*k19/b, -a*k45/b + c*k45/b, a*k46/b - c*k46/b, a**2*k48/b**2 - 2*a*c*k48/b**2 + c**2*k48/b**2,
+        -k49 + a*k49/b + a*k49/c - a**2*k49/(b*c), k16, -k17, -a*k1/c + b*k1/c,
+        -k16 - a*k4/c + b*k4/c, -a*k3/c + b*k3/c, k18 - a*k2/c + b*k2/c, b*k19/a - c*k19/a - a*k7/c + b*k7/c,
+        -a*k6/c + b*k6/c, -a*k8/c + b*k8/c, -a*k11/c + b*k11/c + k17, -a*k10/c + b*k10/c - k18,
+        -a*k9/c + b*k9/c, -a*k14/c + b*k14/c - a*k20/b + c*k20/b, -a*k13/c + b*k13/c + a*k21/c - b*k21/c - a*k5/c + b*k5/c,
+        a*k44/c - b*k44/c, -a*k45/c + b*k45/c, -a*k44/c + b*k44/c, a*k46/c - b*k46/c,
+        -k47 + b*k47/a + b*k47/c - b**2*k47/(a*c), -a*k12/c + b*k12/c, a*k45/c - b*k45/c,
+        -a*k46/c + b*k46/c, -k48 + a*k48/b + a*k48/c - a**2*k48/(b*c),
+        a**2*k49/c**2 - 2*a*b*k49/c**2 + b**2*k49/c**2, k8, k11, -k15, k10 - k18,
+        -k17, k9, -k16, -k29, k14 - k32, -k21 + k23 - k31, -k24 - k30, -k35, k44,
+        -k45, k36, k13 - k23 + k39, -k20 + k38, k25 + k37, b*k26/a - c*k26/a - k34 + k42,
+        -2*k44, k45, k46, b*k47/a - c*k47/a, k41, k44, -k46, -b*k47/a + c*k47/a,
+        k12 + k24, -k19 - k25, -a*k27/b + c*k27/b - k33, k45, -k46, -a*k48/b + c*k48/b,
+        a*k28/c - b*k28/c + k40, -k45, k46, a*k48/b - c*k48/b, a*k49/c - b*k49/c,
+        -a*k49/c + b*k49/c, -k1, -k4, -k3, k15, k18 - k2, k17, k16, k22, k25 - k7,
+        k24 + k30, k21 + k23 - k31, k28, -k44, k45, -k30 - k6, k20 + k32, k27 + b*k33/a - c*k33/a,
+        k44, -k46, -b*k47/a + c*k47/a, -k36, k31 - k39 - k5, -k32 - k38, k19 - k37,
+        k26 - a*k34/b + c*k34/b - k42, k44, -2*k45, k46, a*k48/b - c*k48/b,
+        a*k35/c - b*k35/c - k41, -k44, k46, b*k47/a - c*k47/a, -a*k49/c + b*k49/c,
+        -k40, k45, -k46, -a*k48/b + c*k48/b, a*k49/c - b*k49/c, k1, k4, k3, -k8,
+        -k11, -k10 + k2, -k9, k37 + k7, -k14 - k38, -k22, -k25 - k37, -k24 + k6,
+        -k13 - k23 + k39, -k28 + b*k40/a - c*k40/a, k44, -k45, -k27, -k44, k46,
+        b*k47/a - c*k47/a, k29, k32 + k38, k31 - k39 + k5, -k12 + k30, k35 - a*k41/b + c*k41/b,
+        -k44, k45, -k26 + k34 + a*k42/c - b*k42/c, k44, k45, -2*k46, -b*k47/a + c*k47/a,
+        -a*k48/b + c*k48/b, a*k49/c - b*k49/c, k33, -k45, k46, a*k48/b - c*k48/b,
+        -a*k49/c + b*k49/c
+        ]
+    solution = {
+        k49: 0, k48: 0, k47: 0, k46: 0, k45: 0, k44: 0, k41: 0, k40: 0,
+        k38: 0, k37: 0, k36: 0, k35: 0, k33: 0, k32: 0, k30: 0, k29: 0,
+        k28: 0, k27: 0, k25: 0, k24: 0, k22: 0, k21: 0, k20: 0, k19: 0,
+        k18: 0, k17: 0, k16: 0, k15: 0, k14: 0, k13: 0, k12: 0, k11: 0,
+        k10: 0, k9:  0, k8:  0, k7:  0, k6:  0, k5:  0, k4:  0, k3:  0,
+        k2:  0, k1:  0,
+        k34: b/c*k42, k31: k39, k26: a/c*k42, k23: k39
+    }
+    assert solve_lin_sys(system, ring) == solution
+
+
+def test_M39():
+    x, y, z = symbols('x y z', complex=True)
+    # TODO: Replace solve with solveset, as of now
+    # solveset doesn't supports non-linear multivariate
+    assert solve([x**2*y + 3*y*z - 4, -3*x**2*z + 2*y**2 + 1, 2*y*z**2 - z**2 - 1 ]) ==\
+            [{y: 1, z: 1, x: -1}, {y: 1, z: 1, x: 1},\
+             {y: sqrt(2)*I, z: R(1,3) - sqrt(2)*I/3, x: -sqrt(-1 - sqrt(2)*I)},\
+             {y: sqrt(2)*I, z: R(1,3) - sqrt(2)*I/3, x: sqrt(-1 - sqrt(2)*I)},\
+             {y: -sqrt(2)*I, z: R(1,3) + sqrt(2)*I/3, x: -sqrt(-1 + sqrt(2)*I)},\
+             {y: -sqrt(2)*I, z: R(1,3) + sqrt(2)*I/3, x: sqrt(-1 + sqrt(2)*I)}]
+
+# N. Inequalities
+
+
+def test_N1():
+    assert ask(E**pi > pi**E)
+
+
+@XFAIL
+def test_N2():
+    x = symbols('x', real=True)
+    assert ask(x**4 - x + 1 > 0) is True
+    assert ask(x**4 - x + 1 > 1) is False
+
+
+@XFAIL
+def test_N3():
+    x = symbols('x', real=True)
+    assert ask(And(Lt(-1, x), Lt(x, 1)), abs(x) < 1 )
+
+@XFAIL
+def test_N4():
+    x, y = symbols('x y', real=True)
+    assert ask(2*x**2 > 2*y**2, (x > y) & (y > 0)) is True
+
+
+@XFAIL
+def test_N5():
+    x, y, k = symbols('x y k', real=True)
+    assert ask(k*x**2 > k*y**2, (x > y) & (y > 0) & (k > 0)) is True
+
+
+@slow
+@XFAIL
+def test_N6():
+    x, y, k, n = symbols('x y k n', real=True)
+    assert ask(k*x**n > k*y**n, (x > y) & (y > 0) & (k > 0) & (n > 0)) is True
+
+
+@XFAIL
+def test_N7():
+    x, y = symbols('x y', real=True)
+    assert ask(y > 0, (x > 1) & (y >= x - 1)) is True
+
+
+@XFAIL
+@slow
+def test_N8():
+    x, y, z = symbols('x y z', real=True)
+    assert ask(Eq(x, y) & Eq(y, z),
+               (x >= y) & (y >= z) & (z >= x))
+
+
+def test_N9():
+    x = Symbol('x')
+    assert solveset(abs(x - 1) > 2, domain=S.Reals) == Union(Interval(-oo, -1, False, True),
+                                             Interval(3, oo, True))
+
+
+def test_N10():
+    x = Symbol('x')
+    p = (x - 1)*(x - 2)*(x - 3)*(x - 4)*(x - 5)
+    assert solveset(expand(p) < 0, domain=S.Reals) == Union(Interval(-oo, 1, True, True),
+                                            Interval(2, 3, True, True),
+                                            Interval(4, 5, True, True))
+
+
+def test_N11():
+    x = Symbol('x')
+    assert solveset(6/(x - 3) <= 3, domain=S.Reals) == Union(Interval(-oo, 3, True, True), Interval(5, oo))
+
+
+def test_N12():
+    x = Symbol('x')
+    assert solveset(sqrt(x) < 2, domain=S.Reals) == Interval(0, 4, False, True)
+
+
+def test_N13():
+    x = Symbol('x')
+    assert solveset(sin(x) < 2, domain=S.Reals) == S.Reals
+
+
+@XFAIL
+def test_N14():
+    x = Symbol('x')
+    # Gives 'Union(Interval(Integer(0), Mul(Rational(1, 2), pi), false, true),
+    #        Interval(Mul(Rational(1, 2), pi), Mul(Integer(2), pi), true, false))'
+    # which is not the correct answer, but the provided also seems wrong.
+    assert solveset(sin(x) < 1, x, domain=S.Reals) == Union(Interval(-oo, pi/2, True, True),
+                                         Interval(pi/2, oo, True, True))
+
+
+def test_N15():
+    r, t = symbols('r t')
+    # raises NotImplementedError: only univariate inequalities are supported
+    solveset(abs(2*r*(cos(t) - 1) + 1) <= 1, r, S.Reals)
+
+
+def test_N16():
+    r, t = symbols('r t')
+    solveset((r**2)*((cos(t) - 4)**2)*sin(t)**2 < 9, r, S.Reals)
+
+
+@XFAIL
+def test_N17():
+    # currently only univariate inequalities are supported
+    assert solveset((x + y > 0, x - y < 0), (x, y)) == (abs(x) < y)
+
+
+def test_O1():
+    M = Matrix((1 + I, -2, 3*I))
+    assert sqrt(expand(M.dot(M.H))) == sqrt(15)
+
+
+def test_O2():
+    assert Matrix((2, 2, -3)).cross(Matrix((1, 3, 1))) == Matrix([[11],
+                                                                  [-5],
+                                                                  [4]])
+
+# The vector module has no way of representing vectors symbolically (without
+# respect to a basis)
+@XFAIL
+def test_O3():
+    # assert (va ^ vb) | (vc ^ vd) == -(va | vc)*(vb | vd) + (va | vd)*(vb | vc)
+    raise NotImplementedError("""The vector module has no way of representing
+        vectors symbolically (without respect to a basis)""")
+
+def test_O4():
+    from sympy.vector import CoordSys3D, Del
+    N = CoordSys3D("N")
+    delop = Del()
+    i, j, k = N.base_vectors()
+    x, y, z = N.base_scalars()
+    F = i*(x*y*z) + j*((x*y*z)**2) + k*((y**2)*(z**3))
+    assert delop.cross(F).doit() == (-2*x**2*y**2*z + 2*y*z**3)*i + x*y*j + (2*x*y**2*z**2 - x*z)*k
+
+@XFAIL
+def test_O5():
+    #assert grad|(f^g)-g|(grad^f)+f|(grad^g)  == 0
+    raise NotImplementedError("""The vector module has no way of representing
+        vectors symbolically (without respect to a basis)""")
+
+#testO8-O9 MISSING!!
+
+
+def test_O10():
+    L = [Matrix([2, 3, 5]), Matrix([3, 6, 2]), Matrix([8, 3, 6])]
+    assert GramSchmidt(L) == [Matrix([
+                              [2],
+                              [3],
+                              [5]]),
+                              Matrix([
+                              [R(23, 19)],
+                              [R(63, 19)],
+                              [R(-47, 19)]]),
+                              Matrix([
+                              [R(1692, 353)],
+                              [R(-1551, 706)],
+                              [R(-423, 706)]])]
+
+
+def test_P1():
+    assert Matrix(3, 3, lambda i, j: j - i).diagonal(-1) == Matrix(
+        1, 2, [-1, -1])
+
+
+def test_P2():
+    M = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    M.row_del(1)
+    M.col_del(2)
+    assert M == Matrix([[1, 2],
+                        [7, 8]])
+
+
+def test_P3():
+    A = Matrix([
+        [11, 12, 13, 14],
+        [21, 22, 23, 24],
+        [31, 32, 33, 34],
+        [41, 42, 43, 44]])
+
+    A11 = A[0:3, 1:4]
+    A12 = A[(0, 1, 3), (2, 0, 3)]
+    A21 = A
+    A221 = -A[0:2, 2:4]
+    A222 = -A[(3, 0), (2, 1)]
+    A22 = BlockMatrix([[A221, A222]]).T
+    rows = [[-A11, A12], [A21, A22]]
+    raises(ValueError, lambda: BlockMatrix(rows))
+    B = Matrix(rows)
+    assert B == Matrix([
+        [-12, -13, -14, 13, 11, 14],
+        [-22, -23, -24, 23, 21, 24],
+        [-32, -33, -34, 43, 41, 44],
+        [11, 12, 13, 14, -13, -23],
+        [21, 22, 23, 24, -14, -24],
+        [31, 32, 33, 34, -43, -13],
+        [41, 42, 43, 44, -42, -12]])
+
+
+@XFAIL
+def test_P4():
+    raise NotImplementedError("Block matrix diagonalization not supported")
+
+
+def test_P5():
+    M = Matrix([[7, 11],
+                [3, 8]])
+    assert  M % 2 == Matrix([[1, 1],
+                             [1, 0]])
+
+
+def test_P6():
+    M = Matrix([[cos(x), sin(x)],
+                [-sin(x), cos(x)]])
+    assert M.diff(x, 2) == Matrix([[-cos(x), -sin(x)],
+                                   [sin(x), -cos(x)]])
+
+
+def test_P7():
+    M = Matrix([[x, y]])*(
+        z*Matrix([[1, 3, 5],
+                  [2, 4, 6]]) + Matrix([[7, -9, 11],
+                                        [-8, 10, -12]]))
+    assert M == Matrix([[x*(z + 7) + y*(2*z - 8), x*(3*z - 9) + y*(4*z + 10),
+                         x*(5*z + 11) + y*(6*z - 12)]])
+
+
+def test_P8():
+    M = Matrix([[1, -2*I],
+                [-3*I, 4]])
+    assert M.norm(ord=S.Infinity) == 7
+
+
+def test_P9():
+    a, b, c = symbols('a b c', nonzero=True)
+    M = Matrix([[a/(b*c), 1/c, 1/b],
+                [1/c, b/(a*c), 1/a],
+                [1/b, 1/a, c/(a*b)]])
+    assert factor(M.norm('fro')) == (a**2 + b**2 + c**2)/(abs(a)*abs(b)*abs(c))
+
+
+@XFAIL
+def test_P10():
+    M = Matrix([[1, 2 + 3*I],
+                [f(4 - 5*I), 6]])
+    # conjugate(f(4 - 5*i)) is not simplified to f(4+5*I)
+    assert M.H == Matrix([[1, f(4 + 5*I)],
+                          [2 + 3*I, 6]])
+
+
+@XFAIL
+def test_P11():
+    # raises NotImplementedError("Matrix([[x,y],[1,x*y]]).inv()
+    #   not simplifying to extract common factor")
+    assert Matrix([[x, y],
+                   [1, x*y]]).inv() == (1/(x**2 - 1))*Matrix([[x, -1],
+                                                              [-1/y, x/y]])
+
+
+def test_P11_workaround():
+    # This test was changed to inverse method ADJ because it depended on the
+    # specific form of inverse returned from the 'GE' method which has changed.
+    M = Matrix([[x, y], [1, x*y]]).inv('ADJ')
+    c = gcd(tuple(M))
+    assert MatMul(c, M/c, evaluate=False) == MatMul(c, Matrix([
+        [x*y, -y],
+        [ -1,  x]]), evaluate=False)
+
+
+def test_P12():
+    A11 = MatrixSymbol('A11', n, n)
+    A12 = MatrixSymbol('A12', n, n)
+    A22 = MatrixSymbol('A22', n, n)
+    B = BlockMatrix([[A11, A12],
+                     [ZeroMatrix(n, n), A22]])
+    assert block_collapse(B.I) == BlockMatrix([[A11.I, (-1)*A11.I*A12*A22.I],
+                                               [ZeroMatrix(n, n), A22.I]])
+
+
+def test_P13():
+    M = Matrix([[1,     x - 2,                         x - 3],
+                [x - 1, x**2 - 3*x + 6,       x**2 - 3*x - 2],
+                [x - 2, x**2 - 8,       2*(x**2) - 12*x + 14]])
+    L, U, _ = M.LUdecomposition()
+    assert simplify(L) == Matrix([[1,     0,     0],
+                                  [x - 1, 1,     0],
+                                  [x - 2, x - 3, 1]])
+    assert simplify(U) == Matrix([[1, x - 2, x - 3],
+                                  [0,     4, x - 5],
+                                  [0,     0, x - 7]])
+
+
+def test_P14():
+    M = Matrix([[1, 2, 3, 1, 3],
+                [3, 2, 1, 1, 7],
+                [0, 2, 4, 1, 1],
+                [1, 1, 1, 1, 4]])
+    R, _ = M.rref()
+    assert R == Matrix([[1, 0, -1, 0,  2],
+                        [0, 1,  2, 0, -1],
+                        [0, 0,  0, 1,  3],
+                        [0, 0,  0, 0,  0]])
+
+
+def test_P15():
+    M = Matrix([[-1, 3,  7, -5],
+                [4, -2,  1,  3],
+                [2,  4, 15, -7]])
+    assert M.rank() == 2
+
+
+def test_P16():
+    M = Matrix([[2*sqrt(2), 8],
+                [6*sqrt(6), 24*sqrt(3)]])
+    assert M.rank() == 1
+
+
+def test_P17():
+    t = symbols('t', real=True)
+    M=Matrix([
+        [sin(2*t), cos(2*t)],
+        [2*(1 - (cos(t)**2))*cos(t), (1 - 2*(sin(t)**2))*sin(t)]])
+    assert M.rank() == 1
+
+
+def test_P18():
+    M = Matrix([[1,  0, -2, 0],
+                [-2, 1,  0, 3],
+                [-1, 2, -6, 6]])
+    assert M.nullspace() == [Matrix([[2],
+                                     [4],
+                                     [1],
+                                     [0]]),
+                             Matrix([[0],
+                                     [-3],
+                                     [0],
+                                     [1]])]
+
+
+def test_P19():
+    w = symbols('w')
+    M = Matrix([[1,    1,    1,    1],
+                [w,    x,    y,    z],
+                [w**2, x**2, y**2, z**2],
+                [w**3, x**3, y**3, z**3]])
+    assert M.det() == (w**3*x**2*y   - w**3*x**2*z - w**3*x*y**2 + w**3*x*z**2
+                       + w**3*y**2*z - w**3*y*z**2 - w**2*x**3*y + w**2*x**3*z
+                       + w**2*x*y**3 - w**2*x*z**3 - w**2*y**3*z + w**2*y*z**3
+                       + w*x**3*y**2 - w*x**3*z**2 - w*x**2*y**3 + w*x**2*z**3
+                       + w*y**3*z**2 - w*y**2*z**3 - x**3*y**2*z + x**3*y*z**2
+                       + x**2*y**3*z - x**2*y*z**3 - x*y**3*z**2 + x*y**2*z**3
+                       )
+
+
+@XFAIL
+def test_P20():
+    raise NotImplementedError("Matrix minimal polynomial not supported")
+
+
+def test_P21():
+    M = Matrix([[5, -3, -7],
+                [-2, 1,  2],
+                [2, -3, -4]])
+    assert M.charpoly(x).as_expr() == x**3 - 2*x**2 - 5*x + 6
+
+
+def test_P22():
+    d = 100
+    M = (2 - x)*eye(d)
+    assert M.eigenvals() == {-x + 2: d}
+
+
+def test_P23():
+    M = Matrix([
+        [2, 1, 0, 0, 0],
+        [1, 2, 1, 0, 0],
+        [0, 1, 2, 1, 0],
+        [0, 0, 1, 2, 1],
+        [0, 0, 0, 1, 2]])
+    assert M.eigenvals() == {
+        S('1'): 1,
+        S('2'): 1,
+        S('3'): 1,
+        S('sqrt(3) + 2'): 1,
+        S('-sqrt(3) + 2'): 1}
+
+
+def test_P24():
+    M = Matrix([[611,  196, -192,  407,   -8,  -52,  -49,   29],
+                [196,  899,  113, -192,  -71,  -43,   -8,  -44],
+                [-192,  113,  899,  196,   61,   49,    8,   52],
+                [ 407, -192,  196,  611,    8,   44,   59,  -23],
+                [  -8,  -71,   61,    8,  411, -599,  208,  208],
+                [ -52,  -43,   49,   44, -599,  411,  208,  208],
+                [ -49,   -8,    8,   59,  208,  208,   99, -911],
+                [  29,  -44,   52,  -23,  208,  208, -911,   99]])
+    assert M.eigenvals() == {
+        S('0'): 1,
+        S('10*sqrt(10405)'): 1,
+        S('100*sqrt(26) + 510'): 1,
+        S('1000'): 2,
+        S('-100*sqrt(26) + 510'): 1,
+        S('-10*sqrt(10405)'): 1,
+        S('1020'): 1}
+
+
+def test_P25():
+    MF = N(Matrix([[ 611,  196, -192,  407,   -8,  -52,  -49,   29],
+                   [ 196,  899,  113, -192,  -71,  -43,   -8,  -44],
+                   [-192,  113,  899,  196,   61,   49,    8,   52],
+                   [ 407, -192,  196,  611,    8,   44,   59,  -23],
+                   [  -8,  -71,   61,    8,  411, -599,  208,  208],
+                   [ -52,  -43,   49,   44, -599,  411,  208,  208],
+                   [ -49,   -8,    8,   59,  208,  208,   99, -911],
+                   [  29,  -44,   52,  -23,  208,  208, -911,   99]]))
+
+    ev_1 = sorted(MF.eigenvals(multiple=True))
+    ev_2 = sorted(
+        [-1020.0490184299969, 0.0, 0.09804864072151699, 1000.0, 1000.0,
+        1019.9019513592784, 1020.0, 1020.0490184299969])
+
+    for x, y in zip(ev_1, ev_2):
+        assert abs(x - y) < 1e-12
+
+
+def test_P26():
+    a0, a1, a2, a3, a4 = symbols('a0 a1 a2 a3 a4')
+    M = Matrix([[-a4, -a3, -a2, -a1, -a0,  0,  0,  0,  0],
+                [  1,   0,   0,   0,   0,  0,  0,  0,  0],
+                [  0,   1,   0,   0,   0,  0,  0,  0,  0],
+                [  0,   0,   1,   0,   0,  0,  0,  0,  0],
+                [  0,   0,   0,   1,   0,  0,  0,  0,  0],
+                [  0,   0,   0,   0,   0, -1, -1,  0,  0],
+                [  0,   0,   0,   0,   0,  1,  0,  0,  0],
+                [  0,   0,   0,   0,   0,  0,  1, -1, -1],
+                [  0,   0,   0,   0,   0,  0,  0,  1,  0]])
+    assert M.eigenvals(error_when_incomplete=False) == {
+        S('-1/2 - sqrt(3)*I/2'): 2,
+        S('-1/2 + sqrt(3)*I/2'): 2}
+
+
+def test_P27():
+    a = symbols('a')
+    M = Matrix([[a,  0, 0, 0, 0],
+                [0,  0, 0, 0, 1],
+                [0,  0, a, 0, 0],
+                [0,  0, 0, a, 0],
+                [0, -2, 0, 0, 2]])
+
+    assert M.eigenvects() == [
+        (a, 3, [
+            Matrix([1, 0, 0, 0, 0]),
+            Matrix([0, 0, 1, 0, 0]),
+            Matrix([0, 0, 0, 1, 0])
+        ]),
+        (1 - I, 1, [
+            Matrix([0, (1 + I)/2, 0, 0, 1])
+        ]),
+        (1 + I, 1, [
+            Matrix([0, (1 - I)/2, 0, 0, 1])
+        ]),
+    ]
+
+
+@XFAIL
+def test_P28():
+    raise NotImplementedError("Generalized eigenvectors not supported \
+https://github.com/sympy/sympy/issues/5293")
+
+
+@XFAIL
+def test_P29():
+    raise NotImplementedError("Generalized eigenvectors not supported \
+https://github.com/sympy/sympy/issues/5293")
+
+
+def test_P30():
+    M = Matrix([[1,  0,  0,  1, -1],
+                [0,  1, -2,  3, -3],
+                [0,  0, -1,  2, -2],
+                [1, -1,  1,  0,  1],
+                [1, -1,  1, -1,  2]])
+    _, J = M.jordan_form()
+    assert J == Matrix([[-1, 0, 0, 0, 0],
+                        [0,  1, 1, 0, 0],
+                        [0,  0, 1, 0, 0],
+                        [0,  0, 0, 1, 1],
+                        [0,  0, 0, 0, 1]])
+
+
+@XFAIL
+def test_P31():
+    raise NotImplementedError("Smith normal form not implemented")
+
+
+def test_P32():
+    M = Matrix([[1, -2],
+                [2, 1]])
+    assert exp(M).rewrite(cos).simplify() == Matrix([[E*cos(2), -E*sin(2)],
+                                                     [E*sin(2),  E*cos(2)]])
+
+
+def test_P33():
+    w, t = symbols('w t')
+    M = Matrix([[0,    1,      0,   0],
+                [0,    0,      0, 2*w],
+                [0,    0,      0,   1],
+                [0, -2*w, 3*w**2,   0]])
+    assert exp(M*t).rewrite(cos).expand() == Matrix([
+        [1, -3*t + 4*sin(t*w)/w,  6*t*w - 6*sin(t*w), -2*cos(t*w)/w + 2/w],
+        [0,      4*cos(t*w) - 3, -6*w*cos(t*w) + 6*w,          2*sin(t*w)],
+        [0,  2*cos(t*w)/w - 2/w,     -3*cos(t*w) + 4,          sin(t*w)/w],
+        [0,         -2*sin(t*w),        3*w*sin(t*w),            cos(t*w)]])
+
+
+@XFAIL
+def test_P34():
+    a, b, c = symbols('a b c', real=True)
+    M = Matrix([[a, 1, 0, 0, 0, 0],
+                [0, a, 0, 0, 0, 0],
+                [0, 0, b, 0, 0, 0],
+                [0, 0, 0, c, 1, 0],
+                [0, 0, 0, 0, c, 1],
+                [0, 0, 0, 0, 0, c]])
+    # raises exception, sin(M) not supported. exp(M*I) also not supported
+    # https://github.com/sympy/sympy/issues/6218
+    assert sin(M) == Matrix([[sin(a), cos(a), 0, 0, 0, 0],
+                             [0, sin(a), 0, 0, 0, 0],
+                             [0, 0, sin(b), 0, 0, 0],
+                             [0, 0, 0, sin(c), cos(c), -sin(c)/2],
+                             [0, 0, 0, 0, sin(c), cos(c)],
+                             [0, 0, 0, 0, 0, sin(c)]])
+
+
+@XFAIL
+def test_P35():
+    M = pi/2*Matrix([[2, 1, 1],
+                     [2, 3, 2],
+                     [1, 1, 2]])
+    # raises exception, sin(M) not supported. exp(M*I) also not supported
+    # https://github.com/sympy/sympy/issues/6218
+    assert sin(M) == eye(3)
+
+
+@XFAIL
+def test_P36():
+    M = Matrix([[10, 7],
+                [7, 17]])
+    assert sqrt(M) == Matrix([[3, 1],
+                              [1, 4]])
+
+
+def test_P37():
+    M = Matrix([[1, 1, 0],
+                [0, 1, 0],
+                [0, 0, 1]])
+    assert M**S.Half == Matrix([[1, R(1, 2), 0],
+                                        [0, 1,       0],
+                                        [0, 0,       1]])
+
+
+@XFAIL
+def test_P38():
+    M=Matrix([[0, 1, 0],
+              [0, 0, 0],
+              [0, 0, 0]])
+
+    with raises(AssertionError):
+        # raises ValueError: Matrix det == 0; not invertible
+        M**S.Half
+        # if it doesn't raise then this assertion will be
+        # raised and the test will be flagged as not XFAILing
+        assert None
+
+@XFAIL
+def test_P39():
+    """
+    M=Matrix([
+        [1, 1],
+        [2, 2],
+        [3, 3]])
+    M.SVD()
+    """
+    raise NotImplementedError("Singular value decomposition not implemented")
+
+
+def test_P40():
+    r, t = symbols('r t', real=True)
+    M = Matrix([r*cos(t), r*sin(t)])
+    assert M.jacobian(Matrix([r, t])) == Matrix([[cos(t), -r*sin(t)],
+                                                 [sin(t),  r*cos(t)]])
+
+
+def test_P41():
+    r, t = symbols('r t', real=True)
+    assert hessian(r**2*sin(t),(r,t)) == Matrix([[  2*sin(t),   2*r*cos(t)],
+                                                 [2*r*cos(t), -r**2*sin(t)]])
+
+
+def test_P42():
+    assert wronskian([cos(x), sin(x)], x).simplify() == 1
+
+
+def test_P43():
+    def __my_jacobian(M, Y):
+        return Matrix([M.diff(v).T for v in Y]).T
+    r, t = symbols('r t', real=True)
+    M = Matrix([r*cos(t), r*sin(t)])
+    assert __my_jacobian(M,[r,t]) == Matrix([[cos(t), -r*sin(t)],
+                                             [sin(t),  r*cos(t)]])
+
+
+def test_P44():
+    def __my_hessian(f, Y):
+        V = Matrix([diff(f, v) for v in Y])
+        return  Matrix([V.T.diff(v) for v in Y])
+    r, t = symbols('r t', real=True)
+    assert __my_hessian(r**2*sin(t), (r, t)) == Matrix([
+                                            [  2*sin(t),   2*r*cos(t)],
+                                            [2*r*cos(t), -r**2*sin(t)]])
+
+
+def test_P45():
+    def __my_wronskian(Y, v):
+        M = Matrix([Matrix(Y).T.diff(x, n) for n in range(0, len(Y))])
+        return  M.det()
+    assert __my_wronskian([cos(x), sin(x)], x).simplify() == 1
+
+# Q1-Q6  Tensor tests missing
+
+
+@XFAIL
+def test_R1():
+    i, j, n = symbols('i j n', integer=True, positive=True)
+    xn = MatrixSymbol('xn', n, 1)
+    Sm = Sum((xn[i, 0] - Sum(xn[j, 0], (j, 0, n - 1))/n)**2, (i, 0, n - 1))
+    # sum does not calculate
+    # Unknown result
+    Sm.doit()
+    raise NotImplementedError('Unknown result')
+
+@XFAIL
+def test_R2():
+    m, b = symbols('m b')
+    i, n = symbols('i n', integer=True, positive=True)
+    xn = MatrixSymbol('xn', n, 1)
+    yn = MatrixSymbol('yn', n, 1)
+    f = Sum((yn[i, 0] - m*xn[i, 0] - b)**2, (i, 0, n - 1))
+    f1 = diff(f, m)
+    f2 = diff(f, b)
+    # raises TypeError: solveset() takes at most 2 arguments (3 given)
+    solveset((f1, f2), (m, b), domain=S.Reals)
+
+
+@XFAIL
+def test_R3():
+    n, k = symbols('n k', integer=True, positive=True)
+    sk = ((-1)**k) * (binomial(2*n, k))**2
+    Sm = Sum(sk, (k, 1, oo))
+    T = Sm.doit()
+    T2 = T.combsimp()
+    # returns -((-1)**n*factorial(2*n)
+    #           - (factorial(n))**2)*exp_polar(-I*pi)/(factorial(n))**2
+    assert T2 == (-1)**n*binomial(2*n, n)
+
+
+@XFAIL
+def test_R4():
+# Macsyma indefinite sum test case:
+#(c15) /* Check whether the full Gosper algorithm is implemented
+#   => 1/2^(n + 1) binomial(n, k - 1) */
+#closedform(indefsum(binomial(n, k)/2^n - binomial(n + 1, k)/2^(n + 1), k));
+#Time= 2690 msecs
+#                      (- n + k - 1) binomial(n + 1, k)
+#(d15)               - --------------------------------
+#                                     n
+#                                   2 2  (n + 1)
+#
+#(c16) factcomb(makefact(%));
+#Time= 220 msecs
+#                                 n!
+#(d16)                     ----------------
+#                                n
+#                          2 k! 2  (n - k)!
+# Might be possible after fixing https://github.com/sympy/sympy/pull/1879
+    raise NotImplementedError("Indefinite sum not supported")
+
+
+@XFAIL
+def test_R5():
+    a, b, c, n, k = symbols('a b c n k', integer=True, positive=True)
+    sk = ((-1)**k)*(binomial(a + b, a + k)
+                    *binomial(b + c, b + k)*binomial(c + a, c + k))
+    Sm = Sum(sk, (k, 1, oo))
+    T = Sm.doit()  # hypergeometric series not calculated
+    assert T == factorial(a+b+c)/(factorial(a)*factorial(b)*factorial(c))
+
+
+def test_R6():
+    n, k = symbols('n k', integer=True, positive=True)
+    gn = MatrixSymbol('gn', n + 2, 1)
+    Sm = Sum(gn[k, 0] - gn[k - 1, 0], (k, 1, n + 1))
+    assert Sm.doit() == -gn[0, 0] + gn[n + 1, 0]
+
+
+def test_R7():
+    n, k = symbols('n k', integer=True, positive=True)
+    T = Sum(k**3,(k,1,n)).doit()
+    assert T.factor() == n**2*(n + 1)**2/4
+
+@XFAIL
+def test_R8():
+    n, k = symbols('n k', integer=True, positive=True)
+    Sm = Sum(k**2*binomial(n, k), (k, 1, n))
+    T = Sm.doit() #returns Piecewise function
+    assert T.combsimp() == n*(n + 1)*2**(n - 2)
+
+
+def test_R9():
+    n, k = symbols('n k', integer=True, positive=True)
+    Sm = Sum(binomial(n, k - 1)/k, (k, 1, n + 1))
+    assert Sm.doit().simplify() == (2**(n + 1) - 1)/(n + 1)
+
+
+@XFAIL
+def test_R10():
+    n, m, r, k = symbols('n m r k', integer=True, positive=True)
+    Sm = Sum(binomial(n, k)*binomial(m, r - k), (k, 0, r))
+    T = Sm.doit()
+    T2 = T.combsimp().rewrite(factorial)
+    assert T2 == factorial(m + n)/(factorial(r)*factorial(m + n - r))
+    assert T2 == binomial(m + n, r).rewrite(factorial)
+    # rewrite(binomial) is not working.
+    # https://github.com/sympy/sympy/issues/7135
+    T3 = T2.rewrite(binomial)
+    assert T3 == binomial(m + n, r)
+
+
+@XFAIL
+def test_R11():
+    n, k = symbols('n k', integer=True, positive=True)
+    sk = binomial(n, k)*fibonacci(k)
+    Sm = Sum(sk, (k, 0, n))
+    T = Sm.doit()
+    # Fibonacci simplification not implemented
+    # https://github.com/sympy/sympy/issues/7134
+    assert T == fibonacci(2*n)
+
+
+@XFAIL
+def test_R12():
+    n, k = symbols('n k', integer=True, positive=True)
+    Sm = Sum(fibonacci(k)**2, (k, 0, n))
+    T = Sm.doit()
+    assert T == fibonacci(n)*fibonacci(n + 1)
+
+
+@XFAIL
+def test_R13():
+    n, k = symbols('n k', integer=True, positive=True)
+    Sm = Sum(sin(k*x), (k, 1, n))
+    T = Sm.doit()  # Sum is not calculated
+    assert T.simplify() == cot(x/2)/2 - cos(x*(2*n + 1)/2)/(2*sin(x/2))
+
+
+@XFAIL
+def test_R14():
+    n, k = symbols('n k', integer=True, positive=True)
+    Sm = Sum(sin((2*k - 1)*x), (k, 1, n))
+    T = Sm.doit()  # Sum is not calculated
+    assert T.simplify() == sin(n*x)**2/sin(x)
+
+
+@XFAIL
+def test_R15():
+    n, k = symbols('n k', integer=True, positive=True)
+    Sm = Sum(binomial(n - k, k), (k, 0, floor(n/2)))
+    T = Sm.doit()  # Sum is not calculated
+    assert T.simplify() == fibonacci(n + 1)
+
+
+def test_R16():
+    k = symbols('k', integer=True, positive=True)
+    Sm = Sum(1/k**2 + 1/k**3, (k, 1, oo))
+    assert Sm.doit() == zeta(3) + pi**2/6
+
+
+def test_R17():
+    k = symbols('k', integer=True, positive=True)
+    assert abs(float(Sum(1/k**2 + 1/k**3, (k, 1, oo)))
+               - 2.8469909700078206) < 1e-15
+
+
+def test_R18():
+    k = symbols('k', integer=True, positive=True)
+    Sm = Sum(1/(2**k*k**2), (k, 1, oo))
+    T = Sm.doit()
+    assert T.simplify() == -log(2)**2/2 + pi**2/12
+
+
+@slow
+@XFAIL
+def test_R19():
+    k = symbols('k', integer=True, positive=True)
+    Sm = Sum(1/((3*k + 1)*(3*k + 2)*(3*k + 3)), (k, 0, oo))
+    T = Sm.doit()
+    # assert fails, T not  simplified
+    assert T.simplify() == -log(3)/4 + sqrt(3)*pi/12
+
+
+@XFAIL
+def test_R20():
+    n, k = symbols('n k', integer=True, positive=True)
+    Sm = Sum(binomial(n, 4*k), (k, 0, oo))
+    T = Sm.doit()
+    # assert fails, T not  simplified
+    assert T.simplify() == 2**(n/2)*cos(pi*n/4)/2 + 2**(n - 1)/2
+
+
+@XFAIL
+def test_R21():
+    k = symbols('k', integer=True, positive=True)
+    Sm = Sum(1/(sqrt(k*(k + 1)) * (sqrt(k) + sqrt(k + 1))), (k, 1, oo))
+    T = Sm.doit()  # Sum not calculated
+    assert T.simplify() == 1
+
+
+# test_R22 answer not available in Wester samples
+# Sum(Sum(binomial(n, k)*binomial(n - k, n - 2*k)*x**n*y**(n - 2*k),
+#                 (k, 0, floor(n/2))), (n, 0, oo)) with abs(x*y)<1?
+
+
+@XFAIL
+def test_R23():
+    n, k = symbols('n k', integer=True, positive=True)
+    Sm = Sum(Sum((factorial(n)/(factorial(k)**2*factorial(n - 2*k)))*
+                 (x/y)**k*(x*y)**(n - k), (n, 2*k, oo)), (k, 0, oo))
+    # Missing how to express constraint abs(x*y)<1?
+    T = Sm.doit()  # Sum not calculated
+    assert T == -1/sqrt(x**2*y**2 - 4*x**2 - 2*x*y + 1)
+
+
+def test_R24():
+    m, k = symbols('m k', integer=True, positive=True)
+    Sm = Sum(Product(k/(2*k - 1), (k, 1, m)), (m, 2, oo))
+    assert Sm.doit() == pi/2
+
+
+def test_S1():
+    k = symbols('k', integer=True, positive=True)
+    Pr = Product(gamma(k/3), (k, 1, 8))
+    assert Pr.doit().simplify() == 640*sqrt(3)*pi**3/6561
+
+
+def test_S2():
+    n, k = symbols('n k', integer=True, positive=True)
+    assert Product(k, (k, 1, n)).doit() == factorial(n)
+
+
+def test_S3():
+    n, k = symbols('n k', integer=True, positive=True)
+    assert Product(x**k, (k, 1, n)).doit().simplify() == x**(n*(n + 1)/2)
+
+
+def test_S4():
+    n, k = symbols('n k', integer=True, positive=True)
+    assert Product(1 + 1/k, (k, 1, n -1)).doit().simplify() == n
+
+
+def test_S5():
+    n, k = symbols('n k', integer=True, positive=True)
+    assert (Product((2*k - 1)/(2*k), (k, 1, n)).doit().gammasimp() ==
+            gamma(n + S.Half)/(sqrt(pi)*gamma(n + 1)))
+
+
+@XFAIL
+def test_S6():
+    n, k = symbols('n k', integer=True, positive=True)
+    # Product does not evaluate
+    assert (Product(x**2 -2*x*cos(k*pi/n) + 1, (k, 1, n - 1)).doit().simplify()
+            == (x**(2*n) - 1)/(x**2 - 1))
+
+
+@XFAIL
+def test_S7():
+    k = symbols('k', integer=True, positive=True)
+    Pr = Product((k**3 - 1)/(k**3 + 1), (k, 2, oo))
+    T = Pr.doit()     # Product does not evaluate
+    assert T.simplify() == R(2, 3)
+
+
+@XFAIL
+def test_S8():
+    k = symbols('k', integer=True, positive=True)
+    Pr = Product(1 - 1/(2*k)**2, (k, 1, oo))
+    T = Pr.doit()
+    # Product does not evaluate
+    assert T.simplify() == 2/pi
+
+
+@XFAIL
+def test_S9():
+    k = symbols('k', integer=True, positive=True)
+    Pr = Product(1 + (-1)**(k + 1)/(2*k - 1), (k, 1, oo))
+    T = Pr.doit()
+    # Product produces 0
+    # https://github.com/sympy/sympy/issues/7133
+    assert T.simplify() == sqrt(2)
+
+
+@XFAIL
+def test_S10():
+    k = symbols('k', integer=True, positive=True)
+    Pr = Product((k*(k + 1) + 1 + I)/(k*(k + 1) + 1 - I), (k, 0, oo))
+    T = Pr.doit()
+    # Product does not evaluate
+    assert T.simplify() == -1
+
+
+def test_T1():
+    assert limit((1 + 1/n)**n, n, oo) == E
+    assert limit((1 - cos(x))/x**2, x, 0) == S.Half
+
+
+def test_T2():
+    assert limit((3**x + 5**x)**(1/x), x, oo) == 5
+
+
+def test_T3():
+    assert limit(log(x)/(log(x) + sin(x)), x, oo) == 1
+
+
+def test_T4():
+    assert limit((exp(x*exp(-x)/(exp(-x) + exp(-2*x**2/(x + 1))))
+                 - exp(x))/x, x, oo) == -exp(2)
+
+
+def test_T5():
+    assert  limit(x*log(x)*log(x*exp(x) - x**2)**2/log(log(x**2
+                  + 2*exp(exp(3*x**3*log(x))))), x, oo) == R(1, 3)
+
+
+def test_T6():
+    assert limit(1/n * factorial(n)**(1/n), n, oo) == exp(-1)
+
+
+def test_T7():
+    limit(1/n * gamma(n + 1)**(1/n), n, oo)
+
+
+def test_T8():
+    a, z = symbols('a z', positive=True)
+    assert limit(gamma(z + a)/gamma(z)*exp(-a*log(z)), z, oo) == 1
+
+
+@XFAIL
+def test_T9():
+    z, k = symbols('z k', positive=True)
+    # raises NotImplementedError:
+    #           Don't know how to calculate the mrv of '(1, k)'
+    assert limit(hyper((1, k), (1,), z/k), k, oo) == exp(z)
+
+
+@XFAIL
+def test_T10():
+    # No longer raises PoleError, but should return euler-mascheroni constant
+    assert limit(zeta(x) - 1/(x - 1), x, 1) == integrate(-1/x + 1/floor(x), (x, 1, oo))
+
+@XFAIL
+def test_T11():
+    n, k = symbols('n k', integer=True, positive=True)
+    # evaluates to 0
+    assert limit(n**x/(x*product((1 + x/k), (k, 1, n))), n, oo) == gamma(x)
+
+
+def test_T12():
+    x, t = symbols('x t', real=True)
+    # Does not evaluate the limit but returns an expression with erf
+    assert limit(x * integrate(exp(-t**2), (t, 0, x))/(1 - exp(-x**2)),
+                 x, 0) == 1
+
+
+def test_T13():
+    x = symbols('x', real=True)
+    assert [limit(x/abs(x), x, 0, dir='-'),
+            limit(x/abs(x), x, 0, dir='+')] == [-1, 1]
+
+
+def test_T14():
+    x = symbols('x', real=True)
+    assert limit(atan(-log(x)), x, 0, dir='+') == pi/2
+
+
+def test_U1():
+    x = symbols('x', real=True)
+    assert diff(abs(x), x) == sign(x)
+
+
+def test_U2():
+    f = Lambda(x, Piecewise((-x, x < 0), (x, x >= 0)))
+    assert diff(f(x), x) == Piecewise((-1, x < 0), (1, x >= 0))
+
+
+def test_U3():
+    f = Lambda(x, Piecewise((x**2 - 1, x == 1), (x**3, x != 1)))
+    f1 = Lambda(x, diff(f(x), x))
+    assert f1(x) == 3*x**2
+    assert f1(1) == 3
+
+
+@XFAIL
+def test_U4():
+    n = symbols('n', integer=True, positive=True)
+    x = symbols('x', real=True)
+    d = diff(x**n, x, n)
+    assert d.rewrite(factorial) == factorial(n)
+
+
+def test_U5():
+    # issue 6681
+    t = symbols('t')
+    ans = (
+        Derivative(f(g(t)), g(t))*Derivative(g(t), (t, 2)) +
+        Derivative(f(g(t)), (g(t), 2))*Derivative(g(t), t)**2)
+    assert f(g(t)).diff(t, 2) == ans
+    assert ans.doit() == ans
+
+
+def test_U6():
+    h = Function('h')
+    T = integrate(f(y), (y, h(x), g(x)))
+    assert T.diff(x) == (
+        f(g(x))*Derivative(g(x), x) - f(h(x))*Derivative(h(x), x))
+
+
+@XFAIL
+def test_U7():
+    p, t = symbols('p t', real=True)
+    # Exact differential => d(V(P, T)) => dV/dP DP + dV/dT DT
+    # raises ValueError:  Since there is more than one variable in the
+    # expression, the variable(s) of differentiation must be supplied to
+    # differentiate f(p,t)
+    diff(f(p, t))
+
+
+def test_U8():
+    x, y = symbols('x y', real=True)
+    eq = cos(x*y) + x
+    #  If SymPy had implicit_diff() function this hack could be avoided
+    # TODO: Replace solve with solveset, current test fails for solveset
+    assert idiff(y - eq, y, x) == (-y*sin(x*y) + 1)/(x*sin(x*y) + 1)
+
+
+def test_U9():
+    # Wester sample case for Maple:
+    # O29 := diff(f(x, y), x) + diff(f(x, y), y);
+    #                      /d         \   /d         \
+    #                      |-- f(x, y)| + |-- f(x, y)|
+    #                      \dx        /   \dy        /
+    #
+    # O30 := factor(subs(f(x, y) = g(x^2 + y^2), %));
+    #                                2    2
+    #                        2 D(g)(x  + y ) (x + y)
+    x, y = symbols('x y', real=True)
+    su = diff(f(x, y), x) + diff(f(x, y), y)
+    s2 = su.subs(f(x, y), g(x**2 + y**2))
+    s3 = s2.doit().factor()
+    # Subs not performed, s3 = 2*(x + y)*Subs(Derivative(
+    #   g(_xi_1), _xi_1), _xi_1, x**2 + y**2)
+    # Derivative(g(x*2 + y**2), x**2 + y**2) is not valid in SymPy,
+    # and probably will remain that way. You can take derivatives with respect
+    # to other expressions only if they are atomic, like a symbol or a
+    # function.
+    # D operator should be added to SymPy
+    # See https://github.com/sympy/sympy/issues/4719.
+    assert s3 == (x + y)*Subs(Derivative(g(x), x), x, x**2 + y**2)*2
+
+
+def test_U10():
+    # see issue 2519:
+    assert residue((z**3 + 5)/((z**4 - 1)*(z + 1)), z, -1) == R(-9, 4)
+
+@XFAIL
+def test_U11():
+    # assert (2*dx + dz) ^ (3*dx + dy + dz) ^ (dx + dy + 4*dz) == 8*dx ^ dy ^dz
+    raise NotImplementedError
+
+
+@XFAIL
+def test_U12():
+    # Wester sample case:
+    # (c41) /* d(3 x^5 dy /\ dz + 5 x y^2 dz /\ dx + 8 z dx /\ dy)
+    #    => (15 x^4 + 10 x y + 8) dx /\ dy /\ dz */
+    # factor(ext_diff(3*x^5 * dy ~ dz + 5*x*y^2 * dz ~ dx + 8*z * dx ~ dy));
+    #                      4
+    # (d41)              (10 x y + 15 x  + 8) dx dy dz
+    raise NotImplementedError(
+        "External diff of differential form not supported")
+
+
+def test_U13():
+    assert minimum(x**4 - x + 1, x) == -3*2**R(1,3)/8 + 1
+
+
+@XFAIL
+def test_U14():
+    #f = 1/(x**2 + y**2 + 1)
+    #assert [minimize(f), maximize(f)] == [0,1]
+    raise NotImplementedError("minimize(), maximize() not supported")
+
+
+@XFAIL
+def test_U15():
+    raise NotImplementedError("minimize() not supported and also solve does \
+not support multivariate inequalities")
+
+
+@XFAIL
+def test_U16():
+    raise NotImplementedError("minimize() not supported in SymPy and also \
+solve does not support multivariate inequalities")
+
+
+@XFAIL
+def test_U17():
+    raise NotImplementedError("Linear programming, symbolic simplex not \
+supported in SymPy")
+
+
+def test_V1():
+    x = symbols('x', real=True)
+    assert integrate(abs(x), x) == Piecewise((-x**2/2, x <= 0), (x**2/2, True))
+
+
+def test_V2():
+    assert integrate(Piecewise((-x, x < 0), (x, x >= 0)), x
+        ) == Piecewise((-x**2/2, x < 0), (x**2/2, True))
+
+
+def test_V3():
+    assert integrate(1/(x**3 + 2),x).diff().simplify() == 1/(x**3 + 2)
+
+
+def test_V4():
+    assert integrate(2**x/sqrt(1 + 4**x), x) == asinh(2**x)/log(2)
+
+
+@XFAIL
+def test_V5():
+    # Returns (-45*x**2 + 80*x - 41)/(5*sqrt(2*x - 1)*(4*x**2 - 4*x + 1))
+    assert (integrate((3*x - 5)**2/(2*x - 1)**R(7, 2), x).simplify() ==
+            (-41 + 80*x - 45*x**2)/(5*(2*x - 1)**R(5, 2)))
+
+
+@XFAIL
+def test_V6():
+    # returns RootSum(40*_z**2 - 1, Lambda(_i, _i*log(-4*_i + exp(-m*x))))/m
+    assert (integrate(1/(2*exp(m*x) - 5*exp(-m*x)), x) == sqrt(10)*(
+            log(2*exp(m*x) - sqrt(10)) - log(2*exp(m*x) + sqrt(10)))/(20*m))
+
+
+def test_V7():
+    r1 = integrate(sinh(x)**4/cosh(x)**2)
+    assert r1.simplify() == x*R(-3, 2) + sinh(x)**3/(2*cosh(x)) + 3*tanh(x)/2
+
+
+@XFAIL
+def test_V8_V9():
+#Macsyma test case:
+#(c27) /* This example involves several symbolic parameters
+#   => 1/sqrt(b^2 - a^2) log([sqrt(b^2 - a^2) tan(x/2) + a + b]/
+#                            [sqrt(b^2 - a^2) tan(x/2) - a - b])   (a^2 < b^2)
+#      [Gradshteyn and Ryzhik 2.553(3)] */
+#assume(b^2 > a^2)$
+#(c28) integrate(1/(a + b*cos(x)), x);
+#(c29) trigsimp(ratsimp(diff(%, x)));
+#                        1
+#(d29)             ------------
+#                  b cos(x) + a
+    raise NotImplementedError(
+        "Integrate with assumption not supported")
+
+
+def test_V10():
+    assert integrate(1/(3 + 3*cos(x) + 4*sin(x)), x) == log(4*tan(x/2) + 3)/4
+
+
+def test_V11():
+    r1 = integrate(1/(4 + 3*cos(x) + 4*sin(x)), x)
+    r2 = factor(r1)
+    assert (logcombine(r2, force=True) ==
+            log(((tan(x/2) + 1)/(tan(x/2) + 7))**R(1, 3)))
+
+
+def test_V12():
+    r1 = integrate(1/(5 + 3*cos(x) + 4*sin(x)), x)
+    assert r1 == -1/(tan(x/2) + 2)
+
+
+@XFAIL
+def test_V13():
+    r1 = integrate(1/(6 + 3*cos(x) + 4*sin(x)), x)
+    # expression not simplified, returns: -sqrt(11)*I*log(tan(x/2) + 4/3
+    #   - sqrt(11)*I/3)/11 + sqrt(11)*I*log(tan(x/2) + 4/3 + sqrt(11)*I/3)/11
+    assert r1.simplify() == 2*sqrt(11)*atan(sqrt(11)*(3*tan(x/2) + 4)/11)/11
+
+
+@slow
+@XFAIL
+def test_V14():
+    r1 = integrate(log(abs(x**2 - y**2)), x)
+    # Piecewise result does not simplify to the desired result.
+    assert (r1.simplify() == x*log(abs(x**2  - y**2))
+                            + y*log(x + y) - y*log(x - y) - 2*x)
+
+
+def test_V15():
+    r1 = integrate(x*acot(x/y), x)
+    assert simplify(r1 - (x*y + (x**2 + y**2)*acot(x/y))/2) == 0
+
+
+@XFAIL
+def test_V16():
+    # Integral not calculated
+    assert integrate(cos(5*x)*Ci(2*x), x) == Ci(2*x)*sin(5*x)/5 - (Si(3*x) + Si(7*x))/10
+
+@XFAIL
+def test_V17():
+    r1 = integrate((diff(f(x), x)*g(x)
+                   - f(x)*diff(g(x), x))/(f(x)**2 - g(x)**2), x)
+    # integral not calculated
+    assert simplify(r1 - (f(x) - g(x))/(f(x) + g(x))/2) == 0
+
+
+@XFAIL
+def test_W1():
+    # The function has a pole at y.
+    # The integral has a Cauchy principal value of zero but SymPy returns -I*pi
+    # https://github.com/sympy/sympy/issues/7159
+    assert integrate(1/(x - y), (x, y - 1, y + 1)) == 0
+
+
+@XFAIL
+def test_W2():
+    # The function has a pole at y.
+    # The integral is divergent but SymPy returns -2
+    # https://github.com/sympy/sympy/issues/7160
+    # Test case in Macsyma:
+    # (c6) errcatch(integrate(1/(x - a)^2, x, a - 1, a + 1));
+    # Integral is divergent
+    assert integrate(1/(x - y)**2, (x, y - 1, y + 1)) is zoo
+
+
+@XFAIL
+@slow
+def test_W3():
+    # integral is not  calculated
+    # https://github.com/sympy/sympy/issues/7161
+    assert integrate(sqrt(x + 1/x - 2), (x, 0, 1)) == R(4, 3)
+
+
+@XFAIL
+@slow
+def test_W4():
+    # integral is not  calculated
+    assert integrate(sqrt(x + 1/x - 2), (x, 1, 2)) == -2*sqrt(2)/3 + R(4, 3)
+
+
+@XFAIL
+@slow
+def test_W5():
+    # integral is not  calculated
+    assert integrate(sqrt(x + 1/x - 2), (x, 0, 2)) == -2*sqrt(2)/3 + R(8, 3)
+
+
+@XFAIL
+@slow
+def test_W6():
+    # integral is not  calculated
+    assert integrate(sqrt(2 - 2*cos(2*x))/2, (x, pi*R(-3, 4), -pi/4)) == sqrt(2)
+
+
+def test_W7():
+    a = symbols('a', positive=True)
+    r1 = integrate(cos(x)/(x**2 + a**2), (x, -oo, oo))
+    assert r1.simplify() == pi*exp(-a)/a
+
+
+@XFAIL
+def test_W8():
+    # Test case in Mathematica:
+    # In[19]:= Integrate[t^(a - 1)/(1 + t), {t, 0, Infinity},
+    #                    Assumptions -> 0 < a < 1]
+    # Out[19]= Pi Csc[a Pi]
+    raise NotImplementedError(
+        "Integrate with assumption 0 < a < 1 not supported")
+
+
+@XFAIL
+@slow
+def test_W9():
+    # Integrand with a residue at infinity => -2 pi [sin(pi/5) + sin(2pi/5)]
+    # (principal value)   [Levinson and Redheffer, p. 234] *)
+    r1 = integrate(5*x**3/(1 + x + x**2 + x**3 + x**4), (x, -oo, oo))
+    r2 = r1.doit()
+    assert r2 == -2*pi*(sqrt(-sqrt(5)/8 + 5/8) + sqrt(sqrt(5)/8 + 5/8))
+
+
+@XFAIL
+def test_W10():
+    # integrate(1/[1 + x + x^2 + ... + x^(2 n)], x = -infinity..infinity) =
+    #        2 pi/(2 n + 1) [1 + cos(pi/[2 n + 1])] csc(2 pi/[2 n + 1])
+    # [Levinson and Redheffer, p. 255] => 2 pi/5 [1 + cos(pi/5)] csc(2 pi/5) */
+    r1 = integrate(x/(1 + x + x**2 + x**4), (x, -oo, oo))
+    r2 = r1.doit()
+    assert r2 == 2*pi*(sqrt(5)/4 + 5/4)*csc(pi*R(2, 5))/5
+
+
+@XFAIL
+def test_W11():
+    # integral not calculated
+    assert (integrate(sqrt(1 - x**2)/(1 + x**2), (x, -1, 1)) ==
+            pi*(-1 + sqrt(2)))
+
+
+def test_W12():
+    p = symbols('p', positive=True)
+    q = symbols('q', real=True)
+    r1 = integrate(x*exp(-p*x**2 + 2*q*x), (x, -oo, oo))
+    assert r1.simplify() == sqrt(pi)*q*exp(q**2/p)/p**R(3, 2)
+
+
+@XFAIL
+def test_W13():
+    # Integral not calculated. Expected result is 2*(Euler_mascheroni_constant)
+    r1 = integrate(1/log(x) + 1/(1 - x) - log(log(1/x)), (x, 0, 1))
+    assert r1 == 2*EulerGamma
+
+
+def test_W14():
+    assert integrate(sin(x)/x*exp(2*I*x), (x, -oo, oo)) == 0
+
+
+@XFAIL
+def test_W15():
+    # integral not calculated
+    assert integrate(log(gamma(x))*cos(6*pi*x), (x, 0, 1)) == R(1, 12)
+
+
+def test_W16():
+    assert integrate((1 + x)**3*legendre_poly(1, x)*legendre_poly(2, x),
+                     (x, -1, 1)) == R(36, 35)
+
+
+def test_W17():
+    a, b = symbols('a b', positive=True)
+    assert integrate(exp(-a*x)*besselj(0, b*x),
+                 (x, 0, oo)) == 1/(b*sqrt(a**2/b**2 + 1))
+
+
+def test_W18():
+    assert integrate((besselj(1, x)/x)**2, (x, 0, oo)) == 4/(3*pi)
+
+
+@XFAIL
+def test_W19():
+    # Integral not calculated
+    # Expected result is (cos 7 - 1)/7   [Gradshteyn and Ryzhik 6.782(3)]
+    assert integrate(Ci(x)*besselj(0, 2*sqrt(7*x)), (x, 0, oo)) == (cos(7) - 1)/7
+
+
+@XFAIL
+def test_W20():
+    # integral not calculated
+    assert (integrate(x**2*polylog(3, 1/(x + 1)), (x, 0, 1)) ==
+            -pi**2/36 - R(17, 108) + zeta(3)/4 +
+            (-pi**2/2 - 4*log(2) + log(2)**2 + 35/3)*log(2)/9)
+
+
+def test_W21():
+    assert abs(N(integrate(x**2*polylog(3, 1/(x + 1)), (x, 0, 1)))
+        - 0.210882859565594) < 1e-15
+
+
+def test_W22():
+    t, u = symbols('t u', real=True)
+    s = Lambda(x, Piecewise((1, And(x >= 1, x <= 2)), (0, True)))
+    assert integrate(s(t)*cos(t), (t, 0, u)) == Piecewise(
+        (0, u < 0),
+        (-sin(Min(1, u)) + sin(Min(2, u)), True))
+
+
+@slow
+def test_W23():
+    a, b = symbols('a b', positive=True)
+    r1 = integrate(integrate(x/(x**2 + y**2), (x, a, b)), (y, -oo, oo))
+    assert r1.collect(pi).cancel() == -pi*a + pi*b
+
+
+def test_W23b():
+    # like W23 but limits are reversed
+    a, b = symbols('a b', positive=True)
+    r2 = integrate(integrate(x/(x**2 + y**2), (y, -oo, oo)), (x, a, b))
+    assert r2.collect(pi) == pi*(-a + b)
+
+
+@XFAIL
+@tooslow
+def test_W24():
+    # Not that slow, but does not fully evaluate so simplify is slow.
+    # Maybe also require doit()
+    x, y = symbols('x y', real=True)
+    r1 = integrate(integrate(sqrt(x**2 + y**2), (x, 0, 1)), (y, 0, 1))
+    assert (r1 - (sqrt(2) + asinh(1))/3).simplify() == 0
+
+
+@XFAIL
+@tooslow
+def test_W25():
+    a, x, y = symbols('a x y', real=True)
+    i1 = integrate(
+        sin(a)*sin(y)/sqrt(1 - sin(a)**2*sin(x)**2*sin(y)**2),
+        (x, 0, pi/2))
+    i2 = integrate(i1, (y, 0, pi/2))
+    assert (i2 - pi*a/2).simplify() == 0
+
+
+def test_W26():
+    x, y = symbols('x y', real=True)
+    assert integrate(integrate(abs(y - x**2), (y, 0, 2)),
+                     (x, -1, 1)) == R(46, 15)
+
+
+def test_W27():
+    a, b, c = symbols('a b c')
+    assert integrate(integrate(integrate(1, (z, 0, c*(1 - x/a - y/b))),
+                               (y, 0, b*(1 - x/a))),
+                     (x, 0, a)) == a*b*c/6
+
+
+def test_X1():
+    v, c = symbols('v c', real=True)
+    assert (series(1/sqrt(1 - (v/c)**2), v, x0=0, n=8) ==
+            5*v**6/(16*c**6) + 3*v**4/(8*c**4) + v**2/(2*c**2) + 1 + O(v**8))
+
+
+def test_X2():
+    v, c = symbols('v c', real=True)
+    s1 = series(1/sqrt(1 - (v/c)**2), v, x0=0, n=8)
+    assert (1/s1**2).series(v, x0=0, n=8) == -v**2/c**2 + 1 + O(v**8)
+
+
+def test_X3():
+    s1 = (sin(x).series()/cos(x).series()).series()
+    s2 = tan(x).series()
+    assert s2 == x + x**3/3 + 2*x**5/15 + O(x**6)
+    assert s1 == s2
+
+
+def test_X4():
+    s1 = log(sin(x)/x).series()
+    assert s1 == -x**2/6 - x**4/180 + O(x**6)
+    assert log(series(sin(x)/x)).series() == s1
+
+
+@XFAIL
+def test_X5():
+    # test case in Mathematica syntax:
+    # In[21]:= (* => [a f'(a d) + g(b d) + integrate(h(c y), y = 0..d)]
+    #       + [a^2 f''(a d) + b g'(b d) + h(c d)] (x - d) *)
+    # In[22]:= D[f[a*x], x] + g[b*x] + Integrate[h[c*y], {y, 0, x}]
+    # Out[22]= g[b x] + Integrate[h[c y], {y, 0, x}] + a f'[a x]
+    # In[23]:= Series[%, {x, d, 1}]
+    # Out[23]= (g[b d] + Integrate[h[c y], {y, 0, d}] + a f'[a d]) +
+    #                                    2                               2
+    #             (h[c d] + b g'[b d] + a  f''[a d]) (-d + x) + O[-d + x]
+    h = Function('h')
+    a, b, c, d = symbols('a b c d', real=True)
+    # series() raises NotImplementedError:
+    # The _eval_nseries method should be added to <class
+    # 'sympy.core.function.Subs'> to give terms up to O(x**n) at x=0
+    series(diff(f(a*x), x) + g(b*x) + integrate(h(c*y), (y, 0, x)),
+           x, x0=d, n=2)
+    # assert missing, until exception is removed
+
+
+def test_X6():
+    # Taylor series of nonscalar objects (noncommutative multiplication)
+    # expected result => (B A - A B) t^2/2 + O(t^3)   [Stanly Steinberg]
+    a, b = symbols('a b', commutative=False, scalar=False)
+    assert (series(exp((a + b)*x) - exp(a*x) * exp(b*x), x, x0=0, n=3) ==
+              x**2*(-a*b/2 + b*a/2) + O(x**3))
+
+
+def test_X7():
+    # => sum( Bernoulli[k]/k! x^(k - 2), k = 1..infinity )
+    #    = 1/x^2 - 1/(2 x) + 1/12 - x^2/720 + x^4/30240 + O(x^6)
+    #    [Levinson and Redheffer, p. 173]
+    assert (series(1/(x*(exp(x) - 1)), x, 0, 7) == x**(-2) - 1/(2*x) +
+            R(1, 12) - x**2/720 + x**4/30240 - x**6/1209600 + O(x**7))
+
+
+def test_X8():
+    # Puiseux series (terms with fractional degree):
+    # => 1/sqrt(x - 3/2 pi) + (x - 3/2 pi)^(3/2) / 12 + O([x - 3/2 pi]^(7/2))
+
+    # see issue 7167:
+    x = symbols('x', real=True)
+    assert (series(sqrt(sec(x)), x, x0=pi*3/2, n=4) ==
+            1/sqrt(x - pi*R(3, 2)) + (x - pi*R(3, 2))**R(3, 2)/12 +
+            (x - pi*R(3, 2))**R(7, 2)/160 + O((x - pi*R(3, 2))**4, (x, pi*R(3, 2))))
+
+
+def test_X9():
+    assert (series(x**x, x, x0=0, n=4) == 1 + x*log(x) + x**2*log(x)**2/2 +
+            x**3*log(x)**3/6 + O(x**4*log(x)**4))
+
+
+def test_X10():
+    z, w = symbols('z w')
+    assert (series(log(sinh(z)) + log(cosh(z + w)), z, x0=0, n=2) ==
+            log(cosh(w)) + log(z) + z*sinh(w)/cosh(w) + O(z**2))
+
+
+def test_X11():
+    z, w = symbols('z w')
+    assert (series(log(sinh(z) * cosh(z + w)), z, x0=0, n=2) ==
+            log(cosh(w)) + log(z) + z*sinh(w)/cosh(w) + O(z**2))
+
+
+@XFAIL
+def test_X12():
+    # Look at the generalized Taylor series around x = 1
+    # Result => (x - 1)^a/e^b [1 - (a + 2 b) (x - 1) / 2 + O((x - 1)^2)]
+    a, b, x = symbols('a b x', real=True)
+    # series returns O(log(x-1)**2)
+    # https://github.com/sympy/sympy/issues/7168
+    assert (series(log(x)**a*exp(-b*x), x, x0=1, n=2) ==
+            (x - 1)**a/exp(b)*(1 - (a + 2*b)*(x - 1)/2 + O((x - 1)**2)))
+
+
+def test_X13():
+    assert series(sqrt(2*x**2 + 1), x, x0=oo, n=1) == sqrt(2)*x + O(1/x, (x, oo))
+
+
+@XFAIL
+def test_X14():
+    # Wallis' product => 1/sqrt(pi n) + ...   [Knopp, p. 385]
+    assert series(1/2**(2*n)*binomial(2*n, n),
+                  n, x==oo, n=1) == 1/(sqrt(pi)*sqrt(n)) + O(1/x, (x, oo))
+
+
+@SKIP("https://github.com/sympy/sympy/issues/7164")
+def test_X15():
+    # => 0!/x - 1!/x^2 + 2!/x^3 - 3!/x^4 + O(1/x^5)   [Knopp, p. 544]
+    x, t = symbols('x t', real=True)
+    # raises RuntimeError: maximum recursion depth exceeded
+    # https://github.com/sympy/sympy/issues/7164
+    # 2019-02-17: Raises
+    # PoleError:
+    # Asymptotic expansion of Ei around [-oo] is not implemented.
+    e1 = integrate(exp(-t)/t, (t, x, oo))
+    assert (series(e1, x, x0=oo, n=5) ==
+            6/x**4 + 2/x**3 - 1/x**2 + 1/x + O(x**(-5), (x, oo)))
+
+
+def test_X16():
+    # Multivariate Taylor series expansion => 1 - (x^2 + 2 x y + y^2)/2 + O(x^4)
+    assert (series(cos(x + y), x + y, x0=0, n=4) == 1 - (x + y)**2/2 +
+            O(x**4 + x**3*y + x**2*y**2 + x*y**3 + y**4, x, y))
+
+
+@XFAIL
+def test_X17():
+    # Power series (compute the general formula)
+    # (c41) powerseries(log(sin(x)/x), x, 0);
+    # /aquarius/data2/opt/local/macsyma_422/library1/trgred.so being loaded.
+    #              inf
+    #              ====     i1  2 i1          2 i1
+    #              \        (- 1)   2      bern(2 i1) x
+    # (d41)         >        ------------------------------
+    #              /             2 i1 (2 i1)!
+    #              ====
+    #              i1 = 1
+    # fps does not calculate
+    assert fps(log(sin(x)/x)) == \
+        Sum((-1)**k*2**(2*k - 1)*bernoulli(2*k)*x**(2*k)/(k*factorial(2*k)), (k, 1, oo))
+
+
+@XFAIL
+def test_X18():
+    # Power series (compute the general formula). Maple FPS:
+    # > FormalPowerSeries(exp(-x)*sin(x), x = 0);
+    #                        infinity
+    #                         -----    (1/2 k)                k
+    #                          \      2        sin(3/4 k Pi) x
+    #                           )     -------------------------
+    #                          /                 k!
+    #                         -----
+    #
+    # Now, SymPy returns
+    #      oo
+    #    _____
+    #    \    `
+    #     \        /          k             k\
+    #      \     k |I*(-1 - I)    I*(-1 + I) |
+    #       \   x *|----------- - -----------|
+    #       /      \     2             2     /
+    #      /    ------------------------------
+    #     /                   k!
+    #    /____,
+    #    k = 0
+    k = Dummy('k')
+    assert fps(exp(-x)*sin(x)) == \
+        Sum(2**(S.Half*k)*sin(R(3, 4)*k*pi)*x**k/factorial(k), (k, 0, oo))
+
+
+@XFAIL
+def test_X19():
+    # (c45) /* Derive an explicit Taylor series solution of y as a function of
+    # x from the following implicit relation:
+    #    y = x - 1 + (x - 1)^2/2 + 2/3 (x - 1)^3 + (x - 1)^4 +
+    #        17/10 (x - 1)^5 + ...
+    #    */
+    # x = sin(y) + cos(y);
+    # Time= 0 msecs
+    # (d45)                   x = sin(y) + cos(y)
+    #
+    # (c46) taylor_revert(%, y, 7);
+    raise NotImplementedError("Solve using series not supported. \
+Inverse Taylor series expansion also not supported")
+
+
+@XFAIL
+def test_X20():
+    # Pade (rational function) approximation => (2 - x)/(2 + x)
+    # > numapprox[pade](exp(-x), x = 0, [1, 1]);
+    # bytes used=9019816, alloc=3669344, time=13.12
+    #                                    1 - 1/2 x
+    #                                    ---------
+    #                                    1 + 1/2 x
+    # mpmath support numeric Pade approximant but there is
+    # no symbolic implementation in SymPy
+    # https://en.wikipedia.org/wiki/Pad%C3%A9_approximant
+    raise NotImplementedError("Symbolic Pade approximant not supported")
+
+
+def test_X21():
+    """
+    Test whether `fourier_series` of x periodical on the [-p, p] interval equals
+    `- (2 p / pi) sum( (-1)^n / n sin(n pi x / p), n = 1..infinity )`.
+    """
+    p = symbols('p', positive=True)
+    n = symbols('n', positive=True, integer=True)
+    s = fourier_series(x, (x, -p, p))
+
+    # All cosine coefficients are equal to 0
+    assert s.an.formula == 0
+
+    # Check for sine coefficients
+    assert s.bn.formula.subs(s.bn.variables[0], 0) == 0
+    assert s.bn.formula.subs(s.bn.variables[0], n) == \
+        -2*p/pi * (-1)**n / n * sin(n*pi*x/p)
+
+
+@XFAIL
+def test_X22():
+    # (c52) /* => p / 2
+    #    - (2 p / pi^2) sum( [1 - (-1)^n] cos(n pi x / p) / n^2,
+    #                        n = 1..infinity ) */
+    # fourier_series(abs(x), x, p);
+    #                       p
+    # (e52)                      a  = -
+    #                       0      2
+    #
+    #                       %nn
+    #                   (2 (- 1)    - 2) p
+    # (e53)                a    = ------------------
+    #                 %nn         2    2
+    #                       %pi  %nn
+    #
+    # (e54)                     b    = 0
+    #                      %nn
+    #
+    # Time= 5290 msecs
+    #            inf           %nn            %pi %nn x
+    #            ====       (2 (- 1)    - 2) cos(---------)
+    #            \                    p
+    #          p  >       -------------------------------
+    #            /               2
+    #            ====                %nn
+    #            %nn = 1                     p
+    # (d54)          ----------------------------------------- + -
+    #                       2                 2
+    #                    %pi
+    raise NotImplementedError("Fourier series not supported")
+
+
+def test_Y1():
+    t = symbols('t', positive=True)
+    w = symbols('w', real=True)
+    s = symbols('s')
+    F, _, _ = laplace_transform(cos((w - 1)*t), t, s)
+    assert F == s/(s**2 + (w - 1)**2)
+
+
+def test_Y2():
+    t = symbols('t', positive=True)
+    w = symbols('w', real=True)
+    s = symbols('s')
+    f = inverse_laplace_transform(s/(s**2 + (w - 1)**2), s, t, simplify=True)
+    assert f == cos(t*(w - 1))
+
+
+def test_Y3():
+    t = symbols('t', positive=True)
+    w = symbols('w', real=True)
+    s = symbols('s')
+    F, _, _ = laplace_transform(sinh(w*t)*cosh(w*t), t, s, simplify=True)
+    assert F == w/(s**2 - 4*w**2)
+
+
+def test_Y4():
+    t = symbols('t', positive=True)
+    s = symbols('s')
+    F, _, _ = laplace_transform(erf(3/sqrt(t)), t, s, simplify=True)
+    assert F == 1/s - exp(-6*sqrt(s))/s
+
+
+def test_Y5_Y6():
+# Solve y'' + y = 4 [H(t - 1) - H(t - 2)], y(0) = 1, y'(0) = 0 where H is the
+# Heaviside (unit step) function (the RHS describes a pulse of magnitude 4 and
+# duration 1).  See David A. Sanchez, Richard C. Allen, Jr. and Walter T.
+# Kyner, _Differential Equations: An Introduction_, Addison-Wesley Publishing
+# Company, 1983, p. 211.  First, take the Laplace transform of the ODE
+# => s^2 Y(s) - s + Y(s) = 4/s [e^(-s) - e^(-2 s)]
+# where Y(s) is the Laplace transform of y(t)
+    t = symbols('t', real=True)
+    s = symbols('s')
+    y = Function('y')
+    Y = Function('Y')
+    F = laplace_correspondence(laplace_transform(diff(y(t), t, 2) + y(t)
+                                - 4*(Heaviside(t - 1) - Heaviside(t - 2)),
+                                t, s, noconds=True), {y: Y})
+    D = (
+        -F + s**2*Y(s) - s*y(0) + Y(s) - Subs(Derivative(y(t), t), t, 0) -
+        4*exp(-s)/s + 4*exp(-2*s)/s)
+    assert D == 0
+# Now, solve for Y(s) and then take the inverse Laplace transform
+#   => Y(s) = s/(s^2 + 1) + 4 [1/s - s/(s^2 + 1)] [e^(-s) - e^(-2 s)]
+#   => y(t) = cos t + 4 {[1 - cos(t - 1)] H(t - 1) - [1 - cos(t - 2)] H(t - 2)}
+    Yf = solve(F, Y(s))[0]
+    Yf = laplace_initial_conds(Yf, t, {y: [1, 0]})
+    assert Yf == (s**2*exp(2*s) + 4*exp(s) - 4)*exp(-2*s)/(s*(s**2 + 1))
+    yf = inverse_laplace_transform(Yf, s, t)
+    yf = yf.collect(Heaviside(t-1)).collect(Heaviside(t-2))
+    assert yf == (
+        (4 - 4*cos(t - 1))*Heaviside(t - 1) +
+        (4*cos(t - 2) - 4)*Heaviside(t - 2) +
+        cos(t)*Heaviside(t))
+
+
+@XFAIL
+def test_Y7():
+    # What is the Laplace transform of an infinite square wave?
+    # => 1/s + 2 sum( (-1)^n e^(- s n a)/s, n = 1..infinity )
+    #    [Sanchez, Allen and Kyner, p. 213]
+    t = symbols('t', positive=True)
+    a = symbols('a', real=True)
+    s = symbols('s')
+    F, _, _ = laplace_transform(1 + 2*Sum((-1)**n*Heaviside(t - n*a),
+                                          (n, 1, oo)), t, s)
+    # returns 2*LaplaceTransform(Sum((-1)**n*Heaviside(-a*n + t),
+    #                                (n, 1, oo)), t, s) + 1/s
+    # https://github.com/sympy/sympy/issues/7177
+    assert F == 2*Sum((-1)**n*exp(-a*n*s)/s, (n, 1, oo)) + 1/s
+
+
+@XFAIL
+def test_Y8():
+    assert fourier_transform(1, x, z) == DiracDelta(z)
+
+
+def test_Y9():
+    assert (fourier_transform(exp(-9*x**2), x, z) ==
+            sqrt(pi)*exp(-pi**2*z**2/9)/3)
+
+
+def test_Y10():
+    assert (fourier_transform(abs(x)*exp(-3*abs(x)), x, z).cancel() ==
+            (-8*pi**2*z**2 + 18)/(16*pi**4*z**4 + 72*pi**2*z**2 + 81))
+
+
+@SKIP("https://github.com/sympy/sympy/issues/7181")
+@slow
+def test_Y11():
+    # => pi cot(pi s)   (0 < Re s < 1)   [Gradshteyn and Ryzhik 17.43(5)]
+    x, s = symbols('x s')
+    # raises RuntimeError: maximum recursion depth exceeded
+    # https://github.com/sympy/sympy/issues/7181
+    # Update 2019-02-17 raises:
+    # TypeError: cannot unpack non-iterable MellinTransform object
+    F, _, _ =  mellin_transform(1/(1 - x), x, s)
+    assert F == pi*cot(pi*s)
+
+
+@XFAIL
+def test_Y12():
+    # => 2^(s - 4) gamma(s/2)/gamma(4 - s/2)   (0 < Re s < 1)
+    # [Gradshteyn and Ryzhik 17.43(16)]
+    x, s = symbols('x s')
+    # returns Wrong value -2**(s - 4)*gamma(s/2 - 3)/gamma(-s/2 + 1)
+    # https://github.com/sympy/sympy/issues/7182
+    F, _, _ = mellin_transform(besselj(3, x)/x**3, x, s)
+    assert F == -2**(s - 4)*gamma(s/2)/gamma(-s/2 + 4)
+
+
+@XFAIL
+def test_Y13():
+# Z[H(t - m T)] => z/[z^m (z - 1)]   (H is the Heaviside (unit step) function)                                                 z
+    raise NotImplementedError("z-transform not supported")
+
+
+@XFAIL
+def test_Y14():
+# Z[H(t - m T)] => z/[z^m (z - 1)]   (H is the Heaviside (unit step) function)
+    raise NotImplementedError("z-transform not supported")
+
+
+def test_Z1():
+    r = Function('r')
+    assert (rsolve(r(n + 2) - 2*r(n + 1) + r(n) - 2, r(n),
+                   {r(0): 1, r(1): m}).simplify() == n**2 + n*(m - 2) + 1)
+
+
+def test_Z2():
+    r = Function('r')
+    assert (rsolve(r(n) - (5*r(n - 1) - 6*r(n - 2)), r(n), {r(0): 0, r(1): 1})
+            == -2**n + 3**n)
+
+
+def test_Z3():
+    # => r(n) = Fibonacci[n + 1]   [Cohen, p. 83]
+    r = Function('r')
+    # recurrence solution is correct, Wester expects it to be simplified to
+    # fibonacci(n+1), but that is quite hard
+    expected = ((S(1)/2 - sqrt(5)/2)**n*(S(1)/2 - sqrt(5)/10)
+              + (S(1)/2 + sqrt(5)/2)**n*(sqrt(5)/10 + S(1)/2))
+    sol = rsolve(r(n) - (r(n - 1) + r(n - 2)), r(n), {r(1): 1, r(2): 2})
+    assert sol == expected
+
+
+@XFAIL
+def test_Z4():
+# => [c^(n+1) [c^(n+1) - 2 c - 2] + (n+1) c^2 + 2 c - n] / [(c-1)^3 (c+1)]
+#    [Joan Z. Yu and Robert Israel in sci.math.symbolic]
+    r = Function('r')
+    c = symbols('c')
+    # raises ValueError: Polynomial or rational function expected,
+    #     got '(c**2 - c**n)/(c - c**n)
+    s = rsolve(r(n) - ((1 + c - c**(n-1) - c**(n+1))/(1 - c**n)*r(n - 1)
+                   - c*(1 - c**(n-2))/(1 - c**(n-1))*r(n - 2) + 1),
+           r(n), {r(1): 1, r(2): (2 + 2*c + c**2)/(1 + c)})
+    assert (s - (c*(n + 1)*(c*(n + 1) - 2*c - 2) +
+             (n + 1)*c**2 + 2*c - n)/((c-1)**3*(c+1)) == 0)
+
+
+@XFAIL
+def test_Z5():
+    # Second order ODE with initial conditions---solve directly
+    # transform: f(t) = sin(2 t)/8 - t cos(2 t)/4
+    C1, C2 = symbols('C1 C2')
+    # initial conditions not supported, this is a manual workaround
+    # https://github.com/sympy/sympy/issues/4720
+    eq = Derivative(f(x), x, 2) + 4*f(x) - sin(2*x)
+    sol = dsolve(eq, f(x))
+    f0 = Lambda(x, sol.rhs)
+    assert f0(x) == C2*sin(2*x) + (C1 - x/4)*cos(2*x)
+    f1 = Lambda(x, diff(f0(x), x))
+    # TODO: Replace solve with solveset, when it works for solveset
+    const_dict = solve((f0(0), f1(0)))
+    result = f0(x).subs(C1, const_dict[C1]).subs(C2, const_dict[C2])
+    assert result == -x*cos(2*x)/4 + sin(2*x)/8
+    # Result is OK, but ODE solving with initial conditions should be
+    # supported without all this manual work
+    raise NotImplementedError('ODE solving with initial conditions \
+not supported')
+
+
+@XFAIL
+def test_Z6():
+    # Second order ODE with initial conditions---solve  using Laplace
+    # transform: f(t) = sin(2 t)/8 - t cos(2 t)/4
+    t = symbols('t', positive=True)
+    s = symbols('s')
+    eq = Derivative(f(t), t, 2) + 4*f(t) - sin(2*t)
+    F, _, _ = laplace_transform(eq, t, s)
+    # Laplace transform for diff() not calculated
+    # https://github.com/sympy/sympy/issues/7176
+    assert (F == s**2*LaplaceTransform(f(t), t, s) +
+            4*LaplaceTransform(f(t), t, s) - 2/(s**2 + 4))
+    # rest of test case not implemented

.venv/lib/python3.13/site-packages/sympy/utilities/tests/test_xxe.py

@@ -0,0 +1,3 @@
+# A test file for XXE injection
+# Username: Test
+# Password: Test