Add files using upload-large-folder tool

.gitattributes

@@ -700,3 +700,5 @@ mplug_owl2/lib/python3.10/site-packages/idna/__pycache__/uts46data.cpython-310.p
 pllava/lib/python3.10/site-packages/numpy/core/_simd.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 mplug_owl2/lib/python3.10/site-packages/sympy/physics/quantum/tests/__pycache__/test_spin.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 mplug_owl2/lib/python3.10/site-packages/sympy/parsing/latex/_antlr/__pycache__/latexparser.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+mplug_owl2/lib/python3.10/site-packages/sympy/physics/control/__pycache__/lti.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+mplug_owl2/lib/python3.10/site-packages/sympy/physics/continuum_mechanics/__pycache__/beam.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

mplug_owl2/lib/python3.10/site-packages/sympy/physics/continuum_mechanics/__pycache__/beam.cpython-310.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:206cba6f99b5f464ddb6468822a7f6e8776ca55baa449e69f7a548e3e4111fd7
+size 122356

mplug_owl2/lib/python3.10/site-packages/sympy/physics/control/__pycache__/lti.cpython-310.pyc

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

mplug_owl2/lib/python3.10/site-packages/sympy/testing/__init__.py

@@ -0,0 +1,10 @@
+"""This module contains code for running the tests in SymPy."""
+
+
+from .runtests import doctest
+from .runtests_pytest import test
+
+
+__all__ = [
+    'test', 'doctest',
+]

mplug_owl2/lib/python3.10/site-packages/sympy/testing/matrices.py

@@ -0,0 +1,8 @@
+def allclose(A, B, rtol=1e-05, atol=1e-08):
+    if len(A) != len(B):
+        return False
+
+    for x, y in zip(A, B):
+        if abs(x-y) > atol + rtol * max(abs(x), abs(y)):
+            return False
+    return True

mplug_owl2/lib/python3.10/site-packages/sympy/testing/pytest.py

@@ -0,0 +1,401 @@
+"""py.test hacks to support XFAIL/XPASS"""
+
+import sys
+import re
+import functools
+import os
+import contextlib
+import warnings
+import inspect
+import pathlib
+from typing import Any, Callable
+
+from sympy.utilities.exceptions import SymPyDeprecationWarning
+# Imported here for backwards compatibility. Note: do not import this from
+# here in library code (importing sympy.pytest in library code will break the
+# pytest integration).
+from sympy.utilities.exceptions import ignore_warnings # noqa:F401
+
+ON_CI = os.getenv('CI', None) == "true"
+
+try:
+    import pytest
+    USE_PYTEST = getattr(sys, '_running_pytest', False)
+except ImportError:
+    USE_PYTEST = False
+
+
+raises: Callable[[Any, Any], Any]
+XFAIL: Callable[[Any], Any]
+skip: Callable[[Any], Any]
+SKIP: Callable[[Any], Any]
+slow: Callable[[Any], Any]
+tooslow: Callable[[Any], Any]
+nocache_fail: Callable[[Any], Any]
+
+
+if USE_PYTEST:
+    raises = pytest.raises
+    skip = pytest.skip
+    XFAIL = pytest.mark.xfail
+    SKIP = pytest.mark.skip
+    slow = pytest.mark.slow
+    tooslow = pytest.mark.tooslow
+    nocache_fail = pytest.mark.nocache_fail
+    from _pytest.outcomes import Failed
+
+else:
+    # Not using pytest so define the things that would have been imported from
+    # there.
+
+    # _pytest._code.code.ExceptionInfo
+    class ExceptionInfo:
+        def __init__(self, value):
+            self.value = value
+
+        def __repr__(self):
+            return "<ExceptionInfo {!r}>".format(self.value)
+
+
+    def raises(expectedException, code=None):
+        """
+        Tests that ``code`` raises the exception ``expectedException``.
+
+        ``code`` may be a callable, such as a lambda expression or function
+        name.
+
+        If ``code`` is not given or None, ``raises`` will return a context
+        manager for use in ``with`` statements; the code to execute then
+        comes from the scope of the ``with``.
+
+        ``raises()`` does nothing if the callable raises the expected exception,
+        otherwise it raises an AssertionError.
+
+        Examples
+        ========
+
+        >>> from sympy.testing.pytest import raises
+
+        >>> raises(ZeroDivisionError, lambda: 1/0)
+        <ExceptionInfo ZeroDivisionError(...)>
+        >>> raises(ZeroDivisionError, lambda: 1/2)
+        Traceback (most recent call last):
+        ...
+        Failed: DID NOT RAISE
+
+        >>> with raises(ZeroDivisionError):
+        ...     n = 1/0
+        >>> with raises(ZeroDivisionError):
+        ...     n = 1/2
+        Traceback (most recent call last):
+        ...
+        Failed: DID NOT RAISE
+
+        Note that you cannot test multiple statements via
+        ``with raises``:
+
+        >>> with raises(ZeroDivisionError):
+        ...     n = 1/0    # will execute and raise, aborting the ``with``
+        ...     n = 9999/0 # never executed
+
+        This is just what ``with`` is supposed to do: abort the
+        contained statement sequence at the first exception and let
+        the context manager deal with the exception.
+
+        To test multiple statements, you'll need a separate ``with``
+        for each:
+
+        >>> with raises(ZeroDivisionError):
+        ...     n = 1/0    # will execute and raise
+        >>> with raises(ZeroDivisionError):
+        ...     n = 9999/0 # will also execute and raise
+
+        """
+        if code is None:
+            return RaisesContext(expectedException)
+        elif callable(code):
+            try:
+                code()
+            except expectedException as e:
+                return ExceptionInfo(e)
+            raise Failed("DID NOT RAISE")
+        elif isinstance(code, str):
+            raise TypeError(
+                '\'raises(xxx, "code")\' has been phased out; '
+                'change \'raises(xxx, "expression")\' '
+                'to \'raises(xxx, lambda: expression)\', '
+                '\'raises(xxx, "statement")\' '
+                'to \'with raises(xxx): statement\'')
+        else:
+            raise TypeError(
+                'raises() expects a callable for the 2nd argument.')
+
+    class RaisesContext:
+        def __init__(self, expectedException):
+            self.expectedException = expectedException
+
+        def __enter__(self):
+            return None
+
+        def __exit__(self, exc_type, exc_value, traceback):
+            if exc_type is None:
+                raise Failed("DID NOT RAISE")
+            return issubclass(exc_type, self.expectedException)
+
+    class XFail(Exception):
+        pass
+
+    class XPass(Exception):
+        pass
+
+    class Skipped(Exception):
+        pass
+
+    class Failed(Exception):  # type: ignore
+        pass
+
+    def XFAIL(func):
+        def wrapper():
+            try:
+                func()
+            except Exception as e:
+                message = str(e)
+                if message != "Timeout":
+                    raise XFail(func.__name__)
+                else:
+                    raise Skipped("Timeout")
+            raise XPass(func.__name__)
+
+        wrapper = functools.update_wrapper(wrapper, func)
+        return wrapper
+
+    def skip(str):
+        raise Skipped(str)
+
+    def SKIP(reason):
+        """Similar to ``skip()``, but this is a decorator. """
+        def wrapper(func):
+            def func_wrapper():
+                raise Skipped(reason)
+
+            func_wrapper = functools.update_wrapper(func_wrapper, func)
+            return func_wrapper
+
+        return wrapper
+
+    def slow(func):
+        func._slow = True
+
+        def func_wrapper():
+            func()
+
+        func_wrapper = functools.update_wrapper(func_wrapper, func)
+        func_wrapper.__wrapped__ = func
+        return func_wrapper
+
+    def tooslow(func):
+        func._slow = True
+        func._tooslow = True
+
+        def func_wrapper():
+            skip("Too slow")
+
+        func_wrapper = functools.update_wrapper(func_wrapper, func)
+        func_wrapper.__wrapped__ = func
+        return func_wrapper
+
+    def nocache_fail(func):
+        "Dummy decorator for marking tests that fail when cache is disabled"
+        return func
+
+@contextlib.contextmanager
+def warns(warningcls, *, match='', test_stacklevel=True):
+    '''
+    Like raises but tests that warnings are emitted.
+
+    >>> from sympy.testing.pytest import warns
+    >>> import warnings
+
+    >>> with warns(UserWarning):
+    ...     warnings.warn('deprecated', UserWarning, stacklevel=2)
+
+    >>> with warns(UserWarning):
+    ...     pass
+    Traceback (most recent call last):
+    ...
+    Failed: DID NOT WARN. No warnings of type UserWarning\
+    was emitted. The list of emitted warnings is: [].
+
+    ``test_stacklevel`` makes it check that the ``stacklevel`` parameter to
+    ``warn()`` is set so that the warning shows the user line of code (the
+    code under the warns() context manager). Set this to False if this is
+    ambiguous or if the context manager does not test the direct user code
+    that emits the warning.
+
+    If the warning is a ``SymPyDeprecationWarning``, this additionally tests
+    that the ``active_deprecations_target`` is a real target in the
+    ``active-deprecations.md`` file.
+
+    '''
+    # Absorbs all warnings in warnrec
+    with warnings.catch_warnings(record=True) as warnrec:
+        # Any warning other than the one we are looking for is an error
+        warnings.simplefilter("error")
+        warnings.filterwarnings("always", category=warningcls)
+        # Now run the test
+        yield warnrec
+
+    # Raise if expected warning not found
+    if not any(issubclass(w.category, warningcls) for w in warnrec):
+        msg = ('Failed: DID NOT WARN.'
+               ' No warnings of type %s was emitted.'
+               ' The list of emitted warnings is: %s.'
+               ) % (warningcls, [w.message for w in warnrec])
+        raise Failed(msg)
+
+    # We don't include the match in the filter above because it would then
+    # fall to the error filter, so we instead manually check that it matches
+    # here
+    for w in warnrec:
+        # Should always be true due to the filters above
+        assert issubclass(w.category, warningcls)
+        if not re.compile(match, re.I).match(str(w.message)):
+            raise Failed(f"Failed: WRONG MESSAGE. A warning with of the correct category ({warningcls.__name__}) was issued, but it did not match the given match regex ({match!r})")
+
+    if test_stacklevel:
+        for f in inspect.stack():
+            thisfile = f.filename
+            file = os.path.split(thisfile)[1]
+            if file.startswith('test_'):
+                break
+            elif file == 'doctest.py':
+                # skip the stacklevel testing in the doctests of this
+                # function
+                return
+        else:
+            raise RuntimeError("Could not find the file for the given warning to test the stacklevel")
+        for w in warnrec:
+            if w.filename != thisfile:
+                msg = f'''\
+Failed: Warning has the wrong stacklevel. The warning stacklevel needs to be
+set so that the line of code shown in the warning message is user code that
+calls the deprecated code (the current stacklevel is showing code from
+{w.filename} (line {w.lineno}), expected {thisfile})'''.replace('\n', ' ')
+                raise Failed(msg)
+
+    if warningcls == SymPyDeprecationWarning:
+        this_file = pathlib.Path(__file__)
+        active_deprecations_file = (this_file.parent.parent.parent / 'doc' /
+                                    'src' / 'explanation' /
+                                    'active-deprecations.md')
+        if not active_deprecations_file.exists():
+            # We can only test that the active_deprecations_target works if we are
+            # in the git repo.
+            return
+        targets = []
+        for w in warnrec:
+            targets.append(w.message.active_deprecations_target)
+        with open(active_deprecations_file, encoding="utf-8") as f:
+            text = f.read()
+        for target in targets:
+            if f'({target})=' not in text:
+                raise Failed(f"The active deprecations target {target!r} does not appear to be a valid target in the active-deprecations.md file ({active_deprecations_file}).")
+
+def _both_exp_pow(func):
+    """
+    Decorator used to run the test twice: the first time `e^x` is represented
+    as ``Pow(E, x)``, the second time as ``exp(x)`` (exponential object is not
+    a power).
+
+    This is a temporary trick helping to manage the elimination of the class
+    ``exp`` in favor of a replacement by ``Pow(E, ...)``.
+    """
+    from sympy.core.parameters import _exp_is_pow
+
+    def func_wrap():
+        with _exp_is_pow(True):
+            func()
+        with _exp_is_pow(False):
+            func()
+
+    wrapper = functools.update_wrapper(func_wrap, func)
+    return wrapper
+
+
+@contextlib.contextmanager
+def warns_deprecated_sympy():
+    '''
+    Shorthand for ``warns(SymPyDeprecationWarning)``
+
+    This is the recommended way to test that ``SymPyDeprecationWarning`` is
+    emitted for deprecated features in SymPy. To test for other warnings use
+    ``warns``. To suppress warnings without asserting that they are emitted
+    use ``ignore_warnings``.
+
+    .. note::
+
+       ``warns_deprecated_sympy()`` is only intended for internal use in the
+       SymPy test suite to test that a deprecation warning triggers properly.
+       All other code in the SymPy codebase, including documentation examples,
+       should not use deprecated behavior.
+
+       If you are a user of SymPy and you want to disable
+       SymPyDeprecationWarnings, use ``warnings`` filters (see
+       :ref:`silencing-sympy-deprecation-warnings`).
+
+    >>> from sympy.testing.pytest import warns_deprecated_sympy
+    >>> from sympy.utilities.exceptions import sympy_deprecation_warning
+    >>> with warns_deprecated_sympy():
+    ...     sympy_deprecation_warning("Don't use",
+    ...        deprecated_since_version="1.0",
+    ...        active_deprecations_target="active-deprecations")
+
+    >>> with warns_deprecated_sympy():
+    ...     pass
+    Traceback (most recent call last):
+    ...
+    Failed: DID NOT WARN. No warnings of type \
+    SymPyDeprecationWarning was emitted. The list of emitted warnings is: [].
+
+    .. note::
+
+       Sometimes the stacklevel test will fail because the same warning is
+       emitted multiple times. In this case, you can use
+       :func:`sympy.utilities.exceptions.ignore_warnings` in the code to
+       prevent the ``SymPyDeprecationWarning`` from being emitted again
+       recursively. In rare cases it is impossible to have a consistent
+       ``stacklevel`` for deprecation warnings because different ways of
+       calling a function will produce different call stacks.. In those cases,
+       use ``warns(SymPyDeprecationWarning)`` instead.
+
+    See Also
+    ========
+    sympy.utilities.exceptions.SymPyDeprecationWarning
+    sympy.utilities.exceptions.sympy_deprecation_warning
+    sympy.utilities.decorator.deprecated
+
+    '''
+    with warns(SymPyDeprecationWarning):
+        yield
+
+
+def _running_under_pyodide():
+    """Test if running under pyodide."""
+    try:
+        import pyodide_js  # type: ignore  # noqa
+    except ImportError:
+        return False
+    else:
+        return True
+
+
+def skip_under_pyodide(message):
+    """Decorator to skip a test if running under pyodide."""
+    def decorator(test_func):
+        @functools.wraps(test_func)
+        def test_wrapper():
+            if _running_under_pyodide():
+                skip(message)
+            return test_func()
+        return test_wrapper
+    return decorator

mplug_owl2/lib/python3.10/site-packages/sympy/testing/quality_unicode.py

@@ -0,0 +1,102 @@
+import re
+import fnmatch
+
+
+message_unicode_B = \
+    "File contains a unicode character : %s, line %s. " \
+    "But not in the whitelist. " \
+    "Add the file to the whitelist in " + __file__
+message_unicode_D = \
+    "File does not contain a unicode character : %s." \
+    "but is in the whitelist. " \
+    "Remove the file from the whitelist in " + __file__
+
+
+encoding_header_re = re.compile(
+    r'^[ \t\f]*#.*?coding[:=][ \t]*([-_.a-zA-Z0-9]+)')
+
+# Whitelist pattern for files which can have unicode.
+unicode_whitelist = [
+    # Author names can include non-ASCII characters
+    r'*/bin/authors_update.py',
+    r'*/bin/mailmap_check.py',
+
+    # These files have functions and test functions for unicode input and
+    # output.
+    r'*/sympy/testing/tests/test_code_quality.py',
+    r'*/sympy/physics/vector/tests/test_printing.py',
+    r'*/physics/quantum/tests/test_printing.py',
+    r'*/sympy/vector/tests/test_printing.py',
+    r'*/sympy/parsing/tests/test_sympy_parser.py',
+    r'*/sympy/printing/pretty/stringpict.py',
+    r'*/sympy/printing/pretty/tests/test_pretty.py',
+    r'*/sympy/printing/tests/test_conventions.py',
+    r'*/sympy/printing/tests/test_preview.py',
+    r'*/liealgebras/type_g.py',
+    r'*/liealgebras/weyl_group.py',
+    r'*/liealgebras/tests/test_type_G.py',
+
+    # wigner.py and polarization.py have unicode doctests. These probably
+    # don't need to be there but some of the examples that are there are
+    # pretty ugly without use_unicode (matrices need to be wrapped across
+    # multiple lines etc)
+    r'*/sympy/physics/wigner.py',
+    r'*/sympy/physics/optics/polarization.py',
+
+    # joint.py uses some unicode for variable names in the docstrings
+    r'*/sympy/physics/mechanics/joint.py',
+
+    # lll method has unicode in docstring references and author name
+    r'*/sympy/polys/matrices/domainmatrix.py',
+    r'*/sympy/matrices/repmatrix.py',
+
+    # Explanation of symbols uses greek letters
+    r'*/sympy/core/symbol.py',
+]
+
+unicode_strict_whitelist = [
+    r'*/sympy/parsing/latex/_antlr/__init__.py',
+    # test_mathematica.py uses some unicode for testing Greek characters are working #24055
+    r'*/sympy/parsing/tests/test_mathematica.py',
+]
+
+
+def _test_this_file_encoding(
+    fname, test_file,
+    unicode_whitelist=unicode_whitelist,
+    unicode_strict_whitelist=unicode_strict_whitelist):
+    """Test helper function for unicode test
+
+    The test may have to operate on filewise manner, so it had moved
+    to a separate process.
+    """
+    has_unicode = False
+
+    is_in_whitelist = False
+    is_in_strict_whitelist = False
+    for patt in unicode_whitelist:
+        if fnmatch.fnmatch(fname, patt):
+            is_in_whitelist = True
+            break
+    for patt in unicode_strict_whitelist:
+        if fnmatch.fnmatch(fname, patt):
+            is_in_strict_whitelist = True
+            is_in_whitelist = True
+            break
+
+    if is_in_whitelist:
+        for idx, line in enumerate(test_file):
+            try:
+                line.encode(encoding='ascii')
+            except (UnicodeEncodeError, UnicodeDecodeError):
+                has_unicode = True
+
+        if not has_unicode and not is_in_strict_whitelist:
+            assert False, message_unicode_D % fname
+
+    else:
+        for idx, line in enumerate(test_file):
+            try:
+                line.encode(encoding='ascii')
+            except (UnicodeEncodeError, UnicodeDecodeError):
+                assert False, message_unicode_B % (fname, idx + 1)

mplug_owl2/lib/python3.10/site-packages/sympy/testing/randtest.py

@@ -0,0 +1,19 @@
+"""
+.. deprecated:: 1.10
+
+   ``sympy.testing.randtest`` functions have been moved to
+   :mod:`sympy.core.random`.
+
+"""
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+sympy_deprecation_warning("The sympy.testing.randtest submodule is deprecated. Use sympy.core.random instead.",
+    deprecated_since_version="1.10",
+    active_deprecations_target="deprecated-sympy-testing-randtest")
+
+from sympy.core.random import (  # noqa:F401
+    random_complex_number,
+    verify_numerically,
+    test_derivative_numerically,
+    _randrange,
+    _randint)

mplug_owl2/lib/python3.10/site-packages/sympy/testing/runtests.py

@@ -0,0 +1,2409 @@
+"""
+This is our testing framework.
+
+Goals:
+
+* it should be compatible with py.test and operate very similarly
+  (or identically)
+* does not require any external dependencies
+* preferably all the functionality should be in this file only
+* no magic, just import the test file and execute the test functions, that's it
+* portable
+
+"""
+
+import os
+import sys
+import platform
+import inspect
+import traceback
+import pdb
+import re
+import linecache
+import time
+from fnmatch import fnmatch
+from timeit import default_timer as clock
+import doctest as pdoctest  # avoid clashing with our doctest() function
+from doctest import DocTestFinder, DocTestRunner
+import random
+import subprocess
+import shutil
+import signal
+import stat
+import tempfile
+import warnings
+from contextlib import contextmanager
+from inspect import unwrap
+
+from sympy.core.cache import clear_cache
+from sympy.external import import_module
+from sympy.external.gmpy import GROUND_TYPES
+
+IS_WINDOWS = (os.name == 'nt')
+ON_CI = os.getenv('CI', None)
+
+# empirically generated list of the proportion of time spent running
+# an even split of tests.  This should periodically be regenerated.
+# A list of [.6, .1, .3] would mean that if the tests are evenly split
+# into '1/3', '2/3', '3/3', the first split would take 60% of the time,
+# the second 10% and the third 30%.  These lists are normalized to sum
+# to 1, so [60, 10, 30] has the same behavior as [6, 1, 3] or [.6, .1, .3].
+#
+# This list can be generated with the code:
+#     from time import time
+#     import sympy
+#     import os
+#     os.environ["CI"] = 'true' # Mock CI to get more correct densities
+#     delays, num_splits = [], 30
+#     for i in range(1, num_splits + 1):
+#         tic = time()
+#         sympy.test(split='{}/{}'.format(i, num_splits), time_balance=False) # Add slow=True for slow tests
+#         delays.append(time() - tic)
+#     tot = sum(delays)
+#     print([round(x / tot, 4) for x in delays])
+SPLIT_DENSITY = [
+    0.0059, 0.0027, 0.0068, 0.0011, 0.0006,
+    0.0058, 0.0047, 0.0046, 0.004, 0.0257,
+    0.0017, 0.0026, 0.004, 0.0032, 0.0016,
+    0.0015, 0.0004, 0.0011, 0.0016, 0.0014,
+    0.0077, 0.0137, 0.0217, 0.0074, 0.0043,
+    0.0067, 0.0236, 0.0004, 0.1189, 0.0142,
+    0.0234, 0.0003, 0.0003, 0.0047, 0.0006,
+    0.0013, 0.0004, 0.0008, 0.0007, 0.0006,
+    0.0139, 0.0013, 0.0007, 0.0051, 0.002,
+    0.0004, 0.0005, 0.0213, 0.0048, 0.0016,
+    0.0012, 0.0014, 0.0024, 0.0015, 0.0004,
+    0.0005, 0.0007, 0.011, 0.0062, 0.0015,
+    0.0021, 0.0049, 0.0006, 0.0006, 0.0011,
+    0.0006, 0.0019, 0.003, 0.0044, 0.0054,
+    0.0057, 0.0049, 0.0016, 0.0006, 0.0009,
+    0.0006, 0.0012, 0.0006, 0.0149, 0.0532,
+    0.0076, 0.0041, 0.0024, 0.0135, 0.0081,
+    0.2209, 0.0459, 0.0438, 0.0488, 0.0137,
+    0.002, 0.0003, 0.0008, 0.0039, 0.0024,
+    0.0005, 0.0004, 0.003, 0.056, 0.0026]
+SPLIT_DENSITY_SLOW = [0.0086, 0.0004, 0.0568, 0.0003, 0.0032, 0.0005, 0.0004, 0.0013, 0.0016, 0.0648, 0.0198, 0.1285, 0.098, 0.0005, 0.0064, 0.0003, 0.0004, 0.0026, 0.0007, 0.0051, 0.0089, 0.0024, 0.0033, 0.0057, 0.0005, 0.0003, 0.001, 0.0045, 0.0091, 0.0006, 0.0005, 0.0321, 0.0059, 0.1105, 0.216, 0.1489, 0.0004, 0.0003, 0.0006, 0.0483]
+
+class Skipped(Exception):
+    pass
+
+class TimeOutError(Exception):
+    pass
+
+class DependencyError(Exception):
+    pass
+
+
+def _indent(s, indent=4):
+    """
+    Add the given number of space characters to the beginning of
+    every non-blank line in ``s``, and return the result.
+    If the string ``s`` is Unicode, it is encoded using the stdout
+    encoding and the ``backslashreplace`` error handler.
+    """
+    # This regexp matches the start of non-blank lines:
+    return re.sub('(?m)^(?!$)', indent*' ', s)
+
+
+pdoctest._indent = _indent  # type: ignore
+
+# override reporter to maintain windows and python3
+
+
+def _report_failure(self, out, test, example, got):
+    """
+    Report that the given example failed.
+    """
+    s = self._checker.output_difference(example, got, self.optionflags)
+    s = s.encode('raw_unicode_escape').decode('utf8', 'ignore')
+    out(self._failure_header(test, example) + s)
+
+
+if IS_WINDOWS:
+    DocTestRunner.report_failure = _report_failure  # type: ignore
+
+
+def convert_to_native_paths(lst):
+    """
+    Converts a list of '/' separated paths into a list of
+    native (os.sep separated) paths and converts to lowercase
+    if the system is case insensitive.
+    """
+    newlst = []
+    for i, rv in enumerate(lst):
+        rv = os.path.join(*rv.split("/"))
+        # on windows the slash after the colon is dropped
+        if sys.platform == "win32":
+            pos = rv.find(':')
+            if pos != -1:
+                if rv[pos + 1] != '\\':
+                    rv = rv[:pos + 1] + '\\' + rv[pos + 1:]
+        newlst.append(os.path.normcase(rv))
+    return newlst
+
+
+def get_sympy_dir():
+    """
+    Returns the root SymPy directory and set the global value
+    indicating whether the system is case sensitive or not.
+    """
+    this_file = os.path.abspath(__file__)
+    sympy_dir = os.path.join(os.path.dirname(this_file), "..", "..")
+    sympy_dir = os.path.normpath(sympy_dir)
+    return os.path.normcase(sympy_dir)
+
+
+def setup_pprint(disable_line_wrap=True):
+    from sympy.interactive.printing import init_printing
+    from sympy.printing.pretty.pretty import pprint_use_unicode
+    import sympy.interactive.printing as interactive_printing
+    from sympy.printing.pretty import stringpict
+
+    # Prevent init_printing() in doctests from affecting other doctests
+    interactive_printing.NO_GLOBAL = True
+
+    # force pprint to be in ascii mode in doctests
+    use_unicode_prev = pprint_use_unicode(False)
+
+    # disable line wrapping for pprint() outputs
+    wrap_line_prev = stringpict._GLOBAL_WRAP_LINE
+    if disable_line_wrap:
+        stringpict._GLOBAL_WRAP_LINE = False
+
+    # hook our nice, hash-stable strprinter
+    init_printing(pretty_print=False)
+
+    return use_unicode_prev, wrap_line_prev
+
+
+@contextmanager
+def raise_on_deprecated():
+    """Context manager to make DeprecationWarning raise an error
+
+    This is to catch SymPyDeprecationWarning from library code while running
+    tests and doctests. It is important to use this context manager around
+    each individual test/doctest in case some tests modify the warning
+    filters.
+    """
+    with warnings.catch_warnings():
+        warnings.filterwarnings('error', '.*', DeprecationWarning, module='sympy.*')
+        yield
+
+
+def run_in_subprocess_with_hash_randomization(
+        function, function_args=(),
+        function_kwargs=None, command=sys.executable,
+        module='sympy.testing.runtests', force=False):
+    """
+    Run a function in a Python subprocess with hash randomization enabled.
+
+    If hash randomization is not supported by the version of Python given, it
+    returns False.  Otherwise, it returns the exit value of the command.  The
+    function is passed to sys.exit(), so the return value of the function will
+    be the return value.
+
+    The environment variable PYTHONHASHSEED is used to seed Python's hash
+    randomization.  If it is set, this function will return False, because
+    starting a new subprocess is unnecessary in that case.  If it is not set,
+    one is set at random, and the tests are run.  Note that if this
+    environment variable is set when Python starts, hash randomization is
+    automatically enabled.  To force a subprocess to be created even if
+    PYTHONHASHSEED is set, pass ``force=True``.  This flag will not force a
+    subprocess in Python versions that do not support hash randomization (see
+    below), because those versions of Python do not support the ``-R`` flag.
+
+    ``function`` should be a string name of a function that is importable from
+    the module ``module``, like "_test".  The default for ``module`` is
+    "sympy.testing.runtests".  ``function_args`` and ``function_kwargs``
+    should be a repr-able tuple and dict, respectively.  The default Python
+    command is sys.executable, which is the currently running Python command.
+
+    This function is necessary because the seed for hash randomization must be
+    set by the environment variable before Python starts.  Hence, in order to
+    use a predetermined seed for tests, we must start Python in a separate
+    subprocess.
+
+    Hash randomization was added in the minor Python versions 2.6.8, 2.7.3,
+    3.1.5, and 3.2.3, and is enabled by default in all Python versions after
+    and including 3.3.0.
+
+    Examples
+    ========
+
+    >>> from sympy.testing.runtests import (
+    ... run_in_subprocess_with_hash_randomization)
+    >>> # run the core tests in verbose mode
+    >>> run_in_subprocess_with_hash_randomization("_test",
+    ... function_args=("core",),
+    ... function_kwargs={'verbose': True}) # doctest: +SKIP
+    # Will return 0 if sys.executable supports hash randomization and tests
+    # pass, 1 if they fail, and False if it does not support hash
+    # randomization.
+
+    """
+    cwd = get_sympy_dir()
+    # Note, we must return False everywhere, not None, as subprocess.call will
+    # sometimes return None.
+
+    # First check if the Python version supports hash randomization
+    # If it does not have this support, it won't recognize the -R flag
+    p = subprocess.Popen([command, "-RV"], stdout=subprocess.PIPE,
+                         stderr=subprocess.STDOUT, cwd=cwd)
+    p.communicate()
+    if p.returncode != 0:
+        return False
+
+    hash_seed = os.getenv("PYTHONHASHSEED")
+    if not hash_seed:
+        os.environ["PYTHONHASHSEED"] = str(random.randrange(2**32))
+    else:
+        if not force:
+            return False
+
+    function_kwargs = function_kwargs or {}
+
+    # Now run the command
+    commandstring = ("import sys; from %s import %s;sys.exit(%s(*%s, **%s))" %
+                     (module, function, function, repr(function_args),
+                      repr(function_kwargs)))
+
+    try:
+        p = subprocess.Popen([command, "-R", "-c", commandstring], cwd=cwd)
+        p.communicate()
+    except KeyboardInterrupt:
+        p.wait()
+    finally:
+        # Put the environment variable back, so that it reads correctly for
+        # the current Python process.
+        if hash_seed is None:
+            del os.environ["PYTHONHASHSEED"]
+        else:
+            os.environ["PYTHONHASHSEED"] = hash_seed
+        return p.returncode
+
+
+def run_all_tests(test_args=(), test_kwargs=None,
+                  doctest_args=(), doctest_kwargs=None,
+                  examples_args=(), examples_kwargs=None):
+    """
+    Run all tests.
+
+    Right now, this runs the regular tests (bin/test), the doctests
+    (bin/doctest), and the examples (examples/all.py).
+
+    This is what ``setup.py test`` uses.
+
+    You can pass arguments and keyword arguments to the test functions that
+    support them (for now, test,  doctest, and the examples). See the
+    docstrings of those functions for a description of the available options.
+
+    For example, to run the solvers tests with colors turned off:
+
+    >>> from sympy.testing.runtests import run_all_tests
+    >>> run_all_tests(test_args=("solvers",),
+    ... test_kwargs={"colors:False"}) # doctest: +SKIP
+
+    """
+    tests_successful = True
+
+    test_kwargs = test_kwargs or {}
+    doctest_kwargs = doctest_kwargs or {}
+    examples_kwargs = examples_kwargs or {'quiet': True}
+
+    try:
+        # Regular tests
+        if not test(*test_args, **test_kwargs):
+            # some regular test fails, so set the tests_successful
+            # flag to false and continue running the doctests
+            tests_successful = False
+
+        # Doctests
+        print()
+        if not doctest(*doctest_args, **doctest_kwargs):
+            tests_successful = False
+
+        # Examples
+        print()
+        sys.path.append("examples")   # examples/all.py
+        from all import run_examples  # type: ignore
+        if not run_examples(*examples_args, **examples_kwargs):
+            tests_successful = False
+
+        if tests_successful:
+            return
+        else:
+            # Return nonzero exit code
+            sys.exit(1)
+    except KeyboardInterrupt:
+        print()
+        print("DO *NOT* COMMIT!")
+        sys.exit(1)
+
+
+def test(*paths, subprocess=True, rerun=0, **kwargs):
+    """
+    Run tests in the specified test_*.py files.
+
+    Tests in a particular test_*.py file are run if any of the given strings
+    in ``paths`` matches a part of the test file's path. If ``paths=[]``,
+    tests in all test_*.py files are run.
+
+    Notes:
+
+    - If sort=False, tests are run in random order (not default).
+    - Paths can be entered in native system format or in unix,
+      forward-slash format.
+    - Files that are on the blacklist can be tested by providing
+      their path; they are only excluded if no paths are given.
+
+    **Explanation of test results**
+
+    ======  ===============================================================
+    Output  Meaning
+    ======  ===============================================================
+    .       passed
+    F       failed
+    X       XPassed (expected to fail but passed)
+    f       XFAILed (expected to fail and indeed failed)
+    s       skipped
+    w       slow
+    T       timeout (e.g., when ``--timeout`` is used)
+    K       KeyboardInterrupt (when running the slow tests with ``--slow``,
+            you can interrupt one of them without killing the test runner)
+    ======  ===============================================================
+
+
+    Colors have no additional meaning and are used just to facilitate
+    interpreting the output.
+
+    Examples
+    ========
+
+    >>> import sympy
+
+    Run all tests:
+
+    >>> sympy.test()    # doctest: +SKIP
+
+    Run one file:
+
+    >>> sympy.test("sympy/core/tests/test_basic.py")    # doctest: +SKIP
+    >>> sympy.test("_basic")    # doctest: +SKIP
+
+    Run all tests in sympy/functions/ and some particular file:
+
+    >>> sympy.test("sympy/core/tests/test_basic.py",
+    ...        "sympy/functions")    # doctest: +SKIP
+
+    Run all tests in sympy/core and sympy/utilities:
+
+    >>> sympy.test("/core", "/util")    # doctest: +SKIP
+
+    Run specific test from a file:
+
+    >>> sympy.test("sympy/core/tests/test_basic.py",
+    ...        kw="test_equality")    # doctest: +SKIP
+
+    Run specific test from any file:
+
+    >>> sympy.test(kw="subs")    # doctest: +SKIP
+
+    Run the tests with verbose mode on:
+
+    >>> sympy.test(verbose=True)    # doctest: +SKIP
+
+    Do not sort the test output:
+
+    >>> sympy.test(sort=False)    # doctest: +SKIP
+
+    Turn on post-mortem pdb:
+
+    >>> sympy.test(pdb=True)    # doctest: +SKIP
+
+    Turn off colors:
+
+    >>> sympy.test(colors=False)    # doctest: +SKIP
+
+    Force colors, even when the output is not to a terminal (this is useful,
+    e.g., if you are piping to ``less -r`` and you still want colors)
+
+    >>> sympy.test(force_colors=False)    # doctest: +SKIP
+
+    The traceback verboseness can be set to "short" or "no" (default is
+    "short")
+
+    >>> sympy.test(tb='no')    # doctest: +SKIP
+
+    The ``split`` option can be passed to split the test run into parts. The
+    split currently only splits the test files, though this may change in the
+    future. ``split`` should be a string of the form 'a/b', which will run
+    part ``a`` of ``b``. For instance, to run the first half of the test suite:
+
+    >>> sympy.test(split='1/2')  # doctest: +SKIP
+
+    The ``time_balance`` option can be passed in conjunction with ``split``.
+    If ``time_balance=True`` (the default for ``sympy.test``), SymPy will attempt
+    to split the tests such that each split takes equal time.  This heuristic
+    for balancing is based on pre-recorded test data.
+
+    >>> sympy.test(split='1/2', time_balance=True)  # doctest: +SKIP
+
+    You can disable running the tests in a separate subprocess using
+    ``subprocess=False``.  This is done to support seeding hash randomization,
+    which is enabled by default in the Python versions where it is supported.
+    If subprocess=False, hash randomization is enabled/disabled according to
+    whether it has been enabled or not in the calling Python process.
+    However, even if it is enabled, the seed cannot be printed unless it is
+    called from a new Python process.
+
+    Hash randomization was added in the minor Python versions 2.6.8, 2.7.3,
+    3.1.5, and 3.2.3, and is enabled by default in all Python versions after
+    and including 3.3.0.
+
+    If hash randomization is not supported ``subprocess=False`` is used
+    automatically.
+
+    >>> sympy.test(subprocess=False)     # doctest: +SKIP
+
+    To set the hash randomization seed, set the environment variable
+    ``PYTHONHASHSEED`` before running the tests.  This can be done from within
+    Python using
+
+    >>> import os
+    >>> os.environ['PYTHONHASHSEED'] = '42' # doctest: +SKIP
+
+    Or from the command line using
+
+    $ PYTHONHASHSEED=42 ./bin/test
+
+    If the seed is not set, a random seed will be chosen.
+
+    Note that to reproduce the same hash values, you must use both the same seed
+    as well as the same architecture (32-bit vs. 64-bit).
+
+    """
+    # count up from 0, do not print 0
+    print_counter = lambda i : (print("rerun %d" % (rerun-i))
+                                if rerun-i else None)
+
+    if subprocess:
+        # loop backwards so last i is 0
+        for i in range(rerun, -1, -1):
+            print_counter(i)
+            ret = run_in_subprocess_with_hash_randomization("_test",
+                        function_args=paths, function_kwargs=kwargs)
+            if ret is False:
+                break
+            val = not bool(ret)
+            # exit on the first failure or if done
+            if not val or i == 0:
+                return val
+
+    # rerun even if hash randomization is not supported
+    for i in range(rerun, -1, -1):
+        print_counter(i)
+        val = not bool(_test(*paths, **kwargs))
+        if not val or i == 0:
+            return val
+
+
+def _test(*paths,
+        verbose=False, tb="short", kw=None, pdb=False, colors=True,
+        force_colors=False, sort=True, seed=None, timeout=False,
+        fail_on_timeout=False, slow=False, enhance_asserts=False, split=None,
+        time_balance=True, blacklist=(),
+        fast_threshold=None, slow_threshold=None):
+    """
+    Internal function that actually runs the tests.
+
+    All keyword arguments from ``test()`` are passed to this function except for
+    ``subprocess``.
+
+    Returns 0 if tests passed and 1 if they failed.  See the docstring of
+    ``test()`` for more information.
+    """
+    kw = kw or ()
+    # ensure that kw is a tuple
+    if isinstance(kw, str):
+        kw = (kw,)
+    post_mortem = pdb
+    if seed is None:
+        seed = random.randrange(100000000)
+    if ON_CI and timeout is False:
+        timeout = 595
+        fail_on_timeout = True
+    if ON_CI:
+        blacklist = list(blacklist) + ['sympy/plotting/pygletplot/tests']
+    blacklist = convert_to_native_paths(blacklist)
+    r = PyTestReporter(verbose=verbose, tb=tb, colors=colors,
+        force_colors=force_colors, split=split)
+    # This won't strictly run the test for the corresponding file, but it is
+    # good enough for copying and pasting the failing test.
+    _paths = []
+    for path in paths:
+        if '::' in path:
+            path, _kw = path.split('::', 1)
+            kw += (_kw,)
+        _paths.append(path)
+    paths = _paths
+
+    t = SymPyTests(r, kw, post_mortem, seed,
+                   fast_threshold=fast_threshold,
+                   slow_threshold=slow_threshold)
+
+    test_files = t.get_test_files('sympy')
+
+    not_blacklisted = [f for f in test_files
+                       if not any(b in f for b in blacklist)]
+
+    if len(paths) == 0:
+        matched = not_blacklisted
+    else:
+        paths = convert_to_native_paths(paths)
+        matched = []
+        for f in not_blacklisted:
+            basename = os.path.basename(f)
+            for p in paths:
+                if p in f or fnmatch(basename, p):
+                    matched.append(f)
+                    break
+
+    density = None
+    if time_balance:
+        if slow:
+            density = SPLIT_DENSITY_SLOW
+        else:
+            density = SPLIT_DENSITY
+
+    if split:
+        matched = split_list(matched, split, density=density)
+
+    t._testfiles.extend(matched)
+
+    return int(not t.test(sort=sort, timeout=timeout, slow=slow,
+        enhance_asserts=enhance_asserts, fail_on_timeout=fail_on_timeout))
+
+
+def doctest(*paths, subprocess=True, rerun=0, **kwargs):
+    r"""
+    Runs doctests in all \*.py files in the SymPy directory which match
+    any of the given strings in ``paths`` or all tests if paths=[].
+
+    Notes:
+
+    - Paths can be entered in native system format or in unix,
+      forward-slash format.
+    - Files that are on the blacklist can be tested by providing
+      their path; they are only excluded if no paths are given.
+
+    Examples
+    ========
+
+    >>> import sympy
+
+    Run all tests:
+
+    >>> sympy.doctest() # doctest: +SKIP
+
+    Run one file:
+
+    >>> sympy.doctest("sympy/core/basic.py") # doctest: +SKIP
+    >>> sympy.doctest("polynomial.rst") # doctest: +SKIP
+
+    Run all tests in sympy/functions/ and some particular file:
+
+    >>> sympy.doctest("/functions", "basic.py") # doctest: +SKIP
+
+    Run any file having polynomial in its name, doc/src/modules/polynomial.rst,
+    sympy/functions/special/polynomials.py, and sympy/polys/polynomial.py:
+
+    >>> sympy.doctest("polynomial") # doctest: +SKIP
+
+    The ``split`` option can be passed to split the test run into parts. The
+    split currently only splits the test files, though this may change in the
+    future. ``split`` should be a string of the form 'a/b', which will run
+    part ``a`` of ``b``. Note that the regular doctests and the Sphinx
+    doctests are split independently. For instance, to run the first half of
+    the test suite:
+
+    >>> sympy.doctest(split='1/2')  # doctest: +SKIP
+
+    The ``subprocess`` and ``verbose`` options are the same as with the function
+    ``test()`` (see the docstring of that function for more information) except
+    that ``verbose`` may also be set equal to ``2`` in order to print
+    individual doctest lines, as they are being tested.
+    """
+    # count up from 0, do not print 0
+    print_counter = lambda i : (print("rerun %d" % (rerun-i))
+                                if rerun-i else None)
+
+    if subprocess:
+        # loop backwards so last i is 0
+        for i in range(rerun, -1, -1):
+            print_counter(i)
+            ret = run_in_subprocess_with_hash_randomization("_doctest",
+                        function_args=paths, function_kwargs=kwargs)
+            if ret is False:
+                break
+            val = not bool(ret)
+            # exit on the first failure or if done
+            if not val or i == 0:
+                return val
+
+    # rerun even if hash randomization is not supported
+    for i in range(rerun, -1, -1):
+        print_counter(i)
+        val = not bool(_doctest(*paths, **kwargs))
+        if not val or i == 0:
+            return val
+
+
+def _get_doctest_blacklist():
+    '''Get the default blacklist for the doctests'''
+    blacklist = []
+
+    blacklist.extend([
+        "doc/src/modules/plotting.rst",  # generates live plots
+        "doc/src/modules/physics/mechanics/autolev_parser.rst",
+        "sympy/codegen/array_utils.py", # raises deprecation warning
+        "sympy/core/compatibility.py", # backwards compatibility shim, importing it triggers a deprecation warning
+        "sympy/core/trace.py", # backwards compatibility shim, importing it triggers a deprecation warning
+        "sympy/galgebra.py", # no longer part of SymPy
+        "sympy/parsing/autolev/_antlr/autolevlexer.py", # generated code
+        "sympy/parsing/autolev/_antlr/autolevlistener.py", # generated code
+        "sympy/parsing/autolev/_antlr/autolevparser.py", # generated code
+        "sympy/parsing/latex/_antlr/latexlexer.py", # generated code
+        "sympy/parsing/latex/_antlr/latexparser.py", # generated code
+        "sympy/plotting/pygletplot/__init__.py", # crashes on some systems
+        "sympy/plotting/pygletplot/plot.py", # crashes on some systems
+        "sympy/printing/ccode.py", # backwards compatibility shim, importing it breaks the codegen doctests
+        "sympy/printing/cxxcode.py", # backwards compatibility shim, importing it breaks the codegen doctests
+        "sympy/printing/fcode.py", # backwards compatibility shim, importing it breaks the codegen doctests
+        "sympy/testing/randtest.py", # backwards compatibility shim, importing it triggers a deprecation warning
+        "sympy/this.py", # prints text
+    ])
+    # autolev parser tests
+    num = 12
+    for i in range (1, num+1):
+        blacklist.append("sympy/parsing/autolev/test-examples/ruletest" + str(i) + ".py")
+    blacklist.extend(["sympy/parsing/autolev/test-examples/pydy-example-repo/mass_spring_damper.py",
+                      "sympy/parsing/autolev/test-examples/pydy-example-repo/chaos_pendulum.py",
+                      "sympy/parsing/autolev/test-examples/pydy-example-repo/double_pendulum.py",
+                      "sympy/parsing/autolev/test-examples/pydy-example-repo/non_min_pendulum.py"])
+
+    if import_module('numpy') is None:
+        blacklist.extend([
+            "sympy/plotting/experimental_lambdify.py",
+            "sympy/plotting/plot_implicit.py",
+            "examples/advanced/autowrap_integrators.py",
+            "examples/advanced/autowrap_ufuncify.py",
+            "examples/intermediate/sample.py",
+            "examples/intermediate/mplot2d.py",
+            "examples/intermediate/mplot3d.py",
+            "doc/src/modules/numeric-computation.rst",
+            "doc/src/explanation/best-practices.md",
+            "doc/src/tutorials/physics/biomechanics/biomechanical-model-example.rst",
+            "doc/src/tutorials/physics/biomechanics/biomechanics.rst",
+        ])
+    else:
+        if import_module('matplotlib') is None:
+            blacklist.extend([
+                "examples/intermediate/mplot2d.py",
+                "examples/intermediate/mplot3d.py"
+            ])
+        else:
+            # Use a non-windowed backend, so that the tests work on CI
+            import matplotlib
+            matplotlib.use('Agg')
+
+    if ON_CI or import_module('pyglet') is None:
+        blacklist.extend(["sympy/plotting/pygletplot"])
+
+    if import_module('aesara') is None:
+        blacklist.extend([
+            "sympy/printing/aesaracode.py",
+            "doc/src/modules/numeric-computation.rst",
+        ])
+
+    if import_module('cupy') is None:
+        blacklist.extend([
+            "doc/src/modules/numeric-computation.rst",
+        ])
+
+    if import_module('jax') is None:
+        blacklist.extend([
+            "doc/src/modules/numeric-computation.rst",
+        ])
+
+    if import_module('antlr4') is None:
+        blacklist.extend([
+            "sympy/parsing/autolev/__init__.py",
+            "sympy/parsing/latex/_parse_latex_antlr.py",
+        ])
+
+    if import_module('lfortran') is None:
+        #throws ImportError when lfortran not installed
+        blacklist.extend([
+            "sympy/parsing/sym_expr.py",
+        ])
+
+    if import_module("scipy") is None:
+        # throws ModuleNotFoundError when scipy not installed
+        blacklist.extend([
+            "doc/src/guides/solving/solve-numerically.md",
+            "doc/src/guides/solving/solve-ode.md",
+        ])
+
+    if import_module("numpy") is None:
+        # throws ModuleNotFoundError when numpy not installed
+        blacklist.extend([
+                "doc/src/guides/solving/solve-ode.md",
+                "doc/src/guides/solving/solve-numerically.md",
+        ])
+
+    # disabled because of doctest failures in asmeurer's bot
+    blacklist.extend([
+        "sympy/utilities/autowrap.py",
+        "examples/advanced/autowrap_integrators.py",
+        "examples/advanced/autowrap_ufuncify.py"
+        ])
+
+    blacklist.extend([
+        "sympy/conftest.py", # Depends on pytest
+    ])
+
+    # These are deprecated stubs to be removed:
+    blacklist.extend([
+        "sympy/utilities/tmpfiles.py",
+        "sympy/utilities/pytest.py",
+        "sympy/utilities/runtests.py",
+        "sympy/utilities/quality_unicode.py",
+        "sympy/utilities/randtest.py",
+    ])
+
+    blacklist = convert_to_native_paths(blacklist)
+    return blacklist
+
+
+def _doctest(*paths, **kwargs):
+    """
+    Internal function that actually runs the doctests.
+
+    All keyword arguments from ``doctest()`` are passed to this function
+    except for ``subprocess``.
+
+    Returns 0 if tests passed and 1 if they failed.  See the docstrings of
+    ``doctest()`` and ``test()`` for more information.
+    """
+    from sympy.printing.pretty.pretty import pprint_use_unicode
+    from sympy.printing.pretty import stringpict
+
+    normal = kwargs.get("normal", False)
+    verbose = kwargs.get("verbose", False)
+    colors = kwargs.get("colors", True)
+    force_colors = kwargs.get("force_colors", False)
+    blacklist = kwargs.get("blacklist", [])
+    split  = kwargs.get('split', None)
+
+    blacklist.extend(_get_doctest_blacklist())
+
+    # Use a non-windowed backend, so that the tests work on CI
+    if import_module('matplotlib') is not None:
+        import matplotlib
+        matplotlib.use('Agg')
+
+    # Disable warnings for external modules
+    import sympy.external
+    sympy.external.importtools.WARN_OLD_VERSION = False
+    sympy.external.importtools.WARN_NOT_INSTALLED = False
+
+    # Disable showing up of plots
+    from sympy.plotting.plot import unset_show
+    unset_show()
+
+    r = PyTestReporter(verbose, split=split, colors=colors,\
+                       force_colors=force_colors)
+    t = SymPyDocTests(r, normal)
+
+    test_files = t.get_test_files('sympy')
+    test_files.extend(t.get_test_files('examples', init_only=False))
+
+    not_blacklisted = [f for f in test_files
+                       if not any(b in f for b in blacklist)]
+    if len(paths) == 0:
+        matched = not_blacklisted
+    else:
+        # take only what was requested...but not blacklisted items
+        # and allow for partial match anywhere or fnmatch of name
+        paths = convert_to_native_paths(paths)
+        matched = []
+        for f in not_blacklisted:
+            basename = os.path.basename(f)
+            for p in paths:
+                if p in f or fnmatch(basename, p):
+                    matched.append(f)
+                    break
+
+    matched.sort()
+
+    if split:
+        matched = split_list(matched, split)
+
+    t._testfiles.extend(matched)
+
+    # run the tests and record the result for this *py portion of the tests
+    if t._testfiles:
+        failed = not t.test()
+    else:
+        failed = False
+
+    # N.B.
+    # --------------------------------------------------------------------
+    # Here we test *.rst and *.md files at or below doc/src. Code from these
+    # must be self supporting in terms of imports since there is no importing
+    # of necessary modules by doctest.testfile. If you try to pass *.py files
+    # through this they might fail because they will lack the needed imports
+    # and smarter parsing that can be done with source code.
+    #
+    test_files_rst = t.get_test_files('doc/src', '*.rst', init_only=False)
+    test_files_md = t.get_test_files('doc/src', '*.md', init_only=False)
+    test_files = test_files_rst + test_files_md
+    test_files.sort()
+
+    not_blacklisted = [f for f in test_files
+                       if not any(b in f for b in blacklist)]
+
+    if len(paths) == 0:
+        matched = not_blacklisted
+    else:
+        # Take only what was requested as long as it's not on the blacklist.
+        # Paths were already made native in *py tests so don't repeat here.
+        # There's no chance of having a *py file slip through since we
+        # only have *rst files in test_files.
+        matched = []
+        for f in not_blacklisted:
+            basename = os.path.basename(f)
+            for p in paths:
+                if p in f or fnmatch(basename, p):
+                    matched.append(f)
+                    break
+
+    if split:
+        matched = split_list(matched, split)
+
+    first_report = True
+    for rst_file in matched:
+        if not os.path.isfile(rst_file):
+            continue
+        old_displayhook = sys.displayhook
+        try:
+            use_unicode_prev, wrap_line_prev = setup_pprint()
+            out = sympytestfile(
+                rst_file, module_relative=False, encoding='utf-8',
+                optionflags=pdoctest.ELLIPSIS | pdoctest.NORMALIZE_WHITESPACE |
+                pdoctest.IGNORE_EXCEPTION_DETAIL)
+        finally:
+            # make sure we return to the original displayhook in case some
+            # doctest has changed that
+            sys.displayhook = old_displayhook
+            # The NO_GLOBAL flag overrides the no_global flag to init_printing
+            # if True
+            import sympy.interactive.printing as interactive_printing
+            interactive_printing.NO_GLOBAL = False
+            pprint_use_unicode(use_unicode_prev)
+            stringpict._GLOBAL_WRAP_LINE = wrap_line_prev
+
+        rstfailed, tested = out
+        if tested:
+            failed = rstfailed or failed
+            if first_report:
+                first_report = False
+                msg = 'rst/md doctests start'
+                if not t._testfiles:
+                    r.start(msg=msg)
+                else:
+                    r.write_center(msg)
+                    print()
+            # use as the id, everything past the first 'sympy'
+            file_id = rst_file[rst_file.find('sympy') + len('sympy') + 1:]
+            print(file_id, end=" ")
+                # get at least the name out so it is know who is being tested
+            wid = r.terminal_width - len(file_id) - 1  # update width
+            test_file = '[%s]' % (tested)
+            report = '[%s]' % (rstfailed or 'OK')
+            print(''.join(
+                [test_file, ' '*(wid - len(test_file) - len(report)), report])
+            )
+
+    # the doctests for *py will have printed this message already if there was
+    # a failure, so now only print it if there was intervening reporting by
+    # testing the *rst as evidenced by first_report no longer being True.
+    if not first_report and failed:
+        print()
+        print("DO *NOT* COMMIT!")
+
+    return int(failed)
+
+sp = re.compile(r'([0-9]+)/([1-9][0-9]*)')
+
+def split_list(l, split, density=None):
+    """
+    Splits a list into part a of b
+
+    split should be a string of the form 'a/b'. For instance, '1/3' would give
+    the split one of three.
+
+    If the length of the list is not divisible by the number of splits, the
+    last split will have more items.
+
+    `density` may be specified as a list.  If specified,
+    tests will be balanced so that each split has as equal-as-possible
+    amount of mass according to `density`.
+
+    >>> from sympy.testing.runtests import split_list
+    >>> a = list(range(10))
+    >>> split_list(a, '1/3')
+    [0, 1, 2]
+    >>> split_list(a, '2/3')
+    [3, 4, 5]
+    >>> split_list(a, '3/3')
+    [6, 7, 8, 9]
+    """
+    m = sp.match(split)
+    if not m:
+        raise ValueError("split must be a string of the form a/b where a and b are ints")
+    i, t = map(int, m.groups())
+
+    if not density:
+        return l[(i - 1)*len(l)//t : i*len(l)//t]
+
+    # normalize density
+    tot = sum(density)
+    density = [x / tot for x in density]
+
+    def density_inv(x):
+        """Interpolate the inverse to the cumulative
+        distribution function given by density"""
+        if x <= 0:
+            return 0
+        if x >= sum(density):
+            return 1
+
+        # find the first time the cumulative sum surpasses x
+        # and linearly interpolate
+        cumm = 0
+        for i, d in enumerate(density):
+            cumm += d
+            if cumm >= x:
+                break
+        frac = (d - (cumm - x)) / d
+        return (i + frac) / len(density)
+
+    lower_frac = density_inv((i - 1) / t)
+    higher_frac = density_inv(i / t)
+    return l[int(lower_frac*len(l)) : int(higher_frac*len(l))]
+
+from collections import namedtuple
+SymPyTestResults = namedtuple('SymPyTestResults', 'failed attempted')
+
+def sympytestfile(filename, module_relative=True, name=None, package=None,
+             globs=None, verbose=None, report=True, optionflags=0,
+             extraglobs=None, raise_on_error=False,
+             parser=pdoctest.DocTestParser(), encoding=None):
+
+    """
+    Test examples in the given file.  Return (#failures, #tests).
+
+    Optional keyword arg ``module_relative`` specifies how filenames
+    should be interpreted:
+
+    - If ``module_relative`` is True (the default), then ``filename``
+      specifies a module-relative path.  By default, this path is
+      relative to the calling module's directory; but if the
+      ``package`` argument is specified, then it is relative to that
+      package.  To ensure os-independence, ``filename`` should use
+      "/" characters to separate path segments, and should not
+      be an absolute path (i.e., it may not begin with "/").
+
+    - If ``module_relative`` is False, then ``filename`` specifies an
+      os-specific path.  The path may be absolute or relative (to
+      the current working directory).
+
+    Optional keyword arg ``name`` gives the name of the test; by default
+    use the file's basename.
+
+    Optional keyword argument ``package`` is a Python package or the
+    name of a Python package whose directory should be used as the
+    base directory for a module relative filename.  If no package is
+    specified, then the calling module's directory is used as the base
+    directory for module relative filenames.  It is an error to
+    specify ``package`` if ``module_relative`` is False.
+
+    Optional keyword arg ``globs`` gives a dict to be used as the globals
+    when executing examples; by default, use {}.  A copy of this dict
+    is actually used for each docstring, so that each docstring's
+    examples start with a clean slate.
+
+    Optional keyword arg ``extraglobs`` gives a dictionary that should be
+    merged into the globals that are used to execute examples.  By
+    default, no extra globals are used.
+
+    Optional keyword arg ``verbose`` prints lots of stuff if true, prints
+    only failures if false; by default, it's true iff "-v" is in sys.argv.
+
+    Optional keyword arg ``report`` prints a summary at the end when true,
+    else prints nothing at the end.  In verbose mode, the summary is
+    detailed, else very brief (in fact, empty if all tests passed).
+
+    Optional keyword arg ``optionflags`` or's together module constants,
+    and defaults to 0.  Possible values (see the docs for details):
+
+    - DONT_ACCEPT_TRUE_FOR_1
+    - DONT_ACCEPT_BLANKLINE
+    - NORMALIZE_WHITESPACE
+    - ELLIPSIS
+    - SKIP
+    - IGNORE_EXCEPTION_DETAIL
+    - REPORT_UDIFF
+    - REPORT_CDIFF
+    - REPORT_NDIFF
+    - REPORT_ONLY_FIRST_FAILURE
+
+    Optional keyword arg ``raise_on_error`` raises an exception on the
+    first unexpected exception or failure. This allows failures to be
+    post-mortem debugged.
+
+    Optional keyword arg ``parser`` specifies a DocTestParser (or
+    subclass) that should be used to extract tests from the files.
+
+    Optional keyword arg ``encoding`` specifies an encoding that should
+    be used to convert the file to unicode.
+
+    Advanced tomfoolery:  testmod runs methods of a local instance of
+    class doctest.Tester, then merges the results into (or creates)
+    global Tester instance doctest.master.  Methods of doctest.master
+    can be called directly too, if you want to do something unusual.
+    Passing report=0 to testmod is especially useful then, to delay
+    displaying a summary.  Invoke doctest.master.summarize(verbose)
+    when you're done fiddling.
+    """
+    if package and not module_relative:
+        raise ValueError("Package may only be specified for module-"
+                         "relative paths.")
+
+    # Relativize the path
+    text, filename = pdoctest._load_testfile(
+        filename, package, module_relative, encoding)
+
+    # If no name was given, then use the file's name.
+    if name is None:
+        name = os.path.basename(filename)
+
+    # Assemble the globals.
+    if globs is None:
+        globs = {}
+    else:
+        globs = globs.copy()
+    if extraglobs is not None:
+        globs.update(extraglobs)
+    if '__name__' not in globs:
+        globs['__name__'] = '__main__'
+
+    if raise_on_error:
+        runner = pdoctest.DebugRunner(verbose=verbose, optionflags=optionflags)
+    else:
+        runner = SymPyDocTestRunner(verbose=verbose, optionflags=optionflags)
+        runner._checker = SymPyOutputChecker()
+
+    # Read the file, convert it to a test, and run it.
+    test = parser.get_doctest(text, globs, name, filename, 0)
+    runner.run(test)
+
+    if report:
+        runner.summarize()
+
+    if pdoctest.master is None:
+        pdoctest.master = runner
+    else:
+        pdoctest.master.merge(runner)
+
+    return SymPyTestResults(runner.failures, runner.tries)
+
+
+class SymPyTests:
+
+    def __init__(self, reporter, kw="", post_mortem=False,
+                 seed=None, fast_threshold=None, slow_threshold=None):
+        self._post_mortem = post_mortem
+        self._kw = kw
+        self._count = 0
+        self._root_dir = get_sympy_dir()
+        self._reporter = reporter
+        self._reporter.root_dir(self._root_dir)
+        self._testfiles = []
+        self._seed = seed if seed is not None else random.random()
+
+        # Defaults in seconds, from human / UX design limits
+        # http://www.nngroup.com/articles/response-times-3-important-limits/
+        #
+        # These defaults are *NOT* set in stone as we are measuring different
+        # things, so others feel free to come up with a better yardstick :)
+        if fast_threshold:
+            self._fast_threshold = float(fast_threshold)
+        else:
+            self._fast_threshold = 8
+        if slow_threshold:
+            self._slow_threshold = float(slow_threshold)
+        else:
+            self._slow_threshold = 10
+
+    def test(self, sort=False, timeout=False, slow=False,
+            enhance_asserts=False, fail_on_timeout=False):
+        """
+        Runs the tests returning True if all tests pass, otherwise False.
+
+        If sort=False run tests in random order.
+        """
+        if sort:
+            self._testfiles.sort()
+        elif slow:
+            pass
+        else:
+            random.seed(self._seed)
+            random.shuffle(self._testfiles)
+        self._reporter.start(self._seed)
+        for f in self._testfiles:
+            try:
+                self.test_file(f, sort, timeout, slow,
+                    enhance_asserts, fail_on_timeout)
+            except KeyboardInterrupt:
+                print(" interrupted by user")
+                self._reporter.finish()
+                raise
+        return self._reporter.finish()
+
+    def _enhance_asserts(self, source):
+        from ast import (NodeTransformer, Compare, Name, Store, Load, Tuple,
+            Assign, BinOp, Str, Mod, Assert, parse, fix_missing_locations)
+
+        ops = {"Eq": '==', "NotEq": '!=', "Lt": '<', "LtE": '<=',
+                "Gt": '>', "GtE": '>=', "Is": 'is', "IsNot": 'is not',
+                "In": 'in', "NotIn": 'not in'}
+
+        class Transform(NodeTransformer):
+            def visit_Assert(self, stmt):
+                if isinstance(stmt.test, Compare):
+                    compare = stmt.test
+                    values = [compare.left] + compare.comparators
+                    names = [ "_%s" % i for i, _ in enumerate(values) ]
+                    names_store = [ Name(n, Store()) for n in names ]
+                    names_load = [ Name(n, Load()) for n in names ]
+                    target = Tuple(names_store, Store())
+                    value = Tuple(values, Load())
+                    assign = Assign([target], value)
+                    new_compare = Compare(names_load[0], compare.ops, names_load[1:])
+                    msg_format = "\n%s " + "\n%s ".join([ ops[op.__class__.__name__] for op in compare.ops ]) + "\n%s"
+                    msg = BinOp(Str(msg_format), Mod(), Tuple(names_load, Load()))
+                    test = Assert(new_compare, msg, lineno=stmt.lineno, col_offset=stmt.col_offset)
+                    return [assign, test]
+                else:
+                    return stmt
+
+        tree = parse(source)
+        new_tree = Transform().visit(tree)
+        return fix_missing_locations(new_tree)
+
+    def test_file(self, filename, sort=True, timeout=False, slow=False,
+            enhance_asserts=False, fail_on_timeout=False):
+        reporter = self._reporter
+        funcs = []
+        try:
+            gl = {'__file__': filename}
+            try:
+                open_file = lambda: open(filename, encoding="utf8")
+
+                with open_file() as f:
+                    source = f.read()
+                    if self._kw:
+                        for l in source.splitlines():
+                            if l.lstrip().startswith('def '):
+                                if any(l.lower().find(k.lower()) != -1 for k in self._kw):
+                                    break
+                        else:
+                            return
+
+                if enhance_asserts:
+                    try:
+                        source = self._enhance_asserts(source)
+                    except ImportError:
+                        pass
+
+                code = compile(source, filename, "exec", flags=0, dont_inherit=True)
+                exec(code, gl)
+            except (SystemExit, KeyboardInterrupt):
+                raise
+            except ImportError:
+                reporter.import_error(filename, sys.exc_info())
+                return
+            except Exception:
+                reporter.test_exception(sys.exc_info())
+
+            clear_cache()
+            self._count += 1
+            random.seed(self._seed)
+            disabled = gl.get("disabled", False)
+            if not disabled:
+                # we need to filter only those functions that begin with 'test_'
+                # We have to be careful about decorated functions. As long as
+                # the decorator uses functools.wraps, we can detect it.
+                funcs = []
+                for f in gl:
+                    if (f.startswith("test_") and (inspect.isfunction(gl[f])
+                        or inspect.ismethod(gl[f]))):
+                        func = gl[f]
+                        # Handle multiple decorators
+                        while hasattr(func, '__wrapped__'):
+                            func = func.__wrapped__
+
+                        if inspect.getsourcefile(func) == filename:
+                            funcs.append(gl[f])
+                if slow:
+                    funcs = [f for f in funcs if getattr(f, '_slow', False)]
+                # Sorting of XFAILed functions isn't fixed yet :-(
+                funcs.sort(key=lambda x: inspect.getsourcelines(x)[1])
+                i = 0
+                while i < len(funcs):
+                    if inspect.isgeneratorfunction(funcs[i]):
+                    # some tests can be generators, that return the actual
+                    # test functions. We unpack it below:
+                        f = funcs.pop(i)
+                        for fg in f():
+                            func = fg[0]
+                            args = fg[1:]
+                            fgw = lambda: func(*args)
+                            funcs.insert(i, fgw)
+                            i += 1
+                    else:
+                        i += 1
+                # drop functions that are not selected with the keyword expression:
+                funcs = [x for x in funcs if self.matches(x)]
+
+            if not funcs:
+                return
+        except Exception:
+            reporter.entering_filename(filename, len(funcs))
+            raise
+
+        reporter.entering_filename(filename, len(funcs))
+        if not sort:
+            random.shuffle(funcs)
+
+        for f in funcs:
+            start = time.time()
+            reporter.entering_test(f)
+            try:
+                if getattr(f, '_slow', False) and not slow:
+                    raise Skipped("Slow")
+                with raise_on_deprecated():
+                    if timeout:
+                        self._timeout(f, timeout, fail_on_timeout)
+                    else:
+                        random.seed(self._seed)
+                        f()
+            except KeyboardInterrupt:
+                if getattr(f, '_slow', False):
+                    reporter.test_skip("KeyboardInterrupt")
+                else:
+                    raise
+            except Exception:
+                if timeout:
+                    signal.alarm(0)  # Disable the alarm. It could not be handled before.
+                t, v, tr = sys.exc_info()
+                if t is AssertionError:
+                    reporter.test_fail((t, v, tr))
+                    if self._post_mortem:
+                        pdb.post_mortem(tr)
+                elif t.__name__ == "Skipped":
+                    reporter.test_skip(v)
+                elif t.__name__ == "XFail":
+                    reporter.test_xfail()
+                elif t.__name__ == "XPass":
+                    reporter.test_xpass(v)
+                else:
+                    reporter.test_exception((t, v, tr))
+                    if self._post_mortem:
+                        pdb.post_mortem(tr)
+            else:
+                reporter.test_pass()
+            taken = time.time() - start
+            if taken > self._slow_threshold:
+                filename = os.path.relpath(filename, reporter._root_dir)
+                reporter.slow_test_functions.append(
+                    (filename + "::" + f.__name__, taken))
+            if getattr(f, '_slow', False) and slow:
+                if taken < self._fast_threshold:
+                    filename = os.path.relpath(filename, reporter._root_dir)
+                    reporter.fast_test_functions.append(
+                        (filename + "::" + f.__name__, taken))
+        reporter.leaving_filename()
+
+    def _timeout(self, function, timeout, fail_on_timeout):
+        def callback(x, y):
+            signal.alarm(0)
+            if fail_on_timeout:
+                raise TimeOutError("Timed out after %d seconds" % timeout)
+            else:
+                raise Skipped("Timeout")
+        signal.signal(signal.SIGALRM, callback)
+        signal.alarm(timeout)  # Set an alarm with a given timeout
+        function()
+        signal.alarm(0)  # Disable the alarm
+
+    def matches(self, x):
+        """
+        Does the keyword expression self._kw match "x"? Returns True/False.
+
+        Always returns True if self._kw is "".
+        """
+        if not self._kw:
+            return True
+        for kw in self._kw:
+            if x.__name__.lower().find(kw.lower()) != -1:
+                return True
+        return False
+
+    def get_test_files(self, dir, pat='test_*.py'):
+        """
+        Returns the list of test_*.py (default) files at or below directory
+        ``dir`` relative to the SymPy home directory.
+        """
+        dir = os.path.join(self._root_dir, convert_to_native_paths([dir])[0])
+
+        g = []
+        for path, folders, files in os.walk(dir):
+            g.extend([os.path.join(path, f) for f in files if fnmatch(f, pat)])
+
+        return sorted([os.path.normcase(gi) for gi in g])
+
+
+class SymPyDocTests:
+
+    def __init__(self, reporter, normal):
+        self._count = 0
+        self._root_dir = get_sympy_dir()
+        self._reporter = reporter
+        self._reporter.root_dir(self._root_dir)
+        self._normal = normal
+
+        self._testfiles = []
+
+    def test(self):
+        """
+        Runs the tests and returns True if all tests pass, otherwise False.
+        """
+        self._reporter.start()
+        for f in self._testfiles:
+            try:
+                self.test_file(f)
+            except KeyboardInterrupt:
+                print(" interrupted by user")
+                self._reporter.finish()
+                raise
+        return self._reporter.finish()
+
+    def test_file(self, filename):
+        clear_cache()
+
+        from io import StringIO
+        import sympy.interactive.printing as interactive_printing
+        from sympy.printing.pretty.pretty import pprint_use_unicode
+        from sympy.printing.pretty import stringpict
+
+        rel_name = filename[len(self._root_dir) + 1:]
+        dirname, file = os.path.split(filename)
+        module = rel_name.replace(os.sep, '.')[:-3]
+
+        if rel_name.startswith("examples"):
+            # Examples files do not have __init__.py files,
+            # So we have to temporarily extend sys.path to import them
+            sys.path.insert(0, dirname)
+            module = file[:-3]  # remove ".py"
+        try:
+            module = pdoctest._normalize_module(module)
+            tests = SymPyDocTestFinder().find(module)
+        except (SystemExit, KeyboardInterrupt):
+            raise
+        except ImportError:
+            self._reporter.import_error(filename, sys.exc_info())
+            return
+        finally:
+            if rel_name.startswith("examples"):
+                del sys.path[0]
+
+        tests = [test for test in tests if len(test.examples) > 0]
+        # By default tests are sorted by alphabetical order by function name.
+        # We sort by line number so one can edit the file sequentially from
+        # bottom to top. However, if there are decorated functions, their line
+        # numbers will be too large and for now one must just search for these
+        # by text and function name.
+        tests.sort(key=lambda x: -x.lineno)
+
+        if not tests:
+            return
+        self._reporter.entering_filename(filename, len(tests))
+        for test in tests:
+            assert len(test.examples) != 0
+
+            if self._reporter._verbose:
+                self._reporter.write("\n{} ".format(test.name))
+
+            # check if there are external dependencies which need to be met
+            if '_doctest_depends_on' in test.globs:
+                try:
+                    self._check_dependencies(**test.globs['_doctest_depends_on'])
+                except DependencyError as e:
+                    self._reporter.test_skip(v=str(e))
+                    continue
+
+            runner = SymPyDocTestRunner(verbose=self._reporter._verbose==2,
+                    optionflags=pdoctest.ELLIPSIS |
+                    pdoctest.NORMALIZE_WHITESPACE |
+                    pdoctest.IGNORE_EXCEPTION_DETAIL)
+            runner._checker = SymPyOutputChecker()
+            old = sys.stdout
+            new = old if self._reporter._verbose==2 else StringIO()
+            sys.stdout = new
+            # If the testing is normal, the doctests get importing magic to
+            # provide the global namespace. If not normal (the default) then
+            # then must run on their own; all imports must be explicit within
+            # a function's docstring. Once imported that import will be
+            # available to the rest of the tests in a given function's
+            # docstring (unless clear_globs=True below).
+            if not self._normal:
+                test.globs = {}
+                # if this is uncommented then all the test would get is what
+                # comes by default with a "from sympy import *"
+                #exec('from sympy import *') in test.globs
+            old_displayhook = sys.displayhook
+            use_unicode_prev, wrap_line_prev = setup_pprint()
+
+            try:
+                f, t = runner.run(test,
+                                  out=new.write, clear_globs=False)
+            except KeyboardInterrupt:
+                raise
+            finally:
+                sys.stdout = old
+            if f > 0:
+                self._reporter.doctest_fail(test.name, new.getvalue())
+            else:
+                self._reporter.test_pass()
+                sys.displayhook = old_displayhook
+                interactive_printing.NO_GLOBAL = False
+                pprint_use_unicode(use_unicode_prev)
+                stringpict._GLOBAL_WRAP_LINE = wrap_line_prev
+
+        self._reporter.leaving_filename()
+
+    def get_test_files(self, dir, pat='*.py', init_only=True):
+        r"""
+        Returns the list of \*.py files (default) from which docstrings
+        will be tested which are at or below directory ``dir``. By default,
+        only those that have an __init__.py in their parent directory
+        and do not start with ``test_`` will be included.
+        """
+        def importable(x):
+            """
+            Checks if given pathname x is an importable module by checking for
+            __init__.py file.
+
+            Returns True/False.
+
+            Currently we only test if the __init__.py file exists in the
+            directory with the file "x" (in theory we should also test all the
+            parent dirs).
+            """
+            init_py = os.path.join(os.path.dirname(x), "__init__.py")
+            return os.path.exists(init_py)
+
+        dir = os.path.join(self._root_dir, convert_to_native_paths([dir])[0])
+
+        g = []
+        for path, folders, files in os.walk(dir):
+            g.extend([os.path.join(path, f) for f in files
+                      if not f.startswith('test_') and fnmatch(f, pat)])
+        if init_only:
+            # skip files that are not importable (i.e. missing __init__.py)
+            g = [x for x in g if importable(x)]
+
+        return [os.path.normcase(gi) for gi in g]
+
+    def _check_dependencies(self,
+                            executables=(),
+                            modules=(),
+                            disable_viewers=(),
+                            python_version=(3, 5),
+                            ground_types=None):
+        """
+        Checks if the dependencies for the test are installed.
+
+        Raises ``DependencyError`` it at least one dependency is not installed.
+        """
+
+        for executable in executables:
+            if not shutil.which(executable):
+                raise DependencyError("Could not find %s" % executable)
+
+        for module in modules:
+            if module == 'matplotlib':
+                matplotlib = import_module(
+                    'matplotlib',
+                    import_kwargs={'fromlist':
+                                      ['pyplot', 'cm', 'collections']},
+                    min_module_version='1.0.0', catch=(RuntimeError,))
+                if matplotlib is None:
+                    raise DependencyError("Could not import matplotlib")
+            else:
+                if not import_module(module):
+                    raise DependencyError("Could not import %s" % module)
+
+        if disable_viewers:
+            tempdir = tempfile.mkdtemp()
+            os.environ['PATH'] = '%s:%s' % (tempdir, os.environ['PATH'])
+
+            vw = ('#!/usr/bin/env python3\n'
+                  'import sys\n'
+                  'if len(sys.argv) <= 1:\n'
+                  '    exit("wrong number of args")\n')
+
+            for viewer in disable_viewers:
+                with open(os.path.join(tempdir, viewer), 'w') as fh:
+                    fh.write(vw)
+
+                # make the file executable
+                os.chmod(os.path.join(tempdir, viewer),
+                         stat.S_IREAD | stat.S_IWRITE | stat.S_IXUSR)
+
+        if python_version:
+            if sys.version_info < python_version:
+                raise DependencyError("Requires Python >= " + '.'.join(map(str, python_version)))
+
+        if ground_types is not None:
+            if GROUND_TYPES not in ground_types:
+                raise DependencyError("Requires ground_types in " + str(ground_types))
+
+        if 'pyglet' in modules:
+            # monkey-patch pyglet s.t. it does not open a window during
+            # doctesting
+            import pyglet
+            class DummyWindow:
+                def __init__(self, *args, **kwargs):
+                    self.has_exit = True
+                    self.width = 600
+                    self.height = 400
+
+                def set_vsync(self, x):
+                    pass
+
+                def switch_to(self):
+                    pass
+
+                def push_handlers(self, x):
+                    pass
+
+                def close(self):
+                    pass
+
+            pyglet.window.Window = DummyWindow
+
+
+class SymPyDocTestFinder(DocTestFinder):
+    """
+    A class used to extract the DocTests that are relevant to a given
+    object, from its docstring and the docstrings of its contained
+    objects.  Doctests can currently be extracted from the following
+    object types: modules, functions, classes, methods, staticmethods,
+    classmethods, and properties.
+
+    Modified from doctest's version to look harder for code that
+    appears comes from a different module. For example, the @vectorize
+    decorator makes it look like functions come from multidimensional.py
+    even though their code exists elsewhere.
+    """
+
+    def _find(self, tests, obj, name, module, source_lines, globs, seen):
+        """
+        Find tests for the given object and any contained objects, and
+        add them to ``tests``.
+        """
+        if self._verbose:
+            print('Finding tests in %s' % name)
+
+        # If we've already processed this object, then ignore it.
+        if id(obj) in seen:
+            return
+        seen[id(obj)] = 1
+
+        # Make sure we don't run doctests for classes outside of sympy, such
+        # as in numpy or scipy.
+        if inspect.isclass(obj):
+            if obj.__module__.split('.')[0] != 'sympy':
+                return
+
+        # Find a test for this object, and add it to the list of tests.
+        test = self._get_test(obj, name, module, globs, source_lines)
+        if test is not None:
+            tests.append(test)
+
+        if not self._recurse:
+            return
+
+        # Look for tests in a module's contained objects.
+        if inspect.ismodule(obj):
+            for rawname, val in obj.__dict__.items():
+                # Recurse to functions & classes.
+                if inspect.isfunction(val) or inspect.isclass(val):
+                    # Make sure we don't run doctests functions or classes
+                    # from different modules
+                    if val.__module__ != module.__name__:
+                        continue
+
+                    assert self._from_module(module, val), \
+                        "%s is not in module %s (rawname %s)" % (val, module, rawname)
+
+                    try:
+                        valname = '%s.%s' % (name, rawname)
+                        self._find(tests, val, valname, module,
+                                   source_lines, globs, seen)
+                    except KeyboardInterrupt:
+                        raise
+
+            # Look for tests in a module's __test__ dictionary.
+            for valname, val in getattr(obj, '__test__', {}).items():
+                if not isinstance(valname, str):
+                    raise ValueError("SymPyDocTestFinder.find: __test__ keys "
+                                     "must be strings: %r" %
+                                     (type(valname),))
+                if not (inspect.isfunction(val) or inspect.isclass(val) or
+                        inspect.ismethod(val) or inspect.ismodule(val) or
+                        isinstance(val, str)):
+                    raise ValueError("SymPyDocTestFinder.find: __test__ values "
+                                     "must be strings, functions, methods, "
+                                     "classes, or modules: %r" %
+                                     (type(val),))
+                valname = '%s.__test__.%s' % (name, valname)
+                self._find(tests, val, valname, module, source_lines,
+                           globs, seen)
+
+
+        # Look for tests in a class's contained objects.
+        if inspect.isclass(obj):
+            for valname, val in obj.__dict__.items():
+                # Special handling for staticmethod/classmethod.
+                if isinstance(val, staticmethod):
+                    val = getattr(obj, valname)
+                if isinstance(val, classmethod):
+                    val = getattr(obj, valname).__func__
+
+
+                # Recurse to methods, properties, and nested classes.
+                if ((inspect.isfunction(unwrap(val)) or
+                        inspect.isclass(val) or
+                        isinstance(val, property)) and
+                    self._from_module(module, val)):
+                    # Make sure we don't run doctests functions or classes
+                    # from different modules
+                    if isinstance(val, property):
+                        if hasattr(val.fget, '__module__'):
+                            if val.fget.__module__ != module.__name__:
+                                continue
+                    else:
+                        if val.__module__ != module.__name__:
+                            continue
+
+                    assert self._from_module(module, val), \
+                        "%s is not in module %s (valname %s)" % (
+                            val, module, valname)
+
+                    valname = '%s.%s' % (name, valname)
+                    self._find(tests, val, valname, module, source_lines,
+                               globs, seen)
+
+    def _get_test(self, obj, name, module, globs, source_lines):
+        """
+        Return a DocTest for the given object, if it defines a docstring;
+        otherwise, return None.
+        """
+
+        lineno = None
+
+        # Extract the object's docstring.  If it does not have one,
+        # then return None (no test for this object).
+        if isinstance(obj, str):
+            # obj is a string in the case for objects in the polys package.
+            # Note that source_lines is a binary string (compiled polys
+            # modules), which can't be handled by _find_lineno so determine
+            # the line number here.
+
+            docstring = obj
+
+            matches = re.findall(r"line \d+", name)
+            assert len(matches) == 1, \
+                "string '%s' does not contain lineno " % name
+
+            # NOTE: this is not the exact linenumber but its better than no
+            # lineno ;)
+            lineno = int(matches[0][5:])
+
+        else:
+            docstring = getattr(obj, '__doc__', '')
+            if docstring is None:
+                docstring = ''
+            if not isinstance(docstring, str):
+                docstring = str(docstring)
+
+        # Don't bother if the docstring is empty.
+        if self._exclude_empty and not docstring:
+            return None
+
+        # check that properties have a docstring because _find_lineno
+        # assumes it
+        if isinstance(obj, property):
+            if obj.fget.__doc__ is None:
+                return None
+
+        # Find the docstring's location in the file.
+        if lineno is None:
+            obj = unwrap(obj)
+            # handling of properties is not implemented in _find_lineno so do
+            # it here
+            if hasattr(obj, 'func_closure') and obj.func_closure is not None:
+                tobj = obj.func_closure[0].cell_contents
+            elif isinstance(obj, property):
+                tobj = obj.fget
+            else:
+                tobj = obj
+            lineno = self._find_lineno(tobj, source_lines)
+
+        if lineno is None:
+            return None
+
+        # Return a DocTest for this object.
+        if module is None:
+            filename = None
+        else:
+            filename = getattr(module, '__file__', module.__name__)
+            if filename[-4:] in (".pyc", ".pyo"):
+                filename = filename[:-1]
+
+        globs['_doctest_depends_on'] = getattr(obj, '_doctest_depends_on', {})
+
+        return self._parser.get_doctest(docstring, globs, name,
+                                        filename, lineno)
+
+
+class SymPyDocTestRunner(DocTestRunner):
+    """
+    A class used to run DocTest test cases, and accumulate statistics.
+    The ``run`` method is used to process a single DocTest case.  It
+    returns a tuple ``(f, t)``, where ``t`` is the number of test cases
+    tried, and ``f`` is the number of test cases that failed.
+
+    Modified from the doctest version to not reset the sys.displayhook (see
+    issue 5140).
+
+    See the docstring of the original DocTestRunner for more information.
+    """
+
+    def run(self, test, compileflags=None, out=None, clear_globs=True):
+        """
+        Run the examples in ``test``, and display the results using the
+        writer function ``out``.
+
+        The examples are run in the namespace ``test.globs``.  If
+        ``clear_globs`` is true (the default), then this namespace will
+        be cleared after the test runs, to help with garbage
+        collection.  If you would like to examine the namespace after
+        the test completes, then use ``clear_globs=False``.
+
+        ``compileflags`` gives the set of flags that should be used by
+        the Python compiler when running the examples.  If not
+        specified, then it will default to the set of future-import
+        flags that apply to ``globs``.
+
+        The output of each example is checked using
+        ``SymPyDocTestRunner.check_output``, and the results are
+        formatted by the ``SymPyDocTestRunner.report_*`` methods.
+        """
+        self.test = test
+
+        # Remove ``` from the end of example, which may appear in Markdown
+        # files
+        for example in test.examples:
+            example.want = example.want.replace('```\n', '')
+            example.exc_msg = example.exc_msg and example.exc_msg.replace('```\n', '')
+
+
+        if compileflags is None:
+            compileflags = pdoctest._extract_future_flags(test.globs)
+
+        save_stdout = sys.stdout
+        if out is None:
+            out = save_stdout.write
+        sys.stdout = self._fakeout
+
+        # Patch pdb.set_trace to restore sys.stdout during interactive
+        # debugging (so it's not still redirected to self._fakeout).
+        # Note that the interactive output will go to *our*
+        # save_stdout, even if that's not the real sys.stdout; this
+        # allows us to write test cases for the set_trace behavior.
+        save_set_trace = pdb.set_trace
+        self.debugger = pdoctest._OutputRedirectingPdb(save_stdout)
+        self.debugger.reset()
+        pdb.set_trace = self.debugger.set_trace
+
+        # Patch linecache.getlines, so we can see the example's source
+        # when we're inside the debugger.
+        self.save_linecache_getlines = pdoctest.linecache.getlines
+        linecache.getlines = self.__patched_linecache_getlines
+
+        # Fail for deprecation warnings
+        with raise_on_deprecated():
+            try:
+                return self.__run(test, compileflags, out)
+            finally:
+                sys.stdout = save_stdout
+                pdb.set_trace = save_set_trace
+                linecache.getlines = self.save_linecache_getlines
+                if clear_globs:
+                    test.globs.clear()
+
+
+# We have to override the name mangled methods.
+monkeypatched_methods = [
+    'patched_linecache_getlines',
+    'run',
+    'record_outcome'
+]
+for method in monkeypatched_methods:
+    oldname = '_DocTestRunner__' + method
+    newname = '_SymPyDocTestRunner__' + method
+    setattr(SymPyDocTestRunner, newname, getattr(DocTestRunner, oldname))
+
+
+class SymPyOutputChecker(pdoctest.OutputChecker):
+    """
+    Compared to the OutputChecker from the stdlib our OutputChecker class
+    supports numerical comparison of floats occurring in the output of the
+    doctest examples
+    """
+
+    def __init__(self):
+        # NOTE OutputChecker is an old-style class with no __init__ method,
+        # so we can't call the base class version of __init__ here
+
+        got_floats = r'(\d+\.\d*|\.\d+)'
+
+        # floats in the 'want' string may contain ellipses
+        want_floats = got_floats + r'(\.{3})?'
+
+        front_sep = r'\s|\+|\-|\*|,'
+        back_sep = front_sep + r'|j|e'
+
+        fbeg = r'^%s(?=%s|$)' % (got_floats, back_sep)
+        fmidend = r'(?<=%s)%s(?=%s|$)' % (front_sep, got_floats, back_sep)
+        self.num_got_rgx = re.compile(r'(%s|%s)' %(fbeg, fmidend))
+
+        fbeg = r'^%s(?=%s|$)' % (want_floats, back_sep)
+        fmidend = r'(?<=%s)%s(?=%s|$)' % (front_sep, want_floats, back_sep)
+        self.num_want_rgx = re.compile(r'(%s|%s)' %(fbeg, fmidend))
+
+    def check_output(self, want, got, optionflags):
+        """
+        Return True iff the actual output from an example (`got`)
+        matches the expected output (`want`).  These strings are
+        always considered to match if they are identical; but
+        depending on what option flags the test runner is using,
+        several non-exact match types are also possible.  See the
+        documentation for `TestRunner` for more information about
+        option flags.
+        """
+        # Handle the common case first, for efficiency:
+        # if they're string-identical, always return true.
+        if got == want:
+            return True
+
+        # TODO parse integers as well ?
+        # Parse floats and compare them. If some of the parsed floats contain
+        # ellipses, skip the comparison.
+        matches = self.num_got_rgx.finditer(got)
+        numbers_got = [match.group(1) for match in matches] # list of strs
+        matches = self.num_want_rgx.finditer(want)
+        numbers_want = [match.group(1) for match in matches] # list of strs
+        if len(numbers_got) != len(numbers_want):
+            return False
+
+        if len(numbers_got) > 0:
+            nw_  = []
+            for ng, nw in zip(numbers_got, numbers_want):
+                if '...' in nw:
+                    nw_.append(ng)
+                    continue
+                else:
+                    nw_.append(nw)
+
+                if abs(float(ng)-float(nw)) > 1e-5:
+                    return False
+
+            got = self.num_got_rgx.sub(r'%s', got)
+            got = got % tuple(nw_)
+
+        # <BLANKLINE> can be used as a special sequence to signify a
+        # blank line, unless the DONT_ACCEPT_BLANKLINE flag is used.
+        if not (optionflags & pdoctest.DONT_ACCEPT_BLANKLINE):
+            # Replace <BLANKLINE> in want with a blank line.
+            want = re.sub(r'(?m)^%s\s*?$' % re.escape(pdoctest.BLANKLINE_MARKER),
+                          '', want)
+            # If a line in got contains only spaces, then remove the
+            # spaces.
+            got = re.sub(r'(?m)^\s*?$', '', got)
+            if got == want:
+                return True
+
+        # This flag causes doctest to ignore any differences in the
+        # contents of whitespace strings.  Note that this can be used
+        # in conjunction with the ELLIPSIS flag.
+        if optionflags & pdoctest.NORMALIZE_WHITESPACE:
+            got = ' '.join(got.split())
+            want = ' '.join(want.split())
+            if got == want:
+                return True
+
+        # The ELLIPSIS flag says to let the sequence "..." in `want`
+        # match any substring in `got`.
+        if optionflags & pdoctest.ELLIPSIS:
+            if pdoctest._ellipsis_match(want, got):
+                return True
+
+        # We didn't find any match; return false.
+        return False
+
+
+class Reporter:
+    """
+    Parent class for all reporters.
+    """
+    pass
+
+
+class PyTestReporter(Reporter):
+    """
+    Py.test like reporter. Should produce output identical to py.test.
+    """
+
+    def __init__(self, verbose=False, tb="short", colors=True,
+                 force_colors=False, split=None):
+        self._verbose = verbose
+        self._tb_style = tb
+        self._colors = colors
+        self._force_colors = force_colors
+        self._xfailed = 0
+        self._xpassed = []
+        self._failed = []
+        self._failed_doctest = []
+        self._passed = 0
+        self._skipped = 0
+        self._exceptions = []
+        self._terminal_width = None
+        self._default_width = 80
+        self._split = split
+        self._active_file = ''
+        self._active_f = None
+
+        # TODO: Should these be protected?
+        self.slow_test_functions = []
+        self.fast_test_functions = []
+
+        # this tracks the x-position of the cursor (useful for positioning
+        # things on the screen), without the need for any readline library:
+        self._write_pos = 0
+        self._line_wrap = False
+
+    def root_dir(self, dir):
+        self._root_dir = dir
+
+    @property
+    def terminal_width(self):
+        if self._terminal_width is not None:
+            return self._terminal_width
+
+        def findout_terminal_width():
+            if sys.platform == "win32":
+                # Windows support is based on:
+                #
+                #  http://code.activestate.com/recipes/
+                #  440694-determine-size-of-console-window-on-windows/
+
+                from ctypes import windll, create_string_buffer
+
+                h = windll.kernel32.GetStdHandle(-12)
+                csbi = create_string_buffer(22)
+                res = windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
+
+                if res:
+                    import struct
+                    (_, _, _, _, _, left, _, right, _, _, _) = \
+                        struct.unpack("hhhhHhhhhhh", csbi.raw)
+                    return right - left
+                else:
+                    return self._default_width
+
+            if hasattr(sys.stdout, 'isatty') and not sys.stdout.isatty():
+                return self._default_width  # leave PIPEs alone
+
+            try:
+                process = subprocess.Popen(['stty', '-a'],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE)
+                stdout, stderr = process.communicate()
+                stdout = stdout.decode("utf-8")
+            except OSError:
+                pass
+            else:
+                # We support the following output formats from stty:
+                #
+                # 1) Linux   -> columns 80
+                # 2) OS X    -> 80 columns
+                # 3) Solaris -> columns = 80
+
+                re_linux = r"columns\s+(?P<columns>\d+);"
+                re_osx = r"(?P<columns>\d+)\s*columns;"
+                re_solaris = r"columns\s+=\s+(?P<columns>\d+);"
+
+                for regex in (re_linux, re_osx, re_solaris):
+                    match = re.search(regex, stdout)
+
+                    if match is not None:
+                        columns = match.group('columns')
+
+                        try:
+                            width = int(columns)
+                        except ValueError:
+                            pass
+                        if width != 0:
+                            return width
+
+            return self._default_width
+
+        width = findout_terminal_width()
+        self._terminal_width = width
+
+        return width
+
+    def write(self, text, color="", align="left", width=None,
+              force_colors=False):
+        """
+        Prints a text on the screen.
+
+        It uses sys.stdout.write(), so no readline library is necessary.
+
+        Parameters
+        ==========
+
+        color : choose from the colors below, "" means default color
+        align : "left"/"right", "left" is a normal print, "right" is aligned on
+                the right-hand side of the screen, filled with spaces if
+                necessary
+        width : the screen width
+
+        """
+        color_templates = (
+            ("Black", "0;30"),
+            ("Red", "0;31"),
+            ("Green", "0;32"),
+            ("Brown", "0;33"),
+            ("Blue", "0;34"),
+            ("Purple", "0;35"),
+            ("Cyan", "0;36"),
+            ("LightGray", "0;37"),
+            ("DarkGray", "1;30"),
+            ("LightRed", "1;31"),
+            ("LightGreen", "1;32"),
+            ("Yellow", "1;33"),
+            ("LightBlue", "1;34"),
+            ("LightPurple", "1;35"),
+            ("LightCyan", "1;36"),
+            ("White", "1;37"),
+        )
+
+        colors = {}
+
+        for name, value in color_templates:
+            colors[name] = value
+        c_normal = '\033[0m'
+        c_color = '\033[%sm'
+
+        if width is None:
+            width = self.terminal_width
+
+        if align == "right":
+            if self._write_pos + len(text) > width:
+                # we don't fit on the current line, create a new line
+                self.write("\n")
+            self.write(" "*(width - self._write_pos - len(text)))
+
+        if not self._force_colors and hasattr(sys.stdout, 'isatty') and not \
+                sys.stdout.isatty():
+            # the stdout is not a terminal, this for example happens if the
+            # output is piped to less, e.g. "bin/test | less". In this case,
+            # the terminal control sequences would be printed verbatim, so
+            # don't use any colors.
+            color = ""
+        elif sys.platform == "win32":
+            # Windows consoles don't support ANSI escape sequences
+            color = ""
+        elif not self._colors:
+            color = ""
+
+        if self._line_wrap:
+            if text[0] != "\n":
+                sys.stdout.write("\n")
+
+        # Avoid UnicodeEncodeError when printing out test failures
+        if IS_WINDOWS:
+            text = text.encode('raw_unicode_escape').decode('utf8', 'ignore')
+        elif not sys.stdout.encoding.lower().startswith('utf'):
+            text = text.encode(sys.stdout.encoding, 'backslashreplace'
+                              ).decode(sys.stdout.encoding)
+
+        if color == "":
+            sys.stdout.write(text)
+        else:
+            sys.stdout.write("%s%s%s" %
+                (c_color % colors[color], text, c_normal))
+        sys.stdout.flush()
+        l = text.rfind("\n")
+        if l == -1:
+            self._write_pos += len(text)
+        else:
+            self._write_pos = len(text) - l - 1
+        self._line_wrap = self._write_pos >= width
+        self._write_pos %= width
+
+    def write_center(self, text, delim="="):
+        width = self.terminal_width
+        if text != "":
+            text = " %s " % text
+        idx = (width - len(text)) // 2
+        t = delim*idx + text + delim*(width - idx - len(text))
+        self.write(t + "\n")
+
+    def write_exception(self, e, val, tb):
+        # remove the first item, as that is always runtests.py
+        tb = tb.tb_next
+        t = traceback.format_exception(e, val, tb)
+        self.write("".join(t))
+
+    def start(self, seed=None, msg="test process starts"):
+        self.write_center(msg)
+        executable = sys.executable
+        v = tuple(sys.version_info)
+        python_version = "%s.%s.%s-%s-%s" % v
+        implementation = platform.python_implementation()
+        if implementation == 'PyPy':
+            implementation += " %s.%s.%s-%s-%s" % sys.pypy_version_info
+        self.write("executable:         %s  (%s) [%s]\n" %
+            (executable, python_version, implementation))
+        from sympy.utilities.misc import ARCH
+        self.write("architecture:       %s\n" % ARCH)
+        from sympy.core.cache import USE_CACHE
+        self.write("cache:              %s\n" % USE_CACHE)
+        version = ''
+        if GROUND_TYPES =='gmpy':
+            import gmpy2 as gmpy
+            version = gmpy.version()
+        self.write("ground types:       %s %s\n" % (GROUND_TYPES, version))
+        numpy = import_module('numpy')
+        self.write("numpy:              %s\n" % (None if not numpy else numpy.__version__))
+        if seed is not None:
+            self.write("random seed:        %d\n" % seed)
+        from sympy.utilities.misc import HASH_RANDOMIZATION
+        self.write("hash randomization: ")
+        hash_seed = os.getenv("PYTHONHASHSEED") or '0'
+        if HASH_RANDOMIZATION and (hash_seed == "random" or int(hash_seed)):
+            self.write("on (PYTHONHASHSEED=%s)\n" % hash_seed)
+        else:
+            self.write("off\n")
+        if self._split:
+            self.write("split:              %s\n" % self._split)
+        self.write('\n')
+        self._t_start = clock()
+
+    def finish(self):
+        self._t_end = clock()
+        self.write("\n")
+        global text, linelen
+        text = "tests finished: %d passed, " % self._passed
+        linelen = len(text)
+
+        def add_text(mytext):
+            global text, linelen
+            """Break new text if too long."""
+            if linelen + len(mytext) > self.terminal_width:
+                text += '\n'
+                linelen = 0
+            text += mytext
+            linelen += len(mytext)
+
+        if len(self._failed) > 0:
+            add_text("%d failed, " % len(self._failed))
+        if len(self._failed_doctest) > 0:
+            add_text("%d failed, " % len(self._failed_doctest))
+        if self._skipped > 0:
+            add_text("%d skipped, " % self._skipped)
+        if self._xfailed > 0:
+            add_text("%d expected to fail, " % self._xfailed)
+        if len(self._xpassed) > 0:
+            add_text("%d expected to fail but passed, " % len(self._xpassed))
+        if len(self._exceptions) > 0:
+            add_text("%d exceptions, " % len(self._exceptions))
+        add_text("in %.2f seconds" % (self._t_end - self._t_start))
+
+        if self.slow_test_functions:
+            self.write_center('slowest tests', '_')
+            sorted_slow = sorted(self.slow_test_functions, key=lambda r: r[1])
+            for slow_func_name, taken in sorted_slow:
+                print('%s - Took %.3f seconds' % (slow_func_name, taken))
+
+        if self.fast_test_functions:
+            self.write_center('unexpectedly fast tests', '_')
+            sorted_fast = sorted(self.fast_test_functions,
+                                 key=lambda r: r[1])
+            for fast_func_name, taken in sorted_fast:
+                print('%s - Took %.3f seconds' % (fast_func_name, taken))
+
+        if len(self._xpassed) > 0:
+            self.write_center("xpassed tests", "_")
+            for e in self._xpassed:
+                self.write("%s: %s\n" % (e[0], e[1]))
+            self.write("\n")
+
+        if self._tb_style != "no" and len(self._exceptions) > 0:
+            for e in self._exceptions:
+                filename, f, (t, val, tb) = e
+                self.write_center("", "_")
+                if f is None:
+                    s = "%s" % filename
+                else:
+                    s = "%s:%s" % (filename, f.__name__)
+                self.write_center(s, "_")
+                self.write_exception(t, val, tb)
+            self.write("\n")
+
+        if self._tb_style != "no" and len(self._failed) > 0:
+            for e in self._failed:
+                filename, f, (t, val, tb) = e
+                self.write_center("", "_")
+                self.write_center("%s::%s" % (filename, f.__name__), "_")
+                self.write_exception(t, val, tb)
+            self.write("\n")
+
+        if self._tb_style != "no" and len(self._failed_doctest) > 0:
+            for e in self._failed_doctest:
+                filename, msg = e
+                self.write_center("", "_")
+                self.write_center("%s" % filename, "_")
+                self.write(msg)
+            self.write("\n")
+
+        self.write_center(text)
+        ok = len(self._failed) == 0 and len(self._exceptions) == 0 and \
+            len(self._failed_doctest) == 0
+        if not ok:
+            self.write("DO *NOT* COMMIT!\n")
+        return ok
+
+    def entering_filename(self, filename, n):
+        rel_name = filename[len(self._root_dir) + 1:]
+        self._active_file = rel_name
+        self._active_file_error = False
+        self.write(rel_name)
+        self.write("[%d] " % n)
+
+    def leaving_filename(self):
+        self.write(" ")
+        if self._active_file_error:
+            self.write("[FAIL]", "Red", align="right")
+        else:
+            self.write("[OK]", "Green", align="right")
+        self.write("\n")
+        if self._verbose:
+            self.write("\n")
+
+    def entering_test(self, f):
+        self._active_f = f
+        if self._verbose:
+            self.write("\n" + f.__name__ + " ")
+
+    def test_xfail(self):
+        self._xfailed += 1
+        self.write("f", "Green")
+
+    def test_xpass(self, v):
+        message = str(v)
+        self._xpassed.append((self._active_file, message))
+        self.write("X", "Green")
+
+    def test_fail(self, exc_info):
+        self._failed.append((self._active_file, self._active_f, exc_info))
+        self.write("F", "Red")
+        self._active_file_error = True
+
+    def doctest_fail(self, name, error_msg):
+        # the first line contains "******", remove it:
+        error_msg = "\n".join(error_msg.split("\n")[1:])
+        self._failed_doctest.append((name, error_msg))
+        self.write("F", "Red")
+        self._active_file_error = True
+
+    def test_pass(self, char="."):
+        self._passed += 1
+        if self._verbose:
+            self.write("ok", "Green")
+        else:
+            self.write(char, "Green")
+
+    def test_skip(self, v=None):
+        char = "s"
+        self._skipped += 1
+        if v is not None:
+            message = str(v)
+            if message == "KeyboardInterrupt":
+                char = "K"
+            elif message == "Timeout":
+                char = "T"
+            elif message == "Slow":
+                char = "w"
+        if self._verbose:
+            if v is not None:
+                self.write(message + ' ', "Blue")
+            else:
+                self.write(" - ", "Blue")
+        self.write(char, "Blue")
+
+    def test_exception(self, exc_info):
+        self._exceptions.append((self._active_file, self._active_f, exc_info))
+        if exc_info[0] is TimeOutError:
+            self.write("T", "Red")
+        else:
+            self.write("E", "Red")
+        self._active_file_error = True
+
+    def import_error(self, filename, exc_info):
+        self._exceptions.append((filename, None, exc_info))
+        rel_name = filename[len(self._root_dir) + 1:]
+        self.write(rel_name)
+        self.write("[?]   Failed to import", "Red")
+        self.write(" ")
+        self.write("[FAIL]", "Red", align="right")
+        self.write("\n")

mplug_owl2/lib/python3.10/site-packages/sympy/testing/runtests_pytest.py

@@ -0,0 +1,475 @@
+"""Backwards compatible functions for running tests from SymPy using pytest.
+
+SymPy historically had its own testing framework that aimed to:
+- be compatible with pytest;
+- operate similarly (or identically) to pytest;
+- not require any external dependencies;
+- have all the functionality in one file only;
+- have no magic, just import the test file and execute the test functions; and
+- be portable.
+
+To reduce the maintence burden of developing an independent testing framework
+and to leverage the benefits of existing Python testing infrastructure, SymPy
+now uses pytest (and various of its plugins) to run the test suite.
+
+To maintain backwards compatibility with the legacy testing interface of SymPy,
+which implemented functions that allowed users to run the tests on their
+installed version of SymPy, the functions in this module are implemented to
+match the existing API while thinly wrapping pytest.
+
+These two key functions are `test` and `doctest`.
+
+"""
+
+import functools
+import importlib.util
+import os
+import pathlib
+import re
+from fnmatch import fnmatch
+from typing import List, Optional, Tuple
+
+try:
+    import pytest
+except ImportError:
+
+    class NoPytestError(Exception):
+        """Raise when an internal test helper function is called with pytest."""
+
+    class pytest:  # type: ignore
+        """Shadow to support pytest features when pytest can't be imported."""
+
+        @staticmethod
+        def main(*args, **kwargs):
+            msg = 'pytest must be installed to run tests via this function'
+            raise NoPytestError(msg)
+
+from sympy.testing.runtests import test as test_sympy
+
+
+TESTPATHS_DEFAULT = (
+    pathlib.Path('sympy'),
+    pathlib.Path('doc', 'src'),
+)
+BLACKLIST_DEFAULT = (
+    'sympy/integrals/rubi/rubi_tests/tests',
+)
+
+
+class PytestPluginManager:
+    """Module names for pytest plugins used by SymPy."""
+    PYTEST: str = 'pytest'
+    RANDOMLY: str = 'pytest_randomly'
+    SPLIT: str = 'pytest_split'
+    TIMEOUT: str = 'pytest_timeout'
+    XDIST: str = 'xdist'
+
+    @functools.cached_property
+    def has_pytest(self) -> bool:
+        return bool(importlib.util.find_spec(self.PYTEST))
+
+    @functools.cached_property
+    def has_randomly(self) -> bool:
+        return bool(importlib.util.find_spec(self.RANDOMLY))
+
+    @functools.cached_property
+    def has_split(self) -> bool:
+        return bool(importlib.util.find_spec(self.SPLIT))
+
+    @functools.cached_property
+    def has_timeout(self) -> bool:
+        return bool(importlib.util.find_spec(self.TIMEOUT))
+
+    @functools.cached_property
+    def has_xdist(self) -> bool:
+        return bool(importlib.util.find_spec(self.XDIST))
+
+
+split_pattern = re.compile(r'([1-9][0-9]*)/([1-9][0-9]*)')
+
+
+@functools.lru_cache
+def sympy_dir() -> pathlib.Path:
+    """Returns the root SymPy directory."""
+    return pathlib.Path(__file__).parents[2]
+
+
+def update_args_with_rootdir(args: List[str]) -> List[str]:
+    """Adds `--rootdir` and path to the args `list` passed to `pytest.main`.
+
+    This is required to ensure that pytest is able to find the SymPy tests in
+    instances where it gets confused determining the root directory, e.g. when
+    running with Pyodide (e.g. `bin/test_pyodide.mjs`).
+
+    """
+    args.extend(['--rootdir', str(sympy_dir())])
+    return args
+
+
+def update_args_with_paths(
+    paths: List[str],
+    keywords: Optional[Tuple[str]],
+    args: List[str],
+) -> List[str]:
+    """Appends valid paths and flags to the args `list` passed to `pytest.main`.
+
+    The are three different types of "path" that a user may pass to the `paths`
+    positional arguments, all of which need to be handled slightly differently:
+
+    1. Nothing is passed
+        The paths to the `testpaths` defined in `pytest.ini` need to be appended
+        to the arguments list.
+    2. Full, valid paths are passed
+        These paths need to be validated but can then be directly appended to
+        the arguments list.
+    3. Partial paths are passed.
+        The `testpaths` defined in `pytest.ini` need to be recursed and any
+        matches be appended to the arguments list.
+
+    """
+
+    def find_paths_matching_partial(partial_paths):
+        partial_path_file_patterns = []
+        for partial_path in partial_paths:
+            if len(partial_path) >= 4:
+                has_test_prefix = partial_path[:4] == 'test'
+                has_py_suffix = partial_path[-3:] == '.py'
+            elif len(partial_path) >= 3:
+                has_test_prefix = False
+                has_py_suffix = partial_path[-3:] == '.py'
+            else:
+                has_test_prefix = False
+                has_py_suffix = False
+            if has_test_prefix and has_py_suffix:
+                partial_path_file_patterns.append(partial_path)
+            elif has_test_prefix:
+                partial_path_file_patterns.append(f'{partial_path}*.py')
+            elif has_py_suffix:
+                partial_path_file_patterns.append(f'test*{partial_path}')
+            else:
+                partial_path_file_patterns.append(f'test*{partial_path}*.py')
+        matches = []
+        for testpath in valid_testpaths_default:
+            for path, dirs, files in os.walk(testpath, topdown=True):
+                zipped = zip(partial_paths, partial_path_file_patterns)
+                for (partial_path, partial_path_file) in zipped:
+                    if fnmatch(path, f'*{partial_path}*'):
+                        matches.append(str(pathlib.Path(path)))
+                        dirs[:] = []
+                    else:
+                        for file in files:
+                            if fnmatch(file, partial_path_file):
+                                matches.append(str(pathlib.Path(path, file)))
+        return matches
+
+    def is_tests_file(filepath: str) -> bool:
+        path = pathlib.Path(filepath)
+        if not path.is_file():
+            return False
+        if not path.parts[-1].startswith('test_'):
+            return False
+        if not path.suffix == '.py':
+            return False
+        return True
+
+    def find_tests_matching_keywords(keywords, filepath):
+        matches = []
+        with open(filepath, encoding='utf-8') as tests_file:
+            source = tests_file.read()
+            for line in source.splitlines():
+                if line.lstrip().startswith('def '):
+                    for kw in keywords:
+                        if line.lower().find(kw.lower()) != -1:
+                            test_name = line.split(' ')[1].split('(')[0]
+                            full_test_path = filepath + '::' + test_name
+                            matches.append(full_test_path)
+        return matches
+
+    valid_testpaths_default = []
+    for testpath in TESTPATHS_DEFAULT:
+        absolute_testpath = pathlib.Path(sympy_dir(), testpath)
+        if absolute_testpath.exists():
+            valid_testpaths_default.append(str(absolute_testpath))
+
+    candidate_paths = []
+    if paths:
+        full_paths = []
+        partial_paths = []
+        for path in paths:
+            if pathlib.Path(path).exists():
+                full_paths.append(str(pathlib.Path(sympy_dir(), path)))
+            else:
+                partial_paths.append(path)
+        matched_paths = find_paths_matching_partial(partial_paths)
+        candidate_paths.extend(full_paths)
+        candidate_paths.extend(matched_paths)
+    else:
+        candidate_paths.extend(valid_testpaths_default)
+
+    if keywords is not None and keywords != ():
+        matches = []
+        for path in candidate_paths:
+            if is_tests_file(path):
+                test_matches = find_tests_matching_keywords(keywords, path)
+                matches.extend(test_matches)
+            else:
+                for root, dirnames, filenames in os.walk(path):
+                    for filename in filenames:
+                        absolute_filepath = str(pathlib.Path(root, filename))
+                        if is_tests_file(absolute_filepath):
+                            test_matches = find_tests_matching_keywords(
+                                keywords,
+                                absolute_filepath,
+                            )
+                            matches.extend(test_matches)
+        args.extend(matches)
+    else:
+        args.extend(candidate_paths)
+
+    return args
+
+
+def make_absolute_path(partial_path: str) -> str:
+    """Convert a partial path to an absolute path.
+
+    A path such a `sympy/core` might be needed. However, absolute paths should
+    be used in the arguments to pytest in all cases as it avoids errors that
+    arise from nonexistent paths.
+
+    This function assumes that partial_paths will be passed in such that they
+    begin with the explicit `sympy` directory, i.e. `sympy/...`.
+
+    """
+
+    def is_valid_partial_path(partial_path: str) -> bool:
+        """Assumption that partial paths are defined from the `sympy` root."""
+        return pathlib.Path(partial_path).parts[0] == 'sympy'
+
+    if not is_valid_partial_path(partial_path):
+        msg = (
+            f'Partial path {dir(partial_path)} is invalid, partial paths are '
+            f'expected to be defined with the `sympy` directory as the root.'
+        )
+        raise ValueError(msg)
+
+    absolute_path = str(pathlib.Path(sympy_dir(), partial_path))
+    return absolute_path
+
+
+def test(*paths, subprocess=True, rerun=0, **kwargs):
+    """Interface to run tests via pytest compatible with SymPy's test runner.
+
+    Explanation
+    ===========
+
+    Note that a `pytest.ExitCode`, which is an `enum`, is returned. This is
+    different to the legacy SymPy test runner which would return a `bool`. If
+    all tests sucessfully pass the `pytest.ExitCode.OK` with value `0` is
+    returned, whereas the legacy SymPy test runner would return `True`. In any
+    other scenario, a non-zero `enum` value is returned, whereas the legacy
+    SymPy test runner would return `False`. Users need to, therefore, be careful
+    if treating the pytest exit codes as booleans because
+    `bool(pytest.ExitCode.OK)` evaluates to `False`, the opposite of legacy
+    behaviour.
+
+    Examples
+    ========
+
+    >>> import sympy  # doctest: +SKIP
+
+    Run one file:
+
+    >>> sympy.test('sympy/core/tests/test_basic.py')  # doctest: +SKIP
+    >>> sympy.test('_basic')  # doctest: +SKIP
+
+    Run all tests in sympy/functions/ and some particular file:
+
+    >>> sympy.test("sympy/core/tests/test_basic.py",
+    ...            "sympy/functions")  # doctest: +SKIP
+
+    Run all tests in sympy/core and sympy/utilities:
+
+    >>> sympy.test("/core", "/util")  # doctest: +SKIP
+
+    Run specific test from a file:
+
+    >>> sympy.test("sympy/core/tests/test_basic.py",
+    ...            kw="test_equality")  # doctest: +SKIP
+
+    Run specific test from any file:
+
+    >>> sympy.test(kw="subs")  # doctest: +SKIP
+
+    Run the tests using the legacy SymPy runner:
+
+    >>> sympy.test(use_sympy_runner=True)  # doctest: +SKIP
+
+    Note that this option is slated for deprecation in the near future and is
+    only currently provided to ensure users have an alternative option while the
+    pytest-based runner receives real-world testing.
+
+    Parameters
+    ==========
+    paths : first n positional arguments of strings
+        Paths, both partial and absolute, describing which subset(s) of the test
+        suite are to be run.
+    subprocess : bool, default is True
+        Legacy option, is currently ignored.
+    rerun : int, default is 0
+        Legacy option, is ignored.
+    use_sympy_runner : bool or None, default is None
+        Temporary option to invoke the legacy SymPy test runner instead of
+        `pytest.main`. Will be removed in the near future.
+    verbose : bool, default is False
+        Sets the verbosity of the pytest output. Using `True` will add the
+        `--verbose` option to the pytest call.
+    tb : str, 'auto', 'long', 'short', 'line', 'native', or 'no'
+        Sets the traceback print mode of pytest using the `--tb` option.
+    kw : str
+        Only run tests which match the given substring expression. An expression
+        is a Python evaluatable expression where all names are substring-matched
+        against test names and their parent classes. Example: -k 'test_method or
+        test_other' matches all test functions and classes whose name contains
+        'test_method' or 'test_other', while -k 'not test_method' matches those
+        that don't contain 'test_method' in their names. -k 'not test_method and
+        not test_other' will eliminate the matches. Additionally keywords are
+        matched to classes and functions containing extra names in their
+        'extra_keyword_matches' set, as well as functions which have names
+        assigned directly to them. The matching is case-insensitive.
+    pdb : bool, default is False
+        Start the interactive Python debugger on errors or `KeyboardInterrupt`.
+    colors : bool, default is True
+        Color terminal output.
+    force_colors : bool, default is False
+        Legacy option, is ignored.
+    sort : bool, default is True
+        Run the tests in sorted order. pytest uses a sorted test order by
+        default. Requires pytest-randomly.
+    seed : int
+        Seed to use for random number generation. Requires pytest-randomly.
+    timeout : int, default is 0
+        Timeout in seconds before dumping the stacks. 0 means no timeout.
+        Requires pytest-timeout.
+    fail_on_timeout : bool, default is False
+        Legacy option, is currently ignored.
+    slow : bool, default is False
+        Run the subset of tests marked as `slow`.
+    enhance_asserts : bool, default is False
+        Legacy option, is currently ignored.
+    split : string in form `<SPLIT>/<GROUPS>` or None, default is None
+        Used to split the tests up. As an example, if `split='2/3' is used then
+        only the middle third of tests are run. Requires pytest-split.
+    time_balance : bool, default is True
+        Legacy option, is currently ignored.
+    blacklist : iterable of test paths as strings, default is BLACKLIST_DEFAULT
+        Blacklisted test paths are ignored using the `--ignore` option. Paths
+        may be partial or absolute. If partial then they are matched against
+        all paths in the pytest tests path.
+    parallel : bool, default is False
+        Parallelize the test running using pytest-xdist. If `True` then pytest
+        will automatically detect the number of CPU cores available and use them
+        all. Requires pytest-xdist.
+    store_durations : bool, False
+        Store test durations into the file `.test_durations`. The is used by
+        `pytest-split` to help determine more even splits when more than one
+        test group is being used. Requires pytest-split.
+
+    """
+    # NOTE: to be removed alongside SymPy test runner
+    if kwargs.get('use_sympy_runner', False):
+        kwargs.pop('parallel', False)
+        kwargs.pop('store_durations', False)
+        kwargs.pop('use_sympy_runner', True)
+        if kwargs.get('slow') is None:
+            kwargs['slow'] = False
+        return test_sympy(*paths, subprocess=True, rerun=0, **kwargs)
+
+    pytest_plugin_manager = PytestPluginManager()
+    if not pytest_plugin_manager.has_pytest:
+        pytest.main()
+
+    args = []
+    args = update_args_with_rootdir(args)
+
+    if kwargs.get('verbose', False):
+        args.append('--verbose')
+
+    if tb := kwargs.get('tb'):
+        args.extend(['--tb', tb])
+
+    if kwargs.get('pdb'):
+        args.append('--pdb')
+
+    if not kwargs.get('colors', True):
+        args.extend(['--color', 'no'])
+
+    if seed := kwargs.get('seed'):
+        if not pytest_plugin_manager.has_randomly:
+            msg = '`pytest-randomly` plugin required to control random seed.'
+            raise ModuleNotFoundError(msg)
+        args.extend(['--randomly-seed', str(seed)])
+
+    if kwargs.get('sort', True) and pytest_plugin_manager.has_randomly:
+        args.append('--randomly-dont-reorganize')
+    elif not kwargs.get('sort', True) and not pytest_plugin_manager.has_randomly:
+        msg = '`pytest-randomly` plugin required to randomize test order.'
+        raise ModuleNotFoundError(msg)
+
+    if timeout := kwargs.get('timeout', None):
+        if not pytest_plugin_manager.has_timeout:
+            msg = '`pytest-timeout` plugin required to apply timeout to tests.'
+            raise ModuleNotFoundError(msg)
+        args.extend(['--timeout', str(int(timeout))])
+
+    # Skip slow tests by default and always skip tooslow tests
+    if kwargs.get('slow', False):
+        args.extend(['-m', 'slow and not tooslow'])
+    else:
+        args.extend(['-m', 'not slow and not tooslow'])
+
+    if (split := kwargs.get('split')) is not None:
+        if not pytest_plugin_manager.has_split:
+            msg = '`pytest-split` plugin required to run tests as groups.'
+            raise ModuleNotFoundError(msg)
+        match = split_pattern.match(split)
+        if not match:
+            msg = ('split must be a string of the form a/b where a and b are '
+                   'positive nonzero ints')
+            raise ValueError(msg)
+        group, splits = map(str, match.groups())
+        args.extend(['--group', group, '--splits', splits])
+        if group > splits:
+            msg = (f'cannot have a group number {group} with only {splits} '
+                   'splits')
+            raise ValueError(msg)
+
+    if blacklist := kwargs.get('blacklist', BLACKLIST_DEFAULT):
+        for path in blacklist:
+            args.extend(['--ignore', make_absolute_path(path)])
+
+    if kwargs.get('parallel', False):
+        if not pytest_plugin_manager.has_xdist:
+            msg = '`pytest-xdist` plugin required to run tests in parallel.'
+            raise ModuleNotFoundError(msg)
+        args.extend(['-n', 'auto'])
+
+    if kwargs.get('store_durations', False):
+        if not pytest_plugin_manager.has_split:
+            msg = '`pytest-split` plugin required to store test durations.'
+            raise ModuleNotFoundError(msg)
+        args.append('--store-durations')
+
+    if (keywords := kwargs.get('kw')) is not None:
+        keywords = tuple(str(kw) for kw in keywords)
+    else:
+        keywords = ()
+
+    args = update_args_with_paths(paths, keywords, args)
+    exit_code = pytest.main(args)
+    return exit_code
+
+
+def doctest():
+    """Interface to run doctests via pytest compatible with SymPy's test runner.
+    """
+    raise NotImplementedError

mplug_owl2/lib/python3.10/site-packages/sympy/testing/tests/test_pytest.py

@@ -0,0 +1,211 @@
+import warnings
+
+from sympy.testing.pytest import (raises, warns, ignore_warnings,
+                                    warns_deprecated_sympy, Failed)
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+
+
+# Test callables
+
+
+def test_expected_exception_is_silent_callable():
+    def f():
+        raise ValueError()
+    raises(ValueError, f)
+
+
+# Under pytest raises will raise Failed rather than AssertionError
+def test_lack_of_exception_triggers_AssertionError_callable():
+    try:
+        raises(Exception, lambda: 1 + 1)
+        assert False
+    except Failed as e:
+        assert "DID NOT RAISE" in str(e)
+
+
+def test_unexpected_exception_is_passed_through_callable():
+    def f():
+        raise ValueError("some error message")
+    try:
+        raises(TypeError, f)
+        assert False
+    except ValueError as e:
+        assert str(e) == "some error message"
+
+# Test with statement
+
+def test_expected_exception_is_silent_with():
+    with raises(ValueError):
+        raise ValueError()
+
+
+def test_lack_of_exception_triggers_AssertionError_with():
+    try:
+        with raises(Exception):
+            1 + 1
+        assert False
+    except Failed as e:
+        assert "DID NOT RAISE" in str(e)
+
+
+def test_unexpected_exception_is_passed_through_with():
+    try:
+        with raises(TypeError):
+            raise ValueError("some error message")
+        assert False
+    except ValueError as e:
+        assert str(e) == "some error message"
+
+# Now we can use raises() instead of try/catch
+# to test that a specific exception class is raised
+
+
+def test_second_argument_should_be_callable_or_string():
+    raises(TypeError, lambda: raises("irrelevant", 42))
+
+
+def test_warns_catches_warning():
+    with warnings.catch_warnings(record=True) as w:
+        with warns(UserWarning):
+            warnings.warn('this is the warning message')
+        assert len(w) == 0
+
+
+def test_warns_raises_without_warning():
+    with raises(Failed):
+        with warns(UserWarning):
+            pass
+
+
+def test_warns_hides_other_warnings():
+    with raises(RuntimeWarning):
+        with warns(UserWarning):
+            warnings.warn('this is the warning message', UserWarning)
+            warnings.warn('this is the other message', RuntimeWarning)
+
+
+def test_warns_continues_after_warning():
+    with warnings.catch_warnings(record=True) as w:
+        finished = False
+        with warns(UserWarning):
+            warnings.warn('this is the warning message')
+            finished = True
+        assert finished
+        assert len(w) == 0
+
+
+def test_warns_many_warnings():
+    with warns(UserWarning):
+        warnings.warn('this is the warning message', UserWarning)
+        warnings.warn('this is the other warning message', UserWarning)
+
+
+def test_warns_match_matching():
+    with warnings.catch_warnings(record=True) as w:
+        with warns(UserWarning, match='this is the warning message'):
+            warnings.warn('this is the warning message', UserWarning)
+        assert len(w) == 0
+
+
+def test_warns_match_non_matching():
+    with warnings.catch_warnings(record=True) as w:
+        with raises(Failed):
+            with warns(UserWarning, match='this is the warning message'):
+                warnings.warn('this is not the expected warning message', UserWarning)
+        assert len(w) == 0
+
+def _warn_sympy_deprecation(stacklevel=3):
+    sympy_deprecation_warning(
+        "feature",
+        active_deprecations_target="active-deprecations",
+        deprecated_since_version="0.0.0",
+        stacklevel=stacklevel,
+    )
+
+def test_warns_deprecated_sympy_catches_warning():
+    with warnings.catch_warnings(record=True) as w:
+        with warns_deprecated_sympy():
+            _warn_sympy_deprecation()
+        assert len(w) == 0
+
+
+def test_warns_deprecated_sympy_raises_without_warning():
+    with raises(Failed):
+        with warns_deprecated_sympy():
+            pass
+
+def test_warns_deprecated_sympy_wrong_stacklevel():
+    with raises(Failed):
+        with warns_deprecated_sympy():
+            _warn_sympy_deprecation(stacklevel=1)
+
+def test_warns_deprecated_sympy_doesnt_hide_other_warnings():
+    # Unlike pytest's deprecated_call, we should not hide other warnings.
+    with raises(RuntimeWarning):
+        with warns_deprecated_sympy():
+            _warn_sympy_deprecation()
+            warnings.warn('this is the other message', RuntimeWarning)
+
+
+def test_warns_deprecated_sympy_continues_after_warning():
+    with warnings.catch_warnings(record=True) as w:
+        finished = False
+        with warns_deprecated_sympy():
+            _warn_sympy_deprecation()
+            finished = True
+        assert finished
+        assert len(w) == 0
+
+def test_ignore_ignores_warning():
+    with warnings.catch_warnings(record=True) as w:
+        with ignore_warnings(UserWarning):
+            warnings.warn('this is the warning message')
+        assert len(w) == 0
+
+
+def test_ignore_does_not_raise_without_warning():
+    with warnings.catch_warnings(record=True) as w:
+        with ignore_warnings(UserWarning):
+            pass
+        assert len(w) == 0
+
+
+def test_ignore_allows_other_warnings():
+    with warnings.catch_warnings(record=True) as w:
+        # This is needed when pytest is run as -Werror
+        # the setting is reverted at the end of the catch_Warnings block.
+        warnings.simplefilter("always")
+        with ignore_warnings(UserWarning):
+            warnings.warn('this is the warning message', UserWarning)
+            warnings.warn('this is the other message', RuntimeWarning)
+        assert len(w) == 1
+        assert isinstance(w[0].message, RuntimeWarning)
+        assert str(w[0].message) == 'this is the other message'
+
+
+def test_ignore_continues_after_warning():
+    with warnings.catch_warnings(record=True) as w:
+        finished = False
+        with ignore_warnings(UserWarning):
+            warnings.warn('this is the warning message')
+            finished = True
+        assert finished
+        assert len(w) == 0
+
+
+def test_ignore_many_warnings():
+    with warnings.catch_warnings(record=True) as w:
+        # This is needed when pytest is run as -Werror
+        # the setting is reverted at the end of the catch_Warnings block.
+        warnings.simplefilter("always")
+        with ignore_warnings(UserWarning):
+            warnings.warn('this is the warning message', UserWarning)
+            warnings.warn('this is the other message', RuntimeWarning)
+            warnings.warn('this is the warning message', UserWarning)
+            warnings.warn('this is the other message', RuntimeWarning)
+            warnings.warn('this is the other message', RuntimeWarning)
+        assert len(w) == 3
+        for wi in w:
+            assert isinstance(wi.message, RuntimeWarning)
+            assert str(wi.message) == 'this is the other message'

mplug_owl2/lib/python3.10/site-packages/sympy/testing/tmpfiles.py

@@ -0,0 +1,46 @@
+"""
+This module adds context manager for temporary files generated by the tests.
+"""
+
+import shutil
+import os
+
+
+class TmpFileManager:
+    """
+    A class to track record of every temporary files created by the tests.
+    """
+    tmp_files = set('')
+    tmp_folders = set('')
+
+    @classmethod
+    def tmp_file(cls, name=''):
+        cls.tmp_files.add(name)
+        return name
+
+    @classmethod
+    def tmp_folder(cls, name=''):
+        cls.tmp_folders.add(name)
+        return name
+
+    @classmethod
+    def cleanup(cls):
+        while cls.tmp_files:
+            file = cls.tmp_files.pop()
+            if os.path.isfile(file):
+                os.remove(file)
+        while cls.tmp_folders:
+            folder = cls.tmp_folders.pop()
+            shutil.rmtree(folder)
+
+def cleanup_tmp_files(test_func):
+    """
+    A decorator to help test codes remove temporary files after the tests.
+    """
+    def wrapper_function():
+        try:
+            test_func()
+        finally:
+            TmpFileManager.cleanup()
+
+    return wrapper_function

mplug_owl2/lib/python3.10/site-packages/sympy/vector/tests/test_coordsysrect.py

@@ -0,0 +1,464 @@
+from sympy.testing.pytest import raises
+from sympy.vector.coordsysrect import CoordSys3D
+from sympy.vector.scalar import BaseScalar
+from sympy.core.function import expand
+from sympy.core.numbers import pi
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.hyperbolic import (cosh, sinh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, atan2, cos, sin)
+from sympy.matrices.dense import zeros
+from sympy.matrices.immutable import ImmutableDenseMatrix as Matrix
+from sympy.simplify.simplify import simplify
+from sympy.vector.functions import express
+from sympy.vector.point import Point
+from sympy.vector.vector import Vector
+from sympy.vector.orienters import (AxisOrienter, BodyOrienter,
+                                    SpaceOrienter, QuaternionOrienter)
+
+
+x, y, z = symbols('x y z')
+a, b, c, q = symbols('a b c q')
+q1, q2, q3, q4 = symbols('q1 q2 q3 q4')
+
+
+def test_func_args():
+    A = CoordSys3D('A')
+    assert A.x.func(*A.x.args) == A.x
+    expr = 3*A.x + 4*A.y
+    assert expr.func(*expr.args) == expr
+    assert A.i.func(*A.i.args) == A.i
+    v = A.x*A.i + A.y*A.j + A.z*A.k
+    assert v.func(*v.args) == v
+    assert A.origin.func(*A.origin.args) == A.origin
+
+
+def test_coordsys3d_equivalence():
+    A = CoordSys3D('A')
+    A1 = CoordSys3D('A')
+    assert A1 == A
+    B = CoordSys3D('B')
+    assert A != B
+
+
+def test_orienters():
+    A = CoordSys3D('A')
+    axis_orienter = AxisOrienter(a, A.k)
+    body_orienter = BodyOrienter(a, b, c, '123')
+    space_orienter = SpaceOrienter(a, b, c, '123')
+    q_orienter = QuaternionOrienter(q1, q2, q3, q4)
+    assert axis_orienter.rotation_matrix(A) == Matrix([
+        [ cos(a), sin(a), 0],
+        [-sin(a), cos(a), 0],
+        [      0,      0, 1]])
+    assert body_orienter.rotation_matrix() == Matrix([
+        [ cos(b)*cos(c),  sin(a)*sin(b)*cos(c) + sin(c)*cos(a),
+          sin(a)*sin(c) - sin(b)*cos(a)*cos(c)],
+        [-sin(c)*cos(b), -sin(a)*sin(b)*sin(c) + cos(a)*cos(c),
+         sin(a)*cos(c) + sin(b)*sin(c)*cos(a)],
+        [        sin(b),                        -sin(a)*cos(b),
+                 cos(a)*cos(b)]])
+    assert space_orienter.rotation_matrix() == Matrix([
+        [cos(b)*cos(c), sin(c)*cos(b),       -sin(b)],
+        [sin(a)*sin(b)*cos(c) - sin(c)*cos(a),
+         sin(a)*sin(b)*sin(c) + cos(a)*cos(c), sin(a)*cos(b)],
+        [sin(a)*sin(c) + sin(b)*cos(a)*cos(c), -sin(a)*cos(c) +
+         sin(b)*sin(c)*cos(a), cos(a)*cos(b)]])
+    assert q_orienter.rotation_matrix() == Matrix([
+        [q1**2 + q2**2 - q3**2 - q4**2, 2*q1*q4 + 2*q2*q3,
+         -2*q1*q3 + 2*q2*q4],
+        [-2*q1*q4 + 2*q2*q3, q1**2 - q2**2 + q3**2 - q4**2,
+         2*q1*q2 + 2*q3*q4],
+        [2*q1*q3 + 2*q2*q4,
+         -2*q1*q2 + 2*q3*q4, q1**2 - q2**2 - q3**2 + q4**2]])
+
+
+def test_coordinate_vars():
+    """
+    Tests the coordinate variables functionality with respect to
+    reorientation of coordinate systems.
+    """
+    A = CoordSys3D('A')
+    # Note that the name given on the lhs is different from A.x._name
+    assert BaseScalar(0, A, 'A_x', r'\mathbf{{x}_{A}}') == A.x
+    assert BaseScalar(1, A, 'A_y', r'\mathbf{{y}_{A}}') == A.y
+    assert BaseScalar(2, A, 'A_z', r'\mathbf{{z}_{A}}') == A.z
+    assert BaseScalar(0, A, 'A_x', r'\mathbf{{x}_{A}}').__hash__() == A.x.__hash__()
+    assert isinstance(A.x, BaseScalar) and \
+           isinstance(A.y, BaseScalar) and \
+           isinstance(A.z, BaseScalar)
+    assert A.x*A.y == A.y*A.x
+    assert A.scalar_map(A) == {A.x: A.x, A.y: A.y, A.z: A.z}
+    assert A.x.system == A
+    assert A.x.diff(A.x) == 1
+    B = A.orient_new_axis('B', q, A.k)
+    assert B.scalar_map(A) == {B.z: A.z, B.y: -A.x*sin(q) + A.y*cos(q),
+                                 B.x: A.x*cos(q) + A.y*sin(q)}
+    assert A.scalar_map(B) == {A.x: B.x*cos(q) - B.y*sin(q),
+                                 A.y: B.x*sin(q) + B.y*cos(q), A.z: B.z}
+    assert express(B.x, A, variables=True) == A.x*cos(q) + A.y*sin(q)
+    assert express(B.y, A, variables=True) == -A.x*sin(q) + A.y*cos(q)
+    assert express(B.z, A, variables=True) == A.z
+    assert expand(express(B.x*B.y*B.z, A, variables=True)) == \
+           expand(A.z*(-A.x*sin(q) + A.y*cos(q))*(A.x*cos(q) + A.y*sin(q)))
+    assert express(B.x*B.i + B.y*B.j + B.z*B.k, A) == \
+           (B.x*cos(q) - B.y*sin(q))*A.i + (B.x*sin(q) + \
+           B.y*cos(q))*A.j + B.z*A.k
+    assert simplify(express(B.x*B.i + B.y*B.j + B.z*B.k, A, \
+                            variables=True)) == \
+           A.x*A.i + A.y*A.j + A.z*A.k
+    assert express(A.x*A.i + A.y*A.j + A.z*A.k, B) == \
+           (A.x*cos(q) + A.y*sin(q))*B.i + \
+           (-A.x*sin(q) + A.y*cos(q))*B.j + A.z*B.k
+    assert simplify(express(A.x*A.i + A.y*A.j + A.z*A.k, B, \
+                            variables=True)) == \
+           B.x*B.i + B.y*B.j + B.z*B.k
+    N = B.orient_new_axis('N', -q, B.k)
+    assert N.scalar_map(A) == \
+           {N.x: A.x, N.z: A.z, N.y: A.y}
+    C = A.orient_new_axis('C', q, A.i + A.j + A.k)
+    mapping = A.scalar_map(C)
+    assert mapping[A.x].equals(C.x*(2*cos(q) + 1)/3 +
+                            C.y*(-2*sin(q + pi/6) + 1)/3 +
+                            C.z*(-2*cos(q + pi/3) + 1)/3)
+    assert mapping[A.y].equals(C.x*(-2*cos(q + pi/3) + 1)/3 +
+                            C.y*(2*cos(q) + 1)/3 +
+                            C.z*(-2*sin(q + pi/6) + 1)/3)
+    assert mapping[A.z].equals(C.x*(-2*sin(q + pi/6) + 1)/3 +
+                            C.y*(-2*cos(q + pi/3) + 1)/3 +
+                            C.z*(2*cos(q) + 1)/3)
+    D = A.locate_new('D', a*A.i + b*A.j + c*A.k)
+    assert D.scalar_map(A) == {D.z: A.z - c, D.x: A.x - a, D.y: A.y - b}
+    E = A.orient_new_axis('E', a, A.k, a*A.i + b*A.j + c*A.k)
+    assert A.scalar_map(E) == {A.z: E.z + c,
+                               A.x: E.x*cos(a) - E.y*sin(a) + a,
+                               A.y: E.x*sin(a) + E.y*cos(a) + b}
+    assert E.scalar_map(A) == {E.x: (A.x - a)*cos(a) + (A.y - b)*sin(a),
+                               E.y: (-A.x + a)*sin(a) + (A.y - b)*cos(a),
+                               E.z: A.z - c}
+    F = A.locate_new('F', Vector.zero)
+    assert A.scalar_map(F) == {A.z: F.z, A.x: F.x, A.y: F.y}
+
+
+def test_rotation_matrix():
+    N = CoordSys3D('N')
+    A = N.orient_new_axis('A', q1, N.k)
+    B = A.orient_new_axis('B', q2, A.i)
+    C = B.orient_new_axis('C', q3, B.j)
+    D = N.orient_new_axis('D', q4, N.j)
+    E = N.orient_new_space('E', q1, q2, q3, '123')
+    F = N.orient_new_quaternion('F', q1, q2, q3, q4)
+    G = N.orient_new_body('G', q1, q2, q3, '123')
+    assert N.rotation_matrix(C) == Matrix([
+        [- sin(q1) * sin(q2) * sin(q3) + cos(q1) * cos(q3), - sin(q1) *
+        cos(q2), sin(q1) * sin(q2) * cos(q3) + sin(q3) * cos(q1)], \
+        [sin(q1) * cos(q3) + sin(q2) * sin(q3) * cos(q1), \
+         cos(q1) * cos(q2), sin(q1) * sin(q3) - sin(q2) * cos(q1) * \
+         cos(q3)], [- sin(q3) * cos(q2), sin(q2), cos(q2) * cos(q3)]])
+    test_mat = D.rotation_matrix(C) - Matrix(
+        [[cos(q1) * cos(q3) * cos(q4) - sin(q3) * (- sin(q4) * cos(q2) +
+        sin(q1) * sin(q2) * cos(q4)), - sin(q2) * sin(q4) - sin(q1) *
+            cos(q2) * cos(q4), sin(q3) * cos(q1) * cos(q4) + cos(q3) * \
+          (- sin(q4) * cos(q2) + sin(q1) * sin(q2) * cos(q4))], \
+         [sin(q1) * cos(q3) + sin(q2) * sin(q3) * cos(q1), cos(q1) * \
+          cos(q2), sin(q1) * sin(q3) - sin(q2) * cos(q1) * cos(q3)], \
+         [sin(q4) * cos(q1) * cos(q3) - sin(q3) * (cos(q2) * cos(q4) + \
+                                                   sin(q1) * sin(q2) * \
+                                                   sin(q4)), sin(q2) *
+                cos(q4) - sin(q1) * sin(q4) * cos(q2), sin(q3) * \
+          sin(q4) * cos(q1) + cos(q3) * (cos(q2) * cos(q4) + \
+                                         sin(q1) * sin(q2) * sin(q4))]])
+    assert test_mat.expand() == zeros(3, 3)
+    assert E.rotation_matrix(N) == Matrix(
+        [[cos(q2)*cos(q3), sin(q3)*cos(q2), -sin(q2)],
+        [sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1), \
+         sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3), sin(q1)*cos(q2)], \
+         [sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3), - \
+          sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1), cos(q1)*cos(q2)]])
+    assert F.rotation_matrix(N) == Matrix([[
+        q1**2 + q2**2 - q3**2 - q4**2,
+        2*q1*q4 + 2*q2*q3, -2*q1*q3 + 2*q2*q4],[ -2*q1*q4 + 2*q2*q3,
+            q1**2 - q2**2 + q3**2 - q4**2, 2*q1*q2 + 2*q3*q4],
+                                           [2*q1*q3 + 2*q2*q4,
+                                            -2*q1*q2 + 2*q3*q4,
+                                q1**2 - q2**2 - q3**2 + q4**2]])
+    assert G.rotation_matrix(N) == Matrix([[
+        cos(q2)*cos(q3),  sin(q1)*sin(q2)*cos(q3) + sin(q3)*cos(q1),
+        sin(q1)*sin(q3) - sin(q2)*cos(q1)*cos(q3)], [
+            -sin(q3)*cos(q2), -sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3),
+            sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1)],[
+                sin(q2), -sin(q1)*cos(q2), cos(q1)*cos(q2)]])
+
+
+def test_vector_with_orientation():
+    """
+    Tests the effects of orientation of coordinate systems on
+    basic vector operations.
+    """
+    N = CoordSys3D('N')
+    A = N.orient_new_axis('A', q1, N.k)
+    B = A.orient_new_axis('B', q2, A.i)
+    C = B.orient_new_axis('C', q3, B.j)
+
+    # Test to_matrix
+    v1 = a*N.i + b*N.j + c*N.k
+    assert v1.to_matrix(A) == Matrix([[ a*cos(q1) + b*sin(q1)],
+                                      [-a*sin(q1) + b*cos(q1)],
+                                      [                     c]])
+
+    # Test dot
+    assert N.i.dot(A.i) == cos(q1)
+    assert N.i.dot(A.j) == -sin(q1)
+    assert N.i.dot(A.k) == 0
+    assert N.j.dot(A.i) == sin(q1)
+    assert N.j.dot(A.j) == cos(q1)
+    assert N.j.dot(A.k) == 0
+    assert N.k.dot(A.i) == 0
+    assert N.k.dot(A.j) == 0
+    assert N.k.dot(A.k) == 1
+
+    assert N.i.dot(A.i + A.j) == -sin(q1) + cos(q1) == \
+           (A.i + A.j).dot(N.i)
+
+    assert A.i.dot(C.i) == cos(q3)
+    assert A.i.dot(C.j) == 0
+    assert A.i.dot(C.k) == sin(q3)
+    assert A.j.dot(C.i) == sin(q2)*sin(q3)
+    assert A.j.dot(C.j) == cos(q2)
+    assert A.j.dot(C.k) == -sin(q2)*cos(q3)
+    assert A.k.dot(C.i) == -cos(q2)*sin(q3)
+    assert A.k.dot(C.j) == sin(q2)
+    assert A.k.dot(C.k) == cos(q2)*cos(q3)
+
+    # Test cross
+    assert N.i.cross(A.i) == sin(q1)*A.k
+    assert N.i.cross(A.j) == cos(q1)*A.k
+    assert N.i.cross(A.k) == -sin(q1)*A.i - cos(q1)*A.j
+    assert N.j.cross(A.i) == -cos(q1)*A.k
+    assert N.j.cross(A.j) == sin(q1)*A.k
+    assert N.j.cross(A.k) == cos(q1)*A.i - sin(q1)*A.j
+    assert N.k.cross(A.i) == A.j
+    assert N.k.cross(A.j) == -A.i
+    assert N.k.cross(A.k) == Vector.zero
+
+    assert N.i.cross(A.i) == sin(q1)*A.k
+    assert N.i.cross(A.j) == cos(q1)*A.k
+    assert N.i.cross(A.i + A.j) == sin(q1)*A.k + cos(q1)*A.k
+    assert (A.i + A.j).cross(N.i) == (-sin(q1) - cos(q1))*N.k
+
+    assert A.i.cross(C.i) == sin(q3)*C.j
+    assert A.i.cross(C.j) == -sin(q3)*C.i + cos(q3)*C.k
+    assert A.i.cross(C.k) == -cos(q3)*C.j
+    assert C.i.cross(A.i) == (-sin(q3)*cos(q2))*A.j + \
+           (-sin(q2)*sin(q3))*A.k
+    assert C.j.cross(A.i) == (sin(q2))*A.j + (-cos(q2))*A.k
+    assert express(C.k.cross(A.i), C).trigsimp() == cos(q3)*C.j
+
+
+def test_orient_new_methods():
+    N = CoordSys3D('N')
+    orienter1 = AxisOrienter(q4, N.j)
+    orienter2 = SpaceOrienter(q1, q2, q3, '123')
+    orienter3 = QuaternionOrienter(q1, q2, q3, q4)
+    orienter4 = BodyOrienter(q1, q2, q3, '123')
+    D = N.orient_new('D', (orienter1, ))
+    E = N.orient_new('E', (orienter2, ))
+    F = N.orient_new('F', (orienter3, ))
+    G = N.orient_new('G', (orienter4, ))
+    assert D == N.orient_new_axis('D', q4, N.j)
+    assert E == N.orient_new_space('E', q1, q2, q3, '123')
+    assert F == N.orient_new_quaternion('F', q1, q2, q3, q4)
+    assert G == N.orient_new_body('G', q1, q2, q3, '123')
+
+
+def test_locatenew_point():
+    """
+    Tests Point class, and locate_new method in CoordSys3D.
+    """
+    A = CoordSys3D('A')
+    assert isinstance(A.origin, Point)
+    v = a*A.i + b*A.j + c*A.k
+    C = A.locate_new('C', v)
+    assert C.origin.position_wrt(A) == \
+           C.position_wrt(A) == \
+           C.origin.position_wrt(A.origin) == v
+    assert A.origin.position_wrt(C) == \
+           A.position_wrt(C) == \
+           A.origin.position_wrt(C.origin) == -v
+    assert A.origin.express_coordinates(C) == (-a, -b, -c)
+    p = A.origin.locate_new('p', -v)
+    assert p.express_coordinates(A) == (-a, -b, -c)
+    assert p.position_wrt(C.origin) == p.position_wrt(C) == \
+           -2 * v
+    p1 = p.locate_new('p1', 2*v)
+    assert p1.position_wrt(C.origin) == Vector.zero
+    assert p1.express_coordinates(C) == (0, 0, 0)
+    p2 = p.locate_new('p2', A.i)
+    assert p1.position_wrt(p2) == 2*v - A.i
+    assert p2.express_coordinates(C) == (-2*a + 1, -2*b, -2*c)
+
+
+def test_create_new():
+    a = CoordSys3D('a')
+    c = a.create_new('c', transformation='spherical')
+    assert c._parent == a
+    assert c.transformation_to_parent() == \
+           (c.r*sin(c.theta)*cos(c.phi), c.r*sin(c.theta)*sin(c.phi), c.r*cos(c.theta))
+    assert c.transformation_from_parent() == \
+           (sqrt(a.x**2 + a.y**2 + a.z**2), acos(a.z/sqrt(a.x**2 + a.y**2 + a.z**2)), atan2(a.y, a.x))
+
+
+def test_evalf():
+    A = CoordSys3D('A')
+    v = 3*A.i + 4*A.j + a*A.k
+    assert v.n() == v.evalf()
+    assert v.evalf(subs={a:1}) == v.subs(a, 1).evalf()
+
+
+def test_lame_coefficients():
+    a = CoordSys3D('a', 'spherical')
+    assert a.lame_coefficients() == (1, a.r, sin(a.theta)*a.r)
+    a = CoordSys3D('a')
+    assert a.lame_coefficients() == (1, 1, 1)
+    a = CoordSys3D('a', 'cartesian')
+    assert a.lame_coefficients() == (1, 1, 1)
+    a = CoordSys3D('a', 'cylindrical')
+    assert a.lame_coefficients() == (1, a.r, 1)
+
+
+def test_transformation_equations():
+
+    x, y, z = symbols('x y z')
+    # Str
+    a = CoordSys3D('a', transformation='spherical',
+                   variable_names=["r", "theta", "phi"])
+    r, theta, phi = a.base_scalars()
+
+    assert r == a.r
+    assert theta == a.theta
+    assert phi == a.phi
+
+    raises(AttributeError, lambda: a.x)
+    raises(AttributeError, lambda: a.y)
+    raises(AttributeError, lambda: a.z)
+
+    assert a.transformation_to_parent() == (
+        r*sin(theta)*cos(phi),
+        r*sin(theta)*sin(phi),
+        r*cos(theta)
+    )
+    assert a.lame_coefficients() == (1, r, r*sin(theta))
+    assert a.transformation_from_parent_function()(x, y, z) == (
+        sqrt(x ** 2 + y ** 2 + z ** 2),
+        acos((z) / sqrt(x**2 + y**2 + z**2)),
+        atan2(y, x)
+    )
+    a = CoordSys3D('a', transformation='cylindrical',
+                   variable_names=["r", "theta", "z"])
+    r, theta, z = a.base_scalars()
+    assert a.transformation_to_parent() == (
+        r*cos(theta),
+        r*sin(theta),
+        z
+    )
+    assert a.lame_coefficients() == (1, a.r, 1)
+    assert a.transformation_from_parent_function()(x, y, z) == (sqrt(x**2 + y**2),
+                            atan2(y, x), z)
+
+    a = CoordSys3D('a', 'cartesian')
+    assert a.transformation_to_parent() == (a.x, a.y, a.z)
+    assert a.lame_coefficients() == (1, 1, 1)
+    assert a.transformation_from_parent_function()(x, y, z) == (x, y, z)
+
+    # Variables and expressions
+
+    # Cartesian with equation tuple:
+    x, y, z = symbols('x y z')
+    a = CoordSys3D('a', ((x, y, z), (x, y, z)))
+    a._calculate_inv_trans_equations()
+    assert a.transformation_to_parent() == (a.x1, a.x2, a.x3)
+    assert a.lame_coefficients() == (1, 1, 1)
+    assert a.transformation_from_parent_function()(x, y, z) == (x, y, z)
+    r, theta, z = symbols("r theta z")
+
+    # Cylindrical with equation tuple:
+    a = CoordSys3D('a', [(r, theta, z), (r*cos(theta), r*sin(theta), z)],
+                   variable_names=["r", "theta", "z"])
+    r, theta, z = a.base_scalars()
+    assert a.transformation_to_parent() == (
+        r*cos(theta), r*sin(theta), z
+    )
+    assert a.lame_coefficients() == (
+        sqrt(sin(theta)**2 + cos(theta)**2),
+        sqrt(r**2*sin(theta)**2 + r**2*cos(theta)**2),
+        1
+    )  # ==> this should simplify to (1, r, 1), tests are too slow with `simplify`.
+
+    # Definitions with `lambda`:
+
+    # Cartesian with `lambda`
+    a = CoordSys3D('a', lambda x, y, z: (x, y, z))
+    assert a.transformation_to_parent() == (a.x1, a.x2, a.x3)
+    assert a.lame_coefficients() == (1, 1, 1)
+    a._calculate_inv_trans_equations()
+    assert a.transformation_from_parent_function()(x, y, z) == (x, y, z)
+
+    # Spherical with `lambda`
+    a = CoordSys3D('a', lambda r, theta, phi: (r*sin(theta)*cos(phi), r*sin(theta)*sin(phi), r*cos(theta)),
+                   variable_names=["r", "theta", "phi"])
+    r, theta, phi = a.base_scalars()
+    assert a.transformation_to_parent() == (
+        r*sin(theta)*cos(phi), r*sin(phi)*sin(theta), r*cos(theta)
+    )
+    assert a.lame_coefficients() == (
+        sqrt(sin(phi)**2*sin(theta)**2 + sin(theta)**2*cos(phi)**2 + cos(theta)**2),
+        sqrt(r**2*sin(phi)**2*cos(theta)**2 + r**2*sin(theta)**2 + r**2*cos(phi)**2*cos(theta)**2),
+        sqrt(r**2*sin(phi)**2*sin(theta)**2 + r**2*sin(theta)**2*cos(phi)**2)
+    )  # ==> this should simplify to (1, r, sin(theta)*r), `simplify` is too slow.
+
+    # Cylindrical with `lambda`
+    a = CoordSys3D('a', lambda r, theta, z:
+        (r*cos(theta), r*sin(theta), z),
+        variable_names=["r", "theta", "z"]
+    )
+    r, theta, z = a.base_scalars()
+    assert a.transformation_to_parent() == (r*cos(theta), r*sin(theta), z)
+    assert a.lame_coefficients() == (
+        sqrt(sin(theta)**2 + cos(theta)**2),
+        sqrt(r**2*sin(theta)**2 + r**2*cos(theta)**2),
+        1
+    )  # ==> this should simplify to (1, a.x, 1)
+
+    raises(TypeError, lambda: CoordSys3D('a', transformation={
+        x: x*sin(y)*cos(z), y:x*sin(y)*sin(z), z:  x*cos(y)}))
+
+
+def test_check_orthogonality():
+    x, y, z = symbols('x y z')
+    u,v = symbols('u, v')
+    a = CoordSys3D('a', transformation=((x, y, z), (x*sin(y)*cos(z), x*sin(y)*sin(z), x*cos(y))))
+    assert a._check_orthogonality(a._transformation) is True
+    a = CoordSys3D('a', transformation=((x, y, z), (x * cos(y), x * sin(y), z)))
+    assert a._check_orthogonality(a._transformation) is True
+    a = CoordSys3D('a', transformation=((u, v, z), (cosh(u) * cos(v), sinh(u) * sin(v), z)))
+    assert a._check_orthogonality(a._transformation) is True
+
+    raises(ValueError, lambda: CoordSys3D('a', transformation=((x, y, z), (x, x, z))))
+    raises(ValueError, lambda: CoordSys3D('a', transformation=(
+        (x, y, z), (x*sin(y/2)*cos(z), x*sin(y)*sin(z), x*cos(y)))))
+
+
+def test_rotation_trans_equations():
+    a = CoordSys3D('a')
+    from sympy.core.symbol import symbols
+    q0 = symbols('q0')
+    assert a._rotation_trans_equations(a._parent_rotation_matrix, a.base_scalars()) == (a.x, a.y, a.z)
+    assert a._rotation_trans_equations(a._inverse_rotation_matrix(), a.base_scalars()) == (a.x, a.y, a.z)
+    b = a.orient_new_axis('b', 0, -a.k)
+    assert b._rotation_trans_equations(b._parent_rotation_matrix, b.base_scalars()) == (b.x, b.y, b.z)
+    assert b._rotation_trans_equations(b._inverse_rotation_matrix(), b.base_scalars()) == (b.x, b.y, b.z)
+    c = a.orient_new_axis('c', q0, -a.k)
+    assert c._rotation_trans_equations(c._parent_rotation_matrix, c.base_scalars()) == \
+           (-sin(q0) * c.y + cos(q0) * c.x, sin(q0) * c.x + cos(q0) * c.y, c.z)
+    assert c._rotation_trans_equations(c._inverse_rotation_matrix(), c.base_scalars()) == \
+           (sin(q0) * c.y + cos(q0) * c.x, -sin(q0) * c.x + cos(q0) * c.y, c.z)

mplug_owl2/lib/python3.10/site-packages/sympy/vector/tests/test_field_functions.py

@@ -0,0 +1,321 @@
+from sympy.core.function import Derivative
+from sympy.vector.vector import Vector
+from sympy.vector.coordsysrect import CoordSys3D
+from sympy.simplify import simplify
+from sympy.core.symbol import symbols
+from sympy.core import S
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.vector.vector import Dot
+from sympy.vector.operators import curl, divergence, gradient, Gradient, Divergence, Cross
+from sympy.vector.deloperator import Del
+from sympy.vector.functions import (is_conservative, is_solenoidal,
+                                    scalar_potential, directional_derivative,
+                                    laplacian, scalar_potential_difference)
+from sympy.testing.pytest import raises
+
+C = CoordSys3D('C')
+i, j, k = C.base_vectors()
+x, y, z = C.base_scalars()
+delop = Del()
+a, b, c, q = symbols('a b c q')
+
+
+def test_del_operator():
+    # Tests for curl
+
+    assert delop ^ Vector.zero == Vector.zero
+    assert ((delop ^ Vector.zero).doit() == Vector.zero ==
+            curl(Vector.zero))
+    assert delop.cross(Vector.zero) == delop ^ Vector.zero
+    assert (delop ^ i).doit() == Vector.zero
+    assert delop.cross(2*y**2*j, doit=True) == Vector.zero
+    assert delop.cross(2*y**2*j) == delop ^ 2*y**2*j
+    v = x*y*z * (i + j + k)
+    assert ((delop ^ v).doit() ==
+            (-x*y + x*z)*i + (x*y - y*z)*j + (-x*z + y*z)*k ==
+            curl(v))
+    assert delop ^ v == delop.cross(v)
+    assert (delop.cross(2*x**2*j) ==
+            (Derivative(0, C.y) - Derivative(2*C.x**2, C.z))*C.i +
+            (-Derivative(0, C.x) + Derivative(0, C.z))*C.j +
+            (-Derivative(0, C.y) + Derivative(2*C.x**2, C.x))*C.k)
+    assert (delop.cross(2*x**2*j, doit=True) == 4*x*k ==
+            curl(2*x**2*j))
+
+    #Tests for divergence
+    assert delop & Vector.zero is S.Zero == divergence(Vector.zero)
+    assert (delop & Vector.zero).doit() is S.Zero
+    assert delop.dot(Vector.zero) == delop & Vector.zero
+    assert (delop & i).doit() is S.Zero
+    assert (delop & x**2*i).doit() == 2*x == divergence(x**2*i)
+    assert (delop.dot(v, doit=True) == x*y + y*z + z*x ==
+            divergence(v))
+    assert delop & v == delop.dot(v)
+    assert delop.dot(1/(x*y*z) * (i + j + k), doit=True) == \
+           - 1 / (x*y*z**2) - 1 / (x*y**2*z) - 1 / (x**2*y*z)
+    v = x*i + y*j + z*k
+    assert (delop & v == Derivative(C.x, C.x) +
+            Derivative(C.y, C.y) + Derivative(C.z, C.z))
+    assert delop.dot(v, doit=True) == 3 == divergence(v)
+    assert delop & v == delop.dot(v)
+    assert simplify((delop & v).doit()) == 3
+
+    #Tests for gradient
+    assert (delop.gradient(0, doit=True) == Vector.zero ==
+            gradient(0))
+    assert delop.gradient(0) == delop(0)
+    assert (delop(S.Zero)).doit() == Vector.zero
+    assert (delop(x) == (Derivative(C.x, C.x))*C.i +
+            (Derivative(C.x, C.y))*C.j + (Derivative(C.x, C.z))*C.k)
+    assert (delop(x)).doit() == i == gradient(x)
+    assert (delop(x*y*z) ==
+            (Derivative(C.x*C.y*C.z, C.x))*C.i +
+            (Derivative(C.x*C.y*C.z, C.y))*C.j +
+            (Derivative(C.x*C.y*C.z, C.z))*C.k)
+    assert (delop.gradient(x*y*z, doit=True) ==
+            y*z*i + z*x*j + x*y*k ==
+            gradient(x*y*z))
+    assert delop(x*y*z) == delop.gradient(x*y*z)
+    assert (delop(2*x**2)).doit() == 4*x*i
+    assert ((delop(a*sin(y) / x)).doit() ==
+            -a*sin(y)/x**2 * i + a*cos(y)/x * j)
+
+    #Tests for directional derivative
+    assert (Vector.zero & delop)(a) is S.Zero
+    assert ((Vector.zero & delop)(a)).doit() is S.Zero
+    assert ((v & delop)(Vector.zero)).doit() == Vector.zero
+    assert ((v & delop)(S.Zero)).doit() is S.Zero
+    assert ((i & delop)(x)).doit() == 1
+    assert ((j & delop)(y)).doit() == 1
+    assert ((k & delop)(z)).doit() == 1
+    assert ((i & delop)(x*y*z)).doit() == y*z
+    assert ((v & delop)(x)).doit() == x
+    assert ((v & delop)(x*y*z)).doit() == 3*x*y*z
+    assert (v & delop)(x + y + z) == C.x + C.y + C.z
+    assert ((v & delop)(x + y + z)).doit() == x + y + z
+    assert ((v & delop)(v)).doit() == v
+    assert ((i & delop)(v)).doit() == i
+    assert ((j & delop)(v)).doit() == j
+    assert ((k & delop)(v)).doit() == k
+    assert ((v & delop)(Vector.zero)).doit() == Vector.zero
+
+    # Tests for laplacian on scalar fields
+    assert laplacian(x*y*z) is S.Zero
+    assert laplacian(x**2) == S(2)
+    assert laplacian(x**2*y**2*z**2) == \
+                    2*y**2*z**2 + 2*x**2*z**2 + 2*x**2*y**2
+    A = CoordSys3D('A', transformation="spherical", variable_names=["r", "theta", "phi"])
+    B = CoordSys3D('B', transformation='cylindrical', variable_names=["r", "theta", "z"])
+    assert laplacian(A.r + A.theta + A.phi) == 2/A.r + cos(A.theta)/(A.r**2*sin(A.theta))
+    assert laplacian(B.r + B.theta + B.z) == 1/B.r
+
+    # Tests for laplacian on vector fields
+    assert laplacian(x*y*z*(i + j + k)) == Vector.zero
+    assert laplacian(x*y**2*z*(i + j + k)) == \
+                            2*x*z*i + 2*x*z*j + 2*x*z*k
+
+
+def test_product_rules():
+    """
+    Tests the six product rules defined with respect to the Del
+    operator
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Del
+
+    """
+
+    #Define the scalar and vector functions
+    f = 2*x*y*z
+    g = x*y + y*z + z*x
+    u = x**2*i + 4*j - y**2*z*k
+    v = 4*i + x*y*z*k
+
+    # First product rule
+    lhs = delop(f * g, doit=True)
+    rhs = (f * delop(g) + g * delop(f)).doit()
+    assert simplify(lhs) == simplify(rhs)
+
+    # Second product rule
+    lhs = delop(u & v).doit()
+    rhs = ((u ^ (delop ^ v)) + (v ^ (delop ^ u)) + \
+          ((u & delop)(v)) + ((v & delop)(u))).doit()
+    assert simplify(lhs) == simplify(rhs)
+
+    # Third product rule
+    lhs = (delop & (f*v)).doit()
+    rhs = ((f * (delop & v)) + (v & (delop(f)))).doit()
+    assert simplify(lhs) == simplify(rhs)
+
+    # Fourth product rule
+    lhs = (delop & (u ^ v)).doit()
+    rhs = ((v & (delop ^ u)) - (u & (delop ^ v))).doit()
+    assert simplify(lhs) == simplify(rhs)
+
+    # Fifth product rule
+    lhs = (delop ^ (f * v)).doit()
+    rhs = (((delop(f)) ^ v) + (f * (delop ^ v))).doit()
+    assert simplify(lhs) == simplify(rhs)
+
+    # Sixth product rule
+    lhs = (delop ^ (u ^ v)).doit()
+    rhs = (u * (delop & v) - v * (delop & u) +
+           (v & delop)(u) - (u & delop)(v)).doit()
+    assert simplify(lhs) == simplify(rhs)
+
+
+P = C.orient_new_axis('P', q, C.k)  # type: ignore
+scalar_field = 2*x**2*y*z
+grad_field = gradient(scalar_field)
+vector_field = y**2*i + 3*x*j + 5*y*z*k
+curl_field = curl(vector_field)
+
+
+def test_conservative():
+    assert is_conservative(Vector.zero) is True
+    assert is_conservative(i) is True
+    assert is_conservative(2 * i + 3 * j + 4 * k) is True
+    assert (is_conservative(y*z*i + x*z*j + x*y*k) is
+            True)
+    assert is_conservative(x * j) is False
+    assert is_conservative(grad_field) is True
+    assert is_conservative(curl_field) is False
+    assert (is_conservative(4*x*y*z*i + 2*x**2*z*j) is
+            False)
+    assert is_conservative(z*P.i + P.x*k) is True
+
+
+def test_solenoidal():
+    assert is_solenoidal(Vector.zero) is True
+    assert is_solenoidal(i) is True
+    assert is_solenoidal(2 * i + 3 * j + 4 * k) is True
+    assert (is_solenoidal(y*z*i + x*z*j + x*y*k) is
+            True)
+    assert is_solenoidal(y * j) is False
+    assert is_solenoidal(grad_field) is False
+    assert is_solenoidal(curl_field) is True
+    assert is_solenoidal((-2*y + 3)*k) is True
+    assert is_solenoidal(cos(q)*i + sin(q)*j + cos(q)*P.k) is True
+    assert is_solenoidal(z*P.i + P.x*k) is True
+
+
+def test_directional_derivative():
+    assert directional_derivative(C.x*C.y*C.z, 3*C.i + 4*C.j + C.k) == C.x*C.y + 4*C.x*C.z + 3*C.y*C.z
+    assert directional_derivative(5*C.x**2*C.z, 3*C.i + 4*C.j + C.k) == 5*C.x**2 + 30*C.x*C.z
+    assert directional_derivative(5*C.x**2*C.z, 4*C.j) is S.Zero
+
+    D = CoordSys3D("D", "spherical", variable_names=["r", "theta", "phi"],
+                   vector_names=["e_r", "e_theta", "e_phi"])
+    r, theta, phi = D.base_scalars()
+    e_r, e_theta, e_phi = D.base_vectors()
+    assert directional_derivative(r**2*e_r, e_r) == 2*r*e_r
+    assert directional_derivative(5*r**2*phi, 3*e_r + 4*e_theta + e_phi) == 5*r**2 + 30*r*phi
+
+
+def test_scalar_potential():
+    assert scalar_potential(Vector.zero, C) == 0
+    assert scalar_potential(i, C) == x
+    assert scalar_potential(j, C) == y
+    assert scalar_potential(k, C) == z
+    assert scalar_potential(y*z*i + x*z*j + x*y*k, C) == x*y*z
+    assert scalar_potential(grad_field, C) == scalar_field
+    assert scalar_potential(z*P.i + P.x*k, C) == x*z*cos(q) + y*z*sin(q)
+    assert scalar_potential(z*P.i + P.x*k, P) == P.x*P.z
+    raises(ValueError, lambda: scalar_potential(x*j, C))
+
+
+def test_scalar_potential_difference():
+    point1 = C.origin.locate_new('P1', 1*i + 2*j + 3*k)
+    point2 = C.origin.locate_new('P2', 4*i + 5*j + 6*k)
+    genericpointC = C.origin.locate_new('RP', x*i + y*j + z*k)
+    genericpointP = P.origin.locate_new('PP', P.x*P.i + P.y*P.j + P.z*P.k)
+    assert scalar_potential_difference(S.Zero, C, point1, point2) == 0
+    assert (scalar_potential_difference(scalar_field, C, C.origin,
+                                        genericpointC) ==
+            scalar_field)
+    assert (scalar_potential_difference(grad_field, C, C.origin,
+                                        genericpointC) ==
+            scalar_field)
+    assert scalar_potential_difference(grad_field, C, point1, point2) == 948
+    assert (scalar_potential_difference(y*z*i + x*z*j +
+                                        x*y*k, C, point1,
+                                        genericpointC) ==
+            x*y*z - 6)
+    potential_diff_P = (2*P.z*(P.x*sin(q) + P.y*cos(q))*
+                        (P.x*cos(q) - P.y*sin(q))**2)
+    assert (scalar_potential_difference(grad_field, P, P.origin,
+                                        genericpointP).simplify() ==
+            potential_diff_P.simplify())
+
+
+def test_differential_operators_curvilinear_system():
+    A = CoordSys3D('A', transformation="spherical", variable_names=["r", "theta", "phi"])
+    B = CoordSys3D('B', transformation='cylindrical', variable_names=["r", "theta", "z"])
+    # Test for spherical coordinate system and gradient
+    assert gradient(3*A.r + 4*A.theta) == 3*A.i + 4/A.r*A.j
+    assert gradient(3*A.r*A.phi + 4*A.theta) == 3*A.phi*A.i + 4/A.r*A.j + (3/sin(A.theta))*A.k
+    assert gradient(0*A.r + 0*A.theta+0*A.phi) == Vector.zero
+    assert gradient(A.r*A.theta*A.phi) == A.theta*A.phi*A.i + A.phi*A.j + (A.theta/sin(A.theta))*A.k
+    # Test for spherical coordinate system and divergence
+    assert divergence(A.r * A.i + A.theta * A.j + A.phi * A.k) == \
+           (sin(A.theta)*A.r + cos(A.theta)*A.r*A.theta)/(sin(A.theta)*A.r**2) + 3 + 1/(sin(A.theta)*A.r)
+    assert divergence(3*A.r*A.phi*A.i + A.theta*A.j + A.r*A.theta*A.phi*A.k) == \
+           (sin(A.theta)*A.r + cos(A.theta)*A.r*A.theta)/(sin(A.theta)*A.r**2) + 9*A.phi + A.theta/sin(A.theta)
+    assert divergence(Vector.zero) == 0
+    assert divergence(0*A.i + 0*A.j + 0*A.k) == 0
+    # Test for spherical coordinate system and curl
+    assert curl(A.r*A.i + A.theta*A.j + A.phi*A.k) == \
+           (cos(A.theta)*A.phi/(sin(A.theta)*A.r))*A.i + (-A.phi/A.r)*A.j + A.theta/A.r*A.k
+    assert curl(A.r*A.j + A.phi*A.k) == (cos(A.theta)*A.phi/(sin(A.theta)*A.r))*A.i + (-A.phi/A.r)*A.j + 2*A.k
+
+    # Test for cylindrical coordinate system and gradient
+    assert gradient(0*B.r + 0*B.theta+0*B.z) == Vector.zero
+    assert gradient(B.r*B.theta*B.z) == B.theta*B.z*B.i + B.z*B.j + B.r*B.theta*B.k
+    assert gradient(3*B.r) == 3*B.i
+    assert gradient(2*B.theta) == 2/B.r * B.j
+    assert gradient(4*B.z) == 4*B.k
+    # Test for cylindrical coordinate system and divergence
+    assert divergence(B.r*B.i + B.theta*B.j + B.z*B.k) == 3 + 1/B.r
+    assert divergence(B.r*B.j + B.z*B.k) == 1
+    # Test for cylindrical coordinate system and curl
+    assert curl(B.r*B.j + B.z*B.k) == 2*B.k
+    assert curl(3*B.i + 2/B.r*B.j + 4*B.k) == Vector.zero
+
+def test_mixed_coordinates():
+    # gradient
+    a = CoordSys3D('a')
+    b = CoordSys3D('b')
+    c = CoordSys3D('c')
+    assert gradient(a.x*b.y) == b.y*a.i + a.x*b.j
+    assert gradient(3*cos(q)*a.x*b.x+a.y*(a.x+(cos(q)+b.x))) ==\
+           (a.y + 3*b.x*cos(q))*a.i + (a.x + b.x + cos(q))*a.j + (3*a.x*cos(q) + a.y)*b.i
+    # Some tests need further work:
+    # assert gradient(a.x*(cos(a.x+b.x))) == (cos(a.x + b.x))*a.i + a.x*Gradient(cos(a.x + b.x))
+    # assert gradient(cos(a.x + b.x)*cos(a.x + b.z)) == Gradient(cos(a.x + b.x)*cos(a.x + b.z))
+    assert gradient(a.x**b.y) == Gradient(a.x**b.y)
+    # assert gradient(cos(a.x+b.y)*a.z) == None
+    assert gradient(cos(a.x*b.y)) == Gradient(cos(a.x*b.y))
+    assert gradient(3*cos(q)*a.x*b.x*a.z*a.y+ b.y*b.z + cos(a.x+a.y)*b.z) == \
+           (3*a.y*a.z*b.x*cos(q) - b.z*sin(a.x + a.y))*a.i + \
+           (3*a.x*a.z*b.x*cos(q) - b.z*sin(a.x + a.y))*a.j + (3*a.x*a.y*b.x*cos(q))*a.k + \
+           (3*a.x*a.y*a.z*cos(q))*b.i + b.z*b.j + (b.y + cos(a.x + a.y))*b.k
+    # divergence
+    assert divergence(a.i*a.x+a.j*a.y+a.z*a.k + b.i*b.x+b.j*b.y+b.z*b.k + c.i*c.x+c.j*c.y+c.z*c.k) == S(9)
+    # assert divergence(3*a.i*a.x*cos(a.x+b.z) + a.j*b.x*c.z) == None
+    assert divergence(3*a.i*a.x*a.z + b.j*b.x*c.z + 3*a.j*a.z*a.y) == \
+            6*a.z + b.x*Dot(b.j, c.k)
+    assert divergence(3*cos(q)*a.x*b.x*b.i*c.x) == \
+        3*a.x*b.x*cos(q)*Dot(b.i, c.i) + 3*a.x*c.x*cos(q) + 3*b.x*c.x*cos(q)*Dot(b.i, a.i)
+    assert divergence(a.x*b.x*c.x*Cross(a.x*a.i, a.y*b.j)) ==\
+           a.x*b.x*c.x*Divergence(Cross(a.x*a.i, a.y*b.j)) + \
+           b.x*c.x*Dot(Cross(a.x*a.i, a.y*b.j), a.i) + \
+           a.x*c.x*Dot(Cross(a.x*a.i, a.y*b.j), b.i) + \
+           a.x*b.x*Dot(Cross(a.x*a.i, a.y*b.j), c.i)
+    assert divergence(a.x*b.x*c.x*(a.x*a.i + b.x*b.i)) == \
+                4*a.x*b.x*c.x +\
+                a.x**2*c.x*Dot(a.i, b.i) +\
+                a.x**2*b.x*Dot(a.i, c.i) +\
+                b.x**2*c.x*Dot(b.i, a.i) +\
+                a.x*b.x**2*Dot(b.i, c.i)

mplug_owl2/lib/python3.10/site-packages/sympy/vector/tests/test_implicitregion.py

@@ -0,0 +1,90 @@
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.abc import x, y, z, s, t
+from sympy.sets import FiniteSet, EmptySet
+from sympy.geometry import Point
+from sympy.vector import ImplicitRegion
+from sympy.testing.pytest import raises
+
+
+def test_ImplicitRegion():
+    ellipse = ImplicitRegion((x, y), (x**2/4 + y**2/16 - 1))
+    assert ellipse.equation == x**2/4 + y**2/16 - 1
+    assert ellipse.variables == (x, y)
+    assert ellipse.degree == 2
+    r = ImplicitRegion((x, y, z), Eq(x**4 + y**2 - x*y, 6))
+    assert r.equation == x**4 + y**2 - x*y - 6
+    assert r.variables == (x, y, z)
+    assert r.degree == 4
+
+
+def test_regular_point():
+    r1 = ImplicitRegion((x,), x**2 - 16)
+    assert r1.regular_point() == (-4,)
+    c1 = ImplicitRegion((x, y), x**2 + y**2 - 4)
+    assert c1.regular_point() == (0, -2)
+    c2 = ImplicitRegion((x, y), (x - S(5)/2)**2 + y**2 - (S(1)/4)**2)
+    assert c2.regular_point() == (S(5)/2, -S(1)/4)
+    c3 = ImplicitRegion((x, y), (y - 5)**2  - 16*(x - 5))
+    assert c3.regular_point() == (5, 5)
+    r2 = ImplicitRegion((x, y), x**2 - 4*x*y - 3*y**2 + 4*x + 8*y - 5)
+    assert r2.regular_point() == (S(4)/7, S(9)/7)
+    r3 = ImplicitRegion((x, y), x**2 - 2*x*y + 3*y**2 - 2*x - 5*y + 3/2)
+    raises(ValueError, lambda: r3.regular_point())
+
+
+def test_singular_points_and_multiplicty():
+    r1 = ImplicitRegion((x, y, z), Eq(x + y + z, 0))
+    assert r1.singular_points() == EmptySet
+    r2 = ImplicitRegion((x, y, z), x*y*z + y**4 -x**2*z**2)
+    assert r2.singular_points() == FiniteSet((0, 0, z), (x, 0, 0))
+    assert r2.multiplicity((0, 0, 0)) == 3
+    assert r2.multiplicity((0, 0, 6)) == 2
+    r3 = ImplicitRegion((x, y, z), z**2 - x**2 - y**2)
+    assert r3.singular_points() == FiniteSet((0, 0, 0))
+    assert r3.multiplicity((0, 0, 0)) == 2
+    r4 = ImplicitRegion((x, y), x**2 + y**2 - 2*x)
+    assert r4.singular_points() == EmptySet
+    assert r4.multiplicity(Point(1, 3)) == 0
+
+
+def test_rational_parametrization():
+    p = ImplicitRegion((x,), x - 2)
+    assert p.rational_parametrization() == (x - 2,)
+
+    line = ImplicitRegion((x, y), Eq(y, 3*x + 2))
+    assert line.rational_parametrization() == (x, 3*x + 2)
+
+    circle1 = ImplicitRegion((x, y), (x-2)**2 + (y+3)**2 - 4)
+    assert circle1.rational_parametrization(parameters=t) == (4*t/(t**2 + 1) + 2, 4*t**2/(t**2 + 1) - 5)
+    circle2 = ImplicitRegion((x, y), (x - S.Half)**2 + y**2 - (S(1)/2)**2)
+
+    assert circle2.rational_parametrization(parameters=t) == (t/(t**2 + 1) + S(1)/2, t**2/(t**2 + 1) - S(1)/2)
+    circle3 = ImplicitRegion((x, y), Eq(x**2 + y**2, 2*x))
+    assert circle3.rational_parametrization(parameters=(t,)) == (2*t/(t**2 + 1) + 1, 2*t**2/(t**2 + 1) - 1)
+
+    parabola = ImplicitRegion((x, y), (y - 3)**2 - 4*(x + 6))
+    assert parabola.rational_parametrization(t) == (-6 + 4/t**2, 3 + 4/t)
+
+    rect_hyperbola = ImplicitRegion((x, y), x*y - 1)
+    assert rect_hyperbola.rational_parametrization(t) == (-1 + (t + 1)/t, t)
+
+    cubic_curve = ImplicitRegion((x, y), x**3 + x**2 - y**2)
+    assert cubic_curve.rational_parametrization(parameters=(t)) == (t**2 - 1, t*(t**2 - 1))
+    cuspidal = ImplicitRegion((x, y), (x**3 - y**2))
+    assert cuspidal.rational_parametrization(t) == (t**2, t**3)
+
+    I = ImplicitRegion((x, y), x**3 + x**2 - y**2)
+    assert I.rational_parametrization(t) == (t**2 - 1, t*(t**2 - 1))
+
+    sphere = ImplicitRegion((x, y, z), Eq(x**2 + y**2 + z**2, 2*x))
+    assert sphere.rational_parametrization(parameters=(s, t)) == (2/(s**2 + t**2 + 1), 2*t/(s**2 + t**2 + 1), 2*s/(s**2 + t**2 + 1))
+
+    conic = ImplicitRegion((x, y), Eq(x**2 + 4*x*y + 3*y**2 + x - y + 10, 0))
+    assert conic.rational_parametrization(t) == (
+        S(17)/2 + 4/(3*t**2 + 4*t + 1), 4*t/(3*t**2 + 4*t + 1) - S(11)/2)
+
+    r1 = ImplicitRegion((x, y), y**2 - x**3 + x)
+    raises(NotImplementedError, lambda: r1.rational_parametrization())
+    r2 = ImplicitRegion((x, y), y**2 - x**3 - x**2 + 1)
+    raises(NotImplementedError, lambda: r2.rational_parametrization())

mplug_owl2/lib/python3.10/site-packages/sympy/vector/tests/test_integrals.py

@@ -0,0 +1,106 @@
+from sympy.core.numbers import pi
+from sympy.core.singleton import S
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.testing.pytest import raises
+from sympy.vector.coordsysrect import CoordSys3D
+from sympy.vector.integrals import ParametricIntegral, vector_integrate
+from sympy.vector.parametricregion import ParametricRegion
+from sympy.vector.implicitregion import ImplicitRegion
+from sympy.abc import x, y, z, u, v, r, t, theta, phi
+from sympy.geometry import Point, Segment, Curve, Circle, Polygon, Plane
+
+C = CoordSys3D('C')
+
+def test_parametric_lineintegrals():
+    halfcircle = ParametricRegion((4*cos(theta), 4*sin(theta)), (theta, -pi/2, pi/2))
+    assert ParametricIntegral(C.x*C.y**4, halfcircle) == S(8192)/5
+
+    curve = ParametricRegion((t, t**2, t**3), (t, 0, 1))
+    field1 = 8*C.x**2*C.y*C.z*C.i + 5*C.z*C.j - 4*C.x*C.y*C.k
+    assert ParametricIntegral(field1, curve) == 1
+    line = ParametricRegion((4*t - 1, 2 - 2*t, t), (t, 0, 1))
+    assert ParametricIntegral(C.x*C.z*C.i - C.y*C.z*C.k, line) == 3
+
+    assert ParametricIntegral(4*C.x**3, ParametricRegion((1, t), (t, 0, 2))) == 8
+
+    helix = ParametricRegion((cos(t), sin(t), 3*t), (t, 0, 4*pi))
+    assert ParametricIntegral(C.x*C.y*C.z, helix) == -3*sqrt(10)*pi
+
+    field2 = C.y*C.i + C.z*C.j + C.z*C.k
+    assert ParametricIntegral(field2, ParametricRegion((cos(t), sin(t), t**2), (t, 0, pi))) == -5*pi/2 + pi**4/2
+
+def test_parametric_surfaceintegrals():
+
+    semisphere = ParametricRegion((2*sin(phi)*cos(theta), 2*sin(phi)*sin(theta), 2*cos(phi)),\
+                            (theta, 0, 2*pi), (phi, 0, pi/2))
+    assert ParametricIntegral(C.z, semisphere) == 8*pi
+
+    cylinder = ParametricRegion((sqrt(3)*cos(theta), sqrt(3)*sin(theta), z), (z, 0, 6), (theta, 0, 2*pi))
+    assert ParametricIntegral(C.y, cylinder) == 0
+
+    cone = ParametricRegion((v*cos(u), v*sin(u), v), (u, 0, 2*pi), (v, 0, 1))
+    assert ParametricIntegral(C.x*C.i + C.y*C.j + C.z**4*C.k, cone) == pi/3
+
+    triangle1 = ParametricRegion((x, y), (x, 0, 2), (y, 0, 10 - 5*x))
+    triangle2 = ParametricRegion((x, y), (y, 0, 10 - 5*x), (x, 0, 2))
+    assert ParametricIntegral(-15.6*C.y*C.k, triangle1) == ParametricIntegral(-15.6*C.y*C.k, triangle2)
+    assert ParametricIntegral(C.z, triangle1) == 10*C.z
+
+def test_parametric_volumeintegrals():
+
+    cube = ParametricRegion((x, y, z), (x, 0, 1), (y, 0, 1), (z, 0, 1))
+    assert ParametricIntegral(1, cube) == 1
+
+    solidsphere1 = ParametricRegion((r*sin(phi)*cos(theta), r*sin(phi)*sin(theta), r*cos(phi)),\
+                            (r, 0, 2), (theta, 0, 2*pi), (phi, 0, pi))
+    solidsphere2 = ParametricRegion((r*sin(phi)*cos(theta), r*sin(phi)*sin(theta), r*cos(phi)),\
+                            (r, 0, 2), (phi, 0, pi), (theta, 0, 2*pi))
+    assert ParametricIntegral(C.x**2 + C.y**2, solidsphere1) == -256*pi/15
+    assert ParametricIntegral(C.x**2 + C.y**2, solidsphere2) == 256*pi/15
+
+    region_under_plane1 = ParametricRegion((x, y, z), (x, 0, 3), (y, 0, -2*x/3 + 2),\
+                                    (z, 0, 6 - 2*x - 3*y))
+    region_under_plane2 = ParametricRegion((x, y, z), (x, 0, 3), (z, 0, 6 - 2*x - 3*y),\
+                                    (y, 0, -2*x/3 + 2))
+
+    assert ParametricIntegral(C.x*C.i + C.j - 100*C.k, region_under_plane1) == \
+        ParametricIntegral(C.x*C.i + C.j - 100*C.k, region_under_plane2)
+    assert ParametricIntegral(2*C.x, region_under_plane2) == -9
+
+def test_vector_integrate():
+    halfdisc = ParametricRegion((r*cos(theta), r* sin(theta)), (r, -2, 2), (theta, 0, pi))
+    assert vector_integrate(C.x**2, halfdisc) == 4*pi
+    assert vector_integrate(C.x, ParametricRegion((t, t**2), (t, 2, 3))) == -17*sqrt(17)/12 + 37*sqrt(37)/12
+
+    assert  vector_integrate(C.y**3*C.z, (C.x, 0, 3), (C.y, -1, 4)) == 765*C.z/4
+
+    s1 = Segment(Point(0, 0), Point(0, 1))
+    assert vector_integrate(-15*C.y, s1) == S(-15)/2
+    s2 = Segment(Point(4, 3, 9), Point(1, 1, 7))
+    assert vector_integrate(C.y*C.i, s2) == -6
+
+    curve = Curve((sin(t), cos(t)), (t, 0, 2))
+    assert vector_integrate(5*C.z, curve) == 10*C.z
+
+    c1 = Circle(Point(2, 3), 6)
+    assert vector_integrate(C.x*C.y, c1) == 72*pi
+    c2 = Circle(Point(0, 0), Point(1, 1), Point(1, 0))
+    assert vector_integrate(1, c2) == c2.circumference
+
+    triangle = Polygon((0, 0), (1, 0), (1, 1))
+    assert vector_integrate(C.x*C.i - 14*C.y*C.j, triangle) == 0
+    p1, p2, p3, p4 = [(0, 0), (1, 0), (5, 1), (0, 1)]
+    poly = Polygon(p1, p2, p3, p4)
+    assert vector_integrate(-23*C.z, poly) == -161*C.z - 23*sqrt(17)*C.z
+
+    point = Point(2, 3)
+    assert vector_integrate(C.i*C.y - C.z, point) == ParametricIntegral(C.y*C.i, ParametricRegion((2, 3)))
+
+    c3 = ImplicitRegion((x, y), x**2 + y**2 - 4)
+    assert vector_integrate(45, c3) == 180*pi
+    c4 = ImplicitRegion((x, y), (x - 3)**2 + (y - 4)**2 - 9)
+    assert vector_integrate(1, c4) == 6*pi
+
+    pl = Plane(Point(1, 1, 1), Point(2, 3, 4), Point(2, 2, 2))
+    raises(ValueError, lambda: vector_integrate(C.x*C.z*C.i + C.k, pl))

mplug_owl2/lib/python3.10/site-packages/sympy/vector/tests/test_parametricregion.py

@@ -0,0 +1,97 @@
+from sympy.core.numbers import pi
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.vector.coordsysrect import CoordSys3D
+from sympy.vector.parametricregion import ParametricRegion, parametric_region_list
+from sympy.geometry import Point, Segment, Curve, Ellipse, Line, Parabola, Polygon
+from sympy.testing.pytest import raises
+from sympy.abc import a, b, r, t, x, y, z, theta, phi
+
+
+C = CoordSys3D('C')
+
+def test_ParametricRegion():
+
+    point = ParametricRegion((3, 4))
+    assert point.definition == (3, 4)
+    assert point.parameters == ()
+    assert point.limits == {}
+    assert point.dimensions == 0
+
+    # line x = y
+    line_xy = ParametricRegion((y, y), (y, 1, 5))
+    assert line_xy .definition == (y, y)
+    assert line_xy.parameters == (y,)
+    assert line_xy.dimensions == 1
+
+    # line y = z
+    line_yz = ParametricRegion((x,t,t), x, (t, 1, 2))
+    assert line_yz.definition == (x,t,t)
+    assert line_yz.parameters == (x, t)
+    assert line_yz.limits == {t: (1, 2)}
+    assert line_yz.dimensions == 1
+
+    p1 = ParametricRegion((9*a, -16*b), (a, 0, 2), (b, -1, 5))
+    assert p1.definition == (9*a, -16*b)
+    assert p1.parameters == (a, b)
+    assert p1.limits == {a: (0, 2), b: (-1, 5)}
+    assert p1.dimensions == 2
+
+    p2 = ParametricRegion((t, t**3), t)
+    assert p2.parameters == (t,)
+    assert p2.limits == {}
+    assert p2.dimensions == 0
+
+    circle = ParametricRegion((r*cos(theta), r*sin(theta)), r, (theta, 0, 2*pi))
+    assert circle.definition == (r*cos(theta), r*sin(theta))
+    assert circle.dimensions == 1
+
+    halfdisc = ParametricRegion((r*cos(theta), r*sin(theta)), (r, -2, 2), (theta, 0, pi))
+    assert halfdisc.definition == (r*cos(theta), r*sin(theta))
+    assert halfdisc.parameters == (r, theta)
+    assert halfdisc.limits == {r: (-2, 2), theta: (0, pi)}
+    assert halfdisc.dimensions == 2
+
+    ellipse = ParametricRegion((a*cos(t), b*sin(t)), (t, 0, 8))
+    assert ellipse.parameters == (t,)
+    assert ellipse.limits == {t: (0, 8)}
+    assert ellipse.dimensions == 1
+
+    cylinder = ParametricRegion((r*cos(theta), r*sin(theta), z), (r, 0, 1), (theta, 0, 2*pi), (z, 0, 4))
+    assert cylinder.parameters == (r, theta, z)
+    assert cylinder.dimensions == 3
+
+    sphere = ParametricRegion((r*sin(phi)*cos(theta),r*sin(phi)*sin(theta), r*cos(phi)),
+                                r, (theta, 0, 2*pi), (phi, 0, pi))
+    assert sphere.definition == (r*sin(phi)*cos(theta),r*sin(phi)*sin(theta), r*cos(phi))
+    assert sphere.parameters == (r, theta, phi)
+    assert sphere.dimensions == 2
+
+    raises(ValueError, lambda: ParametricRegion((a*t**2, 2*a*t), (a, -2)))
+    raises(ValueError, lambda: ParametricRegion((a, b), (a**2, sin(b)), (a, 2, 4, 6)))
+
+
+def test_parametric_region_list():
+
+    point = Point(-5, 12)
+    assert parametric_region_list(point) == [ParametricRegion((-5, 12))]
+
+    e = Ellipse(Point(2, 8), 2, 6)
+    assert parametric_region_list(e, t) == [ParametricRegion((2*cos(t) + 2, 6*sin(t) + 8), (t, 0, 2*pi))]
+
+    c = Curve((t, t**3), (t, 5, 3))
+    assert parametric_region_list(c) == [ParametricRegion((t, t**3), (t, 5, 3))]
+
+    s = Segment(Point(2, 11, -6), Point(0, 2, 5))
+    assert parametric_region_list(s, t) == [ParametricRegion((2 - 2*t, 11 - 9*t, 11*t - 6), (t, 0, 1))]
+    s1 = Segment(Point(0, 0), (1, 0))
+    assert parametric_region_list(s1, t) == [ParametricRegion((t, 0), (t, 0, 1))]
+    s2 = Segment(Point(1, 2, 3), Point(1, 2, 5))
+    assert parametric_region_list(s2, t) == [ParametricRegion((1, 2, 2*t + 3), (t, 0, 1))]
+    s3 = Segment(Point(12, 56), Point(12, 56))
+    assert parametric_region_list(s3) == [ParametricRegion((12, 56))]
+
+    poly = Polygon((1,3), (-3, 8), (2, 4))
+    assert parametric_region_list(poly, t) == [ParametricRegion((1 - 4*t, 5*t + 3), (t, 0, 1)), ParametricRegion((5*t - 3, 8 - 4*t), (t, 0, 1)), ParametricRegion((2 - t, 4 - t), (t, 0, 1))]
+
+    p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7,8)))
+    raises(ValueError, lambda: parametric_region_list(p1))