diff --git a/lib/python3.10/site-packages/debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_defaults.cpython-310.pyc b/lib/python3.10/site-packages/debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_defaults.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1d4636ef495ebb51c9396857bd6bf789daf2360a
Binary files /dev/null and b/lib/python3.10/site-packages/debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_defaults.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_dont_trace.cpython-310.pyc b/lib/python3.10/site-packages/debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_dont_trace.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0a5d18667dc565498fb6d1acb7e12bb8d7487d67
Binary files /dev/null and b/lib/python3.10/site-packages/debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_dont_trace.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_dont_trace_files.cpython-310.pyc b/lib/python3.10/site-packages/debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_dont_trace_files.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..86fb348a46882731c4ab870235096e655146b570
Binary files /dev/null and b/lib/python3.10/site-packages/debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_dont_trace_files.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_exec2.cpython-310.pyc b/lib/python3.10/site-packages/debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_exec2.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..43e948668fe2ca3c6cebefb209cf2c118b78a422
Binary files /dev/null and b/lib/python3.10/site-packages/debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_exec2.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/__init__.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9b667307876fdec918f67958d19ce39ba2d0d41a
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/__init__.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/_afm.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/_afm.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e6547f968e055f8a33f1f369b223734b528631a4
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/_afm.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/_animation_data.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/_animation_data.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..948daf3309f014eb1d70015ebf7ccad20d5118da
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/_animation_data.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/_blocking_input.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/_blocking_input.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9667df23817b88cc9229df440e0219909848840d
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/_blocking_input.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/_cm.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/_cm.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e74a6c84ea7a330980399fe19708b99d2854ebd6
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/_cm.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/_cm_bivar.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/_cm_bivar.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e8cd5e631a8642f7d7cf62d33d0f850c39ebbd2e
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/_cm_bivar.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/_cm_multivar.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/_cm_multivar.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2360c1f22dc4534adb3fd8a17d2b9b9b408c1cbd
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/_cm_multivar.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/_color_data.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/_color_data.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3174ae88b4580985d9772103d703cd2fcf5f0393
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/_color_data.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/_docstring.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/_docstring.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8cb4ac3a4508223c359f8b72454c9ac1ecd002eb
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/_docstring.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/_enums.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/_enums.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5d9c9af8385dbd38cc1210965ecd56502637c481
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/_enums.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/_fontconfig_pattern.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/_fontconfig_pattern.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2dc3466c43ebeb1b6f442994c93b0c085d647178
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/_fontconfig_pattern.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/_internal_utils.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/_internal_utils.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c0bda56e64b48ce94e49494dbfd8044d5ad972e8
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/_internal_utils.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/_layoutgrid.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/_layoutgrid.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..08a95926bca1f230aacd47b47f9fc0192266950e
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/_layoutgrid.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/_mathtext.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/_mathtext.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3b41d391def1b54c4b1e07b836a2adbaced60bf8
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/_mathtext.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/_mathtext_data.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/_mathtext_data.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b26b7599f8fef9cb818df26d6e5ed92b80e3624f
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/_mathtext_data.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/_pylab_helpers.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/_pylab_helpers.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7da7a83e601f82d25c168ae906b8a0d9c06c885c
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/_pylab_helpers.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/_text_helpers.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/_text_helpers.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..60b0ddc3ccf9b65a85954b448f83eadd43f022f1
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/_text_helpers.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/_tight_bbox.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/_tight_bbox.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c175e0be0bb3a2f19f17b096b30110696cca265e
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/_tight_bbox.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/_tight_layout.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/_tight_layout.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f9e0ae972fbe0a806019e89058178700d7e39630
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/_tight_layout.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/_type1font.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/_type1font.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..524d570c38c01e86acdea272009d0f976b80885d
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/_type1font.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/_version.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/_version.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..879535d3f43885265182d9c96f02aa7ab4a1717b
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/_version.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/animation.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/animation.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d92d0a0cc7346365f983c26946ea75484a6b6c33
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/animation.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/artist.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/artist.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..355f78808bc33c55bbc76a89d5795c5073a3c347
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/artist.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/axis.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/axis.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..36b9e51d3c6808c1eefdf1df52209ccb089cfaaf
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/axis.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/backend_managers.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/backend_managers.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..025ff0e26d9de18430b5dfb34bbdaaea889051d0
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/backend_managers.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/backend_tools.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/backend_tools.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ff984be052d6d0a6525170ae62e564b3647b95d2
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/backend_tools.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/bezier.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/bezier.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f563d45669fdefb89a128b97a44104620f88c105
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/bezier.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/category.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/category.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cc2efcfe19b85ee47e64f307d70644b588667b8f
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/category.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/cbook.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/cbook.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7b7e2556848717b3787b5b649c7ba3bb68992002
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/cbook.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/cm.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/cm.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b9d480467e2e9447c7359258dd62872684942dd0
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/cm.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/collections.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/collections.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2a06eaa106f1eed4c9e70534dd09e15b0e96fc39
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/collections.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/colorbar.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/colorbar.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5dd0d5eb453c49eaac31dabf63f087635d5c226e
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/colorbar.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/colorizer.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/colorizer.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2ed9f565283d10f5c2a9d07c32f7d6d021ae6ebe
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/colorizer.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/contour.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/contour.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7a875c13ece94407e76dc0f9a585abc459aa691c
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/contour.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/dates.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/dates.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d885dcadf6d344bde7a1d3d2de37aaf8baabf608
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/dates.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/dviread.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/dviread.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d0d907b1e1efd37aa2013c6dd643f9494f5cc8e2
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/dviread.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/font_manager.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/font_manager.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3024661792fcdee39f3643381808833a37022291
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/font_manager.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/gridspec.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/gridspec.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6f4e3f9f5f14c9418f868cf22abeffc53c76acc3
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/gridspec.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/hatch.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/hatch.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..708e4fc288e7e0fb02bff59503e9ea8c137aa06f
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/hatch.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/text.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/text.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1f0e8d71e4c0332876bfb22c0da7b56a31dfd1d9
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/text.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/textpath.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/textpath.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c784055c48c20f0d4b0fe7e6eaabfddce6b2db9a
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/textpath.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/ticker.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/ticker.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1188f561440b69358e02301c4714e869317039b9
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/ticker.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/transforms.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/transforms.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..86e952a6baca41356d5d674a6888fa5a98d68a42
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/transforms.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/typing.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/typing.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..87d6b116bc1bbac7a5e8946568ae7b7ad3a14b12
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/typing.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/__pycache__/units.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/__pycache__/units.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1e65ad3af50014421a80b2b0a31e67dc04c68673
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/__pycache__/units.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/_api/__init__.py b/lib/python3.10/site-packages/matplotlib/_api/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..22b58b62ff8e7f83043c9d99cc6d0dcefb0a93d2
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/_api/__init__.py
@@ -0,0 +1,391 @@
+"""
+Helper functions for managing the Matplotlib API.
+
+This documentation is only relevant for Matplotlib developers, not for users.
+
+.. warning::
+
+    This module and its submodules are for internal use only.  Do not use them
+    in your own code.  We may change the API at any time with no warning.
+
+"""
+
+import functools
+import itertools
+import pathlib
+import re
+import sys
+import warnings
+
+from .deprecation import (  # noqa: F401
+    deprecated, warn_deprecated,
+    rename_parameter, delete_parameter, make_keyword_only,
+    deprecate_method_override, deprecate_privatize_attribute,
+    suppress_matplotlib_deprecation_warning,
+    MatplotlibDeprecationWarning)
+
+
+class classproperty:
+    """
+    Like `property`, but also triggers on access via the class, and it is the
+    *class* that's passed as argument.
+
+    Examples
+    --------
+    ::
+
+        class C:
+            @classproperty
+            def foo(cls):
+                return cls.__name__
+
+        assert C.foo == "C"
+    """
+
+    def __init__(self, fget, fset=None, fdel=None, doc=None):
+        self._fget = fget
+        if fset is not None or fdel is not None:
+            raise ValueError('classproperty only implements fget.')
+        self.fset = fset
+        self.fdel = fdel
+        # docs are ignored for now
+        self._doc = doc
+
+    def __get__(self, instance, owner):
+        return self._fget(owner)
+
+    @property
+    def fget(self):
+        return self._fget
+
+
+# In the following check_foo() functions, the first parameter is positional-only to make
+# e.g. `_api.check_isinstance([...], types=foo)` work.
+
+def check_isinstance(types, /, **kwargs):
+    """
+    For each *key, value* pair in *kwargs*, check that *value* is an instance
+    of one of *types*; if not, raise an appropriate TypeError.
+
+    As a special case, a ``None`` entry in *types* is treated as NoneType.
+
+    Examples
+    --------
+    >>> _api.check_isinstance((SomeClass, None), arg=arg)
+    """
+    none_type = type(None)
+    types = ((types,) if isinstance(types, type) else
+             (none_type,) if types is None else
+             tuple(none_type if tp is None else tp for tp in types))
+
+    def type_name(tp):
+        return ("None" if tp is none_type
+                else tp.__qualname__ if tp.__module__ == "builtins"
+                else f"{tp.__module__}.{tp.__qualname__}")
+
+    for k, v in kwargs.items():
+        if not isinstance(v, types):
+            names = [*map(type_name, types)]
+            if "None" in names:  # Move it to the end for better wording.
+                names.remove("None")
+                names.append("None")
+            raise TypeError(
+                "{!r} must be an instance of {}, not a {}".format(
+                    k,
+                    ", ".join(names[:-1]) + " or " + names[-1]
+                    if len(names) > 1 else names[0],
+                    type_name(type(v))))
+
+
+def check_in_list(values, /, *, _print_supported_values=True, **kwargs):
+    """
+    For each *key, value* pair in *kwargs*, check that *value* is in *values*;
+    if not, raise an appropriate ValueError.
+
+    Parameters
+    ----------
+    values : iterable
+        Sequence of values to check on.
+    _print_supported_values : bool, default: True
+        Whether to print *values* when raising ValueError.
+    **kwargs : dict
+        *key, value* pairs as keyword arguments to find in *values*.
+
+    Raises
+    ------
+    ValueError
+        If any *value* in *kwargs* is not found in *values*.
+
+    Examples
+    --------
+    >>> _api.check_in_list(["foo", "bar"], arg=arg, other_arg=other_arg)
+    """
+    if not kwargs:
+        raise TypeError("No argument to check!")
+    for key, val in kwargs.items():
+        if val not in values:
+            msg = f"{val!r} is not a valid value for {key}"
+            if _print_supported_values:
+                msg += f"; supported values are {', '.join(map(repr, values))}"
+            raise ValueError(msg)
+
+
+def check_shape(shape, /, **kwargs):
+    """
+    For each *key, value* pair in *kwargs*, check that *value* has the shape *shape*;
+    if not, raise an appropriate ValueError.
+
+    *None* in the shape is treated as a "free" size that can have any length.
+    e.g. (None, 2) -> (N, 2)
+
+    The values checked must be numpy arrays.
+
+    Examples
+    --------
+    To check for (N, 2) shaped arrays
+
+    >>> _api.check_shape((None, 2), arg=arg, other_arg=other_arg)
+    """
+    for k, v in kwargs.items():
+        data_shape = v.shape
+
+        if (len(data_shape) != len(shape)
+                or any(s != t and t is not None for s, t in zip(data_shape, shape))):
+            dim_labels = iter(itertools.chain(
+                'NMLKJIH',
+                (f"D{i}" for i in itertools.count())))
+            text_shape = ", ".join([str(n) if n is not None else next(dim_labels)
+                                    for n in shape[::-1]][::-1])
+            if len(shape) == 1:
+                text_shape += ","
+
+            raise ValueError(
+                f"{k!r} must be {len(shape)}D with shape ({text_shape}), "
+                f"but your input has shape {v.shape}"
+            )
+
+
+def check_getitem(mapping, /, **kwargs):
+    """
+    *kwargs* must consist of a single *key, value* pair.  If *key* is in
+    *mapping*, return ``mapping[value]``; else, raise an appropriate
+    ValueError.
+
+    Examples
+    --------
+    >>> _api.check_getitem({"foo": "bar"}, arg=arg)
+    """
+    if len(kwargs) != 1:
+        raise ValueError("check_getitem takes a single keyword argument")
+    (k, v), = kwargs.items()
+    try:
+        return mapping[v]
+    except KeyError:
+        raise ValueError(
+            f"{v!r} is not a valid value for {k}; supported values are "
+            f"{', '.join(map(repr, mapping))}") from None
+
+
+def caching_module_getattr(cls):
+    """
+    Helper decorator for implementing module-level ``__getattr__`` as a class.
+
+    This decorator must be used at the module toplevel as follows::
+
+        @caching_module_getattr
+        class __getattr__:  # The class *must* be named ``__getattr__``.
+            @property  # Only properties are taken into account.
+            def name(self): ...
+
+    The ``__getattr__`` class will be replaced by a ``__getattr__``
+    function such that trying to access ``name`` on the module will
+    resolve the corresponding property (which may be decorated e.g. with
+    ``_api.deprecated`` for deprecating module globals).  The properties are
+    all implicitly cached.  Moreover, a suitable AttributeError is generated
+    and raised if no property with the given name exists.
+    """
+
+    assert cls.__name__ == "__getattr__"
+    # Don't accidentally export cls dunders.
+    props = {name: prop for name, prop in vars(cls).items()
+             if isinstance(prop, property)}
+    instance = cls()
+
+    @functools.cache
+    def __getattr__(name):
+        if name in props:
+            return props[name].__get__(instance)
+        raise AttributeError(
+            f"module {cls.__module__!r} has no attribute {name!r}")
+
+    return __getattr__
+
+
+def define_aliases(alias_d, cls=None):
+    """
+    Class decorator for defining property aliases.
+
+    Use as ::
+
+        @_api.define_aliases({"property": ["alias", ...], ...})
+        class C: ...
+
+    For each property, if the corresponding ``get_property`` is defined in the
+    class so far, an alias named ``get_alias`` will be defined; the same will
+    be done for setters.  If neither the getter nor the setter exists, an
+    exception will be raised.
+
+    The alias map is stored as the ``_alias_map`` attribute on the class and
+    can be used by `.normalize_kwargs` (which assumes that higher priority
+    aliases come last).
+    """
+    if cls is None:  # Return the actual class decorator.
+        return functools.partial(define_aliases, alias_d)
+
+    def make_alias(name):  # Enforce a closure over *name*.
+        @functools.wraps(getattr(cls, name))
+        def method(self, *args, **kwargs):
+            return getattr(self, name)(*args, **kwargs)
+        return method
+
+    for prop, aliases in alias_d.items():
+        exists = False
+        for prefix in ["get_", "set_"]:
+            if prefix + prop in vars(cls):
+                exists = True
+                for alias in aliases:
+                    method = make_alias(prefix + prop)
+                    method.__name__ = prefix + alias
+                    method.__doc__ = f"Alias for `{prefix + prop}`."
+                    setattr(cls, prefix + alias, method)
+        if not exists:
+            raise ValueError(
+                f"Neither getter nor setter exists for {prop!r}")
+
+    def get_aliased_and_aliases(d):
+        return {*d, *(alias for aliases in d.values() for alias in aliases)}
+
+    preexisting_aliases = getattr(cls, "_alias_map", {})
+    conflicting = (get_aliased_and_aliases(preexisting_aliases)
+                   & get_aliased_and_aliases(alias_d))
+    if conflicting:
+        # Need to decide on conflict resolution policy.
+        raise NotImplementedError(
+            f"Parent class already defines conflicting aliases: {conflicting}")
+    cls._alias_map = {**preexisting_aliases, **alias_d}
+    return cls
+
+
+def select_matching_signature(funcs, *args, **kwargs):
+    """
+    Select and call the function that accepts ``*args, **kwargs``.
+
+    *funcs* is a list of functions which should not raise any exception (other
+    than `TypeError` if the arguments passed do not match their signature).
+
+    `select_matching_signature` tries to call each of the functions in *funcs*
+    with ``*args, **kwargs`` (in the order in which they are given).  Calls
+    that fail with a `TypeError` are silently skipped.  As soon as a call
+    succeeds, `select_matching_signature` returns its return value.  If no
+    function accepts ``*args, **kwargs``, then the `TypeError` raised by the
+    last failing call is re-raised.
+
+    Callers should normally make sure that any ``*args, **kwargs`` can only
+    bind a single *func* (to avoid any ambiguity), although this is not checked
+    by `select_matching_signature`.
+
+    Notes
+    -----
+    `select_matching_signature` is intended to help implementing
+    signature-overloaded functions.  In general, such functions should be
+    avoided, except for back-compatibility concerns.  A typical use pattern is
+    ::
+
+        def my_func(*args, **kwargs):
+            params = select_matching_signature(
+                [lambda old1, old2: locals(), lambda new: locals()],
+                *args, **kwargs)
+            if "old1" in params:
+                warn_deprecated(...)
+                old1, old2 = params.values()  # note that locals() is ordered.
+            else:
+                new, = params.values()
+            # do things with params
+
+    which allows *my_func* to be called either with two parameters (*old1* and
+    *old2*) or a single one (*new*).  Note that the new signature is given
+    last, so that callers get a `TypeError` corresponding to the new signature
+    if the arguments they passed in do not match any signature.
+    """
+    # Rather than relying on locals() ordering, one could have just used func's
+    # signature (``bound = inspect.signature(func).bind(*args, **kwargs);
+    # bound.apply_defaults(); return bound``) but that is significantly slower.
+    for i, func in enumerate(funcs):
+        try:
+            return func(*args, **kwargs)
+        except TypeError:
+            if i == len(funcs) - 1:
+                raise
+
+
+def nargs_error(name, takes, given):
+    """Generate a TypeError to be raised by function calls with wrong arity."""
+    return TypeError(f"{name}() takes {takes} positional arguments but "
+                     f"{given} were given")
+
+
+def kwarg_error(name, kw):
+    """
+    Generate a TypeError to be raised by function calls with wrong kwarg.
+
+    Parameters
+    ----------
+    name : str
+        The name of the calling function.
+    kw : str or Iterable[str]
+        Either the invalid keyword argument name, or an iterable yielding
+        invalid keyword arguments (e.g., a ``kwargs`` dict).
+    """
+    if not isinstance(kw, str):
+        kw = next(iter(kw))
+    return TypeError(f"{name}() got an unexpected keyword argument '{kw}'")
+
+
+def recursive_subclasses(cls):
+    """Yield *cls* and direct and indirect subclasses of *cls*."""
+    yield cls
+    for subcls in cls.__subclasses__():
+        yield from recursive_subclasses(subcls)
+
+
+def warn_external(message, category=None):
+    """
+    `warnings.warn` wrapper that sets *stacklevel* to "outside Matplotlib".
+
+    The original emitter of the warning can be obtained by patching this
+    function back to `warnings.warn`, i.e. ``_api.warn_external =
+    warnings.warn`` (or ``functools.partial(warnings.warn, stacklevel=2)``,
+    etc.).
+    """
+    kwargs = {}
+    if sys.version_info[:2] >= (3, 12):
+        # Go to Python's `site-packages` or `lib` from an editable install.
+        basedir = pathlib.Path(__file__).parents[2]
+        kwargs['skip_file_prefixes'] = (str(basedir / 'matplotlib'),
+                                        str(basedir / 'mpl_toolkits'))
+    else:
+        frame = sys._getframe()
+        for stacklevel in itertools.count(1):
+            if frame is None:
+                # when called in embedded context may hit frame is None
+                kwargs['stacklevel'] = stacklevel
+                break
+            if not re.match(r"\A(matplotlib|mpl_toolkits)(\Z|\.(?!tests\.))",
+                            # Work around sphinx-gallery not setting __name__.
+                            frame.f_globals.get("__name__", "")):
+                kwargs['stacklevel'] = stacklevel
+                break
+            frame = frame.f_back
+        # preemptively break reference cycle between locals and the frame
+        del frame
+    warnings.warn(message, category, **kwargs)
diff --git a/lib/python3.10/site-packages/matplotlib/_api/__init__.pyi b/lib/python3.10/site-packages/matplotlib/_api/__init__.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..ea7076feac3c415be6d789e92f87020ea89db7a1
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/_api/__init__.pyi
@@ -0,0 +1,59 @@
+from collections.abc import Callable, Generator, Iterable, Mapping, Sequence
+from typing import Any, TypeVar, overload
+from typing_extensions import Self  # < Py 3.11
+
+from numpy.typing import NDArray
+
+from .deprecation import (  # noqa: F401, re-exported API
+    deprecated as deprecated,
+    warn_deprecated as warn_deprecated,
+    rename_parameter as rename_parameter,
+    delete_parameter as delete_parameter,
+    make_keyword_only as make_keyword_only,
+    deprecate_method_override as deprecate_method_override,
+    deprecate_privatize_attribute as deprecate_privatize_attribute,
+    suppress_matplotlib_deprecation_warning as suppress_matplotlib_deprecation_warning,
+    MatplotlibDeprecationWarning as MatplotlibDeprecationWarning,
+)
+
+_T = TypeVar("_T")
+
+class classproperty(Any):
+    def __init__(
+        self,
+        fget: Callable[[_T], Any],
+        fset: None = ...,
+        fdel: None = ...,
+        doc: str | None = None,
+    ): ...
+    @overload
+    def __get__(self, instance: None, owner: None) -> Self: ...
+    @overload
+    def __get__(self, instance: object, owner: type[object]) -> Any: ...
+    @property
+    def fget(self) -> Callable[[_T], Any]: ...
+
+def check_isinstance(
+    types: type | tuple[type | None, ...], /, **kwargs: Any
+) -> None: ...
+def check_in_list(
+    values: Sequence[Any], /, *, _print_supported_values: bool = ..., **kwargs: Any
+) -> None: ...
+def check_shape(shape: tuple[int | None, ...], /, **kwargs: NDArray) -> None: ...
+def check_getitem(mapping: Mapping[Any, Any], /, **kwargs: Any) -> Any: ...
+def caching_module_getattr(cls: type) -> Callable[[str], Any]: ...
+@overload
+def define_aliases(
+    alias_d: dict[str, list[str]], cls: None = ...
+) -> Callable[[type[_T]], type[_T]]: ...
+@overload
+def define_aliases(alias_d: dict[str, list[str]], cls: type[_T]) -> type[_T]: ...
+def select_matching_signature(
+    funcs: list[Callable], *args: Any, **kwargs: Any
+) -> Any: ...
+def nargs_error(name: str, takes: int | str, given: int) -> TypeError: ...
+def kwarg_error(name: str, kw: str | Iterable[str]) -> TypeError: ...
+def recursive_subclasses(cls: type) -> Generator[type, None, None]: ...
+def warn_external(
+    message: str | Warning, category: type[Warning] | None = ...
+) -> None: ...
diff --git a/lib/python3.10/site-packages/matplotlib/_api/__pycache__/__init__.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/_api/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b8c496737489f74b5bb94c8059b4ec0cbab5dff4
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/_api/__pycache__/__init__.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/_api/__pycache__/deprecation.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/_api/__pycache__/deprecation.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..539898449b65c6d3409f38c4017124897e7a303b
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/_api/__pycache__/deprecation.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/_api/deprecation.py b/lib/python3.10/site-packages/matplotlib/_api/deprecation.py
new file mode 100644
index 0000000000000000000000000000000000000000..65a754bbb43d424f52e9b11f4580ba5d08dc6e59
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/_api/deprecation.py
@@ -0,0 +1,509 @@
+"""
+Helper functions for deprecating parts of the Matplotlib API.
+
+This documentation is only relevant for Matplotlib developers, not for users.
+
+.. warning::
+
+    This module is for internal use only.  Do not use it in your own code.
+    We may change the API at any time with no warning.
+
+"""
+
+import contextlib
+import functools
+import inspect
+import math
+import warnings
+
+
+class MatplotlibDeprecationWarning(DeprecationWarning):
+    """A class for issuing deprecation warnings for Matplotlib users."""
+
+
+def _generate_deprecation_warning(
+        since, message='', name='', alternative='', pending=False, obj_type='',
+        addendum='', *, removal=''):
+    if pending:
+        if removal:
+            raise ValueError("A pending deprecation cannot have a scheduled removal")
+    elif removal == '':
+        macro, meso, *_ = since.split('.')
+        removal = f'{macro}.{int(meso) + 2}'
+    if not message:
+        message = (
+            ("The %(name)s %(obj_type)s" if obj_type else "%(name)s") +
+            (" will be deprecated in a future version" if pending else
+             (" was deprecated in Matplotlib %(since)s" +
+              (" and will be removed in %(removal)s" if removal else ""))) +
+            "." +
+            (" Use %(alternative)s instead." if alternative else "") +
+            (" %(addendum)s" if addendum else ""))
+    warning_cls = PendingDeprecationWarning if pending else MatplotlibDeprecationWarning
+    return warning_cls(message % dict(
+        func=name, name=name, obj_type=obj_type, since=since, removal=removal,
+        alternative=alternative, addendum=addendum))
+
+
+def warn_deprecated(
+        since, *, message='', name='', alternative='', pending=False,
+        obj_type='', addendum='', removal=''):
+    """
+    Display a standardized deprecation.
+
+    Parameters
+    ----------
+    since : str
+        The release at which this API became deprecated.
+    message : str, optional
+        Override the default deprecation message.  The ``%(since)s``,
+        ``%(name)s``, ``%(alternative)s``, ``%(obj_type)s``, ``%(addendum)s``,
+        and ``%(removal)s`` format specifiers will be replaced by the values
+        of the respective arguments passed to this function.
+    name : str, optional
+        The name of the deprecated object.
+    alternative : str, optional
+        An alternative API that the user may use in place of the deprecated
+        API.  The deprecation warning will tell the user about this alternative
+        if provided.
+    pending : bool, optional
+        If True, uses a PendingDeprecationWarning instead of a
+        DeprecationWarning.  Cannot be used together with *removal*.
+    obj_type : str, optional
+        The object type being deprecated.
+    addendum : str, optional
+        Additional text appended directly to the final message.
+    removal : str, optional
+        The expected removal version.  With the default (an empty string), a
+        removal version is automatically computed from *since*.  Set to other
+        Falsy values to not schedule a removal date.  Cannot be used together
+        with *pending*.
+
+    Examples
+    --------
+    ::
+
+        # To warn of the deprecation of "matplotlib.name_of_module"
+        warn_deprecated('1.4.0', name='matplotlib.name_of_module',
+                        obj_type='module')
+    """
+    warning = _generate_deprecation_warning(
+        since, message, name, alternative, pending, obj_type, addendum,
+        removal=removal)
+    from . import warn_external
+    warn_external(warning, category=MatplotlibDeprecationWarning)
+
+
+def deprecated(since, *, message='', name='', alternative='', pending=False,
+               obj_type=None, addendum='', removal=''):
+    """
+    Decorator to mark a function, a class, or a property as deprecated.
+
+    When deprecating a classmethod, a staticmethod, or a property, the
+    ``@deprecated`` decorator should go *under* ``@classmethod`` and
+    ``@staticmethod`` (i.e., `deprecated` should directly decorate the
+    underlying callable), but *over* ``@property``.
+
+    When deprecating a class ``C`` intended to be used as a base class in a
+    multiple inheritance hierarchy, ``C`` *must* define an ``__init__`` method
+    (if ``C`` instead inherited its ``__init__`` from its own base class, then
+    ``@deprecated`` would mess up ``__init__`` inheritance when installing its
+    own (deprecation-emitting) ``C.__init__``).
+
+    Parameters are the same as for `warn_deprecated`, except that *obj_type*
+    defaults to 'class' if decorating a class, 'attribute' if decorating a
+    property, and 'function' otherwise.
+
+    Examples
+    --------
+    ::
+
+        @deprecated('1.4.0')
+        def the_function_to_deprecate():
+            pass
+    """
+
+    def deprecate(obj, message=message, name=name, alternative=alternative,
+                  pending=pending, obj_type=obj_type, addendum=addendum):
+        from matplotlib._api import classproperty
+
+        if isinstance(obj, type):
+            if obj_type is None:
+                obj_type = "class"
+            func = obj.__init__
+            name = name or obj.__name__
+            old_doc = obj.__doc__
+
+            def finalize(wrapper, new_doc):
+                try:
+                    obj.__doc__ = new_doc
+                except AttributeError:  # Can't set on some extension objects.
+                    pass
+                obj.__init__ = functools.wraps(obj.__init__)(wrapper)
+                return obj
+
+        elif isinstance(obj, (property, classproperty)):
+            if obj_type is None:
+                obj_type = "attribute"
+            func = None
+            name = name or obj.fget.__name__
+            old_doc = obj.__doc__
+
+            class _deprecated_property(type(obj)):
+                def __get__(self, instance, owner=None):
+                    if instance is not None or owner is not None \
+                            and isinstance(self, classproperty):
+                        emit_warning()
+                    return super().__get__(instance, owner)
+
+                def __set__(self, instance, value):
+                    if instance is not None:
+                        emit_warning()
+                    return super().__set__(instance, value)
+
+                def __delete__(self, instance):
+                    if instance is not None:
+                        emit_warning()
+                    return super().__delete__(instance)
+
+                def __set_name__(self, owner, set_name):
+                    nonlocal name
+                    if name == "<lambda>":
+                        name = set_name
+
+            def finalize(_, new_doc):
+                return _deprecated_property(
+                    fget=obj.fget, fset=obj.fset, fdel=obj.fdel, doc=new_doc)
+
+        else:
+            if obj_type is None:
+                obj_type = "function"
+            func = obj
+            name = name or obj.__name__
+            old_doc = func.__doc__
+
+            def finalize(wrapper, new_doc):
+                wrapper = functools.wraps(func)(wrapper)
+                wrapper.__doc__ = new_doc
+                return wrapper
+
+        def emit_warning():
+            warn_deprecated(
+                since, message=message, name=name, alternative=alternative,
+                pending=pending, obj_type=obj_type, addendum=addendum,
+                removal=removal)
+
+        def wrapper(*args, **kwargs):
+            emit_warning()
+            return func(*args, **kwargs)
+
+        old_doc = inspect.cleandoc(old_doc or '').strip('\n')
+
+        notes_header = '\nNotes\n-----'
+        second_arg = ' '.join([t.strip() for t in
+                               (message, f"Use {alternative} instead."
+                                if alternative else "", addendum) if t])
+        new_doc = (f"[*Deprecated*] {old_doc}\n"
+                   f"{notes_header if notes_header not in old_doc else ''}\n"
+                   f".. deprecated:: {since}\n"
+                   f"   {second_arg}")
+
+        if not old_doc:
+            # This is to prevent a spurious 'unexpected unindent' warning from
+            # docutils when the original docstring was blank.
+            new_doc += r'\ '
+
+        return finalize(wrapper, new_doc)
+
+    return deprecate
+
+
+class deprecate_privatize_attribute:
+    """
+    Helper to deprecate public access to an attribute (or method).
+
+    This helper should only be used at class scope, as follows::
+
+        class Foo:
+            attr = _deprecate_privatize_attribute(*args, **kwargs)
+
+    where *all* parameters are forwarded to `deprecated`.  This form makes
+    ``attr`` a property which forwards read and write access to ``self._attr``
+    (same name but with a leading underscore), with a deprecation warning.
+    Note that the attribute name is derived from *the name this helper is
+    assigned to*.  This helper also works for deprecating methods.
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.deprecator = deprecated(*args, **kwargs)
+
+    def __set_name__(self, owner, name):
+        setattr(owner, name, self.deprecator(
+            property(lambda self: getattr(self, f"_{name}"),
+                     lambda self, value: setattr(self, f"_{name}", value)),
+            name=name))
+
+
+# Used by _copy_docstring_and_deprecators to redecorate pyplot wrappers and
+# boilerplate.py to retrieve original signatures.  It may seem natural to store
+# this information as an attribute on the wrapper, but if the wrapper gets
+# itself functools.wraps()ed, then such attributes are silently propagated to
+# the outer wrapper, which is not desired.
+DECORATORS = {}
+
+
+def rename_parameter(since, old, new, func=None):
+    """
+    Decorator indicating that parameter *old* of *func* is renamed to *new*.
+
+    The actual implementation of *func* should use *new*, not *old*.  If *old*
+    is passed to *func*, a DeprecationWarning is emitted, and its value is
+    used, even if *new* is also passed by keyword (this is to simplify pyplot
+    wrapper functions, which always pass *new* explicitly to the Axes method).
+    If *new* is also passed but positionally, a TypeError will be raised by the
+    underlying function during argument binding.
+
+    Examples
+    --------
+    ::
+
+        @_api.rename_parameter("3.1", "bad_name", "good_name")
+        def func(good_name): ...
+    """
+
+    decorator = functools.partial(rename_parameter, since, old, new)
+
+    if func is None:
+        return decorator
+
+    signature = inspect.signature(func)
+    assert old not in signature.parameters, (
+        f"Matplotlib internal error: {old!r} cannot be a parameter for "
+        f"{func.__name__}()")
+    assert new in signature.parameters, (
+        f"Matplotlib internal error: {new!r} must be a parameter for "
+        f"{func.__name__}()")
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        if old in kwargs:
+            warn_deprecated(
+                since, message=f"The {old!r} parameter of {func.__name__}() "
+                f"has been renamed {new!r} since Matplotlib {since}; support "
+                f"for the old name will be dropped in %(removal)s.")
+            kwargs[new] = kwargs.pop(old)
+        return func(*args, **kwargs)
+
+    # wrapper() must keep the same documented signature as func(): if we
+    # instead made both *old* and *new* appear in wrapper()'s signature, they
+    # would both show up in the pyplot function for an Axes method as well and
+    # pyplot would explicitly pass both arguments to the Axes method.
+
+    DECORATORS[wrapper] = decorator
+    return wrapper
+
+
+class _deprecated_parameter_class:
+    def __repr__(self):
+        return "<deprecated parameter>"
+
+
+_deprecated_parameter = _deprecated_parameter_class()
+
+
+def delete_parameter(since, name, func=None, **kwargs):
+    """
+    Decorator indicating that parameter *name* of *func* is being deprecated.
+
+    The actual implementation of *func* should keep the *name* parameter in its
+    signature, or accept a ``**kwargs`` argument (through which *name* would be
+    passed).
+
+    Parameters that come after the deprecated parameter effectively become
+    keyword-only (as they cannot be passed positionally without triggering the
+    DeprecationWarning on the deprecated parameter), and should be marked as
+    such after the deprecation period has passed and the deprecated parameter
+    is removed.
+
+    Parameters other than *since*, *name*, and *func* are keyword-only and
+    forwarded to `.warn_deprecated`.
+
+    Examples
+    --------
+    ::
+
+        @_api.delete_parameter("3.1", "unused")
+        def func(used_arg, other_arg, unused, more_args): ...
+    """
+
+    decorator = functools.partial(delete_parameter, since, name, **kwargs)
+
+    if func is None:
+        return decorator
+
+    signature = inspect.signature(func)
+    # Name of `**kwargs` parameter of the decorated function, typically
+    # "kwargs" if such a parameter exists, or None if the decorated function
+    # doesn't accept `**kwargs`.
+    kwargs_name = next((param.name for param in signature.parameters.values()
+                        if param.kind == inspect.Parameter.VAR_KEYWORD), None)
+    if name in signature.parameters:
+        kind = signature.parameters[name].kind
+        is_varargs = kind is inspect.Parameter.VAR_POSITIONAL
+        is_varkwargs = kind is inspect.Parameter.VAR_KEYWORD
+        if not is_varargs and not is_varkwargs:
+            name_idx = (
+                # Deprecated parameter can't be passed positionally.
+                math.inf if kind is inspect.Parameter.KEYWORD_ONLY
+                # If call site has no more than this number of parameters, the
+                # deprecated parameter can't have been passed positionally.
+                else [*signature.parameters].index(name))
+            func.__signature__ = signature = signature.replace(parameters=[
+                param.replace(default=_deprecated_parameter)
+                if param.name == name else param
+                for param in signature.parameters.values()])
+        else:
+            name_idx = -1  # Deprecated parameter can always have been passed.
+    else:
+        is_varargs = is_varkwargs = False
+        # Deprecated parameter can't be passed positionally.
+        name_idx = math.inf
+        assert kwargs_name, (
+            f"Matplotlib internal error: {name!r} must be a parameter for "
+            f"{func.__name__}()")
+
+    addendum = kwargs.pop('addendum', None)
+
+    @functools.wraps(func)
+    def wrapper(*inner_args, **inner_kwargs):
+        if len(inner_args) <= name_idx and name not in inner_kwargs:
+            # Early return in the simple, non-deprecated case (much faster than
+            # calling bind()).
+            return func(*inner_args, **inner_kwargs)
+        arguments = signature.bind(*inner_args, **inner_kwargs).arguments
+        if is_varargs and arguments.get(name):
+            warn_deprecated(
+                since, message=f"Additional positional arguments to "
+                f"{func.__name__}() are deprecated since %(since)s and "
+                f"support for them will be removed in %(removal)s.")
+        elif is_varkwargs and arguments.get(name):
+            warn_deprecated(
+                since, message=f"Additional keyword arguments to "
+                f"{func.__name__}() are deprecated since %(since)s and "
+                f"support for them will be removed in %(removal)s.")
+        # We cannot just check `name not in arguments` because the pyplot
+        # wrappers always pass all arguments explicitly.
+        elif any(name in d and d[name] != _deprecated_parameter
+                 for d in [arguments, arguments.get(kwargs_name, {})]):
+            deprecation_addendum = (
+                f"If any parameter follows {name!r}, they should be passed as "
+                f"keyword, not positionally.")
+            warn_deprecated(
+                since,
+                name=repr(name),
+                obj_type=f"parameter of {func.__name__}()",
+                addendum=(addendum + " " + deprecation_addendum) if addendum
+                         else deprecation_addendum,
+                **kwargs)
+        return func(*inner_args, **inner_kwargs)
+
+    DECORATORS[wrapper] = decorator
+    return wrapper
+
+
+def make_keyword_only(since, name, func=None):
+    """
+    Decorator indicating that passing parameter *name* (or any of the following
+    ones) positionally to *func* is being deprecated.
+
+    When used on a method that has a pyplot wrapper, this should be the
+    outermost decorator, so that :file:`boilerplate.py` can access the original
+    signature.
+    """
+
+    decorator = functools.partial(make_keyword_only, since, name)
+
+    if func is None:
+        return decorator
+
+    signature = inspect.signature(func)
+    POK = inspect.Parameter.POSITIONAL_OR_KEYWORD
+    KWO = inspect.Parameter.KEYWORD_ONLY
+    assert (name in signature.parameters
+            and signature.parameters[name].kind == POK), (
+        f"Matplotlib internal error: {name!r} must be a positional-or-keyword "
+        f"parameter for {func.__name__}(). If this error happens on a function with a "
+        f"pyplot wrapper, make sure make_keyword_only() is the outermost decorator.")
+    names = [*signature.parameters]
+    name_idx = names.index(name)
+    kwonly = [name for name in names[name_idx:]
+              if signature.parameters[name].kind == POK]
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        # Don't use signature.bind here, as it would fail when stacked with
+        # rename_parameter and an "old" argument name is passed in
+        # (signature.bind would fail, but the actual call would succeed).
+        if len(args) > name_idx:
+            warn_deprecated(
+                since, message="Passing the %(name)s %(obj_type)s "
+                "positionally is deprecated since Matplotlib %(since)s; the "
+                "parameter will become keyword-only in %(removal)s.",
+                name=name, obj_type=f"parameter of {func.__name__}()")
+        return func(*args, **kwargs)
+
+    # Don't modify *func*'s signature, as boilerplate.py needs it.
+    wrapper.__signature__ = signature.replace(parameters=[
+        param.replace(kind=KWO) if param.name in kwonly else param
+        for param in signature.parameters.values()])
+    DECORATORS[wrapper] = decorator
+    return wrapper
+
+
+def deprecate_method_override(method, obj, *, allow_empty=False, **kwargs):
+    """
+    Return ``obj.method`` with a deprecation if it was overridden, else None.
+
+    Parameters
+    ----------
+    method
+        An unbound method, i.e. an expression of the form
+        ``Class.method_name``.  Remember that within the body of a method, one
+        can always use ``__class__`` to refer to the class that is currently
+        being defined.
+    obj
+        Either an object of the class where *method* is defined, or a subclass
+        of that class.
+    allow_empty : bool, default: False
+        Whether to allow overrides by "empty" methods without emitting a
+        warning.
+    **kwargs
+        Additional parameters passed to `warn_deprecated` to generate the
+        deprecation warning; must at least include the "since" key.
+    """
+
+    def empty(): pass
+    def empty_with_docstring(): """doc"""
+
+    name = method.__name__
+    bound_child = getattr(obj, name)
+    bound_base = (
+        method  # If obj is a class, then we need to use unbound methods.
+        if isinstance(bound_child, type(empty)) and isinstance(obj, type)
+        else method.__get__(obj))
+    if (bound_child != bound_base
+            and (not allow_empty
+                 or (getattr(getattr(bound_child, "__code__", None),
+                             "co_code", None)
+                     not in [empty.__code__.co_code,
+                             empty_with_docstring.__code__.co_code]))):
+        warn_deprecated(**{"name": name, "obj_type": "method", **kwargs})
+        return bound_child
+    return None
+
+
+@contextlib.contextmanager
+def suppress_matplotlib_deprecation_warning():
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", MatplotlibDeprecationWarning)
+        yield
diff --git a/lib/python3.10/site-packages/matplotlib/_api/deprecation.pyi b/lib/python3.10/site-packages/matplotlib/_api/deprecation.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..e050290662d925fd68bd534881512e86db13a4bb
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/_api/deprecation.pyi
@@ -0,0 +1,75 @@
+from collections.abc import Callable
+import contextlib
+from typing import Any, Literal, ParamSpec, TypedDict, TypeVar, overload
+from typing_extensions import (
+    Unpack,  # < Py 3.11
+)
+
+_P = ParamSpec("_P")
+_R = TypeVar("_R")
+_T = TypeVar("_T")
+
+class MatplotlibDeprecationWarning(DeprecationWarning): ...
+
+class DeprecationKwargs(TypedDict, total=False):
+    message: str
+    alternative: str
+    pending: bool
+    obj_type: str
+    addendum: str
+    removal: str | Literal[False]
+
+class NamedDeprecationKwargs(DeprecationKwargs, total=False):
+    name: str
+
+def warn_deprecated(since: str, **kwargs: Unpack[NamedDeprecationKwargs]) -> None: ...
+def deprecated(
+    since: str, **kwargs: Unpack[NamedDeprecationKwargs]
+) -> Callable[[_T], _T]: ...
+
+class deprecate_privatize_attribute(Any):
+    def __init__(self, since: str, **kwargs: Unpack[NamedDeprecationKwargs]): ...
+    def __set_name__(self, owner: type[object], name: str) -> None: ...
+
+DECORATORS: dict[Callable, Callable] = ...
+
+@overload
+def rename_parameter(
+    since: str, old: str, new: str, func: None = ...
+) -> Callable[[Callable[_P, _R]], Callable[_P, _R]]: ...
+@overload
+def rename_parameter(
+    since: str, old: str, new: str, func: Callable[_P, _R]
+) -> Callable[_P, _R]: ...
+
+class _deprecated_parameter_class: ...
+
+_deprecated_parameter: _deprecated_parameter_class
+
+@overload
+def delete_parameter(
+    since: str, name: str, func: None = ..., **kwargs: Unpack[DeprecationKwargs]
+) -> Callable[[Callable[_P, _R]], Callable[_P, _R]]: ...
+@overload
+def delete_parameter(
+    since: str, name: str, func: Callable[_P, _R], **kwargs: Unpack[DeprecationKwargs]
+) -> Callable[_P, _R]: ...
+@overload
+def make_keyword_only(
+    since: str, name: str, func: None = ...
+) -> Callable[[Callable[_P, _R]], Callable[_P, _R]]: ...
+@overload
+def make_keyword_only(
+    since: str, name: str, func: Callable[_P, _R]
+) -> Callable[_P, _R]: ...
+def deprecate_method_override(
+    method: Callable[_P, _R],
+    obj: object | type,
+    *,
+    allow_empty: bool = ...,
+    since: str,
+    **kwargs: Unpack[NamedDeprecationKwargs]
+) -> Callable[_P, _R]: ...
+def suppress_matplotlib_deprecation_warning() -> (
+    contextlib.AbstractContextManager[None]
+): ...
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/__init__.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..480518eaaf94312b29c6f865298b99910fdba07b
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/__init__.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/_backend_gtk.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/_backend_gtk.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2d5b54d2006a83b1470bcf80b7cd60d9bc2766da
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/_backend_gtk.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/_backend_pdf_ps.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/_backend_pdf_ps.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d45801eb3201397e004cd49b8c9e562f0a18c840
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/_backend_pdf_ps.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/_backend_tk.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/_backend_tk.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..625eabe4df4e1fd71fb5035d8af10f30dfa3ecef
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/_backend_tk.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_agg.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_agg.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6e26c02376300a452d6874f3b05c51148ceb3e47
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_agg.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_cairo.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_cairo.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a000f93544f40da99c9b55350da435ecd6c9aa74
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_cairo.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_gtk3.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_gtk3.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5c8ffa2e46a19b50aa23140a719d2b375c23398b
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_gtk3.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_gtk3agg.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_gtk3agg.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cc5dc8afaad047ae67fa9050ba43162deea7b752
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_gtk3agg.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_gtk3cairo.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_gtk3cairo.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9dc8d01eec010e24c328090f86ace31630b33532
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_gtk3cairo.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_gtk4.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_gtk4.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2a0388cde2eb4e49f7e1427758541c78757e8e0a
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_gtk4.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_gtk4agg.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_gtk4agg.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b61f7c8599bd8e74b0273cb7ac36faea960446e9
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_gtk4agg.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_gtk4cairo.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_gtk4cairo.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b6698527665276b88200e792de7890345688669a
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_gtk4cairo.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_macosx.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_macosx.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..600697bb121634d9eb22351677a966d613de9c11
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_macosx.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_mixed.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_mixed.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..14887fbd1c2794a6773d73b5024b339191019d8c
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_mixed.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_nbagg.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_nbagg.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6665e0541c92ac54303b013f63f1cd048b989d16
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_nbagg.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_pdf.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_pdf.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..844086fa617b6d9fc955db00429763ee2f00d042
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_pdf.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_pgf.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_pgf.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..39e76e6fb63c95d210641cc7a323252dc3d8a3d2
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_pgf.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_ps.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_ps.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..87d74f4f14b283be7b93281a9471fc5a82e9a965
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_ps.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_qt.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_qt.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8c51dfff05f6e75b5ad7aa1bdc4d0cc747fdfa9e
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_qt.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_qt5.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_qt5.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..61cc76406211920d614c020c85a7085ca9bbef36
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_qt5.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_qt5agg.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_qt5agg.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..057d93446a904199094a9f75c58ad4a473cb0674
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_qt5agg.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_qt5cairo.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_qt5cairo.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ed764a93231023898713c4fe89b1aeeadc2653e9
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_qt5cairo.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_qtagg.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_qtagg.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..48ec81431aad79605b20b31d62f5b0567756d9e6
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_qtagg.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_qtcairo.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_qtcairo.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..94f38275a38a5cfe540e6b7eb7200b77f8b490cc
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_qtcairo.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_svg.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_svg.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a5d7d0978e39e42f3ceaf2b32fd068ed456eabc4
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_svg.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_template.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_template.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cdc13bf6f021a98be254e41890320ca7917a18b8
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_template.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_tkagg.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_tkagg.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b8a788836718f2bf18920674457c925339637285
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_tkagg.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_tkcairo.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_tkcairo.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cb000b4f1632e499e2dec60c3f90797ab029ef0b
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_tkcairo.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_webagg.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_webagg.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1c4e5897b183bbcec0890b1610d406a8d67816ac
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_webagg.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_webagg_core.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_webagg_core.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..822457c4e86e8f62d9f6c79ee527f87cde405125
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_webagg_core.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_wx.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_wx.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3361d237cc2a7901d11a6d61555e3a9801856d05
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_wx.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_wxagg.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_wxagg.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..938e538737c396b71dbd0a479abe6f3886d298d7
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_wxagg.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_wxcairo.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_wxcairo.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..17ebbc95f886d8983c643c8eff63c7c21156a7c0
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/backend_wxcairo.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/qt_compat.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/qt_compat.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..522e0eb56da3e39b90e2cdb660cb2682629fe6d9
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/qt_compat.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/__pycache__/registry.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/registry.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..de9ad802c94363a2e7759b7f7ca35f7eee9f11cd
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/__pycache__/registry.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/qt_editor/__init__.py b/lib/python3.10/site-packages/matplotlib/backends/qt_editor/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/lib/python3.10/site-packages/matplotlib/backends/qt_editor/__pycache__/figureoptions.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/backends/qt_editor/__pycache__/figureoptions.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c64ba59615cb33bfe982d0532dab4a9754d1b0b4
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/backends/qt_editor/__pycache__/figureoptions.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/backends/qt_editor/_formlayout.py b/lib/python3.10/site-packages/matplotlib/backends/qt_editor/_formlayout.py
new file mode 100644
index 0000000000000000000000000000000000000000..fcf73cefbac8bc41c2f02f7895706423d3676e96
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/backends/qt_editor/_formlayout.py
@@ -0,0 +1,592 @@
+"""
+formlayout
+==========
+
+Module creating Qt form dialogs/layouts to edit various type of parameters
+
+
+formlayout License Agreement (MIT License)
+------------------------------------------
+
+Copyright (c) 2009 Pierre Raybaut
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+"""
+
+# History:
+# 1.0.10: added float validator
+#         (disable "Ok" and "Apply" button when not valid)
+# 1.0.7: added support for "Apply" button
+# 1.0.6: code cleaning
+
+__version__ = '1.0.10'
+__license__ = __doc__
+
+from ast import literal_eval
+
+import copy
+import datetime
+import logging
+from numbers import Integral, Real
+
+from matplotlib import _api, colors as mcolors
+from matplotlib.backends.qt_compat import _to_int, QtGui, QtWidgets, QtCore
+
+_log = logging.getLogger(__name__)
+
+BLACKLIST = {"title", "label"}
+
+
+class ColorButton(QtWidgets.QPushButton):
+    """
+    Color choosing push button
+    """
+    colorChanged = QtCore.Signal(QtGui.QColor)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setFixedSize(20, 20)
+        self.setIconSize(QtCore.QSize(12, 12))
+        self.clicked.connect(self.choose_color)
+        self._color = QtGui.QColor()
+
+    def choose_color(self):
+        color = QtWidgets.QColorDialog.getColor(
+            self._color, self.parentWidget(), "",
+            QtWidgets.QColorDialog.ColorDialogOption.ShowAlphaChannel)
+        if color.isValid():
+            self.set_color(color)
+
+    def get_color(self):
+        return self._color
+
+    @QtCore.Slot(QtGui.QColor)
+    def set_color(self, color):
+        if color != self._color:
+            self._color = color
+            self.colorChanged.emit(self._color)
+            pixmap = QtGui.QPixmap(self.iconSize())
+            pixmap.fill(color)
+            self.setIcon(QtGui.QIcon(pixmap))
+
+    color = QtCore.Property(QtGui.QColor, get_color, set_color)
+
+
+def to_qcolor(color):
+    """Create a QColor from a matplotlib color"""
+    qcolor = QtGui.QColor()
+    try:
+        rgba = mcolors.to_rgba(color)
+    except ValueError:
+        _api.warn_external(f'Ignoring invalid color {color!r}')
+        return qcolor  # return invalid QColor
+    qcolor.setRgbF(*rgba)
+    return qcolor
+
+
+class ColorLayout(QtWidgets.QHBoxLayout):
+    """Color-specialized QLineEdit layout"""
+    def __init__(self, color, parent=None):
+        super().__init__()
+        assert isinstance(color, QtGui.QColor)
+        self.lineedit = QtWidgets.QLineEdit(
+            mcolors.to_hex(color.getRgbF(), keep_alpha=True), parent)
+        self.lineedit.editingFinished.connect(self.update_color)
+        self.addWidget(self.lineedit)
+        self.colorbtn = ColorButton(parent)
+        self.colorbtn.color = color
+        self.colorbtn.colorChanged.connect(self.update_text)
+        self.addWidget(self.colorbtn)
+
+    def update_color(self):
+        color = self.text()
+        qcolor = to_qcolor(color)  # defaults to black if not qcolor.isValid()
+        self.colorbtn.color = qcolor
+
+    def update_text(self, color):
+        self.lineedit.setText(mcolors.to_hex(color.getRgbF(), keep_alpha=True))
+
+    def text(self):
+        return self.lineedit.text()
+
+
+def font_is_installed(font):
+    """Check if font is installed"""
+    return [fam for fam in QtGui.QFontDatabase().families()
+            if str(fam) == font]
+
+
+def tuple_to_qfont(tup):
+    """
+    Create a QFont from tuple:
+        (family [string], size [int], italic [bool], bold [bool])
+    """
+    if not (isinstance(tup, tuple) and len(tup) == 4
+            and font_is_installed(tup[0])
+            and isinstance(tup[1], Integral)
+            and isinstance(tup[2], bool)
+            and isinstance(tup[3], bool)):
+        return None
+    font = QtGui.QFont()
+    family, size, italic, bold = tup
+    font.setFamily(family)
+    font.setPointSize(size)
+    font.setItalic(italic)
+    font.setBold(bold)
+    return font
+
+
+def qfont_to_tuple(font):
+    return (str(font.family()), int(font.pointSize()),
+            font.italic(), font.bold())
+
+
+class FontLayout(QtWidgets.QGridLayout):
+    """Font selection"""
+    def __init__(self, value, parent=None):
+        super().__init__()
+        font = tuple_to_qfont(value)
+        assert font is not None
+
+        # Font family
+        self.family = QtWidgets.QFontComboBox(parent)
+        self.family.setCurrentFont(font)
+        self.addWidget(self.family, 0, 0, 1, -1)
+
+        # Font size
+        self.size = QtWidgets.QComboBox(parent)
+        self.size.setEditable(True)
+        sizelist = [*range(6, 12), *range(12, 30, 2), 36, 48, 72]
+        size = font.pointSize()
+        if size not in sizelist:
+            sizelist.append(size)
+            sizelist.sort()
+        self.size.addItems([str(s) for s in sizelist])
+        self.size.setCurrentIndex(sizelist.index(size))
+        self.addWidget(self.size, 1, 0)
+
+        # Italic or not
+        self.italic = QtWidgets.QCheckBox(self.tr("Italic"), parent)
+        self.italic.setChecked(font.italic())
+        self.addWidget(self.italic, 1, 1)
+
+        # Bold or not
+        self.bold = QtWidgets.QCheckBox(self.tr("Bold"), parent)
+        self.bold.setChecked(font.bold())
+        self.addWidget(self.bold, 1, 2)
+
+    def get_font(self):
+        font = self.family.currentFont()
+        font.setItalic(self.italic.isChecked())
+        font.setBold(self.bold.isChecked())
+        font.setPointSize(int(self.size.currentText()))
+        return qfont_to_tuple(font)
+
+
+def is_edit_valid(edit):
+    text = edit.text()
+    state = edit.validator().validate(text, 0)[0]
+    return state == QtGui.QDoubleValidator.State.Acceptable
+
+
+class FormWidget(QtWidgets.QWidget):
+    update_buttons = QtCore.Signal()
+
+    def __init__(self, data, comment="", with_margin=False, parent=None):
+        """
+        Parameters
+        ----------
+        data : list of (label, value) pairs
+            The data to be edited in the form.
+        comment : str, optional
+        with_margin : bool, default: False
+            If False, the form elements reach to the border of the widget.
+            This is the desired behavior if the FormWidget is used as a widget
+            alongside with other widgets such as a QComboBox, which also do
+            not have a margin around them.
+            However, a margin can be desired if the FormWidget is the only
+            widget within a container, e.g. a tab in a QTabWidget.
+        parent : QWidget or None
+            The parent widget.
+        """
+        super().__init__(parent)
+        self.data = copy.deepcopy(data)
+        self.widgets = []
+        self.formlayout = QtWidgets.QFormLayout(self)
+        if not with_margin:
+            self.formlayout.setContentsMargins(0, 0, 0, 0)
+        if comment:
+            self.formlayout.addRow(QtWidgets.QLabel(comment))
+            self.formlayout.addRow(QtWidgets.QLabel(" "))
+
+    def get_dialog(self):
+        """Return FormDialog instance"""
+        dialog = self.parent()
+        while not isinstance(dialog, QtWidgets.QDialog):
+            dialog = dialog.parent()
+        return dialog
+
+    def setup(self):
+        for label, value in self.data:
+            if label is None and value is None:
+                # Separator: (None, None)
+                self.formlayout.addRow(QtWidgets.QLabel(" "),
+                                       QtWidgets.QLabel(" "))
+                self.widgets.append(None)
+                continue
+            elif label is None:
+                # Comment
+                self.formlayout.addRow(QtWidgets.QLabel(value))
+                self.widgets.append(None)
+                continue
+            elif tuple_to_qfont(value) is not None:
+                field = FontLayout(value, self)
+            elif (label.lower() not in BLACKLIST
+                  and mcolors.is_color_like(value)):
+                field = ColorLayout(to_qcolor(value), self)
+            elif isinstance(value, str):
+                field = QtWidgets.QLineEdit(value, self)
+            elif isinstance(value, (list, tuple)):
+                if isinstance(value, tuple):
+                    value = list(value)
+                # Note: get() below checks the type of value[0] in self.data so
+                # it is essential that value gets modified in-place.
+                # This means that the code is actually broken in the case where
+                # value is a tuple, but fortunately we always pass a list...
+                selindex = value.pop(0)
+                field = QtWidgets.QComboBox(self)
+                if isinstance(value[0], (list, tuple)):
+                    keys = [key for key, _val in value]
+                    value = [val for _key, val in value]
+                else:
+                    keys = value
+                field.addItems(value)
+                if selindex in value:
+                    selindex = value.index(selindex)
+                elif selindex in keys:
+                    selindex = keys.index(selindex)
+                elif not isinstance(selindex, Integral):
+                    _log.warning(
+                        "index '%s' is invalid (label: %s, value: %s)",
+                        selindex, label, value)
+                    selindex = 0
+                field.setCurrentIndex(selindex)
+            elif isinstance(value, bool):
+                field = QtWidgets.QCheckBox(self)
+                field.setChecked(value)
+            elif isinstance(value, Integral):
+                field = QtWidgets.QSpinBox(self)
+                field.setRange(-10**9, 10**9)
+                field.setValue(value)
+            elif isinstance(value, Real):
+                field = QtWidgets.QLineEdit(repr(value), self)
+                field.setCursorPosition(0)
+                field.setValidator(QtGui.QDoubleValidator(field))
+                field.validator().setLocale(QtCore.QLocale("C"))
+                dialog = self.get_dialog()
+                dialog.register_float_field(field)
+                field.textChanged.connect(lambda text: dialog.update_buttons())
+            elif isinstance(value, datetime.datetime):
+                field = QtWidgets.QDateTimeEdit(self)
+                field.setDateTime(value)
+            elif isinstance(value, datetime.date):
+                field = QtWidgets.QDateEdit(self)
+                field.setDate(value)
+            else:
+                field = QtWidgets.QLineEdit(repr(value), self)
+            self.formlayout.addRow(label, field)
+            self.widgets.append(field)
+
+    def get(self):
+        valuelist = []
+        for index, (label, value) in enumerate(self.data):
+            field = self.widgets[index]
+            if label is None:
+                # Separator / Comment
+                continue
+            elif tuple_to_qfont(value) is not None:
+                value = field.get_font()
+            elif isinstance(value, str) or mcolors.is_color_like(value):
+                value = str(field.text())
+            elif isinstance(value, (list, tuple)):
+                index = int(field.currentIndex())
+                if isinstance(value[0], (list, tuple)):
+                    value = value[index][0]
+                else:
+                    value = value[index]
+            elif isinstance(value, bool):
+                value = field.isChecked()
+            elif isinstance(value, Integral):
+                value = int(field.value())
+            elif isinstance(value, Real):
+                value = float(str(field.text()))
+            elif isinstance(value, datetime.datetime):
+                datetime_ = field.dateTime()
+                if hasattr(datetime_, "toPyDateTime"):
+                    value = datetime_.toPyDateTime()
+                else:
+                    value = datetime_.toPython()
+            elif isinstance(value, datetime.date):
+                date_ = field.date()
+                if hasattr(date_, "toPyDate"):
+                    value = date_.toPyDate()
+                else:
+                    value = date_.toPython()
+            else:
+                value = literal_eval(str(field.text()))
+            valuelist.append(value)
+        return valuelist
+
+
+class FormComboWidget(QtWidgets.QWidget):
+    update_buttons = QtCore.Signal()
+
+    def __init__(self, datalist, comment="", parent=None):
+        super().__init__(parent)
+        layout = QtWidgets.QVBoxLayout()
+        self.setLayout(layout)
+        self.combobox = QtWidgets.QComboBox()
+        layout.addWidget(self.combobox)
+
+        self.stackwidget = QtWidgets.QStackedWidget(self)
+        layout.addWidget(self.stackwidget)
+        self.combobox.currentIndexChanged.connect(
+            self.stackwidget.setCurrentIndex)
+
+        self.widgetlist = []
+        for data, title, comment in datalist:
+            self.combobox.addItem(title)
+            widget = FormWidget(data, comment=comment, parent=self)
+            self.stackwidget.addWidget(widget)
+            self.widgetlist.append(widget)
+
+    def setup(self):
+        for widget in self.widgetlist:
+            widget.setup()
+
+    def get(self):
+        return [widget.get() for widget in self.widgetlist]
+
+
+class FormTabWidget(QtWidgets.QWidget):
+    update_buttons = QtCore.Signal()
+
+    def __init__(self, datalist, comment="", parent=None):
+        super().__init__(parent)
+        layout = QtWidgets.QVBoxLayout()
+        self.tabwidget = QtWidgets.QTabWidget()
+        layout.addWidget(self.tabwidget)
+        layout.setContentsMargins(0, 0, 0, 0)
+        self.setLayout(layout)
+        self.widgetlist = []
+        for data, title, comment in datalist:
+            if len(data[0]) == 3:
+                widget = FormComboWidget(data, comment=comment, parent=self)
+            else:
+                widget = FormWidget(data, with_margin=True, comment=comment,
+                                    parent=self)
+            index = self.tabwidget.addTab(widget, title)
+            self.tabwidget.setTabToolTip(index, comment)
+            self.widgetlist.append(widget)
+
+    def setup(self):
+        for widget in self.widgetlist:
+            widget.setup()
+
+    def get(self):
+        return [widget.get() for widget in self.widgetlist]
+
+
+class FormDialog(QtWidgets.QDialog):
+    """Form Dialog"""
+    def __init__(self, data, title="", comment="",
+                 icon=None, parent=None, apply=None):
+        super().__init__(parent)
+
+        self.apply_callback = apply
+
+        # Form
+        if isinstance(data[0][0], (list, tuple)):
+            self.formwidget = FormTabWidget(data, comment=comment,
+                                            parent=self)
+        elif len(data[0]) == 3:
+            self.formwidget = FormComboWidget(data, comment=comment,
+                                              parent=self)
+        else:
+            self.formwidget = FormWidget(data, comment=comment,
+                                         parent=self)
+        layout = QtWidgets.QVBoxLayout()
+        layout.addWidget(self.formwidget)
+
+        self.float_fields = []
+        self.formwidget.setup()
+
+        # Button box
+        self.bbox = bbox = QtWidgets.QDialogButtonBox(
+            QtWidgets.QDialogButtonBox.StandardButton(
+                    _to_int(QtWidgets.QDialogButtonBox.StandardButton.Ok) |
+                    _to_int(QtWidgets.QDialogButtonBox.StandardButton.Cancel)
+            ))
+        self.formwidget.update_buttons.connect(self.update_buttons)
+        if self.apply_callback is not None:
+            apply_btn = bbox.addButton(
+                QtWidgets.QDialogButtonBox.StandardButton.Apply)
+            apply_btn.clicked.connect(self.apply)
+
+        bbox.accepted.connect(self.accept)
+        bbox.rejected.connect(self.reject)
+        layout.addWidget(bbox)
+
+        self.setLayout(layout)
+
+        self.setWindowTitle(title)
+        if not isinstance(icon, QtGui.QIcon):
+            icon = QtWidgets.QWidget().style().standardIcon(
+                QtWidgets.QStyle.SP_MessageBoxQuestion)
+        self.setWindowIcon(icon)
+
+    def register_float_field(self, field):
+        self.float_fields.append(field)
+
+    def update_buttons(self):
+        valid = True
+        for field in self.float_fields:
+            if not is_edit_valid(field):
+                valid = False
+        for btn_type in ["Ok", "Apply"]:
+            btn = self.bbox.button(
+                getattr(QtWidgets.QDialogButtonBox.StandardButton,
+                        btn_type))
+            if btn is not None:
+                btn.setEnabled(valid)
+
+    def accept(self):
+        self.data = self.formwidget.get()
+        self.apply_callback(self.data)
+        super().accept()
+
+    def reject(self):
+        self.data = None
+        super().reject()
+
+    def apply(self):
+        self.apply_callback(self.formwidget.get())
+
+    def get(self):
+        """Return form result"""
+        return self.data
+
+
+def fedit(data, title="", comment="", icon=None, parent=None, apply=None):
+    """
+    Create form dialog
+
+    data: datalist, datagroup
+    title: str
+    comment: str
+    icon: QIcon instance
+    parent: parent QWidget
+    apply: apply callback (function)
+
+    datalist: list/tuple of (field_name, field_value)
+    datagroup: list/tuple of (datalist *or* datagroup, title, comment)
+
+    -> one field for each member of a datalist
+    -> one tab for each member of a top-level datagroup
+    -> one page (of a multipage widget, each page can be selected with a combo
+       box) for each member of a datagroup inside a datagroup
+
+    Supported types for field_value:
+      - int, float, str, bool
+      - colors: in Qt-compatible text form, i.e. in hex format or name
+                (red, ...) (automatically detected from a string)
+      - list/tuple:
+          * the first element will be the selected index (or value)
+          * the other elements can be couples (key, value) or only values
+    """
+
+    # Create a QApplication instance if no instance currently exists
+    # (e.g., if the module is used directly from the interpreter)
+    if QtWidgets.QApplication.startingUp():
+        _app = QtWidgets.QApplication([])
+    dialog = FormDialog(data, title, comment, icon, parent, apply)
+
+    if parent is not None:
+        if hasattr(parent, "_fedit_dialog"):
+            parent._fedit_dialog.close()
+        parent._fedit_dialog = dialog
+
+    dialog.show()
+
+
+if __name__ == "__main__":
+
+    _app = QtWidgets.QApplication([])
+
+    def create_datalist_example():
+        return [('str', 'this is a string'),
+                ('list', [0, '1', '3', '4']),
+                ('list2', ['--', ('none', 'None'), ('--', 'Dashed'),
+                           ('-.', 'DashDot'), ('-', 'Solid'),
+                           ('steps', 'Steps'), (':', 'Dotted')]),
+                ('float', 1.2),
+                (None, 'Other:'),
+                ('int', 12),
+                ('font', ('Arial', 10, False, True)),
+                ('color', '#123409'),
+                ('bool', True),
+                ('date', datetime.date(2010, 10, 10)),
+                ('datetime', datetime.datetime(2010, 10, 10)),
+                ]
+
+    def create_datagroup_example():
+        datalist = create_datalist_example()
+        return ((datalist, "Category 1", "Category 1 comment"),
+                (datalist, "Category 2", "Category 2 comment"),
+                (datalist, "Category 3", "Category 3 comment"))
+
+    # --------- datalist example
+    datalist = create_datalist_example()
+
+    def apply_test(data):
+        print("data:", data)
+    fedit(datalist, title="Example",
+          comment="This is just an <b>example</b>.",
+          apply=apply_test)
+
+    _app.exec()
+
+    # --------- datagroup example
+    datagroup = create_datagroup_example()
+    fedit(datagroup, "Global title",
+          apply=apply_test)
+    _app.exec()
+
+    # --------- datagroup inside a datagroup example
+    datalist = create_datalist_example()
+    datagroup = create_datagroup_example()
+    fedit(((datagroup, "Title 1", "Tab 1 comment"),
+           (datalist, "Title 2", "Tab 2 comment"),
+           (datalist, "Title 3", "Tab 3 comment")),
+          "Global title",
+          apply=apply_test)
+    _app.exec()
diff --git a/lib/python3.10/site-packages/matplotlib/backends/qt_editor/figureoptions.py b/lib/python3.10/site-packages/matplotlib/backends/qt_editor/figureoptions.py
new file mode 100644
index 0000000000000000000000000000000000000000..9d31fa9ced2ca24961597eddcc5e3e0f36f8fad8
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/backends/qt_editor/figureoptions.py
@@ -0,0 +1,271 @@
+# Copyright © 2009 Pierre Raybaut
+# Licensed under the terms of the MIT License
+# see the Matplotlib licenses directory for a copy of the license
+
+
+"""Module that provides a GUI-based editor for Matplotlib's figure options."""
+
+from itertools import chain
+from matplotlib import cbook, cm, colors as mcolors, markers, image as mimage
+from matplotlib.backends.qt_compat import QtGui
+from matplotlib.backends.qt_editor import _formlayout
+from matplotlib.dates import DateConverter, num2date
+
+LINESTYLES = {'-': 'Solid',
+              '--': 'Dashed',
+              '-.': 'DashDot',
+              ':': 'Dotted',
+              'None': 'None',
+              }
+
+DRAWSTYLES = {
+    'default': 'Default',
+    'steps-pre': 'Steps (Pre)', 'steps': 'Steps (Pre)',
+    'steps-mid': 'Steps (Mid)',
+    'steps-post': 'Steps (Post)'}
+
+MARKERS = markers.MarkerStyle.markers
+
+
+def figure_edit(axes, parent=None):
+    """Edit matplotlib figure options"""
+    sep = (None, None)  # separator
+
+    # Get / General
+    def convert_limits(lim, converter):
+        """Convert axis limits for correct input editors."""
+        if isinstance(converter, DateConverter):
+            return map(num2date, lim)
+        # Cast to builtin floats as they have nicer reprs.
+        return map(float, lim)
+
+    axis_map = axes._axis_map
+    axis_limits = {
+        name: tuple(convert_limits(
+            getattr(axes, f'get_{name}lim')(), axis.get_converter()
+        ))
+        for name, axis in axis_map.items()
+    }
+    general = [
+        ('Title', axes.get_title()),
+        sep,
+        *chain.from_iterable([
+            (
+                (None, f"<b>{name.title()}-Axis</b>"),
+                ('Min', axis_limits[name][0]),
+                ('Max', axis_limits[name][1]),
+                ('Label', axis.label.get_text()),
+                ('Scale', [axis.get_scale(),
+                           'linear', 'log', 'symlog', 'logit']),
+                sep,
+            )
+            for name, axis in axis_map.items()
+        ]),
+        ('(Re-)Generate automatic legend', False),
+    ]
+
+    # Save the converter and unit data
+    axis_converter = {
+        name: axis.get_converter()
+        for name, axis in axis_map.items()
+    }
+    axis_units = {
+        name: axis.get_units()
+        for name, axis in axis_map.items()
+    }
+
+    # Get / Curves
+    labeled_lines = []
+    for line in axes.get_lines():
+        label = line.get_label()
+        if label == '_nolegend_':
+            continue
+        labeled_lines.append((label, line))
+    curves = []
+
+    def prepare_data(d, init):
+        """
+        Prepare entry for FormLayout.
+
+        *d* is a mapping of shorthands to style names (a single style may
+        have multiple shorthands, in particular the shorthands `None`,
+        `"None"`, `"none"` and `""` are synonyms); *init* is one shorthand
+        of the initial style.
+
+        This function returns an list suitable for initializing a
+        FormLayout combobox, namely `[initial_name, (shorthand,
+        style_name), (shorthand, style_name), ...]`.
+        """
+        if init not in d:
+            d = {**d, init: str(init)}
+        # Drop duplicate shorthands from dict (by overwriting them during
+        # the dict comprehension).
+        name2short = {name: short for short, name in d.items()}
+        # Convert back to {shorthand: name}.
+        short2name = {short: name for name, short in name2short.items()}
+        # Find the kept shorthand for the style specified by init.
+        canonical_init = name2short[d[init]]
+        # Sort by representation and prepend the initial value.
+        return ([canonical_init] +
+                sorted(short2name.items(),
+                       key=lambda short_and_name: short_and_name[1]))
+
+    for label, line in labeled_lines:
+        color = mcolors.to_hex(
+            mcolors.to_rgba(line.get_color(), line.get_alpha()),
+            keep_alpha=True)
+        ec = mcolors.to_hex(
+            mcolors.to_rgba(line.get_markeredgecolor(), line.get_alpha()),
+            keep_alpha=True)
+        fc = mcolors.to_hex(
+            mcolors.to_rgba(line.get_markerfacecolor(), line.get_alpha()),
+            keep_alpha=True)
+        curvedata = [
+            ('Label', label),
+            sep,
+            (None, '<b>Line</b>'),
+            ('Line style', prepare_data(LINESTYLES, line.get_linestyle())),
+            ('Draw style', prepare_data(DRAWSTYLES, line.get_drawstyle())),
+            ('Width', line.get_linewidth()),
+            ('Color (RGBA)', color),
+            sep,
+            (None, '<b>Marker</b>'),
+            ('Style', prepare_data(MARKERS, line.get_marker())),
+            ('Size', line.get_markersize()),
+            ('Face color (RGBA)', fc),
+            ('Edge color (RGBA)', ec)]
+        curves.append([curvedata, label, ""])
+    # Is there a curve displayed?
+    has_curve = bool(curves)
+
+    # Get ScalarMappables.
+    labeled_mappables = []
+    for mappable in [*axes.images, *axes.collections]:
+        label = mappable.get_label()
+        if label == '_nolegend_' or mappable.get_array() is None:
+            continue
+        labeled_mappables.append((label, mappable))
+    mappables = []
+    cmaps = [(cmap, name) for name, cmap in sorted(cm._colormaps.items())]
+    for label, mappable in labeled_mappables:
+        cmap = mappable.get_cmap()
+        if cmap.name not in cm._colormaps:
+            cmaps = [(cmap, cmap.name), *cmaps]
+        low, high = mappable.get_clim()
+        mappabledata = [
+            ('Label', label),
+            ('Colormap', [cmap.name] + cmaps),
+            ('Min. value', low),
+            ('Max. value', high),
+        ]
+        if hasattr(mappable, "get_interpolation"):  # Images.
+            interpolations = [
+                (name, name) for name in sorted(mimage.interpolations_names)]
+            mappabledata.append((
+                'Interpolation',
+                [mappable.get_interpolation(), *interpolations]))
+
+            interpolation_stages = ['data', 'rgba', 'auto']
+            mappabledata.append((
+                'Interpolation stage',
+                [mappable.get_interpolation_stage(), *interpolation_stages]))
+
+        mappables.append([mappabledata, label, ""])
+    # Is there a scalarmappable displayed?
+    has_sm = bool(mappables)
+
+    datalist = [(general, "Axes", "")]
+    if curves:
+        datalist.append((curves, "Curves", ""))
+    if mappables:
+        datalist.append((mappables, "Images, etc.", ""))
+
+    def apply_callback(data):
+        """A callback to apply changes."""
+        orig_limits = {
+            name: getattr(axes, f"get_{name}lim")()
+            for name in axis_map
+        }
+
+        general = data.pop(0)
+        curves = data.pop(0) if has_curve else []
+        mappables = data.pop(0) if has_sm else []
+        if data:
+            raise ValueError("Unexpected field")
+
+        title = general.pop(0)
+        axes.set_title(title)
+        generate_legend = general.pop()
+
+        for i, (name, axis) in enumerate(axis_map.items()):
+            axis_min = general[4*i]
+            axis_max = general[4*i + 1]
+            axis_label = general[4*i + 2]
+            axis_scale = general[4*i + 3]
+            if axis.get_scale() != axis_scale:
+                getattr(axes, f"set_{name}scale")(axis_scale)
+
+            axis._set_lim(axis_min, axis_max, auto=False)
+            axis.set_label_text(axis_label)
+
+            # Restore the unit data
+            axis._set_converter(axis_converter[name])
+            axis.set_units(axis_units[name])
+
+        # Set / Curves
+        for index, curve in enumerate(curves):
+            line = labeled_lines[index][1]
+            (label, linestyle, drawstyle, linewidth, color, marker, markersize,
+             markerfacecolor, markeredgecolor) = curve
+            line.set_label(label)
+            line.set_linestyle(linestyle)
+            line.set_drawstyle(drawstyle)
+            line.set_linewidth(linewidth)
+            rgba = mcolors.to_rgba(color)
+            line.set_alpha(None)
+            line.set_color(rgba)
+            if marker != 'none':
+                line.set_marker(marker)
+                line.set_markersize(markersize)
+                line.set_markerfacecolor(markerfacecolor)
+                line.set_markeredgecolor(markeredgecolor)
+
+        # Set ScalarMappables.
+        for index, mappable_settings in enumerate(mappables):
+            mappable = labeled_mappables[index][1]
+            if len(mappable_settings) == 6:
+                label, cmap, low, high, interpolation, interpolation_stage = \
+                  mappable_settings
+                mappable.set_interpolation(interpolation)
+                mappable.set_interpolation_stage(interpolation_stage)
+            elif len(mappable_settings) == 4:
+                label, cmap, low, high = mappable_settings
+            mappable.set_label(label)
+            mappable.set_cmap(cmap)
+            mappable.set_clim(*sorted([low, high]))
+
+        # re-generate legend, if checkbox is checked
+        if generate_legend:
+            draggable = None
+            ncols = 1
+            if axes.legend_ is not None:
+                old_legend = axes.get_legend()
+                draggable = old_legend._draggable is not None
+                ncols = old_legend._ncols
+            new_legend = axes.legend(ncols=ncols)
+            if new_legend:
+                new_legend.set_draggable(draggable)
+
+        # Redraw
+        figure = axes.get_figure()
+        figure.canvas.draw()
+        for name in axis_map:
+            if getattr(axes, f"get_{name}lim")() != orig_limits[name]:
+                figure.canvas.toolbar.push_current()
+                break
+
+    _formlayout.fedit(
+        datalist, title="Figure options", parent=parent,
+        icon=QtGui.QIcon(
+            str(cbook._get_data_path('images', 'qt4_editor_options.svg'))),
+        apply=apply_callback)
diff --git a/lib/python3.10/site-packages/matplotlib/backends/web_backend/all_figures.html b/lib/python3.10/site-packages/matplotlib/backends/web_backend/all_figures.html
new file mode 100644
index 0000000000000000000000000000000000000000..62f04b65c9bf6b72e7b5de2c25e46a1b88109c89
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/backends/web_backend/all_figures.html
@@ -0,0 +1,52 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <link rel="stylesheet" href="{{ prefix }}/_static/css/page.css" type="text/css">
+    <link rel="stylesheet" href="{{ prefix }}/_static/css/boilerplate.css" type="text/css">
+    <link rel="stylesheet" href="{{ prefix }}/_static/css/fbm.css" type="text/css">
+    <link rel="stylesheet" href="{{ prefix }}/_static/css/mpl.css" type="text/css">
+    <script src="{{ prefix }}/_static/js/mpl_tornado.js"></script>
+    <script src="{{ prefix }}/js/mpl.js"></script>
+
+    <script>
+      function ready(fn) {
+        if (document.readyState != "loading") {
+          fn();
+        } else {
+          document.addEventListener("DOMContentLoaded", fn);
+        }
+      }
+
+      function figure_ready(fig_id) {
+        return function () {
+          var main_div = document.querySelector("div#figures");
+          var figure_div = document.createElement("div");
+          figure_div.id = "figure-div";
+          main_div.appendChild(figure_div);
+          var websocket_type = mpl.get_websocket_type();
+          var uri = "{{ ws_uri }}" + fig_id + "/ws";
+          if (window.location.protocol === "https:") uri = uri.replace('ws:', 'wss:')
+          var websocket = new websocket_type(uri);
+          var fig = new mpl.figure(fig_id, websocket, mpl_ondownload, figure_div);
+
+          fig.focus_on_mouseover = true;
+
+          fig.canvas.setAttribute("tabindex", fig_id);
+        }
+      };
+
+      {% for (fig_id, fig_manager) in figures %}
+        ready(figure_ready({{ str(fig_id) }}));
+      {% end %}
+    </script>
+
+  <title>MPL | WebAgg current figures</title>
+
+  </head>
+  <body>
+    <div id="mpl-warnings" class="mpl-warnings"></div>
+
+    <div id="figures" style="margin: 10px 10px;"></div>
+
+  </body>
+</html>
diff --git a/lib/python3.10/site-packages/matplotlib/backends/web_backend/css/boilerplate.css b/lib/python3.10/site-packages/matplotlib/backends/web_backend/css/boilerplate.css
new file mode 100644
index 0000000000000000000000000000000000000000..2b1535f4495e6f2242a09f6c822a01e34389bd98
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/backends/web_backend/css/boilerplate.css
@@ -0,0 +1,77 @@
+/**
+ * HTML5 ✰ Boilerplate
+ *
+ * style.css contains a reset, font normalization and some base styles.
+ *
+ * Credit is left where credit is due.
+ * Much inspiration was taken from these projects:
+ * - yui.yahooapis.com/2.8.1/build/base/base.css
+ * - camendesign.com/design/
+ * - praegnanz.de/weblog/htmlcssjs-kickstart
+ */
+
+
+/**
+ * html5doctor.com Reset Stylesheet (Eric Meyer's Reset Reloaded + HTML5 baseline)
+ * v1.6.1 2010-09-17 | Authors: Eric Meyer & Richard Clark
+ * html5doctor.com/html-5-reset-stylesheet/
+ */
+
+html, body, div, span, object, iframe,
+h1, h2, h3, h4, h5, h6, p, blockquote, pre,
+abbr, address, cite, code, del, dfn, em, img, ins, kbd, q, samp,
+small, strong, sub, sup, var, b, i, dl, dt, dd, ol, ul, li,
+fieldset, form, label, legend,
+table, caption, tbody, tfoot, thead, tr, th, td,
+article, aside, canvas, details, figcaption, figure,
+footer, header, hgroup, menu, nav, section, summary,
+time, mark, audio, video {
+  margin: 0;
+  padding: 0;
+  border: 0;
+  font-size: 100%;
+  font: inherit;
+  vertical-align: baseline;
+}
+
+sup { vertical-align: super; }
+sub { vertical-align: sub; }
+
+article, aside, details, figcaption, figure,
+footer, header, hgroup, menu, nav, section {
+  display: block;
+}
+
+blockquote, q { quotes: none; }
+
+blockquote:before, blockquote:after,
+q:before, q:after { content: ""; content: none; }
+
+ins { background-color: #ff9; color: #000; text-decoration: none; }
+
+mark { background-color: #ff9; color: #000; font-style: italic; font-weight: bold; }
+
+del { text-decoration: line-through; }
+
+abbr[title], dfn[title] { border-bottom: 1px dotted; cursor: help; }
+
+table { border-collapse: collapse; border-spacing: 0; }
+
+hr { display: block; height: 1px; border: 0; border-top: 1px solid #ccc; margin: 1em 0; padding: 0; }
+
+input, select { vertical-align: middle; }
+
+
+/**
+ * Font normalization inspired by YUI Library's fonts.css: developer.yahoo.com/yui/
+ */
+
+body { font:13px/1.231 sans-serif; *font-size:small; } /* Hack retained to preserve specificity */
+select, input, textarea, button { font:99% sans-serif; }
+
+/* Normalize monospace sizing:
+   en.wikipedia.org/wiki/MediaWiki_talk:Common.css/Archive_11#Teletype_style_fix_for_Chrome */
+pre, code, kbd, samp { font-family: monospace, sans-serif; }
+
+em,i { font-style: italic; }
+b,strong { font-weight: bold; }
diff --git a/lib/python3.10/site-packages/matplotlib/backends/web_backend/css/fbm.css b/lib/python3.10/site-packages/matplotlib/backends/web_backend/css/fbm.css
new file mode 100644
index 0000000000000000000000000000000000000000..ce35d99a5e64c2e42a368aa61cd41ddb563d9ddd
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/backends/web_backend/css/fbm.css
@@ -0,0 +1,97 @@
+
+/* Flexible box model classes */
+/* Taken from Alex Russell https://infrequently.org/2009/08/css-3-progress/ */
+
+.hbox {
+	display: -webkit-box;
+	-webkit-box-orient: horizontal;
+	-webkit-box-align: stretch;
+
+	display: -moz-box;
+	-moz-box-orient: horizontal;
+	-moz-box-align: stretch;
+
+	display: box;
+	box-orient: horizontal;
+	box-align: stretch;
+}
+
+.hbox > * {
+	-webkit-box-flex: 0;
+	-moz-box-flex: 0;
+	box-flex: 0;
+}
+
+.vbox {
+	display: -webkit-box;
+	-webkit-box-orient: vertical;
+	-webkit-box-align: stretch;
+
+	display: -moz-box;
+	-moz-box-orient: vertical;
+	-moz-box-align: stretch;
+
+	display: box;
+	box-orient: vertical;
+	box-align: stretch;
+}
+
+.vbox > * {
+	-webkit-box-flex: 0;
+	-moz-box-flex: 0;
+	box-flex: 0;
+}
+
+.reverse {
+	-webkit-box-direction: reverse;
+	-moz-box-direction: reverse;
+	box-direction: reverse;
+}
+
+.box-flex0 {
+	-webkit-box-flex: 0;
+	-moz-box-flex: 0;
+	box-flex: 0;
+}
+
+.box-flex1, .box-flex {
+	-webkit-box-flex: 1;
+	-moz-box-flex: 1;
+	box-flex: 1;
+}
+
+.box-flex2 {
+	-webkit-box-flex: 2;
+	-moz-box-flex: 2;
+	box-flex: 2;
+}
+
+.box-group1 {
+	-webkit-box-flex-group: 1;
+	-moz-box-flex-group: 1;
+	box-flex-group: 1;
+}
+
+.box-group2 {
+	-webkit-box-flex-group: 2;
+	-moz-box-flex-group: 2;
+	box-flex-group: 2;
+}
+
+.start {
+	-webkit-box-pack: start;
+	-moz-box-pack: start;
+	box-pack: start;
+}
+
+.end {
+	-webkit-box-pack: end;
+	-moz-box-pack: end;
+	box-pack: end;
+}
+
+.center {
+	-webkit-box-pack: center;
+	-moz-box-pack: center;
+	box-pack: center;
+}
diff --git a/lib/python3.10/site-packages/matplotlib/backends/web_backend/css/mpl.css b/lib/python3.10/site-packages/matplotlib/backends/web_backend/css/mpl.css
new file mode 100644
index 0000000000000000000000000000000000000000..e55733d25ecfc6237aa8052c1fc2b7e3f356da23
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/backends/web_backend/css/mpl.css
@@ -0,0 +1,84 @@
+/* General styling */
+.ui-helper-clearfix:before,
+.ui-helper-clearfix:after {
+  content: "";
+  display: table;
+  border-collapse: collapse;
+}
+.ui-helper-clearfix:after {
+  clear: both;
+}
+
+/* Header */
+.ui-widget-header {
+  border: 1px solid #dddddd;
+  border-top-left-radius: 6px;
+  border-top-right-radius: 6px;
+  background: #e9e9e9;
+  color: #333333;
+  font-weight: bold;
+}
+
+/* Toolbar and items */
+.mpl-toolbar {
+  width: 100%;
+}
+
+.mpl-toolbar div.mpl-button-group {
+  display: inline-block;
+}
+
+.mpl-button-group + .mpl-button-group {
+  margin-left: 0.5em;
+}
+
+.mpl-widget {
+  background-color: #fff;
+  border: 1px solid #ccc;
+  display: inline-block;
+  cursor: pointer;
+  color: #333;
+  padding: 6px;
+  vertical-align: middle;
+}
+
+.mpl-widget:disabled,
+.mpl-widget[disabled] {
+  background-color: #ddd;
+  border-color: #ddd !important;
+  cursor: not-allowed;
+}
+
+.mpl-widget:disabled img,
+.mpl-widget[disabled] img {
+  /* Convert black to grey */
+  filter: contrast(0%);
+}
+
+.mpl-widget.active img {
+  /* Convert black to tab:blue, approximately */
+  filter: invert(34%) sepia(97%) saturate(468%) hue-rotate(162deg) brightness(96%) contrast(91%);
+}
+
+button.mpl-widget:focus,
+button.mpl-widget:hover {
+  background-color: #ddd;
+  border-color: #aaa;
+}
+
+.mpl-button-group button.mpl-widget {
+  margin-left: -1px;
+}
+.mpl-button-group button.mpl-widget:first-child {
+  border-top-left-radius: 6px;
+  border-bottom-left-radius: 6px;
+  margin-left: 0px;
+}
+.mpl-button-group button.mpl-widget:last-child {
+  border-top-right-radius: 6px;
+  border-bottom-right-radius: 6px;
+}
+
+select.mpl-widget {
+  cursor: default;
+}
diff --git a/lib/python3.10/site-packages/matplotlib/backends/web_backend/css/page.css b/lib/python3.10/site-packages/matplotlib/backends/web_backend/css/page.css
new file mode 100644
index 0000000000000000000000000000000000000000..ded0d92203790eaaab21feea83930611acec51f0
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/backends/web_backend/css/page.css
@@ -0,0 +1,82 @@
+/**
+ * Primary styles
+ *
+ * Author: IPython Development Team
+ */
+
+
+body {
+    background-color: white;
+    /* This makes sure that the body covers the entire window and needs to
+       be in a different element than the display: box in wrapper below */
+    position: absolute;
+    left: 0px;
+    right: 0px;
+    top: 0px;
+    bottom: 0px;
+    overflow: visible;
+}
+
+
+div#header {
+    /* Initially hidden to prevent FLOUC */
+    display: none;
+    position: relative;
+    height: 40px;
+    padding: 5px;
+    margin: 0px;
+    width: 100%;
+}
+
+span#ipython_notebook {
+    position: absolute;
+    padding: 2px 2px 2px 5px;
+}
+
+span#ipython_notebook img {
+    font-family: Verdana, "Helvetica Neue", Arial, Helvetica, Geneva, sans-serif;
+    height: 24px;
+    text-decoration:none;
+    display: inline;
+    color: black;
+}
+
+#site {
+    width: 100%;
+    display: none;
+}
+
+/* We set the fonts by hand here to override the values in the theme */
+.ui-widget {
+    font-family: "Lucinda Grande", "Lucinda Sans Unicode", Helvetica, Arial, Verdana, sans-serif;
+}
+
+.ui-widget input, .ui-widget select, .ui-widget textarea, .ui-widget button {
+    font-family: "Lucinda Grande", "Lucinda Sans Unicode", Helvetica, Arial, Verdana, sans-serif;
+}
+
+/* Smaller buttons */
+.ui-button .ui-button-text {
+    padding: 0.2em 0.8em;
+    font-size: 77%;
+}
+
+input.ui-button {
+    padding: 0.3em 0.9em;
+}
+
+span#login_widget {
+    float: right;
+}
+
+.border-box-sizing {
+    box-sizing: border-box;
+    -moz-box-sizing: border-box;
+    -webkit-box-sizing: border-box;
+}
+
+#figure-div {
+    display: inline-block;
+    margin: 10px;
+    vertical-align: top;
+}
diff --git a/lib/python3.10/site-packages/matplotlib/backends/web_backend/ipython_inline_figure.html b/lib/python3.10/site-packages/matplotlib/backends/web_backend/ipython_inline_figure.html
new file mode 100644
index 0000000000000000000000000000000000000000..b941d352a7d6ca1351b7fb9879386c2d391e9be7
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/backends/web_backend/ipython_inline_figure.html
@@ -0,0 +1,34 @@
+<!-- Within the kernel, we don't know the address of the matplotlib
+     websocket server, so we have to get in client-side and fetch our
+     resources that way. -->
+<script>
+  // We can't proceed until these JavaScript files are fetched, so
+  // we fetch them synchronously
+  $.ajaxSetup({async: false});
+  $.getScript("http://" + window.location.hostname + ":{{ port }}{{prefix}}/_static/js/mpl_tornado.js");
+  $.getScript("http://" + window.location.hostname + ":{{ port }}{{prefix}}/js/mpl.js");
+  $.ajaxSetup({async: true});
+
+  function init_figure{{ fig_id }}(e) {
+    $('div.output').off('resize');
+
+    var output_div = e.target.querySelector('div.output_subarea');
+    var websocket_type = mpl.get_websocket_type();
+    var websocket = new websocket_type(
+        "ws://" + window.location.hostname + ":{{ port }}{{ prefix}}/" +
+        {{ repr(str(fig_id)) }} + "/ws");
+
+    var fig = new mpl.figure(
+        {{repr(str(fig_id))}}, websocket, mpl_ondownload, output_div);
+
+    // Fetch the first image
+    fig.context.drawImage(fig.imageObj, 0, 0);
+
+    fig.focus_on_mouseover = true;
+  }
+
+  // We can't initialize the figure contents until our content
+  // has been added to the DOM.  This is a bit of hack to get an
+  // event for that.
+  $('div.output').resize(init_figure{{ fig_id }});
+</script>
diff --git a/lib/python3.10/site-packages/matplotlib/backends/web_backend/js/mpl.js b/lib/python3.10/site-packages/matplotlib/backends/web_backend/js/mpl.js
new file mode 100644
index 0000000000000000000000000000000000000000..2d1f383e9839508df2ec05201b8d7cf8dae767ba
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/backends/web_backend/js/mpl.js
@@ -0,0 +1,705 @@
+/* Put everything inside the global mpl namespace */
+/* global mpl */
+window.mpl = {};
+
+mpl.get_websocket_type = function () {
+    if (typeof WebSocket !== 'undefined') {
+        return WebSocket;
+    } else if (typeof MozWebSocket !== 'undefined') {
+        return MozWebSocket;
+    } else {
+        alert(
+            'Your browser does not have WebSocket support. ' +
+                'Please try Chrome, Safari or Firefox ≥ 6. ' +
+                'Firefox 4 and 5 are also supported but you ' +
+                'have to enable WebSockets in about:config.'
+        );
+    }
+};
+
+mpl.figure = function (figure_id, websocket, ondownload, parent_element) {
+    this.id = figure_id;
+
+    this.ws = websocket;
+
+    this.supports_binary = this.ws.binaryType !== undefined;
+
+    if (!this.supports_binary) {
+        var warnings = document.getElementById('mpl-warnings');
+        if (warnings) {
+            warnings.style.display = 'block';
+            warnings.textContent =
+                'This browser does not support binary websocket messages. ' +
+                'Performance may be slow.';
+        }
+    }
+
+    this.imageObj = new Image();
+
+    this.context = undefined;
+    this.message = undefined;
+    this.canvas = undefined;
+    this.rubberband_canvas = undefined;
+    this.rubberband_context = undefined;
+    this.format_dropdown = undefined;
+
+    this.image_mode = 'full';
+
+    this.root = document.createElement('div');
+    this.root.setAttribute('style', 'display: inline-block');
+    this._root_extra_style(this.root);
+
+    parent_element.appendChild(this.root);
+
+    this._init_header(this);
+    this._init_canvas(this);
+    this._init_toolbar(this);
+
+    var fig = this;
+
+    this.waiting = false;
+
+    this.ws.onopen = function () {
+        fig.send_message('supports_binary', { value: fig.supports_binary });
+        fig.send_message('send_image_mode', {});
+        if (fig.ratio !== 1) {
+            fig.send_message('set_device_pixel_ratio', {
+                device_pixel_ratio: fig.ratio,
+            });
+        }
+        fig.send_message('refresh', {});
+    };
+
+    this.imageObj.onload = function () {
+        if (fig.image_mode === 'full') {
+            // Full images could contain transparency (where diff images
+            // almost always do), so we need to clear the canvas so that
+            // there is no ghosting.
+            fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);
+        }
+        fig.context.drawImage(fig.imageObj, 0, 0);
+    };
+
+    this.imageObj.onunload = function () {
+        fig.ws.close();
+    };
+
+    this.ws.onmessage = this._make_on_message_function(this);
+
+    this.ondownload = ondownload;
+};
+
+mpl.figure.prototype._init_header = function () {
+    var titlebar = document.createElement('div');
+    titlebar.classList =
+        'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';
+    var titletext = document.createElement('div');
+    titletext.classList = 'ui-dialog-title';
+    titletext.setAttribute(
+        'style',
+        'width: 100%; text-align: center; padding: 3px;'
+    );
+    titlebar.appendChild(titletext);
+    this.root.appendChild(titlebar);
+    this.header = titletext;
+};
+
+mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};
+
+mpl.figure.prototype._root_extra_style = function (_canvas_div) {};
+
+mpl.figure.prototype._init_canvas = function () {
+    var fig = this;
+
+    var canvas_div = (this.canvas_div = document.createElement('div'));
+    canvas_div.setAttribute('tabindex', '0');
+    canvas_div.setAttribute(
+        'style',
+        'border: 1px solid #ddd;' +
+            'box-sizing: content-box;' +
+            'clear: both;' +
+            'min-height: 1px;' +
+            'min-width: 1px;' +
+            'outline: 0;' +
+            'overflow: hidden;' +
+            'position: relative;' +
+            'resize: both;' +
+            'z-index: 2;'
+    );
+
+    function on_keyboard_event_closure(name) {
+        return function (event) {
+            return fig.key_event(event, name);
+        };
+    }
+
+    canvas_div.addEventListener(
+        'keydown',
+        on_keyboard_event_closure('key_press')
+    );
+    canvas_div.addEventListener(
+        'keyup',
+        on_keyboard_event_closure('key_release')
+    );
+
+    this._canvas_extra_style(canvas_div);
+    this.root.appendChild(canvas_div);
+
+    var canvas = (this.canvas = document.createElement('canvas'));
+    canvas.classList.add('mpl-canvas');
+    canvas.setAttribute(
+        'style',
+        'box-sizing: content-box;' +
+            'pointer-events: none;' +
+            'position: relative;' +
+            'z-index: 0;'
+    );
+
+    this.context = canvas.getContext('2d');
+
+    var backingStore =
+        this.context.backingStorePixelRatio ||
+        this.context.webkitBackingStorePixelRatio ||
+        this.context.mozBackingStorePixelRatio ||
+        this.context.msBackingStorePixelRatio ||
+        this.context.oBackingStorePixelRatio ||
+        this.context.backingStorePixelRatio ||
+        1;
+
+    this.ratio = (window.devicePixelRatio || 1) / backingStore;
+
+    var rubberband_canvas = (this.rubberband_canvas = document.createElement(
+        'canvas'
+    ));
+    rubberband_canvas.setAttribute(
+        'style',
+        'box-sizing: content-box;' +
+            'left: 0;' +
+            'pointer-events: none;' +
+            'position: absolute;' +
+            'top: 0;' +
+            'z-index: 1;'
+    );
+
+    // Apply a ponyfill if ResizeObserver is not implemented by browser.
+    if (this.ResizeObserver === undefined) {
+        if (window.ResizeObserver !== undefined) {
+            this.ResizeObserver = window.ResizeObserver;
+        } else {
+            var obs = _JSXTOOLS_RESIZE_OBSERVER({});
+            this.ResizeObserver = obs.ResizeObserver;
+        }
+    }
+
+    this.resizeObserverInstance = new this.ResizeObserver(function (entries) {
+        // There's no need to resize if the WebSocket is not connected:
+        // - If it is still connecting, then we will get an initial resize from
+        //   Python once it connects.
+        // - If it has disconnected, then resizing will clear the canvas and
+        //   never get anything back to refill it, so better to not resize and
+        //   keep something visible.
+        if (fig.ws.readyState != 1) {
+            return;
+        }
+        var nentries = entries.length;
+        for (var i = 0; i < nentries; i++) {
+            var entry = entries[i];
+            var width, height;
+            if (entry.contentBoxSize) {
+                if (entry.contentBoxSize instanceof Array) {
+                    // Chrome 84 implements new version of spec.
+                    width = entry.contentBoxSize[0].inlineSize;
+                    height = entry.contentBoxSize[0].blockSize;
+                } else {
+                    // Firefox implements old version of spec.
+                    width = entry.contentBoxSize.inlineSize;
+                    height = entry.contentBoxSize.blockSize;
+                }
+            } else {
+                // Chrome <84 implements even older version of spec.
+                width = entry.contentRect.width;
+                height = entry.contentRect.height;
+            }
+
+            // Keep the size of the canvas and rubber band canvas in sync with
+            // the canvas container.
+            if (entry.devicePixelContentBoxSize) {
+                // Chrome 84 implements new version of spec.
+                canvas.setAttribute(
+                    'width',
+                    entry.devicePixelContentBoxSize[0].inlineSize
+                );
+                canvas.setAttribute(
+                    'height',
+                    entry.devicePixelContentBoxSize[0].blockSize
+                );
+            } else {
+                canvas.setAttribute('width', width * fig.ratio);
+                canvas.setAttribute('height', height * fig.ratio);
+            }
+            /* This rescales the canvas back to display pixels, so that it
+             * appears correct on HiDPI screens. */
+            canvas.style.width = width + 'px';
+            canvas.style.height = height + 'px';
+
+            rubberband_canvas.setAttribute('width', width);
+            rubberband_canvas.setAttribute('height', height);
+
+            // And update the size in Python. We ignore the initial 0/0 size
+            // that occurs as the element is placed into the DOM, which should
+            // otherwise not happen due to the minimum size styling.
+            if (width != 0 && height != 0) {
+                fig.request_resize(width, height);
+            }
+        }
+    });
+    this.resizeObserverInstance.observe(canvas_div);
+
+    function on_mouse_event_closure(name) {
+        /* User Agent sniffing is bad, but WebKit is busted:
+         * https://bugs.webkit.org/show_bug.cgi?id=144526
+         * https://bugs.webkit.org/show_bug.cgi?id=181818
+         * The worst that happens here is that they get an extra browser
+         * selection when dragging, if this check fails to catch them.
+         */
+        var UA = navigator.userAgent;
+        var isWebKit = /AppleWebKit/.test(UA) && !/Chrome/.test(UA);
+        if(isWebKit) {
+            return function (event) {
+                /* This prevents the web browser from automatically changing to
+                 * the text insertion cursor when the button is pressed. We
+                 * want to control all of the cursor setting manually through
+                 * the 'cursor' event from matplotlib */
+                event.preventDefault()
+                return fig.mouse_event(event, name);
+            };
+        } else {
+            return function (event) {
+                return fig.mouse_event(event, name);
+            };
+        }
+    }
+
+    canvas_div.addEventListener(
+        'mousedown',
+        on_mouse_event_closure('button_press')
+    );
+    canvas_div.addEventListener(
+        'mouseup',
+        on_mouse_event_closure('button_release')
+    );
+    canvas_div.addEventListener(
+        'dblclick',
+        on_mouse_event_closure('dblclick')
+    );
+    // Throttle sequential mouse events to 1 every 20ms.
+    canvas_div.addEventListener(
+        'mousemove',
+        on_mouse_event_closure('motion_notify')
+    );
+
+    canvas_div.addEventListener(
+        'mouseenter',
+        on_mouse_event_closure('figure_enter')
+    );
+    canvas_div.addEventListener(
+        'mouseleave',
+        on_mouse_event_closure('figure_leave')
+    );
+
+    canvas_div.addEventListener('wheel', function (event) {
+        if (event.deltaY < 0) {
+            event.step = 1;
+        } else {
+            event.step = -1;
+        }
+        on_mouse_event_closure('scroll')(event);
+    });
+
+    canvas_div.appendChild(canvas);
+    canvas_div.appendChild(rubberband_canvas);
+
+    this.rubberband_context = rubberband_canvas.getContext('2d');
+    this.rubberband_context.strokeStyle = '#000000';
+
+    this._resize_canvas = function (width, height, forward) {
+        if (forward) {
+            canvas_div.style.width = width + 'px';
+            canvas_div.style.height = height + 'px';
+        }
+    };
+
+    // Disable right mouse context menu.
+    canvas_div.addEventListener('contextmenu', function (_e) {
+        event.preventDefault();
+        return false;
+    });
+
+    function set_focus() {
+        canvas.focus();
+        canvas_div.focus();
+    }
+
+    window.setTimeout(set_focus, 100);
+};
+
+mpl.figure.prototype._init_toolbar = function () {
+    var fig = this;
+
+    var toolbar = document.createElement('div');
+    toolbar.classList = 'mpl-toolbar';
+    this.root.appendChild(toolbar);
+
+    function on_click_closure(name) {
+        return function (_event) {
+            return fig.toolbar_button_onclick(name);
+        };
+    }
+
+    function on_mouseover_closure(tooltip) {
+        return function (event) {
+            if (!event.currentTarget.disabled) {
+                return fig.toolbar_button_onmouseover(tooltip);
+            }
+        };
+    }
+
+    fig.buttons = {};
+    var buttonGroup = document.createElement('div');
+    buttonGroup.classList = 'mpl-button-group';
+    for (var toolbar_ind in mpl.toolbar_items) {
+        var name = mpl.toolbar_items[toolbar_ind][0];
+        var tooltip = mpl.toolbar_items[toolbar_ind][1];
+        var image = mpl.toolbar_items[toolbar_ind][2];
+        var method_name = mpl.toolbar_items[toolbar_ind][3];
+
+        if (!name) {
+            /* Instead of a spacer, we start a new button group. */
+            if (buttonGroup.hasChildNodes()) {
+                toolbar.appendChild(buttonGroup);
+            }
+            buttonGroup = document.createElement('div');
+            buttonGroup.classList = 'mpl-button-group';
+            continue;
+        }
+
+        var button = (fig.buttons[name] = document.createElement('button'));
+        button.classList = 'mpl-widget';
+        button.setAttribute('role', 'button');
+        button.setAttribute('aria-disabled', 'false');
+        button.addEventListener('click', on_click_closure(method_name));
+        button.addEventListener('mouseover', on_mouseover_closure(tooltip));
+
+        var icon_img = document.createElement('img');
+        icon_img.src = '_images/' + image + '.png';
+        icon_img.srcset = '_images/' + image + '_large.png 2x';
+        icon_img.alt = tooltip;
+        button.appendChild(icon_img);
+
+        buttonGroup.appendChild(button);
+    }
+
+    if (buttonGroup.hasChildNodes()) {
+        toolbar.appendChild(buttonGroup);
+    }
+
+    var fmt_picker = document.createElement('select');
+    fmt_picker.classList = 'mpl-widget';
+    toolbar.appendChild(fmt_picker);
+    this.format_dropdown = fmt_picker;
+
+    for (var ind in mpl.extensions) {
+        var fmt = mpl.extensions[ind];
+        var option = document.createElement('option');
+        option.selected = fmt === mpl.default_extension;
+        option.innerHTML = fmt;
+        fmt_picker.appendChild(option);
+    }
+
+    var status_bar = document.createElement('span');
+    status_bar.classList = 'mpl-message';
+    toolbar.appendChild(status_bar);
+    this.message = status_bar;
+};
+
+mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {
+    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,
+    // which will in turn request a refresh of the image.
+    this.send_message('resize', { width: x_pixels, height: y_pixels });
+};
+
+mpl.figure.prototype.send_message = function (type, properties) {
+    properties['type'] = type;
+    properties['figure_id'] = this.id;
+    this.ws.send(JSON.stringify(properties));
+};
+
+mpl.figure.prototype.send_draw_message = function () {
+    if (!this.waiting) {
+        this.waiting = true;
+        this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));
+    }
+};
+
+mpl.figure.prototype.handle_save = function (fig, _msg) {
+    var format_dropdown = fig.format_dropdown;
+    var format = format_dropdown.options[format_dropdown.selectedIndex].value;
+    fig.ondownload(fig, format);
+};
+
+mpl.figure.prototype.handle_resize = function (fig, msg) {
+    var size = msg['size'];
+    if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {
+        fig._resize_canvas(size[0], size[1], msg['forward']);
+        fig.send_message('refresh', {});
+    }
+};
+
+mpl.figure.prototype.handle_rubberband = function (fig, msg) {
+    var x0 = msg['x0'] / fig.ratio;
+    var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;
+    var x1 = msg['x1'] / fig.ratio;
+    var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;
+    x0 = Math.floor(x0) + 0.5;
+    y0 = Math.floor(y0) + 0.5;
+    x1 = Math.floor(x1) + 0.5;
+    y1 = Math.floor(y1) + 0.5;
+    var min_x = Math.min(x0, x1);
+    var min_y = Math.min(y0, y1);
+    var width = Math.abs(x1 - x0);
+    var height = Math.abs(y1 - y0);
+
+    fig.rubberband_context.clearRect(
+        0,
+        0,
+        fig.canvas.width / fig.ratio,
+        fig.canvas.height / fig.ratio
+    );
+
+    fig.rubberband_context.strokeRect(min_x, min_y, width, height);
+};
+
+mpl.figure.prototype.handle_figure_label = function (fig, msg) {
+    // Updates the figure title.
+    fig.header.textContent = msg['label'];
+};
+
+mpl.figure.prototype.handle_cursor = function (fig, msg) {
+    fig.canvas_div.style.cursor = msg['cursor'];
+};
+
+mpl.figure.prototype.handle_message = function (fig, msg) {
+    fig.message.textContent = msg['message'];
+};
+
+mpl.figure.prototype.handle_draw = function (fig, _msg) {
+    // Request the server to send over a new figure.
+    fig.send_draw_message();
+};
+
+mpl.figure.prototype.handle_image_mode = function (fig, msg) {
+    fig.image_mode = msg['mode'];
+};
+
+mpl.figure.prototype.handle_history_buttons = function (fig, msg) {
+    for (var key in msg) {
+        if (!(key in fig.buttons)) {
+            continue;
+        }
+        fig.buttons[key].disabled = !msg[key];
+        fig.buttons[key].setAttribute('aria-disabled', !msg[key]);
+    }
+};
+
+mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {
+    if (msg['mode'] === 'PAN') {
+        fig.buttons['Pan'].classList.add('active');
+        fig.buttons['Zoom'].classList.remove('active');
+    } else if (msg['mode'] === 'ZOOM') {
+        fig.buttons['Pan'].classList.remove('active');
+        fig.buttons['Zoom'].classList.add('active');
+    } else {
+        fig.buttons['Pan'].classList.remove('active');
+        fig.buttons['Zoom'].classList.remove('active');
+    }
+};
+
+mpl.figure.prototype.updated_canvas_event = function () {
+    // Called whenever the canvas gets updated.
+    this.send_message('ack', {});
+};
+
+// A function to construct a web socket function for onmessage handling.
+// Called in the figure constructor.
+mpl.figure.prototype._make_on_message_function = function (fig) {
+    return function socket_on_message(evt) {
+        if (evt.data instanceof Blob) {
+            var img = evt.data;
+            if (img.type !== 'image/png') {
+                /* FIXME: We get "Resource interpreted as Image but
+                 * transferred with MIME type text/plain:" errors on
+                 * Chrome.  But how to set the MIME type?  It doesn't seem
+                 * to be part of the websocket stream */
+                img.type = 'image/png';
+            }
+
+            /* Free the memory for the previous frames */
+            if (fig.imageObj.src) {
+                (window.URL || window.webkitURL).revokeObjectURL(
+                    fig.imageObj.src
+                );
+            }
+
+            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(
+                img
+            );
+            fig.updated_canvas_event();
+            fig.waiting = false;
+            return;
+        } else if (
+            typeof evt.data === 'string' &&
+            evt.data.slice(0, 21) === 'data:image/png;base64'
+        ) {
+            fig.imageObj.src = evt.data;
+            fig.updated_canvas_event();
+            fig.waiting = false;
+            return;
+        }
+
+        var msg = JSON.parse(evt.data);
+        var msg_type = msg['type'];
+
+        // Call the  "handle_{type}" callback, which takes
+        // the figure and JSON message as its only arguments.
+        try {
+            var callback = fig['handle_' + msg_type];
+        } catch (e) {
+            console.log(
+                "No handler for the '" + msg_type + "' message type: ",
+                msg
+            );
+            return;
+        }
+
+        if (callback) {
+            try {
+                // console.log("Handling '" + msg_type + "' message: ", msg);
+                callback(fig, msg);
+            } catch (e) {
+                console.log(
+                    "Exception inside the 'handler_" + msg_type + "' callback:",
+                    e,
+                    e.stack,
+                    msg
+                );
+            }
+        }
+    };
+};
+
+function getModifiers(event) {
+    var mods = [];
+    if (event.ctrlKey) {
+        mods.push('ctrl');
+    }
+    if (event.altKey) {
+        mods.push('alt');
+    }
+    if (event.shiftKey) {
+        mods.push('shift');
+    }
+    if (event.metaKey) {
+        mods.push('meta');
+    }
+    return mods;
+}
+
+/*
+ * return a copy of an object with only non-object keys
+ * we need this to avoid circular references
+ * https://stackoverflow.com/a/24161582/3208463
+ */
+function simpleKeys(original) {
+    return Object.keys(original).reduce(function (obj, key) {
+        if (typeof original[key] !== 'object') {
+            obj[key] = original[key];
+        }
+        return obj;
+    }, {});
+}
+
+mpl.figure.prototype.mouse_event = function (event, name) {
+    if (name === 'button_press') {
+        this.canvas.focus();
+        this.canvas_div.focus();
+    }
+
+    // from https://stackoverflow.com/q/1114465
+    var boundingRect = this.canvas.getBoundingClientRect();
+    var x = (event.clientX - boundingRect.left) * this.ratio;
+    var y = (event.clientY - boundingRect.top) * this.ratio;
+
+    this.send_message(name, {
+        x: x,
+        y: y,
+        button: event.button,
+        step: event.step,
+        buttons: event.buttons,
+        modifiers: getModifiers(event),
+        guiEvent: simpleKeys(event),
+    });
+
+    return false;
+};
+
+mpl.figure.prototype._key_event_extra = function (_event, _name) {
+    // Handle any extra behaviour associated with a key event
+};
+
+mpl.figure.prototype.key_event = function (event, name) {
+    // Prevent repeat events
+    if (name === 'key_press') {
+        if (event.key === this._key) {
+            return;
+        } else {
+            this._key = event.key;
+        }
+    }
+    if (name === 'key_release') {
+        this._key = null;
+    }
+
+    var value = '';
+    if (event.ctrlKey && event.key !== 'Control') {
+        value += 'ctrl+';
+    }
+    else if (event.altKey && event.key !== 'Alt') {
+        value += 'alt+';
+    }
+    else if (event.shiftKey && event.key !== 'Shift') {
+        value += 'shift+';
+    }
+
+    value += 'k' + event.key;
+
+    this._key_event_extra(event, name);
+
+    this.send_message(name, { key: value, guiEvent: simpleKeys(event) });
+    return false;
+};
+
+mpl.figure.prototype.toolbar_button_onclick = function (name) {
+    if (name === 'download') {
+        this.handle_save(this, null);
+    } else {
+        this.send_message('toolbar_button', { name: name });
+    }
+};
+
+mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {
+    this.message.textContent = tooltip;
+};
+
+///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////
+// prettier-ignore
+var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError("Constructor requires 'new' operator");i.set(this,e)}function h(){throw new TypeError("Function is not a constructor")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line
diff --git a/lib/python3.10/site-packages/matplotlib/backends/web_backend/js/mpl_tornado.js b/lib/python3.10/site-packages/matplotlib/backends/web_backend/js/mpl_tornado.js
new file mode 100644
index 0000000000000000000000000000000000000000..b3cab8b7b906d95fcfe221bf3aaf04722004f7a6
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/backends/web_backend/js/mpl_tornado.js
@@ -0,0 +1,8 @@
+/* This .js file contains functions for matplotlib's built-in
+   tornado-based server, that are not relevant when embedding WebAgg
+   in another web application. */
+
+/* exported mpl_ondownload */
+function mpl_ondownload(figure, format) {
+    window.open(figure.id + '/download.' + format, '_blank');
+}
diff --git a/lib/python3.10/site-packages/matplotlib/backends/web_backend/js/nbagg_mpl.js b/lib/python3.10/site-packages/matplotlib/backends/web_backend/js/nbagg_mpl.js
new file mode 100644
index 0000000000000000000000000000000000000000..26d79ff4e1da11d3c362f748e75b22026cc8438a
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/backends/web_backend/js/nbagg_mpl.js
@@ -0,0 +1,275 @@
+/* global mpl */
+
+var comm_websocket_adapter = function (comm) {
+    // Create a "websocket"-like object which calls the given IPython comm
+    // object with the appropriate methods. Currently this is a non binary
+    // socket, so there is still some room for performance tuning.
+    var ws = {};
+
+    ws.binaryType = comm.kernel.ws.binaryType;
+    ws.readyState = comm.kernel.ws.readyState;
+    function updateReadyState(_event) {
+        if (comm.kernel.ws) {
+            ws.readyState = comm.kernel.ws.readyState;
+        } else {
+            ws.readyState = 3; // Closed state.
+        }
+    }
+    comm.kernel.ws.addEventListener('open', updateReadyState);
+    comm.kernel.ws.addEventListener('close', updateReadyState);
+    comm.kernel.ws.addEventListener('error', updateReadyState);
+
+    ws.close = function () {
+        comm.close();
+    };
+    ws.send = function (m) {
+        //console.log('sending', m);
+        comm.send(m);
+    };
+    // Register the callback with on_msg.
+    comm.on_msg(function (msg) {
+        //console.log('receiving', msg['content']['data'], msg);
+        var data = msg['content']['data'];
+        if (data['blob'] !== undefined) {
+            data = {
+                data: new Blob(msg['buffers'], { type: data['blob'] }),
+            };
+        }
+        // Pass the mpl event to the overridden (by mpl) onmessage function.
+        ws.onmessage(data);
+    });
+    return ws;
+};
+
+mpl.mpl_figure_comm = function (comm, msg) {
+    // This is the function which gets called when the mpl process
+    // starts-up an IPython Comm through the "matplotlib" channel.
+
+    var id = msg.content.data.id;
+    // Get hold of the div created by the display call when the Comm
+    // socket was opened in Python.
+    var element = document.getElementById(id);
+    var ws_proxy = comm_websocket_adapter(comm);
+
+    function ondownload(figure, _format) {
+        window.open(figure.canvas.toDataURL());
+    }
+
+    var fig = new mpl.figure(id, ws_proxy, ondownload, element);
+
+    // Call onopen now - mpl needs it, as it is assuming we've passed it a real
+    // web socket which is closed, not our websocket->open comm proxy.
+    ws_proxy.onopen();
+
+    fig.parent_element = element;
+    fig.cell_info = mpl.find_output_cell("<div id='" + id + "'></div>");
+    if (!fig.cell_info) {
+        console.error('Failed to find cell for figure', id, fig);
+        return;
+    }
+    fig.cell_info[0].output_area.element.on(
+        'cleared',
+        { fig: fig },
+        fig._remove_fig_handler
+    );
+};
+
+mpl.figure.prototype.handle_close = function (fig, msg) {
+    var width = fig.canvas.width / fig.ratio;
+    fig.cell_info[0].output_area.element.off(
+        'cleared',
+        fig._remove_fig_handler
+    );
+    fig.resizeObserverInstance.unobserve(fig.canvas_div);
+
+    // Update the output cell to use the data from the current canvas.
+    fig.push_to_output();
+    var dataURL = fig.canvas.toDataURL();
+    // Re-enable the keyboard manager in IPython - without this line, in FF,
+    // the notebook keyboard shortcuts fail.
+    IPython.keyboard_manager.enable();
+    fig.parent_element.innerHTML =
+        '<img src="' + dataURL + '" width="' + width + '">';
+    fig.close_ws(fig, msg);
+};
+
+mpl.figure.prototype.close_ws = function (fig, msg) {
+    fig.send_message('closing', msg);
+    // fig.ws.close()
+};
+
+mpl.figure.prototype.push_to_output = function (_remove_interactive) {
+    // Turn the data on the canvas into data in the output cell.
+    var width = this.canvas.width / this.ratio;
+    var dataURL = this.canvas.toDataURL();
+    this.cell_info[1]['text/html'] =
+        '<img src="' + dataURL + '" width="' + width + '">';
+};
+
+mpl.figure.prototype.updated_canvas_event = function () {
+    // Tell IPython that the notebook contents must change.
+    IPython.notebook.set_dirty(true);
+    this.send_message('ack', {});
+    var fig = this;
+    // Wait a second, then push the new image to the DOM so
+    // that it is saved nicely (might be nice to debounce this).
+    setTimeout(function () {
+        fig.push_to_output();
+    }, 1000);
+};
+
+mpl.figure.prototype._init_toolbar = function () {
+    var fig = this;
+
+    var toolbar = document.createElement('div');
+    toolbar.classList = 'btn-toolbar';
+    this.root.appendChild(toolbar);
+
+    function on_click_closure(name) {
+        return function (_event) {
+            return fig.toolbar_button_onclick(name);
+        };
+    }
+
+    function on_mouseover_closure(tooltip) {
+        return function (event) {
+            if (!event.currentTarget.disabled) {
+                return fig.toolbar_button_onmouseover(tooltip);
+            }
+        };
+    }
+
+    fig.buttons = {};
+    var buttonGroup = document.createElement('div');
+    buttonGroup.classList = 'btn-group';
+    var button;
+    for (var toolbar_ind in mpl.toolbar_items) {
+        var name = mpl.toolbar_items[toolbar_ind][0];
+        var tooltip = mpl.toolbar_items[toolbar_ind][1];
+        var image = mpl.toolbar_items[toolbar_ind][2];
+        var method_name = mpl.toolbar_items[toolbar_ind][3];
+
+        if (!name) {
+            /* Instead of a spacer, we start a new button group. */
+            if (buttonGroup.hasChildNodes()) {
+                toolbar.appendChild(buttonGroup);
+            }
+            buttonGroup = document.createElement('div');
+            buttonGroup.classList = 'btn-group';
+            continue;
+        }
+
+        button = fig.buttons[name] = document.createElement('button');
+        button.classList = 'btn btn-default';
+        button.href = '#';
+        button.title = name;
+        button.innerHTML = '<i class="fa ' + image + ' fa-lg"></i>';
+        button.addEventListener('click', on_click_closure(method_name));
+        button.addEventListener('mouseover', on_mouseover_closure(tooltip));
+        buttonGroup.appendChild(button);
+    }
+
+    if (buttonGroup.hasChildNodes()) {
+        toolbar.appendChild(buttonGroup);
+    }
+
+    // Add the status bar.
+    var status_bar = document.createElement('span');
+    status_bar.classList = 'mpl-message pull-right';
+    toolbar.appendChild(status_bar);
+    this.message = status_bar;
+
+    // Add the close button to the window.
+    var buttongrp = document.createElement('div');
+    buttongrp.classList = 'btn-group inline pull-right';
+    button = document.createElement('button');
+    button.classList = 'btn btn-mini btn-primary';
+    button.href = '#';
+    button.title = 'Stop Interaction';
+    button.innerHTML = '<i class="fa fa-power-off icon-remove icon-large"></i>';
+    button.addEventListener('click', function (_evt) {
+        fig.handle_close(fig, {});
+    });
+    button.addEventListener(
+        'mouseover',
+        on_mouseover_closure('Stop Interaction')
+    );
+    buttongrp.appendChild(button);
+    var titlebar = this.root.querySelector('.ui-dialog-titlebar');
+    titlebar.insertBefore(buttongrp, titlebar.firstChild);
+};
+
+mpl.figure.prototype._remove_fig_handler = function (event) {
+    var fig = event.data.fig;
+    if (event.target !== this) {
+        // Ignore bubbled events from children.
+        return;
+    }
+    fig.close_ws(fig, {});
+};
+
+mpl.figure.prototype._root_extra_style = function (el) {
+    el.style.boxSizing = 'content-box'; // override notebook setting of border-box.
+};
+
+mpl.figure.prototype._canvas_extra_style = function (el) {
+    // this is important to make the div 'focusable
+    el.setAttribute('tabindex', 0);
+    // reach out to IPython and tell the keyboard manager to turn it's self
+    // off when our div gets focus
+
+    // location in version 3
+    if (IPython.notebook.keyboard_manager) {
+        IPython.notebook.keyboard_manager.register_events(el);
+    } else {
+        // location in version 2
+        IPython.keyboard_manager.register_events(el);
+    }
+};
+
+mpl.figure.prototype._key_event_extra = function (event, _name) {
+    // Check for shift+enter
+    if (event.shiftKey && event.which === 13) {
+        this.canvas_div.blur();
+        // select the cell after this one
+        var index = IPython.notebook.find_cell_index(this.cell_info[0]);
+        IPython.notebook.select(index + 1);
+    }
+};
+
+mpl.figure.prototype.handle_save = function (fig, _msg) {
+    fig.ondownload(fig, null);
+};
+
+mpl.find_output_cell = function (html_output) {
+    // Return the cell and output element which can be found *uniquely* in the notebook.
+    // Note - this is a bit hacky, but it is done because the "notebook_saving.Notebook"
+    // IPython event is triggered only after the cells have been serialised, which for
+    // our purposes (turning an active figure into a static one), is too late.
+    var cells = IPython.notebook.get_cells();
+    var ncells = cells.length;
+    for (var i = 0; i < ncells; i++) {
+        var cell = cells[i];
+        if (cell.cell_type === 'code') {
+            for (var j = 0; j < cell.output_area.outputs.length; j++) {
+                var data = cell.output_area.outputs[j];
+                if (data.data) {
+                    // IPython >= 3 moved mimebundle to data attribute of output
+                    data = data.data;
+                }
+                if (data['text/html'] === html_output) {
+                    return [cell, data, j];
+                }
+            }
+        }
+    }
+};
+
+// Register the function which deals with the matplotlib target/channel.
+// The kernel may be null if the page has been refreshed.
+if (IPython.notebook.kernel !== null) {
+    IPython.notebook.kernel.comm_manager.register_target(
+        'matplotlib',
+        mpl.mpl_figure_comm
+    );
+}
diff --git a/lib/python3.10/site-packages/matplotlib/backends/web_backend/single_figure.html b/lib/python3.10/site-packages/matplotlib/backends/web_backend/single_figure.html
new file mode 100644
index 0000000000000000000000000000000000000000..ceaaab00669ff62e0724eff610dcb74adcff1674
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/backends/web_backend/single_figure.html
@@ -0,0 +1,39 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <link rel="stylesheet" href="{{ prefix }}/_static/css/page.css" type="text/css">
+    <link rel="stylesheet" href="{{ prefix }}/_static/css/boilerplate.css" type="text/css">
+    <link rel="stylesheet" href="{{ prefix }}/_static/css/fbm.css" type="text/css">
+    <link rel="stylesheet" href="{{ prefix }}/_static/css/mpl.css" type="text/css">
+    <script src="{{ prefix }}/_static/js/mpl_tornado.js"></script>
+    <script src="{{ prefix }}/js/mpl.js"></script>
+    <script>
+      function ready(fn) {
+        if (document.readyState != "loading") {
+          fn();
+        } else {
+          document.addEventListener("DOMContentLoaded", fn);
+        }
+      }
+
+      ready(
+        function () {
+          var websocket_type = mpl.get_websocket_type();
+          var uri = "{{ ws_uri }}" + {{ str(fig_id) }} + "/ws";
+          if (window.location.protocol === 'https:') uri = uri.replace('ws:', 'wss:')
+          var websocket = new websocket_type(uri);
+          var fig = new mpl.figure(
+              {{ str(fig_id) }}, websocket, mpl_ondownload,
+              document.getElementById("figure"));
+        }
+      );
+    </script>
+
+    <title>matplotlib</title>
+  </head>
+
+  <body>
+    <div id="mpl-warnings" class="mpl-warnings"></div>
+    <div id="figure" style="margin: 10px 10px;"></div>
+  </body>
+</html>
diff --git a/lib/python3.10/site-packages/matplotlib/sphinxext/__init__.py b/lib/python3.10/site-packages/matplotlib/sphinxext/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/lib/python3.10/site-packages/matplotlib/sphinxext/__pycache__/__init__.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/sphinxext/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6b3584461fffca2baf58c22c2388a3af68eca3ff
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/sphinxext/__pycache__/__init__.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/sphinxext/__pycache__/figmpl_directive.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/sphinxext/__pycache__/figmpl_directive.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a1bc79112c1e9acd07561cc76a7230c64bfdd09b
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/sphinxext/__pycache__/figmpl_directive.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/sphinxext/__pycache__/mathmpl.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/sphinxext/__pycache__/mathmpl.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5665307424cba8a91530de936674dd999df88d8a
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/sphinxext/__pycache__/mathmpl.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/sphinxext/__pycache__/plot_directive.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/sphinxext/__pycache__/plot_directive.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2205e3dd286cea385372c956da96425fd3efd719
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/sphinxext/__pycache__/plot_directive.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/sphinxext/__pycache__/roles.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/sphinxext/__pycache__/roles.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d1bf9f311f048e34cfc8c8a724007ddfa1ab1e19
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/sphinxext/__pycache__/roles.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/sphinxext/figmpl_directive.py b/lib/python3.10/site-packages/matplotlib/sphinxext/figmpl_directive.py
new file mode 100644
index 0000000000000000000000000000000000000000..7cb9c6c04e8a130fe9d61c3a4c66f0ba4d80b1ad
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/sphinxext/figmpl_directive.py
@@ -0,0 +1,286 @@
+"""
+Add a ``figure-mpl`` directive that is a responsive version of ``figure``.
+
+This implementation is very similar to ``.. figure::``, except it also allows a
+``srcset=`` argument to be passed to the image tag, hence allowing responsive
+resolution images.
+
+There is no particular reason this could not be used standalone, but is meant
+to be used with :doc:`/api/sphinxext_plot_directive_api`.
+
+Note that the directory organization is a bit different than ``.. figure::``.
+See the *FigureMpl* documentation below.
+
+"""
+import os
+from os.path import relpath
+from pathlib import PurePath, Path
+import shutil
+
+from docutils import nodes
+from docutils.parsers.rst import directives
+from docutils.parsers.rst.directives.images import Figure, Image
+from sphinx.errors import ExtensionError
+
+import matplotlib
+
+
+class figmplnode(nodes.General, nodes.Element):
+    pass
+
+
+class FigureMpl(Figure):
+    """
+    Implements a directive to allow an optional hidpi image.
+
+    Meant to be used with the *plot_srcset* configuration option in conf.py,
+    and gets set in the TEMPLATE of plot_directive.py
+
+    e.g.::
+
+        .. figure-mpl:: plot_directive/some_plots-1.png
+            :alt: bar
+            :srcset: plot_directive/some_plots-1.png,
+                     plot_directive/some_plots-1.2x.png 2.00x
+            :class: plot-directive
+
+    The resulting html (at ``some_plots.html``) is::
+
+        <img src="sphx_glr_bar_001_hidpi.png"
+            srcset="_images/some_plot-1.png,
+                    _images/some_plots-1.2x.png 2.00x",
+            alt="bar"
+            class="plot_directive" />
+
+    Note that the handling of subdirectories is different than that used by the sphinx
+    figure directive::
+
+        .. figure-mpl:: plot_directive/nestedpage/index-1.png
+            :alt: bar
+            :srcset: plot_directive/nestedpage/index-1.png
+                     plot_directive/nestedpage/index-1.2x.png 2.00x
+            :class: plot_directive
+
+    The resulting html (at ``nestedpage/index.html``)::
+
+        <img src="../_images/nestedpage-index-1.png"
+            srcset="../_images/nestedpage-index-1.png,
+                    ../_images/_images/nestedpage-index-1.2x.png 2.00x",
+            alt="bar"
+            class="sphx-glr-single-img" />
+
+    where the subdirectory is included in the image name for uniqueness.
+    """
+
+    has_content = False
+    required_arguments = 1
+    optional_arguments = 2
+    final_argument_whitespace = False
+    option_spec = {
+        'alt': directives.unchanged,
+        'height': directives.length_or_unitless,
+        'width': directives.length_or_percentage_or_unitless,
+        'scale': directives.nonnegative_int,
+        'align': Image.align,
+        'class': directives.class_option,
+        'caption': directives.unchanged,
+        'srcset': directives.unchanged,
+    }
+
+    def run(self):
+
+        image_node = figmplnode()
+
+        imagenm = self.arguments[0]
+        image_node['alt'] = self.options.get('alt', '')
+        image_node['align'] = self.options.get('align', None)
+        image_node['class'] = self.options.get('class', None)
+        image_node['width'] = self.options.get('width', None)
+        image_node['height'] = self.options.get('height', None)
+        image_node['scale'] = self.options.get('scale', None)
+        image_node['caption'] = self.options.get('caption', None)
+
+        # we would like uri to be the highest dpi version so that
+        # latex etc will use that.  But for now, lets just make
+        # imagenm... maybe pdf one day?
+
+        image_node['uri'] = imagenm
+        image_node['srcset'] = self.options.get('srcset', None)
+
+        return [image_node]
+
+
+def _parse_srcsetNodes(st):
+    """
+    parse srcset...
+    """
+    entries = st.split(',')
+    srcset = {}
+    for entry in entries:
+        spl = entry.strip().split(' ')
+        if len(spl) == 1:
+            srcset[0] = spl[0]
+        elif len(spl) == 2:
+            mult = spl[1][:-1]
+            srcset[float(mult)] = spl[0]
+        else:
+            raise ExtensionError(f'srcset argument "{entry}" is invalid.')
+    return srcset
+
+
+def _copy_images_figmpl(self, node):
+
+    # these will be the temporary place the plot-directive put the images eg:
+    # ../../../build/html/plot_directive/users/explain/artists/index-1.png
+    if node['srcset']:
+        srcset = _parse_srcsetNodes(node['srcset'])
+    else:
+        srcset = None
+
+    # the rst file's location:  eg /Users/username/matplotlib/doc/users/explain/artists
+    docsource = PurePath(self.document['source']).parent
+
+    # get the relpath relative to root:
+    srctop = self.builder.srcdir
+    rel = relpath(docsource, srctop).replace('.', '').replace(os.sep, '-')
+    if len(rel):
+        rel += '-'
+    # eg: users/explain/artists
+
+    imagedir = PurePath(self.builder.outdir, self.builder.imagedir)
+    # eg: /Users/username/matplotlib/doc/build/html/_images/users/explain/artists
+
+    Path(imagedir).mkdir(parents=True, exist_ok=True)
+
+    # copy all the sources to the imagedir:
+    if srcset:
+        for src in srcset.values():
+            # the entries in srcset are relative to docsource's directory
+            abspath = PurePath(docsource, src)
+            name = rel + abspath.name
+            shutil.copyfile(abspath, imagedir / name)
+    else:
+        abspath = PurePath(docsource, node['uri'])
+        name = rel + abspath.name
+        shutil.copyfile(abspath, imagedir / name)
+
+    return imagedir, srcset, rel
+
+
+def visit_figmpl_html(self, node):
+
+    imagedir, srcset, rel = _copy_images_figmpl(self, node)
+
+    # /doc/examples/subd/plot_1.rst
+    docsource = PurePath(self.document['source'])
+    # /doc/
+    # make sure to add the trailing slash:
+    srctop = PurePath(self.builder.srcdir, '')
+    # examples/subd/plot_1.rst
+    relsource = relpath(docsource, srctop)
+    # /doc/build/html
+    desttop = PurePath(self.builder.outdir, '')
+    # /doc/build/html/examples/subd
+    dest = desttop / relsource
+
+    # ../../_images/ for dirhtml and ../_images/ for html
+    imagerel = PurePath(relpath(imagedir, dest.parent)).as_posix()
+    if self.builder.name == "dirhtml":
+        imagerel = f'..{imagerel}'
+
+    # make uri also be relative...
+    nm = PurePath(node['uri'][1:]).name
+    uri = f'{imagerel}/{rel}{nm}'
+    img_attrs = {'src': uri, 'alt': node['alt']}
+
+    # make srcset str.  Need to change all the prefixes!
+    maxsrc = uri
+    if srcset:
+        maxmult = -1
+        srcsetst = ''
+        for mult, src in srcset.items():
+            nm = PurePath(src[1:]).name
+            # ../../_images/plot_1_2_0x.png
+            path = f'{imagerel}/{rel}{nm}'
+            srcsetst += path
+            if mult == 0:
+                srcsetst += ', '
+            else:
+                srcsetst += f' {mult:1.2f}x, '
+
+            if mult > maxmult:
+                maxmult = mult
+                maxsrc = path
+
+        # trim trailing comma and space...
+        img_attrs['srcset'] = srcsetst[:-2]
+
+    if node['class'] is not None:
+        img_attrs['class'] = ' '.join(node['class'])
+    for style in ['width', 'height', 'scale']:
+        if node[style]:
+            if 'style' not in img_attrs:
+                img_attrs['style'] = f'{style}: {node[style]};'
+            else:
+                img_attrs['style'] += f'{style}: {node[style]};'
+
+    # <figure class="align-default" id="id1">
+    # <a class="reference internal image-reference" href="_images/index-1.2x.png">
+    # <img alt="_images/index-1.2x.png"
+    #  src="_images/index-1.2x.png" style="width: 53%;" />
+    # </a>
+    # <figcaption>
+    # <p><span class="caption-text">Figure caption is here....</span>
+    # <a class="headerlink" href="#id1" title="Permalink to this image">#</a></p>
+    # </figcaption>
+    # </figure>
+    self.body.append(
+        self.starttag(
+            node, 'figure',
+            CLASS=f'align-{node["align"]}' if node['align'] else 'align-center'))
+    self.body.append(
+        self.starttag(node, 'a', CLASS='reference internal image-reference',
+                      href=maxsrc) +
+        self.emptytag(node, 'img', **img_attrs) +
+        '</a>\n')
+    if node['caption']:
+        self.body.append(self.starttag(node, 'figcaption'))
+        self.body.append(self.starttag(node, 'p'))
+        self.body.append(self.starttag(node, 'span', CLASS='caption-text'))
+        self.body.append(node['caption'])
+        self.body.append('</span></p></figcaption>\n')
+    self.body.append('</figure>\n')
+
+
+def visit_figmpl_latex(self, node):
+
+    if node['srcset'] is not None:
+        imagedir, srcset = _copy_images_figmpl(self, node)
+        maxmult = -1
+        # choose the highest res version for latex:
+        maxmult = max(srcset, default=-1)
+        node['uri'] = PurePath(srcset[maxmult]).name
+
+    self.visit_figure(node)
+
+
+def depart_figmpl_html(self, node):
+    pass
+
+
+def depart_figmpl_latex(self, node):
+    self.depart_figure(node)
+
+
+def figurempl_addnode(app):
+    app.add_node(figmplnode,
+                 html=(visit_figmpl_html, depart_figmpl_html),
+                 latex=(visit_figmpl_latex, depart_figmpl_latex))
+
+
+def setup(app):
+    app.add_directive("figure-mpl", FigureMpl)
+    figurempl_addnode(app)
+    metadata = {'parallel_read_safe': True, 'parallel_write_safe': True,
+                'version': matplotlib.__version__}
+    return metadata
diff --git a/lib/python3.10/site-packages/matplotlib/sphinxext/mathmpl.py b/lib/python3.10/site-packages/matplotlib/sphinxext/mathmpl.py
new file mode 100644
index 0000000000000000000000000000000000000000..30f0245242583c5ea162de9e5443da67d7111465
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/sphinxext/mathmpl.py
@@ -0,0 +1,242 @@
+r"""
+A role and directive to display mathtext in Sphinx
+==================================================
+
+The ``mathmpl`` Sphinx extension creates a mathtext image in Matplotlib and
+shows it in html output. Thus, it is a true and faithful representation of what
+you will see if you pass a given LaTeX string to Matplotlib (see
+:ref:`mathtext`).
+
+.. warning::
+    In most cases, you will likely want to use one of `Sphinx's builtin Math
+    extensions
+    <https://www.sphinx-doc.org/en/master/usage/extensions/math.html>`__
+    instead of this one. The builtin Sphinx math directive uses MathJax to
+    render mathematical expressions, and addresses accessibility concerns that
+    ``mathmpl`` doesn't address.
+
+Mathtext may be included in two ways:
+
+1. Inline, using the role::
+
+     This text uses inline math: :mathmpl:`\alpha > \beta`.
+
+   which produces:
+
+     This text uses inline math: :mathmpl:`\alpha > \beta`.
+
+2. Standalone, using the directive::
+
+     Here is some standalone math:
+
+     .. mathmpl::
+
+         \alpha > \beta
+
+   which produces:
+
+     Here is some standalone math:
+
+     .. mathmpl::
+
+         \alpha > \beta
+
+Options
+-------
+
+The ``mathmpl`` role and directive both support the following options:
+
+fontset : str, default: 'cm'
+    The font set to use when displaying math. See :rc:`mathtext.fontset`.
+
+fontsize : float
+    The font size, in points. Defaults to the value from the extension
+    configuration option defined below.
+
+Configuration options
+---------------------
+
+The mathtext extension has the following configuration options:
+
+mathmpl_fontsize : float, default: 10.0
+    Default font size, in points.
+
+mathmpl_srcset : list of str, default: []
+    Additional image sizes to generate when embedding in HTML, to support
+    `responsive resolution images
+    <https://developer.mozilla.org/en-US/docs/Learn/HTML/Multimedia_and_embedding/Responsive_images>`__.
+    The list should contain additional x-descriptors (``'1.5x'``, ``'2x'``,
+    etc.) to generate (1x is the default and always included.)
+
+"""
+
+import hashlib
+from pathlib import Path
+
+from docutils import nodes
+from docutils.parsers.rst import Directive, directives
+import sphinx
+from sphinx.errors import ConfigError, ExtensionError
+
+import matplotlib as mpl
+from matplotlib import _api, mathtext
+from matplotlib.rcsetup import validate_float_or_None
+
+
+# Define LaTeX math node:
+class latex_math(nodes.General, nodes.Element):
+    pass
+
+
+def fontset_choice(arg):
+    return directives.choice(arg, mathtext.MathTextParser._font_type_mapping)
+
+
+def math_role(role, rawtext, text, lineno, inliner,
+              options={}, content=[]):
+    i = rawtext.find('`')
+    latex = rawtext[i+1:-1]
+    node = latex_math(rawtext)
+    node['latex'] = latex
+    node['fontset'] = options.get('fontset', 'cm')
+    node['fontsize'] = options.get('fontsize',
+                                   setup.app.config.mathmpl_fontsize)
+    return [node], []
+math_role.options = {'fontset': fontset_choice,
+                     'fontsize': validate_float_or_None}
+
+
+class MathDirective(Directive):
+    """
+    The ``.. mathmpl::`` directive, as documented in the module's docstring.
+    """
+    has_content = True
+    required_arguments = 0
+    optional_arguments = 0
+    final_argument_whitespace = False
+    option_spec = {'fontset': fontset_choice,
+                   'fontsize': validate_float_or_None}
+
+    def run(self):
+        latex = ''.join(self.content)
+        node = latex_math(self.block_text)
+        node['latex'] = latex
+        node['fontset'] = self.options.get('fontset', 'cm')
+        node['fontsize'] = self.options.get('fontsize',
+                                            setup.app.config.mathmpl_fontsize)
+        return [node]
+
+
+# This uses mathtext to render the expression
+def latex2png(latex, filename, fontset='cm', fontsize=10, dpi=100):
+    with mpl.rc_context({'mathtext.fontset': fontset, 'font.size': fontsize}):
+        try:
+            depth = mathtext.math_to_image(
+                f"${latex}$", filename, dpi=dpi, format="png")
+        except Exception:
+            _api.warn_external(f"Could not render math expression {latex}")
+            depth = 0
+    return depth
+
+
+# LaTeX to HTML translation stuff:
+def latex2html(node, source):
+    inline = isinstance(node.parent, nodes.TextElement)
+    latex = node['latex']
+    fontset = node['fontset']
+    fontsize = node['fontsize']
+    name = 'math-{}'.format(
+        hashlib.sha256(
+            f'{latex}{fontset}{fontsize}'.encode(),
+            usedforsecurity=False,
+        ).hexdigest()[-10:])
+
+    destdir = Path(setup.app.builder.outdir, '_images', 'mathmpl')
+    destdir.mkdir(parents=True, exist_ok=True)
+
+    dest = destdir / f'{name}.png'
+    depth = latex2png(latex, dest, fontset, fontsize=fontsize)
+
+    srcset = []
+    for size in setup.app.config.mathmpl_srcset:
+        filename = f'{name}-{size.replace(".", "_")}.png'
+        latex2png(latex, destdir / filename, fontset, fontsize=fontsize,
+                  dpi=100 * float(size[:-1]))
+        srcset.append(
+            f'{setup.app.builder.imgpath}/mathmpl/{filename} {size}')
+    if srcset:
+        srcset = (f'srcset="{setup.app.builder.imgpath}/mathmpl/{name}.png, ' +
+                  ', '.join(srcset) + '" ')
+
+    if inline:
+        cls = ''
+    else:
+        cls = 'class="center" '
+    if inline and depth != 0:
+        style = 'style="position: relative; bottom: -%dpx"' % (depth + 1)
+    else:
+        style = ''
+
+    return (f'<img src="{setup.app.builder.imgpath}/mathmpl/{name}.png"'
+            f' {srcset}{cls}{style}/>')
+
+
+def _config_inited(app, config):
+    # Check for srcset hidpi images
+    for i, size in enumerate(app.config.mathmpl_srcset):
+        if size[-1] == 'x':  # "2x" = "2.0"
+            try:
+                float(size[:-1])
+            except ValueError:
+                raise ConfigError(
+                    f'Invalid value for mathmpl_srcset parameter: {size!r}. '
+                    'Must be a list of strings with the multiplicative '
+                    'factor followed by an "x".  e.g. ["2.0x", "1.5x"]')
+        else:
+            raise ConfigError(
+                f'Invalid value for mathmpl_srcset parameter: {size!r}. '
+                'Must be a list of strings with the multiplicative '
+                'factor followed by an "x".  e.g. ["2.0x", "1.5x"]')
+
+
+def setup(app):
+    setup.app = app
+    app.add_config_value('mathmpl_fontsize', 10.0, True)
+    app.add_config_value('mathmpl_srcset', [], True)
+    try:
+        app.connect('config-inited', _config_inited)  # Sphinx 1.8+
+    except ExtensionError:
+        app.connect('env-updated', lambda app, env: _config_inited(app, None))
+
+    # Add visit/depart methods to HTML-Translator:
+    def visit_latex_math_html(self, node):
+        source = self.document.attributes['source']
+        self.body.append(latex2html(node, source))
+
+    def depart_latex_math_html(self, node):
+        pass
+
+    # Add visit/depart methods to LaTeX-Translator:
+    def visit_latex_math_latex(self, node):
+        inline = isinstance(node.parent, nodes.TextElement)
+        if inline:
+            self.body.append('$%s$' % node['latex'])
+        else:
+            self.body.extend(['\\begin{equation}',
+                              node['latex'],
+                              '\\end{equation}'])
+
+    def depart_latex_math_latex(self, node):
+        pass
+
+    app.add_node(latex_math,
+                 html=(visit_latex_math_html, depart_latex_math_html),
+                 latex=(visit_latex_math_latex, depart_latex_math_latex))
+    app.add_role('mathmpl', math_role)
+    app.add_directive('mathmpl', MathDirective)
+    if sphinx.version_info < (1, 8):
+        app.add_role('math', math_role)
+        app.add_directive('math', MathDirective)
+
+    metadata = {'parallel_read_safe': True, 'parallel_write_safe': True}
+    return metadata
diff --git a/lib/python3.10/site-packages/matplotlib/sphinxext/plot_directive.py b/lib/python3.10/site-packages/matplotlib/sphinxext/plot_directive.py
new file mode 100644
index 0000000000000000000000000000000000000000..ab9b7d76955015186d148e1a04fa32f3ab245a3e
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/sphinxext/plot_directive.py
@@ -0,0 +1,936 @@
+"""
+A directive for including a Matplotlib plot in a Sphinx document
+================================================================
+
+This is a Sphinx extension providing a reStructuredText directive
+``.. plot::`` for including a plot in a Sphinx document.
+
+In HTML output, ``.. plot::`` will include a .png file with a link
+to a high-res .png and .pdf.  In LaTeX output, it will include a .pdf.
+
+The plot content may be defined in one of three ways:
+
+1. **A path to a source file** as the argument to the directive::
+
+     .. plot:: path/to/plot.py
+
+   When a path to a source file is given, the content of the
+   directive may optionally contain a caption for the plot::
+
+     .. plot:: path/to/plot.py
+
+        The plot caption.
+
+   Additionally, one may specify the name of a function to call (with
+   no arguments) immediately after importing the module::
+
+     .. plot:: path/to/plot.py plot_function1
+
+2. Included as **inline content** to the directive::
+
+     .. plot::
+
+        import matplotlib.pyplot as plt
+        plt.plot([1, 2, 3], [4, 5, 6])
+        plt.title("A plotting exammple")
+
+3. Using **doctest** syntax::
+
+     .. plot::
+
+        A plotting example:
+        >>> import matplotlib.pyplot as plt
+        >>> plt.plot([1, 2, 3], [4, 5, 6])
+
+Options
+-------
+
+The ``.. plot::`` directive supports the following options:
+
+``:format:`` : {'python', 'doctest'}
+    The format of the input.  If unset, the format is auto-detected.
+
+``:include-source:`` : bool
+    Whether to display the source code. The default can be changed using
+    the ``plot_include_source`` variable in :file:`conf.py` (which itself
+    defaults to False).
+
+``:show-source-link:`` : bool
+    Whether to show a link to the source in HTML. The default can be
+    changed using the ``plot_html_show_source_link`` variable in
+    :file:`conf.py` (which itself defaults to True).
+
+``:context:`` : bool or str
+    If provided, the code will be run in the context of all previous plot
+    directives for which the ``:context:`` option was specified.  This only
+    applies to inline code plot directives, not those run from files. If
+    the ``:context: reset`` option is specified, the context is reset
+    for this and future plots, and previous figures are closed prior to
+    running the code. ``:context: close-figs`` keeps the context but closes
+    previous figures before running the code.
+
+``:nofigs:`` : bool
+    If specified, the code block will be run, but no figures will be
+    inserted.  This is usually useful with the ``:context:`` option.
+
+``:caption:`` : str
+    If specified, the option's argument will be used as a caption for the
+    figure. This overwrites the caption given in the content, when the plot
+    is generated from a file.
+
+Additionally, this directive supports all the options of the `image directive
+<https://docutils.sourceforge.io/docs/ref/rst/directives.html#image>`_,
+except for ``:target:`` (since plot will add its own target).  These include
+``:alt:``, ``:height:``, ``:width:``, ``:scale:``, ``:align:`` and ``:class:``.
+
+Configuration options
+---------------------
+
+The plot directive has the following configuration options:
+
+plot_include_source
+    Default value for the include-source option (default: False).
+
+plot_html_show_source_link
+    Whether to show a link to the source in HTML (default: True).
+
+plot_pre_code
+    Code that should be executed before each plot. If None (the default),
+    it will default to a string containing::
+
+        import numpy as np
+        from matplotlib import pyplot as plt
+
+plot_basedir
+    Base directory, to which ``plot::`` file names are relative to.
+    If None or empty (the default), file names are relative to the
+    directory where the file containing the directive is.
+
+plot_formats
+    File formats to generate (default: ['png', 'hires.png', 'pdf']).
+    List of tuples or strings::
+
+        [(suffix, dpi), suffix, ...]
+
+    that determine the file format and the DPI. For entries whose
+    DPI was omitted, sensible defaults are chosen. When passing from
+    the command line through sphinx_build the list should be passed as
+    suffix:dpi,suffix:dpi, ...
+
+plot_html_show_formats
+    Whether to show links to the files in HTML (default: True).
+
+plot_rcparams
+    A dictionary containing any non-standard rcParams that should
+    be applied before each plot (default: {}).
+
+plot_apply_rcparams
+    By default, rcParams are applied when ``:context:`` option is not used
+    in a plot directive.  If set, this configuration option overrides this
+    behavior and applies rcParams before each plot.
+
+plot_working_directory
+    By default, the working directory will be changed to the directory of
+    the example, so the code can get at its data files, if any.  Also its
+    path will be added to `sys.path` so it can import any helper modules
+    sitting beside it.  This configuration option can be used to specify
+    a central directory (also added to `sys.path`) where data files and
+    helper modules for all code are located.
+
+plot_template
+    Provide a customized template for preparing restructured text.
+
+plot_srcset
+    Allow the srcset image option for responsive image resolutions. List of
+    strings with the multiplicative factors followed by an "x".
+    e.g. ["2.0x", "1.5x"].  "2.0x" will create a png with the default "png"
+    resolution from plot_formats, multiplied by 2. If plot_srcset is
+    specified, the plot directive uses the
+    :doc:`/api/sphinxext_figmpl_directive_api` (instead of the usual figure
+    directive) in the intermediary rst file that is generated.
+    The plot_srcset option is incompatible with *singlehtml* builds, and an
+    error will be raised.
+
+Notes on how it works
+---------------------
+
+The plot directive runs the code it is given, either in the source file or the
+code under the directive. The figure created (if any) is saved in the sphinx
+build directory under a subdirectory named ``plot_directive``.  It then creates
+an intermediate rst file that calls a ``.. figure:`` directive (or
+``.. figmpl::`` directive if ``plot_srcset`` is being used) and has links to
+the ``*.png`` files in the ``plot_directive`` directory.  These translations can
+be customized by changing the *plot_template*.  See the source of
+:doc:`/api/sphinxext_plot_directive_api` for the templates defined in *TEMPLATE*
+and *TEMPLATE_SRCSET*.
+"""
+
+import contextlib
+import doctest
+from io import StringIO
+import itertools
+import os
+from os.path import relpath
+from pathlib import Path
+import re
+import shutil
+import sys
+import textwrap
+import traceback
+
+from docutils.parsers.rst import directives, Directive
+from docutils.parsers.rst.directives.images import Image
+import jinja2  # Sphinx dependency.
+
+from sphinx.errors import ExtensionError
+
+import matplotlib
+from matplotlib.backend_bases import FigureManagerBase
+import matplotlib.pyplot as plt
+from matplotlib import _pylab_helpers, cbook
+
+matplotlib.use("agg")
+
+__version__ = 2
+
+
+# -----------------------------------------------------------------------------
+# Registration hook
+# -----------------------------------------------------------------------------
+
+
+def _option_boolean(arg):
+    if not arg or not arg.strip():
+        # no argument given, assume used as a flag
+        return True
+    elif arg.strip().lower() in ('no', '0', 'false'):
+        return False
+    elif arg.strip().lower() in ('yes', '1', 'true'):
+        return True
+    else:
+        raise ValueError(f'{arg!r} unknown boolean')
+
+
+def _option_context(arg):
+    if arg in [None, 'reset', 'close-figs']:
+        return arg
+    raise ValueError("Argument should be None or 'reset' or 'close-figs'")
+
+
+def _option_format(arg):
+    return directives.choice(arg, ('python', 'doctest'))
+
+
+def mark_plot_labels(app, document):
+    """
+    To make plots referenceable, we need to move the reference from the
+    "htmlonly" (or "latexonly") node to the actual figure node itself.
+    """
+    for name, explicit in document.nametypes.items():
+        if not explicit:
+            continue
+        labelid = document.nameids[name]
+        if labelid is None:
+            continue
+        node = document.ids[labelid]
+        if node.tagname in ('html_only', 'latex_only'):
+            for n in node:
+                if n.tagname == 'figure':
+                    sectname = name
+                    for c in n:
+                        if c.tagname == 'caption':
+                            sectname = c.astext()
+                            break
+
+                    node['ids'].remove(labelid)
+                    node['names'].remove(name)
+                    n['ids'].append(labelid)
+                    n['names'].append(name)
+                    document.settings.env.labels[name] = \
+                        document.settings.env.docname, labelid, sectname
+                    break
+
+
+class PlotDirective(Directive):
+    """The ``.. plot::`` directive, as documented in the module's docstring."""
+
+    has_content = True
+    required_arguments = 0
+    optional_arguments = 2
+    final_argument_whitespace = False
+    option_spec = {
+        'alt': directives.unchanged,
+        'height': directives.length_or_unitless,
+        'width': directives.length_or_percentage_or_unitless,
+        'scale': directives.nonnegative_int,
+        'align': Image.align,
+        'class': directives.class_option,
+        'include-source': _option_boolean,
+        'show-source-link': _option_boolean,
+        'format': _option_format,
+        'context': _option_context,
+        'nofigs': directives.flag,
+        'caption': directives.unchanged,
+        }
+
+    def run(self):
+        """Run the plot directive."""
+        try:
+            return run(self.arguments, self.content, self.options,
+                       self.state_machine, self.state, self.lineno)
+        except Exception as e:
+            raise self.error(str(e))
+
+
+def _copy_css_file(app, exc):
+    if exc is None and app.builder.format == 'html':
+        src = cbook._get_data_path('plot_directive/plot_directive.css')
+        dst = app.outdir / Path('_static')
+        dst.mkdir(exist_ok=True)
+        # Use copyfile because we do not want to copy src's permissions.
+        shutil.copyfile(src, dst / Path('plot_directive.css'))
+
+
+def setup(app):
+    setup.app = app
+    setup.config = app.config
+    setup.confdir = app.confdir
+    app.add_directive('plot', PlotDirective)
+    app.add_config_value('plot_pre_code', None, True)
+    app.add_config_value('plot_include_source', False, True)
+    app.add_config_value('plot_html_show_source_link', True, True)
+    app.add_config_value('plot_formats', ['png', 'hires.png', 'pdf'], True)
+    app.add_config_value('plot_basedir', None, True)
+    app.add_config_value('plot_html_show_formats', True, True)
+    app.add_config_value('plot_rcparams', {}, True)
+    app.add_config_value('plot_apply_rcparams', False, True)
+    app.add_config_value('plot_working_directory', None, True)
+    app.add_config_value('plot_template', None, True)
+    app.add_config_value('plot_srcset', [], True)
+    app.connect('doctree-read', mark_plot_labels)
+    app.add_css_file('plot_directive.css')
+    app.connect('build-finished', _copy_css_file)
+    metadata = {'parallel_read_safe': True, 'parallel_write_safe': True,
+                'version': matplotlib.__version__}
+    return metadata
+
+
+# -----------------------------------------------------------------------------
+# Doctest handling
+# -----------------------------------------------------------------------------
+
+
+def contains_doctest(text):
+    try:
+        # check if it's valid Python as-is
+        compile(text, '<string>', 'exec')
+        return False
+    except SyntaxError:
+        pass
+    r = re.compile(r'^\s*>>>', re.M)
+    m = r.search(text)
+    return bool(m)
+
+
+def _split_code_at_show(text, function_name):
+    """Split code at plt.show()."""
+
+    is_doctest = contains_doctest(text)
+    if function_name is None:
+        parts = []
+        part = []
+        for line in text.split("\n"):
+            if ((not is_doctest and line.startswith('plt.show(')) or
+                   (is_doctest and line.strip() == '>>> plt.show()')):
+                part.append(line)
+                parts.append("\n".join(part))
+                part = []
+            else:
+                part.append(line)
+        if "\n".join(part).strip():
+            parts.append("\n".join(part))
+    else:
+        parts = [text]
+    return is_doctest, parts
+
+
+# -----------------------------------------------------------------------------
+# Template
+# -----------------------------------------------------------------------------
+
+_SOURCECODE = """
+{{ source_code }}
+
+.. only:: html
+
+   {% if src_name or (html_show_formats and not multi_image) %}
+   (
+   {%- if src_name -%}
+   :download:`Source code <{{ build_dir }}/{{ src_name }}>`
+   {%- endif -%}
+   {%- if html_show_formats and not multi_image -%}
+     {%- for img in images -%}
+       {%- for fmt in img.formats -%}
+         {%- if src_name or not loop.first -%}, {% endif -%}
+         :download:`{{ fmt }} <{{ build_dir }}/{{ img.basename }}.{{ fmt }}>`
+       {%- endfor -%}
+     {%- endfor -%}
+   {%- endif -%}
+   )
+   {% endif %}
+"""
+
+TEMPLATE_SRCSET = _SOURCECODE + """
+   {% for img in images %}
+   .. figure-mpl:: {{ build_dir }}/{{ img.basename }}.{{ default_fmt }}
+      {% for option in options -%}
+      {{ option }}
+      {% endfor %}
+      {%- if caption -%}
+      {{ caption }}  {# appropriate leading whitespace added beforehand #}
+      {% endif -%}
+      {%- if srcset -%}
+        :srcset: {{ build_dir }}/{{ img.basename }}.{{ default_fmt }}
+        {%- for sr in srcset -%}
+            , {{ build_dir }}/{{ img.basename }}.{{ sr }}.{{ default_fmt }} {{sr}}
+        {%- endfor -%}
+      {% endif %}
+
+   {% if html_show_formats and multi_image %}
+   (
+    {%- for fmt in img.formats -%}
+    {%- if not loop.first -%}, {% endif -%}
+    :download:`{{ fmt }} <{{ build_dir }}/{{ img.basename }}.{{ fmt }}>`
+    {%- endfor -%}
+   )
+   {% endif %}
+
+
+   {% endfor %}
+
+.. only:: not html
+
+   {% for img in images %}
+   .. figure-mpl:: {{ build_dir }}/{{ img.basename }}.*
+      {% for option in options -%}
+      {{ option }}
+      {% endfor -%}
+
+      {{ caption }}  {# appropriate leading whitespace added beforehand #}
+   {% endfor %}
+
+"""
+
+TEMPLATE = _SOURCECODE + """
+
+   {% for img in images %}
+   .. figure:: {{ build_dir }}/{{ img.basename }}.{{ default_fmt }}
+      {% for option in options -%}
+      {{ option }}
+      {% endfor %}
+
+      {% if html_show_formats and multi_image -%}
+        (
+        {%- for fmt in img.formats -%}
+        {%- if not loop.first -%}, {% endif -%}
+        :download:`{{ fmt }} <{{ build_dir }}/{{ img.basename }}.{{ fmt }}>`
+        {%- endfor -%}
+        )
+      {%- endif -%}
+
+      {{ caption }}  {# appropriate leading whitespace added beforehand #}
+   {% endfor %}
+
+.. only:: not html
+
+   {% for img in images %}
+   .. figure:: {{ build_dir }}/{{ img.basename }}.*
+      {% for option in options -%}
+      {{ option }}
+      {% endfor -%}
+
+      {{ caption }}  {# appropriate leading whitespace added beforehand #}
+   {% endfor %}
+
+"""
+
+exception_template = """
+.. only:: html
+
+   [`source code <%(linkdir)s/%(basename)s.py>`__]
+
+Exception occurred rendering plot.
+
+"""
+
+# the context of the plot for all directives specified with the
+# :context: option
+plot_context = dict()
+
+
+class ImageFile:
+    def __init__(self, basename, dirname):
+        self.basename = basename
+        self.dirname = dirname
+        self.formats = []
+
+    def filename(self, format):
+        return os.path.join(self.dirname, f"{self.basename}.{format}")
+
+    def filenames(self):
+        return [self.filename(fmt) for fmt in self.formats]
+
+
+def out_of_date(original, derived, includes=None):
+    """
+    Return whether *derived* is out-of-date relative to *original* or any of
+    the RST files included in it using the RST include directive (*includes*).
+    *derived* and *original* are full paths, and *includes* is optionally a
+    list of full paths which may have been included in the *original*.
+    """
+    if not os.path.exists(derived):
+        return True
+
+    if includes is None:
+        includes = []
+    files_to_check = [original, *includes]
+
+    def out_of_date_one(original, derived_mtime):
+        return (os.path.exists(original) and
+                derived_mtime < os.stat(original).st_mtime)
+
+    derived_mtime = os.stat(derived).st_mtime
+    return any(out_of_date_one(f, derived_mtime) for f in files_to_check)
+
+
+class PlotError(RuntimeError):
+    pass
+
+
+def _run_code(code, code_path, ns=None, function_name=None):
+    """
+    Import a Python module from a path, and run the function given by
+    name, if function_name is not None.
+    """
+
+    # Change the working directory to the directory of the example, so
+    # it can get at its data files, if any.  Add its path to sys.path
+    # so it can import any helper modules sitting beside it.
+    pwd = os.getcwd()
+    if setup.config.plot_working_directory is not None:
+        try:
+            os.chdir(setup.config.plot_working_directory)
+        except OSError as err:
+            raise OSError(f'{err}\n`plot_working_directory` option in '
+                          f'Sphinx configuration file must be a valid '
+                          f'directory path') from err
+        except TypeError as err:
+            raise TypeError(f'{err}\n`plot_working_directory` option in '
+                            f'Sphinx configuration file must be a string or '
+                            f'None') from err
+    elif code_path is not None:
+        dirname = os.path.abspath(os.path.dirname(code_path))
+        os.chdir(dirname)
+
+    with cbook._setattr_cm(
+            sys, argv=[code_path], path=[os.getcwd(), *sys.path]), \
+            contextlib.redirect_stdout(StringIO()):
+        try:
+            if ns is None:
+                ns = {}
+            if not ns:
+                if setup.config.plot_pre_code is None:
+                    exec('import numpy as np\n'
+                         'from matplotlib import pyplot as plt\n', ns)
+                else:
+                    exec(str(setup.config.plot_pre_code), ns)
+            if "__main__" in code:
+                ns['__name__'] = '__main__'
+
+            # Patch out non-interactive show() to avoid triggering a warning.
+            with cbook._setattr_cm(FigureManagerBase, show=lambda self: None):
+                exec(code, ns)
+                if function_name is not None:
+                    exec(function_name + "()", ns)
+
+        except (Exception, SystemExit) as err:
+            raise PlotError(traceback.format_exc()) from err
+        finally:
+            os.chdir(pwd)
+    return ns
+
+
+def clear_state(plot_rcparams, close=True):
+    if close:
+        plt.close('all')
+    matplotlib.rc_file_defaults()
+    matplotlib.rcParams.update(plot_rcparams)
+
+
+def get_plot_formats(config):
+    default_dpi = {'png': 80, 'hires.png': 200, 'pdf': 200}
+    formats = []
+    plot_formats = config.plot_formats
+    for fmt in plot_formats:
+        if isinstance(fmt, str):
+            if ':' in fmt:
+                suffix, dpi = fmt.split(':')
+                formats.append((str(suffix), int(dpi)))
+            else:
+                formats.append((fmt, default_dpi.get(fmt, 80)))
+        elif isinstance(fmt, (tuple, list)) and len(fmt) == 2:
+            formats.append((str(fmt[0]), int(fmt[1])))
+        else:
+            raise PlotError('invalid image format "%r" in plot_formats' % fmt)
+    return formats
+
+
+def _parse_srcset(entries):
+    """
+    Parse srcset for multiples...
+    """
+    srcset = {}
+    for entry in entries:
+        entry = entry.strip()
+        if len(entry) >= 2:
+            mult = entry[:-1]
+            srcset[float(mult)] = entry
+        else:
+            raise ExtensionError(f'srcset argument {entry!r} is invalid.')
+    return srcset
+
+
+def render_figures(code, code_path, output_dir, output_base, context,
+                   function_name, config, context_reset=False,
+                   close_figs=False,
+                   code_includes=None):
+    """
+    Run a pyplot script and save the images in *output_dir*.
+
+    Save the images under *output_dir* with file names derived from
+    *output_base*
+    """
+
+    if function_name is not None:
+        output_base = f'{output_base}_{function_name}'
+    formats = get_plot_formats(config)
+
+    # Try to determine if all images already exist
+
+    is_doctest, code_pieces = _split_code_at_show(code, function_name)
+    # Look for single-figure output files first
+    img = ImageFile(output_base, output_dir)
+    for format, dpi in formats:
+        if context or out_of_date(code_path, img.filename(format),
+                                  includes=code_includes):
+            all_exists = False
+            break
+        img.formats.append(format)
+    else:
+        all_exists = True
+
+    if all_exists:
+        return [(code, [img])]
+
+    # Then look for multi-figure output files
+    results = []
+    for i, code_piece in enumerate(code_pieces):
+        images = []
+        for j in itertools.count():
+            if len(code_pieces) > 1:
+                img = ImageFile('%s_%02d_%02d' % (output_base, i, j),
+                                output_dir)
+            else:
+                img = ImageFile('%s_%02d' % (output_base, j), output_dir)
+            for fmt, dpi in formats:
+                if context or out_of_date(code_path, img.filename(fmt),
+                                          includes=code_includes):
+                    all_exists = False
+                    break
+                img.formats.append(fmt)
+
+            # assume that if we have one, we have them all
+            if not all_exists:
+                all_exists = (j > 0)
+                break
+            images.append(img)
+        if not all_exists:
+            break
+        results.append((code_piece, images))
+    else:
+        all_exists = True
+
+    if all_exists:
+        return results
+
+    # We didn't find the files, so build them
+
+    results = []
+    ns = plot_context if context else {}
+
+    if context_reset:
+        clear_state(config.plot_rcparams)
+        plot_context.clear()
+
+    close_figs = not context or close_figs
+
+    for i, code_piece in enumerate(code_pieces):
+
+        if not context or config.plot_apply_rcparams:
+            clear_state(config.plot_rcparams, close_figs)
+        elif close_figs:
+            plt.close('all')
+
+        _run_code(doctest.script_from_examples(code_piece) if is_doctest
+                  else code_piece,
+                  code_path, ns, function_name)
+
+        images = []
+        fig_managers = _pylab_helpers.Gcf.get_all_fig_managers()
+        for j, figman in enumerate(fig_managers):
+            if len(fig_managers) == 1 and len(code_pieces) == 1:
+                img = ImageFile(output_base, output_dir)
+            elif len(code_pieces) == 1:
+                img = ImageFile("%s_%02d" % (output_base, j), output_dir)
+            else:
+                img = ImageFile("%s_%02d_%02d" % (output_base, i, j),
+                                output_dir)
+            images.append(img)
+
+            for fmt, dpi in formats:
+                try:
+                    figman.canvas.figure.savefig(img.filename(fmt), dpi=dpi)
+                    if fmt == formats[0][0] and config.plot_srcset:
+                        # save a 2x, 3x etc version of the default...
+                        srcset = _parse_srcset(config.plot_srcset)
+                        for mult, suffix in srcset.items():
+                            fm = f'{suffix}.{fmt}'
+                            img.formats.append(fm)
+                            figman.canvas.figure.savefig(img.filename(fm),
+                                                         dpi=int(dpi * mult))
+                except Exception as err:
+                    raise PlotError(traceback.format_exc()) from err
+                img.formats.append(fmt)
+
+        results.append((code_piece, images))
+
+    if not context or config.plot_apply_rcparams:
+        clear_state(config.plot_rcparams, close=not context)
+
+    return results
+
+
+def run(arguments, content, options, state_machine, state, lineno):
+    document = state_machine.document
+    config = document.settings.env.config
+    nofigs = 'nofigs' in options
+
+    if config.plot_srcset and setup.app.builder.name == 'singlehtml':
+        raise ExtensionError(
+            'plot_srcset option not compatible with single HTML writer')
+
+    formats = get_plot_formats(config)
+    default_fmt = formats[0][0]
+
+    options.setdefault('include-source', config.plot_include_source)
+    options.setdefault('show-source-link', config.plot_html_show_source_link)
+
+    if 'class' in options:
+        # classes are parsed into a list of string, and output by simply
+        # printing the list, abusing the fact that RST guarantees to strip
+        # non-conforming characters
+        options['class'] = ['plot-directive'] + options['class']
+    else:
+        options.setdefault('class', ['plot-directive'])
+    keep_context = 'context' in options
+    context_opt = None if not keep_context else options['context']
+
+    rst_file = document.attributes['source']
+    rst_dir = os.path.dirname(rst_file)
+
+    if len(arguments):
+        if not config.plot_basedir:
+            source_file_name = os.path.join(setup.app.builder.srcdir,
+                                            directives.uri(arguments[0]))
+        else:
+            source_file_name = os.path.join(setup.confdir, config.plot_basedir,
+                                            directives.uri(arguments[0]))
+        # If there is content, it will be passed as a caption.
+        caption = '\n'.join(content)
+
+        # Enforce unambiguous use of captions.
+        if "caption" in options:
+            if caption:
+                raise ValueError(
+                    'Caption specified in both content and options.'
+                    ' Please remove ambiguity.'
+                )
+            # Use caption option
+            caption = options["caption"]
+
+        # If the optional function name is provided, use it
+        if len(arguments) == 2:
+            function_name = arguments[1]
+        else:
+            function_name = None
+
+        code = Path(source_file_name).read_text(encoding='utf-8')
+        output_base = os.path.basename(source_file_name)
+    else:
+        source_file_name = rst_file
+        code = textwrap.dedent("\n".join(map(str, content)))
+        counter = document.attributes.get('_plot_counter', 0) + 1
+        document.attributes['_plot_counter'] = counter
+        base, ext = os.path.splitext(os.path.basename(source_file_name))
+        output_base = '%s-%d.py' % (base, counter)
+        function_name = None
+        caption = options.get('caption', '')
+
+    base, source_ext = os.path.splitext(output_base)
+    if source_ext in ('.py', '.rst', '.txt'):
+        output_base = base
+    else:
+        source_ext = ''
+
+    # ensure that LaTeX includegraphics doesn't choke in foo.bar.pdf filenames
+    output_base = output_base.replace('.', '-')
+
+    # is it in doctest format?
+    is_doctest = contains_doctest(code)
+    if 'format' in options:
+        if options['format'] == 'python':
+            is_doctest = False
+        else:
+            is_doctest = True
+
+    # determine output directory name fragment
+    source_rel_name = relpath(source_file_name, setup.confdir)
+    source_rel_dir = os.path.dirname(source_rel_name).lstrip(os.path.sep)
+
+    # build_dir: where to place output files (temporarily)
+    build_dir = os.path.join(os.path.dirname(setup.app.doctreedir),
+                             'plot_directive',
+                             source_rel_dir)
+    # get rid of .. in paths, also changes pathsep
+    # see note in Python docs for warning about symbolic links on Windows.
+    # need to compare source and dest paths at end
+    build_dir = os.path.normpath(build_dir)
+    os.makedirs(build_dir, exist_ok=True)
+
+    # how to link to files from the RST file
+    try:
+        build_dir_link = relpath(build_dir, rst_dir).replace(os.path.sep, '/')
+    except ValueError:
+        # on Windows, relpath raises ValueError when path and start are on
+        # different mounts/drives
+        build_dir_link = build_dir
+
+    # get list of included rst files so that the output is updated when any
+    # plots in the included files change. These attributes are modified by the
+    # include directive (see the docutils.parsers.rst.directives.misc module).
+    try:
+        source_file_includes = [os.path.join(os.getcwd(), t[0])
+                                for t in state.document.include_log]
+    except AttributeError:
+        # the document.include_log attribute only exists in docutils >=0.17,
+        # before that we need to inspect the state machine
+        possible_sources = {os.path.join(setup.confdir, t[0])
+                            for t in state_machine.input_lines.items}
+        source_file_includes = [f for f in possible_sources
+                                if os.path.isfile(f)]
+    # remove the source file itself from the includes
+    try:
+        source_file_includes.remove(source_file_name)
+    except ValueError:
+        pass
+
+    # save script (if necessary)
+    if options['show-source-link']:
+        Path(build_dir, output_base + source_ext).write_text(
+            doctest.script_from_examples(code)
+            if source_file_name == rst_file and is_doctest
+            else code,
+            encoding='utf-8')
+
+    # make figures
+    try:
+        results = render_figures(code=code,
+                                 code_path=source_file_name,
+                                 output_dir=build_dir,
+                                 output_base=output_base,
+                                 context=keep_context,
+                                 function_name=function_name,
+                                 config=config,
+                                 context_reset=context_opt == 'reset',
+                                 close_figs=context_opt == 'close-figs',
+                                 code_includes=source_file_includes)
+        errors = []
+    except PlotError as err:
+        reporter = state.memo.reporter
+        sm = reporter.system_message(
+            2, "Exception occurred in plotting {}\n from {}:\n{}".format(
+                output_base, source_file_name, err),
+            line=lineno)
+        results = [(code, [])]
+        errors = [sm]
+
+    # Properly indent the caption
+    if caption and config.plot_srcset:
+        caption = ':caption: ' + caption.replace('\n', ' ')
+    elif caption:
+        caption = '\n' + '\n'.join('      ' + line.strip()
+                                   for line in caption.split('\n'))
+    # generate output restructuredtext
+    total_lines = []
+    for j, (code_piece, images) in enumerate(results):
+        if options['include-source']:
+            if is_doctest:
+                lines = ['', *code_piece.splitlines()]
+            else:
+                lines = ['.. code-block:: python', '',
+                         *textwrap.indent(code_piece, '    ').splitlines()]
+            source_code = "\n".join(lines)
+        else:
+            source_code = ""
+
+        if nofigs:
+            images = []
+
+        if 'alt' in options:
+            options['alt'] = options['alt'].replace('\n', ' ')
+
+        opts = [
+            f':{key}: {val}' for key, val in options.items()
+            if key in ('alt', 'height', 'width', 'scale', 'align', 'class')]
+
+        # Not-None src_name signals the need for a source download in the
+        # generated html
+        if j == 0 and options['show-source-link']:
+            src_name = output_base + source_ext
+        else:
+            src_name = None
+        if config.plot_srcset:
+            srcset = [*_parse_srcset(config.plot_srcset).values()]
+            template = TEMPLATE_SRCSET
+        else:
+            srcset = None
+            template = TEMPLATE
+
+        result = jinja2.Template(config.plot_template or template).render(
+            default_fmt=default_fmt,
+            build_dir=build_dir_link,
+            src_name=src_name,
+            multi_image=len(images) > 1,
+            options=opts,
+            srcset=srcset,
+            images=images,
+            source_code=source_code,
+            html_show_formats=config.plot_html_show_formats and len(images),
+            caption=caption)
+        total_lines.extend(result.split("\n"))
+        total_lines.extend("\n")
+
+    if total_lines:
+        state_machine.insert_input(total_lines, source=source_file_name)
+
+    return errors
diff --git a/lib/python3.10/site-packages/matplotlib/sphinxext/roles.py b/lib/python3.10/site-packages/matplotlib/sphinxext/roles.py
new file mode 100644
index 0000000000000000000000000000000000000000..301adcd8a5f5e0b18d28df297ee2025947e5c90d
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/sphinxext/roles.py
@@ -0,0 +1,147 @@
+"""
+Custom roles for the Matplotlib documentation.
+
+.. warning::
+
+    These roles are considered semi-public. They are only intended to be used in
+    the Matplotlib documentation.
+
+However, it can happen that downstream packages end up pulling these roles into
+their documentation, which will result in documentation build errors. The following
+describes the exact mechanism and how to fix the errors.
+
+There are two ways, Matplotlib docstrings can end up in downstream documentation.
+You have to subclass a Matplotlib class and either use the ``:inherited-members:``
+option in your autodoc configuration, or you have to override a method without
+specifying a new docstring; the new method will inherit the original docstring and
+still render in your autodoc. If the docstring contains one of the custom sphinx
+roles, you'll see one of the following error messages:
+
+.. code-block:: none
+
+    Unknown interpreted text role "mpltype".
+    Unknown interpreted text role "rc".
+
+To fix this, you can add this module as extension to your sphinx :file:`conf.py`::
+
+    extensions = [
+        'matplotlib.sphinxext.roles',
+        # Other extensions.
+    ]
+
+.. warning::
+
+    Direct use of these roles in other packages is not officially supported. We
+    reserve the right to modify or remove these roles without prior notification.
+"""
+
+from urllib.parse import urlsplit, urlunsplit
+
+from docutils import nodes
+
+import matplotlib
+from matplotlib import rcParamsDefault
+
+
+class _QueryReference(nodes.Inline, nodes.TextElement):
+    """
+    Wraps a reference or pending reference to add a query string.
+
+    The query string is generated from the attributes added to this node.
+
+    Also equivalent to a `~docutils.nodes.literal` node.
+    """
+
+    def to_query_string(self):
+        """Generate query string from node attributes."""
+        return '&'.join(f'{name}={value}' for name, value in self.attlist())
+
+
+def _visit_query_reference_node(self, node):
+    """
+    Resolve *node* into query strings on its ``reference`` children.
+
+    Then act as if this is a `~docutils.nodes.literal`.
+    """
+    query = node.to_query_string()
+    for refnode in node.findall(nodes.reference):
+        uri = urlsplit(refnode['refuri'])._replace(query=query)
+        refnode['refuri'] = urlunsplit(uri)
+
+    self.visit_literal(node)
+
+
+def _depart_query_reference_node(self, node):
+    """
+    Act as if this is a `~docutils.nodes.literal`.
+    """
+    self.depart_literal(node)
+
+
+def _rcparam_role(name, rawtext, text, lineno, inliner, options=None, content=None):
+    """
+    Sphinx role ``:rc:`` to highlight and link ``rcParams`` entries.
+
+    Usage: Give the desired ``rcParams`` key as parameter.
+
+    :code:`:rc:`figure.dpi`` will render as: :rc:`figure.dpi`
+    """
+    # Generate a pending cross-reference so that Sphinx will ensure this link
+    # isn't broken at some point in the future.
+    title = f'rcParams["{text}"]'
+    target = 'matplotlibrc-sample'
+    ref_nodes, messages = inliner.interpreted(title, f'{title} <{target}>',
+                                              'ref', lineno)
+
+    qr = _QueryReference(rawtext, highlight=text)
+    qr += ref_nodes
+    node_list = [qr]
+
+    # The default backend would be printed as "agg", but that's not correct (as
+    # the default is actually determined by fallback).
+    if text in rcParamsDefault and text != "backend":
+        node_list.extend([
+            nodes.Text(' (default: '),
+            nodes.literal('', repr(rcParamsDefault[text])),
+            nodes.Text(')'),
+            ])
+
+    return node_list, messages
+
+
+def _mpltype_role(name, rawtext, text, lineno, inliner, options=None, content=None):
+    """
+    Sphinx role ``:mpltype:`` for custom matplotlib types.
+
+    In Matplotlib, there are a number of type-like concepts that do not have a
+    direct type representation; example: color. This role allows to properly
+    highlight them in the docs and link to their definition.
+
+    Currently supported values:
+
+    - :code:`:mpltype:`color`` will render as: :mpltype:`color`
+
+    """
+    mpltype = text
+    type_to_link_target = {
+        'color': 'colors_def',
+    }
+    if mpltype not in type_to_link_target:
+        raise ValueError(f"Unknown mpltype: {mpltype!r}")
+
+    node_list, messages = inliner.interpreted(
+        mpltype, f'{mpltype} <{type_to_link_target[mpltype]}>', 'ref', lineno)
+    return node_list, messages
+
+
+def setup(app):
+    app.add_role("rc", _rcparam_role)
+    app.add_role("mpltype", _mpltype_role)
+    app.add_node(
+        _QueryReference,
+        html=(_visit_query_reference_node, _depart_query_reference_node),
+        latex=(_visit_query_reference_node, _depart_query_reference_node),
+        text=(_visit_query_reference_node, _depart_query_reference_node),
+    )
+    return {"version": matplotlib.__version__,
+            "parallel_read_safe": True, "parallel_write_safe": True}
diff --git a/lib/python3.10/site-packages/matplotlib/style/__init__.py b/lib/python3.10/site-packages/matplotlib/style/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..488c6d6ae1ec310cdd84bb209b4103da26fed284
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/style/__init__.py
@@ -0,0 +1,4 @@
+from .core import available, context, library, reload_library, use
+
+
+__all__ = ["available", "context", "library", "reload_library", "use"]
diff --git a/lib/python3.10/site-packages/matplotlib/style/__pycache__/__init__.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/style/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..264ace4e5ae903563aa4d8298a9b342ea23b2565
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/style/__pycache__/__init__.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/style/__pycache__/core.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/style/__pycache__/core.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6deba9f491a7d92c649822e01f9d86e45c22482a
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/style/__pycache__/core.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/style/core.py b/lib/python3.10/site-packages/matplotlib/style/core.py
new file mode 100644
index 0000000000000000000000000000000000000000..e36c3c37a882492afbb71716b4d98a46208bfe55
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/style/core.py
@@ -0,0 +1,237 @@
+"""
+Core functions and attributes for the matplotlib style library:
+
+``use``
+    Select style sheet to override the current matplotlib settings.
+``context``
+    Context manager to use a style sheet temporarily.
+``available``
+    List available style sheets.
+``library``
+    A dictionary of style names and matplotlib settings.
+"""
+
+import contextlib
+import importlib.resources
+import logging
+import os
+from pathlib import Path
+import warnings
+
+import matplotlib as mpl
+from matplotlib import _api, _docstring, _rc_params_in_file, rcParamsDefault
+
+_log = logging.getLogger(__name__)
+
+__all__ = ['use', 'context', 'available', 'library', 'reload_library']
+
+
+BASE_LIBRARY_PATH = os.path.join(mpl.get_data_path(), 'stylelib')
+# Users may want multiple library paths, so store a list of paths.
+USER_LIBRARY_PATHS = [os.path.join(mpl.get_configdir(), 'stylelib')]
+STYLE_EXTENSION = 'mplstyle'
+# A list of rcParams that should not be applied from styles
+STYLE_BLACKLIST = {
+    'interactive', 'backend', 'webagg.port', 'webagg.address',
+    'webagg.port_retries', 'webagg.open_in_browser', 'backend_fallback',
+    'toolbar', 'timezone', 'figure.max_open_warning',
+    'figure.raise_window', 'savefig.directory', 'tk.window_focus',
+    'docstring.hardcopy', 'date.epoch'}
+
+
+@_docstring.Substitution(
+    "\n".join(map("- {}".format, sorted(STYLE_BLACKLIST, key=str.lower)))
+)
+def use(style):
+    """
+    Use Matplotlib style settings from a style specification.
+
+    The style name of 'default' is reserved for reverting back to
+    the default style settings.
+
+    .. note::
+
+       This updates the `.rcParams` with the settings from the style.
+       `.rcParams` not defined in the style are kept.
+
+    Parameters
+    ----------
+    style : str, dict, Path or list
+
+        A style specification. Valid options are:
+
+        str
+            - One of the style names in `.style.available` (a builtin style or
+              a style installed in the user library path).
+
+            - A dotted name of the form "package.style_name"; in that case,
+              "package" should be an importable Python package name, e.g. at
+              ``/path/to/package/__init__.py``; the loaded style file is
+              ``/path/to/package/style_name.mplstyle``.  (Style files in
+              subpackages are likewise supported.)
+
+            - The path or URL to a style file, which gets loaded by
+              `.rc_params_from_file`.
+
+        dict
+            A mapping of key/value pairs for `matplotlib.rcParams`.
+
+        Path
+            The path to a style file, which gets loaded by
+            `.rc_params_from_file`.
+
+        list
+            A list of style specifiers (str, Path or dict), which are applied
+            from first to last in the list.
+
+    Notes
+    -----
+    The following `.rcParams` are not related to style and will be ignored if
+    found in a style specification:
+
+    %s
+    """
+    if isinstance(style, (str, Path)) or hasattr(style, 'keys'):
+        # If name is a single str, Path or dict, make it a single element list.
+        styles = [style]
+    else:
+        styles = style
+
+    style_alias = {'mpl20': 'default', 'mpl15': 'classic'}
+
+    for style in styles:
+        if isinstance(style, str):
+            style = style_alias.get(style, style)
+            if style == "default":
+                # Deprecation warnings were already handled when creating
+                # rcParamsDefault, no need to reemit them here.
+                with _api.suppress_matplotlib_deprecation_warning():
+                    # don't trigger RcParams.__getitem__('backend')
+                    style = {k: rcParamsDefault[k] for k in rcParamsDefault
+                             if k not in STYLE_BLACKLIST}
+            elif style in library:
+                style = library[style]
+            elif "." in style:
+                pkg, _, name = style.rpartition(".")
+                try:
+                    path = importlib.resources.files(pkg) / f"{name}.{STYLE_EXTENSION}"
+                    style = _rc_params_in_file(path)
+                except (ModuleNotFoundError, OSError, TypeError) as exc:
+                    # There is an ambiguity whether a dotted name refers to a
+                    # package.style_name or to a dotted file path.  Currently,
+                    # we silently try the first form and then the second one;
+                    # in the future, we may consider forcing file paths to
+                    # either use Path objects or be prepended with "./" and use
+                    # the slash as marker for file paths.
+                    pass
+        if isinstance(style, (str, Path)):
+            try:
+                style = _rc_params_in_file(style)
+            except OSError as err:
+                raise OSError(
+                    f"{style!r} is not a valid package style, path of style "
+                    f"file, URL of style file, or library style name (library "
+                    f"styles are listed in `style.available`)") from err
+        filtered = {}
+        for k in style:  # don't trigger RcParams.__getitem__('backend')
+            if k in STYLE_BLACKLIST:
+                _api.warn_external(
+                    f"Style includes a parameter, {k!r}, that is not "
+                    f"related to style.  Ignoring this parameter.")
+            else:
+                filtered[k] = style[k]
+        mpl.rcParams.update(filtered)
+
+
+@contextlib.contextmanager
+def context(style, after_reset=False):
+    """
+    Context manager for using style settings temporarily.
+
+    Parameters
+    ----------
+    style : str, dict, Path or list
+        A style specification. Valid options are:
+
+        str
+            - One of the style names in `.style.available` (a builtin style or
+              a style installed in the user library path).
+
+            - A dotted name of the form "package.style_name"; in that case,
+              "package" should be an importable Python package name, e.g. at
+              ``/path/to/package/__init__.py``; the loaded style file is
+              ``/path/to/package/style_name.mplstyle``.  (Style files in
+              subpackages are likewise supported.)
+
+            - The path or URL to a style file, which gets loaded by
+              `.rc_params_from_file`.
+        dict
+            A mapping of key/value pairs for `matplotlib.rcParams`.
+
+        Path
+            The path to a style file, which gets loaded by
+            `.rc_params_from_file`.
+
+        list
+            A list of style specifiers (str, Path or dict), which are applied
+            from first to last in the list.
+
+    after_reset : bool
+        If True, apply style after resetting settings to their defaults;
+        otherwise, apply style on top of the current settings.
+    """
+    with mpl.rc_context():
+        if after_reset:
+            mpl.rcdefaults()
+        use(style)
+        yield
+
+
+def update_user_library(library):
+    """Update style library with user-defined rc files."""
+    for stylelib_path in map(os.path.expanduser, USER_LIBRARY_PATHS):
+        styles = read_style_directory(stylelib_path)
+        update_nested_dict(library, styles)
+    return library
+
+
+def read_style_directory(style_dir):
+    """Return dictionary of styles defined in *style_dir*."""
+    styles = dict()
+    for path in Path(style_dir).glob(f"*.{STYLE_EXTENSION}"):
+        with warnings.catch_warnings(record=True) as warns:
+            styles[path.stem] = _rc_params_in_file(path)
+        for w in warns:
+            _log.warning('In %s: %s', path, w.message)
+    return styles
+
+
+def update_nested_dict(main_dict, new_dict):
+    """
+    Update nested dict (only level of nesting) with new values.
+
+    Unlike `dict.update`, this assumes that the values of the parent dict are
+    dicts (or dict-like), so you shouldn't replace the nested dict if it
+    already exists. Instead you should update the sub-dict.
+    """
+    # update named styles specified by user
+    for name, rc_dict in new_dict.items():
+        main_dict.setdefault(name, {}).update(rc_dict)
+    return main_dict
+
+
+# Load style library
+# ==================
+_base_library = read_style_directory(BASE_LIBRARY_PATH)
+library = {}
+available = []
+
+
+def reload_library():
+    """Reload the style library."""
+    library.clear()
+    library.update(update_user_library(_base_library))
+    available[:] = sorted(library.keys())
+
+
+reload_library()
diff --git a/lib/python3.10/site-packages/matplotlib/style/core.pyi b/lib/python3.10/site-packages/matplotlib/style/core.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..5734b017f7c41ee09908c191d18e8f557ed814a2
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/style/core.pyi
@@ -0,0 +1,21 @@
+from collections.abc import Generator
+import contextlib
+
+from matplotlib import RcParams
+from matplotlib.typing import RcStyleType
+
+USER_LIBRARY_PATHS: list[str] = ...
+STYLE_EXTENSION: str = ...
+
+def use(style: RcStyleType) -> None: ...
+@contextlib.contextmanager
+def context(
+    style: RcStyleType, after_reset: bool = ...
+) -> Generator[None, None, None]: ...
+
+library: dict[str, RcParams]
+available: list[str]
+
+def reload_library() -> None: ...
+
+__all__ = ['use', 'context', 'available', 'library', 'reload_library']
diff --git a/lib/python3.10/site-packages/matplotlib/testing/__init__.py b/lib/python3.10/site-packages/matplotlib/testing/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..19113d3996268ca6d3cec637785f7a30da0aae2f
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/testing/__init__.py
@@ -0,0 +1,234 @@
+"""
+Helper functions for testing.
+"""
+from pathlib import Path
+from tempfile import TemporaryDirectory
+import locale
+import logging
+import os
+import subprocess
+import sys
+
+import matplotlib as mpl
+from matplotlib import _api
+
+_log = logging.getLogger(__name__)
+
+
+def set_font_settings_for_testing():
+    mpl.rcParams['font.family'] = 'DejaVu Sans'
+    mpl.rcParams['text.hinting'] = 'none'
+    mpl.rcParams['text.hinting_factor'] = 8
+
+
+def set_reproducibility_for_testing():
+    mpl.rcParams['svg.hashsalt'] = 'matplotlib'
+
+
+def setup():
+    # The baseline images are created in this locale, so we should use
+    # it during all of the tests.
+
+    try:
+        locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
+    except locale.Error:
+        try:
+            locale.setlocale(locale.LC_ALL, 'English_United States.1252')
+        except locale.Error:
+            _log.warning(
+                "Could not set locale to English/United States. "
+                "Some date-related tests may fail.")
+
+    mpl.use('Agg')
+
+    with _api.suppress_matplotlib_deprecation_warning():
+        mpl.rcdefaults()  # Start with all defaults
+
+    # These settings *must* be hardcoded for running the comparison tests and
+    # are not necessarily the default values as specified in rcsetup.py.
+    set_font_settings_for_testing()
+    set_reproducibility_for_testing()
+
+
+def subprocess_run_for_testing(command, env=None, timeout=60, stdout=None,
+                               stderr=None, check=False, text=True,
+                               capture_output=False):
+    """
+    Create and run a subprocess.
+
+    Thin wrapper around `subprocess.run`, intended for testing.  Will
+    mark fork() failures on Cygwin as expected failures: not a
+    success, but not indicating a problem with the code either.
+
+    Parameters
+    ----------
+    args : list of str
+    env : dict[str, str]
+    timeout : float
+    stdout, stderr
+    check : bool
+    text : bool
+        Also called ``universal_newlines`` in subprocess.  I chose this
+        name since the main effect is returning bytes (`False`) vs. str
+        (`True`), though it also tries to normalize newlines across
+        platforms.
+    capture_output : bool
+        Set stdout and stderr to subprocess.PIPE
+
+    Returns
+    -------
+    proc : subprocess.Popen
+
+    See Also
+    --------
+    subprocess.run
+
+    Raises
+    ------
+    pytest.xfail
+        If platform is Cygwin and subprocess reports a fork() failure.
+    """
+    if capture_output:
+        stdout = stderr = subprocess.PIPE
+    try:
+        proc = subprocess.run(
+            command, env=env,
+            timeout=timeout, check=check,
+            stdout=stdout, stderr=stderr,
+            text=text
+        )
+    except BlockingIOError:
+        if sys.platform == "cygwin":
+            # Might want to make this more specific
+            import pytest
+            pytest.xfail("Fork failure")
+        raise
+    return proc
+
+
+def subprocess_run_helper(func, *args, timeout, extra_env=None):
+    """
+    Run a function in a sub-process.
+
+    Parameters
+    ----------
+    func : function
+        The function to be run.  It must be in a module that is importable.
+    *args : str
+        Any additional command line arguments to be passed in
+        the first argument to ``subprocess.run``.
+    extra_env : dict[str, str]
+        Any additional environment variables to be set for the subprocess.
+    """
+    target = func.__name__
+    module = func.__module__
+    file = func.__code__.co_filename
+    proc = subprocess_run_for_testing(
+        [
+            sys.executable,
+            "-c",
+            f"import importlib.util;"
+            f"_spec = importlib.util.spec_from_file_location({module!r}, {file!r});"
+            f"_module = importlib.util.module_from_spec(_spec);"
+            f"_spec.loader.exec_module(_module);"
+            f"_module.{target}()",
+            *args
+        ],
+        env={**os.environ, "SOURCE_DATE_EPOCH": "0", **(extra_env or {})},
+        timeout=timeout, check=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True
+    )
+    return proc
+
+
+def _check_for_pgf(texsystem):
+    """
+    Check if a given TeX system + pgf is available
+
+    Parameters
+    ----------
+    texsystem : str
+        The executable name to check
+    """
+    with TemporaryDirectory() as tmpdir:
+        tex_path = Path(tmpdir, "test.tex")
+        tex_path.write_text(r"""
+            \documentclass{article}
+            \usepackage{pgf}
+            \begin{document}
+            \typeout{pgfversion=\pgfversion}
+            \makeatletter
+            \@@end
+        """, encoding="utf-8")
+        try:
+            subprocess.check_call(
+                [texsystem, "-halt-on-error", str(tex_path)], cwd=tmpdir,
+                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        except (OSError, subprocess.CalledProcessError):
+            return False
+        return True
+
+
+def _has_tex_package(package):
+    try:
+        mpl.dviread.find_tex_file(f"{package}.sty")
+        return True
+    except FileNotFoundError:
+        return False
+
+
+def ipython_in_subprocess(requested_backend_or_gui_framework, all_expected_backends):
+    import pytest
+    IPython = pytest.importorskip("IPython")
+
+    if sys.platform == "win32":
+        pytest.skip("Cannot change backend running IPython in subprocess on Windows")
+
+    if (IPython.version_info[:3] == (8, 24, 0) and
+            requested_backend_or_gui_framework == "osx"):
+        pytest.skip("Bug using macosx backend in IPython 8.24.0 fixed in 8.24.1")
+
+    # This code can be removed when Python 3.12, the latest version supported
+    # by IPython < 8.24, reaches end-of-life in late 2028.
+    for min_version, backend in all_expected_backends.items():
+        if IPython.version_info[:2] >= min_version:
+            expected_backend = backend
+            break
+
+    code = ("import matplotlib as mpl, matplotlib.pyplot as plt;"
+            "fig, ax=plt.subplots(); ax.plot([1, 3, 2]); mpl.get_backend()")
+    proc = subprocess_run_for_testing(
+        [
+            "ipython",
+            "--no-simple-prompt",
+            f"--matplotlib={requested_backend_or_gui_framework}",
+            "-c", code,
+        ],
+        check=True,
+        capture_output=True,
+    )
+
+    assert proc.stdout.strip().endswith(f"'{expected_backend}'")
+
+
+def is_ci_environment():
+    # Common CI variables
+    ci_environment_variables = [
+        'CI',        # Generic CI environment variable
+        'CONTINUOUS_INTEGRATION',  # Generic CI environment variable
+        'TRAVIS',    # Travis CI
+        'CIRCLECI',  # CircleCI
+        'JENKINS',   # Jenkins
+        'GITLAB_CI',  # GitLab CI
+        'GITHUB_ACTIONS',  # GitHub Actions
+        'TEAMCITY_VERSION'  # TeamCity
+        # Add other CI environment variables as needed
+    ]
+
+    for env_var in ci_environment_variables:
+        if os.getenv(env_var):
+            return True
+
+    return False
diff --git a/lib/python3.10/site-packages/matplotlib/testing/__init__.pyi b/lib/python3.10/site-packages/matplotlib/testing/__init__.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..6917b6a5a38080b389f5d970beb8973c1c041206
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/testing/__init__.pyi
@@ -0,0 +1,54 @@
+from collections.abc import Callable
+import subprocess
+from typing import Any, IO, Literal, overload
+
+def set_font_settings_for_testing() -> None: ...
+def set_reproducibility_for_testing() -> None: ...
+def setup() -> None: ...
+@overload
+def subprocess_run_for_testing(
+    command: list[str],
+    env: dict[str, str] | None = ...,
+    timeout: float | None = ...,
+    stdout: int | IO[Any] | None = ...,
+    stderr: int | IO[Any] | None = ...,
+    check: bool = ...,
+    *,
+    text: Literal[True],
+    capture_output: bool = ...,
+) -> subprocess.CompletedProcess[str]: ...
+@overload
+def subprocess_run_for_testing(
+    command: list[str],
+    env: dict[str, str] | None = ...,
+    timeout: float | None = ...,
+    stdout: int | IO[Any] | None = ...,
+    stderr: int | IO[Any] | None = ...,
+    check: bool = ...,
+    text: Literal[False] = ...,
+    capture_output: bool = ...,
+) -> subprocess.CompletedProcess[bytes]: ...
+@overload
+def subprocess_run_for_testing(
+    command: list[str],
+    env: dict[str, str] | None = ...,
+    timeout: float | None = ...,
+    stdout: int | IO[Any] | None = ...,
+    stderr: int | IO[Any] | None = ...,
+    check: bool = ...,
+    text: bool = ...,
+    capture_output: bool = ...,
+) -> subprocess.CompletedProcess[bytes] | subprocess.CompletedProcess[str]: ...
+def subprocess_run_helper(
+    func: Callable[[], None],
+    *args: Any,
+    timeout: float,
+    extra_env: dict[str, str] | None = ...,
+) -> subprocess.CompletedProcess[str]: ...
+def _check_for_pgf(texsystem: str) -> bool: ...
+def _has_tex_package(package: str) -> bool: ...
+def ipython_in_subprocess(
+    requested_backend_or_gui_framework: str,
+    all_expected_backends: dict[tuple[int, int], str],
+) -> None: ...
+def is_ci_environment() -> bool: ...
diff --git a/lib/python3.10/site-packages/matplotlib/testing/__pycache__/__init__.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/testing/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6ce145d195bf4bb73d9720343f64e9f899669825
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/testing/__pycache__/__init__.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/testing/__pycache__/_markers.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/testing/__pycache__/_markers.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1149a00017d2bcb5367b37f88ac6f2fac11c618b
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/testing/__pycache__/_markers.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/testing/__pycache__/compare.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/testing/__pycache__/compare.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7bd4be278bd586636c42c610cf310e8749ade845
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/testing/__pycache__/compare.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/testing/__pycache__/conftest.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/testing/__pycache__/conftest.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fd271ada6ba45f8d974c5305980713b6828ee81a
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/testing/__pycache__/conftest.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/testing/__pycache__/decorators.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/testing/__pycache__/decorators.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..93d3ac8d28ab1436c33bba4ace3056b6dfceeb6c
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/testing/__pycache__/decorators.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/testing/__pycache__/exceptions.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/testing/__pycache__/exceptions.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2b8f01a0ed738123bca84da34cc1a88db4bd743d
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/testing/__pycache__/exceptions.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/testing/__pycache__/widgets.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/testing/__pycache__/widgets.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d52f6ab5d2f17c0b4156065f18550bc927addda9
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/testing/__pycache__/widgets.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/testing/_markers.py b/lib/python3.10/site-packages/matplotlib/testing/_markers.py
new file mode 100644
index 0000000000000000000000000000000000000000..c7ef8687a8b39766ba0385b5145b841043251de5
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/testing/_markers.py
@@ -0,0 +1,49 @@
+"""
+pytest markers for the internal Matplotlib test suite.
+"""
+
+import logging
+import shutil
+
+import pytest
+
+import matplotlib.testing
+import matplotlib.testing.compare
+from matplotlib import _get_executable_info, ExecutableNotFoundError
+
+
+_log = logging.getLogger(__name__)
+
+
+def _checkdep_usetex() -> bool:
+    if not shutil.which("tex"):
+        _log.warning("usetex mode requires TeX.")
+        return False
+    try:
+        _get_executable_info("dvipng")
+    except ExecutableNotFoundError:
+        _log.warning("usetex mode requires dvipng.")
+        return False
+    try:
+        _get_executable_info("gs")
+    except ExecutableNotFoundError:
+        _log.warning("usetex mode requires ghostscript.")
+        return False
+    return True
+
+
+needs_ghostscript = pytest.mark.skipif(
+    "eps" not in matplotlib.testing.compare.converter,
+    reason="This test needs a ghostscript installation")
+needs_pgf_lualatex = pytest.mark.skipif(
+    not matplotlib.testing._check_for_pgf('lualatex'),
+    reason='lualatex + pgf is required')
+needs_pgf_pdflatex = pytest.mark.skipif(
+    not matplotlib.testing._check_for_pgf('pdflatex'),
+    reason='pdflatex + pgf is required')
+needs_pgf_xelatex = pytest.mark.skipif(
+    not matplotlib.testing._check_for_pgf('xelatex'),
+    reason='xelatex + pgf is required')
+needs_usetex = pytest.mark.skipif(
+    not _checkdep_usetex(),
+    reason="This test needs a TeX installation")
diff --git a/lib/python3.10/site-packages/matplotlib/testing/compare.py b/lib/python3.10/site-packages/matplotlib/testing/compare.py
new file mode 100644
index 0000000000000000000000000000000000000000..3aeddcbe2b5e9cf99a665171cf5c58e33fc90497
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/testing/compare.py
@@ -0,0 +1,527 @@
+"""
+Utilities for comparing image results.
+"""
+
+import atexit
+import functools
+import hashlib
+import logging
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+from tempfile import TemporaryDirectory, TemporaryFile
+import weakref
+import re
+
+import numpy as np
+from PIL import Image
+
+import matplotlib as mpl
+from matplotlib import cbook
+from matplotlib.testing.exceptions import ImageComparisonFailure
+
+_log = logging.getLogger(__name__)
+
+__all__ = ['calculate_rms', 'comparable_formats', 'compare_images']
+
+
+def make_test_filename(fname, purpose):
+    """
+    Make a new filename by inserting *purpose* before the file's extension.
+    """
+    base, ext = os.path.splitext(fname)
+    return f'{base}-{purpose}{ext}'
+
+
+def _get_cache_path():
+    cache_dir = Path(mpl.get_cachedir(), 'test_cache')
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    return cache_dir
+
+
+def get_cache_dir():
+    return str(_get_cache_path())
+
+
+def get_file_hash(path, block_size=2 ** 20):
+    sha256 = hashlib.sha256(usedforsecurity=False)
+    with open(path, 'rb') as fd:
+        while True:
+            data = fd.read(block_size)
+            if not data:
+                break
+            sha256.update(data)
+
+    if Path(path).suffix == '.pdf':
+        sha256.update(str(mpl._get_executable_info("gs").version).encode('utf-8'))
+    elif Path(path).suffix == '.svg':
+        sha256.update(str(mpl._get_executable_info("inkscape").version).encode('utf-8'))
+
+    return sha256.hexdigest()
+
+
+class _ConverterError(Exception):
+    pass
+
+
+class _Converter:
+    def __init__(self):
+        self._proc = None
+        # Explicitly register deletion from an atexit handler because if we
+        # wait until the object is GC'd (which occurs later), then some module
+        # globals (e.g. signal.SIGKILL) has already been set to None, and
+        # kill() doesn't work anymore...
+        atexit.register(self.__del__)
+
+    def __del__(self):
+        if self._proc:
+            self._proc.kill()
+            self._proc.wait()
+            for stream in filter(None, [self._proc.stdin,
+                                        self._proc.stdout,
+                                        self._proc.stderr]):
+                stream.close()
+            self._proc = None
+
+    def _read_until(self, terminator):
+        """Read until the prompt is reached."""
+        buf = bytearray()
+        while True:
+            c = self._proc.stdout.read(1)
+            if not c:
+                raise _ConverterError(os.fsdecode(bytes(buf)))
+            buf.extend(c)
+            if buf.endswith(terminator):
+                return bytes(buf)
+
+
+class _GSConverter(_Converter):
+    def __call__(self, orig, dest):
+        if not self._proc:
+            self._proc = subprocess.Popen(
+                [mpl._get_executable_info("gs").executable,
+                 "-dNOSAFER", "-dNOPAUSE", "-dEPSCrop", "-sDEVICE=png16m"],
+                # As far as I can see, ghostscript never outputs to stderr.
+                stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+            try:
+                self._read_until(b"\nGS")
+            except _ConverterError as e:
+                raise OSError(f"Failed to start Ghostscript:\n\n{e.args[0]}") from None
+
+        def encode_and_escape(name):
+            return (os.fsencode(name)
+                    .replace(b"\\", b"\\\\")
+                    .replace(b"(", br"\(")
+                    .replace(b")", br"\)"))
+
+        self._proc.stdin.write(
+            b"<< /OutputFile ("
+            + encode_and_escape(dest)
+            + b") >> setpagedevice ("
+            + encode_and_escape(orig)
+            + b") run flush\n")
+        self._proc.stdin.flush()
+        # GS> if nothing left on the stack; GS<n> if n items left on the stack.
+        err = self._read_until((b"GS<", b"GS>"))
+        stack = self._read_until(b">") if err.endswith(b"GS<") else b""
+        if stack or not os.path.exists(dest):
+            stack_size = int(stack[:-1]) if stack else 0
+            self._proc.stdin.write(b"pop\n" * stack_size)
+            # Using the systemencoding should at least get the filenames right.
+            raise ImageComparisonFailure(
+                (err + stack).decode(sys.getfilesystemencoding(), "replace"))
+
+
+class _SVGConverter(_Converter):
+    def __call__(self, orig, dest):
+        old_inkscape = mpl._get_executable_info("inkscape").version.major < 1
+        terminator = b"\n>" if old_inkscape else b"> "
+        if not hasattr(self, "_tmpdir"):
+            self._tmpdir = TemporaryDirectory()
+            # On Windows, we must make sure that self._proc has terminated
+            # (which __del__ does) before clearing _tmpdir.
+            weakref.finalize(self._tmpdir, self.__del__)
+        if (not self._proc  # First run.
+                or self._proc.poll() is not None):  # Inkscape terminated.
+            if self._proc is not None and self._proc.poll() is not None:
+                for stream in filter(None, [self._proc.stdin,
+                                            self._proc.stdout,
+                                            self._proc.stderr]):
+                    stream.close()
+            env = {
+                **os.environ,
+                # If one passes e.g. a png file to Inkscape, it will try to
+                # query the user for conversion options via a GUI (even with
+                # `--without-gui`).  Unsetting `DISPLAY` prevents this (and
+                # causes GTK to crash and Inkscape to terminate, but that'll
+                # just be reported as a regular exception below).
+                "DISPLAY": "",
+                # Do not load any user options.
+                "INKSCAPE_PROFILE_DIR": self._tmpdir.name,
+            }
+            # Old versions of Inkscape (e.g. 0.48.3.1) seem to sometimes
+            # deadlock when stderr is redirected to a pipe, so we redirect it
+            # to a temporary file instead.  This is not necessary anymore as of
+            # Inkscape 0.92.1.
+            stderr = TemporaryFile()
+            self._proc = subprocess.Popen(
+                ["inkscape", "--without-gui", "--shell"] if old_inkscape else
+                ["inkscape", "--shell"],
+                stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=stderr,
+                env=env, cwd=self._tmpdir.name)
+            # Slight abuse, but makes shutdown handling easier.
+            self._proc.stderr = stderr
+            try:
+                self._read_until(terminator)
+            except _ConverterError as err:
+                raise OSError(
+                    "Failed to start Inkscape in interactive mode:\n\n"
+                    + err.args[0]) from err
+
+        # Inkscape's shell mode does not support escaping metacharacters in the
+        # filename ("\n", and ":;" for inkscape>=1).  Avoid any problems by
+        # running from a temporary directory and using fixed filenames.
+        inkscape_orig = Path(self._tmpdir.name, os.fsdecode(b"f.svg"))
+        inkscape_dest = Path(self._tmpdir.name, os.fsdecode(b"f.png"))
+        try:
+            inkscape_orig.symlink_to(Path(orig).resolve())
+        except OSError:
+            shutil.copyfile(orig, inkscape_orig)
+        self._proc.stdin.write(
+            b"f.svg --export-png=f.png\n" if old_inkscape else
+            b"file-open:f.svg;export-filename:f.png;export-do;file-close\n")
+        self._proc.stdin.flush()
+        try:
+            self._read_until(terminator)
+        except _ConverterError as err:
+            # Inkscape's output is not localized but gtk's is, so the output
+            # stream probably has a mixed encoding.  Using the filesystem
+            # encoding should at least get the filenames right...
+            self._proc.stderr.seek(0)
+            raise ImageComparisonFailure(
+                self._proc.stderr.read().decode(
+                    sys.getfilesystemencoding(), "replace")) from err
+        os.remove(inkscape_orig)
+        shutil.move(inkscape_dest, dest)
+
+    def __del__(self):
+        super().__del__()
+        if hasattr(self, "_tmpdir"):
+            self._tmpdir.cleanup()
+
+
+class _SVGWithMatplotlibFontsConverter(_SVGConverter):
+    """
+    A SVG converter which explicitly adds the fonts shipped by Matplotlib to
+    Inkspace's font search path, to better support `svg.fonttype = "none"`
+    (which is in particular used by certain mathtext tests).
+    """
+
+    def __call__(self, orig, dest):
+        if not hasattr(self, "_tmpdir"):
+            self._tmpdir = TemporaryDirectory()
+            shutil.copytree(cbook._get_data_path("fonts/ttf"),
+                            Path(self._tmpdir.name, "fonts"))
+        return super().__call__(orig, dest)
+
+
+def _update_converter():
+    try:
+        mpl._get_executable_info("gs")
+    except mpl.ExecutableNotFoundError:
+        pass
+    else:
+        converter['pdf'] = converter['eps'] = _GSConverter()
+    try:
+        mpl._get_executable_info("inkscape")
+    except mpl.ExecutableNotFoundError:
+        pass
+    else:
+        converter['svg'] = _SVGConverter()
+
+
+#: A dictionary that maps filename extensions to functions which themselves
+#: convert between arguments `old` and `new` (filenames).
+converter = {}
+_update_converter()
+_svg_with_matplotlib_fonts_converter = _SVGWithMatplotlibFontsConverter()
+
+
+def comparable_formats():
+    """
+    Return the list of file formats that `.compare_images` can compare
+    on this system.
+
+    Returns
+    -------
+    list of str
+        E.g. ``['png', 'pdf', 'svg', 'eps']``.
+
+    """
+    return ['png', *converter]
+
+
+def convert(filename, cache):
+    """
+    Convert the named file to png; return the name of the created file.
+
+    If *cache* is True, the result of the conversion is cached in
+    `matplotlib.get_cachedir() + '/test_cache/'`.  The caching is based on a
+    hash of the exact contents of the input file.  Old cache entries are
+    automatically deleted as needed to keep the size of the cache capped to
+    twice the size of all baseline images.
+    """
+    path = Path(filename)
+    if not path.exists():
+        raise OSError(f"{path} does not exist")
+    if path.suffix[1:] not in converter:
+        import pytest
+        pytest.skip(f"Don't know how to convert {path.suffix} files to png")
+    newpath = path.parent / f"{path.stem}_{path.suffix[1:]}.png"
+
+    # Only convert the file if the destination doesn't already exist or
+    # is out of date.
+    if not newpath.exists() or newpath.stat().st_mtime < path.stat().st_mtime:
+        cache_dir = _get_cache_path() if cache else None
+
+        if cache_dir is not None:
+            _register_conversion_cache_cleaner_once()
+            hash_value = get_file_hash(path)
+            cached_path = cache_dir / (hash_value + newpath.suffix)
+            if cached_path.exists():
+                _log.debug("For %s: reusing cached conversion.", filename)
+                shutil.copyfile(cached_path, newpath)
+                return str(newpath)
+
+        _log.debug("For %s: converting to png.", filename)
+        convert = converter[path.suffix[1:]]
+        if path.suffix == ".svg":
+            contents = path.read_text()
+            # NOTE: This check should be kept in sync with font styling in
+            # `lib/matplotlib/backends/backend_svg.py`. If it changes, then be sure to
+            # re-generate any SVG test files using this mode, or else such tests will
+            # fail to use the converter for the expected images (but will for the
+            # results), and the tests will fail strangely.
+            if re.search(
+                # searches for attributes :
+                #   style=[font|font-size|font-weight|
+                #          font-family|font-variant|font-style]
+                # taking care of the possibility of multiple style attributes
+                # before the font styling (i.e. opacity)
+                r'style="[^"]*font(|-size|-weight|-family|-variant|-style):',
+                contents  # raw contents of the svg file
+                    ):
+                # for svg.fonttype = none, we explicitly patch the font search
+                # path so that fonts shipped by Matplotlib are found.
+                convert = _svg_with_matplotlib_fonts_converter
+        convert(path, newpath)
+
+        if cache_dir is not None:
+            _log.debug("For %s: caching conversion result.", filename)
+            shutil.copyfile(newpath, cached_path)
+
+    return str(newpath)
+
+
+def _clean_conversion_cache():
+    # This will actually ignore mpl_toolkits baseline images, but they're
+    # relatively small.
+    baseline_images_size = sum(
+        path.stat().st_size
+        for path in Path(mpl.__file__).parent.glob("**/baseline_images/**/*"))
+    # 2x: one full copy of baselines, and one full copy of test results
+    # (actually an overestimate: we don't convert png baselines and results).
+    max_cache_size = 2 * baseline_images_size
+    # Reduce cache until it fits.
+    with cbook._lock_path(_get_cache_path()):
+        cache_stat = {
+            path: path.stat() for path in _get_cache_path().glob("*")}
+        cache_size = sum(stat.st_size for stat in cache_stat.values())
+        paths_by_atime = sorted(  # Oldest at the end.
+            cache_stat, key=lambda path: cache_stat[path].st_atime,
+            reverse=True)
+        while cache_size > max_cache_size:
+            path = paths_by_atime.pop()
+            cache_size -= cache_stat[path].st_size
+            path.unlink()
+
+
+@functools.cache  # Ensure this is only registered once.
+def _register_conversion_cache_cleaner_once():
+    atexit.register(_clean_conversion_cache)
+
+
+def crop_to_same(actual_path, actual_image, expected_path, expected_image):
+    # clip the images to the same size -- this is useful only when
+    # comparing eps to pdf
+    if actual_path[-7:-4] == 'eps' and expected_path[-7:-4] == 'pdf':
+        aw, ah, ad = actual_image.shape
+        ew, eh, ed = expected_image.shape
+        actual_image = actual_image[int(aw / 2 - ew / 2):int(
+            aw / 2 + ew / 2), int(ah / 2 - eh / 2):int(ah / 2 + eh / 2)]
+    return actual_image, expected_image
+
+
+def calculate_rms(expected_image, actual_image):
+    """
+    Calculate the per-pixel errors, then compute the root mean square error.
+    """
+    if expected_image.shape != actual_image.shape:
+        raise ImageComparisonFailure(
+            f"Image sizes do not match expected size: {expected_image.shape} "
+            f"actual size {actual_image.shape}")
+    # Convert to float to avoid overflowing finite integer types.
+    return np.sqrt(((expected_image - actual_image).astype(float) ** 2).mean())
+
+
+# NOTE: compare_image and save_diff_image assume that the image does not have
+# 16-bit depth, as Pillow converts these to RGB incorrectly.
+
+
+def _load_image(path):
+    img = Image.open(path)
+    # In an RGBA image, if the smallest value in the alpha channel is 255, all
+    # values in it must be 255, meaning that the image is opaque. If so,
+    # discard the alpha channel so that it may compare equal to an RGB image.
+    if img.mode != "RGBA" or img.getextrema()[3][0] == 255:
+        img = img.convert("RGB")
+    return np.asarray(img)
+
+
+def compare_images(expected, actual, tol, in_decorator=False):
+    """
+    Compare two "image" files checking differences within a tolerance.
+
+    The two given filenames may point to files which are convertible to
+    PNG via the `.converter` dictionary. The underlying RMS is calculated
+    with the `.calculate_rms` function.
+
+    Parameters
+    ----------
+    expected : str
+        The filename of the expected image.
+    actual : str
+        The filename of the actual image.
+    tol : float
+        The tolerance (a color value difference, where 255 is the
+        maximal difference).  The test fails if the average pixel
+        difference is greater than this value.
+    in_decorator : bool
+        Determines the output format. If called from image_comparison
+        decorator, this should be True. (default=False)
+
+    Returns
+    -------
+    None or dict or str
+        Return *None* if the images are equal within the given tolerance.
+
+        If the images differ, the return value depends on  *in_decorator*.
+        If *in_decorator* is true, a dict with the following entries is
+        returned:
+
+        - *rms*: The RMS of the image difference.
+        - *expected*: The filename of the expected image.
+        - *actual*: The filename of the actual image.
+        - *diff_image*: The filename of the difference image.
+        - *tol*: The comparison tolerance.
+
+        Otherwise, a human-readable multi-line string representation of this
+        information is returned.
+
+    Examples
+    --------
+    ::
+
+        img1 = "./baseline/plot.png"
+        img2 = "./output/plot.png"
+        compare_images(img1, img2, 0.001)
+
+    """
+    actual = os.fspath(actual)
+    if not os.path.exists(actual):
+        raise Exception(f"Output image {actual} does not exist.")
+    if os.stat(actual).st_size == 0:
+        raise Exception(f"Output image file {actual} is empty.")
+
+    # Convert the image to png
+    expected = os.fspath(expected)
+    if not os.path.exists(expected):
+        raise OSError(f'Baseline image {expected!r} does not exist.')
+    extension = expected.split('.')[-1]
+    if extension != 'png':
+        actual = convert(actual, cache=True)
+        expected = convert(expected, cache=True)
+
+    # open the image files
+    expected_image = _load_image(expected)
+    actual_image = _load_image(actual)
+
+    actual_image, expected_image = crop_to_same(
+        actual, actual_image, expected, expected_image)
+
+    diff_image = make_test_filename(actual, 'failed-diff')
+
+    if tol <= 0:
+        if np.array_equal(expected_image, actual_image):
+            return None
+
+    # convert to signed integers, so that the images can be subtracted without
+    # overflow
+    expected_image = expected_image.astype(np.int16)
+    actual_image = actual_image.astype(np.int16)
+
+    rms = calculate_rms(expected_image, actual_image)
+
+    if rms <= tol:
+        return None
+
+    save_diff_image(expected, actual, diff_image)
+
+    results = dict(rms=rms, expected=str(expected),
+                   actual=str(actual), diff=str(diff_image), tol=tol)
+
+    if not in_decorator:
+        # Then the results should be a string suitable for stdout.
+        template = ['Error: Image files did not match.',
+                    'RMS Value: {rms}',
+                    'Expected:  \n    {expected}',
+                    'Actual:    \n    {actual}',
+                    'Difference:\n    {diff}',
+                    'Tolerance: \n    {tol}', ]
+        results = '\n  '.join([line.format(**results) for line in template])
+    return results
+
+
+def save_diff_image(expected, actual, output):
+    """
+    Parameters
+    ----------
+    expected : str
+        File path of expected image.
+    actual : str
+        File path of actual image.
+    output : str
+        File path to save difference image to.
+    """
+    expected_image = _load_image(expected)
+    actual_image = _load_image(actual)
+    actual_image, expected_image = crop_to_same(
+        actual, actual_image, expected, expected_image)
+    expected_image = np.array(expected_image, float)
+    actual_image = np.array(actual_image, float)
+    if expected_image.shape != actual_image.shape:
+        raise ImageComparisonFailure(
+            f"Image sizes do not match expected size: {expected_image.shape} "
+            f"actual size {actual_image.shape}")
+    abs_diff = np.abs(expected_image - actual_image)
+
+    # expand differences in luminance domain
+    abs_diff *= 10
+    abs_diff = np.clip(abs_diff, 0, 255).astype(np.uint8)
+
+    if abs_diff.shape[2] == 4:  # Hard-code the alpha channel to fully solid
+        abs_diff[:, :, 3] = 255
+
+    Image.fromarray(abs_diff).save(output, format="png")
diff --git a/lib/python3.10/site-packages/matplotlib/testing/compare.pyi b/lib/python3.10/site-packages/matplotlib/testing/compare.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..8f11b3bebc1a0f4186448b1e8d6a8f11f06e3b4f
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/testing/compare.pyi
@@ -0,0 +1,32 @@
+from collections.abc import Callable
+from typing import Literal, overload
+
+from numpy.typing import NDArray
+
+__all__ = ["calculate_rms", "comparable_formats", "compare_images"]
+
+def make_test_filename(fname: str, purpose: str) -> str: ...
+def get_cache_dir() -> str: ...
+def get_file_hash(path: str, block_size: int = ...) -> str: ...
+
+converter: dict[str, Callable[[str, str], None]] = {}
+
+def comparable_formats() -> list[str]: ...
+def convert(filename: str, cache: bool) -> str: ...
+def crop_to_same(
+    actual_path: str, actual_image: NDArray, expected_path: str, expected_image: NDArray
+) -> tuple[NDArray, NDArray]: ...
+def calculate_rms(expected_image: NDArray, actual_image: NDArray) -> float: ...
+@overload
+def compare_images(
+    expected: str, actual: str, tol: float, in_decorator: Literal[True]
+) -> None | dict[str, float | str]: ...
+@overload
+def compare_images(
+    expected: str, actual: str, tol: float, in_decorator: Literal[False]
+) -> None | str: ...
+@overload
+def compare_images(
+    expected: str, actual: str, tol: float, in_decorator: bool = ...
+) -> None | str | dict[str, float | str]: ...
+def save_diff_image(expected: str, actual: str, output: str) -> None: ...
diff --git a/lib/python3.10/site-packages/matplotlib/testing/conftest.py b/lib/python3.10/site-packages/matplotlib/testing/conftest.py
new file mode 100644
index 0000000000000000000000000000000000000000..2961e7f02f3f9081f9918f090233281e18db2c2e
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/testing/conftest.py
@@ -0,0 +1,178 @@
+import pytest
+import sys
+import matplotlib
+from matplotlib import _api
+
+
+def pytest_configure(config):
+    # config is initialized here rather than in pytest.ini so that `pytest
+    # --pyargs matplotlib` (which would not find pytest.ini) works.  The only
+    # entries in pytest.ini set minversion (which is checked earlier),
+    # testpaths/python_files, as they are required to properly find the tests
+    for key, value in [
+        ("markers", "flaky: (Provided by pytest-rerunfailures.)"),
+        ("markers", "timeout: (Provided by pytest-timeout.)"),
+        ("markers", "backend: Set alternate Matplotlib backend temporarily."),
+        ("markers", "baseline_images: Compare output against references."),
+        ("markers", "pytz: Tests that require pytz to be installed."),
+        ("filterwarnings", "error"),
+        ("filterwarnings",
+         "ignore:.*The py23 module has been deprecated:DeprecationWarning"),
+        ("filterwarnings",
+         r"ignore:DynamicImporter.find_spec\(\) not found; "
+         r"falling back to find_module\(\):ImportWarning"),
+    ]:
+        config.addinivalue_line(key, value)
+
+    matplotlib.use('agg', force=True)
+    matplotlib._called_from_pytest = True
+    matplotlib._init_tests()
+
+
+def pytest_unconfigure(config):
+    matplotlib._called_from_pytest = False
+
+
+@pytest.fixture(autouse=True)
+def mpl_test_settings(request):
+    from matplotlib.testing.decorators import _cleanup_cm
+
+    with _cleanup_cm():
+
+        backend = None
+        backend_marker = request.node.get_closest_marker('backend')
+        prev_backend = matplotlib.get_backend()
+        if backend_marker is not None:
+            assert len(backend_marker.args) == 1, \
+                "Marker 'backend' must specify 1 backend."
+            backend, = backend_marker.args
+            skip_on_importerror = backend_marker.kwargs.get(
+                'skip_on_importerror', False)
+
+            # special case Qt backend importing to avoid conflicts
+            if backend.lower().startswith('qt5'):
+                if any(sys.modules.get(k) for k in ('PyQt4', 'PySide')):
+                    pytest.skip('Qt4 binding already imported')
+
+        matplotlib.testing.setup()
+        with _api.suppress_matplotlib_deprecation_warning():
+            if backend is not None:
+                # This import must come after setup() so it doesn't load the
+                # default backend prematurely.
+                import matplotlib.pyplot as plt
+                try:
+                    plt.switch_backend(backend)
+                except ImportError as exc:
+                    # Should only occur for the cairo backend tests, if neither
+                    # pycairo nor cairocffi are installed.
+                    if 'cairo' in backend.lower() or skip_on_importerror:
+                        pytest.skip("Failed to switch to backend "
+                                    f"{backend} ({exc}).")
+                    else:
+                        raise
+            # Default of cleanup and image_comparison too.
+            matplotlib.style.use(["classic", "_classic_test_patch"])
+        try:
+            yield
+        finally:
+            if backend is not None:
+                plt.close("all")
+                matplotlib.use(prev_backend)
+
+
+@pytest.fixture
+def pd():
+    """
+    Fixture to import and configure pandas. Using this fixture, the test is skipped when
+    pandas is not installed. Use this fixture instead of importing pandas in test files.
+
+    Examples
+    --------
+    Request the pandas fixture by passing in ``pd`` as an argument to the test ::
+
+        def test_matshow_pandas(pd):
+
+            df = pd.DataFrame({'x':[1,2,3], 'y':[4,5,6]})
+            im = plt.figure().subplots().matshow(df)
+            np.testing.assert_array_equal(im.get_array(), df)
+    """
+    pd = pytest.importorskip('pandas')
+    try:
+        from pandas.plotting import (
+            deregister_matplotlib_converters as deregister)
+        deregister()
+    except ImportError:
+        pass
+    return pd
+
+
+@pytest.fixture
+def xr():
+    """
+    Fixture to import xarray so that the test is skipped when xarray is not installed.
+    Use this fixture instead of importing xrray in test files.
+
+    Examples
+    --------
+    Request the xarray fixture by passing in ``xr`` as an argument to the test ::
+
+        def test_imshow_xarray(xr):
+
+            ds = xr.DataArray(np.random.randn(2, 3))
+            im = plt.figure().subplots().imshow(ds)
+            np.testing.assert_array_equal(im.get_array(), ds)
+    """
+
+    xr = pytest.importorskip('xarray')
+    return xr
+
+
+@pytest.fixture
+def text_placeholders(monkeypatch):
+    """
+    Replace texts with placeholder rectangles.
+
+    The rectangle size only depends on the font size and the number of characters. It is
+    thus insensitive to font properties and rendering details. This should be used for
+    tests that depend on text geometries but not the actual text rendering, e.g. layout
+    tests.
+    """
+    from matplotlib.patches import Rectangle
+
+    def patched_get_text_metrics_with_cache(renderer, text, fontprop, ismath, dpi):
+        """
+        Replace ``_get_text_metrics_with_cache`` with fixed results.
+
+        The usual ``renderer.get_text_width_height_descent`` would depend on font
+        metrics; instead the fixed results are based on font size and the length of the
+        string only.
+        """
+        # While get_window_extent returns pixels and font size is in points, font size
+        # includes ascenders and descenders. Leaving out this factor and setting
+        # descent=0 ends up with a box that is relatively close to DejaVu Sans.
+        height = fontprop.get_size()
+        width = len(text) * height / 1.618  # Golden ratio for character size.
+        descent = 0
+        return width, height, descent
+
+    def patched_text_draw(self, renderer):
+        """
+        Replace ``Text.draw`` with a fixed bounding box Rectangle.
+
+        The bounding box corresponds to ``Text.get_window_extent``, which ultimately
+        depends on the above patched ``_get_text_metrics_with_cache``.
+        """
+        if renderer is not None:
+            self._renderer = renderer
+        if not self.get_visible():
+            return
+        if self.get_text() == '':
+            return
+        bbox = self.get_window_extent()
+        rect = Rectangle(bbox.p0, bbox.width, bbox.height,
+                         facecolor=self.get_color(), edgecolor='none')
+        rect.draw(renderer)
+
+    monkeypatch.setattr('matplotlib.text._get_text_metrics_with_cache',
+                        patched_get_text_metrics_with_cache)
+    monkeypatch.setattr('matplotlib.text.Text.draw', patched_text_draw)
diff --git a/lib/python3.10/site-packages/matplotlib/testing/conftest.pyi b/lib/python3.10/site-packages/matplotlib/testing/conftest.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..f5d90bc88f738244c463b6a070a756ace8c56202
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/testing/conftest.pyi
@@ -0,0 +1,14 @@
+from types import ModuleType
+
+import pytest
+
+def pytest_configure(config: pytest.Config) -> None: ...
+def pytest_unconfigure(config: pytest.Config) -> None: ...
+@pytest.fixture
+def mpl_test_settings(request: pytest.FixtureRequest) -> None: ...
+@pytest.fixture
+def pd() -> ModuleType: ...
+@pytest.fixture
+def xr() -> ModuleType: ...
+@pytest.fixture
+def text_placeholders(monkeypatch: pytest.MonkeyPatch) -> None: ...
diff --git a/lib/python3.10/site-packages/matplotlib/testing/decorators.py b/lib/python3.10/site-packages/matplotlib/testing/decorators.py
new file mode 100644
index 0000000000000000000000000000000000000000..6f1af7debdb3160b9975b5278d2864e1b79d64e3
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/testing/decorators.py
@@ -0,0 +1,464 @@
+import contextlib
+import functools
+import inspect
+import os
+from platform import uname
+from pathlib import Path
+import shutil
+import string
+import sys
+import warnings
+
+from packaging.version import parse as parse_version
+
+import matplotlib.style
+import matplotlib.units
+import matplotlib.testing
+from matplotlib import _pylab_helpers, cbook, ft2font, pyplot as plt, ticker
+from .compare import comparable_formats, compare_images, make_test_filename
+from .exceptions import ImageComparisonFailure
+
+
+@contextlib.contextmanager
+def _cleanup_cm():
+    orig_units_registry = matplotlib.units.registry.copy()
+    try:
+        with warnings.catch_warnings(), matplotlib.rc_context():
+            yield
+    finally:
+        matplotlib.units.registry.clear()
+        matplotlib.units.registry.update(orig_units_registry)
+        plt.close("all")
+
+
+def _check_freetype_version(ver):
+    if ver is None:
+        return True
+
+    if isinstance(ver, str):
+        ver = (ver, ver)
+    ver = [parse_version(x) for x in ver]
+    found = parse_version(ft2font.__freetype_version__)
+
+    return ver[0] <= found <= ver[1]
+
+
+def _checked_on_freetype_version(required_freetype_version):
+    import pytest
+    return pytest.mark.xfail(
+        not _check_freetype_version(required_freetype_version),
+        reason=f"Mismatched version of freetype. "
+               f"Test requires '{required_freetype_version}', "
+               f"you have '{ft2font.__freetype_version__}'",
+        raises=ImageComparisonFailure, strict=False)
+
+
+def remove_ticks_and_titles(figure):
+    figure.suptitle("")
+    null_formatter = ticker.NullFormatter()
+    def remove_ticks(ax):
+        """Remove ticks in *ax* and all its child Axes."""
+        ax.set_title("")
+        ax.xaxis.set_major_formatter(null_formatter)
+        ax.xaxis.set_minor_formatter(null_formatter)
+        ax.yaxis.set_major_formatter(null_formatter)
+        ax.yaxis.set_minor_formatter(null_formatter)
+        try:
+            ax.zaxis.set_major_formatter(null_formatter)
+            ax.zaxis.set_minor_formatter(null_formatter)
+        except AttributeError:
+            pass
+        for child in ax.child_axes:
+            remove_ticks(child)
+    for ax in figure.get_axes():
+        remove_ticks(ax)
+
+
+@contextlib.contextmanager
+def _collect_new_figures():
+    """
+    After::
+
+        with _collect_new_figures() as figs:
+            some_code()
+
+    the list *figs* contains the figures that have been created during the
+    execution of ``some_code``, sorted by figure number.
+    """
+    managers = _pylab_helpers.Gcf.figs
+    preexisting = [manager for manager in managers.values()]
+    new_figs = []
+    try:
+        yield new_figs
+    finally:
+        new_managers = sorted([manager for manager in managers.values()
+                               if manager not in preexisting],
+                              key=lambda manager: manager.num)
+        new_figs[:] = [manager.canvas.figure for manager in new_managers]
+
+
+def _raise_on_image_difference(expected, actual, tol):
+    __tracebackhide__ = True
+
+    err = compare_images(expected, actual, tol, in_decorator=True)
+    if err:
+        for key in ["actual", "expected", "diff"]:
+            err[key] = os.path.relpath(err[key])
+        raise ImageComparisonFailure(
+            ('images not close (RMS %(rms).3f):'
+                '\n\t%(actual)s\n\t%(expected)s\n\t%(diff)s') % err)
+
+
+class _ImageComparisonBase:
+    """
+    Image comparison base class
+
+    This class provides *just* the comparison-related functionality and avoids
+    any code that would be specific to any testing framework.
+    """
+
+    def __init__(self, func, tol, remove_text, savefig_kwargs):
+        self.func = func
+        self.baseline_dir, self.result_dir = _image_directories(func)
+        self.tol = tol
+        self.remove_text = remove_text
+        self.savefig_kwargs = savefig_kwargs
+
+    def copy_baseline(self, baseline, extension):
+        baseline_path = self.baseline_dir / baseline
+        orig_expected_path = baseline_path.with_suffix(f'.{extension}')
+        if extension == 'eps' and not orig_expected_path.exists():
+            orig_expected_path = orig_expected_path.with_suffix('.pdf')
+        expected_fname = make_test_filename(
+            self.result_dir / orig_expected_path.name, 'expected')
+        try:
+            # os.symlink errors if the target already exists.
+            with contextlib.suppress(OSError):
+                os.remove(expected_fname)
+            try:
+                if 'microsoft' in uname().release.lower():
+                    raise OSError  # On WSL, symlink breaks silently
+                os.symlink(orig_expected_path, expected_fname)
+            except OSError:  # On Windows, symlink *may* be unavailable.
+                shutil.copyfile(orig_expected_path, expected_fname)
+        except OSError as err:
+            raise ImageComparisonFailure(
+                f"Missing baseline image {expected_fname} because the "
+                f"following file cannot be accessed: "
+                f"{orig_expected_path}") from err
+        return expected_fname
+
+    def compare(self, fig, baseline, extension, *, _lock=False):
+        __tracebackhide__ = True
+
+        if self.remove_text:
+            remove_ticks_and_titles(fig)
+
+        actual_path = (self.result_dir / baseline).with_suffix(f'.{extension}')
+        kwargs = self.savefig_kwargs.copy()
+        if extension == 'pdf':
+            kwargs.setdefault('metadata',
+                              {'Creator': None, 'Producer': None,
+                               'CreationDate': None})
+
+        lock = (cbook._lock_path(actual_path)
+                if _lock else contextlib.nullcontext())
+        with lock:
+            try:
+                fig.savefig(actual_path, **kwargs)
+            finally:
+                # Matplotlib has an autouse fixture to close figures, but this
+                # makes things more convenient for third-party users.
+                plt.close(fig)
+            expected_path = self.copy_baseline(baseline, extension)
+            _raise_on_image_difference(expected_path, actual_path, self.tol)
+
+
+def _pytest_image_comparison(baseline_images, extensions, tol,
+                             freetype_version, remove_text, savefig_kwargs,
+                             style):
+    """
+    Decorate function with image comparison for pytest.
+
+    This function creates a decorator that wraps a figure-generating function
+    with image comparison code.
+    """
+    import pytest
+
+    KEYWORD_ONLY = inspect.Parameter.KEYWORD_ONLY
+
+    def decorator(func):
+        old_sig = inspect.signature(func)
+
+        @functools.wraps(func)
+        @pytest.mark.parametrize('extension', extensions)
+        @matplotlib.style.context(style)
+        @_checked_on_freetype_version(freetype_version)
+        @functools.wraps(func)
+        def wrapper(*args, extension, request, **kwargs):
+            __tracebackhide__ = True
+            if 'extension' in old_sig.parameters:
+                kwargs['extension'] = extension
+            if 'request' in old_sig.parameters:
+                kwargs['request'] = request
+
+            if extension not in comparable_formats():
+                reason = {
+                    'pdf': 'because Ghostscript is not installed',
+                    'eps': 'because Ghostscript is not installed',
+                    'svg': 'because Inkscape is not installed',
+                }.get(extension, 'on this system')
+                pytest.skip(f"Cannot compare {extension} files {reason}")
+
+            img = _ImageComparisonBase(func, tol=tol, remove_text=remove_text,
+                                       savefig_kwargs=savefig_kwargs)
+            matplotlib.testing.set_font_settings_for_testing()
+
+            with _collect_new_figures() as figs:
+                func(*args, **kwargs)
+
+            # If the test is parametrized in any way other than applied via
+            # this decorator, then we need to use a lock to prevent two
+            # processes from touching the same output file.
+            needs_lock = any(
+                marker.args[0] != 'extension'
+                for marker in request.node.iter_markers('parametrize'))
+
+            if baseline_images is not None:
+                our_baseline_images = baseline_images
+            else:
+                # Allow baseline image list to be produced on the fly based on
+                # current parametrization.
+                our_baseline_images = request.getfixturevalue(
+                    'baseline_images')
+
+            assert len(figs) == len(our_baseline_images), (
+                f"Test generated {len(figs)} images but there are "
+                f"{len(our_baseline_images)} baseline images")
+            for fig, baseline in zip(figs, our_baseline_images):
+                img.compare(fig, baseline, extension, _lock=needs_lock)
+
+        parameters = list(old_sig.parameters.values())
+        if 'extension' not in old_sig.parameters:
+            parameters += [inspect.Parameter('extension', KEYWORD_ONLY)]
+        if 'request' not in old_sig.parameters:
+            parameters += [inspect.Parameter("request", KEYWORD_ONLY)]
+        new_sig = old_sig.replace(parameters=parameters)
+        wrapper.__signature__ = new_sig
+
+        # Reach a bit into pytest internals to hoist the marks from our wrapped
+        # function.
+        new_marks = getattr(func, 'pytestmark', []) + wrapper.pytestmark
+        wrapper.pytestmark = new_marks
+
+        return wrapper
+
+    return decorator
+
+
+def image_comparison(baseline_images, extensions=None, tol=0,
+                     freetype_version=None, remove_text=False,
+                     savefig_kwarg=None,
+                     # Default of mpl_test_settings fixture and cleanup too.
+                     style=("classic", "_classic_test_patch")):
+    """
+    Compare images generated by the test with those specified in
+    *baseline_images*, which must correspond, else an `.ImageComparisonFailure`
+    exception will be raised.
+
+    Parameters
+    ----------
+    baseline_images : list or None
+        A list of strings specifying the names of the images generated by
+        calls to `.Figure.savefig`.
+
+        If *None*, the test function must use the ``baseline_images`` fixture,
+        either as a parameter or with `pytest.mark.usefixtures`. This value is
+        only allowed when using pytest.
+
+    extensions : None or list of str
+        The list of extensions to test, e.g. ``['png', 'pdf']``.
+
+        If *None*, defaults to all supported extensions: png, pdf, and svg.
+
+        When testing a single extension, it can be directly included in the
+        names passed to *baseline_images*.  In that case, *extensions* must not
+        be set.
+
+        In order to keep the size of the test suite from ballooning, we only
+        include the ``svg`` or ``pdf`` outputs if the test is explicitly
+        exercising a feature dependent on that backend (see also the
+        `check_figures_equal` decorator for that purpose).
+
+    tol : float, default: 0
+        The RMS threshold above which the test is considered failed.
+
+        Due to expected small differences in floating-point calculations, on
+        32-bit systems an additional 0.06 is added to this threshold.
+
+    freetype_version : str or tuple
+        The expected freetype version or range of versions for this test to
+        pass.
+
+    remove_text : bool
+        Remove the title and tick text from the figure before comparison.  This
+        is useful to make the baseline images independent of variations in text
+        rendering between different versions of FreeType.
+
+        This does not remove other, more deliberate, text, such as legends and
+        annotations.
+
+    savefig_kwarg : dict
+        Optional arguments that are passed to the savefig method.
+
+    style : str, dict, or list
+        The optional style(s) to apply to the image test. The test itself
+        can also apply additional styles if desired. Defaults to ``["classic",
+        "_classic_test_patch"]``.
+    """
+
+    if baseline_images is not None:
+        # List of non-empty filename extensions.
+        baseline_exts = [*filter(None, {Path(baseline).suffix[1:]
+                                        for baseline in baseline_images})]
+        if baseline_exts:
+            if extensions is not None:
+                raise ValueError(
+                    "When including extensions directly in 'baseline_images', "
+                    "'extensions' cannot be set as well")
+            if len(baseline_exts) > 1:
+                raise ValueError(
+                    "When including extensions directly in 'baseline_images', "
+                    "all baselines must share the same suffix")
+            extensions = baseline_exts
+            baseline_images = [  # Chop suffix out from baseline_images.
+                Path(baseline).stem for baseline in baseline_images]
+    if extensions is None:
+        # Default extensions to test, if not set via baseline_images.
+        extensions = ['png', 'pdf', 'svg']
+    if savefig_kwarg is None:
+        savefig_kwarg = dict()  # default no kwargs to savefig
+    if sys.maxsize <= 2**32:
+        tol += 0.06
+    return _pytest_image_comparison(
+        baseline_images=baseline_images, extensions=extensions, tol=tol,
+        freetype_version=freetype_version, remove_text=remove_text,
+        savefig_kwargs=savefig_kwarg, style=style)
+
+
+def check_figures_equal(*, extensions=("png", "pdf", "svg"), tol=0):
+    """
+    Decorator for test cases that generate and compare two figures.
+
+    The decorated function must take two keyword arguments, *fig_test*
+    and *fig_ref*, and draw the test and reference images on them.
+    After the function returns, the figures are saved and compared.
+
+    This decorator should be preferred over `image_comparison` when possible in
+    order to keep the size of the test suite from ballooning.
+
+    Parameters
+    ----------
+    extensions : list, default: ["png", "pdf", "svg"]
+        The extensions to test.
+    tol : float
+        The RMS threshold above which the test is considered failed.
+
+    Raises
+    ------
+    RuntimeError
+        If any new figures are created (and not subsequently closed) inside
+        the test function.
+
+    Examples
+    --------
+    Check that calling `.Axes.plot` with a single argument plots it against
+    ``[0, 1, 2, ...]``::
+
+        @check_figures_equal()
+        def test_plot(fig_test, fig_ref):
+            fig_test.subplots().plot([1, 3, 5])
+            fig_ref.subplots().plot([0, 1, 2], [1, 3, 5])
+
+    """
+    ALLOWED_CHARS = set(string.digits + string.ascii_letters + '_-[]()')
+    KEYWORD_ONLY = inspect.Parameter.KEYWORD_ONLY
+
+    def decorator(func):
+        import pytest
+
+        _, result_dir = _image_directories(func)
+        old_sig = inspect.signature(func)
+
+        if not {"fig_test", "fig_ref"}.issubset(old_sig.parameters):
+            raise ValueError("The decorated function must have at least the "
+                             "parameters 'fig_test' and 'fig_ref', but your "
+                             f"function has the signature {old_sig}")
+
+        @pytest.mark.parametrize("ext", extensions)
+        def wrapper(*args, ext, request, **kwargs):
+            if 'ext' in old_sig.parameters:
+                kwargs['ext'] = ext
+            if 'request' in old_sig.parameters:
+                kwargs['request'] = request
+
+            file_name = "".join(c for c in request.node.name
+                                if c in ALLOWED_CHARS)
+            try:
+                fig_test = plt.figure("test")
+                fig_ref = plt.figure("reference")
+                with _collect_new_figures() as figs:
+                    func(*args, fig_test=fig_test, fig_ref=fig_ref, **kwargs)
+                if figs:
+                    raise RuntimeError('Number of open figures changed during '
+                                       'test. Make sure you are plotting to '
+                                       'fig_test or fig_ref, or if this is '
+                                       'deliberate explicitly close the '
+                                       'new figure(s) inside the test.')
+                test_image_path = result_dir / (file_name + "." + ext)
+                ref_image_path = result_dir / (file_name + "-expected." + ext)
+                fig_test.savefig(test_image_path)
+                fig_ref.savefig(ref_image_path)
+                _raise_on_image_difference(
+                    ref_image_path, test_image_path, tol=tol
+                )
+            finally:
+                plt.close(fig_test)
+                plt.close(fig_ref)
+
+        parameters = [
+            param
+            for param in old_sig.parameters.values()
+            if param.name not in {"fig_test", "fig_ref"}
+        ]
+        if 'ext' not in old_sig.parameters:
+            parameters += [inspect.Parameter("ext", KEYWORD_ONLY)]
+        if 'request' not in old_sig.parameters:
+            parameters += [inspect.Parameter("request", KEYWORD_ONLY)]
+        new_sig = old_sig.replace(parameters=parameters)
+        wrapper.__signature__ = new_sig
+
+        # reach a bit into pytest internals to hoist the marks from
+        # our wrapped function
+        new_marks = getattr(func, "pytestmark", []) + wrapper.pytestmark
+        wrapper.pytestmark = new_marks
+
+        return wrapper
+
+    return decorator
+
+
+def _image_directories(func):
+    """
+    Compute the baseline and result image directories for testing *func*.
+
+    For test module ``foo.bar.test_baz``, the baseline directory is at
+    ``foo/bar/baseline_images/test_baz`` and the result directory at
+    ``$(pwd)/result_images/test_baz``.  The result directory is created if it
+    doesn't exist.
+    """
+    module_path = Path(inspect.getfile(func))
+    baseline_dir = module_path.parent / "baseline_images" / module_path.stem
+    result_dir = Path().resolve() / "result_images" / module_path.stem
+    result_dir.mkdir(parents=True, exist_ok=True)
+    return baseline_dir, result_dir
diff --git a/lib/python3.10/site-packages/matplotlib/testing/decorators.pyi b/lib/python3.10/site-packages/matplotlib/testing/decorators.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..f1b6c5e595cbca4899cf169a6a85b917ad98bfb4
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/testing/decorators.pyi
@@ -0,0 +1,25 @@
+from collections.abc import Callable, Sequence
+from pathlib import Path
+from typing import Any, TypeVar
+from typing_extensions import ParamSpec
+
+from matplotlib.figure import Figure
+from matplotlib.typing import RcStyleType
+
+_P = ParamSpec("_P")
+_R = TypeVar("_R")
+
+def remove_ticks_and_titles(figure: Figure) -> None: ...
+def image_comparison(
+    baseline_images: list[str] | None,
+    extensions: list[str] | None = ...,
+    tol: float = ...,
+    freetype_version: tuple[str, str] | str | None = ...,
+    remove_text: bool = ...,
+    savefig_kwarg: dict[str, Any] | None = ...,
+    style: RcStyleType = ...,
+) -> Callable[[Callable[_P, _R]], Callable[_P, _R]]: ...
+def check_figures_equal(
+    *, extensions: Sequence[str] = ..., tol: float = ...
+) -> Callable[[Callable[_P, _R]], Callable[_P, _R]]: ...
+def _image_directories(func: Callable) -> tuple[Path, Path]: ...
diff --git a/lib/python3.10/site-packages/matplotlib/testing/exceptions.py b/lib/python3.10/site-packages/matplotlib/testing/exceptions.py
new file mode 100644
index 0000000000000000000000000000000000000000..c39a39207747c75d768ea2dd498dfed364eb88c5
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/testing/exceptions.py
@@ -0,0 +1,4 @@
+class ImageComparisonFailure(AssertionError):
+    """
+    Raise this exception to mark a test as a comparison between two images.
+    """
diff --git a/lib/python3.10/site-packages/matplotlib/testing/jpl_units/Duration.py b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/Duration.py
new file mode 100644
index 0000000000000000000000000000000000000000..052c5a47c0fd8313795acfcfc2e1aaf851d05c60
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/Duration.py
@@ -0,0 +1,138 @@
+"""Duration module."""
+
+import functools
+import operator
+
+from matplotlib import _api
+
+
+class Duration:
+    """Class Duration in development."""
+
+    allowed = ["ET", "UTC"]
+
+    def __init__(self, frame, seconds):
+        """
+        Create a new Duration object.
+
+        = ERROR CONDITIONS
+        - If the input frame is not in the allowed list, an error is thrown.
+
+        = INPUT VARIABLES
+        - frame     The frame of the duration.  Must be 'ET' or 'UTC'
+        - seconds  The number of seconds in the Duration.
+        """
+        _api.check_in_list(self.allowed, frame=frame)
+        self._frame = frame
+        self._seconds = seconds
+
+    def frame(self):
+        """Return the frame the duration is in."""
+        return self._frame
+
+    def __abs__(self):
+        """Return the absolute value of the duration."""
+        return Duration(self._frame, abs(self._seconds))
+
+    def __neg__(self):
+        """Return the negative value of this Duration."""
+        return Duration(self._frame, -self._seconds)
+
+    def seconds(self):
+        """Return the number of seconds in the Duration."""
+        return self._seconds
+
+    def __bool__(self):
+        return self._seconds != 0
+
+    def _cmp(self, op, rhs):
+        """
+        Check that *self* and *rhs* share frames; compare them using *op*.
+        """
+        self.checkSameFrame(rhs, "compare")
+        return op(self._seconds, rhs._seconds)
+
+    __eq__ = functools.partialmethod(_cmp, operator.eq)
+    __ne__ = functools.partialmethod(_cmp, operator.ne)
+    __lt__ = functools.partialmethod(_cmp, operator.lt)
+    __le__ = functools.partialmethod(_cmp, operator.le)
+    __gt__ = functools.partialmethod(_cmp, operator.gt)
+    __ge__ = functools.partialmethod(_cmp, operator.ge)
+
+    def __add__(self, rhs):
+        """
+        Add two Durations.
+
+        = ERROR CONDITIONS
+        - If the input rhs is not in the same frame, an error is thrown.
+
+        = INPUT VARIABLES
+        - rhs     The Duration to add.
+
+        = RETURN VALUE
+        - Returns the sum of ourselves and the input Duration.
+        """
+        # Delay-load due to circular dependencies.
+        import matplotlib.testing.jpl_units as U
+
+        if isinstance(rhs, U.Epoch):
+            return rhs + self
+
+        self.checkSameFrame(rhs, "add")
+        return Duration(self._frame, self._seconds + rhs._seconds)
+
+    def __sub__(self, rhs):
+        """
+        Subtract two Durations.
+
+        = ERROR CONDITIONS
+        - If the input rhs is not in the same frame, an error is thrown.
+
+        = INPUT VARIABLES
+        - rhs     The Duration to subtract.
+
+        = RETURN VALUE
+        - Returns the difference of ourselves and the input Duration.
+        """
+        self.checkSameFrame(rhs, "sub")
+        return Duration(self._frame, self._seconds - rhs._seconds)
+
+    def __mul__(self, rhs):
+        """
+        Scale a UnitDbl by a value.
+
+        = INPUT VARIABLES
+        - rhs     The scalar to multiply by.
+
+        = RETURN VALUE
+        - Returns the scaled Duration.
+        """
+        return Duration(self._frame, self._seconds * float(rhs))
+
+    __rmul__ = __mul__
+
+    def __str__(self):
+        """Print the Duration."""
+        return f"{self._seconds:g} {self._frame}"
+
+    def __repr__(self):
+        """Print the Duration."""
+        return f"Duration('{self._frame}', {self._seconds:g})"
+
+    def checkSameFrame(self, rhs, func):
+        """
+        Check to see if frames are the same.
+
+        = ERROR CONDITIONS
+        - If the frame of the rhs Duration is not the same as our frame,
+          an error is thrown.
+
+        = INPUT VARIABLES
+        - rhs     The Duration to check for the same frame
+        - func    The name of the function doing the check.
+        """
+        if self._frame != rhs._frame:
+            raise ValueError(
+                f"Cannot {func} Durations with different frames.\n"
+                f"LHS: {self._frame}\n"
+                f"RHS: {rhs._frame}")
diff --git a/lib/python3.10/site-packages/matplotlib/testing/jpl_units/Epoch.py b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/Epoch.py
new file mode 100644
index 0000000000000000000000000000000000000000..501b7fa38c792d5bc3c7c683e62e1393a63a4ff7
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/Epoch.py
@@ -0,0 +1,211 @@
+"""Epoch module."""
+
+import functools
+import operator
+import math
+import datetime as DT
+
+from matplotlib import _api
+from matplotlib.dates import date2num
+
+
+class Epoch:
+    # Frame conversion offsets in seconds
+    # t(TO) = t(FROM) + allowed[ FROM ][ TO ]
+    allowed = {
+        "ET": {
+            "UTC": +64.1839,
+            },
+        "UTC": {
+            "ET": -64.1839,
+            },
+        }
+
+    def __init__(self, frame, sec=None, jd=None, daynum=None, dt=None):
+        """
+        Create a new Epoch object.
+
+        Build an epoch 1 of 2 ways:
+
+        Using seconds past a Julian date:
+        #   Epoch('ET', sec=1e8, jd=2451545)
+
+        or using a matplotlib day number
+        #   Epoch('ET', daynum=730119.5)
+
+        = ERROR CONDITIONS
+        - If the input units are not in the allowed list, an error is thrown.
+
+        = INPUT VARIABLES
+        - frame     The frame of the epoch.  Must be 'ET' or 'UTC'
+        - sec        The number of seconds past the input JD.
+        - jd         The Julian date of the epoch.
+        - daynum    The matplotlib day number of the epoch.
+        - dt         A python datetime instance.
+        """
+        if ((sec is None and jd is not None) or
+                (sec is not None and jd is None) or
+                (daynum is not None and
+                 (sec is not None or jd is not None)) or
+                (daynum is None and dt is None and
+                 (sec is None or jd is None)) or
+                (daynum is not None and dt is not None) or
+                (dt is not None and (sec is not None or jd is not None)) or
+                ((dt is not None) and not isinstance(dt, DT.datetime))):
+            raise ValueError(
+                "Invalid inputs.  Must enter sec and jd together, "
+                "daynum by itself, or dt (must be a python datetime).\n"
+                "Sec = %s\n"
+                "JD  = %s\n"
+                "dnum= %s\n"
+                "dt  = %s" % (sec, jd, daynum, dt))
+
+        _api.check_in_list(self.allowed, frame=frame)
+        self._frame = frame
+
+        if dt is not None:
+            daynum = date2num(dt)
+
+        if daynum is not None:
+            # 1-JAN-0001 in JD = 1721425.5
+            jd = float(daynum) + 1721425.5
+            self._jd = math.floor(jd)
+            self._seconds = (jd - self._jd) * 86400.0
+
+        else:
+            self._seconds = float(sec)
+            self._jd = float(jd)
+
+            # Resolve seconds down to [ 0, 86400)
+            deltaDays = math.floor(self._seconds / 86400)
+            self._jd += deltaDays
+            self._seconds -= deltaDays * 86400.0
+
+    def convert(self, frame):
+        if self._frame == frame:
+            return self
+
+        offset = self.allowed[self._frame][frame]
+
+        return Epoch(frame, self._seconds + offset, self._jd)
+
+    def frame(self):
+        return self._frame
+
+    def julianDate(self, frame):
+        t = self
+        if frame != self._frame:
+            t = self.convert(frame)
+
+        return t._jd + t._seconds / 86400.0
+
+    def secondsPast(self, frame, jd):
+        t = self
+        if frame != self._frame:
+            t = self.convert(frame)
+
+        delta = t._jd - jd
+        return t._seconds + delta * 86400
+
+    def _cmp(self, op, rhs):
+        """Compare Epochs *self* and *rhs* using operator *op*."""
+        t = self
+        if self._frame != rhs._frame:
+            t = self.convert(rhs._frame)
+        if t._jd != rhs._jd:
+            return op(t._jd, rhs._jd)
+        return op(t._seconds, rhs._seconds)
+
+    __eq__ = functools.partialmethod(_cmp, operator.eq)
+    __ne__ = functools.partialmethod(_cmp, operator.ne)
+    __lt__ = functools.partialmethod(_cmp, operator.lt)
+    __le__ = functools.partialmethod(_cmp, operator.le)
+    __gt__ = functools.partialmethod(_cmp, operator.gt)
+    __ge__ = functools.partialmethod(_cmp, operator.ge)
+
+    def __add__(self, rhs):
+        """
+        Add a duration to an Epoch.
+
+        = INPUT VARIABLES
+        - rhs     The Epoch to subtract.
+
+        = RETURN VALUE
+        - Returns the difference of ourselves and the input Epoch.
+        """
+        t = self
+        if self._frame != rhs.frame():
+            t = self.convert(rhs._frame)
+
+        sec = t._seconds + rhs.seconds()
+
+        return Epoch(t._frame, sec, t._jd)
+
+    def __sub__(self, rhs):
+        """
+        Subtract two Epoch's or a Duration from an Epoch.
+
+        Valid:
+        Duration = Epoch - Epoch
+        Epoch = Epoch - Duration
+
+        = INPUT VARIABLES
+        - rhs     The Epoch to subtract.
+
+        = RETURN VALUE
+        - Returns either the duration between to Epoch's or the a new
+          Epoch that is the result of subtracting a duration from an epoch.
+        """
+        # Delay-load due to circular dependencies.
+        import matplotlib.testing.jpl_units as U
+
+        # Handle Epoch - Duration
+        if isinstance(rhs, U.Duration):
+            return self + -rhs
+
+        t = self
+        if self._frame != rhs._frame:
+            t = self.convert(rhs._frame)
+
+        days = t._jd - rhs._jd
+        sec = t._seconds - rhs._seconds
+
+        return U.Duration(rhs._frame, days*86400 + sec)
+
+    def __str__(self):
+        """Print the Epoch."""
+        return f"{self.julianDate(self._frame):22.15e} {self._frame}"
+
+    def __repr__(self):
+        """Print the Epoch."""
+        return str(self)
+
+    @staticmethod
+    def range(start, stop, step):
+        """
+        Generate a range of Epoch objects.
+
+        Similar to the Python range() method.  Returns the range [
+        start, stop) at the requested step.  Each element will be a
+        Epoch object.
+
+        = INPUT VARIABLES
+        - start     The starting value of the range.
+        - stop      The stop value of the range.
+        - step      Step to use.
+
+        = RETURN VALUE
+        - Returns a list containing the requested Epoch values.
+        """
+        elems = []
+
+        i = 0
+        while True:
+            d = start + i * step
+            if d >= stop:
+                break
+
+            elems.append(d)
+            i += 1
+
+        return elems
diff --git a/lib/python3.10/site-packages/matplotlib/testing/jpl_units/EpochConverter.py b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/EpochConverter.py
new file mode 100644
index 0000000000000000000000000000000000000000..1edc2acf2b24fe4aab242455dd32679456f69b57
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/EpochConverter.py
@@ -0,0 +1,94 @@
+"""EpochConverter module containing class EpochConverter."""
+
+from matplotlib import cbook, units
+import matplotlib.dates as date_ticker
+
+__all__ = ['EpochConverter']
+
+
+class EpochConverter(units.ConversionInterface):
+    """
+    Provides Matplotlib conversion functionality for Monte Epoch and Duration
+    classes.
+    """
+
+    jdRef = 1721425.5
+
+    @staticmethod
+    def axisinfo(unit, axis):
+        # docstring inherited
+        majloc = date_ticker.AutoDateLocator()
+        majfmt = date_ticker.AutoDateFormatter(majloc)
+        return units.AxisInfo(majloc=majloc, majfmt=majfmt, label=unit)
+
+    @staticmethod
+    def float2epoch(value, unit):
+        """
+        Convert a Matplotlib floating-point date into an Epoch of the specified
+        units.
+
+        = INPUT VARIABLES
+        - value     The Matplotlib floating-point date.
+        - unit      The unit system to use for the Epoch.
+
+        = RETURN VALUE
+        - Returns the value converted to an Epoch in the specified time system.
+        """
+        # Delay-load due to circular dependencies.
+        import matplotlib.testing.jpl_units as U
+
+        secPastRef = value * 86400.0 * U.UnitDbl(1.0, 'sec')
+        return U.Epoch(unit, secPastRef, EpochConverter.jdRef)
+
+    @staticmethod
+    def epoch2float(value, unit):
+        """
+        Convert an Epoch value to a float suitable for plotting as a python
+        datetime object.
+
+        = INPUT VARIABLES
+        - value    An Epoch or list of Epochs that need to be converted.
+        - unit     The units to use for an axis with Epoch data.
+
+        = RETURN VALUE
+        - Returns the value parameter converted to floats.
+        """
+        return value.julianDate(unit) - EpochConverter.jdRef
+
+    @staticmethod
+    def duration2float(value):
+        """
+        Convert a Duration value to a float suitable for plotting as a python
+        datetime object.
+
+        = INPUT VARIABLES
+        - value    A Duration or list of Durations that need to be converted.
+
+        = RETURN VALUE
+        - Returns the value parameter converted to floats.
+        """
+        return value.seconds() / 86400.0
+
+    @staticmethod
+    def convert(value, unit, axis):
+        # docstring inherited
+
+        # Delay-load due to circular dependencies.
+        import matplotlib.testing.jpl_units as U
+
+        if not cbook.is_scalar_or_string(value):
+            return [EpochConverter.convert(x, unit, axis) for x in value]
+        if unit is None:
+            unit = EpochConverter.default_units(value, axis)
+        if isinstance(value, U.Duration):
+            return EpochConverter.duration2float(value)
+        else:
+            return EpochConverter.epoch2float(value, unit)
+
+    @staticmethod
+    def default_units(value, axis):
+        # docstring inherited
+        if cbook.is_scalar_or_string(value):
+            return value.frame()
+        else:
+            return EpochConverter.default_units(value[0], axis)
diff --git a/lib/python3.10/site-packages/matplotlib/testing/jpl_units/StrConverter.py b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/StrConverter.py
new file mode 100644
index 0000000000000000000000000000000000000000..a62d4981dc79201214dc926eaa6a4c74ffcba078
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/StrConverter.py
@@ -0,0 +1,97 @@
+"""StrConverter module containing class StrConverter."""
+
+import numpy as np
+
+import matplotlib.units as units
+
+__all__ = ['StrConverter']
+
+
+class StrConverter(units.ConversionInterface):
+    """
+    A Matplotlib converter class for string data values.
+
+    Valid units for string are:
+    - 'indexed' : Values are indexed as they are specified for plotting.
+    - 'sorted'  : Values are sorted alphanumerically.
+    - 'inverted' : Values are inverted so that the first value is on top.
+    - 'sorted-inverted' :  A combination of 'sorted' and 'inverted'
+    """
+
+    @staticmethod
+    def axisinfo(unit, axis):
+        # docstring inherited
+        return None
+
+    @staticmethod
+    def convert(value, unit, axis):
+        # docstring inherited
+
+        if value == []:
+            return []
+
+        # we delay loading to make matplotlib happy
+        ax = axis.axes
+        if axis is ax.xaxis:
+            isXAxis = True
+        else:
+            isXAxis = False
+
+        axis.get_major_ticks()
+        ticks = axis.get_ticklocs()
+        labels = axis.get_ticklabels()
+
+        labels = [l.get_text() for l in labels if l.get_text()]
+
+        if not labels:
+            ticks = []
+            labels = []
+
+        if not np.iterable(value):
+            value = [value]
+
+        newValues = []
+        for v in value:
+            if v not in labels and v not in newValues:
+                newValues.append(v)
+
+        labels.extend(newValues)
+
+        # DISABLED: This is disabled because matplotlib bar plots do not
+        # DISABLED: recalculate the unit conversion of the data values
+        # DISABLED: this is due to design and is not really a bug.
+        # DISABLED: If this gets changed, then we can activate the following
+        # DISABLED: block of code.  Note that this works for line plots.
+        # DISABLED if unit:
+        # DISABLED     if unit.find("sorted") > -1:
+        # DISABLED         labels.sort()
+        # DISABLED     if unit.find("inverted") > -1:
+        # DISABLED         labels = labels[::-1]
+
+        # add padding (so they do not appear on the axes themselves)
+        labels = [''] + labels + ['']
+        ticks = list(range(len(labels)))
+        ticks[0] = 0.5
+        ticks[-1] = ticks[-1] - 0.5
+
+        axis.set_ticks(ticks)
+        axis.set_ticklabels(labels)
+        # we have to do the following lines to make ax.autoscale_view work
+        loc = axis.get_major_locator()
+        loc.set_bounds(ticks[0], ticks[-1])
+
+        if isXAxis:
+            ax.set_xlim(ticks[0], ticks[-1])
+        else:
+            ax.set_ylim(ticks[0], ticks[-1])
+
+        result = [ticks[labels.index(v)] for v in value]
+
+        ax.viewLim.ignore(-1)
+        return result
+
+    @staticmethod
+    def default_units(value, axis):
+        # docstring inherited
+        # The default behavior for string indexing.
+        return "indexed"
diff --git a/lib/python3.10/site-packages/matplotlib/testing/jpl_units/UnitDbl.py b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/UnitDbl.py
new file mode 100644
index 0000000000000000000000000000000000000000..5226c06ad54b9f7718a59e7ed19198d442c04f31
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/UnitDbl.py
@@ -0,0 +1,180 @@
+"""UnitDbl module."""
+
+import functools
+import operator
+
+from matplotlib import _api
+
+
+class UnitDbl:
+    """Class UnitDbl in development."""
+
+    # Unit conversion table.  Small subset of the full one but enough
+    # to test the required functions.  First field is a scale factor to
+    # convert the input units to the units of the second field.  Only
+    # units in this table are allowed.
+    allowed = {
+        "m": (0.001, "km"),
+        "km": (1, "km"),
+        "mile": (1.609344, "km"),
+
+        "rad": (1, "rad"),
+        "deg": (1.745329251994330e-02, "rad"),
+
+        "sec": (1, "sec"),
+        "min": (60.0, "sec"),
+        "hour": (3600, "sec"),
+        }
+
+    _types = {
+        "km": "distance",
+        "rad": "angle",
+        "sec": "time",
+        }
+
+    def __init__(self, value, units):
+        """
+        Create a new UnitDbl object.
+
+        Units are internally converted to km, rad, and sec.  The only
+        valid inputs for units are [m, km, mile, rad, deg, sec, min, hour].
+
+        The field UnitDbl.value will contain the converted value.  Use
+        the convert() method to get a specific type of units back.
+
+        = ERROR CONDITIONS
+        - If the input units are not in the allowed list, an error is thrown.
+
+        = INPUT VARIABLES
+        - value     The numeric value of the UnitDbl.
+        - units     The string name of the units the value is in.
+        """
+        data = _api.check_getitem(self.allowed, units=units)
+        self._value = float(value * data[0])
+        self._units = data[1]
+
+    def convert(self, units):
+        """
+        Convert the UnitDbl to a specific set of units.
+
+        = ERROR CONDITIONS
+        - If the input units are not in the allowed list, an error is thrown.
+
+        = INPUT VARIABLES
+        - units     The string name of the units to convert to.
+
+        = RETURN VALUE
+        - Returns the value of the UnitDbl in the requested units as a floating
+          point number.
+        """
+        if self._units == units:
+            return self._value
+        data = _api.check_getitem(self.allowed, units=units)
+        if self._units != data[1]:
+            raise ValueError(f"Error trying to convert to different units.\n"
+                             f"    Invalid conversion requested.\n"
+                             f"    UnitDbl: {self}\n"
+                             f"    Units:   {units}\n")
+        return self._value / data[0]
+
+    def __abs__(self):
+        """Return the absolute value of this UnitDbl."""
+        return UnitDbl(abs(self._value), self._units)
+
+    def __neg__(self):
+        """Return the negative value of this UnitDbl."""
+        return UnitDbl(-self._value, self._units)
+
+    def __bool__(self):
+        """Return the truth value of a UnitDbl."""
+        return bool(self._value)
+
+    def _cmp(self, op, rhs):
+        """Check that *self* and *rhs* share units; compare them using *op*."""
+        self.checkSameUnits(rhs, "compare")
+        return op(self._value, rhs._value)
+
+    __eq__ = functools.partialmethod(_cmp, operator.eq)
+    __ne__ = functools.partialmethod(_cmp, operator.ne)
+    __lt__ = functools.partialmethod(_cmp, operator.lt)
+    __le__ = functools.partialmethod(_cmp, operator.le)
+    __gt__ = functools.partialmethod(_cmp, operator.gt)
+    __ge__ = functools.partialmethod(_cmp, operator.ge)
+
+    def _binop_unit_unit(self, op, rhs):
+        """Check that *self* and *rhs* share units; combine them using *op*."""
+        self.checkSameUnits(rhs, op.__name__)
+        return UnitDbl(op(self._value, rhs._value), self._units)
+
+    __add__ = functools.partialmethod(_binop_unit_unit, operator.add)
+    __sub__ = functools.partialmethod(_binop_unit_unit, operator.sub)
+
+    def _binop_unit_scalar(self, op, scalar):
+        """Combine *self* and *scalar* using *op*."""
+        return UnitDbl(op(self._value, scalar), self._units)
+
+    __mul__ = functools.partialmethod(_binop_unit_scalar, operator.mul)
+    __rmul__ = functools.partialmethod(_binop_unit_scalar, operator.mul)
+
+    def __str__(self):
+        """Print the UnitDbl."""
+        return f"{self._value:g} *{self._units}"
+
+    def __repr__(self):
+        """Print the UnitDbl."""
+        return f"UnitDbl({self._value:g}, '{self._units}')"
+
+    def type(self):
+        """Return the type of UnitDbl data."""
+        return self._types[self._units]
+
+    @staticmethod
+    def range(start, stop, step=None):
+        """
+        Generate a range of UnitDbl objects.
+
+        Similar to the Python range() method.  Returns the range [
+        start, stop) at the requested step.  Each element will be a
+        UnitDbl object.
+
+        = INPUT VARIABLES
+        - start     The starting value of the range.
+        - stop      The stop value of the range.
+        - step      Optional step to use.  If set to None, then a UnitDbl of
+                      value 1 w/ the units of the start is used.
+
+        = RETURN VALUE
+        - Returns a list containing the requested UnitDbl values.
+        """
+        if step is None:
+            step = UnitDbl(1, start._units)
+
+        elems = []
+
+        i = 0
+        while True:
+            d = start + i * step
+            if d >= stop:
+                break
+
+            elems.append(d)
+            i += 1
+
+        return elems
+
+    def checkSameUnits(self, rhs, func):
+        """
+        Check to see if units are the same.
+
+        = ERROR CONDITIONS
+        - If the units of the rhs UnitDbl are not the same as our units,
+          an error is thrown.
+
+        = INPUT VARIABLES
+        - rhs     The UnitDbl to check for the same units
+        - func    The name of the function doing the check.
+        """
+        if self._units != rhs._units:
+            raise ValueError(f"Cannot {func} units of different types.\n"
+                             f"LHS: {self._units}\n"
+                             f"RHS: {rhs._units}")
diff --git a/lib/python3.10/site-packages/matplotlib/testing/jpl_units/UnitDblConverter.py b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/UnitDblConverter.py
new file mode 100644
index 0000000000000000000000000000000000000000..23065379f58193ae2f240d7bff44aaf70f8a8dca
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/UnitDblConverter.py
@@ -0,0 +1,85 @@
+"""UnitDblConverter module containing class UnitDblConverter."""
+
+import numpy as np
+
+from matplotlib import cbook, units
+import matplotlib.projections.polar as polar
+
+__all__ = ['UnitDblConverter']
+
+
+# A special function for use with the matplotlib FuncFormatter class
+# for formatting axes with radian units.
+# This was copied from matplotlib example code.
+def rad_fn(x, pos=None):
+    """Radian function formatter."""
+    n = int((x / np.pi) * 2.0 + 0.25)
+    if n == 0:
+        return str(x)
+    elif n == 1:
+        return r'$\pi/2$'
+    elif n == 2:
+        return r'$\pi$'
+    elif n % 2 == 0:
+        return fr'${n//2}\pi$'
+    else:
+        return fr'${n}\pi/2$'
+
+
+class UnitDblConverter(units.ConversionInterface):
+    """
+    Provides Matplotlib conversion functionality for the Monte UnitDbl class.
+    """
+    # default for plotting
+    defaults = {
+       "distance": 'km',
+       "angle": 'deg',
+       "time": 'sec',
+       }
+
+    @staticmethod
+    def axisinfo(unit, axis):
+        # docstring inherited
+
+        # Delay-load due to circular dependencies.
+        import matplotlib.testing.jpl_units as U
+
+        # Check to see if the value used for units is a string unit value
+        # or an actual instance of a UnitDbl so that we can use the unit
+        # value for the default axis label value.
+        if unit:
+            label = unit if isinstance(unit, str) else unit.label()
+        else:
+            label = None
+
+        if label == "deg" and isinstance(axis.axes, polar.PolarAxes):
+            # If we want degrees for a polar plot, use the PolarPlotFormatter
+            majfmt = polar.PolarAxes.ThetaFormatter()
+        else:
+            majfmt = U.UnitDblFormatter(useOffset=False)
+
+        return units.AxisInfo(majfmt=majfmt, label=label)
+
+    @staticmethod
+    def convert(value, unit, axis):
+        # docstring inherited
+        if not cbook.is_scalar_or_string(value):
+            return [UnitDblConverter.convert(x, unit, axis) for x in value]
+        # If no units were specified, then get the default units to use.
+        if unit is None:
+            unit = UnitDblConverter.default_units(value, axis)
+        # Convert the incoming UnitDbl value/values to float/floats
+        if isinstance(axis.axes, polar.PolarAxes) and value.type() == "angle":
+            # Guarantee that units are radians for polar plots.
+            return value.convert("rad")
+        return value.convert(unit)
+
+    @staticmethod
+    def default_units(value, axis):
+        # docstring inherited
+        # Determine the default units based on the user preferences set for
+        # default units when printing a UnitDbl.
+        if cbook.is_scalar_or_string(value):
+            return UnitDblConverter.defaults[value.type()]
+        else:
+            return UnitDblConverter.default_units(value[0], axis)
diff --git a/lib/python3.10/site-packages/matplotlib/testing/jpl_units/UnitDblFormatter.py b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/UnitDblFormatter.py
new file mode 100644
index 0000000000000000000000000000000000000000..30a9914015bc7eb955c88e562a771591b82ad2e8
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/UnitDblFormatter.py
@@ -0,0 +1,28 @@
+"""UnitDblFormatter module containing class UnitDblFormatter."""
+
+import matplotlib.ticker as ticker
+
+__all__ = ['UnitDblFormatter']
+
+
+class UnitDblFormatter(ticker.ScalarFormatter):
+    """
+    The formatter for UnitDbl data types.
+
+    This allows for formatting with the unit string.
+    """
+
+    def __call__(self, x, pos=None):
+        # docstring inherited
+        if len(self.locs) == 0:
+            return ''
+        else:
+            return f'{x:.12}'
+
+    def format_data_short(self, value):
+        # docstring inherited
+        return f'{value:.12}'
+
+    def format_data(self, value):
+        # docstring inherited
+        return f'{value:.12}'
diff --git a/lib/python3.10/site-packages/matplotlib/testing/jpl_units/__init__.py b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b8caa9a8957a250b78712c25175bec415507e416
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/__init__.py
@@ -0,0 +1,76 @@
+"""
+A sample set of units for use with testing unit conversion
+of Matplotlib routines.  These are used because they use very strict
+enforcement of unitized data which will test the entire spectrum of how
+unitized data might be used (it is not always meaningful to convert to
+a float without specific units given).
+
+UnitDbl is essentially a unitized floating point number.  It has a
+minimal set of supported units (enough for testing purposes).  All
+of the mathematical operation are provided to fully test any behaviour
+that might occur with unitized data.  Remember that unitized data has
+rules as to how it can be applied to one another (a value of distance
+cannot be added to a value of time).  Thus we need to guard against any
+accidental "default" conversion that will strip away the meaning of the
+data and render it neutered.
+
+Epoch is different than a UnitDbl of time.  Time is something that can be
+measured where an Epoch is a specific moment in time.  Epochs are typically
+referenced as an offset from some predetermined epoch.
+
+A difference of two epochs is a Duration.  The distinction between a Duration
+and a UnitDbl of time is made because an Epoch can have different frames (or
+units).  In the case of our test Epoch class the two allowed frames are 'UTC'
+and 'ET' (Note that these are rough estimates provided for testing purposes
+and should not be used in production code where accuracy of time frames is
+desired).  As such a Duration also has a frame of reference and therefore needs
+to be called out as different that a simple measurement of time since a delta-t
+in one frame may not be the same in another.
+"""
+
+from .Duration import Duration
+from .Epoch import Epoch
+from .UnitDbl import UnitDbl
+
+from .StrConverter import StrConverter
+from .EpochConverter import EpochConverter
+from .UnitDblConverter import UnitDblConverter
+
+from .UnitDblFormatter import UnitDblFormatter
+
+
+__version__ = "1.0"
+
+__all__ = [
+            'register',
+            'Duration',
+            'Epoch',
+            'UnitDbl',
+            'UnitDblFormatter',
+          ]
+
+
+def register():
+    """Register the unit conversion classes with matplotlib."""
+    import matplotlib.units as mplU
+
+    mplU.registry[str] = StrConverter()
+    mplU.registry[Epoch] = EpochConverter()
+    mplU.registry[Duration] = EpochConverter()
+    mplU.registry[UnitDbl] = UnitDblConverter()
+
+
+# Some default unit instances
+# Distances
+m = UnitDbl(1.0, "m")
+km = UnitDbl(1.0, "km")
+mile = UnitDbl(1.0, "mile")
+# Angles
+deg = UnitDbl(1.0, "deg")
+rad = UnitDbl(1.0, "rad")
+# Time
+sec = UnitDbl(1.0, "sec")
+min = UnitDbl(1.0, "min")
+hr = UnitDbl(1.0, "hour")
+day = UnitDbl(24.0, "hour")
+sec = UnitDbl(1.0, "sec")
diff --git a/lib/python3.10/site-packages/matplotlib/testing/jpl_units/__pycache__/Duration.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/__pycache__/Duration.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a05b8e1907f9ca58713244c7b5c7be760dc68cd8
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/__pycache__/Duration.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/testing/jpl_units/__pycache__/Epoch.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/__pycache__/Epoch.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f2da3b265f534ad3313f9ccfb12653c8ccfe5988
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/__pycache__/Epoch.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/testing/jpl_units/__pycache__/EpochConverter.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/__pycache__/EpochConverter.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..64138e569466b5f027ffee847d844915fe09da12
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/__pycache__/EpochConverter.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/testing/jpl_units/__pycache__/StrConverter.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/__pycache__/StrConverter.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ce4a9c0c10f75987492a92091cb1680071d2e09f
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/__pycache__/StrConverter.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/testing/jpl_units/__pycache__/UnitDbl.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/__pycache__/UnitDbl.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b24cb5a0ef064f61fa38103b6f4c5ed2096b7524
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/__pycache__/UnitDbl.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/testing/jpl_units/__pycache__/UnitDblConverter.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/__pycache__/UnitDblConverter.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e25747dad863d8b85b1ba9ce70586118017b340b
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/__pycache__/UnitDblConverter.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/testing/jpl_units/__pycache__/UnitDblFormatter.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/__pycache__/UnitDblFormatter.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..25fc7a09bc4a40b66b8a9fe2cbd8e52d14e28a8a
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/__pycache__/UnitDblFormatter.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/testing/jpl_units/__pycache__/__init__.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c196ab483e0da3d53a71e58a181d789472b3efe3
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/testing/jpl_units/__pycache__/__init__.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/testing/widgets.py b/lib/python3.10/site-packages/matplotlib/testing/widgets.py
new file mode 100644
index 0000000000000000000000000000000000000000..3962567aa7c03eb978db53e3d6007446bb177d28
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/testing/widgets.py
@@ -0,0 +1,119 @@
+"""
+========================
+Widget testing utilities
+========================
+
+See also :mod:`matplotlib.tests.test_widgets`.
+"""
+
+from unittest import mock
+
+import matplotlib.pyplot as plt
+
+
+def get_ax():
+    """Create a plot and return its Axes."""
+    fig, ax = plt.subplots(1, 1)
+    ax.plot([0, 200], [0, 200])
+    ax.set_aspect(1.0)
+    fig.canvas.draw()
+    return ax
+
+
+def noop(*args, **kwargs):
+    pass
+
+
+def mock_event(ax, button=1, xdata=0, ydata=0, key=None, step=1):
+    r"""
+    Create a mock event that can stand in for `.Event` and its subclasses.
+
+    This event is intended to be used in tests where it can be passed into
+    event handling functions.
+
+    Parameters
+    ----------
+    ax : `~matplotlib.axes.Axes`
+        The Axes the event will be in.
+    xdata : float
+        x coord of mouse in data coords.
+    ydata : float
+        y coord of mouse in data coords.
+    button : None or `MouseButton` or {'up', 'down'}
+        The mouse button pressed in this event (see also `.MouseEvent`).
+    key : None or str
+        The key pressed when the mouse event triggered (see also `.KeyEvent`).
+    step : int
+        Number of scroll steps (positive for 'up', negative for 'down').
+
+    Returns
+    -------
+    event
+        A `.Event`\-like Mock instance.
+    """
+    event = mock.Mock()
+    event.button = button
+    event.x, event.y = ax.transData.transform([(xdata, ydata),
+                                               (xdata, ydata)])[0]
+    event.xdata, event.ydata = xdata, ydata
+    event.inaxes = ax
+    event.canvas = ax.get_figure(root=True).canvas
+    event.key = key
+    event.step = step
+    event.guiEvent = None
+    event.name = 'Custom'
+    return event
+
+
+def do_event(tool, etype, button=1, xdata=0, ydata=0, key=None, step=1):
+    """
+    Trigger an event on the given tool.
+
+    Parameters
+    ----------
+    tool : matplotlib.widgets.AxesWidget
+    etype : str
+        The event to trigger.
+    xdata : float
+        x coord of mouse in data coords.
+    ydata : float
+        y coord of mouse in data coords.
+    button : None or `MouseButton` or {'up', 'down'}
+        The mouse button pressed in this event (see also `.MouseEvent`).
+    key : None or str
+        The key pressed when the mouse event triggered (see also `.KeyEvent`).
+    step : int
+        Number of scroll steps (positive for 'up', negative for 'down').
+    """
+    event = mock_event(tool.ax, button, xdata, ydata, key, step)
+    func = getattr(tool, etype)
+    func(event)
+
+
+def click_and_drag(tool, start, end, key=None):
+    """
+    Helper to simulate a mouse drag operation.
+
+    Parameters
+    ----------
+    tool : `~matplotlib.widgets.Widget`
+    start : [float, float]
+        Starting point in data coordinates.
+    end : [float, float]
+        End point in data coordinates.
+    key : None or str
+         An optional key that is pressed during the whole operation
+         (see also `.KeyEvent`).
+    """
+    if key is not None:
+        # Press key
+        do_event(tool, 'on_key_press', xdata=start[0], ydata=start[1],
+                 button=1, key=key)
+    # Click, move, and release mouse
+    do_event(tool, 'press', xdata=start[0], ydata=start[1], button=1)
+    do_event(tool, 'onmove', xdata=end[0], ydata=end[1], button=1)
+    do_event(tool, 'release', xdata=end[0], ydata=end[1], button=1)
+    if key is not None:
+        # Release key
+        do_event(tool, 'on_key_release', xdata=end[0], ydata=end[1],
+                 button=1, key=key)
diff --git a/lib/python3.10/site-packages/matplotlib/testing/widgets.pyi b/lib/python3.10/site-packages/matplotlib/testing/widgets.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..858ff457158283bae9db974e05098890ef5ac260
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/testing/widgets.pyi
@@ -0,0 +1,31 @@
+from typing import Any, Literal
+
+from matplotlib.axes import Axes
+from matplotlib.backend_bases import Event, MouseButton
+from matplotlib.widgets import AxesWidget, Widget
+
+def get_ax() -> Axes: ...
+def noop(*args: Any, **kwargs: Any) -> None: ...
+def mock_event(
+    ax: Axes,
+    button: MouseButton | int | Literal["up", "down"] | None = ...,
+    xdata: float = ...,
+    ydata: float = ...,
+    key: str | None = ...,
+    step: int = ...,
+) -> Event: ...
+def do_event(
+    tool: AxesWidget,
+    etype: str,
+    button: MouseButton | int | Literal["up", "down"] | None = ...,
+    xdata: float = ...,
+    ydata: float = ...,
+    key: str | None = ...,
+    step: int = ...,
+) -> None: ...
+def click_and_drag(
+    tool: Widget,
+    start: tuple[float, float],
+    end: tuple[float, float],
+    key: str | None = ...,
+) -> None: ...
diff --git a/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_offsetbox.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_offsetbox.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..36e9a0c99e308558b99670beddee9f24ea19e172
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_offsetbox.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_patches.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_patches.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..89758b1bb694729113757c6ebaa36ea201bfffad
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_patches.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_path.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_path.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7401c7a30079983e532588bf0ebe50eb9c337690
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_path.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_patheffects.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_patheffects.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7c577aca212f8cced5e110bedc42f7cf5a58ba8e
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_patheffects.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_pickle.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_pickle.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..321b25f32311c6dbade71c3127f04eacdfb732e9
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_pickle.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_png.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_png.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2ee5351fe06dc180b0816543d8fdb927b476fc84
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_png.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_polar.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_polar.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..557d7b396a393bc761134e05e26c4834e33b62d8
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_polar.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_preprocess_data.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_preprocess_data.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ad297baa6e2ea3d852228cf2746f5bb0fb99850c
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_preprocess_data.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_pyplot.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_pyplot.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b6ac9794ccc8a46f687d4442738c90b879c0769c
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_pyplot.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_quiver.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_quiver.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5836b8ea285d6491bfb68dbe6516efca87354c16
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/tests/__pycache__/test_quiver.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/tests/test_backend_svg.py b/lib/python3.10/site-packages/matplotlib/tests/test_backend_svg.py
new file mode 100644
index 0000000000000000000000000000000000000000..509136fe323e618c64c1b0ea6f1da4a37f730697
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/tests/test_backend_svg.py
@@ -0,0 +1,707 @@
+import datetime
+from io import BytesIO
+from pathlib import Path
+import xml.etree.ElementTree
+import xml.parsers.expat
+
+import pytest
+
+import numpy as np
+
+import matplotlib as mpl
+from matplotlib.figure import Figure
+from matplotlib.patches import Circle
+from matplotlib.text import Text
+import matplotlib.pyplot as plt
+from matplotlib.testing.decorators import check_figures_equal, image_comparison
+from matplotlib.testing._markers import needs_usetex
+from matplotlib import font_manager as fm
+from matplotlib.offsetbox import (OffsetImage, AnnotationBbox)
+
+
+def test_visibility():
+    fig, ax = plt.subplots()
+
+    x = np.linspace(0, 4 * np.pi, 50)
+    y = np.sin(x)
+    yerr = np.ones_like(y)
+
+    a, b, c = ax.errorbar(x, y, yerr=yerr, fmt='ko')
+    for artist in b:
+        artist.set_visible(False)
+
+    with BytesIO() as fd:
+        fig.savefig(fd, format='svg')
+        buf = fd.getvalue()
+
+    parser = xml.parsers.expat.ParserCreate()
+    parser.Parse(buf)  # this will raise ExpatError if the svg is invalid
+
+
+@image_comparison(['fill_black_with_alpha.svg'], remove_text=True)
+def test_fill_black_with_alpha():
+    fig, ax = plt.subplots()
+    ax.scatter(x=[0, 0.1, 1], y=[0, 0, 0], c='k', alpha=0.1, s=10000)
+
+
+@image_comparison(['noscale'], remove_text=True)
+def test_noscale():
+    X, Y = np.meshgrid(np.arange(-5, 5, 1), np.arange(-5, 5, 1))
+    Z = np.sin(Y ** 2)
+
+    fig, ax = plt.subplots()
+    ax.imshow(Z, cmap='gray', interpolation='none')
+
+
+def test_text_urls():
+    fig = plt.figure()
+
+    test_url = "http://test_text_urls.matplotlib.org"
+    fig.suptitle("test_text_urls", url=test_url)
+
+    with BytesIO() as fd:
+        fig.savefig(fd, format='svg')
+        buf = fd.getvalue().decode()
+
+    expected = f'<a xlink:href="{test_url}">'
+    assert expected in buf
+
+
+@image_comparison(['bold_font_output.svg'])
+def test_bold_font_output():
+    fig, ax = plt.subplots()
+    ax.plot(np.arange(10), np.arange(10))
+    ax.set_xlabel('nonbold-xlabel')
+    ax.set_ylabel('bold-ylabel', fontweight='bold')
+    ax.set_title('bold-title', fontweight='bold')
+
+
+@image_comparison(['bold_font_output_with_none_fonttype.svg'])
+def test_bold_font_output_with_none_fonttype():
+    plt.rcParams['svg.fonttype'] = 'none'
+    fig, ax = plt.subplots()
+    ax.plot(np.arange(10), np.arange(10))
+    ax.set_xlabel('nonbold-xlabel')
+    ax.set_ylabel('bold-ylabel', fontweight='bold')
+    ax.set_title('bold-title', fontweight='bold')
+
+
+@check_figures_equal(tol=20)
+def test_rasterized(fig_test, fig_ref):
+    t = np.arange(0, 100) * (2.3)
+    x = np.cos(t)
+    y = np.sin(t)
+
+    ax_ref = fig_ref.subplots()
+    ax_ref.plot(x, y, "-", c="r", lw=10)
+    ax_ref.plot(x+1, y, "-", c="b", lw=10)
+
+    ax_test = fig_test.subplots()
+    ax_test.plot(x, y, "-", c="r", lw=10, rasterized=True)
+    ax_test.plot(x+1, y, "-", c="b", lw=10, rasterized=True)
+
+
+@check_figures_equal(extensions=['svg'])
+def test_rasterized_ordering(fig_test, fig_ref):
+    t = np.arange(0, 100) * (2.3)
+    x = np.cos(t)
+    y = np.sin(t)
+
+    ax_ref = fig_ref.subplots()
+    ax_ref.set_xlim(0, 3)
+    ax_ref.set_ylim(-1.1, 1.1)
+    ax_ref.plot(x, y, "-", c="r", lw=10, rasterized=True)
+    ax_ref.plot(x+1, y, "-", c="b", lw=10, rasterized=False)
+    ax_ref.plot(x+2, y, "-", c="g", lw=10, rasterized=True)
+    ax_ref.plot(x+3, y, "-", c="m", lw=10, rasterized=True)
+
+    ax_test = fig_test.subplots()
+    ax_test.set_xlim(0, 3)
+    ax_test.set_ylim(-1.1, 1.1)
+    ax_test.plot(x, y, "-", c="r", lw=10, rasterized=True, zorder=1.1)
+    ax_test.plot(x+2, y, "-", c="g", lw=10, rasterized=True, zorder=1.3)
+    ax_test.plot(x+3, y, "-", c="m", lw=10, rasterized=True, zorder=1.4)
+    ax_test.plot(x+1, y, "-", c="b", lw=10, rasterized=False, zorder=1.2)
+
+
+@check_figures_equal(tol=5, extensions=['svg', 'pdf'])
+def test_prevent_rasterization(fig_test, fig_ref):
+    loc = [0.05, 0.05]
+
+    ax_ref = fig_ref.subplots()
+
+    ax_ref.plot([loc[0]], [loc[1]], marker="x", c="black", zorder=2)
+
+    b = mpl.offsetbox.TextArea("X")
+    abox = mpl.offsetbox.AnnotationBbox(b, loc, zorder=2.1)
+    ax_ref.add_artist(abox)
+
+    ax_test = fig_test.subplots()
+    ax_test.plot([loc[0]], [loc[1]], marker="x", c="black", zorder=2,
+                 rasterized=True)
+
+    b = mpl.offsetbox.TextArea("X")
+    abox = mpl.offsetbox.AnnotationBbox(b, loc, zorder=2.1)
+    ax_test.add_artist(abox)
+
+
+def test_count_bitmaps():
+    def count_tag(fig, tag):
+        with BytesIO() as fd:
+            fig.savefig(fd, format='svg')
+            buf = fd.getvalue().decode()
+        return buf.count(f"<{tag}")
+
+    # No rasterized elements
+    fig1 = plt.figure()
+    ax1 = fig1.add_subplot(1, 1, 1)
+    ax1.set_axis_off()
+    for n in range(5):
+        ax1.plot([0, 20], [0, n], "b-", rasterized=False)
+    assert count_tag(fig1, "image") == 0
+    assert count_tag(fig1, "path") == 6  # axis patch plus lines
+
+    # rasterized can be merged
+    fig2 = plt.figure()
+    ax2 = fig2.add_subplot(1, 1, 1)
+    ax2.set_axis_off()
+    for n in range(5):
+        ax2.plot([0, 20], [0, n], "b-", rasterized=True)
+    assert count_tag(fig2, "image") == 1
+    assert count_tag(fig2, "path") == 1  # axis patch
+
+    # rasterized can't be merged without affecting draw order
+    fig3 = plt.figure()
+    ax3 = fig3.add_subplot(1, 1, 1)
+    ax3.set_axis_off()
+    for n in range(5):
+        ax3.plot([0, 20], [n, 0], "b-", rasterized=False)
+        ax3.plot([0, 20], [0, n], "b-", rasterized=True)
+    assert count_tag(fig3, "image") == 5
+    assert count_tag(fig3, "path") == 6
+
+    # rasterized whole axes
+    fig4 = plt.figure()
+    ax4 = fig4.add_subplot(1, 1, 1)
+    ax4.set_axis_off()
+    ax4.set_rasterized(True)
+    for n in range(5):
+        ax4.plot([0, 20], [n, 0], "b-", rasterized=False)
+        ax4.plot([0, 20], [0, n], "b-", rasterized=True)
+    assert count_tag(fig4, "image") == 1
+    assert count_tag(fig4, "path") == 1
+
+    # rasterized can be merged, but inhibited by suppressComposite
+    fig5 = plt.figure()
+    fig5.suppressComposite = True
+    ax5 = fig5.add_subplot(1, 1, 1)
+    ax5.set_axis_off()
+    for n in range(5):
+        ax5.plot([0, 20], [0, n], "b-", rasterized=True)
+    assert count_tag(fig5, "image") == 5
+    assert count_tag(fig5, "path") == 1  # axis patch
+
+
+# Use Computer Modern Sans Serif, not Helvetica (which has no \textwon).
+@mpl.style.context('default')
+@needs_usetex
+def test_unicode_won():
+    fig = Figure()
+    fig.text(.5, .5, r'\textwon', usetex=True)
+
+    with BytesIO() as fd:
+        fig.savefig(fd, format='svg')
+        buf = fd.getvalue()
+
+    tree = xml.etree.ElementTree.fromstring(buf)
+    ns = 'http://www.w3.org/2000/svg'
+    won_id = 'SFSS3583-8e'
+    assert len(tree.findall(f'.//{{{ns}}}path[@d][@id="{won_id}"]')) == 1
+    assert f'#{won_id}' in tree.find(f'.//{{{ns}}}use').attrib.values()
+
+
+def test_svgnone_with_data_coordinates():
+    plt.rcParams.update({'svg.fonttype': 'none', 'font.stretch': 'condensed'})
+    expected = 'Unlikely to appear by chance'
+
+    fig, ax = plt.subplots()
+    ax.text(np.datetime64('2019-06-30'), 1, expected)
+    ax.set_xlim(np.datetime64('2019-01-01'), np.datetime64('2019-12-31'))
+    ax.set_ylim(0, 2)
+
+    with BytesIO() as fd:
+        fig.savefig(fd, format='svg')
+        fd.seek(0)
+        buf = fd.read().decode()
+
+    assert expected in buf and "condensed" in buf
+
+
+def test_gid():
+    """Test that object gid appears in output svg."""
+    from matplotlib.offsetbox import OffsetBox
+    from matplotlib.axis import Tick
+
+    fig = plt.figure()
+
+    ax1 = fig.add_subplot(131)
+    ax1.imshow([[1., 2.], [2., 3.]], aspect="auto")
+    ax1.scatter([1, 2, 3], [1, 2, 3], label="myscatter")
+    ax1.plot([2, 3, 1], label="myplot")
+    ax1.legend()
+    ax1a = ax1.twinx()
+    ax1a.bar([1, 2, 3], [1, 2, 3])
+
+    ax2 = fig.add_subplot(132, projection="polar")
+    ax2.plot([0, 1.5, 3], [1, 2, 3])
+
+    ax3 = fig.add_subplot(133, projection="3d")
+    ax3.plot([1, 2], [1, 2], [1, 2])
+
+    fig.canvas.draw()
+
+    gdic = {}
+    for idx, obj in enumerate(fig.findobj(include_self=True)):
+        if obj.get_visible():
+            gid = f"test123{obj.__class__.__name__}_{idx}"
+            gdic[gid] = obj
+            obj.set_gid(gid)
+
+    with BytesIO() as fd:
+        fig.savefig(fd, format='svg')
+        buf = fd.getvalue().decode()
+
+    def include(gid, obj):
+        # we need to exclude certain objects which will not appear in the svg
+        if isinstance(obj, OffsetBox):
+            return False
+        if isinstance(obj, Text):
+            if obj.get_text() == "":
+                return False
+            elif obj.axes is None:
+                return False
+        if isinstance(obj, plt.Line2D):
+            xdata, ydata = obj.get_data()
+            if len(xdata) == len(ydata) == 1:
+                return False
+            elif not hasattr(obj, "axes") or obj.axes is None:
+                return False
+        if isinstance(obj, Tick):
+            loc = obj.get_loc()
+            if loc == 0:
+                return False
+            vi = obj.get_view_interval()
+            if loc < min(vi) or loc > max(vi):
+                return False
+        return True
+
+    for gid, obj in gdic.items():
+        if include(gid, obj):
+            assert gid in buf
+
+
+def test_clip_path_ids_reuse():
+    fig, circle = Figure(), Circle((0, 0), radius=10)
+    for i in range(5):
+        ax = fig.add_subplot()
+        aimg = ax.imshow([[i]])
+        aimg.set_clip_path(circle)
+
+    inner_circle = Circle((0, 0), radius=1)
+    ax = fig.add_subplot()
+    aimg = ax.imshow([[0]])
+    aimg.set_clip_path(inner_circle)
+
+    with BytesIO() as fd:
+        fig.savefig(fd, format='svg')
+        buf = fd.getvalue()
+
+    tree = xml.etree.ElementTree.fromstring(buf)
+    ns = 'http://www.w3.org/2000/svg'
+
+    clip_path_ids = set()
+    for node in tree.findall(f'.//{{{ns}}}clipPath[@id]'):
+        node_id = node.attrib['id']
+        assert node_id not in clip_path_ids  # assert ID uniqueness
+        clip_path_ids.add(node_id)
+    assert len(clip_path_ids) == 2  # only two clipPaths despite reuse in multiple axes
+
+
+def test_savefig_tight():
+    # Check that the draw-disabled renderer correctly disables open/close_group
+    # as well.
+    plt.savefig(BytesIO(), format="svgz", bbox_inches="tight")
+
+
+def test_url():
+    # Test that object url appears in output svg.
+
+    fig, ax = plt.subplots()
+
+    # collections
+    s = ax.scatter([1, 2, 3], [4, 5, 6])
+    s.set_urls(['https://example.com/foo', 'https://example.com/bar', None])
+
+    # Line2D
+    p, = plt.plot([2, 3, 4], [4, 5, 6])
+    p.set_url('https://example.com/baz')
+
+    # Line2D markers-only
+    p, = plt.plot([3, 4, 5], [4, 5, 6], linestyle='none', marker='x')
+    p.set_url('https://example.com/quux')
+
+    b = BytesIO()
+    fig.savefig(b, format='svg')
+    b = b.getvalue()
+    for v in [b'foo', b'bar', b'baz', b'quux']:
+        assert b'https://example.com/' + v in b
+
+
+def test_url_tick(monkeypatch):
+    monkeypatch.setenv('SOURCE_DATE_EPOCH', '19680801')
+
+    fig1, ax = plt.subplots()
+    ax.scatter([1, 2, 3], [4, 5, 6])
+    for i, tick in enumerate(ax.yaxis.get_major_ticks()):
+        tick.set_url(f'https://example.com/{i}')
+
+    fig2, ax = plt.subplots()
+    ax.scatter([1, 2, 3], [4, 5, 6])
+    for i, tick in enumerate(ax.yaxis.get_major_ticks()):
+        tick.label1.set_url(f'https://example.com/{i}')
+        tick.label2.set_url(f'https://example.com/{i}')
+
+    b1 = BytesIO()
+    fig1.savefig(b1, format='svg')
+    b1 = b1.getvalue()
+
+    b2 = BytesIO()
+    fig2.savefig(b2, format='svg')
+    b2 = b2.getvalue()
+
+    for i in range(len(ax.yaxis.get_major_ticks())):
+        assert f'https://example.com/{i}'.encode('ascii') in b1
+    assert b1 == b2
+
+
+def test_svg_default_metadata(monkeypatch):
+    # Values have been predefined for 'Creator', 'Date', 'Format', and 'Type'.
+    monkeypatch.setenv('SOURCE_DATE_EPOCH', '19680801')
+
+    fig, ax = plt.subplots()
+    with BytesIO() as fd:
+        fig.savefig(fd, format='svg')
+        buf = fd.getvalue().decode()
+
+    # Creator
+    assert mpl.__version__ in buf
+    # Date
+    assert '1970-08-16' in buf
+    # Format
+    assert 'image/svg+xml' in buf
+    # Type
+    assert 'StillImage' in buf
+
+    # Now make sure all the default metadata can be cleared.
+    with BytesIO() as fd:
+        fig.savefig(fd, format='svg', metadata={'Date': None, 'Creator': None,
+                                                'Format': None, 'Type': None})
+        buf = fd.getvalue().decode()
+
+    # Creator
+    assert mpl.__version__ not in buf
+    # Date
+    assert '1970-08-16' not in buf
+    # Format
+    assert 'image/svg+xml' not in buf
+    # Type
+    assert 'StillImage' not in buf
+
+
+def test_svg_clear_default_metadata(monkeypatch):
+    # Makes sure that setting a default metadata to `None`
+    # removes the corresponding tag from the metadata.
+    monkeypatch.setenv('SOURCE_DATE_EPOCH', '19680801')
+
+    metadata_contains = {'creator': mpl.__version__, 'date': '1970-08-16',
+                         'format': 'image/svg+xml', 'type': 'StillImage'}
+
+    SVGNS = '{http://www.w3.org/2000/svg}'
+    RDFNS = '{http://www.w3.org/1999/02/22-rdf-syntax-ns#}'
+    CCNS = '{http://creativecommons.org/ns#}'
+    DCNS = '{http://purl.org/dc/elements/1.1/}'
+
+    fig, ax = plt.subplots()
+    for name in metadata_contains:
+        with BytesIO() as fd:
+            fig.savefig(fd, format='svg', metadata={name.title(): None})
+            buf = fd.getvalue().decode()
+
+        root = xml.etree.ElementTree.fromstring(buf)
+        work, = root.findall(f'./{SVGNS}metadata/{RDFNS}RDF/{CCNS}Work')
+        for key in metadata_contains:
+            data = work.findall(f'./{DCNS}{key}')
+            if key == name:
+                # The one we cleared is not there
+                assert not data
+                continue
+            # Everything else should be there
+            data, = data
+            xmlstr = xml.etree.ElementTree.tostring(data, encoding="unicode")
+            assert metadata_contains[key] in xmlstr
+
+
+def test_svg_clear_all_metadata():
+    # Makes sure that setting all default metadata to `None`
+    # removes the metadata tag from the output.
+
+    fig, ax = plt.subplots()
+    with BytesIO() as fd:
+        fig.savefig(fd, format='svg', metadata={'Date': None, 'Creator': None,
+                                                'Format': None, 'Type': None})
+        buf = fd.getvalue().decode()
+
+    SVGNS = '{http://www.w3.org/2000/svg}'
+
+    root = xml.etree.ElementTree.fromstring(buf)
+    assert not root.findall(f'./{SVGNS}metadata')
+
+
+def test_svg_metadata():
+    single_value = ['Coverage', 'Identifier', 'Language', 'Relation', 'Source',
+                    'Title', 'Type']
+    multi_value = ['Contributor', 'Creator', 'Keywords', 'Publisher', 'Rights']
+    metadata = {
+        'Date': [datetime.date(1968, 8, 1),
+                 datetime.datetime(1968, 8, 2, 1, 2, 3)],
+        'Description': 'description\ntext',
+        **{k: f'{k} foo' for k in single_value},
+        **{k: [f'{k} bar', f'{k} baz'] for k in multi_value},
+    }
+
+    fig = plt.figure()
+    with BytesIO() as fd:
+        fig.savefig(fd, format='svg', metadata=metadata)
+        buf = fd.getvalue().decode()
+
+    SVGNS = '{http://www.w3.org/2000/svg}'
+    RDFNS = '{http://www.w3.org/1999/02/22-rdf-syntax-ns#}'
+    CCNS = '{http://creativecommons.org/ns#}'
+    DCNS = '{http://purl.org/dc/elements/1.1/}'
+
+    root = xml.etree.ElementTree.fromstring(buf)
+    rdf, = root.findall(f'./{SVGNS}metadata/{RDFNS}RDF')
+
+    # Check things that are single entries.
+    titles = [node.text for node in root.findall(f'./{SVGNS}title')]
+    assert titles == [metadata['Title']]
+    types = [node.attrib[f'{RDFNS}resource']
+             for node in rdf.findall(f'./{CCNS}Work/{DCNS}type')]
+    assert types == [metadata['Type']]
+    for k in ['Description', *single_value]:
+        if k == 'Type':
+            continue
+        values = [node.text
+                  for node in rdf.findall(f'./{CCNS}Work/{DCNS}{k.lower()}')]
+        assert values == [metadata[k]]
+
+    # Check things that are multi-value entries.
+    for k in multi_value:
+        if k == 'Keywords':
+            continue
+        values = [
+            node.text
+            for node in rdf.findall(
+                f'./{CCNS}Work/{DCNS}{k.lower()}/{CCNS}Agent/{DCNS}title')]
+        assert values == metadata[k]
+
+    # Check special things.
+    dates = [node.text for node in rdf.findall(f'./{CCNS}Work/{DCNS}date')]
+    assert dates == ['1968-08-01/1968-08-02T01:02:03']
+
+    values = [node.text for node in
+              rdf.findall(f'./{CCNS}Work/{DCNS}subject/{RDFNS}Bag/{RDFNS}li')]
+    assert values == metadata['Keywords']
+
+
+@image_comparison(["multi_font_aspath.svg"], tol=1.8)
+def test_multi_font_type3():
+    fp = fm.FontProperties(family=["WenQuanYi Zen Hei"])
+    if Path(fm.findfont(fp)).name != "wqy-zenhei.ttc":
+        pytest.skip("Font may be missing")
+
+    plt.rc('font', family=['DejaVu Sans', 'WenQuanYi Zen Hei'], size=27)
+    plt.rc('svg', fonttype='path')
+
+    fig = plt.figure()
+    fig.text(0.15, 0.475, "There are 几个汉字 in between!")
+
+
+@image_comparison(["multi_font_astext.svg"])
+def test_multi_font_type42():
+    fp = fm.FontProperties(family=["WenQuanYi Zen Hei"])
+    if Path(fm.findfont(fp)).name != "wqy-zenhei.ttc":
+        pytest.skip("Font may be missing")
+
+    fig = plt.figure()
+    plt.rc('svg', fonttype='none')
+
+    plt.rc('font', family=['DejaVu Sans', 'WenQuanYi Zen Hei'], size=27)
+    fig.text(0.15, 0.475, "There are 几个汉字 in between!")
+
+
+@pytest.mark.parametrize('metadata,error,message', [
+    ({'Date': 1}, TypeError, "Invalid type for Date metadata. Expected str"),
+    ({'Date': [1]}, TypeError,
+     "Invalid type for Date metadata. Expected iterable"),
+    ({'Keywords': 1}, TypeError,
+     "Invalid type for Keywords metadata. Expected str"),
+    ({'Keywords': [1]}, TypeError,
+     "Invalid type for Keywords metadata. Expected iterable"),
+    ({'Creator': 1}, TypeError,
+     "Invalid type for Creator metadata. Expected str"),
+    ({'Creator': [1]}, TypeError,
+     "Invalid type for Creator metadata. Expected iterable"),
+    ({'Title': 1}, TypeError,
+     "Invalid type for Title metadata. Expected str"),
+    ({'Format': 1}, TypeError,
+     "Invalid type for Format metadata. Expected str"),
+    ({'Foo': 'Bar'}, ValueError, "Unknown metadata key"),
+    ])
+def test_svg_incorrect_metadata(metadata, error, message):
+    with pytest.raises(error, match=message), BytesIO() as fd:
+        fig = plt.figure()
+        fig.savefig(fd, format='svg', metadata=metadata)
+
+
+def test_svg_escape():
+    fig = plt.figure()
+    fig.text(0.5, 0.5, "<\'\"&>", gid="<\'\"&>")
+    with BytesIO() as fd:
+        fig.savefig(fd, format='svg')
+        buf = fd.getvalue().decode()
+        assert '&lt;&apos;&quot;&amp;&gt;"' in buf
+
+
+@pytest.mark.parametrize("font_str", [
+    "'DejaVu Sans', 'WenQuanYi Zen Hei', 'Arial', sans-serif",
+    "'DejaVu Serif', 'WenQuanYi Zen Hei', 'Times New Roman', serif",
+    "'Arial', 'WenQuanYi Zen Hei', cursive",
+    "'Impact', 'WenQuanYi Zen Hei', fantasy",
+    "'DejaVu Sans Mono', 'WenQuanYi Zen Hei', 'Courier New', monospace",
+    # These do not work because the logic to get the font metrics will not find
+    # WenQuanYi as the fallback logic stops with the first fallback font:
+    # "'DejaVu Sans Mono', 'Courier New', 'WenQuanYi Zen Hei', monospace",
+    # "'DejaVu Sans', 'Arial', 'WenQuanYi Zen Hei', sans-serif",
+    # "'DejaVu Serif', 'Times New Roman', 'WenQuanYi Zen Hei',  serif",
+])
+@pytest.mark.parametrize("include_generic", [True, False])
+def test_svg_font_string(font_str, include_generic):
+    fp = fm.FontProperties(family=["WenQuanYi Zen Hei"])
+    if Path(fm.findfont(fp)).name != "wqy-zenhei.ttc":
+        pytest.skip("Font may be missing")
+
+    explicit, *rest, generic = map(
+        lambda x: x.strip("'"), font_str.split(", ")
+    )
+    size = len(generic)
+    if include_generic:
+        rest = rest + [generic]
+    plt.rcParams[f"font.{generic}"] = rest
+    plt.rcParams["font.size"] = size
+    plt.rcParams["svg.fonttype"] = "none"
+
+    fig, ax = plt.subplots()
+    if generic == "sans-serif":
+        generic_options = ["sans", "sans-serif", "sans serif"]
+    else:
+        generic_options = [generic]
+
+    for generic_name in generic_options:
+        # test that fallback works
+        ax.text(0.5, 0.5, "There are 几个汉字 in between!",
+                family=[explicit, generic_name], ha="center")
+        # test deduplication works
+        ax.text(0.5, 0.1, "There are 几个汉字 in between!",
+                family=[explicit, *rest, generic_name], ha="center")
+    ax.axis("off")
+
+    with BytesIO() as fd:
+        fig.savefig(fd, format="svg")
+        buf = fd.getvalue()
+
+    tree = xml.etree.ElementTree.fromstring(buf)
+    ns = "http://www.w3.org/2000/svg"
+    text_count = 0
+    for text_element in tree.findall(f".//{{{ns}}}text"):
+        text_count += 1
+        font_style = dict(
+            map(lambda x: x.strip(), _.strip().split(":"))
+            for _ in dict(text_element.items())["style"].split(";")
+        )
+
+        assert font_style["font-size"] == f"{size}px"
+        assert font_style["font-family"] == font_str
+    assert text_count == len(ax.texts)
+
+
+def test_annotationbbox_gid():
+    # Test that object gid appears in the AnnotationBbox
+    # in output svg.
+    fig = plt.figure()
+    ax = fig.add_subplot()
+    arr_img = np.ones((32, 32))
+    xy = (0.3, 0.55)
+
+    imagebox = OffsetImage(arr_img, zoom=0.1)
+    imagebox.image.axes = ax
+
+    ab = AnnotationBbox(imagebox, xy,
+                        xybox=(120., -80.),
+                        xycoords='data',
+                        boxcoords="offset points",
+                        pad=0.5,
+                        arrowprops=dict(
+                            arrowstyle="->",
+                            connectionstyle="angle,angleA=0,angleB=90,rad=3")
+                        )
+    ab.set_gid("a test for issue 20044")
+    ax.add_artist(ab)
+
+    with BytesIO() as fd:
+        fig.savefig(fd, format='svg')
+        buf = fd.getvalue().decode('utf-8')
+
+    expected = '<g id="a test for issue 20044">'
+    assert expected in buf
+
+
+def test_svgid():
+    """Test that `svg.id` rcparam appears in output svg if not None."""
+
+    fig, ax = plt.subplots()
+    ax.plot([1, 2, 3], [3, 2, 1])
+    fig.canvas.draw()
+
+    # Default: svg.id = None
+    with BytesIO() as fd:
+        fig.savefig(fd, format='svg')
+        buf = fd.getvalue().decode()
+
+    tree = xml.etree.ElementTree.fromstring(buf)
+
+    assert plt.rcParams['svg.id'] is None
+    assert not tree.findall('.[@id]')
+
+    # String: svg.id = str
+    svg_id = 'a test for issue 28535'
+    plt.rc('svg', id=svg_id)
+
+    with BytesIO() as fd:
+        fig.savefig(fd, format='svg')
+        buf = fd.getvalue().decode()
+
+    tree = xml.etree.ElementTree.fromstring(buf)
+
+    assert plt.rcParams['svg.id'] == svg_id
+    assert tree.findall(f'.[@id="{svg_id}"]')
diff --git a/lib/python3.10/site-packages/matplotlib/tests/test_font_manager.py b/lib/python3.10/site-packages/matplotlib/tests/test_font_manager.py
new file mode 100644
index 0000000000000000000000000000000000000000..d15b892b3eeaaed6762b6b9344ad9729a6ea3f0a
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/tests/test_font_manager.py
@@ -0,0 +1,409 @@
+from io import BytesIO, StringIO
+import gc
+import multiprocessing
+import os
+from pathlib import Path
+from PIL import Image
+import shutil
+import sys
+import warnings
+
+import numpy as np
+import pytest
+
+import matplotlib as mpl
+from matplotlib.font_manager import (
+    findfont, findSystemFonts, FontEntry, FontProperties, fontManager,
+    json_dump, json_load, get_font, is_opentype_cff_font,
+    MSUserFontDirectories, _get_fontconfig_fonts, ttfFontProperty)
+from matplotlib import cbook, ft2font, pyplot as plt, rc_context, figure as mfigure
+from matplotlib.testing import subprocess_run_helper, subprocess_run_for_testing
+
+
+has_fclist = shutil.which('fc-list') is not None
+
+
+def test_font_priority():
+    with rc_context(rc={
+            'font.sans-serif':
+            ['cmmi10', 'Bitstream Vera Sans']}):
+        fontfile = findfont(FontProperties(family=["sans-serif"]))
+    assert Path(fontfile).name == 'cmmi10.ttf'
+
+    # Smoketest get_charmap, which isn't used internally anymore
+    font = get_font(fontfile)
+    cmap = font.get_charmap()
+    assert len(cmap) == 131
+    assert cmap[8729] == 30
+
+
+def test_score_weight():
+    assert 0 == fontManager.score_weight("regular", "regular")
+    assert 0 == fontManager.score_weight("bold", "bold")
+    assert (0 < fontManager.score_weight(400, 400) <
+            fontManager.score_weight("normal", "bold"))
+    assert (0 < fontManager.score_weight("normal", "regular") <
+            fontManager.score_weight("normal", "bold"))
+    assert (fontManager.score_weight("normal", "regular") ==
+            fontManager.score_weight(400, 400))
+
+
+def test_json_serialization(tmp_path):
+    # Can't open a NamedTemporaryFile twice on Windows, so use a temporary
+    # directory instead.
+    json_dump(fontManager, tmp_path / "fontlist.json")
+    copy = json_load(tmp_path / "fontlist.json")
+    with warnings.catch_warnings():
+        warnings.filterwarnings('ignore', 'findfont: Font family.*not found')
+        for prop in ({'family': 'STIXGeneral'},
+                     {'family': 'Bitstream Vera Sans', 'weight': 700},
+                     {'family': 'no such font family'}):
+            fp = FontProperties(**prop)
+            assert (fontManager.findfont(fp, rebuild_if_missing=False) ==
+                    copy.findfont(fp, rebuild_if_missing=False))
+
+
+def test_otf():
+    fname = '/usr/share/fonts/opentype/freefont/FreeMono.otf'
+    if Path(fname).exists():
+        assert is_opentype_cff_font(fname)
+    for f in fontManager.ttflist:
+        if 'otf' in f.fname:
+            with open(f.fname, 'rb') as fd:
+                res = fd.read(4) == b'OTTO'
+            assert res == is_opentype_cff_font(f.fname)
+
+
+@pytest.mark.skipif(sys.platform == "win32" or not has_fclist,
+                    reason='no fontconfig installed')
+def test_get_fontconfig_fonts():
+    assert len(_get_fontconfig_fonts()) > 1
+
+
+@pytest.mark.parametrize('factor', [2, 4, 6, 8])
+def test_hinting_factor(factor):
+    font = findfont(FontProperties(family=["sans-serif"]))
+
+    font1 = get_font(font, hinting_factor=1)
+    font1.clear()
+    font1.set_size(12, 100)
+    font1.set_text('abc')
+    expected = font1.get_width_height()
+
+    hinted_font = get_font(font, hinting_factor=factor)
+    hinted_font.clear()
+    hinted_font.set_size(12, 100)
+    hinted_font.set_text('abc')
+    # Check that hinting only changes text layout by a small (10%) amount.
+    np.testing.assert_allclose(hinted_font.get_width_height(), expected,
+                               rtol=0.1)
+
+
+def test_utf16m_sfnt():
+    try:
+        # seguisbi = Microsoft Segoe UI Semibold
+        entry = next(entry for entry in fontManager.ttflist
+                     if Path(entry.fname).name == "seguisbi.ttf")
+    except StopIteration:
+        pytest.skip("Couldn't find seguisbi.ttf font to test against.")
+    else:
+        # Check that we successfully read "semibold" from the font's sfnt table
+        # and set its weight accordingly.
+        assert entry.weight == 600
+
+
+def test_find_ttc():
+    fp = FontProperties(family=["WenQuanYi Zen Hei"])
+    if Path(findfont(fp)).name != "wqy-zenhei.ttc":
+        pytest.skip("Font wqy-zenhei.ttc may be missing")
+    fig, ax = plt.subplots()
+    ax.text(.5, .5, "\N{KANGXI RADICAL DRAGON}", fontproperties=fp)
+    for fmt in ["raw", "svg", "pdf", "ps"]:
+        fig.savefig(BytesIO(), format=fmt)
+
+
+def test_find_noto():
+    fp = FontProperties(family=["Noto Sans CJK SC", "Noto Sans CJK JP"])
+    name = Path(findfont(fp)).name
+    if name not in ("NotoSansCJKsc-Regular.otf", "NotoSansCJK-Regular.ttc"):
+        pytest.skip(f"Noto Sans CJK SC font may be missing (found {name})")
+
+    fig, ax = plt.subplots()
+    ax.text(0.5, 0.5, 'Hello, 你好', fontproperties=fp)
+    for fmt in ["raw", "svg", "pdf", "ps"]:
+        fig.savefig(BytesIO(), format=fmt)
+
+
+def test_find_invalid(tmp_path):
+
+    with pytest.raises(FileNotFoundError):
+        get_font(tmp_path / 'non-existent-font-name.ttf')
+
+    with pytest.raises(FileNotFoundError):
+        get_font(str(tmp_path / 'non-existent-font-name.ttf'))
+
+    with pytest.raises(FileNotFoundError):
+        get_font(bytes(tmp_path / 'non-existent-font-name.ttf'))
+
+    # Not really public, but get_font doesn't expose non-filename constructor.
+    from matplotlib.ft2font import FT2Font
+    with pytest.raises(TypeError, match='font file or a binary-mode file'):
+        FT2Font(StringIO())  # type: ignore[arg-type]
+
+
+@pytest.mark.skipif(sys.platform != 'linux' or not has_fclist,
+                    reason='only Linux with fontconfig installed')
+def test_user_fonts_linux(tmpdir, monkeypatch):
+    font_test_file = 'mpltest.ttf'
+
+    # Precondition: the test font should not be available
+    fonts = findSystemFonts()
+    if any(font_test_file in font for font in fonts):
+        pytest.skip(f'{font_test_file} already exists in system fonts')
+
+    # Prepare a temporary user font directory
+    user_fonts_dir = tmpdir.join('fonts')
+    user_fonts_dir.ensure(dir=True)
+    shutil.copyfile(Path(__file__).parent / font_test_file,
+                    user_fonts_dir.join(font_test_file))
+
+    with monkeypatch.context() as m:
+        m.setenv('XDG_DATA_HOME', str(tmpdir))
+        _get_fontconfig_fonts.cache_clear()
+        # Now, the font should be available
+        fonts = findSystemFonts()
+        assert any(font_test_file in font for font in fonts)
+
+    # Make sure the temporary directory is no longer cached.
+    _get_fontconfig_fonts.cache_clear()
+
+
+def test_addfont_as_path():
+    """Smoke test that addfont() accepts pathlib.Path."""
+    font_test_file = 'mpltest.ttf'
+    path = Path(__file__).parent / font_test_file
+    try:
+        fontManager.addfont(path)
+        added, = (font for font in fontManager.ttflist
+                  if font.fname.endswith(font_test_file))
+        fontManager.ttflist.remove(added)
+    finally:
+        to_remove = [font for font in fontManager.ttflist
+                     if font.fname.endswith(font_test_file)]
+        for font in to_remove:
+            fontManager.ttflist.remove(font)
+
+
+@pytest.mark.skipif(sys.platform != 'win32', reason='Windows only')
+def test_user_fonts_win32():
+    if not (os.environ.get('APPVEYOR') or os.environ.get('TF_BUILD')):
+        pytest.xfail("This test should only run on CI (appveyor or azure) "
+                     "as the developer's font directory should remain "
+                     "unchanged.")
+    pytest.xfail("We need to update the registry for this test to work")
+    font_test_file = 'mpltest.ttf'
+
+    # Precondition: the test font should not be available
+    fonts = findSystemFonts()
+    if any(font_test_file in font for font in fonts):
+        pytest.skip(f'{font_test_file} already exists in system fonts')
+
+    user_fonts_dir = MSUserFontDirectories[0]
+
+    # Make sure that the user font directory exists (this is probably not the
+    # case on Windows versions < 1809)
+    os.makedirs(user_fonts_dir)
+
+    # Copy the test font to the user font directory
+    shutil.copy(Path(__file__).parent / font_test_file, user_fonts_dir)
+
+    # Now, the font should be available
+    fonts = findSystemFonts()
+    assert any(font_test_file in font for font in fonts)
+
+
+def _model_handler(_):
+    fig, ax = plt.subplots()
+    fig.savefig(BytesIO(), format="pdf")
+    plt.close()
+
+
+@pytest.mark.skipif(not hasattr(os, "register_at_fork"),
+                    reason="Cannot register at_fork handlers")
+def test_fork():
+    _model_handler(0)  # Make sure the font cache is filled.
+    ctx = multiprocessing.get_context("fork")
+    with ctx.Pool(processes=2) as pool:
+        pool.map(_model_handler, range(2))
+
+
+def test_missing_family(caplog):
+    plt.rcParams["font.sans-serif"] = ["this-font-does-not-exist"]
+    with caplog.at_level("WARNING"):
+        findfont("sans")
+    assert [rec.getMessage() for rec in caplog.records] == [
+        "findfont: Font family ['sans'] not found. "
+        "Falling back to DejaVu Sans.",
+        "findfont: Generic family 'sans' not found because none of the "
+        "following families were found: this-font-does-not-exist",
+    ]
+
+
+def _test_threading():
+    import threading
+    from matplotlib.ft2font import LoadFlags
+    import matplotlib.font_manager as fm
+
+    def loud_excepthook(args):
+        raise RuntimeError("error in thread!")
+
+    threading.excepthook = loud_excepthook
+
+    N = 10
+    b = threading.Barrier(N)
+
+    def bad_idea(n):
+        b.wait(timeout=5)
+        for j in range(100):
+            font = fm.get_font(fm.findfont("DejaVu Sans"))
+            font.set_text(str(n), 0.0, flags=LoadFlags.NO_HINTING)
+
+    threads = [
+        threading.Thread(target=bad_idea, name=f"bad_thread_{j}", args=(j,))
+        for j in range(N)
+    ]
+
+    for t in threads:
+        t.start()
+
+    for t in threads:
+        t.join(timeout=9)
+        if t.is_alive():
+            raise RuntimeError("thread failed to join")
+
+
+def test_fontcache_thread_safe():
+    pytest.importorskip('threading')
+
+    subprocess_run_helper(_test_threading, timeout=10)
+
+
+def test_lockfilefailure(tmp_path):
+    # The logic here:
+    # 1. get a temp directory from pytest
+    # 2. import matplotlib which makes sure it exists
+    # 3. get the cache dir (where we check it is writable)
+    # 4. make it not writable
+    # 5. try to write into it via font manager
+    proc = subprocess_run_for_testing(
+        [
+            sys.executable,
+            "-c",
+            "import matplotlib;"
+            "import os;"
+            "p = matplotlib.get_cachedir();"
+            "os.chmod(p, 0o555);"
+            "import matplotlib.font_manager;"
+        ],
+        env={**os.environ, 'MPLCONFIGDIR': str(tmp_path)},
+        check=True
+    )
+
+
+def test_fontentry_dataclass():
+    fontent = FontEntry(name='font-name')
+
+    png = fontent._repr_png_()
+    img = Image.open(BytesIO(png))
+    assert img.width > 0
+    assert img.height > 0
+
+    html = fontent._repr_html_()
+    assert html.startswith("<img src=\"data:image/png;base64")
+
+
+def test_fontentry_dataclass_invalid_path():
+    with pytest.raises(FileNotFoundError):
+        fontent = FontEntry(fname='/random', name='font-name')
+        fontent._repr_html_()
+
+
+@pytest.mark.skipif(sys.platform == 'win32', reason='Linux or OS only')
+def test_get_font_names():
+    paths_mpl = [cbook._get_data_path('fonts', subdir) for subdir in ['ttf']]
+    fonts_mpl = findSystemFonts(paths_mpl, fontext='ttf')
+    fonts_system = findSystemFonts(fontext='ttf')
+    ttf_fonts = []
+    for path in fonts_mpl + fonts_system:
+        try:
+            font = ft2font.FT2Font(path)
+            prop = ttfFontProperty(font)
+            ttf_fonts.append(prop.name)
+        except Exception:
+            pass
+    available_fonts = sorted(list(set(ttf_fonts)))
+    mpl_font_names = sorted(fontManager.get_font_names())
+    assert set(available_fonts) == set(mpl_font_names)
+    assert len(available_fonts) == len(mpl_font_names)
+    assert available_fonts == mpl_font_names
+
+
+def test_donot_cache_tracebacks():
+
+    class SomeObject:
+        pass
+
+    def inner():
+        x = SomeObject()
+        fig = mfigure.Figure()
+        ax = fig.subplots()
+        fig.text(.5, .5, 'aardvark', family='doesnotexist')
+        with BytesIO() as out:
+            with warnings.catch_warnings():
+                warnings.filterwarnings('ignore')
+                fig.savefig(out, format='raw')
+
+    inner()
+
+    for obj in gc.get_objects():
+        if isinstance(obj, SomeObject):
+            pytest.fail("object from inner stack still alive")
+
+
+def test_fontproperties_init_deprecation():
+    """
+    Test the deprecated API of FontProperties.__init__.
+
+    The deprecation does not change behavior, it only adds a deprecation warning
+    via a decorator. Therefore, the purpose of this test is limited to check
+    which calls do and do not issue deprecation warnings. Behavior is still
+    tested via the existing regular tests.
+    """
+    with pytest.warns(mpl.MatplotlibDeprecationWarning):
+        # multiple positional arguments
+        FontProperties("Times", "italic")
+
+    with pytest.warns(mpl.MatplotlibDeprecationWarning):
+        # Mixed positional and keyword arguments
+        FontProperties("Times", size=10)
+
+    with pytest.warns(mpl.MatplotlibDeprecationWarning):
+        # passing a family list positionally
+        FontProperties(["Times"])
+
+    # still accepted:
+    FontProperties(family="Times", style="italic")
+    FontProperties(family="Times")
+    FontProperties("Times")  # works as pattern and family
+    FontProperties("serif-24:style=oblique:weight=bold")  # pattern
+
+    # also still accepted:
+    # passing as pattern via family kwarg was not covered by the docs but
+    # historically worked. This is left unchanged for now.
+    # AFAICT, we cannot detect this: We can determine whether a string
+    # works as pattern, but that doesn't help, because there are strings
+    # that are both pattern and family. We would need to identify, whether
+    # a string is *not* a valid family.
+    # Since this case is not covered by docs, I've refrained from jumping
+    # extra hoops to detect this possible API misuse.
+    FontProperties(family="serif-24:style=oblique:weight=bold")
diff --git a/lib/python3.10/site-packages/matplotlib/tests/test_sphinxext.py b/lib/python3.10/site-packages/matplotlib/tests/test_sphinxext.py
new file mode 100644
index 0000000000000000000000000000000000000000..1aaa6baca47c5f8e5a7dd6dbae608487a401590f
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/tests/test_sphinxext.py
@@ -0,0 +1,227 @@
+"""Tests for tinypages build using sphinx extensions."""
+
+import filecmp
+import os
+from pathlib import Path
+import shutil
+import sys
+
+from matplotlib.testing import subprocess_run_for_testing
+import pytest
+
+
+pytest.importorskip('sphinx', minversion='4.1.3')
+
+
+def build_sphinx_html(source_dir, doctree_dir, html_dir, extra_args=None):
+    # Build the pages with warnings turned into errors
+    extra_args = [] if extra_args is None else extra_args
+    cmd = [sys.executable, '-msphinx', '-W', '-b', 'html',
+           '-d', str(doctree_dir), str(source_dir), str(html_dir), *extra_args]
+    proc = subprocess_run_for_testing(
+        cmd, capture_output=True, text=True,
+        env={**os.environ, "MPLBACKEND": ""})
+    out = proc.stdout
+    err = proc.stderr
+
+    assert proc.returncode == 0, \
+        f"sphinx build failed with stdout:\n{out}\nstderr:\n{err}\n"
+    if err:
+        pytest.fail(f"sphinx build emitted the following warnings:\n{err}")
+
+    assert html_dir.is_dir()
+
+
+def test_tinypages(tmp_path):
+    shutil.copytree(Path(__file__).parent / 'tinypages', tmp_path,
+                    dirs_exist_ok=True)
+    html_dir = tmp_path / '_build' / 'html'
+    img_dir = html_dir / '_images'
+    doctree_dir = tmp_path / 'doctrees'
+    # Build the pages with warnings turned into errors
+    cmd = [sys.executable, '-msphinx', '-W', '-b', 'html',
+           '-d', str(doctree_dir),
+           str(Path(__file__).parent / 'tinypages'), str(html_dir)]
+    # On CI, gcov emits warnings (due to agg headers being included with the
+    # same name in multiple extension modules -- but we don't care about their
+    # coverage anyways); hide them using GCOV_ERROR_FILE.
+    proc = subprocess_run_for_testing(
+        cmd, capture_output=True, text=True,
+        env={**os.environ, "MPLBACKEND": "", "GCOV_ERROR_FILE": os.devnull}
+    )
+    out = proc.stdout
+    err = proc.stderr
+
+    # Build the pages with warnings turned into errors
+    build_sphinx_html(tmp_path, doctree_dir, html_dir)
+
+    def plot_file(num):
+        return img_dir / f'some_plots-{num}.png'
+
+    def plot_directive_file(num):
+        # This is always next to the doctree dir.
+        return doctree_dir.parent / 'plot_directive' / f'some_plots-{num}.png'
+
+    range_10, range_6, range_4 = (plot_file(i) for i in range(1, 4))
+    # Plot 5 is range(6) plot
+    assert filecmp.cmp(range_6, plot_file(5))
+    # Plot 7 is range(4) plot
+    assert filecmp.cmp(range_4, plot_file(7))
+    # Plot 11 is range(10) plot
+    assert filecmp.cmp(range_10, plot_file(11))
+    # Plot 12 uses the old range(10) figure and the new range(6) figure
+    assert filecmp.cmp(range_10, plot_file('12_00'))
+    assert filecmp.cmp(range_6, plot_file('12_01'))
+    # Plot 13 shows close-figs in action
+    assert filecmp.cmp(range_4, plot_file(13))
+    # Plot 14 has included source
+    html_contents = (html_dir / 'some_plots.html').read_text(encoding='utf-8')
+
+    assert '# Only a comment' in html_contents
+    # check plot defined in external file.
+    assert filecmp.cmp(range_4, img_dir / 'range4.png')
+    assert filecmp.cmp(range_6, img_dir / 'range6_range6.png')
+    # check if figure caption made it into html file
+    assert 'This is the caption for plot 15.' in html_contents
+    # check if figure caption using :caption: made it into html file (because this plot
+    # doesn't use srcset, the caption preserves newlines in the output.)
+    assert 'Plot 17 uses the caption option,\nwith multi-line input.' in html_contents
+    # check if figure alt text using :alt: made it into html file
+    assert 'Plot 17 uses the alt option, with multi-line input.' in html_contents
+    # check if figure caption made it into html file
+    assert 'This is the caption for plot 18.' in html_contents
+    # check if the custom classes made it into the html file
+    assert 'plot-directive my-class my-other-class' in html_contents
+    # check that the multi-image caption is applied twice
+    assert html_contents.count('This caption applies to both plots.') == 2
+    # Plot 21 is range(6) plot via an include directive. But because some of
+    # the previous plots are repeated, the argument to plot_file() is only 17.
+    assert filecmp.cmp(range_6, plot_file(17))
+    # plot 22 is from the range6.py file again, but a different function
+    assert filecmp.cmp(range_10, img_dir / 'range6_range10.png')
+
+    # Modify the included plot
+    contents = (tmp_path / 'included_plot_21.rst').read_bytes()
+    contents = contents.replace(b'plt.plot(range(6))', b'plt.plot(range(4))')
+    (tmp_path / 'included_plot_21.rst').write_bytes(contents)
+    # Build the pages again and check that the modified file was updated
+    modification_times = [plot_directive_file(i).stat().st_mtime
+                          for i in (1, 2, 3, 5)]
+    build_sphinx_html(tmp_path, doctree_dir, html_dir)
+    assert filecmp.cmp(range_4, plot_file(17))
+    # Check that the plots in the plot_directive folder weren't changed.
+    # (plot_directive_file(1) won't be modified, but it will be copied to html/
+    # upon compilation, so plot_file(1) will be modified)
+    assert plot_directive_file(1).stat().st_mtime == modification_times[0]
+    assert plot_directive_file(2).stat().st_mtime == modification_times[1]
+    assert plot_directive_file(3).stat().st_mtime == modification_times[2]
+    assert filecmp.cmp(range_10, plot_file(1))
+    assert filecmp.cmp(range_6, plot_file(2))
+    assert filecmp.cmp(range_4, plot_file(3))
+    # Make sure that figures marked with context are re-created (but that the
+    # contents are the same)
+    assert plot_directive_file(5).stat().st_mtime > modification_times[3]
+    assert filecmp.cmp(range_6, plot_file(5))
+
+
+def test_plot_html_show_source_link(tmp_path):
+    parent = Path(__file__).parent
+    shutil.copyfile(parent / 'tinypages/conf.py', tmp_path / 'conf.py')
+    shutil.copytree(parent / 'tinypages/_static', tmp_path / '_static')
+    doctree_dir = tmp_path / 'doctrees'
+    (tmp_path / 'index.rst').write_text("""
+.. plot::
+
+    plt.plot(range(2))
+""")
+    # Make sure source scripts are created by default
+    html_dir1 = tmp_path / '_build' / 'html1'
+    build_sphinx_html(tmp_path, doctree_dir, html_dir1)
+    assert len(list(html_dir1.glob("**/index-1.py"))) == 1
+    # Make sure source scripts are NOT created when
+    # plot_html_show_source_link` is False
+    html_dir2 = tmp_path / '_build' / 'html2'
+    build_sphinx_html(tmp_path, doctree_dir, html_dir2,
+                      extra_args=['-D', 'plot_html_show_source_link=0'])
+    assert len(list(html_dir2.glob("**/index-1.py"))) == 0
+
+
+@pytest.mark.parametrize('plot_html_show_source_link', [0, 1])
+def test_show_source_link_true(tmp_path, plot_html_show_source_link):
+    # Test that a source link is generated if :show-source-link: is true,
+    # whether or not plot_html_show_source_link is true.
+    parent = Path(__file__).parent
+    shutil.copyfile(parent / 'tinypages/conf.py', tmp_path / 'conf.py')
+    shutil.copytree(parent / 'tinypages/_static', tmp_path / '_static')
+    doctree_dir = tmp_path / 'doctrees'
+    (tmp_path / 'index.rst').write_text("""
+.. plot::
+    :show-source-link: true
+
+    plt.plot(range(2))
+""")
+    html_dir = tmp_path / '_build' / 'html'
+    build_sphinx_html(tmp_path, doctree_dir, html_dir, extra_args=[
+        '-D', f'plot_html_show_source_link={plot_html_show_source_link}'])
+    assert len(list(html_dir.glob("**/index-1.py"))) == 1
+
+
+@pytest.mark.parametrize('plot_html_show_source_link', [0, 1])
+def test_show_source_link_false(tmp_path, plot_html_show_source_link):
+    # Test that a source link is NOT generated if :show-source-link: is false,
+    # whether or not plot_html_show_source_link is true.
+    parent = Path(__file__).parent
+    shutil.copyfile(parent / 'tinypages/conf.py', tmp_path / 'conf.py')
+    shutil.copytree(parent / 'tinypages/_static', tmp_path / '_static')
+    doctree_dir = tmp_path / 'doctrees'
+    (tmp_path / 'index.rst').write_text("""
+.. plot::
+    :show-source-link: false
+
+    plt.plot(range(2))
+""")
+    html_dir = tmp_path / '_build' / 'html'
+    build_sphinx_html(tmp_path, doctree_dir, html_dir, extra_args=[
+        '-D', f'plot_html_show_source_link={plot_html_show_source_link}'])
+    assert len(list(html_dir.glob("**/index-1.py"))) == 0
+
+
+def test_srcset_version(tmp_path):
+    shutil.copytree(Path(__file__).parent / 'tinypages', tmp_path,
+                    dirs_exist_ok=True)
+    html_dir = tmp_path / '_build' / 'html'
+    img_dir = html_dir / '_images'
+    doctree_dir = tmp_path / 'doctrees'
+
+    build_sphinx_html(tmp_path, doctree_dir, html_dir, extra_args=[
+        '-D', 'plot_srcset=2x'])
+
+    def plot_file(num, suff=''):
+        return img_dir / f'some_plots-{num}{suff}.png'
+
+    # check some-plots
+    for ind in [1, 2, 3, 5, 7, 11, 13, 15, 17]:
+        assert plot_file(ind).exists()
+        assert plot_file(ind, suff='.2x').exists()
+
+    assert (img_dir / 'nestedpage-index-1.png').exists()
+    assert (img_dir / 'nestedpage-index-1.2x.png').exists()
+    assert (img_dir / 'nestedpage-index-2.png').exists()
+    assert (img_dir / 'nestedpage-index-2.2x.png').exists()
+    assert (img_dir / 'nestedpage2-index-1.png').exists()
+    assert (img_dir / 'nestedpage2-index-1.2x.png').exists()
+    assert (img_dir / 'nestedpage2-index-2.png').exists()
+    assert (img_dir / 'nestedpage2-index-2.2x.png').exists()
+
+    # Check html for srcset
+
+    assert ('srcset="_images/some_plots-1.png, _images/some_plots-1.2x.png 2.00x"'
+            in (html_dir / 'some_plots.html').read_text(encoding='utf-8'))
+
+    st = ('srcset="../_images/nestedpage-index-1.png, '
+          '../_images/nestedpage-index-1.2x.png 2.00x"')
+    assert st in (html_dir / 'nestedpage/index.html').read_text(encoding='utf-8')
+
+    st = ('srcset="../_images/nestedpage2-index-2.png, '
+          '../_images/nestedpage2-index-2.2x.png 2.00x"')
+    assert st in (html_dir / 'nestedpage2/index.html').read_text(encoding='utf-8')
diff --git a/lib/python3.10/site-packages/matplotlib/tests/test_spines.py b/lib/python3.10/site-packages/matplotlib/tests/test_spines.py
new file mode 100644
index 0000000000000000000000000000000000000000..29b4ecf6f33033a8d46f281a7fba92b6cc7d46ce
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/tests/test_spines.py
@@ -0,0 +1,156 @@
+import numpy as np
+import pytest
+
+import matplotlib.pyplot as plt
+from matplotlib.spines import Spines
+from matplotlib.testing.decorators import check_figures_equal, image_comparison
+
+
+def test_spine_class():
+    """Test Spines and SpinesProxy in isolation."""
+    class SpineMock:
+        def __init__(self):
+            self.val = None
+
+        def set(self, **kwargs):
+            vars(self).update(kwargs)
+
+        def set_val(self, val):
+            self.val = val
+
+    spines_dict = {
+        'left': SpineMock(),
+        'right': SpineMock(),
+        'top': SpineMock(),
+        'bottom': SpineMock(),
+    }
+    spines = Spines(**spines_dict)
+
+    assert spines['left'] is spines_dict['left']
+    assert spines.left is spines_dict['left']
+
+    spines[['left', 'right']].set_val('x')
+    assert spines.left.val == 'x'
+    assert spines.right.val == 'x'
+    assert spines.top.val is None
+    assert spines.bottom.val is None
+
+    spines[:].set_val('y')
+    assert all(spine.val == 'y' for spine in spines.values())
+
+    spines[:].set(foo='bar')
+    assert all(spine.foo == 'bar' for spine in spines.values())
+
+    with pytest.raises(AttributeError, match='foo'):
+        spines.foo
+    with pytest.raises(KeyError, match='foo'):
+        spines['foo']
+    with pytest.raises(KeyError, match='foo, bar'):
+        spines[['left', 'foo', 'right', 'bar']]
+    with pytest.raises(ValueError, match='single list'):
+        spines['left', 'right']
+    with pytest.raises(ValueError, match='Spines does not support slicing'):
+        spines['left':'right']
+    with pytest.raises(ValueError, match='Spines does not support slicing'):
+        spines['top':]
+
+
+@image_comparison(['spines_axes_positions.png'])
+def test_spines_axes_positions():
+    # SF bug 2852168
+    fig = plt.figure()
+    x = np.linspace(0, 2*np.pi, 100)
+    y = 2*np.sin(x)
+    ax = fig.add_subplot(1, 1, 1)
+    ax.set_title('centered spines')
+    ax.plot(x, y)
+    ax.spines.right.set_position(('axes', 0.1))
+    ax.yaxis.set_ticks_position('right')
+    ax.spines.top.set_position(('axes', 0.25))
+    ax.xaxis.set_ticks_position('top')
+    ax.spines.left.set_color('none')
+    ax.spines.bottom.set_color('none')
+
+
+@image_comparison(['spines_data_positions.png'])
+def test_spines_data_positions():
+    fig, ax = plt.subplots()
+    ax.spines.left.set_position(('data', -1.5))
+    ax.spines.top.set_position(('data', 0.5))
+    ax.spines.right.set_position(('data', -0.5))
+    ax.spines.bottom.set_position('zero')
+    ax.set_xlim([-2, 2])
+    ax.set_ylim([-2, 2])
+
+
+@check_figures_equal(extensions=["png"])
+def test_spine_nonlinear_data_positions(fig_test, fig_ref):
+    plt.style.use("default")
+
+    ax = fig_test.add_subplot()
+    ax.set(xscale="log", xlim=(.1, 1))
+    # Use position="data" to visually swap the left and right spines, using
+    # linewidth to distinguish them.  The calls to tick_params removes labels
+    # (for image comparison purposes) and harmonizes tick positions with the
+    # reference).
+    ax.spines.left.set_position(("data", 1))
+    ax.spines.left.set_linewidth(2)
+    ax.spines.right.set_position(("data", .1))
+    ax.tick_params(axis="y", labelleft=False, direction="in")
+
+    ax = fig_ref.add_subplot()
+    ax.set(xscale="log", xlim=(.1, 1))
+    ax.spines.right.set_linewidth(2)
+    ax.tick_params(axis="y", labelleft=False, left=False, right=True)
+
+
+@image_comparison(['spines_capstyle.png'])
+def test_spines_capstyle():
+    # issue 2542
+    plt.rc('axes', linewidth=20)
+    fig, ax = plt.subplots()
+    ax.set_xticks([])
+    ax.set_yticks([])
+
+
+def test_label_without_ticks():
+    fig, ax = plt.subplots()
+    plt.subplots_adjust(left=0.3, bottom=0.3)
+    ax.plot(np.arange(10))
+    ax.yaxis.set_ticks_position('left')
+    ax.spines.left.set_position(('outward', 30))
+    ax.spines.right.set_visible(False)
+    ax.set_ylabel('y label')
+    ax.xaxis.set_ticks_position('bottom')
+    ax.spines.bottom.set_position(('outward', 30))
+    ax.spines.top.set_visible(False)
+    ax.set_xlabel('x label')
+    ax.xaxis.set_ticks([])
+    ax.yaxis.set_ticks([])
+    plt.draw()
+
+    spine = ax.spines.left
+    spinebbox = spine.get_transform().transform_path(
+        spine.get_path()).get_extents()
+    assert ax.yaxis.label.get_position()[0] < spinebbox.xmin, \
+        "Y-Axis label not left of the spine"
+
+    spine = ax.spines.bottom
+    spinebbox = spine.get_transform().transform_path(
+        spine.get_path()).get_extents()
+    assert ax.xaxis.label.get_position()[1] < spinebbox.ymin, \
+        "X-Axis label not below the spine"
+
+
+@image_comparison(['black_axes.png'])
+def test_spines_black_axes():
+    # GitHub #18804
+    plt.rcParams["savefig.pad_inches"] = 0
+    plt.rcParams["savefig.bbox"] = 'tight'
+    fig = plt.figure(0, figsize=(4, 4))
+    ax = fig.add_axes((0, 0, 1, 1))
+    ax.set_xticklabels([])
+    ax.set_yticklabels([])
+    ax.set_xticks([])
+    ax.set_yticks([])
+    ax.set_facecolor((0, 0, 0))
diff --git a/lib/python3.10/site-packages/matplotlib/tests/test_streamplot.py b/lib/python3.10/site-packages/matplotlib/tests/test_streamplot.py
new file mode 100644
index 0000000000000000000000000000000000000000..92e72c5baeca1d8f6212310d9f0b5b98beb39f82
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/tests/test_streamplot.py
@@ -0,0 +1,169 @@
+import numpy as np
+from numpy.testing import assert_array_almost_equal
+import pytest
+import matplotlib.pyplot as plt
+from matplotlib.testing.decorators import image_comparison
+import matplotlib.transforms as mtransforms
+
+
+def velocity_field():
+    Y, X = np.mgrid[-3:3:100j, -3:3:200j]
+    U = -1 - X**2 + Y
+    V = 1 + X - Y**2
+    return X, Y, U, V
+
+
+def swirl_velocity_field():
+    x = np.linspace(-3., 3., 200)
+    y = np.linspace(-3., 3., 100)
+    X, Y = np.meshgrid(x, y)
+    a = 0.1
+    U = np.cos(a) * (-Y) - np.sin(a) * X
+    V = np.sin(a) * (-Y) + np.cos(a) * X
+    return x, y, U, V
+
+
+@image_comparison(['streamplot_startpoints'], remove_text=True, style='mpl20',
+                  extensions=['png'])
+def test_startpoints():
+    X, Y, U, V = velocity_field()
+    start_x, start_y = np.meshgrid(np.linspace(X.min(), X.max(), 5),
+                                   np.linspace(Y.min(), Y.max(), 5))
+    start_points = np.column_stack([start_x.ravel(), start_y.ravel()])
+    plt.streamplot(X, Y, U, V, start_points=start_points)
+    plt.plot(start_x, start_y, 'ok')
+
+
+@image_comparison(['streamplot_colormap.png'], remove_text=True, style='mpl20',
+                  tol=0.022)
+def test_colormap():
+    X, Y, U, V = velocity_field()
+    plt.streamplot(X, Y, U, V, color=U, density=0.6, linewidth=2,
+                   cmap=plt.cm.autumn)
+    plt.colorbar()
+
+
+@image_comparison(['streamplot_linewidth'], remove_text=True, style='mpl20',
+                  tol=0.004)
+def test_linewidth():
+    X, Y, U, V = velocity_field()
+    speed = np.hypot(U, V)
+    lw = 5 * speed / speed.max()
+    ax = plt.figure().subplots()
+    ax.streamplot(X, Y, U, V, density=[0.5, 1], color='k', linewidth=lw)
+
+
+@image_comparison(['streamplot_masks_and_nans.png'],
+                  remove_text=True, style='mpl20')
+def test_masks_and_nans():
+    X, Y, U, V = velocity_field()
+    mask = np.zeros(U.shape, dtype=bool)
+    mask[40:60, 80:120] = 1
+    U[:20, :40] = np.nan
+    U = np.ma.array(U, mask=mask)
+    ax = plt.figure().subplots()
+    with np.errstate(invalid='ignore'):
+        ax.streamplot(X, Y, U, V, color=U, cmap=plt.cm.Blues)
+
+
+@image_comparison(['streamplot_maxlength.png'],
+                  remove_text=True, style='mpl20', tol=0.302)
+def test_maxlength():
+    x, y, U, V = swirl_velocity_field()
+    ax = plt.figure().subplots()
+    ax.streamplot(x, y, U, V, maxlength=10., start_points=[[0., 1.5]],
+                  linewidth=2, density=2)
+    assert ax.get_xlim()[-1] == ax.get_ylim()[-1] == 3
+    # Compatibility for old test image
+    ax.set(xlim=(None, 3.2555988021882305), ylim=(None, 3.078326760195413))
+
+
+@image_comparison(['streamplot_maxlength_no_broken.png'],
+                  remove_text=True, style='mpl20', tol=0.302)
+def test_maxlength_no_broken():
+    x, y, U, V = swirl_velocity_field()
+    ax = plt.figure().subplots()
+    ax.streamplot(x, y, U, V, maxlength=10., start_points=[[0., 1.5]],
+                  linewidth=2, density=2, broken_streamlines=False)
+    assert ax.get_xlim()[-1] == ax.get_ylim()[-1] == 3
+    # Compatibility for old test image
+    ax.set(xlim=(None, 3.2555988021882305), ylim=(None, 3.078326760195413))
+
+
+@image_comparison(['streamplot_direction.png'],
+                  remove_text=True, style='mpl20', tol=0.073)
+def test_direction():
+    x, y, U, V = swirl_velocity_field()
+    plt.streamplot(x, y, U, V, integration_direction='backward',
+                   maxlength=1.5, start_points=[[1.5, 0.]],
+                   linewidth=2, density=2)
+
+
+def test_streamplot_limits():
+    ax = plt.axes()
+    x = np.linspace(-5, 10, 20)
+    y = np.linspace(-2, 4, 10)
+    y, x = np.meshgrid(y, x)
+    trans = mtransforms.Affine2D().translate(25, 32) + ax.transData
+    plt.barbs(x, y, np.sin(x), np.cos(y), transform=trans)
+    # The calculated bounds are approximately the bounds of the original data,
+    # this is because the entire path is taken into account when updating the
+    # datalim.
+    assert_array_almost_equal(ax.dataLim.bounds, (20, 30, 15, 6),
+                              decimal=1)
+
+
+def test_streamplot_grid():
+    u = np.ones((2, 2))
+    v = np.zeros((2, 2))
+
+    # Test for same rows and columns
+    x = np.array([[10, 20], [10, 30]])
+    y = np.array([[10, 10], [20, 20]])
+
+    with pytest.raises(ValueError, match="The rows of 'x' must be equal"):
+        plt.streamplot(x, y, u, v)
+
+    x = np.array([[10, 20], [10, 20]])
+    y = np.array([[10, 10], [20, 30]])
+
+    with pytest.raises(ValueError, match="The columns of 'y' must be equal"):
+        plt.streamplot(x, y, u, v)
+
+    x = np.array([[10, 20], [10, 20]])
+    y = np.array([[10, 10], [20, 20]])
+    plt.streamplot(x, y, u, v)
+
+    # Test for maximum dimensions
+    x = np.array([0, 10])
+    y = np.array([[[0, 10]]])
+
+    with pytest.raises(ValueError, match="'y' can have at maximum "
+                                         "2 dimensions"):
+        plt.streamplot(x, y, u, v)
+
+    # Test for equal spacing
+    u = np.ones((3, 3))
+    v = np.zeros((3, 3))
+    x = np.array([0, 10, 20])
+    y = np.array([0, 10, 30])
+
+    with pytest.raises(ValueError, match="'y' values must be equally spaced"):
+        plt.streamplot(x, y, u, v)
+
+    # Test for strictly increasing
+    x = np.array([0, 20, 40])
+    y = np.array([0, 20, 10])
+
+    with pytest.raises(ValueError, match="'y' must be strictly increasing"):
+        plt.streamplot(x, y, u, v)
+
+
+def test_streamplot_inputs():  # test no exception occurs.
+    # fully-masked
+    plt.streamplot(np.arange(3), np.arange(3),
+                   np.full((3, 3), np.nan), np.full((3, 3), np.nan),
+                   color=np.random.rand(3, 3))
+    # array-likes
+    plt.streamplot(range(3), range(3),
+                   np.random.rand(3, 3), np.random.rand(3, 3))
diff --git a/lib/python3.10/site-packages/matplotlib/tests/test_style.py b/lib/python3.10/site-packages/matplotlib/tests/test_style.py
new file mode 100644
index 0000000000000000000000000000000000000000..be038965e33da3a0646b5a330a7247e51488fb16
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/tests/test_style.py
@@ -0,0 +1,197 @@
+from contextlib import contextmanager
+from pathlib import Path
+from tempfile import TemporaryDirectory
+import sys
+
+import numpy as np
+import pytest
+
+import matplotlib as mpl
+from matplotlib import pyplot as plt, style
+from matplotlib.style.core import USER_LIBRARY_PATHS, STYLE_EXTENSION
+
+
+PARAM = 'image.cmap'
+VALUE = 'pink'
+DUMMY_SETTINGS = {PARAM: VALUE}
+
+
+@contextmanager
+def temp_style(style_name, settings=None):
+    """Context manager to create a style sheet in a temporary directory."""
+    if not settings:
+        settings = DUMMY_SETTINGS
+    temp_file = f'{style_name}.{STYLE_EXTENSION}'
+    try:
+        with TemporaryDirectory() as tmpdir:
+            # Write style settings to file in the tmpdir.
+            Path(tmpdir, temp_file).write_text(
+                "\n".join(f"{k}: {v}" for k, v in settings.items()),
+                encoding="utf-8")
+            # Add tmpdir to style path and reload so we can access this style.
+            USER_LIBRARY_PATHS.append(tmpdir)
+            style.reload_library()
+            yield
+    finally:
+        style.reload_library()
+
+
+def test_invalid_rc_warning_includes_filename(caplog):
+    SETTINGS = {'foo': 'bar'}
+    basename = 'basename'
+    with temp_style(basename, SETTINGS):
+        # style.reload_library() in temp_style() triggers the warning
+        pass
+    assert (len(caplog.records) == 1
+            and basename in caplog.records[0].getMessage())
+
+
+def test_available():
+    with temp_style('_test_', DUMMY_SETTINGS):
+        assert '_test_' in style.available
+
+
+def test_use():
+    mpl.rcParams[PARAM] = 'gray'
+    with temp_style('test', DUMMY_SETTINGS):
+        with style.context('test'):
+            assert mpl.rcParams[PARAM] == VALUE
+
+
+def test_use_url(tmp_path):
+    path = tmp_path / 'file'
+    path.write_text('axes.facecolor: adeade', encoding='utf-8')
+    with temp_style('test', DUMMY_SETTINGS):
+        url = ('file:'
+               + ('///' if sys.platform == 'win32' else '')
+               + path.resolve().as_posix())
+        with style.context(url):
+            assert mpl.rcParams['axes.facecolor'] == "#adeade"
+
+
+def test_single_path(tmp_path):
+    mpl.rcParams[PARAM] = 'gray'
+    path = tmp_path / f'text.{STYLE_EXTENSION}'
+    path.write_text(f'{PARAM} : {VALUE}', encoding='utf-8')
+    with style.context(path):
+        assert mpl.rcParams[PARAM] == VALUE
+    assert mpl.rcParams[PARAM] == 'gray'
+
+
+def test_context():
+    mpl.rcParams[PARAM] = 'gray'
+    with temp_style('test', DUMMY_SETTINGS):
+        with style.context('test'):
+            assert mpl.rcParams[PARAM] == VALUE
+    # Check that this value is reset after the exiting the context.
+    assert mpl.rcParams[PARAM] == 'gray'
+
+
+def test_context_with_dict():
+    original_value = 'gray'
+    other_value = 'blue'
+    mpl.rcParams[PARAM] = original_value
+    with style.context({PARAM: other_value}):
+        assert mpl.rcParams[PARAM] == other_value
+    assert mpl.rcParams[PARAM] == original_value
+
+
+def test_context_with_dict_after_namedstyle():
+    # Test dict after style name where dict modifies the same parameter.
+    original_value = 'gray'
+    other_value = 'blue'
+    mpl.rcParams[PARAM] = original_value
+    with temp_style('test', DUMMY_SETTINGS):
+        with style.context(['test', {PARAM: other_value}]):
+            assert mpl.rcParams[PARAM] == other_value
+    assert mpl.rcParams[PARAM] == original_value
+
+
+def test_context_with_dict_before_namedstyle():
+    # Test dict before style name where dict modifies the same parameter.
+    original_value = 'gray'
+    other_value = 'blue'
+    mpl.rcParams[PARAM] = original_value
+    with temp_style('test', DUMMY_SETTINGS):
+        with style.context([{PARAM: other_value}, 'test']):
+            assert mpl.rcParams[PARAM] == VALUE
+    assert mpl.rcParams[PARAM] == original_value
+
+
+def test_context_with_union_of_dict_and_namedstyle():
+    # Test dict after style name where dict modifies the a different parameter.
+    original_value = 'gray'
+    other_param = 'text.usetex'
+    other_value = True
+    d = {other_param: other_value}
+    mpl.rcParams[PARAM] = original_value
+    mpl.rcParams[other_param] = (not other_value)
+    with temp_style('test', DUMMY_SETTINGS):
+        with style.context(['test', d]):
+            assert mpl.rcParams[PARAM] == VALUE
+            assert mpl.rcParams[other_param] == other_value
+    assert mpl.rcParams[PARAM] == original_value
+    assert mpl.rcParams[other_param] == (not other_value)
+
+
+def test_context_with_badparam():
+    original_value = 'gray'
+    other_value = 'blue'
+    with style.context({PARAM: other_value}):
+        assert mpl.rcParams[PARAM] == other_value
+        x = style.context({PARAM: original_value, 'badparam': None})
+        with pytest.raises(KeyError):
+            with x:
+                pass
+        assert mpl.rcParams[PARAM] == other_value
+
+
+@pytest.mark.parametrize('equiv_styles',
+                         [('mpl20', 'default'),
+                          ('mpl15', 'classic')],
+                         ids=['mpl20', 'mpl15'])
+def test_alias(equiv_styles):
+    rc_dicts = []
+    for sty in equiv_styles:
+        with style.context(sty):
+            rc_dicts.append(mpl.rcParams.copy())
+
+    rc_base = rc_dicts[0]
+    for nm, rc in zip(equiv_styles[1:], rc_dicts[1:]):
+        assert rc_base == rc
+
+
+def test_xkcd_no_cm():
+    assert mpl.rcParams["path.sketch"] is None
+    plt.xkcd()
+    assert mpl.rcParams["path.sketch"] == (1, 100, 2)
+    np.testing.break_cycles()
+    assert mpl.rcParams["path.sketch"] == (1, 100, 2)
+
+
+def test_xkcd_cm():
+    assert mpl.rcParams["path.sketch"] is None
+    with plt.xkcd():
+        assert mpl.rcParams["path.sketch"] == (1, 100, 2)
+    assert mpl.rcParams["path.sketch"] is None
+
+
+def test_up_to_date_blacklist():
+    assert mpl.style.core.STYLE_BLACKLIST <= {*mpl.rcsetup._validators}
+
+
+def test_style_from_module(tmp_path, monkeypatch):
+    monkeypatch.syspath_prepend(tmp_path)
+    monkeypatch.chdir(tmp_path)
+    pkg_path = tmp_path / "mpl_test_style_pkg"
+    pkg_path.mkdir()
+    (pkg_path / "test_style.mplstyle").write_text(
+        "lines.linewidth: 42", encoding="utf-8")
+    pkg_path.with_suffix(".mplstyle").write_text(
+        "lines.linewidth: 84", encoding="utf-8")
+    mpl.style.use("mpl_test_style_pkg.test_style")
+    assert mpl.rcParams["lines.linewidth"] == 42
+    mpl.style.use("mpl_test_style_pkg.mplstyle")
+    assert mpl.rcParams["lines.linewidth"] == 84
+    mpl.style.use("./mpl_test_style_pkg.mplstyle")
+    assert mpl.rcParams["lines.linewidth"] == 84
diff --git a/lib/python3.10/site-packages/matplotlib/tests/test_subplots.py b/lib/python3.10/site-packages/matplotlib/tests/test_subplots.py
new file mode 100644
index 0000000000000000000000000000000000000000..704ff6e1bd3f0f87a7374be7cd3b6c55e7a0ca27
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/tests/test_subplots.py
@@ -0,0 +1,287 @@
+import itertools
+import platform
+
+import numpy as np
+import pytest
+
+from matplotlib.axes import Axes, SubplotBase
+import matplotlib.pyplot as plt
+from matplotlib.testing.decorators import check_figures_equal, image_comparison
+
+
+def check_shared(axs, x_shared, y_shared):
+    """
+    x_shared and y_shared are n x n boolean matrices; entry (i, j) indicates
+    whether the x (or y) axes of subplots i and j should be shared.
+    """
+    for (i1, ax1), (i2, ax2), (i3, (name, shared)) in itertools.product(
+            enumerate(axs),
+            enumerate(axs),
+            enumerate(zip("xy", [x_shared, y_shared]))):
+        if i2 <= i1:
+            continue
+        assert axs[0]._shared_axes[name].joined(ax1, ax2) == shared[i1, i2], \
+            "axes %i and %i incorrectly %ssharing %s axis" % (
+                i1, i2, "not " if shared[i1, i2] else "", name)
+
+
+def check_ticklabel_visible(axs, x_visible, y_visible):
+    """Check that the x and y ticklabel visibility is as specified."""
+    for i, (ax, vx, vy) in enumerate(zip(axs, x_visible, y_visible)):
+        for l in ax.get_xticklabels() + [ax.xaxis.offsetText]:
+            assert l.get_visible() == vx, \
+                    f"Visibility of x axis #{i} is incorrectly {vx}"
+        for l in ax.get_yticklabels() + [ax.yaxis.offsetText]:
+            assert l.get_visible() == vy, \
+                    f"Visibility of y axis #{i} is incorrectly {vy}"
+        # axis label "visibility" is toggled by label_outer by resetting the
+        # label to empty, but it can also be empty to start with.
+        if not vx:
+            assert ax.get_xlabel() == ""
+        if not vy:
+            assert ax.get_ylabel() == ""
+
+
+def check_tick1_visible(axs, x_visible, y_visible):
+    """
+    Check that the x and y tick visibility is as specified.
+
+    Note: This only checks the tick1line, i.e. bottom / left ticks.
+    """
+    for ax, visible, in zip(axs, x_visible):
+        for tick in ax.xaxis.get_major_ticks():
+            assert tick.tick1line.get_visible() == visible
+    for ax, y_visible, in zip(axs, y_visible):
+        for tick in ax.yaxis.get_major_ticks():
+            assert tick.tick1line.get_visible() == visible
+
+
+def test_shared():
+    rdim = (4, 4, 2)
+    share = {
+            'all': np.ones(rdim[:2], dtype=bool),
+            'none': np.zeros(rdim[:2], dtype=bool),
+            'row': np.array([
+                [False, True, False, False],
+                [True, False, False, False],
+                [False, False, False, True],
+                [False, False, True, False]]),
+            'col': np.array([
+                [False, False, True, False],
+                [False, False, False, True],
+                [True, False, False, False],
+                [False, True, False, False]]),
+            }
+    visible = {
+            'x': {
+                'all': [False, False, True, True],
+                'col': [False, False, True, True],
+                'row': [True] * 4,
+                'none': [True] * 4,
+                False: [True] * 4,
+                True: [False, False, True, True],
+                },
+            'y': {
+                'all': [True, False, True, False],
+                'col': [True] * 4,
+                'row': [True, False, True, False],
+                'none': [True] * 4,
+                False: [True] * 4,
+                True: [True, False, True, False],
+                },
+            }
+    share[False] = share['none']
+    share[True] = share['all']
+
+    # test default
+    f, ((a1, a2), (a3, a4)) = plt.subplots(2, 2)
+    axs = [a1, a2, a3, a4]
+    check_shared(axs, share['none'], share['none'])
+    plt.close(f)
+
+    # test all option combinations
+    ops = [False, True, 'all', 'none', 'row', 'col', 0, 1]
+    for xo in ops:
+        for yo in ops:
+            f, ((a1, a2), (a3, a4)) = plt.subplots(2, 2, sharex=xo, sharey=yo)
+            axs = [a1, a2, a3, a4]
+            check_shared(axs, share[xo], share[yo])
+            check_ticklabel_visible(axs, visible['x'][xo], visible['y'][yo])
+            plt.close(f)
+
+
+@pytest.mark.parametrize('remove_ticks', [True, False])
+def test_label_outer(remove_ticks):
+    f, axs = plt.subplots(2, 2, sharex=True, sharey=True)
+    for ax in axs.flat:
+        ax.set(xlabel="foo", ylabel="bar")
+        ax.label_outer(remove_inner_ticks=remove_ticks)
+    check_ticklabel_visible(
+        axs.flat, [False, False, True, True], [True, False, True, False])
+    if remove_ticks:
+        check_tick1_visible(
+            axs.flat, [False, False, True, True], [True, False, True, False])
+    else:
+        check_tick1_visible(
+            axs.flat, [True, True, True, True], [True, True, True, True])
+
+
+def test_label_outer_span():
+    fig = plt.figure()
+    gs = fig.add_gridspec(3, 3)
+    # +---+---+---+
+    # |   1   |   |
+    # +---+---+---+
+    # |   |   | 3 |
+    # + 2 +---+---+
+    # |   | 4 |   |
+    # +---+---+---+
+    a1 = fig.add_subplot(gs[0, 0:2])
+    a2 = fig.add_subplot(gs[1:3, 0])
+    a3 = fig.add_subplot(gs[1, 2])
+    a4 = fig.add_subplot(gs[2, 1])
+    for ax in fig.axes:
+        ax.label_outer()
+    check_ticklabel_visible(
+        fig.axes, [False, True, False, True], [True, True, False, False])
+
+
+def test_label_outer_non_gridspec():
+    ax = plt.axes((0, 0, 1, 1))
+    ax.label_outer()  # Does nothing.
+    check_ticklabel_visible([ax], [True], [True])
+
+
+def test_shared_and_moved():
+    # test if sharey is on, but then tick_left is called that labels don't
+    # re-appear.  Seaborn does this just to be sure yaxis is on left...
+    f, (a1, a2) = plt.subplots(1, 2, sharey=True)
+    check_ticklabel_visible([a2], [True], [False])
+    a2.yaxis.tick_left()
+    check_ticklabel_visible([a2], [True], [False])
+
+    f, (a1, a2) = plt.subplots(2, 1, sharex=True)
+    check_ticklabel_visible([a1], [False], [True])
+    a2.xaxis.tick_bottom()
+    check_ticklabel_visible([a1], [False], [True])
+
+
+def test_exceptions():
+    # TODO should this test more options?
+    with pytest.raises(ValueError):
+        plt.subplots(2, 2, sharex='blah')
+    with pytest.raises(ValueError):
+        plt.subplots(2, 2, sharey='blah')
+
+
+@image_comparison(['subplots_offset_text.png'],
+                  tol=0 if platform.machine() == 'x86_64' else 0.028)
+def test_subplots_offsettext():
+    x = np.arange(0, 1e10, 1e9)
+    y = np.arange(0, 100, 10)+1e4
+    fig, axs = plt.subplots(2, 2, sharex='col', sharey='all')
+    axs[0, 0].plot(x, x)
+    axs[1, 0].plot(x, x)
+    axs[0, 1].plot(y, x)
+    axs[1, 1].plot(y, x)
+
+
+@pytest.mark.parametrize("top", [True, False])
+@pytest.mark.parametrize("bottom", [True, False])
+@pytest.mark.parametrize("left", [True, False])
+@pytest.mark.parametrize("right", [True, False])
+def test_subplots_hide_ticklabels(top, bottom, left, right):
+    # Ideally, we would also test offset-text visibility (and remove
+    # test_subplots_offsettext), but currently, setting rcParams fails to move
+    # the offset texts as well.
+    with plt.rc_context({"xtick.labeltop": top, "xtick.labelbottom": bottom,
+                         "ytick.labelleft": left, "ytick.labelright": right}):
+        axs = plt.figure().subplots(3, 3, sharex=True, sharey=True)
+    for (i, j), ax in np.ndenumerate(axs):
+        xtop = ax.xaxis._major_tick_kw["label2On"]
+        xbottom = ax.xaxis._major_tick_kw["label1On"]
+        yleft = ax.yaxis._major_tick_kw["label1On"]
+        yright = ax.yaxis._major_tick_kw["label2On"]
+        assert xtop == (top and i == 0)
+        assert xbottom == (bottom and i == 2)
+        assert yleft == (left and j == 0)
+        assert yright == (right and j == 2)
+
+
+@pytest.mark.parametrize("xlabel_position", ["bottom", "top"])
+@pytest.mark.parametrize("ylabel_position", ["left", "right"])
+def test_subplots_hide_axislabels(xlabel_position, ylabel_position):
+    axs = plt.figure().subplots(3, 3, sharex=True, sharey=True)
+    for (i, j), ax in np.ndenumerate(axs):
+        ax.set(xlabel="foo", ylabel="bar")
+        ax.xaxis.set_label_position(xlabel_position)
+        ax.yaxis.set_label_position(ylabel_position)
+        ax.label_outer()
+        assert bool(ax.get_xlabel()) == (
+            xlabel_position == "bottom" and i == 2
+            or xlabel_position == "top" and i == 0)
+        assert bool(ax.get_ylabel()) == (
+            ylabel_position == "left" and j == 0
+            or ylabel_position == "right" and j == 2)
+
+
+def test_get_gridspec():
+    # ahem, pretty trivial, but...
+    fig, ax = plt.subplots()
+    assert ax.get_subplotspec().get_gridspec() == ax.get_gridspec()
+
+
+def test_dont_mutate_kwargs():
+    subplot_kw = {'sharex': 'all'}
+    gridspec_kw = {'width_ratios': [1, 2]}
+    fig, ax = plt.subplots(1, 2, subplot_kw=subplot_kw,
+                           gridspec_kw=gridspec_kw)
+    assert subplot_kw == {'sharex': 'all'}
+    assert gridspec_kw == {'width_ratios': [1, 2]}
+
+
+@pytest.mark.parametrize("width_ratios", [None, [1, 3, 2]])
+@pytest.mark.parametrize("height_ratios", [None, [1, 2]])
+@check_figures_equal(extensions=['png'])
+def test_width_and_height_ratios(fig_test, fig_ref,
+                                 height_ratios, width_ratios):
+    fig_test.subplots(2, 3, height_ratios=height_ratios,
+                      width_ratios=width_ratios)
+    fig_ref.subplots(2, 3, gridspec_kw={
+                     'height_ratios': height_ratios,
+                     'width_ratios': width_ratios})
+
+
+@pytest.mark.parametrize("width_ratios", [None, [1, 3, 2]])
+@pytest.mark.parametrize("height_ratios", [None, [1, 2]])
+@check_figures_equal(extensions=['png'])
+def test_width_and_height_ratios_mosaic(fig_test, fig_ref,
+                                        height_ratios, width_ratios):
+    mosaic_spec = [['A', 'B', 'B'], ['A', 'C', 'D']]
+    fig_test.subplot_mosaic(mosaic_spec, height_ratios=height_ratios,
+                            width_ratios=width_ratios)
+    fig_ref.subplot_mosaic(mosaic_spec, gridspec_kw={
+                           'height_ratios': height_ratios,
+                           'width_ratios': width_ratios})
+
+
+@pytest.mark.parametrize('method,args', [
+    ('subplots', (2, 3)),
+    ('subplot_mosaic', ('abc;def', ))
+    ]
+)
+def test_ratio_overlapping_kws(method, args):
+    with pytest.raises(ValueError, match='height_ratios'):
+        getattr(plt, method)(*args, height_ratios=[1, 2],
+                             gridspec_kw={'height_ratios': [1, 2]})
+    with pytest.raises(ValueError, match='width_ratios'):
+        getattr(plt, method)(*args, width_ratios=[1, 2, 3],
+                             gridspec_kw={'width_ratios': [1, 2, 3]})
+
+
+def test_old_subplot_compat():
+    fig = plt.figure()
+    assert isinstance(fig.add_subplot(), SubplotBase)
+    assert not isinstance(fig.add_axes(rect=[0, 0, 1, 1]), SubplotBase)
+    with pytest.raises(TypeError):
+        Axes(fig, [0, 0, 1, 1], rect=[0, 0, 1, 1])
diff --git a/lib/python3.10/site-packages/matplotlib/tests/test_table.py b/lib/python3.10/site-packages/matplotlib/tests/test_table.py
new file mode 100644
index 0000000000000000000000000000000000000000..29d1944323fc3e6141b0cc2bac229ae4a82bec35
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/tests/test_table.py
@@ -0,0 +1,283 @@
+import datetime
+from unittest.mock import Mock
+
+import numpy as np
+
+import matplotlib.pyplot as plt
+from matplotlib.path import Path
+from matplotlib.table import CustomCell, Table
+from matplotlib.testing.decorators import image_comparison, check_figures_equal
+from matplotlib.transforms import Bbox
+import matplotlib.units as munits
+
+
+def test_non_square():
+    # Check that creating a non-square table works
+    cellcolors = ['b', 'r']
+    plt.table(cellColours=cellcolors)
+
+
+@image_comparison(['table_zorder.png'], remove_text=True)
+def test_zorder():
+    data = [[66386, 174296],
+            [58230, 381139]]
+
+    colLabels = ('Freeze', 'Wind')
+    rowLabels = ['%d year' % x for x in (100, 50)]
+
+    cellText = []
+    yoff = np.zeros(len(colLabels))
+    for row in reversed(data):
+        yoff += row
+        cellText.append(['%1.1f' % (x/1000.0) for x in yoff])
+
+    t = np.linspace(0, 2*np.pi, 100)
+    plt.plot(t, np.cos(t), lw=4, zorder=2)
+
+    plt.table(cellText=cellText,
+              rowLabels=rowLabels,
+              colLabels=colLabels,
+              loc='center',
+              zorder=-2,
+              )
+
+    plt.table(cellText=cellText,
+              rowLabels=rowLabels,
+              colLabels=colLabels,
+              loc='upper center',
+              zorder=4,
+              )
+    plt.yticks([])
+
+
+@image_comparison(['table_labels.png'])
+def test_label_colours():
+    dim = 3
+
+    c = np.linspace(0, 1, dim)
+    colours = plt.cm.RdYlGn(c)
+    cellText = [['1'] * dim] * dim
+
+    fig = plt.figure()
+
+    ax1 = fig.add_subplot(4, 1, 1)
+    ax1.axis('off')
+    ax1.table(cellText=cellText,
+              rowColours=colours,
+              loc='best')
+
+    ax2 = fig.add_subplot(4, 1, 2)
+    ax2.axis('off')
+    ax2.table(cellText=cellText,
+              rowColours=colours,
+              rowLabels=['Header'] * dim,
+              loc='best')
+
+    ax3 = fig.add_subplot(4, 1, 3)
+    ax3.axis('off')
+    ax3.table(cellText=cellText,
+              colColours=colours,
+              loc='best')
+
+    ax4 = fig.add_subplot(4, 1, 4)
+    ax4.axis('off')
+    ax4.table(cellText=cellText,
+              colColours=colours,
+              colLabels=['Header'] * dim,
+              loc='best')
+
+
+@image_comparison(['table_cell_manipulation.png'], style='mpl20')
+def test_diff_cell_table(text_placeholders):
+    cells = ('horizontal', 'vertical', 'open', 'closed', 'T', 'R', 'B', 'L')
+    cellText = [['1'] * len(cells)] * 2
+    colWidths = [0.1] * len(cells)
+
+    _, axs = plt.subplots(nrows=len(cells), figsize=(4, len(cells)+1), layout='tight')
+    for ax, cell in zip(axs, cells):
+        ax.table(
+                colWidths=colWidths,
+                cellText=cellText,
+                loc='center',
+                edges=cell,
+                )
+        ax.axis('off')
+
+
+def test_customcell():
+    types = ('horizontal', 'vertical', 'open', 'closed', 'T', 'R', 'B', 'L')
+    codes = (
+        (Path.MOVETO, Path.LINETO, Path.MOVETO, Path.LINETO, Path.MOVETO),
+        (Path.MOVETO, Path.MOVETO, Path.LINETO, Path.MOVETO, Path.LINETO),
+        (Path.MOVETO, Path.MOVETO, Path.MOVETO, Path.MOVETO, Path.MOVETO),
+        (Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY),
+        (Path.MOVETO, Path.MOVETO, Path.MOVETO, Path.LINETO, Path.MOVETO),
+        (Path.MOVETO, Path.MOVETO, Path.LINETO, Path.MOVETO, Path.MOVETO),
+        (Path.MOVETO, Path.LINETO, Path.MOVETO, Path.MOVETO, Path.MOVETO),
+        (Path.MOVETO, Path.MOVETO, Path.MOVETO, Path.MOVETO, Path.LINETO),
+        )
+
+    for t, c in zip(types, codes):
+        cell = CustomCell((0, 0), visible_edges=t, width=1, height=1)
+        code = tuple(s for _, s in cell.get_path().iter_segments())
+        assert c == code
+
+
+@image_comparison(['table_auto_column.png'])
+def test_auto_column():
+    fig, (ax1, ax2, ax3, ax4) = plt.subplots(4, 1)
+
+    # iterable list input
+    ax1.axis('off')
+    tb1 = ax1.table(
+        cellText=[['Fit Text', 2],
+                  ['very long long text, Longer text than default', 1]],
+        rowLabels=["A", "B"],
+        colLabels=["Col1", "Col2"],
+        loc="center")
+    tb1.auto_set_font_size(False)
+    tb1.set_fontsize(12)
+    tb1.auto_set_column_width([-1, 0, 1])
+
+    # iterable tuple input
+    ax2.axis('off')
+    tb2 = ax2.table(
+        cellText=[['Fit Text', 2],
+                  ['very long long text, Longer text than default', 1]],
+        rowLabels=["A", "B"],
+        colLabels=["Col1", "Col2"],
+        loc="center")
+    tb2.auto_set_font_size(False)
+    tb2.set_fontsize(12)
+    tb2.auto_set_column_width((-1, 0, 1))
+
+    # 3 single inputs
+    ax3.axis('off')
+    tb3 = ax3.table(
+        cellText=[['Fit Text', 2],
+                  ['very long long text, Longer text than default', 1]],
+        rowLabels=["A", "B"],
+        colLabels=["Col1", "Col2"],
+        loc="center")
+    tb3.auto_set_font_size(False)
+    tb3.set_fontsize(12)
+    tb3.auto_set_column_width(-1)
+    tb3.auto_set_column_width(0)
+    tb3.auto_set_column_width(1)
+
+    # 4 this used to test non-integer iterable input, which did nothing, but only
+    # remains to avoid re-generating the test image.
+    ax4.axis('off')
+    tb4 = ax4.table(
+        cellText=[['Fit Text', 2],
+                  ['very long long text, Longer text than default', 1]],
+        rowLabels=["A", "B"],
+        colLabels=["Col1", "Col2"],
+        loc="center")
+    tb4.auto_set_font_size(False)
+    tb4.set_fontsize(12)
+
+
+def test_table_cells():
+    fig, ax = plt.subplots()
+    table = Table(ax)
+
+    cell = table.add_cell(1, 2, 1, 1)
+    assert isinstance(cell, CustomCell)
+    assert cell is table[1, 2]
+
+    cell2 = CustomCell((0, 0), 1, 2, visible_edges=None)
+    table[2, 1] = cell2
+    assert table[2, 1] is cell2
+
+    # make sure getitem support has not broken
+    # properties and setp
+    table.properties()
+    plt.setp(table)
+
+
+@check_figures_equal(extensions=["png"])
+def test_table_bbox(fig_test, fig_ref):
+    data = [[2, 3],
+            [4, 5]]
+
+    col_labels = ('Foo', 'Bar')
+    row_labels = ('Ada', 'Bob')
+
+    cell_text = [[f"{x}" for x in row] for row in data]
+
+    ax_list = fig_test.subplots()
+    ax_list.table(cellText=cell_text,
+                  rowLabels=row_labels,
+                  colLabels=col_labels,
+                  loc='center',
+                  bbox=[0.1, 0.2, 0.8, 0.6]
+                  )
+
+    ax_bbox = fig_ref.subplots()
+    ax_bbox.table(cellText=cell_text,
+                  rowLabels=row_labels,
+                  colLabels=col_labels,
+                  loc='center',
+                  bbox=Bbox.from_extents(0.1, 0.2, 0.9, 0.8)
+                  )
+
+
+@check_figures_equal(extensions=['png'])
+def test_table_unit(fig_test, fig_ref):
+    # test that table doesn't participate in unit machinery, instead uses repr/str
+
+    class FakeUnit:
+        def __init__(self, thing):
+            pass
+        def __repr__(self):
+            return "Hello"
+
+    fake_convertor = munits.ConversionInterface()
+    # v, u, a = value, unit, axis
+    fake_convertor.convert = Mock(side_effect=lambda v, u, a: 0)
+    # not used, here for completeness
+    fake_convertor.default_units = Mock(side_effect=lambda v, a: None)
+    fake_convertor.axisinfo = Mock(side_effect=lambda u, a: munits.AxisInfo())
+
+    munits.registry[FakeUnit] = fake_convertor
+
+    data = [[FakeUnit("yellow"), FakeUnit(42)],
+            [FakeUnit(datetime.datetime(1968, 8, 1)), FakeUnit(True)]]
+
+    fig_test.subplots().table(data)
+    fig_ref.subplots().table([["Hello", "Hello"], ["Hello", "Hello"]])
+    fig_test.canvas.draw()
+    fake_convertor.convert.assert_not_called()
+
+    munits.registry.pop(FakeUnit)
+    assert not munits.registry.get_converter(FakeUnit)
+
+
+def test_table_dataframe(pd):
+    # Test if Pandas Data Frame can be passed in cellText
+
+    data = {
+        'Letter': ['A', 'B', 'C'],
+        'Number': [100, 200, 300]
+    }
+
+    df = pd.DataFrame(data)
+    fig, ax = plt.subplots()
+    table = ax.table(df, loc='center')
+
+    for r, (index, row) in enumerate(df.iterrows()):
+        for c, col in enumerate(df.columns if r == 0 else row.values):
+            assert table[r if r == 0 else r+1, c].get_text().get_text() == str(col)
+
+
+def test_table_fontsize():
+    # Test that the passed fontsize propagates to cells
+    tableData = [['a', 1], ['b', 2]]
+    fig, ax = plt.subplots()
+    test_fontsize = 20
+    t = ax.table(cellText=tableData, loc='top', fontsize=test_fontsize)
+    cell_fontsize = t[(0, 0)].get_fontsize()
+    assert cell_fontsize == test_fontsize, f"Actual:{test_fontsize},got:{cell_fontsize}"
+    cell_fontsize = t[(1, 1)].get_fontsize()
+    assert cell_fontsize == test_fontsize, f"Actual:{test_fontsize},got:{cell_fontsize}"
diff --git a/lib/python3.10/site-packages/matplotlib/tests/test_testing.py b/lib/python3.10/site-packages/matplotlib/tests/test_testing.py
new file mode 100644
index 0000000000000000000000000000000000000000..f13839d6b3b68a6ce7e2f7d21e7ba68088e05f95
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/tests/test_testing.py
@@ -0,0 +1,41 @@
+import warnings
+
+import pytest
+
+import matplotlib.pyplot as plt
+from matplotlib.testing.decorators import check_figures_equal
+
+
+@pytest.mark.xfail(
+    strict=True, reason="testing that warnings fail tests"
+)
+def test_warn_to_fail():
+    warnings.warn("This should fail the test")
+
+
+@pytest.mark.parametrize("a", [1])
+@check_figures_equal(extensions=["png"])
+@pytest.mark.parametrize("b", [1])
+def test_parametrize_with_check_figure_equal(a, fig_ref, b, fig_test):
+    assert a == b
+
+
+def test_wrap_failure():
+    with pytest.raises(ValueError, match="^The decorated function"):
+        @check_figures_equal()
+        def should_fail(test, ref):
+            pass
+
+
+@pytest.mark.xfail(raises=RuntimeError, strict=True,
+                   reason='Test for check_figures_equal test creating '
+                          'new figures')
+@check_figures_equal()
+def test_check_figures_equal_extra_fig(fig_test, fig_ref):
+    plt.figure()
+
+
+@check_figures_equal()
+def test_check_figures_equal_closed_fig(fig_test, fig_ref):
+    fig = plt.figure()
+    plt.close(fig)
diff --git a/lib/python3.10/site-packages/matplotlib/tests/test_texmanager.py b/lib/python3.10/site-packages/matplotlib/tests/test_texmanager.py
new file mode 100644
index 0000000000000000000000000000000000000000..64dcbf46456de679c6c29f104a7e86e6afcd9ac2
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/tests/test_texmanager.py
@@ -0,0 +1,75 @@
+import os
+from pathlib import Path
+import re
+import sys
+
+import pytest
+
+import matplotlib.pyplot as plt
+from matplotlib.testing import subprocess_run_for_testing
+from matplotlib.testing._markers import needs_usetex
+from matplotlib.texmanager import TexManager
+
+
+def test_fontconfig_preamble():
+    """Test that the preamble is included in the source."""
+    plt.rcParams['text.usetex'] = True
+
+    src1 = TexManager()._get_tex_source("", fontsize=12)
+    plt.rcParams['text.latex.preamble'] = '\\usepackage{txfonts}'
+    src2 = TexManager()._get_tex_source("", fontsize=12)
+
+    assert src1 != src2
+
+
+@pytest.mark.parametrize(
+    "rc, preamble, family", [
+        ({"font.family": "sans-serif", "font.sans-serif": "helvetica"},
+         r"\usepackage{helvet}", r"\sffamily"),
+        ({"font.family": "serif", "font.serif": "palatino"},
+         r"\usepackage{mathpazo}", r"\rmfamily"),
+        ({"font.family": "cursive", "font.cursive": "zapf chancery"},
+         r"\usepackage{chancery}", r"\rmfamily"),
+        ({"font.family": "monospace", "font.monospace": "courier"},
+         r"\usepackage{courier}", r"\ttfamily"),
+        ({"font.family": "helvetica"}, r"\usepackage{helvet}", r"\sffamily"),
+        ({"font.family": "palatino"}, r"\usepackage{mathpazo}", r"\rmfamily"),
+        ({"font.family": "zapf chancery"},
+         r"\usepackage{chancery}", r"\rmfamily"),
+        ({"font.family": "courier"}, r"\usepackage{courier}", r"\ttfamily")
+    ])
+def test_font_selection(rc, preamble, family):
+    plt.rcParams.update(rc)
+    tm = TexManager()
+    src = Path(tm.make_tex("hello, world", fontsize=12)).read_text()
+    assert preamble in src
+    assert [*re.findall(r"\\\w+family", src)] == [family]
+
+
+@needs_usetex
+def test_unicode_characters():
+    # Smoke test to see that Unicode characters does not cause issues
+    # See #23019
+    plt.rcParams['text.usetex'] = True
+    fig, ax = plt.subplots()
+    ax.set_ylabel('\\textit{Velocity (\N{DEGREE SIGN}/sec)}')
+    ax.set_xlabel('\N{VULGAR FRACTION ONE QUARTER}Öøæ')
+    fig.canvas.draw()
+
+    # But not all characters.
+    # Should raise RuntimeError, not UnicodeDecodeError
+    with pytest.raises(RuntimeError):
+        ax.set_title('\N{SNOWMAN}')
+        fig.canvas.draw()
+
+
+@needs_usetex
+def test_openin_any_paranoid():
+    completed = subprocess_run_for_testing(
+        [sys.executable, "-c",
+         'import matplotlib.pyplot as plt;'
+         'plt.rcParams.update({"text.usetex": True});'
+         'plt.title("paranoid");'
+         'plt.show(block=False);'],
+        env={**os.environ, 'openin_any': 'p'}, check=True, capture_output=True)
+    assert completed.stderr == ""
diff --git a/lib/python3.10/site-packages/matplotlib/tests/test_text.py b/lib/python3.10/site-packages/matplotlib/tests/test_text.py
new file mode 100644
index 0000000000000000000000000000000000000000..19262202e5c160c32fe1ebda3d4feabb54233616
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/tests/test_text.py
@@ -0,0 +1,1137 @@
+from datetime import datetime
+import io
+import warnings
+
+import numpy as np
+from numpy.testing import assert_almost_equal
+from packaging.version import parse as parse_version
+import pyparsing
+import pytest
+
+import matplotlib as mpl
+from matplotlib.backend_bases import MouseEvent
+from matplotlib.backends.backend_agg import RendererAgg
+from matplotlib.figure import Figure
+from matplotlib.font_manager import FontProperties
+import matplotlib.patches as mpatches
+import matplotlib.pyplot as plt
+from matplotlib.gridspec import GridSpec
+import matplotlib.transforms as mtransforms
+from matplotlib.testing.decorators import check_figures_equal, image_comparison
+from matplotlib.testing._markers import needs_usetex
+from matplotlib.text import Text, Annotation, OffsetFrom
+
+pyparsing_version = parse_version(pyparsing.__version__)
+
+
+@image_comparison(['font_styles'])
+def test_font_styles():
+
+    def find_matplotlib_font(**kw):
+        prop = FontProperties(**kw)
+        path = findfont(prop, directory=mpl.get_data_path())
+        return FontProperties(fname=path)
+
+    from matplotlib.font_manager import FontProperties, findfont
+    warnings.filterwarnings(
+        'ignore',
+        r"findfont: Font family \[u?'Foo'\] not found. Falling back to .",
+        UserWarning,
+        module='matplotlib.font_manager')
+
+    fig, ax = plt.subplots()
+
+    normal_font = find_matplotlib_font(
+        family="sans-serif",
+        style="normal",
+        variant="normal",
+        size=14)
+    a = ax.annotate(
+        "Normal Font",
+        (0.1, 0.1),
+        xycoords='axes fraction',
+        fontproperties=normal_font)
+    assert a.get_fontname() == 'DejaVu Sans'
+    assert a.get_fontstyle() == 'normal'
+    assert a.get_fontvariant() == 'normal'
+    assert a.get_weight() == 'normal'
+    assert a.get_stretch() == 'normal'
+
+    bold_font = find_matplotlib_font(
+        family="Foo",
+        style="normal",
+        variant="normal",
+        weight="bold",
+        stretch=500,
+        size=14)
+    ax.annotate(
+        "Bold Font",
+        (0.1, 0.2),
+        xycoords='axes fraction',
+        fontproperties=bold_font)
+
+    bold_italic_font = find_matplotlib_font(
+        family="sans serif",
+        style="italic",
+        variant="normal",
+        weight=750,
+        stretch=500,
+        size=14)
+    ax.annotate(
+        "Bold Italic Font",
+        (0.1, 0.3),
+        xycoords='axes fraction',
+        fontproperties=bold_italic_font)
+
+    light_font = find_matplotlib_font(
+        family="sans-serif",
+        style="normal",
+        variant="normal",
+        weight=200,
+        stretch=500,
+        size=14)
+    ax.annotate(
+        "Light Font",
+        (0.1, 0.4),
+        xycoords='axes fraction',
+        fontproperties=light_font)
+
+    condensed_font = find_matplotlib_font(
+        family="sans-serif",
+        style="normal",
+        variant="normal",
+        weight=500,
+        stretch=100,
+        size=14)
+    ax.annotate(
+        "Condensed Font",
+        (0.1, 0.5),
+        xycoords='axes fraction',
+        fontproperties=condensed_font)
+
+    ax.set_xticks([])
+    ax.set_yticks([])
+
+
+@image_comparison(['multiline'])
+def test_multiline():
+    plt.figure()
+    ax = plt.subplot(1, 1, 1)
+    ax.set_title("multiline\ntext alignment")
+
+    plt.text(
+        0.2, 0.5, "TpTpTp\n$M$\nTpTpTp", size=20, ha="center", va="top")
+
+    plt.text(
+        0.5, 0.5, "TpTpTp\n$M^{M^{M^{M}}}$\nTpTpTp", size=20,
+        ha="center", va="top")
+
+    plt.text(
+        0.8, 0.5, "TpTpTp\n$M_{q_{q_{q}}}$\nTpTpTp", size=20,
+        ha="center", va="top")
+
+    plt.xlim(0, 1)
+    plt.ylim(0, 0.8)
+
+    ax.set_xticks([])
+    ax.set_yticks([])
+
+
+@image_comparison(['multiline2'], style='mpl20')
+def test_multiline2():
+    # Remove this line when this test image is regenerated.
+    plt.rcParams['text.kerning_factor'] = 6
+
+    fig, ax = plt.subplots()
+
+    ax.set_xlim([0, 1.4])
+    ax.set_ylim([0, 2])
+    ax.axhline(0.5, color='C2', linewidth=0.3)
+    sts = ['Line', '2 Lineg\n 2 Lg', '$\\sum_i x $', 'hi $\\sum_i x $\ntest',
+           'test\n $\\sum_i x $', '$\\sum_i x $\n $\\sum_i x $']
+    renderer = fig.canvas.get_renderer()
+
+    def draw_box(ax, tt):
+        r = mpatches.Rectangle((0, 0), 1, 1, clip_on=False,
+                               transform=ax.transAxes)
+        r.set_bounds(
+            tt.get_window_extent(renderer)
+            .transformed(ax.transAxes.inverted())
+            .bounds)
+        ax.add_patch(r)
+
+    horal = 'left'
+    for nn, st in enumerate(sts):
+        tt = ax.text(0.2 * nn + 0.1, 0.5, st, horizontalalignment=horal,
+                     verticalalignment='bottom')
+        draw_box(ax, tt)
+    ax.text(1.2, 0.5, 'Bottom align', color='C2')
+
+    ax.axhline(1.3, color='C2', linewidth=0.3)
+    for nn, st in enumerate(sts):
+        tt = ax.text(0.2 * nn + 0.1, 1.3, st, horizontalalignment=horal,
+                     verticalalignment='top')
+        draw_box(ax, tt)
+    ax.text(1.2, 1.3, 'Top align', color='C2')
+
+    ax.axhline(1.8, color='C2', linewidth=0.3)
+    for nn, st in enumerate(sts):
+        tt = ax.text(0.2 * nn + 0.1, 1.8, st, horizontalalignment=horal,
+                     verticalalignment='baseline')
+        draw_box(ax, tt)
+    ax.text(1.2, 1.8, 'Baseline align', color='C2')
+
+    ax.axhline(0.1, color='C2', linewidth=0.3)
+    for nn, st in enumerate(sts):
+        tt = ax.text(0.2 * nn + 0.1, 0.1, st, horizontalalignment=horal,
+                     verticalalignment='bottom', rotation=20)
+        draw_box(ax, tt)
+    ax.text(1.2, 0.1, 'Bot align, rot20', color='C2')
+
+
+@image_comparison(['antialiased.png'], style='mpl20')
+def test_antialiasing():
+    mpl.rcParams['text.antialiased'] = False  # Passed arguments should override.
+
+    fig = plt.figure(figsize=(5.25, 0.75))
+    fig.text(0.3, 0.75, "antialiased", horizontalalignment='center',
+             verticalalignment='center', antialiased=True)
+    fig.text(0.3, 0.25, r"$\sqrt{x}$", horizontalalignment='center',
+             verticalalignment='center', antialiased=True)
+
+    mpl.rcParams['text.antialiased'] = True  # Passed arguments should override.
+    fig.text(0.7, 0.75, "not antialiased", horizontalalignment='center',
+             verticalalignment='center', antialiased=False)
+    fig.text(0.7, 0.25, r"$\sqrt{x}$", horizontalalignment='center',
+             verticalalignment='center', antialiased=False)
+
+    mpl.rcParams['text.antialiased'] = False  # Should not affect existing text.
+
+
+def test_afm_kerning():
+    fn = mpl.font_manager.findfont("Helvetica", fontext="afm")
+    with open(fn, 'rb') as fh:
+        afm = mpl._afm.AFM(fh)
+    assert afm.string_width_height('VAVAVAVAVAVA') == (7174.0, 718)
+
+
+@image_comparison(['text_contains.png'])
+def test_contains():
+    fig = plt.figure()
+    ax = plt.axes()
+
+    mevent = MouseEvent('button_press_event', fig.canvas, 0.5, 0.5, 1, None)
+
+    xs = np.linspace(0.25, 0.75, 30)
+    ys = np.linspace(0.25, 0.75, 30)
+    xs, ys = np.meshgrid(xs, ys)
+
+    txt = plt.text(
+        0.5, 0.4, 'hello world', ha='center', fontsize=30, rotation=30)
+    # uncomment to draw the text's bounding box
+    # txt.set_bbox(dict(edgecolor='black', facecolor='none'))
+
+    # draw the text. This is important, as the contains method can only work
+    # when a renderer exists.
+    fig.canvas.draw()
+
+    for x, y in zip(xs.flat, ys.flat):
+        mevent.x, mevent.y = plt.gca().transAxes.transform([x, y])
+        contains, _ = txt.contains(mevent)
+        color = 'yellow' if contains else 'red'
+
+        # capture the viewLim, plot a point, and reset the viewLim
+        vl = ax.viewLim.frozen()
+        ax.plot(x, y, 'o', color=color)
+        ax.viewLim.set(vl)
+
+
+def test_annotation_contains():
+    # Check that Annotation.contains looks at the bboxes of the text and the
+    # arrow separately, not at the joint bbox.
+    fig, ax = plt.subplots()
+    ann = ax.annotate(
+        "hello", xy=(.4, .4), xytext=(.6, .6), arrowprops={"arrowstyle": "->"})
+    fig.canvas.draw()  # Needed for the same reason as in test_contains.
+    event = MouseEvent(
+        "button_press_event", fig.canvas, *ax.transData.transform((.5, .6)))
+    assert ann.contains(event) == (False, {})
+
+
+@pytest.mark.parametrize('err, xycoords, match', (
+    (TypeError, print, "xycoords callable must return a BboxBase or Transform, not a"),
+    (TypeError, [0, 0], r"'xycoords' must be an instance of str, tuple"),
+    (ValueError, "foo", "'foo' is not a valid coordinate"),
+    (ValueError, "foo bar", "'foo bar' is not a valid coordinate"),
+    (ValueError, "offset foo", "xycoords cannot be an offset coordinate"),
+    (ValueError, "axes foo", "'foo' is not a recognized unit"),
+))
+def test_annotate_errors(err, xycoords, match):
+    fig, ax = plt.subplots()
+    with pytest.raises(err, match=match):
+        ax.annotate('xy', (0, 0), xytext=(0.5, 0.5), xycoords=xycoords)
+        fig.canvas.draw()
+
+
+@image_comparison(['titles'])
+def test_titles():
+    # left and right side titles
+    plt.figure()
+    ax = plt.subplot(1, 1, 1)
+    ax.set_title("left title", loc="left")
+    ax.set_title("right title", loc="right")
+    ax.set_xticks([])
+    ax.set_yticks([])
+
+
+@image_comparison(['text_alignment'], style='mpl20')
+def test_alignment():
+    plt.figure()
+    ax = plt.subplot(1, 1, 1)
+
+    x = 0.1
+    for rotation in (0, 30):
+        for alignment in ('top', 'bottom', 'baseline', 'center'):
+            ax.text(
+                x, 0.5, alignment + " Tj", va=alignment, rotation=rotation,
+                bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.5))
+            ax.text(
+                x, 1.0, r'$\sum_{i=0}^{j}$', va=alignment, rotation=rotation)
+            x += 0.1
+
+    ax.plot([0, 1], [0.5, 0.5])
+    ax.plot([0, 1], [1.0, 1.0])
+
+    ax.set_xlim(0, 1)
+    ax.set_ylim(0, 1.5)
+    ax.set_xticks([])
+    ax.set_yticks([])
+
+
+@image_comparison(['axes_titles.png'])
+def test_axes_titles():
+    # Related to issue #3327
+    plt.figure()
+    ax = plt.subplot(1, 1, 1)
+    ax.set_title('center', loc='center', fontsize=20, fontweight=700)
+    ax.set_title('left', loc='left', fontsize=12, fontweight=400)
+    ax.set_title('right', loc='right', fontsize=12, fontweight=400)
+
+
+def test_set_position():
+    fig, ax = plt.subplots()
+
+    # test set_position
+    ann = ax.annotate(
+        'test', (0, 0), xytext=(0, 0), textcoords='figure pixels')
+    fig.canvas.draw()
+
+    init_pos = ann.get_window_extent(fig.canvas.renderer)
+    shift_val = 15
+    ann.set_position((shift_val, shift_val))
+    fig.canvas.draw()
+    post_pos = ann.get_window_extent(fig.canvas.renderer)
+
+    for a, b in zip(init_pos.min, post_pos.min):
+        assert a + shift_val == b
+
+    # test xyann
+    ann = ax.annotate(
+        'test', (0, 0), xytext=(0, 0), textcoords='figure pixels')
+    fig.canvas.draw()
+
+    init_pos = ann.get_window_extent(fig.canvas.renderer)
+    shift_val = 15
+    ann.xyann = (shift_val, shift_val)
+    fig.canvas.draw()
+    post_pos = ann.get_window_extent(fig.canvas.renderer)
+
+    for a, b in zip(init_pos.min, post_pos.min):
+        assert a + shift_val == b
+
+
+def test_char_index_at():
+    fig = plt.figure()
+    text = fig.text(0.1, 0.9, "")
+
+    text.set_text("i")
+    bbox = text.get_window_extent()
+    size_i = bbox.x1 - bbox.x0
+
+    text.set_text("m")
+    bbox = text.get_window_extent()
+    size_m = bbox.x1 - bbox.x0
+
+    text.set_text("iiiimmmm")
+    bbox = text.get_window_extent()
+    origin = bbox.x0
+
+    assert text._char_index_at(origin - size_i) == 0  # left of first char
+    assert text._char_index_at(origin) == 0
+    assert text._char_index_at(origin + 0.499*size_i) == 0
+    assert text._char_index_at(origin + 0.501*size_i) == 1
+    assert text._char_index_at(origin + size_i*3) == 3
+    assert text._char_index_at(origin + size_i*4 + size_m*3) == 7
+    assert text._char_index_at(origin + size_i*4 + size_m*4) == 8
+    assert text._char_index_at(origin + size_i*4 + size_m*10) == 8
+
+
+@pytest.mark.parametrize('text', ['', 'O'], ids=['empty', 'non-empty'])
+def test_non_default_dpi(text):
+    fig, ax = plt.subplots()
+
+    t1 = ax.text(0.5, 0.5, text, ha='left', va='bottom')
+    fig.canvas.draw()
+    dpi = fig.dpi
+
+    bbox1 = t1.get_window_extent()
+    bbox2 = t1.get_window_extent(dpi=dpi * 10)
+    np.testing.assert_allclose(bbox2.get_points(), bbox1.get_points() * 10,
+                               rtol=5e-2)
+    # Text.get_window_extent should not permanently change dpi.
+    assert fig.dpi == dpi
+
+
+def test_get_rotation_string():
+    assert Text(rotation='horizontal').get_rotation() == 0.
+    assert Text(rotation='vertical').get_rotation() == 90.
+
+
+def test_get_rotation_float():
+    for i in [15., 16.70, 77.4]:
+        assert Text(rotation=i).get_rotation() == i
+
+
+def test_get_rotation_int():
+    for i in [67, 16, 41]:
+        assert Text(rotation=i).get_rotation() == float(i)
+
+
+def test_get_rotation_raises():
+    with pytest.raises(ValueError):
+        Text(rotation='hozirontal')
+
+
+def test_get_rotation_none():
+    assert Text(rotation=None).get_rotation() == 0.0
+
+
+def test_get_rotation_mod360():
+    for i, j in zip([360., 377., 720+177.2], [0., 17., 177.2]):
+        assert_almost_equal(Text(rotation=i).get_rotation(), j)
+
+
+@pytest.mark.parametrize("ha", ["center", "right", "left"])
+@pytest.mark.parametrize("va", ["center", "top", "bottom",
+                                "baseline", "center_baseline"])
+def test_null_rotation_with_rotation_mode(ha, va):
+    fig, ax = plt.subplots()
+    kw = dict(rotation=0, va=va, ha=ha)
+    t0 = ax.text(.5, .5, 'test', rotation_mode='anchor', **kw)
+    t1 = ax.text(.5, .5, 'test', rotation_mode='default', **kw)
+    fig.canvas.draw()
+    assert_almost_equal(t0.get_window_extent(fig.canvas.renderer).get_points(),
+                        t1.get_window_extent(fig.canvas.renderer).get_points())
+
+
+@image_comparison(['text_bboxclip'])
+def test_bbox_clipping():
+    plt.text(0.9, 0.2, 'Is bbox clipped?', backgroundcolor='r', clip_on=True)
+    t = plt.text(0.9, 0.5, 'Is fancy bbox clipped?', clip_on=True)
+    t.set_bbox({"boxstyle": "round, pad=0.1"})
+
+
+@image_comparison(['annotation_negative_ax_coords.png'])
+def test_annotation_negative_ax_coords():
+    fig, ax = plt.subplots()
+
+    ax.annotate('+ pts',
+                xytext=[30, 20], textcoords='axes points',
+                xy=[30, 20], xycoords='axes points', fontsize=32)
+    ax.annotate('- pts',
+                xytext=[30, -20], textcoords='axes points',
+                xy=[30, -20], xycoords='axes points', fontsize=32,
+                va='top')
+    ax.annotate('+ frac',
+                xytext=[0.75, 0.05], textcoords='axes fraction',
+                xy=[0.75, 0.05], xycoords='axes fraction', fontsize=32)
+    ax.annotate('- frac',
+                xytext=[0.75, -0.05], textcoords='axes fraction',
+                xy=[0.75, -0.05], xycoords='axes fraction', fontsize=32,
+                va='top')
+
+    ax.annotate('+ pixels',
+                xytext=[160, 25], textcoords='axes pixels',
+                xy=[160, 25], xycoords='axes pixels', fontsize=32)
+    ax.annotate('- pixels',
+                xytext=[160, -25], textcoords='axes pixels',
+                xy=[160, -25], xycoords='axes pixels', fontsize=32,
+                va='top')
+
+
+@image_comparison(['annotation_negative_fig_coords.png'])
+def test_annotation_negative_fig_coords():
+    fig, ax = plt.subplots()
+
+    ax.annotate('+ pts',
+                xytext=[10, 120], textcoords='figure points',
+                xy=[10, 120], xycoords='figure points', fontsize=32)
+    ax.annotate('- pts',
+                xytext=[-10, 180], textcoords='figure points',
+                xy=[-10, 180], xycoords='figure points', fontsize=32,
+                va='top')
+    ax.annotate('+ frac',
+                xytext=[0.05, 0.55], textcoords='figure fraction',
+                xy=[0.05, 0.55], xycoords='figure fraction', fontsize=32)
+    ax.annotate('- frac',
+                xytext=[-0.05, 0.5], textcoords='figure fraction',
+                xy=[-0.05, 0.5], xycoords='figure fraction', fontsize=32,
+                va='top')
+
+    ax.annotate('+ pixels',
+                xytext=[50, 50], textcoords='figure pixels',
+                xy=[50, 50], xycoords='figure pixels', fontsize=32)
+    ax.annotate('- pixels',
+                xytext=[-50, 100], textcoords='figure pixels',
+                xy=[-50, 100], xycoords='figure pixels', fontsize=32,
+                va='top')
+
+
+def test_text_stale():
+    fig, (ax1, ax2) = plt.subplots(1, 2)
+    plt.draw_all()
+    assert not ax1.stale
+    assert not ax2.stale
+    assert not fig.stale
+
+    txt1 = ax1.text(.5, .5, 'aardvark')
+    assert ax1.stale
+    assert txt1.stale
+    assert fig.stale
+
+    ann1 = ax2.annotate('aardvark', xy=[.5, .5])
+    assert ax2.stale
+    assert ann1.stale
+    assert fig.stale
+
+    plt.draw_all()
+    assert not ax1.stale
+    assert not ax2.stale
+    assert not fig.stale
+
+
+@image_comparison(['agg_text_clip.png'])
+def test_agg_text_clip():
+    np.random.seed(1)
+    fig, (ax1, ax2) = plt.subplots(2)
+    for x, y in np.random.rand(10, 2):
+        ax1.text(x, y, "foo", clip_on=True)
+        ax2.text(x, y, "foo")
+
+
+def test_text_size_binding():
+    mpl.rcParams['font.size'] = 10
+    fp = mpl.font_manager.FontProperties(size='large')
+    sz1 = fp.get_size_in_points()
+    mpl.rcParams['font.size'] = 100
+
+    assert sz1 == fp.get_size_in_points()
+
+
+@image_comparison(['font_scaling.pdf'])
+def test_font_scaling():
+    mpl.rcParams['pdf.fonttype'] = 42
+    fig, ax = plt.subplots(figsize=(6.4, 12.4))
+    ax.xaxis.set_major_locator(plt.NullLocator())
+    ax.yaxis.set_major_locator(plt.NullLocator())
+    ax.set_ylim(-10, 600)
+
+    for i, fs in enumerate(range(4, 43, 2)):
+        ax.text(0.1, i*30, f"{fs} pt font size", fontsize=fs)
+
+
+@pytest.mark.parametrize('spacing1, spacing2', [(0.4, 2), (2, 0.4), (2, 2)])
+def test_two_2line_texts(spacing1, spacing2):
+    text_string = 'line1\nline2'
+    fig = plt.figure()
+    renderer = fig.canvas.get_renderer()
+
+    text1 = fig.text(0.25, 0.5, text_string, linespacing=spacing1)
+    text2 = fig.text(0.25, 0.5, text_string, linespacing=spacing2)
+    fig.canvas.draw()
+
+    box1 = text1.get_window_extent(renderer=renderer)
+    box2 = text2.get_window_extent(renderer=renderer)
+
+    # line spacing only affects height
+    assert box1.width == box2.width
+    if spacing1 == spacing2:
+        assert box1.height == box2.height
+    else:
+        assert box1.height != box2.height
+
+
+def test_validate_linespacing():
+    with pytest.raises(TypeError):
+        plt.text(.25, .5, "foo", linespacing="abc")
+
+
+def test_nonfinite_pos():
+    fig, ax = plt.subplots()
+    ax.text(0, np.nan, 'nan')
+    ax.text(np.inf, 0, 'inf')
+    fig.canvas.draw()
+
+
+def test_hinting_factor_backends():
+    plt.rcParams['text.hinting_factor'] = 1
+    fig = plt.figure()
+    t = fig.text(0.5, 0.5, 'some text')
+
+    fig.savefig(io.BytesIO(), format='svg')
+    expected = t.get_window_extent().intervalx
+
+    fig.savefig(io.BytesIO(), format='png')
+    # Backends should apply hinting_factor consistently (within 10%).
+    np.testing.assert_allclose(t.get_window_extent().intervalx, expected,
+                               rtol=0.1)
+
+
+@needs_usetex
+def test_usetex_is_copied():
+    # Indirectly tests that update_from (which is used to copy tick label
+    # properties) copies usetex state.
+    fig = plt.figure()
+    plt.rcParams["text.usetex"] = False
+    ax1 = fig.add_subplot(121)
+    plt.rcParams["text.usetex"] = True
+    ax2 = fig.add_subplot(122)
+    fig.canvas.draw()
+    for ax, usetex in [(ax1, False), (ax2, True)]:
+        for t in ax.xaxis.majorTicks:
+            assert t.label1.get_usetex() == usetex
+
+
+@needs_usetex
+def test_single_artist_usetex():
+    # Check that a single artist marked with usetex does not get passed through
+    # the mathtext parser at all (for the Agg backend) (the mathtext parser
+    # currently fails to parse \frac12, requiring \frac{1}{2} instead).
+    fig = plt.figure()
+    fig.text(.5, .5, r"$\frac12$", usetex=True)
+    fig.canvas.draw()
+
+
+@pytest.mark.parametrize("fmt", ["png", "pdf", "svg"])
+def test_single_artist_usenotex(fmt):
+    # Check that a single artist can be marked as not-usetex even though the
+    # rcParam is on ("2_2_2" fails if passed to TeX).  This currently skips
+    # postscript output as the ps renderer doesn't support mixing usetex and
+    # non-usetex.
+    plt.rcParams["text.usetex"] = True
+    fig = plt.figure()
+    fig.text(.5, .5, "2_2_2", usetex=False)
+    fig.savefig(io.BytesIO(), format=fmt)
+
+
+@image_comparison(['text_as_path_opacity.svg'])
+def test_text_as_path_opacity():
+    plt.figure()
+    plt.gca().set_axis_off()
+    plt.text(0.25, 0.25, 'c', color=(0, 0, 0, 0.5))
+    plt.text(0.25, 0.5, 'a', alpha=0.5)
+    plt.text(0.25, 0.75, 'x', alpha=0.5, color=(0, 0, 0, 1))
+
+
+@image_comparison(['text_as_text_opacity.svg'])
+def test_text_as_text_opacity():
+    mpl.rcParams['svg.fonttype'] = 'none'
+    plt.figure()
+    plt.gca().set_axis_off()
+    plt.text(0.25, 0.25, '50% using `color`', color=(0, 0, 0, 0.5))
+    plt.text(0.25, 0.5, '50% using `alpha`', alpha=0.5)
+    plt.text(0.25, 0.75, '50% using `alpha` and 100% `color`', alpha=0.5,
+             color=(0, 0, 0, 1))
+
+
+def test_text_repr():
+    # smoketest to make sure text repr doesn't error for category
+    plt.plot(['A', 'B'], [1, 2])
+    repr(plt.text(['A'], 0.5, 'Boo'))
+
+
+def test_annotation_update():
+    fig, ax = plt.subplots(1, 1)
+    an = ax.annotate('annotation', xy=(0.5, 0.5))
+    extent1 = an.get_window_extent(fig.canvas.get_renderer())
+    fig.tight_layout()
+    extent2 = an.get_window_extent(fig.canvas.get_renderer())
+
+    assert not np.allclose(extent1.get_points(), extent2.get_points(),
+                           rtol=1e-6)
+
+
+@check_figures_equal(extensions=["png"])
+def test_annotation_units(fig_test, fig_ref):
+    ax = fig_test.add_subplot()
+    ax.plot(datetime.now(), 1, "o")  # Implicitly set axes extents.
+    ax.annotate("x", (datetime.now(), 0.5), xycoords=("data", "axes fraction"),
+                # This used to crash before.
+                xytext=(0, 0), textcoords="offset points")
+    ax = fig_ref.add_subplot()
+    ax.plot(datetime.now(), 1, "o")
+    ax.annotate("x", (datetime.now(), 0.5), xycoords=("data", "axes fraction"))
+
+
+@image_comparison(['large_subscript_title.png'], style='mpl20')
+def test_large_subscript_title():
+    # Remove this line when this test image is regenerated.
+    plt.rcParams['text.kerning_factor'] = 6
+    plt.rcParams['axes.titley'] = None
+
+    fig, axs = plt.subplots(1, 2, figsize=(9, 2.5), constrained_layout=True)
+    ax = axs[0]
+    ax.set_title(r'$\sum_{i} x_i$')
+    ax.set_title('New way', loc='left')
+    ax.set_xticklabels([])
+
+    ax = axs[1]
+    ax.set_title(r'$\sum_{i} x_i$', y=1.01)
+    ax.set_title('Old Way', loc='left')
+    ax.set_xticklabels([])
+
+
+@pytest.mark.parametrize(
+    "x, rotation, halign",
+    [(0.7, 0, 'left'),
+     (0.5, 95, 'left'),
+     (0.3, 0, 'right'),
+     (0.3, 185, 'left')])
+def test_wrap(x, rotation, halign):
+    fig = plt.figure(figsize=(18, 18))
+    gs = GridSpec(nrows=3, ncols=3, figure=fig)
+    subfig = fig.add_subfigure(gs[1, 1])
+    # we only use the central subfigure, which does not align with any
+    # figure boundary, to ensure only subfigure boundaries are relevant
+    s = 'This is a very long text that should be wrapped multiple times.'
+    text = subfig.text(x, 0.7, s, wrap=True, rotation=rotation, ha=halign)
+    fig.canvas.draw()
+    assert text._get_wrapped_text() == ('This is a very long\n'
+                                        'text that should be\n'
+                                        'wrapped multiple\n'
+                                        'times.')
+
+
+def test_mathwrap():
+    fig = plt.figure(figsize=(6, 4))
+    s = r'This is a very $\overline{\mathrm{long}}$ line of Mathtext.'
+    text = fig.text(0, 0.5, s, size=40, wrap=True)
+    fig.canvas.draw()
+    assert text._get_wrapped_text() == ('This is a very $\\overline{\\mathrm{long}}$\n'
+                                        'line of Mathtext.')
+
+
+def test_get_window_extent_wrapped():
+    # Test that a long title that wraps to two lines has the same vertical
+    # extent as an explicit two line title.
+
+    fig1 = plt.figure(figsize=(3, 3))
+    fig1.suptitle("suptitle that is clearly too long in this case", wrap=True)
+    window_extent_test = fig1._suptitle.get_window_extent()
+
+    fig2 = plt.figure(figsize=(3, 3))
+    fig2.suptitle("suptitle that is clearly\ntoo long in this case")
+    window_extent_ref = fig2._suptitle.get_window_extent()
+
+    assert window_extent_test.y0 == window_extent_ref.y0
+    assert window_extent_test.y1 == window_extent_ref.y1
+
+
+def test_long_word_wrap():
+    fig = plt.figure(figsize=(6, 4))
+    text = fig.text(9.5, 8, 'Alonglineoftexttowrap', wrap=True)
+    fig.canvas.draw()
+    assert text._get_wrapped_text() == 'Alonglineoftexttowrap'
+
+
+def test_wrap_no_wrap():
+    fig = plt.figure(figsize=(6, 4))
+    text = fig.text(0, 0, 'non wrapped text', wrap=True)
+    fig.canvas.draw()
+    assert text._get_wrapped_text() == 'non wrapped text'
+
+
+@check_figures_equal(extensions=["png"])
+def test_buffer_size(fig_test, fig_ref):
+    # On old versions of the Agg renderer, large non-ascii single-character
+    # strings (here, "€") would be rendered clipped because the rendering
+    # buffer would be set by the physical size of the smaller "a" character.
+    ax = fig_test.add_subplot()
+    ax.set_yticks([0, 1])
+    ax.set_yticklabels(["€", "a"])
+    ax.yaxis.majorTicks[1].label1.set_color("w")
+    ax = fig_ref.add_subplot()
+    ax.set_yticks([0, 1])
+    ax.set_yticklabels(["€", ""])
+
+
+def test_fontproperties_kwarg_precedence():
+    """Test that kwargs take precedence over fontproperties defaults."""
+    plt.figure()
+    text1 = plt.xlabel("value", fontproperties='Times New Roman', size=40.0)
+    text2 = plt.ylabel("counts", size=40.0, fontproperties='Times New Roman')
+    assert text1.get_size() == 40.0
+    assert text2.get_size() == 40.0
+
+
+def test_transform_rotates_text():
+    ax = plt.gca()
+    transform = mtransforms.Affine2D().rotate_deg(30)
+    text = ax.text(0, 0, 'test', transform=transform,
+                   transform_rotates_text=True)
+    result = text.get_rotation()
+    assert_almost_equal(result, 30)
+
+
+def test_update_mutate_input():
+    inp = dict(fontproperties=FontProperties(weight="bold"),
+               bbox=None)
+    cache = dict(inp)
+    t = Text()
+    t.update(inp)
+    assert inp['fontproperties'] == cache['fontproperties']
+    assert inp['bbox'] == cache['bbox']
+
+
+@pytest.mark.parametrize('rotation', ['invalid string', [90]])
+def test_invalid_rotation_values(rotation):
+    with pytest.raises(
+            ValueError,
+            match=("rotation must be 'vertical', 'horizontal' or a number")):
+        Text(0, 0, 'foo', rotation=rotation)
+
+
+def test_invalid_color():
+    with pytest.raises(ValueError):
+        plt.figtext(.5, .5, "foo", c="foobar")
+
+
+@image_comparison(['text_pdf_kerning.pdf'], style='mpl20')
+def test_pdf_kerning():
+    plt.figure()
+    plt.figtext(0.1, 0.5, "ATATATATATATATATATA", size=30)
+
+
+def test_unsupported_script(recwarn):
+    fig = plt.figure()
+    t = fig.text(.5, .5, "\N{BENGALI DIGIT ZERO}")
+    fig.canvas.draw()
+    assert all(isinstance(warn.message, UserWarning) for warn in recwarn)
+    assert (
+        [warn.message.args for warn in recwarn] ==
+        [(r"Glyph 2534 (\N{BENGALI DIGIT ZERO}) missing from font(s) "
+            + f"{t.get_fontname()}.",),
+         (r"Matplotlib currently does not support Bengali natively.",)])
+
+
+# See gh-26152 for more information on this xfail
+@pytest.mark.xfail(pyparsing_version.release == (3, 1, 0),
+                   reason="Error messages are incorrect with pyparsing 3.1.0")
+def test_parse_math():
+    fig, ax = plt.subplots()
+    ax.text(0, 0, r"$ \wrong{math} $", parse_math=False)
+    fig.canvas.draw()
+
+    ax.text(0, 0, r"$ \wrong{math} $", parse_math=True)
+    with pytest.raises(ValueError, match='Unknown symbol'):
+        fig.canvas.draw()
+
+
+# See gh-26152 for more information on this xfail
+@pytest.mark.xfail(pyparsing_version.release == (3, 1, 0),
+                   reason="Error messages are incorrect with pyparsing 3.1.0")
+def test_parse_math_rcparams():
+    # Default is True
+    fig, ax = plt.subplots()
+    ax.text(0, 0, r"$ \wrong{math} $")
+    with pytest.raises(ValueError, match='Unknown symbol'):
+        fig.canvas.draw()
+
+    # Setting rcParams to False
+    with mpl.rc_context({'text.parse_math': False}):
+        fig, ax = plt.subplots()
+        ax.text(0, 0, r"$ \wrong{math} $")
+        fig.canvas.draw()
+
+
+@image_comparison(['text_pdf_font42_kerning.pdf'], style='mpl20')
+def test_pdf_font42_kerning():
+    plt.rcParams['pdf.fonttype'] = 42
+    plt.figure()
+    plt.figtext(0.1, 0.5, "ATAVATAVATAVATAVATA", size=30)
+
+
+@image_comparison(['text_pdf_chars_beyond_bmp.pdf'], style='mpl20')
+def test_pdf_chars_beyond_bmp():
+    plt.rcParams['pdf.fonttype'] = 42
+    plt.rcParams['mathtext.fontset'] = 'stixsans'
+    plt.figure()
+    plt.figtext(0.1, 0.5, "Mass $m$ \U00010308", size=30)
+
+
+@needs_usetex
+def test_metrics_cache():
+    mpl.text._get_text_metrics_with_cache_impl.cache_clear()
+
+    fig = plt.figure()
+    fig.text(.3, .5, "foo\nbar")
+    fig.text(.3, .5, "foo\nbar", usetex=True)
+    fig.text(.5, .5, "foo\nbar", usetex=True)
+    fig.canvas.draw()
+    renderer = fig._get_renderer()
+    ys = {}  # mapping of strings to where they were drawn in y with draw_tex.
+
+    def call(*args, **kwargs):
+        renderer, x, y, s, *_ = args
+        ys.setdefault(s, set()).add(y)
+
+    renderer.draw_tex = call
+    fig.canvas.draw()
+    assert [*ys] == ["foo", "bar"]
+    # Check that both TeX strings were drawn with the same y-position for both
+    # single-line substrings.  Previously, there used to be an incorrect cache
+    # collision with the non-TeX string (drawn first here) whose metrics would
+    # get incorrectly reused by the first TeX string.
+    assert len(ys["foo"]) == len(ys["bar"]) == 1
+
+    info = mpl.text._get_text_metrics_with_cache_impl.cache_info()
+    # Every string gets a miss for the first layouting (extents), then a hit
+    # when drawing, but "foo\nbar" gets two hits as it's drawn twice.
+    assert info.hits > info.misses
+
+
+def test_annotate_offset_fontsize():
+    # Test that offset_fontsize parameter works and uses accurate values
+    fig, ax = plt.subplots()
+    text_coords = ['offset points', 'offset fontsize']
+    # 10 points should be equal to 1 fontsize unit at fontsize=10
+    xy_text = [(10, 10), (1, 1)]
+    anns = [ax.annotate('test', xy=(0.5, 0.5),
+                        xytext=xy_text[i],
+                        fontsize='10',
+                        xycoords='data',
+                        textcoords=text_coords[i]) for i in range(2)]
+    points_coords, fontsize_coords = (ann.get_window_extent() for ann in anns)
+    fig.canvas.draw()
+    assert str(points_coords) == str(fontsize_coords)
+
+
+def test_get_set_antialiased():
+    txt = Text(.5, .5, "foo\nbar")
+    assert txt._antialiased == mpl.rcParams['text.antialiased']
+    assert txt.get_antialiased() == mpl.rcParams['text.antialiased']
+
+    txt.set_antialiased(True)
+    assert txt._antialiased is True
+    assert txt.get_antialiased() == txt._antialiased
+
+    txt.set_antialiased(False)
+    assert txt._antialiased is False
+    assert txt.get_antialiased() == txt._antialiased
+
+
+def test_annotation_antialiased():
+    annot = Annotation("foo\nbar", (.5, .5), antialiased=True)
+    assert annot._antialiased is True
+    assert annot.get_antialiased() == annot._antialiased
+
+    annot2 = Annotation("foo\nbar", (.5, .5), antialiased=False)
+    assert annot2._antialiased is False
+    assert annot2.get_antialiased() == annot2._antialiased
+
+    annot3 = Annotation("foo\nbar", (.5, .5), antialiased=False)
+    annot3.set_antialiased(True)
+    assert annot3.get_antialiased() is True
+    assert annot3._antialiased is True
+
+    annot4 = Annotation("foo\nbar", (.5, .5))
+    assert annot4._antialiased == mpl.rcParams['text.antialiased']
+
+
+@check_figures_equal(extensions=["png"])
+def test_annotate_and_offsetfrom_copy_input(fig_test, fig_ref):
+    # Both approaches place the text (10, 0) pixels away from the center of the line.
+    ax = fig_test.add_subplot()
+    l, = ax.plot([0, 2], [0, 2])
+    of_xy = np.array([.5, .5])
+    ax.annotate("foo", textcoords=OffsetFrom(l, of_xy), xytext=(10, 0),
+                xy=(0, 0))  # xy is unused.
+    of_xy[:] = 1
+    ax = fig_ref.add_subplot()
+    l, = ax.plot([0, 2], [0, 2])
+    an_xy = np.array([.5, .5])
+    ax.annotate("foo", xy=an_xy, xycoords=l, xytext=(10, 0), textcoords="offset points")
+    an_xy[:] = 2
+
+
+@check_figures_equal()
+def test_text_antialiased_off_default_vs_manual(fig_test, fig_ref):
+    fig_test.text(0.5, 0.5, '6 inches x 2 inches',
+                             antialiased=False)
+
+    mpl.rcParams['text.antialiased'] = False
+    fig_ref.text(0.5, 0.5, '6 inches x 2 inches')
+
+
+@check_figures_equal()
+def test_text_antialiased_on_default_vs_manual(fig_test, fig_ref):
+    fig_test.text(0.5, 0.5, '6 inches x 2 inches', antialiased=True)
+
+    mpl.rcParams['text.antialiased'] = True
+    fig_ref.text(0.5, 0.5, '6 inches x 2 inches')
+
+
+def test_text_annotation_get_window_extent():
+    figure = Figure(dpi=100)
+    renderer = RendererAgg(200, 200, 100)
+
+    # Only text annotation
+    annotation = Annotation('test', xy=(0, 0), xycoords='figure pixels')
+    annotation.set_figure(figure)
+
+    text = Text(text='test', x=0, y=0)
+    text.set_figure(figure)
+
+    bbox = annotation.get_window_extent(renderer=renderer)
+
+    text_bbox = text.get_window_extent(renderer=renderer)
+    assert bbox.width == text_bbox.width
+    assert bbox.height == text_bbox.height
+
+    _, _, d = renderer.get_text_width_height_descent(
+        'text', annotation._fontproperties, ismath=False)
+    _, _, lp_d = renderer.get_text_width_height_descent(
+        'lp', annotation._fontproperties, ismath=False)
+    below_line = max(d, lp_d)
+
+    # These numbers are specific to the current implementation of Text
+    points = bbox.get_points()
+    assert points[0, 0] == 0.0
+    assert points[1, 0] == text_bbox.width
+    assert points[0, 1] == -below_line
+    assert points[1, 1] == text_bbox.height - below_line
+
+
+def test_text_with_arrow_annotation_get_window_extent():
+    headwidth = 21
+    fig, ax = plt.subplots(dpi=100)
+    txt = ax.text(s='test', x=0, y=0)
+    ann = ax.annotate(
+        'test',
+        xy=(0.0, 50.0),
+        xytext=(50.0, 50.0), xycoords='figure pixels',
+        arrowprops={
+            'facecolor': 'black', 'width': 2,
+            'headwidth': headwidth, 'shrink': 0.0})
+
+    plt.draw()
+    renderer = fig.canvas.renderer
+    # bounding box of text
+    text_bbox = txt.get_window_extent(renderer=renderer)
+    # bounding box of annotation (text + arrow)
+    bbox = ann.get_window_extent(renderer=renderer)
+    # bounding box of arrow
+    arrow_bbox = ann.arrow_patch.get_window_extent(renderer)
+    # bounding box of annotation text
+    ann_txt_bbox = Text.get_window_extent(ann)
+
+    # make sure annotation width is 50 px wider than
+    # just the text
+    assert bbox.width == text_bbox.width + 50.0
+    # make sure the annotation text bounding box is same size
+    # as the bounding box of the same string as a Text object
+    assert ann_txt_bbox.height == text_bbox.height
+    assert ann_txt_bbox.width == text_bbox.width
+    # compute the expected bounding box of arrow + text
+    expected_bbox = mtransforms.Bbox.union([ann_txt_bbox, arrow_bbox])
+    assert_almost_equal(bbox.height, expected_bbox.height)
+
+
+def test_arrow_annotation_get_window_extent():
+    dpi = 100
+    dots_per_point = dpi / 72
+    figure = Figure(dpi=dpi)
+    figure.set_figwidth(2.0)
+    figure.set_figheight(2.0)
+    renderer = RendererAgg(200, 200, 100)
+
+    # Text annotation with arrow; arrow dimensions are in points
+    annotation = Annotation(
+        '', xy=(0.0, 50.0), xytext=(50.0, 50.0), xycoords='figure pixels',
+        arrowprops={
+            'facecolor': 'black', 'width': 8, 'headwidth': 10, 'shrink': 0.0})
+    annotation.set_figure(figure)
+    annotation.draw(renderer)
+
+    bbox = annotation.get_window_extent()
+    points = bbox.get_points()
+
+    assert bbox.width == 50.0
+    assert_almost_equal(bbox.height, 10.0 * dots_per_point)
+    assert points[0, 0] == 0.0
+    assert points[0, 1] == 50.0 - 5 * dots_per_point
+
+
+def test_empty_annotation_get_window_extent():
+    figure = Figure(dpi=100)
+    figure.set_figwidth(2.0)
+    figure.set_figheight(2.0)
+    renderer = RendererAgg(200, 200, 100)
+
+    # Text annotation with arrow
+    annotation = Annotation(
+        '', xy=(0.0, 50.0), xytext=(0.0, 50.0), xycoords='figure pixels')
+    annotation.set_figure(figure)
+    annotation.draw(renderer)
+
+    bbox = annotation.get_window_extent()
+    points = bbox.get_points()
+
+    assert points[0, 0] == 0.0
+    assert points[1, 0] == 0.0
+    assert points[1, 1] == 50.0
+    assert points[0, 1] == 50.0
+
+
+@image_comparison(baseline_images=['basictext_wrap'],
+                  extensions=['png'])
+def test_basic_wrap():
+    fig = plt.figure()
+    plt.axis([0, 10, 0, 10])
+    t = "This is a really long string that I'd rather have wrapped so that" \
+        " it doesn't go outside of the figure, but if it's long enough it" \
+        " will go off the top or bottom!"
+    plt.text(4, 1, t, ha='left', rotation=15, wrap=True)
+    plt.text(6, 5, t, ha='left', rotation=15, wrap=True)
+    plt.text(5, 5, t, ha='right', rotation=-15, wrap=True)
+    plt.text(5, 10, t, fontsize=18, style='oblique', ha='center',
+             va='top', wrap=True)
+    plt.text(3, 4, t, family='serif', style='italic', ha='right', wrap=True)
+    plt.text(-1, 0, t, ha='left', rotation=-15, wrap=True)
+
+
+@image_comparison(baseline_images=['fonttext_wrap'],
+                  extensions=['png'])
+def test_font_wrap():
+    fig = plt.figure()
+    plt.axis([0, 10, 0, 10])
+    t = "This is a really long string that I'd rather have wrapped so that" \
+        " it doesn't go outside of the figure, but if it's long enough it" \
+        " will go off the top or bottom!"
+    plt.text(4, -1, t, fontsize=18, family='serif', ha='left', rotation=15,
+             wrap=True)
+    plt.text(6, 5, t, family='sans serif', ha='left', rotation=15, wrap=True)
+    plt.text(5, 10, t, weight='heavy', ha='center', va='top', wrap=True)
+    plt.text(3, 4, t, family='monospace', ha='right', wrap=True)
+    plt.text(-1, 0, t, fontsize=14, style='italic', ha='left', rotation=-15,
+             wrap=True)
diff --git a/lib/python3.10/site-packages/matplotlib/tests/test_textpath.py b/lib/python3.10/site-packages/matplotlib/tests/test_textpath.py
new file mode 100644
index 0000000000000000000000000000000000000000..e421d2623cadac7931f1f21148bdc0a603c290b1
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/tests/test_textpath.py
@@ -0,0 +1,10 @@
+import copy
+
+from matplotlib.textpath import TextPath
+
+
+def test_copy():
+    tp = TextPath((0, 0), ".")
+    assert copy.deepcopy(tp).vertices is not tp.vertices
+    assert (copy.deepcopy(tp).vertices == tp.vertices).all()
+    assert copy.copy(tp).vertices is tp.vertices
diff --git a/lib/python3.10/site-packages/matplotlib/tests/test_ticker.py b/lib/python3.10/site-packages/matplotlib/tests/test_ticker.py
new file mode 100644
index 0000000000000000000000000000000000000000..77c0e917df8a1fd2c7deb450e3dd8b917391f3b8
--- /dev/null
+++ b/lib/python3.10/site-packages/matplotlib/tests/test_ticker.py
@@ -0,0 +1,1939 @@
+from contextlib import nullcontext
+import itertools
+import locale
+import logging
+import re
+from packaging.version import parse as parse_version
+
+import numpy as np
+from numpy.testing import assert_almost_equal, assert_array_equal
+import pytest
+
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+import matplotlib.ticker as mticker
+
+
+class TestMaxNLocator:
+    basic_data = [
+        (20, 100, np.array([20., 40., 60., 80., 100.])),
+        (0.001, 0.0001, np.array([0., 0.0002, 0.0004, 0.0006, 0.0008, 0.001])),
+        (-1e15, 1e15, np.array([-1.0e+15, -5.0e+14, 0e+00, 5e+14, 1.0e+15])),
+        (0, 0.85e-50, np.arange(6) * 2e-51),
+        (-0.85e-50, 0, np.arange(-5, 1) * 2e-51),
+    ]
+
+    integer_data = [
+        (-0.1, 1.1, None, np.array([-1, 0, 1, 2])),
+        (-0.1, 0.95, None, np.array([-0.25, 0, 0.25, 0.5, 0.75, 1.0])),
+        (1, 55, [1, 1.5, 5, 6, 10], np.array([0, 15, 30, 45, 60])),
+    ]
+
+    @pytest.mark.parametrize('vmin, vmax, expected', basic_data)
+    def test_basic(self, vmin, vmax, expected):
+        loc = mticker.MaxNLocator(nbins=5)
+        assert_almost_equal(loc.tick_values(vmin, vmax), expected)
+
+    @pytest.mark.parametrize('vmin, vmax, steps, expected', integer_data)
+    def test_integer(self, vmin, vmax, steps, expected):
+        loc = mticker.MaxNLocator(nbins=5, integer=True, steps=steps)
+        assert_almost_equal(loc.tick_values(vmin, vmax), expected)
+
+    @pytest.mark.parametrize('kwargs, errortype, match', [
+        ({'foo': 0}, TypeError,
+         re.escape("set_params() got an unexpected keyword argument 'foo'")),
+        ({'steps': [2, 1]}, ValueError, "steps argument must be an increasing"),
+        ({'steps': 2}, ValueError, "steps argument must be an increasing"),
+        ({'steps': [2, 11]}, ValueError, "steps argument must be an increasing"),
+    ])
+    def test_errors(self, kwargs, errortype, match):
+        with pytest.raises(errortype, match=match):
+            mticker.MaxNLocator(**kwargs)
+
+    @pytest.mark.parametrize('steps, result', [
+        ([1, 2, 10], [1, 2, 10]),
+        ([2, 10], [1, 2, 10]),
+        ([1, 2], [1, 2, 10]),
+        ([2], [1, 2, 10]),
+    ])
+    def test_padding(self, steps, result):
+        loc = mticker.MaxNLocator(steps=steps)
+        assert (loc._steps == result).all()
+
+
+class TestLinearLocator:
+    def test_basic(self):
+        loc = mticker.LinearLocator(numticks=3)
+        test_value = np.array([-0.8, -0.3, 0.2])
+        assert_almost_equal(loc.tick_values(-0.8, 0.2), test_value)
+
+    def test_zero_numticks(self):
+        loc = mticker.LinearLocator(numticks=0)
+        loc.tick_values(-0.8, 0.2) == []
+
+    def test_set_params(self):
+        """
+        Create linear locator with presets={}, numticks=2 and change it to
+        something else. See if change was successful. Should not exception.
+        """
+        loc = mticker.LinearLocator(numticks=2)
+        loc.set_params(numticks=8, presets={(0, 1): []})
+        assert loc.numticks == 8
+        assert loc.presets == {(0, 1): []}
+
+    def test_presets(self):
+        loc = mticker.LinearLocator(presets={(1, 2): [1, 1.25, 1.75],
+                                             (0, 2): [0.5, 1.5]})
+        assert loc.tick_values(1, 2) == [1, 1.25, 1.75]
+        assert loc.tick_values(2, 1) == [1, 1.25, 1.75]
+        assert loc.tick_values(0, 2) == [0.5, 1.5]
+        assert loc.tick_values(0.0, 2.0) == [0.5, 1.5]
+        assert (loc.tick_values(0, 1) == np.linspace(0, 1, 11)).all()
+
+
+class TestMultipleLocator:
+    def test_basic(self):
+        loc = mticker.MultipleLocator(base=3.147)
+        test_value = np.array([-9.441, -6.294, -3.147, 0., 3.147, 6.294,
+                               9.441, 12.588])
+        assert_almost_equal(loc.tick_values(-7, 10), test_value)
+
+    def test_basic_with_offset(self):
+        loc = mticker.MultipleLocator(base=3.147, offset=1.2)
+        test_value = np.array([-8.241, -5.094, -1.947, 1.2, 4.347, 7.494,
+                               10.641])
+        assert_almost_equal(loc.tick_values(-7, 10), test_value)
+
+    def test_view_limits(self):
+        """
+        Test basic behavior of view limits.
+        """
+        with mpl.rc_context({'axes.autolimit_mode': 'data'}):
+            loc = mticker.MultipleLocator(base=3.147)
+            assert_almost_equal(loc.view_limits(-5, 5), (-5, 5))
+
+    def test_view_limits_round_numbers(self):
+        """
+        Test that everything works properly with 'round_numbers' for auto
+        limit.
+        """
+        with mpl.rc_context({'axes.autolimit_mode': 'round_numbers'}):
+            loc = mticker.MultipleLocator(base=3.147)
+            assert_almost_equal(loc.view_limits(-4, 4), (-6.294, 6.294))
+
+    def test_view_limits_round_numbers_with_offset(self):
+        """
+        Test that everything works properly with 'round_numbers' for auto
+        limit.
+        """
+        with mpl.rc_context({'axes.autolimit_mode': 'round_numbers'}):
+            loc = mticker.MultipleLocator(base=3.147, offset=1.3)
+            assert_almost_equal(loc.view_limits(-4, 4), (-4.994, 4.447))
+
+    def test_view_limits_single_bin(self):
+        """
+        Test that 'round_numbers' works properly with a single bin.
+        """
+        with mpl.rc_context({'axes.autolimit_mode': 'round_numbers'}):
+            loc = mticker.MaxNLocator(nbins=1)
+            assert_almost_equal(loc.view_limits(-2.3, 2.3), (-4, 4))
+
+    def test_set_params(self):
+        """
+        Create multiple locator with 0.7 base, and change it to something else.
+        See if change was successful.
+        """
+        mult = mticker.MultipleLocator(base=0.7)
+        mult.set_params(base=1.7)
+        assert mult._edge.step == 1.7
+        mult.set_params(offset=3)
+        assert mult._offset == 3
+
+
+class TestAutoMinorLocator:
+    def test_basic(self):
+        fig, ax = plt.subplots()
+        ax.set_xlim(0, 1.39)
+        ax.minorticks_on()
+        test_value = np.array([0.05, 0.1, 0.15, 0.25, 0.3, 0.35, 0.45,
+                               0.5, 0.55, 0.65, 0.7, 0.75, 0.85, 0.9,
+                               0.95, 1.05, 1.1, 1.15, 1.25, 1.3, 1.35])
+        assert_almost_equal(ax.xaxis.get_ticklocs(minor=True), test_value)
+
+    # NB: the following values are assuming that *xlim* is [0, 5]
+    params = [
+        (0, 0),  # no major tick => no minor tick either
+        (1, 0)   # a single major tick => no minor tick
+    ]
+
+    def test_first_and_last_minorticks(self):
+        """
+        Test that first and last minor tick appear as expected.
+        """
+        # This test is related to issue #22331
+        fig, ax = plt.subplots()
+        ax.set_xlim(-1.9, 1.9)
+        ax.xaxis.set_minor_locator(mticker.AutoMinorLocator())
+        test_value = np.array([-1.9, -1.8, -1.7, -1.6, -1.4, -1.3, -1.2, -1.1,
+                               -0.9, -0.8, -0.7, -0.6, -0.4, -0.3, -0.2, -0.1,
+                               0.1, 0.2, 0.3, 0.4, 0.6, 0.7, 0.8, 0.9, 1.1,
+                               1.2, 1.3, 1.4, 1.6, 1.7, 1.8, 1.9])
+        assert_almost_equal(ax.xaxis.get_ticklocs(minor=True), test_value)
+
+        ax.set_xlim(-5, 5)
+        test_value = np.array([-5.0, -4.5, -3.5, -3.0, -2.5, -1.5, -1.0, -0.5,
+                               0.5, 1.0, 1.5, 2.5, 3.0, 3.5, 4.5, 5.0])
+        assert_almost_equal(ax.xaxis.get_ticklocs(minor=True), test_value)
+
+    @pytest.mark.parametrize('nb_majorticks, expected_nb_minorticks', params)
+    def test_low_number_of_majorticks(
+            self, nb_majorticks, expected_nb_minorticks):
+        # This test is related to issue #8804
+        fig, ax = plt.subplots()
+        xlims = (0, 5)  # easier to test the different code paths
+        ax.set_xlim(*xlims)
+        ax.set_xticks(np.linspace(xlims[0], xlims[1], nb_majorticks))
+        ax.minorticks_on()
+        ax.xaxis.set_minor_locator(mticker.AutoMinorLocator())
+        assert len(ax.xaxis.get_minorticklocs()) == expected_nb_minorticks
+
+    majorstep_minordivisions = [(1, 5),
+                                (2, 4),
+                                (2.5, 5),
+                                (5, 5),
+                                (10, 5)]
+
+    # This test is meant to verify the parameterization for
+    # test_number_of_minor_ticks
+    def test_using_all_default_major_steps(self):
+        with mpl.rc_context({'_internal.classic_mode': False}):
+            majorsteps = [x[0] for x in self.majorstep_minordivisions]
+            np.testing.assert_allclose(majorsteps,
+                                       mticker.AutoLocator()._steps)
+
+    @pytest.mark.parametrize('major_step, expected_nb_minordivisions',
+                             majorstep_minordivisions)
+    def test_number_of_minor_ticks(
+            self, major_step, expected_nb_minordivisions):
+        fig, ax = plt.subplots()
+        xlims = (0, major_step)
+        ax.set_xlim(*xlims)
+        ax.set_xticks(xlims)
+        ax.minorticks_on()
+        ax.xaxis.set_minor_locator(mticker.AutoMinorLocator())
+        nb_minor_divisions = len(ax.xaxis.get_minorticklocs()) + 1
+        assert nb_minor_divisions == expected_nb_minordivisions
+
+    limits = [(0, 1.39), (0, 0.139),
+              (0, 0.11e-19), (0, 0.112e-12),
+              (-2.0e-07, -3.3e-08), (1.20e-06, 1.42e-06),
+              (-1.34e-06, -1.44e-06), (-8.76e-07, -1.51e-06)]
+
+    reference = [
+        [0.05, 0.1, 0.15, 0.25, 0.3, 0.35, 0.45, 0.5, 0.55, 0.65, 0.7,
+         0.75, 0.85, 0.9, 0.95, 1.05, 1.1, 1.15, 1.25, 1.3, 1.35],
+        [0.005, 0.01, 0.015, 0.025, 0.03, 0.035, 0.045, 0.05, 0.055, 0.065,
+         0.07, 0.075, 0.085, 0.09, 0.095, 0.105, 0.11, 0.115, 0.125, 0.13,
+         0.135],
+        [5.00e-22, 1.00e-21, 1.50e-21, 2.50e-21, 3.00e-21, 3.50e-21, 4.50e-21,
+         5.00e-21, 5.50e-21, 6.50e-21, 7.00e-21, 7.50e-21, 8.50e-21, 9.00e-21,
+         9.50e-21, 1.05e-20, 1.10e-20],
+        [5.00e-15, 1.00e-14, 1.50e-14, 2.50e-14, 3.00e-14, 3.50e-14, 4.50e-14,
+         5.00e-14, 5.50e-14, 6.50e-14, 7.00e-14, 7.50e-14, 8.50e-14, 9.00e-14,
+         9.50e-14, 1.05e-13, 1.10e-13],
+        [-1.95e-07, -1.90e-07, -1.85e-07, -1.75e-07, -1.70e-07, -1.65e-07,
+         -1.55e-07, -1.50e-07, -1.45e-07, -1.35e-07, -1.30e-07, -1.25e-07,
+         -1.15e-07, -1.10e-07, -1.05e-07, -9.50e-08, -9.00e-08, -8.50e-08,
+         -7.50e-08, -7.00e-08, -6.50e-08, -5.50e-08, -5.00e-08, -4.50e-08,
+         -3.50e-08],
+        [1.21e-06, 1.22e-06, 1.23e-06, 1.24e-06, 1.26e-06, 1.27e-06, 1.28e-06,
+         1.29e-06, 1.31e-06, 1.32e-06, 1.33e-06, 1.34e-06, 1.36e-06, 1.37e-06,
+         1.38e-06, 1.39e-06, 1.41e-06, 1.42e-06],
+        [-1.435e-06, -1.430e-06, -1.425e-06, -1.415e-06, -1.410e-06,
+         -1.405e-06, -1.395e-06, -1.390e-06, -1.385e-06, -1.375e-06,
+         -1.370e-06, -1.365e-06, -1.355e-06, -1.350e-06, -1.345e-06],
+        [-1.48e-06, -1.46e-06, -1.44e-06, -1.42e-06, -1.38e-06, -1.36e-06,
+         -1.34e-06, -1.32e-06, -1.28e-06, -1.26e-06, -1.24e-06, -1.22e-06,
+         -1.18e-06, -1.16e-06, -1.14e-06, -1.12e-06, -1.08e-06, -1.06e-06,
+         -1.04e-06, -1.02e-06, -9.80e-07, -9.60e-07, -9.40e-07, -9.20e-07,
+         -8.80e-07]]
+
+    additional_data = list(zip(limits, reference))
+
+    @pytest.mark.parametrize('lim, ref', additional_data)
+    def test_additional(self, lim, ref):
+        fig, ax = plt.subplots()
+
+        ax.minorticks_on()
+        ax.grid(True, 'minor', 'y', linewidth=1)
+        ax.grid(True, 'major', color='k', linewidth=1)
+        ax.set_ylim(lim)
+
+        assert_almost_equal(ax.yaxis.get_ticklocs(minor=True), ref)
+
+    @pytest.mark.parametrize('use_rcparam', [False, True])
+    @pytest.mark.parametrize(
+        'lim, ref', [
+            ((0, 1.39),
+             [0.05, 0.1, 0.15, 0.25, 0.3, 0.35, 0.45, 0.5, 0.55, 0.65, 0.7,
+              0.75, 0.85, 0.9, 0.95, 1.05, 1.1, 1.15, 1.25, 1.3, 1.35]),
+            ((0, 0.139),
+             [0.005, 0.01, 0.015, 0.025, 0.03, 0.035, 0.045, 0.05, 0.055,
+              0.065, 0.07, 0.075, 0.085, 0.09, 0.095, 0.105, 0.11, 0.115,
+              0.125, 0.13, 0.135]),
+        ])
+    def test_number_of_minor_ticks_auto(self, lim, ref, use_rcparam):
+        if use_rcparam:
+            context = {'xtick.minor.ndivs': 'auto', 'ytick.minor.ndivs': 'auto'}
+            kwargs = {}
+        else:
+            context = {}
+            kwargs = {'n': 'auto'}
+
+        with mpl.rc_context(context):
+            fig, ax = plt.subplots()
+            ax.set_xlim(*lim)
+            ax.set_ylim(*lim)
+            ax.xaxis.set_minor_locator(mticker.AutoMinorLocator(**kwargs))
+            ax.yaxis.set_minor_locator(mticker.AutoMinorLocator(**kwargs))
+            assert_almost_equal(ax.xaxis.get_ticklocs(minor=True), ref)
+            assert_almost_equal(ax.yaxis.get_ticklocs(minor=True), ref)
+
+    @pytest.mark.parametrize('use_rcparam', [False, True])
+    @pytest.mark.parametrize(
+        'n, lim, ref', [
+            (2, (0, 4), [0.5, 1.5, 2.5, 3.5]),
+            (4, (0, 2), [0.25, 0.5, 0.75, 1.25, 1.5, 1.75]),
+            (10, (0, 1), [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]),
+        ])
+    def test_number_of_minor_ticks_int(self, n, lim, ref, use_rcparam):
+        if use_rcparam:
+            context = {'xtick.minor.ndivs': n, 'ytick.minor.ndivs': n}
+            kwargs = {}
+        else:
+            context = {}
+            kwargs = {'n': n}
+
+        with mpl.rc_context(context):
+            fig, ax = plt.subplots()
+            ax.set_xlim(*lim)
+            ax.set_ylim(*lim)
+            ax.xaxis.set_major_locator(mticker.MultipleLocator(1))
+            ax.xaxis.set_minor_locator(mticker.AutoMinorLocator(**kwargs))
+            ax.yaxis.set_major_locator(mticker.MultipleLocator(1))
+            ax.yaxis.set_minor_locator(mticker.AutoMinorLocator(**kwargs))
+            assert_almost_equal(ax.xaxis.get_ticklocs(minor=True), ref)
+            assert_almost_equal(ax.yaxis.get_ticklocs(minor=True), ref)
+
+
+class TestLogLocator:
+    def test_basic(self):
+        loc = mticker.LogLocator(numticks=5)
+        with pytest.raises(ValueError):
+            loc.tick_values(0, 1000)
+
+        test_value = np.array([1.00000000e-05, 1.00000000e-03, 1.00000000e-01,
+                               1.00000000e+01, 1.00000000e+03, 1.00000000e+05,
+                               1.00000000e+07, 1.000000000e+09])
+        assert_almost_equal(loc.tick_values(0.001, 1.1e5), test_value)
+
+        loc = mticker.LogLocator(base=2)
+        test_value = np.array([0.5, 1., 2., 4., 8., 16., 32., 64., 128., 256.])
+        assert_almost_equal(loc.tick_values(1, 100), test_value)
+
+    def test_polar_axes(self):
+        """
+        Polar Axes have a different ticking logic.
+        """
+        fig, ax = plt.subplots(subplot_kw={'projection': 'polar'})
+        ax.set_yscale('log')
+        ax.set_ylim(1, 100)
+        assert_array_equal(ax.get_yticks(), [10, 100, 1000])
+
+    def test_switch_to_autolocator(self):
+        loc = mticker.LogLocator(subs="all")
+        assert_array_equal(loc.tick_values(0.45, 0.55),
+                           [0.44, 0.46, 0.48, 0.5, 0.52, 0.54, 0.56])
+        # check that we *skip* 1.0, and 10, because this is a minor locator
+        loc = mticker.LogLocator(subs=np.arange(2, 10))
+        assert 1.0 not in loc.tick_values(0.9, 20.)
+        assert 10.0 not in loc.tick_values(0.9, 20.)
+
+    def test_set_params(self):
+        """
+        Create log locator with default value, base=10.0, subs=[1.0],
+        numticks=15 and change it to something else.
+        See if change was successful. Should not raise exception.
+        """
+        loc = mticker.LogLocator()
+        loc.set_params(numticks=7, subs=[2.0], base=4)
+        assert loc.numticks == 7
+        assert loc._base == 4
+        assert list(loc._subs) == [2.0]
+
+    def test_tick_values_correct(self):
+        ll = mticker.LogLocator(subs=(1, 2, 5))
+        test_value = np.array([1.e-01, 2.e-01, 5.e-01, 1.e+00, 2.e+00, 5.e+00,
+                               1.e+01, 2.e+01, 5.e+01, 1.e+02, 2.e+02, 5.e+02,
+                               1.e+03, 2.e+03, 5.e+03, 1.e+04, 2.e+04, 5.e+04,
+                               1.e+05, 2.e+05, 5.e+05, 1.e+06, 2.e+06, 5.e+06,
+                               1.e+07, 2.e+07, 5.e+07, 1.e+08, 2.e+08, 5.e+08])
+        assert_almost_equal(ll.tick_values(1, 1e7), test_value)
+
+    def test_tick_values_not_empty(self):
+        mpl.rcParams['_internal.classic_mode'] = False
+        ll = mticker.LogLocator(subs=(1, 2, 5))
+        test_value = np.array([1.e-01, 2.e-01, 5.e-01, 1.e+00, 2.e+00, 5.e+00,
+                               1.e+01, 2.e+01, 5.e+01, 1.e+02, 2.e+02, 5.e+02,
+                               1.e+03, 2.e+03, 5.e+03, 1.e+04, 2.e+04, 5.e+04,
+                               1.e+05, 2.e+05, 5.e+05, 1.e+06, 2.e+06, 5.e+06,
+                               1.e+07, 2.e+07, 5.e+07, 1.e+08, 2.e+08, 5.e+08,
+                               1.e+09, 2.e+09, 5.e+09])
+        assert_almost_equal(ll.tick_values(1, 1e8), test_value)
+
+    def test_multiple_shared_axes(self):
+        rng = np.random.default_rng(19680801)
+        dummy_data = [rng.normal(size=100), [], []]
+        fig, axes = plt.subplots(len(dummy_data), sharex=True, sharey=True)
+
+        for ax, data in zip(axes.flatten(), dummy_data):
+            ax.hist(data, bins=10)
+            ax.set_yscale('log', nonpositive='clip')
+
+        for ax in axes.flatten():
+            assert all(ax.get_yticks() == axes[0].get_yticks())
+            assert ax.get_ylim() == axes[0].get_ylim()
+
+
+class TestNullLocator:
+    def test_set_params(self):
+        """
+        Create null locator, and attempt to call set_params() on it.
+        Should not exception, and should raise a warning.
+        """
+        loc = mticker.NullLocator()
+        with pytest.warns(UserWarning):
+            loc.set_params()
+
+
+class _LogitHelper:
+    @staticmethod
+    def isclose(x, y):
+        return (np.isclose(-np.log(1/x-1), -np.log(1/y-1))
+                if 0 < x < 1 and 0 < y < 1 else False)
+
+    @staticmethod
+    def assert_almost_equal(x, y):
+        ax = np.array(x)
+        ay = np.array(y)
+        assert np.all(ax > 0) and np.all(ax < 1)
+        assert np.all(ay > 0) and np.all(ay < 1)
+        lx = -np.log(1/ax-1)
+        ly = -np.log(1/ay-1)
+        assert_almost_equal(lx, ly)
+
+
+class TestLogitLocator:
+    ref_basic_limits = [
+        (5e-2, 1 - 5e-2),
+        (5e-3, 1 - 5e-3),
+        (5e-4, 1 - 5e-4),
+        (5e-5, 1 - 5e-5),
+        (5e-6, 1 - 5e-6),
+        (5e-7, 1 - 5e-7),
+        (5e-8, 1 - 5e-8),
+        (5e-9, 1 - 5e-9),
+    ]
+
+    ref_basic_major_ticks = [
+        1 / (10 ** np.arange(1, 3)),
+        1 / (10 ** np.arange(1, 4)),
+        1 / (10 ** np.arange(1, 5)),
+        1 / (10 ** np.arange(1, 6)),
+        1 / (10 ** np.arange(1, 7)),
+        1 / (10 ** np.arange(1, 8)),
+        1 / (10 ** np.arange(1, 9)),
+        1 / (10 ** np.arange(1, 10)),
+    ]
+
+    ref_maxn_limits = [(0.4, 0.6), (5e-2, 2e-1), (1 - 2e-1, 1 - 5e-2)]
+
+    @pytest.mark.parametrize(
+        "lims, expected_low_ticks",
+        zip(ref_basic_limits, ref_basic_major_ticks),
+    )
+    def test_basic_major(self, lims, expected_low_ticks):
+        """
+        Create logit locator with huge number of major, and tests ticks.
+        """
+        expected_ticks = sorted(
+            [*expected_low_ticks, 0.5, *(1 - expected_low_ticks)]
+        )
+        loc = mticker.LogitLocator(nbins=100)
+        _LogitHelper.assert_almost_equal(
+            loc.tick_values(*lims),
+            expected_ticks
+        )
+
+    @pytest.mark.parametrize("lims", ref_maxn_limits)
+    def test_maxn_major(self, lims):
+        """
+        When the axis is zoomed, the locator must have the same behavior as
+        MaxNLocator.
+        """
+        loc = mticker.LogitLocator(nbins=100)
+        maxn_loc = mticker.MaxNLocator(nbins=100, steps=[1, 2, 5, 10])
+        for nbins in (4, 8, 16):
+            loc.set_params(nbins=nbins)
+            maxn_loc.set_params(nbins=nbins)
+            ticks = loc.tick_values(*lims)
+            maxn_ticks = maxn_loc.tick_values(*lims)
+            assert ticks.shape == maxn_ticks.shape
+            assert (ticks == maxn_ticks).all()
+
+    @pytest.mark.parametrize("lims", ref_basic_limits + ref_maxn_limits)
+    def test_nbins_major(self, lims):
+        """
+        Assert logit locator for respecting nbins param.
+        """
+
+        basic_needed = int(-np.floor(np.log10(lims[0]))) * 2 + 1
+        loc = mticker.LogitLocator(nbins=100)
+        for nbins in range(basic_needed, 2, -1):
+            loc.set_params(nbins=nbins)
+            assert len(loc.tick_values(*lims)) <= nbins + 2
+
+    @pytest.mark.parametrize(
+        "lims, expected_low_ticks",
+        zip(ref_basic_limits, ref_basic_major_ticks),
+    )
+    def test_minor(self, lims, expected_low_ticks):
+        """
+        In large scale, test the presence of minor,
+        and assert no minor when major are subsampled.
+        """
+
+        expected_ticks = sorted(
+            [*expected_low_ticks, 0.5, *(1 - expected_low_ticks)]
+        )
+        basic_needed = len(expected_ticks)
+        loc = mticker.LogitLocator(nbins=100)
+        minor_loc = mticker.LogitLocator(nbins=100, minor=True)
+        for nbins in range(basic_needed, 2, -1):
+            loc.set_params(nbins=nbins)
+            minor_loc.set_params(nbins=nbins)
+            major_ticks = loc.tick_values(*lims)
+            minor_ticks = minor_loc.tick_values(*lims)
+            if len(major_ticks) >= len(expected_ticks):
+                # no subsample, we must have a lot of minors ticks
+                assert (len(major_ticks) - 1) * 5 < len(minor_ticks)
+            else:
+                # subsample
+                _LogitHelper.assert_almost_equal(
+                    sorted([*major_ticks, *minor_ticks]), expected_ticks)
+
+    def test_minor_attr(self):
+        loc = mticker.LogitLocator(nbins=100)
+        assert not loc.minor
+        loc.minor = True
+        assert loc.minor
+        loc.set_params(minor=False)
+        assert not loc.minor
+
+    acceptable_vmin_vmax = [
+        *(2.5 ** np.arange(-3, 0)),
+        *(1 - 2.5 ** np.arange(-3, 0)),
+    ]
+
+    @pytest.mark.parametrize(
+        "lims",
+        [
+            (a, b)
+            for (a, b) in itertools.product(acceptable_vmin_vmax, repeat=2)
+            if a != b
+        ],
+    )
+    def test_nonsingular_ok(self, lims):
+        """
+        Create logit locator, and test the nonsingular method for acceptable
+        value
+        """
+        loc = mticker.LogitLocator()
+        lims2 = loc.nonsingular(*lims)
+        assert sorted(lims) == sorted(lims2)
+
+    @pytest.mark.parametrize("okval", acceptable_vmin_vmax)
+    def test_nonsingular_nok(self, okval):
+        """
+        Create logit locator, and test the nonsingular method for non
+        acceptable value
+        """
+        loc = mticker.LogitLocator()
+        vmin, vmax = (-1, okval)
+        vmin2, vmax2 = loc.nonsingular(vmin, vmax)
+        assert vmax2 == vmax
+        assert 0 < vmin2 < vmax2
+        vmin, vmax = (okval, 2)
+        vmin2, vmax2 = loc.nonsingular(vmin, vmax)
+        assert vmin2 == vmin
+        assert vmin2 < vmax2 < 1
+
+
+class TestFixedLocator:
+    def test_set_params(self):
+        """
+        Create fixed locator with 5 nbins, and change it to something else.
+        See if change was successful.
+        Should not exception.
+        """
+        fixed = mticker.FixedLocator(range(0, 24), nbins=5)
+        fixed.set_params(nbins=7)
+        assert fixed.nbins == 7
+
+
+class TestIndexLocator:
+    def test_set_params(self):
+        """
+        Create index locator with 3 base, 4 offset. and change it to something
+        else. See if change was successful.
+        Should not exception.
+        """
+        index = mticker.IndexLocator(base=3, offset=4)
+        index.set_params(base=7, offset=7)
+        assert index._base == 7
+        assert index.offset == 7
+
+
+class TestSymmetricalLogLocator:
+    def test_set_params(self):
+        """
+        Create symmetrical log locator with default subs =[1.0] numticks = 15,
+        and change it to something else.
+        See if change was successful.
+        Should not exception.
+        """
+        sym = mticker.SymmetricalLogLocator(base=10, linthresh=1)
+        sym.set_params(subs=[2.0], numticks=8)
+        assert sym._subs == [2.0]
+        assert sym.numticks == 8
+
+    @pytest.mark.parametrize(
+            'vmin, vmax, expected',
+            [
+                (0, 1, [0, 1]),
+                (-1, 1, [-1, 0, 1]),
+            ],
+    )
+    def test_values(self, vmin, vmax, expected):
+        # https://github.com/matplotlib/matplotlib/issues/25945
+        sym = mticker.SymmetricalLogLocator(base=10, linthresh=1)
+        ticks = sym.tick_values(vmin=vmin, vmax=vmax)
+        assert_array_equal(ticks, expected)
+
+    def test_subs(self):
+        sym = mticker.SymmetricalLogLocator(base=10, linthresh=1, subs=[2.0, 4.0])
+        sym.create_dummy_axis()
+        sym.axis.set_view_interval(-10, 10)
+        assert_array_equal(sym(), [-20, -40, -2, -4, 0, 2, 4, 20, 40])
+
+    def test_extending(self):
+        sym = mticker.SymmetricalLogLocator(base=10, linthresh=1)
+        sym.create_dummy_axis()
+        sym.axis.set_view_interval(8, 9)
+        assert (sym() == [1.0]).all()
+        sym.axis.set_view_interval(8, 12)
+        assert (sym() == [1.0, 10.0]).all()
+        assert sym.view_limits(10, 10) == (1, 100)
+        assert sym.view_limits(-10, -10) == (-100, -1)
+        assert sym.view_limits(0, 0) == (-0.001, 0.001)
+
+
+class TestAsinhLocator:
+    def test_init(self):
+        lctr = mticker.AsinhLocator(linear_width=2.718, numticks=19)
+        assert lctr.linear_width == 2.718
+        assert lctr.numticks == 19
+        assert lctr.base == 10
+
+    def test_set_params(self):
+        lctr = mticker.AsinhLocator(linear_width=5,
+                                    numticks=17, symthresh=0.125,
+                                    base=4, subs=(2.5, 3.25))
+        assert lctr.numticks == 17
+        assert lctr.symthresh == 0.125
+        assert lctr.base == 4
+        assert lctr.subs == (2.5, 3.25)
+
+        lctr.set_params(numticks=23)
+        assert lctr.numticks == 23
+        lctr.set_params(None)
+        assert lctr.numticks == 23
+
+        lctr.set_params(symthresh=0.5)
+        assert lctr.symthresh == 0.5
+        lctr.set_params(symthresh=None)
+        assert lctr.symthresh == 0.5
+
+        lctr.set_params(base=7)
+        assert lctr.base == 7
+        lctr.set_params(base=None)
+        assert lctr.base == 7
+
+        lctr.set_params(subs=(2, 4.125))
+        assert lctr.subs == (2, 4.125)
+        lctr.set_params(subs=None)
+        assert lctr.subs == (2, 4.125)
+        lctr.set_params(subs=[])
+        assert lctr.subs is None
+
+    def test_linear_values(self):
+        lctr = mticker.AsinhLocator(linear_width=100, numticks=11, base=0)
+
+        assert_almost_equal(lctr.tick_values(-1, 1),
+                            np.arange(-1, 1.01, 0.2))
+        assert_almost_equal(lctr.tick_values(-0.1, 0.1),
+                            np.arange(-0.1, 0.101, 0.02))
+        assert_almost_equal(lctr.tick_values(-0.01, 0.01),
+                            np.arange(-0.01, 0.0101, 0.002))
+
+    def test_wide_values(self):
+        lctr = mticker.AsinhLocator(linear_width=0.1, numticks=11, base=0)
+
+        assert_almost_equal(lctr.tick_values(-100, 100),
+                            [-100, -20, -5, -1, -0.2,
+                             0, 0.2, 1, 5, 20, 100])
+        assert_almost_equal(lctr.tick_values(-1000, 1000),
+                            [-1000, -100, -20, -3, -0.4,
+                             0, 0.4, 3, 20, 100, 1000])
+
+    def test_near_zero(self):
+        """Check that manually injected zero will supersede nearby tick"""
+        lctr = mticker.AsinhLocator(linear_width=100, numticks=3, base=0)
+
+        assert_almost_equal(lctr.tick_values(-1.1, 0.9), [-1.0, 0.0, 0.9])
+
+    def test_fallback(self):
+        lctr = mticker.AsinhLocator(1.0, numticks=11)
+
+        assert_almost_equal(lctr.tick_values(101, 102),
+                            np.arange(101, 102.01, 0.1))
+
+    def test_symmetrizing(self):
+        lctr = mticker.AsinhLocator(linear_width=1, numticks=3,
+                                    symthresh=0.25, base=0)
+        lctr.create_dummy_axis()
+
+        lctr.axis.set_view_interval(-1, 2)
+        assert_almost_equal(lctr(), [-1, 0, 2])
+
+        lctr.axis.set_view_interval(-1, 0.9)
+        assert_almost_equal(lctr(), [-1, 0, 1])
+
+        lctr.axis.set_view_interval(-0.85, 1.05)
+        assert_almost_equal(lctr(), [-1, 0, 1])
+
+        lctr.axis.set_view_interval(1, 1.1)
+        assert_almost_equal(lctr(), [1, 1.05, 1.1])
+
+    def test_base_rounding(self):
+        lctr10 = mticker.AsinhLocator(linear_width=1, numticks=8,
+                                      base=10, subs=(1, 3, 5))
+        assert_almost_equal(lctr10.tick_values(-110, 110),
+                            [-500, -300, -100, -50, -30, -10, -5, -3, -1,
+                             -0.5, -0.3, -0.1, 0, 0.1, 0.3, 0.5,
+                             1, 3, 5, 10, 30, 50, 100, 300, 500])
+
+        lctr5 = mticker.AsinhLocator(linear_width=1, numticks=20, base=5)
+        assert_almost_equal(lctr5.tick_values(-1050, 1050),
+                            [-625, -125, -25, -5, -1, -0.2, 0,
+                             0.2, 1, 5, 25, 125, 625])
+
+
+class TestScalarFormatter:
+    offset_data = [
+        (123, 189, 0),
+        (-189, -123, 0),
+        (12341, 12349, 12340),
+        (-12349, -12341, -12340),
+        (99999.5, 100010.5, 100000),
+        (-100010.5, -99999.5, -100000),
+        (99990.5, 100000.5, 100000),
+        (-100000.5, -99990.5, -100000),
+        (1233999, 1234001, 1234000),
+        (-1234001, -1233999, -1234000),
+        (1, 1, 1),
+        (123, 123, 0),
+        # Test cases courtesy of @WeatherGod
+        (.4538, .4578, .45),
+        (3789.12, 3783.1, 3780),
+        (45124.3, 45831.75, 45000),
+        (0.000721, 0.0007243, 0.00072),
+        (12592.82, 12591.43, 12590),
+        (9., 12., 0),
+        (900., 1200., 0),
+        (1900., 1200., 0),
+        (0.99, 1.01, 1),
+        (9.99, 10.01, 10),
+        (99.99, 100.01, 100),
+        (5.99, 6.01, 6),
+        (15.99, 16.01, 16),
+        (-0.452, 0.492, 0),
+        (-0.492, 0.492, 0),
+        (12331.4, 12350.5, 12300),
+        (-12335.3, 12335.3, 0),
+    ]
+
+    use_offset_data = [True, False]
+
+    useMathText_data = [True, False]
+
+    #  (sci_type, scilimits, lim, orderOfMag, fewticks)
+    scilimits_data = [
+        (False, (0, 0), (10.0, 20.0), 0, False),
+        (True, (-2, 2), (-10, 20), 0, False),
+        (True, (-2, 2), (-20, 10), 0, False),
+        (True, (-2, 2), (-110, 120), 2, False),
+        (True, (-2, 2), (-120, 110), 2, False),
+        (True, (-2, 2), (-.001, 0.002), -3, False),
+        (True, (-7, 7), (0.18e10, 0.83e10), 9, True),
+        (True, (0, 0), (-1e5, 1e5), 5, False),
+        (True, (6, 6), (-1e5, 1e5), 6, False),
+    ]
+
+    cursor_data = [
+        [0., "0.000"],
+        [0.0123, "0.012"],
+        [0.123, "0.123"],
+        [1.23,  "1.230"],
+        [12.3, "12.300"],
+    ]
+
+    format_data = [
+        (.1, "1e-1"),
+        (.11, "1.1e-1"),
+        (1e8, "1e8"),
+        (1.1e8, "1.1e8"),
+    ]
+
+    @pytest.mark.parametrize('unicode_minus, result',
+                             [(True, "\N{MINUS SIGN}1"), (False, "-1")])
+    def test_unicode_minus(self, unicode_minus, result):
+        mpl.rcParams['axes.unicode_minus'] = unicode_minus
+        assert (
+            plt.gca().xaxis.get_major_formatter().format_data_short(-1).strip()
+            == result)
+
+    @pytest.mark.parametrize('left, right, offset', offset_data)
+    def test_offset_value(self, left, right, offset):
+        fig, ax = plt.subplots()
+        formatter = ax.xaxis.get_major_formatter()
+
+        with (pytest.warns(UserWarning, match='Attempting to set identical')
+              if left == right else nullcontext()):
+            ax.set_xlim(left, right)
+        ax.xaxis._update_ticks()
+        assert formatter.offset == offset
+
+        with (pytest.warns(UserWarning, match='Attempting to set identical')
+              if left == right else nullcontext()):
+            ax.set_xlim(right, left)
+        ax.xaxis._update_ticks()
+        assert formatter.offset == offset
+
+    @pytest.mark.parametrize('use_offset', use_offset_data)
+    def test_use_offset(self, use_offset):
+        with mpl.rc_context({'axes.formatter.useoffset': use_offset}):
+            tmp_form = mticker.ScalarFormatter()
+            assert use_offset == tmp_form.get_useOffset()
+            assert tmp_form.offset == 0
+
+    @pytest.mark.parametrize('use_math_text', useMathText_data)
+    def test_useMathText(self, use_math_text):
+        with mpl.rc_context({'axes.formatter.use_mathtext': use_math_text}):
+            tmp_form = mticker.ScalarFormatter()
+            assert use_math_text == tmp_form.get_useMathText()
+
+    def test_set_use_offset_float(self):
+        tmp_form = mticker.ScalarFormatter()
+        tmp_form.set_useOffset(0.5)
+        assert not tmp_form.get_useOffset()
+        assert tmp_form.offset == 0.5
+
+    def test_use_locale(self):
+        conv = locale.localeconv()
+        sep = conv['thousands_sep']
+        if not sep or conv['grouping'][-1:] in ([], [locale.CHAR_MAX]):
+            pytest.skip('Locale does not apply grouping')  # pragma: no cover
+
+        with mpl.rc_context({'axes.formatter.use_locale': True}):
+            tmp_form = mticker.ScalarFormatter()
+            assert tmp_form.get_useLocale()
+
+            tmp_form.create_dummy_axis()
+            tmp_form.axis.set_data_interval(0, 10)
+            tmp_form.set_locs([1, 2, 3])
+            assert sep in tmp_form(1e9)
+
+    @pytest.mark.parametrize(
+        'sci_type, scilimits, lim, orderOfMag, fewticks', scilimits_data)
+    def test_scilimits(self, sci_type, scilimits, lim, orderOfMag, fewticks):
+        tmp_form = mticker.ScalarFormatter()
+        tmp_form.set_scientific(sci_type)
+        tmp_form.set_powerlimits(scilimits)
+        fig, ax = plt.subplots()
+        ax.yaxis.set_major_formatter(tmp_form)
+        ax.set_ylim(*lim)
+        if fewticks:
+            ax.yaxis.set_major_locator(mticker.MaxNLocator(4))
+
+        tmp_form.set_locs(ax.yaxis.get_majorticklocs())
+        assert orderOfMag == tmp_form.orderOfMagnitude
+
+    @pytest.mark.parametrize('value, expected', format_data)
+    def test_format_data(self, value, expected):
+        mpl.rcParams['axes.unicode_minus'] = False
+        sf = mticker.ScalarFormatter()
+        assert sf.format_data(value) == expected
+
+    @pytest.mark.parametrize('data, expected', cursor_data)
+    def test_cursor_precision(self, data, expected):
+        fig, ax = plt.subplots()
+        ax.set_xlim(-1, 1)  # Pointing precision of 0.001.
+        fmt = ax.xaxis.get_major_formatter().format_data_short
+        assert fmt(data) == expected
+
+    @pytest.mark.parametrize('data, expected', cursor_data)
+    def test_cursor_dummy_axis(self, data, expected):
+        # Issue #17624
+        sf = mticker.ScalarFormatter()
+        sf.create_dummy_axis()
+        sf.axis.set_view_interval(0, 10)
+        fmt = sf.format_data_short
+        assert fmt(data) == expected
+        assert sf.axis.get_tick_space() == 9
+        assert sf.axis.get_minpos() == 0
+
+    def test_mathtext_ticks(self):
+        mpl.rcParams.update({
+            'font.family': 'serif',
+            'font.serif': 'cmr10',
+            'axes.formatter.use_mathtext': False
+        })
+
+        if parse_version(pytest.__version__).major < 8:
+            with pytest.warns(UserWarning, match='cmr10 font should ideally'):
+                fig, ax = plt.subplots()
+                ax.set_xticks([-1, 0, 1])
+                fig.canvas.draw()
+        else:
+            with (pytest.warns(UserWarning, match="Glyph 8722"),
+                  pytest.warns(UserWarning, match='cmr10 font should ideally')):
+                fig, ax = plt.subplots()
+                ax.set_xticks([-1, 0, 1])
+                fig.canvas.draw()
+
+    def test_cmr10_substitutions(self, caplog):
+        mpl.rcParams.update({
+            'font.family': 'cmr10',
+            'mathtext.fontset': 'cm',
+            'axes.formatter.use_mathtext': True,
+        })
+
+        # Test that it does not log a warning about missing glyphs.
+        with caplog.at_level(logging.WARNING, logger='matplotlib.mathtext'):
+            fig, ax = plt.subplots()
+            ax.plot([-0.03, 0.05], [40, 0.05])
+            ax.set_yscale('log')
+            yticks = [0.02, 0.3, 4, 50]
+            formatter = mticker.LogFormatterSciNotation()
+            ax.set_yticks(yticks, map(formatter, yticks))
+            fig.canvas.draw()
+            assert not caplog.text
+
+    def test_empty_locs(self):
+        sf = mticker.ScalarFormatter()
+        sf.set_locs([])
+        assert sf(0.5) == ''
+
+
+class TestLogFormatterExponent:
+    param_data = [
+        (True, 4, np.arange(-3, 4.0), np.arange(-3, 4.0),
+         ['-3', '-2', '-1', '0', '1', '2', '3']),
+        # With labelOnlyBase=False, non-integer powers should be nicely
+        # formatted.
+        (False, 10, np.array([0.1, 0.00001, np.pi, 0.2, -0.2, -0.00001]),
+         range(6), ['0.1', '1e-05', '3.14', '0.2', '-0.2', '-1e-05']),
+        (False, 50, np.array([3, 5, 12, 42], dtype=float), range(6),
+         ['3', '5', '12', '42']),
+    ]
+
+    base_data = [2.0, 5.0, 10.0, np.pi, np.e]
+
+    @pytest.mark.parametrize(
+            'labelOnlyBase, exponent, locs, positions, expected', param_data)
+    @pytest.mark.parametrize('base', base_data)
+    def test_basic(self, labelOnlyBase, base, exponent, locs, positions,
+                   expected):
+        formatter = mticker.LogFormatterExponent(base=base,
+                                                 labelOnlyBase=labelOnlyBase)
+        formatter.create_dummy_axis()
+        formatter.axis.set_view_interval(1, base**exponent)
+        vals = base**locs
+        labels = [formatter(x, pos) for (x, pos) in zip(vals, positions)]
+        expected = [label.replace('-', '\N{Minus Sign}') for label in expected]
+        assert labels == expected
+
+    def test_blank(self):
+        # Should be a blank string for non-integer powers if labelOnlyBase=True
+        formatter = mticker.LogFormatterExponent(base=10, labelOnlyBase=True)
+        formatter.create_dummy_axis()
+        formatter.axis.set_view_interval(1, 10)
+        assert formatter(10**0.1) == ''
+
+
+class TestLogFormatterMathtext:
+    fmt = mticker.LogFormatterMathtext()
+    test_data = [
+        (0, 1, '$\\mathdefault{10^{0}}$'),
+        (0, 1e-2, '$\\mathdefault{10^{-2}}$'),
+        (0, 1e2, '$\\mathdefault{10^{2}}$'),
+        (3, 1, '$\\mathdefault{1}$'),
+        (3, 1e-2, '$\\mathdefault{0.01}$'),
+        (3, 1e2, '$\\mathdefault{100}$'),
+        (3, 1e-3, '$\\mathdefault{10^{-3}}$'),
+        (3, 1e3, '$\\mathdefault{10^{3}}$'),
+    ]
+
+    @pytest.mark.parametrize('min_exponent, value, expected', test_data)
+    def test_min_exponent(self, min_exponent, value, expected):
+        with mpl.rc_context({'axes.formatter.min_exponent': min_exponent}):
+            assert self.fmt(value) == expected
+
+
+class TestLogFormatterSciNotation:
+    test_data = [
+        (2, 0.03125, '$\\mathdefault{2^{-5}}$'),
+        (2, 1, '$\\mathdefault{2^{0}}$'),
+        (2, 32, '$\\mathdefault{2^{5}}$'),
+        (2, 0.0375, '$\\mathdefault{1.2\\times2^{-5}}$'),
+        (2, 1.2, '$\\mathdefault{1.2\\times2^{0}}$'),
+        (2, 38.4, '$\\mathdefault{1.2\\times2^{5}}$'),
+        (10, -1, '$\\mathdefault{-10^{0}}$'),
+        (10, 1e-05, '$\\mathdefault{10^{-5}}$'),
+        (10, 1, '$\\mathdefault{10^{0}}$'),
+        (10, 100000, '$\\mathdefault{10^{5}}$'),
+        (10, 2e-05, '$\\mathdefault{2\\times10^{-5}}$'),
+        (10, 2, '$\\mathdefault{2\\times10^{0}}$'),
+        (10, 200000, '$\\mathdefault{2\\times10^{5}}$'),
+        (10, 5e-05, '$\\mathdefault{5\\times10^{-5}}$'),
+        (10, 5, '$\\mathdefault{5\\times10^{0}}$'),
+        (10, 500000, '$\\mathdefault{5\\times10^{5}}$'),
+    ]
+
+    @mpl.style.context('default')
+    @pytest.mark.parametrize('base, value, expected', test_data)
+    def test_basic(self, base, value, expected):
+        formatter = mticker.LogFormatterSciNotation(base=base)
+        with mpl.rc_context({'text.usetex': False}):
+            assert formatter(value) == expected
+
+
+class TestLogFormatter:
+    pprint_data = [
+        (3.141592654e-05, 0.001, '3.142e-5'),
+        (0.0003141592654, 0.001, '3.142e-4'),
+        (0.003141592654, 0.001, '3.142e-3'),
+        (0.03141592654, 0.001, '3.142e-2'),
+        (0.3141592654, 0.001, '3.142e-1'),
+        (3.141592654, 0.001, '3.142'),
+        (31.41592654, 0.001, '3.142e1'),
+        (314.1592654, 0.001, '3.142e2'),
+        (3141.592654, 0.001, '3.142e3'),
+        (31415.92654, 0.001, '3.142e4'),
+        (314159.2654, 0.001, '3.142e5'),
+        (1e-05, 0.001, '1e-5'),
+        (0.0001, 0.001, '1e-4'),
+        (0.001, 0.001, '1e-3'),
+        (0.01, 0.001, '1e-2'),
+        (0.1, 0.001, '1e-1'),
+        (1, 0.001, '1'),
+        (10, 0.001, '10'),
+        (100, 0.001, '100'),
+        (1000, 0.001, '1000'),
+        (10000, 0.001, '1e4'),
+        (100000, 0.001, '1e5'),
+        (3.141592654e-05, 0.015, '0'),
+        (0.0003141592654, 0.015, '0'),
+        (0.003141592654, 0.015, '0.003'),
+        (0.03141592654, 0.015, '0.031'),
+        (0.3141592654, 0.015, '0.314'),
+        (3.141592654, 0.015, '3.142'),
+        (31.41592654, 0.015, '31.416'),
+        (314.1592654, 0.015, '314.159'),
+        (3141.592654, 0.015, '3141.593'),
+        (31415.92654, 0.015, '31415.927'),
+        (314159.2654, 0.015, '314159.265'),
+        (1e-05, 0.015, '0'),
+        (0.0001, 0.015, '0'),
+        (0.001, 0.015, '0.001'),
+        (0.01, 0.015, '0.01'),
+        (0.1, 0.015, '0.1'),
+        (1, 0.015, '1'),
+        (10, 0.015, '10'),
+        (100, 0.015, '100'),
+        (1000, 0.015, '1000'),
+        (10000, 0.015, '10000'),
+        (100000, 0.015, '100000'),
+        (3.141592654e-05, 0.5, '0'),
+        (0.0003141592654, 0.5, '0'),
+        (0.003141592654, 0.5, '0.003'),
+        (0.03141592654, 0.5, '0.031'),
+        (0.3141592654, 0.5, '0.314'),
+        (3.141592654, 0.5, '3.142'),
+        (31.41592654, 0.5, '31.416'),
+        (314.1592654, 0.5, '314.159'),
+        (3141.592654, 0.5, '3141.593'),
+        (31415.92654, 0.5, '31415.927'),
+        (314159.2654, 0.5, '314159.265'),
+        (1e-05, 0.5, '0'),
+        (0.0001, 0.5, '0'),
+        (0.001, 0.5, '0.001'),
+        (0.01, 0.5, '0.01'),
+        (0.1, 0.5, '0.1'),
+        (1, 0.5, '1'),
+        (10, 0.5, '10'),
+        (100, 0.5, '100'),
+        (1000, 0.5, '1000'),
+        (10000, 0.5, '10000'),
+        (100000, 0.5, '100000'),
+        (3.141592654e-05, 5, '0'),
+        (0.0003141592654, 5, '0'),
+        (0.003141592654, 5, '0'),
+        (0.03141592654, 5, '0.03'),
+        (0.3141592654, 5, '0.31'),
+        (3.141592654, 5, '3.14'),
+        (31.41592654, 5, '31.42'),
+        (314.1592654, 5, '314.16'),
+        (3141.592654, 5, '3141.59'),
+        (31415.92654, 5, '31415.93'),
+        (314159.2654, 5, '314159.27'),
+        (1e-05, 5, '0'),
+        (0.0001, 5, '0'),
+        (0.001, 5, '0'),
+        (0.01, 5, '0.01'),
+        (0.1, 5, '0.1'),
+        (1, 5, '1'),
+        (10, 5, '10'),
+        (100, 5, '100'),
+        (1000, 5, '1000'),
+        (10000, 5, '10000'),
+        (100000, 5, '100000'),
+        (3.141592654e-05, 100, '0'),
+        (0.0003141592654, 100, '0'),
+        (0.003141592654, 100, '0'),
+        (0.03141592654, 100, '0'),
+        (0.3141592654, 100, '0.3'),
+        (3.141592654, 100, '3.1'),
+        (31.41592654, 100, '31.4'),
+        (314.1592654, 100, '314.2'),
+        (3141.592654, 100, '3141.6'),
+        (31415.92654, 100, '31415.9'),
+        (314159.2654, 100, '314159.3'),
+        (1e-05, 100, '0'),
+        (0.0001, 100, '0'),
+        (0.001, 100, '0'),
+        (0.01, 100, '0'),
+        (0.1, 100, '0.1'),
+        (1, 100, '1'),
+        (10, 100, '10'),
+        (100, 100, '100'),
+        (1000, 100, '1000'),
+        (10000, 100, '10000'),
+        (100000, 100, '100000'),
+        (3.141592654e-05, 1000000.0, '3.1e-5'),
+        (0.0003141592654, 1000000.0, '3.1e-4'),
+        (0.003141592654, 1000000.0, '3.1e-3'),
+        (0.03141592654, 1000000.0, '3.1e-2'),
+        (0.3141592654, 1000000.0, '3.1e-1'),
+        (3.141592654, 1000000.0, '3.1'),
+        (31.41592654, 1000000.0, '3.1e1'),
+        (314.1592654, 1000000.0, '3.1e2'),
+        (3141.592654, 1000000.0, '3.1e3'),
+        (31415.92654, 1000000.0, '3.1e4'),
+        (314159.2654, 1000000.0, '3.1e5'),
+        (1e-05, 1000000.0, '1e-5'),
+        (0.0001, 1000000.0, '1e-4'),
+        (0.001, 1000000.0, '1e-3'),
+        (0.01, 1000000.0, '1e-2'),
+        (0.1, 1000000.0, '1e-1'),
+        (1, 1000000.0, '1'),
+        (10, 1000000.0, '10'),
+        (100, 1000000.0, '100'),
+        (1000, 1000000.0, '1000'),
+        (10000, 1000000.0, '1e4'),
+        (100000, 1000000.0, '1e5'),
+    ]
+
+    @pytest.mark.parametrize('value, domain, expected', pprint_data)
+    def test_pprint(self, value, domain, expected):
+        fmt = mticker.LogFormatter()
+        label = fmt._pprint_val(value, domain)
+        assert label == expected
+
+    @pytest.mark.parametrize('value, long, short', [
+        (0.0, "0", "0"),
+        (0, "0", "0"),
+        (-1.0, "-10^0", "-1"),
+        (2e-10, "2x10^-10", "2e-10"),
+        (1e10, "10^10", "1e+10"),
+    ])
+    def test_format_data(self, value, long, short):
+        fig, ax = plt.subplots()
+        ax.set_xscale('log')
+        fmt = ax.xaxis.get_major_formatter()
+        assert fmt.format_data(value) == long
+        assert fmt.format_data_short(value) == short
+
+    def _sub_labels(self, axis, subs=()):
+        """Test whether locator marks subs to be labeled."""
+        fmt = axis.get_minor_formatter()
+        minor_tlocs = axis.get_minorticklocs()
+        fmt.set_locs(minor_tlocs)
+        coefs = minor_tlocs / 10**(np.floor(np.log10(minor_tlocs)))
+        label_expected = [round(c) in subs for c in coefs]
+        label_test = [fmt(x) != '' for x in minor_tlocs]
+        assert label_test == label_expected
+
+    @mpl.style.context('default')
+    def test_sublabel(self):
+        # test label locator
+        fig, ax = plt.subplots()
+        ax.set_xscale('log')
+        ax.xaxis.set_major_locator(mticker.LogLocator(base=10, subs=[]))
+        ax.xaxis.set_minor_locator(mticker.LogLocator(base=10,
+                                                      subs=np.arange(2, 10)))
+        ax.xaxis.set_major_formatter(mticker.LogFormatter(labelOnlyBase=True))
+        ax.xaxis.set_minor_formatter(mticker.LogFormatter(labelOnlyBase=False))
+        # axis range above 3 decades, only bases are labeled
+        ax.set_xlim(1, 1e4)
+        fmt = ax.xaxis.get_major_formatter()
+        fmt.set_locs(ax.xaxis.get_majorticklocs())
+        show_major_labels = [fmt(x) != ''
+                             for x in ax.xaxis.get_majorticklocs()]
+        assert np.all(show_major_labels)
+        self._sub_labels(ax.xaxis, subs=[])
+
+        # For the next two, if the numdec threshold in LogFormatter.set_locs
+        # were 3, then the label sub would be 3 for 2-3 decades and (2, 5)
+        # for 1-2 decades.  With a threshold of 1, subs are not labeled.
+        # axis range at 2 to 3 decades
+        ax.set_xlim(1, 800)
+        self._sub_labels(ax.xaxis, subs=[])
+
+        # axis range at 1 to 2 decades
+        ax.set_xlim(1, 80)
+        self._sub_labels(ax.xaxis, subs=[])
+
+        # axis range at 0.4 to 1 decades, label subs 2, 3, 4, 6
+        ax.set_xlim(1, 8)
+        self._sub_labels(ax.xaxis, subs=[2, 3, 4, 6])
+
+        # axis range at 0 to 0.4 decades, label all
+        ax.set_xlim(0.5, 0.9)
+        self._sub_labels(ax.xaxis, subs=np.arange(2, 10, dtype=int))
+
+    @pytest.mark.parametrize('val', [1, 10, 100, 1000])
+    def test_LogFormatter_call(self, val):
+        # test _num_to_string method used in __call__
+        temp_lf = mticker.LogFormatter()
+        temp_lf.create_dummy_axis()
+        temp_lf.axis.set_view_interval(1, 10)
+        assert temp_lf(val) == str(val)
+
+    @pytest.mark.parametrize('val', [1e-323, 2e-323, 10e-323, 11e-323])
+    def test_LogFormatter_call_tiny(self, val):
+        # test coeff computation in __call__
+        temp_lf = mticker.LogFormatter()
+        temp_lf.create_dummy_axis()
+        temp_lf.axis.set_view_interval(1, 10)
+        temp_lf(val)
+
+
+class TestLogitFormatter:
+    @staticmethod
+    def logit_deformatter(string):
+        r"""
+        Parser to convert string as r'$\mathdefault{1.41\cdot10^{-4}}$' in
+        float 1.41e-4, as '0.5' or as r'$\mathdefault{\frac{1}{2}}$' in float
+        0.5,
+        """
+        match = re.match(
+            r"[^\d]*"
+            r"(?P<comp>1-)?"
+            r"(?P<mant>\d*\.?\d*)?"
+            r"(?:\\cdot)?"
+            r"(?:10\^\{(?P<expo>-?\d*)})?"
+            r"[^\d]*$",
+            string,
+        )
+        if match:
+            comp = match["comp"] is not None
+            mantissa = float(match["mant"]) if match["mant"] else 1
+            expo = int(match["expo"]) if match["expo"] is not None else 0
+            value = mantissa * 10 ** expo
+            if match["mant"] or match["expo"] is not None:
+                if comp:
+                    return 1 - value
+                return value
+        match = re.match(
+            r"[^\d]*\\frac\{(?P<num>\d+)\}\{(?P<deno>\d+)\}[^\d]*$", string
+        )
+        if match:
+            num, deno = float(match["num"]), float(match["deno"])
+            return num / deno
+        raise ValueError("Not formatted by LogitFormatter")
+
+    @pytest.mark.parametrize(
+        "fx, x",
+        [
+            (r"STUFF0.41OTHERSTUFF", 0.41),
+            (r"STUFF1.41\cdot10^{-2}OTHERSTUFF", 1.41e-2),
+            (r"STUFF1-0.41OTHERSTUFF", 1 - 0.41),
+            (r"STUFF1-1.41\cdot10^{-2}OTHERSTUFF", 1 - 1.41e-2),
+            (r"STUFF", None),
+            (r"STUFF12.4e-3OTHERSTUFF", None),
+        ],
+    )
+    def test_logit_deformater(self, fx, x):
+        if x is None:
+            with pytest.raises(ValueError):
+                TestLogitFormatter.logit_deformatter(fx)
+        else:
+            y = TestLogitFormatter.logit_deformatter(fx)
+            assert _LogitHelper.isclose(x, y)
+
+    decade_test = sorted(
+        [10 ** (-i) for i in range(1, 10)]
+        + [1 - 10 ** (-i) for i in range(1, 10)]
+        + [1 / 2]
+    )
+
+    @pytest.mark.parametrize("x", decade_test)
+    def test_basic(self, x):
+        """
+        Test the formatted value correspond to the value for ideal ticks in
+        logit space.
+        """
+        formatter = mticker.LogitFormatter(use_overline=False)
+        formatter.set_locs(self.decade_test)
+        s = formatter(x)
+        x2 = TestLogitFormatter.logit_deformatter(s)
+        assert _LogitHelper.isclose(x, x2)
+
+    @pytest.mark.parametrize("x", (-1, -0.5, -0.1, 1.1, 1.5, 2))
+    def test_invalid(self, x):
+        """
+        Test that invalid value are formatted with empty string without
+        raising exception.
+        """
+        formatter = mticker.LogitFormatter(use_overline=False)
+        formatter.set_locs(self.decade_test)
+        s = formatter(x)
+        assert s == ""
+
+    @pytest.mark.parametrize("x", 1 / (1 + np.exp(-np.linspace(-7, 7, 10))))
+    def test_variablelength(self, x):
+        """
+        The format length should change depending on the neighbor labels.
+        """
+        formatter = mticker.LogitFormatter(use_overline=False)
+        for N in (10, 20, 50, 100, 200, 1000, 2000, 5000, 10000):
+            if x + 1 / N < 1:
+                formatter.set_locs([x - 1 / N, x, x + 1 / N])
+                sx = formatter(x)
+                sx1 = formatter(x + 1 / N)
+                d = (
+                    TestLogitFormatter.logit_deformatter(sx1)
+                    - TestLogitFormatter.logit_deformatter(sx)
+                )
+                assert 0 < d < 2 / N
+
+    lims_minor_major = [
+        (True, (5e-8, 1 - 5e-8), ((25, False), (75, False))),
+        (True, (5e-5, 1 - 5e-5), ((25, False), (75, True))),
+        (True, (5e-2, 1 - 5e-2), ((25, True), (75, True))),
+        (False, (0.75, 0.76, 0.77), ((7, True), (25, True), (75, True))),
+    ]
+
+    @pytest.mark.parametrize("method, lims, cases", lims_minor_major)
+    def test_minor_vs_major(self, method, lims, cases):
+        """
+        Test minor/major displays.
+        """
+
+        if method:
+            min_loc = mticker.LogitLocator(minor=True)
+            ticks = min_loc.tick_values(*lims)
+        else:
+            ticks = np.array(lims)
+        min_form = mticker.LogitFormatter(minor=True)
+        for threshold, has_minor in cases:
+            min_form.set_minor_threshold(threshold)
+            formatted = min_form.format_ticks(ticks)
+            labelled = [f for f in formatted if len(f) > 0]
+            if has_minor:
+                assert len(labelled) > 0, (threshold, has_minor)
+            else:
+                assert len(labelled) == 0, (threshold, has_minor)
+
+    def test_minor_number(self):
+        """
+        Test the parameter minor_number
+        """
+        min_loc = mticker.LogitLocator(minor=True)
+        min_form = mticker.LogitFormatter(minor=True)
+        ticks = min_loc.tick_values(5e-2, 1 - 5e-2)
+        for minor_number in (2, 4, 8, 16):
+            min_form.set_minor_number(minor_number)
+            formatted = min_form.format_ticks(ticks)
+            labelled = [f for f in formatted if len(f) > 0]
+            assert len(labelled) == minor_number
+
+    def test_use_overline(self):
+        """
+        Test the parameter use_overline
+        """
+        x = 1 - 1e-2
+        fx1 = r"$\mathdefault{1-10^{-2}}$"
+        fx2 = r"$\mathdefault{\overline{10^{-2}}}$"
+        form = mticker.LogitFormatter(use_overline=False)
+        assert form(x) == fx1
+        form.use_overline(True)
+        assert form(x) == fx2
+        form.use_overline(False)
+        assert form(x) == fx1
+
+    def test_one_half(self):
+        """
+        Test the parameter one_half
+        """
+        form = mticker.LogitFormatter()
+        assert r"\frac{1}{2}" in form(1/2)
+        form.set_one_half("1/2")
+        assert "1/2" in form(1/2)
+        form.set_one_half("one half")
+        assert "one half" in form(1/2)
+
+    @pytest.mark.parametrize("N", (100, 253, 754))
+    def test_format_data_short(self, N):
+        locs = np.linspace(0, 1, N)[1:-1]
+        form = mticker.LogitFormatter()
+        for x in locs:
+            fx = form.format_data_short(x)
+            if fx.startswith("1-"):
+                x2 = 1 - float(fx[2:])
+            else:
+                x2 = float(fx)
+            assert abs(x - x2) < 1 / N
+
+
+class TestFormatStrFormatter:
+    def test_basic(self):
+        # test % style formatter
+        tmp_form = mticker.FormatStrFormatter('%05d')
+        assert '00002' == tmp_form(2)
+
+
+class TestStrMethodFormatter:
+    test_data = [
+        ('{x:05d}', (2,), False, '00002'),
+        ('{x:05d}', (2,), True, '00002'),
+        ('{x:05d}', (-2,), False, '-0002'),
+        ('{x:05d}', (-2,), True, '\N{MINUS SIGN}0002'),
+        ('{x:03d}-{pos:02d}', (2, 1), False, '002-01'),
+        ('{x:03d}-{pos:02d}', (2, 1), True, '002-01'),
+        ('{x:03d}-{pos:02d}', (-2, 1), False, '-02-01'),
+        ('{x:03d}-{pos:02d}', (-2, 1), True, '\N{MINUS SIGN}02-01'),
+    ]
+
+    @pytest.mark.parametrize('format, input, unicode_minus, expected', test_data)
+    def test_basic(self, format, input, unicode_minus, expected):
+        with mpl.rc_context({"axes.unicode_minus": unicode_minus}):
+            fmt = mticker.StrMethodFormatter(format)
+            assert fmt(*input) == expected
+
+
+class TestEngFormatter:
+    # (unicode_minus, input, expected) where ''expected'' corresponds to the
+    # outputs respectively returned when (places=None, places=0, places=2)
+    # unicode_minus is a boolean value for the rcParam['axes.unicode_minus']
+    raw_format_data = [
+        (False, -1234.56789, ('-1.23457 k', '-1 k', '-1.23 k')),
+        (True, -1234.56789, ('\N{MINUS SIGN}1.23457 k', '\N{MINUS SIGN}1 k',
+                             '\N{MINUS SIGN}1.23 k')),
+        (False, -1.23456789, ('-1.23457', '-1', '-1.23')),
+        (True, -1.23456789, ('\N{MINUS SIGN}1.23457', '\N{MINUS SIGN}1',
+                             '\N{MINUS SIGN}1.23')),
+        (False, -0.123456789, ('-123.457 m', '-123 m', '-123.46 m')),
+        (True, -0.123456789, ('\N{MINUS SIGN}123.457 m', '\N{MINUS SIGN}123 m',
+                              '\N{MINUS SIGN}123.46 m')),
+        (False, -0.00123456789, ('-1.23457 m', '-1 m', '-1.23 m')),
+        (True, -0.00123456789, ('\N{MINUS SIGN}1.23457 m', '\N{MINUS SIGN}1 m',
+                                '\N{MINUS SIGN}1.23 m')),
+        (True, -0.0, ('0', '0', '0.00')),
+        (True, -0, ('0', '0', '0.00')),
+        (True, 0, ('0', '0', '0.00')),
+        (True, 1.23456789e-6, ('1.23457 µ', '1 µ', '1.23 µ')),
+        (True, 0.123456789, ('123.457 m', '123 m', '123.46 m')),
+        (True, 0.1, ('100 m', '100 m', '100.00 m')),
+        (True, 1, ('1', '1', '1.00')),
+        (True, 1.23456789, ('1.23457', '1', '1.23')),
+        # places=0: corner-case rounding
+        (True, 999.9, ('999.9', '1 k', '999.90')),
+        # corner-case rounding for all
+        (True, 999.9999, ('1 k', '1 k', '1.00 k')),
+        # negative corner-case
+        (False, -999.9999, ('-1 k', '-1 k', '-1.00 k')),
+        (True, -999.9999, ('\N{MINUS SIGN}1 k', '\N{MINUS SIGN}1 k',
+                           '\N{MINUS SIGN}1.00 k')),
+        (True, 1000, ('1 k', '1 k', '1.00 k')),
+        (True, 1001, ('1.001 k', '1 k', '1.00 k')),
+        (True, 100001, ('100.001 k', '100 k', '100.00 k')),
+        (True, 987654.321, ('987.654 k', '988 k', '987.65 k')),
+        # OoR value (> 1000 Q)
+        (True, 1.23e33, ('1230 Q', '1230 Q', '1230.00 Q'))
+    ]
+
+    @pytest.mark.parametrize('unicode_minus, input, expected', raw_format_data)
+    def test_params(self, unicode_minus, input, expected):
+        """
+        Test the formatting of EngFormatter for various values of the 'places'
+        argument, in several cases:
+
+        0. without a unit symbol but with a (default) space separator;
+        1. with both a unit symbol and a (default) space separator;
+        2. with both a unit symbol and some non default separators;
+        3. without a unit symbol but with some non default separators.
+
+        Note that cases 2. and 3. are looped over several separator strings.
+        """
+
+        plt.rcParams['axes.unicode_minus'] = unicode_minus
+        UNIT = 's'  # seconds
+        DIGITS = '0123456789'  # %timeit showed 10-20% faster search than set
+
+        # Case 0: unit='' (default) and sep=' ' (default).
+        # 'expected' already corresponds to this reference case.
+        exp_outputs = expected
+        formatters = (
+            mticker.EngFormatter(),  # places=None (default)
+            mticker.EngFormatter(places=0),
+            mticker.EngFormatter(places=2)
+        )
+        for _formatter, _exp_output in zip(formatters, exp_outputs):
+            assert _formatter(input) == _exp_output
+
+        # Case 1: unit=UNIT and sep=' ' (default).
+        # Append a unit symbol to the reference case.
+        # Beware of the values in [1, 1000), where there is no prefix!
+        exp_outputs = (_s + " " + UNIT if _s[-1] in DIGITS  # case w/o prefix
+                       else _s + UNIT for _s in expected)
+        formatters = (
+            mticker.EngFormatter(unit=UNIT),  # places=None (default)
+            mticker.EngFormatter(unit=UNIT, places=0),
+            mticker.EngFormatter(unit=UNIT, places=2)
+        )
+        for _formatter, _exp_output in zip(formatters, exp_outputs):
+            assert _formatter(input) == _exp_output
+
+        # Test several non default separators: no separator, a narrow
+        # no-break space (Unicode character) and an extravagant string.
+        for _sep in ("", "\N{NARROW NO-BREAK SPACE}", "@_@"):
+            # Case 2: unit=UNIT and sep=_sep.
+            # Replace the default space separator from the reference case
+            # with the tested one `_sep` and append a unit symbol to it.
+            exp_outputs = (_s + _sep + UNIT if _s[-1] in DIGITS  # no prefix
+                           else _s.replace(" ", _sep) + UNIT
+                           for _s in expected)
+            formatters = (
+                mticker.EngFormatter(unit=UNIT, sep=_sep),  # places=None
+                mticker.EngFormatter(unit=UNIT, places=0, sep=_sep),
+                mticker.EngFormatter(unit=UNIT, places=2, sep=_sep)
+            )
+            for _formatter, _exp_output in zip(formatters, exp_outputs):
+                assert _formatter(input) == _exp_output
+
+            # Case 3: unit='' (default) and sep=_sep.
+            # Replace the default space separator from the reference case
+            # with the tested one `_sep`. Reference case is already unitless.
+            exp_outputs = (_s.replace(" ", _sep) for _s in expected)
+            formatters = (
+                mticker.EngFormatter(sep=_sep),  # places=None (default)
+                mticker.EngFormatter(places=0, sep=_sep),
+                mticker.EngFormatter(places=2, sep=_sep)
+            )
+            for _formatter, _exp_output in zip(formatters, exp_outputs):
+                assert _formatter(input) == _exp_output
+
+
+def test_engformatter_usetex_useMathText():
+    fig, ax = plt.subplots()
+    ax.plot([0, 500, 1000], [0, 500, 1000])
+    ax.set_xticks([0, 500, 1000])
+    for formatter in (mticker.EngFormatter(usetex=True),
+                      mticker.EngFormatter(useMathText=True)):
+        ax.xaxis.set_major_formatter(formatter)
+        fig.canvas.draw()
+        x_tick_label_text = [labl.get_text() for labl in ax.get_xticklabels()]
+        # Checking if the dollar `$` signs have been inserted around numbers
+        # in tick labels.
+        assert x_tick_label_text == ['$0$', '$500$', '$1$ k']
+
+
+@pytest.mark.parametrize(
+    'data_offset, noise, oom_center_desired, oom_noise_desired', [
+        (271_490_000_000.0,    10,         9,  0),
+        (27_149_000_000_000.0, 10_000_000, 12, 6),
+        (27.149,               0.01,       0, -3),
+        (2_714.9,              0.01,       3, -3),
+        (271_490.0,            0.001,      3, -3),
+        (271.49,               0.001,      0, -3),
+        # The following sets of parameters demonstrates that when
+        # oom(data_offset)-1 and oom(noise)-2 equal a standard 3*N oom, we get
+        # that oom_noise_desired < oom(noise)
+        (27_149_000_000.0,     100,        9, +3),
+        (27.149,               1e-07,      0, -6),
+        (271.49,               0.0001,     0, -3),
+        (27.149,               0.0001,     0, -3),
+        # Tests where oom(data_offset) <= oom(noise), those are probably
+        # covered by the part where formatter.offset != 0
+        (27_149.0,             10_000,     0, 3),
+        (27.149,               10_000,     0, 3),
+        (27.149,               1_000,      0, 3),
+        (27.149,               100,        0, 0),
+        (27.149,               10,         0, 0),
+    ]
+)
+def test_engformatter_offset_oom(
+    data_offset,
+    noise,
+    oom_center_desired,
+    oom_noise_desired
+):
+    UNIT = "eV"
+    fig, ax = plt.subplots()
+    ydata = data_offset + np.arange(-5, 7, dtype=float)*noise
+    ax.plot(ydata)
+    formatter = mticker.EngFormatter(useOffset=True, unit=UNIT)
+    # So that offset strings will always have the same size
+    formatter.ENG_PREFIXES[0] = "_"
+    ax.yaxis.set_major_formatter(formatter)
+    fig.canvas.draw()
+    offset_got = formatter.get_offset()
+    ticks_got = [labl.get_text() for labl in ax.get_yticklabels()]
+    # Predicting whether offset should be 0 or not is essentially testing
+    # ScalarFormatter._compute_offset . This function is pretty complex and it
+    # would be nice to test it, but this is out of scope for this test which
+    # only makes sure that offset text and the ticks gets the correct unit
+    # prefixes and the ticks.
+    if formatter.offset:
+        prefix_noise_got = offset_got[2]
+        prefix_noise_desired = formatter.ENG_PREFIXES[oom_noise_desired]
+        prefix_center_got = offset_got[-1-len(UNIT)]
+        prefix_center_desired = formatter.ENG_PREFIXES[oom_center_desired]
+        assert prefix_noise_desired == prefix_noise_got
+        assert prefix_center_desired == prefix_center_got
+        # Make sure the ticks didn't get the UNIT
+        for tick in ticks_got:
+            assert UNIT not in tick
+    else:
+        assert oom_center_desired == 0
+        assert offset_got == ""
+        # Make sure the ticks contain now the prefixes
+        for tick in ticks_got:
+            # 0 is zero on all orders of magnitudes, no matter what is
+            # oom_noise_desired
+            prefix_idx = 0 if tick[0] == "0" else oom_noise_desired
+            assert tick.endswith(formatter.ENG_PREFIXES[prefix_idx] + UNIT)
+
+
+class TestPercentFormatter:
+    percent_data = [
+        # Check explicitly set decimals over different intervals and values
+        (100, 0, '%', 120, 100, '120%'),
+        (100, 0, '%', 100, 90, '100%'),
+        (100, 0, '%', 90, 50, '90%'),
+        (100, 0, '%', -1.7, 40, '-2%'),
+        (100, 1, '%', 90.0, 100, '90.0%'),
+        (100, 1, '%', 80.1, 90, '80.1%'),
+        (100, 1, '%', 70.23, 50, '70.2%'),
+        # 60.554 instead of 60.55: see https://bugs.python.org/issue5118
+        (100, 1, '%', -60.554, 40, '-60.6%'),
+        # Check auto decimals over different intervals and values
+        (100, None, '%', 95, 1, '95.00%'),
+        (1.0, None, '%', 3, 6, '300%'),
+        (17.0, None, '%', 1, 8.5, '6%'),
+        (17.0, None, '%', 1, 8.4, '5.9%'),
+        (5, None, '%', -100, 0.000001, '-2000.00000%'),
+        # Check percent symbol
+        (1.0, 2, None, 1.2, 100, '120.00'),
+        (75, 3, '', 50, 100, '66.667'),
+        (42, None, '^^Foobar$$', 21, 12, '50.0^^Foobar$$'),
+    ]
+
+    percent_ids = [
+        # Check explicitly set decimals over different intervals and values
+        'decimals=0, x>100%',
+        'decimals=0, x=100%',
+        'decimals=0, x<100%',
+        'decimals=0, x<0%',
+        'decimals=1, x>100%',
+        'decimals=1, x=100%',
+        'decimals=1, x<100%',
+        'decimals=1, x<0%',
+        # Check auto decimals over different intervals and values
+        'autodecimal, x<100%, display_range=1',
+        'autodecimal, x>100%, display_range=6 (custom xmax test)',
+        'autodecimal, x<100%, display_range=8.5 (autodecimal test 1)',
+        'autodecimal, x<100%, display_range=8.4 (autodecimal test 2)',
+        'autodecimal, x<-100%, display_range=1e-6 (tiny display range)',
+        # Check percent symbol
+        'None as percent symbol',
+        'Empty percent symbol',
+        'Custom percent symbol',
+    ]
+
+    latex_data = [
+        (False, False, r'50\{t}%'),
+        (False, True, r'50\\\{t\}\%'),
+        (True, False, r'50\{t}%'),
+        (True, True, r'50\{t}%'),
+    ]
+
+    @pytest.mark.parametrize(
+            'xmax, decimals, symbol, x, display_range, expected',
+            percent_data, ids=percent_ids)
+    def test_basic(self, xmax, decimals, symbol,
+                   x, display_range, expected):
+        formatter = mticker.PercentFormatter(xmax, decimals, symbol)
+        with mpl.rc_context(rc={'text.usetex': False}):
+            assert formatter.format_pct(x, display_range) == expected
+
+    @pytest.mark.parametrize('is_latex, usetex, expected', latex_data)
+    def test_latex(self, is_latex, usetex, expected):
+        fmt = mticker.PercentFormatter(symbol='\\{t}%', is_latex=is_latex)
+        with mpl.rc_context(rc={'text.usetex': usetex}):
+            assert fmt.format_pct(50, 100) == expected
+
+
+def _impl_locale_comma():
+    try:
+        locale.setlocale(locale.LC_ALL, 'de_DE.UTF-8')
+    except locale.Error:
+        print('SKIP: Locale de_DE.UTF-8 is not supported on this machine')
+        return
+    ticks = mticker.ScalarFormatter(useMathText=True, useLocale=True)
+    fmt = '$\\mathdefault{%1.1f}$'
+    x = ticks._format_maybe_minus_and_locale(fmt, 0.5)
+    assert x == '$\\mathdefault{0{,}5}$'
+    # Do not change , in the format string
+    fmt = ',$\\mathdefault{,%1.1f},$'
+    x = ticks._format_maybe_minus_and_locale(fmt, 0.5)
+    assert x == ',$\\mathdefault{,0{,}5},$'
+    # Make sure no brackets are added if not using math text
+    ticks = mticker.ScalarFormatter(useMathText=False, useLocale=True)
+    fmt = '%1.1f'
+    x = ticks._format_maybe_minus_and_locale(fmt, 0.5)
+    assert x == '0,5'
+
+
+def test_locale_comma():
+    # On some systems/pytest versions, `pytest.skip` in an exception handler
+    # does not skip, but is treated as an exception, so directly running this
+    # test can incorrectly fail instead of skip.
+    # Instead, run this test in a subprocess, which avoids the problem, and the
+    # need to fix the locale after.
+    proc = mpl.testing.subprocess_run_helper(_impl_locale_comma, timeout=60,
+                                             extra_env={'MPLBACKEND': 'Agg'})
+    skip_msg = next((line[len('SKIP:'):].strip()
+                     for line in proc.stdout.splitlines()
+                     if line.startswith('SKIP:')),
+                    '')
+    if skip_msg:
+        pytest.skip(skip_msg)
+
+
+def test_majformatter_type():
+    fig, ax = plt.subplots()
+    with pytest.raises(TypeError):
+        ax.xaxis.set_major_formatter(mticker.LogLocator())
+
+
+def test_minformatter_type():
+    fig, ax = plt.subplots()
+    with pytest.raises(TypeError):
+        ax.xaxis.set_minor_formatter(mticker.LogLocator())
+
+
+def test_majlocator_type():
+    fig, ax = plt.subplots()
+    with pytest.raises(TypeError):
+        ax.xaxis.set_major_locator(mticker.LogFormatter())
+
+
+def test_minlocator_type():
+    fig, ax = plt.subplots()
+    with pytest.raises(TypeError):
+        ax.xaxis.set_minor_locator(mticker.LogFormatter())
+
+
+def test_minorticks_rc():
+    fig = plt.figure()
+
+    def minorticksubplot(xminor, yminor, i):
+        rc = {'xtick.minor.visible': xminor,
+              'ytick.minor.visible': yminor}
+        with plt.rc_context(rc=rc):
+            ax = fig.add_subplot(2, 2, i)
+
+        assert (len(ax.xaxis.get_minor_ticks()) > 0) == xminor
+        assert (len(ax.yaxis.get_minor_ticks()) > 0) == yminor
+
+    minorticksubplot(False, False, 1)
+    minorticksubplot(True, False, 2)
+    minorticksubplot(False, True, 3)
+    minorticksubplot(True, True, 4)
+
+
+def test_minorticks_toggle():
+    """
+    Test toggling minor ticks
+
+    Test `.Axis.minorticks_on()` and `.Axis.minorticks_off()`. Testing is
+    limited to a subset of built-in scales - `'linear'`, `'log'`, `'asinh'`
+    and `'logit'`. `symlog` scale does not seem to have a working minor
+    locator and is omitted. In future, this test should cover all scales in
+    `matplotlib.scale.get_scale_names()`.
+    """
+    fig = plt.figure()
+    def minortickstoggle(xminor, yminor, scale, i):
+        ax = fig.add_subplot(2, 2, i)
+        ax.set_xscale(scale)
+        ax.set_yscale(scale)
+        if not xminor and not yminor:
+            ax.minorticks_off()
+        if xminor and not yminor:
+            ax.xaxis.minorticks_on()
+            ax.yaxis.minorticks_off()
+        if not xminor and yminor:
+            ax.xaxis.minorticks_off()
+            ax.yaxis.minorticks_on()
+        if xminor and yminor:
+            ax.minorticks_on()
+
+        assert (len(ax.xaxis.get_minor_ticks()) > 0) == xminor
+        assert (len(ax.yaxis.get_minor_ticks()) > 0) == yminor
+
+    scales = ['linear', 'log', 'asinh', 'logit']
+    for scale in scales:
+        minortickstoggle(False, False, scale, 1)
+        minortickstoggle(True, False, scale, 2)
+        minortickstoggle(False, True, scale, 3)
+        minortickstoggle(True, True, scale, 4)
+        fig.clear()
+
+    plt.close(fig)
+
+
+@pytest.mark.parametrize('remove_overlapping_locs, expected_num',
+                         ((True, 6),
+                          (None, 6),  # this tests the default
+                          (False, 9)))
+def test_remove_overlap(remove_overlapping_locs, expected_num):
+    t = np.arange("2018-11-03", "2018-11-06", dtype="datetime64")
+    x = np.ones(len(t))
+
+    fig, ax = plt.subplots()
+    ax.plot(t, x)
+
+    ax.xaxis.set_major_locator(mpl.dates.DayLocator())
+    ax.xaxis.set_major_formatter(mpl.dates.DateFormatter('\n%a'))
+
+    ax.xaxis.set_minor_locator(mpl.dates.HourLocator((0, 6, 12, 18)))
+    ax.xaxis.set_minor_formatter(mpl.dates.DateFormatter('%H:%M'))
+    # force there to be extra ticks
+    ax.xaxis.get_minor_ticks(15)
+    if remove_overlapping_locs is not None:
+        ax.xaxis.remove_overlapping_locs = remove_overlapping_locs
+
+    # check that getter/setter exists
+    current = ax.xaxis.remove_overlapping_locs
+    assert (current == ax.xaxis.get_remove_overlapping_locs())
+    plt.setp(ax.xaxis, remove_overlapping_locs=current)
+    new = ax.xaxis.remove_overlapping_locs
+    assert (new == ax.xaxis.remove_overlapping_locs)
+
+    # check that the accessors filter correctly
+    # this is the method that does the actual filtering
+    assert len(ax.xaxis.get_minorticklocs()) == expected_num
+    # these three are derivative
+    assert len(ax.xaxis.get_minor_ticks()) == expected_num
+    assert len(ax.xaxis.get_minorticklabels()) == expected_num
+    assert len(ax.xaxis.get_minorticklines()) == expected_num*2
+
+
+@pytest.mark.parametrize('sub', [
+    ['hi', 'aardvark'],
+    np.zeros((2, 2))])
+def test_bad_locator_subs(sub):
+    ll = mticker.LogLocator()
+    with pytest.raises(ValueError):
+        ll.set_params(subs=sub)
+
+
+@pytest.mark.parametrize('numticks', [1, 2, 3, 9])
+@mpl.style.context('default')
+def test_small_range_loglocator(numticks):
+    ll = mticker.LogLocator()
+    ll.set_params(numticks=numticks)
+    for top in [5, 7, 9, 11, 15, 50, 100, 1000]:
+        ticks = ll.tick_values(.5, top)
+        assert (np.diff(np.log10(ll.tick_values(6, 150))) == 1).all()
+
+
+def test_NullFormatter():
+    formatter = mticker.NullFormatter()
+    assert formatter(1.0) == ''
+    assert formatter.format_data(1.0) == ''
+    assert formatter.format_data_short(1.0) == ''
+
+
+@pytest.mark.parametrize('formatter', (
+    mticker.FuncFormatter(lambda a: f'val: {a}'),
+    mticker.FixedFormatter(('foo', 'bar'))))
+def test_set_offset_string(formatter):
+    assert formatter.get_offset() == ''
+    formatter.set_offset_string('mpl')
+    assert formatter.get_offset() == 'mpl'
+
+
+def test_minorticks_on_multi_fig():
+    """
+    Turning on minor gridlines in a multi-Axes Figure
+    that contains more than one boxplot and shares the x-axis
+    should not raise an exception.
+    """
+    fig, ax = plt.subplots()
+
+    ax.boxplot(np.arange(10), positions=[0])
+    ax.boxplot(np.arange(10), positions=[0])
+    ax.boxplot(np.arange(10), positions=[1])
+
+    ax.grid(which="major")
+    ax.grid(which="minor")
+    ax.minorticks_on()
+    fig.draw_without_rendering()
+
+    assert ax.get_xgridlines()
+    assert isinstance(ax.xaxis.get_minor_locator(), mpl.ticker.AutoMinorLocator)
diff --git a/lib/python3.10/site-packages/matplotlib/tri/__pycache__/__init__.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/tri/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d608c2a2a5e4d97c316a8fd8c780ebec92baa5c9
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/tri/__pycache__/__init__.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/tri/__pycache__/_triangulation.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/tri/__pycache__/_triangulation.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..83d467aad44a9edf2f9fdad4b8d02b0018b1623b
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/tri/__pycache__/_triangulation.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/tri/__pycache__/_tricontour.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/tri/__pycache__/_tricontour.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..21573302980b34647c57529aa4076b133eafef36
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/tri/__pycache__/_tricontour.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/tri/__pycache__/_trifinder.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/tri/__pycache__/_trifinder.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1fbe46c5e6f87b8fefc810d4ffefa8152a6f78d6
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/tri/__pycache__/_trifinder.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/tri/__pycache__/_triinterpolate.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/tri/__pycache__/_triinterpolate.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d5470dd3bd90c61596635770ce5e0ab8ba7626d2
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/tri/__pycache__/_triinterpolate.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/tri/__pycache__/_tripcolor.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/tri/__pycache__/_tripcolor.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6b5cf12a98ed39bca27446e823be22a329d0a899
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/tri/__pycache__/_tripcolor.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/tri/__pycache__/_triplot.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/tri/__pycache__/_triplot.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..965f83280a722b4032f723ef330860bdb557c0b7
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/tri/__pycache__/_triplot.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/tri/__pycache__/_trirefine.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/tri/__pycache__/_trirefine.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..803acb6c60baa7395347e52b77a550091f249da5
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/tri/__pycache__/_trirefine.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib/tri/__pycache__/_tritools.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib/tri/__pycache__/_tritools.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9ea994b495f8f51407d9bb7b3813996e1459bb4d
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib/tri/__pycache__/_tritools.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib_inline/__pycache__/__init__.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib_inline/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..497281072e646a11a6f0f9ed038f87237b91f45d
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib_inline/__pycache__/__init__.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib_inline/__pycache__/backend_inline.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib_inline/__pycache__/backend_inline.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..13ad3894c7a86326382984cfea267b8cf053a79c
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib_inline/__pycache__/backend_inline.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/matplotlib_inline/__pycache__/config.cpython-310.pyc b/lib/python3.10/site-packages/matplotlib_inline/__pycache__/config.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d2a690313c5b7ac2edbec44d3f49edc82ec7f80e
Binary files /dev/null and b/lib/python3.10/site-packages/matplotlib_inline/__pycache__/config.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mdurl/__pycache__/__init__.cpython-310.pyc b/lib/python3.10/site-packages/mdurl/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dbe3b87672fff38e2a88cf1bdc05ddc20f43e6c7
Binary files /dev/null and b/lib/python3.10/site-packages/mdurl/__pycache__/__init__.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mdurl/__pycache__/_decode.cpython-310.pyc b/lib/python3.10/site-packages/mdurl/__pycache__/_decode.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..75ea3f575575b61ab8ea290006164f57b85798aa
Binary files /dev/null and b/lib/python3.10/site-packages/mdurl/__pycache__/_decode.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mdurl/__pycache__/_encode.cpython-310.pyc b/lib/python3.10/site-packages/mdurl/__pycache__/_encode.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a322f4ad90fe33fe99aca7aa7efe1d7bbe7b0f1a
Binary files /dev/null and b/lib/python3.10/site-packages/mdurl/__pycache__/_encode.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mdurl/__pycache__/_format.cpython-310.pyc b/lib/python3.10/site-packages/mdurl/__pycache__/_format.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..732ca3e412924ac4934c13246623956d39d627df
Binary files /dev/null and b/lib/python3.10/site-packages/mdurl/__pycache__/_format.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mdurl/__pycache__/_parse.cpython-310.pyc b/lib/python3.10/site-packages/mdurl/__pycache__/_parse.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0da54796e54c7c6e2ce9eb391e1eb75d3de4dd6a
Binary files /dev/null and b/lib/python3.10/site-packages/mdurl/__pycache__/_parse.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mdurl/__pycache__/_url.cpython-310.pyc b/lib/python3.10/site-packages/mdurl/__pycache__/_url.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1f079a3f52bae7cc4ed2de3e355921125cb65d13
Binary files /dev/null and b/lib/python3.10/site-packages/mdurl/__pycache__/_url.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mkl/__pycache__/__init__.cpython-310.pyc b/lib/python3.10/site-packages/mkl/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6f91db99e4e5f381674373206856fbef196901aa
Binary files /dev/null and b/lib/python3.10/site-packages/mkl/__pycache__/__init__.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mkl_fft/__pycache__/__init__.cpython-310.pyc b/lib/python3.10/site-packages/mkl_fft/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bfd08f55a995708630182bda2332d594ea87ca9b
Binary files /dev/null and b/lib/python3.10/site-packages/mkl_fft/__pycache__/__init__.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mkl_fft/__pycache__/_scipy_fft_backend.cpython-310.pyc b/lib/python3.10/site-packages/mkl_fft/__pycache__/_scipy_fft_backend.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d1763da18937232b93e9945d8a50cbcbe7fc5da6
Binary files /dev/null and b/lib/python3.10/site-packages/mkl_fft/__pycache__/_scipy_fft_backend.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mkl_fft/__pycache__/_version.cpython-310.pyc b/lib/python3.10/site-packages/mkl_fft/__pycache__/_version.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..077ad683dfa15782d3713680e51e2302926ed59c
Binary files /dev/null and b/lib/python3.10/site-packages/mkl_fft/__pycache__/_version.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mkl_fft/tests/__pycache__/test_fft1d.cpython-310.pyc b/lib/python3.10/site-packages/mkl_fft/tests/__pycache__/test_fft1d.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7fc1b8c9ea7ef7f611c793b7add56f876c25bebc
Binary files /dev/null and b/lib/python3.10/site-packages/mkl_fft/tests/__pycache__/test_fft1d.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mkl_fft/tests/__pycache__/test_fftnd.cpython-310.pyc b/lib/python3.10/site-packages/mkl_fft/tests/__pycache__/test_fftnd.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5cf51bd839d4e5842cf8141839c59c6a1f705f60
Binary files /dev/null and b/lib/python3.10/site-packages/mkl_fft/tests/__pycache__/test_fftnd.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/__pycache__/__init__.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..36c82e4b08aafe344b51a7b4f42af0f59203ef7f
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/__pycache__/__init__.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/__pycache__/ctx_base.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/__pycache__/ctx_base.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4b2d10894cfca3d48749b95f91be2f97aa813c84
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/__pycache__/ctx_base.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/__pycache__/ctx_fp.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/__pycache__/ctx_fp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5bb4aafbf1a87a0749c115dd70c714aa0618dae6
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/__pycache__/ctx_fp.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/__pycache__/ctx_iv.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/__pycache__/ctx_iv.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0b94127e27a814f1cca5fd4daa818fbb2f0d2160
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/__pycache__/ctx_iv.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/__pycache__/ctx_mp.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/__pycache__/ctx_mp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..761f95d4d7fc65cf4466394a2e129e210b39d8d0
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/__pycache__/ctx_mp.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/__pycache__/ctx_mp_python.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/__pycache__/ctx_mp_python.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ab81f86f718dfd03e5ffa360d545f0f44354b8f9
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/__pycache__/ctx_mp_python.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/__pycache__/identification.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/__pycache__/identification.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7eaebab0ca6721593c3abef07ef0f9ff5ce279c1
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/__pycache__/identification.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/__pycache__/math2.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/__pycache__/math2.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0e0c51aa73b525b6fe45bb5307bac234f324ffe5
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/__pycache__/math2.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/__pycache__/rational.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/__pycache__/rational.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..952d83700e23944536d390bb0fcf9834fbded8ae
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/__pycache__/rational.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/__pycache__/usertools.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/__pycache__/usertools.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ce507594538ef8e423a44a75130f07258ec92b5e
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/__pycache__/usertools.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/__pycache__/visualization.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/__pycache__/visualization.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fa5699147d30a8fbd2cf8741923a0b5c496863cd
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/__pycache__/visualization.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/calculus/__init__.py b/lib/python3.10/site-packages/mpmath/calculus/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..040a3806b968f75b8d1a88ae37a4979fe83d466a
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/calculus/__init__.py
@@ -0,0 +1,6 @@
+from . import calculus
+# XXX: hack to set methods
+from . import approximation
+from . import differentiation
+from . import extrapolation
+from . import polynomials
diff --git a/lib/python3.10/site-packages/mpmath/calculus/approximation.py b/lib/python3.10/site-packages/mpmath/calculus/approximation.py
new file mode 100644
index 0000000000000000000000000000000000000000..7ca5cc598fb53491cb6ae4a41a40477c58544d53
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/calculus/approximation.py
@@ -0,0 +1,246 @@
+from ..libmp.backend import xrange
+from .calculus import defun
+
+#----------------------------------------------------------------------------#
+#                              Approximation methods                         #
+#----------------------------------------------------------------------------#
+
+# The Chebyshev approximation formula is given at:
+# http://mathworld.wolfram.com/ChebyshevApproximationFormula.html
+
+# The only major changes in the following code is that we return the
+# expanded polynomial coefficients instead of Chebyshev coefficients,
+# and that we automatically transform [a,b] -> [-1,1] and back
+# for convenience.
+
+# Coefficient in Chebyshev approximation
+def chebcoeff(ctx,f,a,b,j,N):
+    s = ctx.mpf(0)
+    h = ctx.mpf(0.5)
+    for k in range(1, N+1):
+        t = ctx.cospi((k-h)/N)
+        s += f(t*(b-a)*h + (b+a)*h) * ctx.cospi(j*(k-h)/N)
+    return 2*s/N
+
+# Generate Chebyshev polynomials T_n(ax+b) in expanded form
+def chebT(ctx, a=1, b=0):
+    Tb = [1]
+    yield Tb
+    Ta = [b, a]
+    while 1:
+        yield Ta
+        # Recurrence: T[n+1](ax+b) = 2*(ax+b)*T[n](ax+b) - T[n-1](ax+b)
+        Tmp = [0] + [2*a*t for t in Ta]
+        for i, c in enumerate(Ta): Tmp[i] += 2*b*c
+        for i, c in enumerate(Tb): Tmp[i] -= c
+        Ta, Tb = Tmp, Ta
+
+@defun
+def chebyfit(ctx, f, interval, N, error=False):
+    r"""
+    Computes a polynomial of degree `N-1` that approximates the
+    given function `f` on the interval `[a, b]`. With ``error=True``,
+    :func:`~mpmath.chebyfit` also returns an accurate estimate of the
+    maximum absolute error; that is, the maximum value of
+    `|f(x) - P(x)|` for `x \in [a, b]`.
+
+    :func:`~mpmath.chebyfit` uses the Chebyshev approximation formula,
+    which gives a nearly optimal solution: that is, the maximum
+    error of the approximating polynomial is very close to
+    the smallest possible for any polynomial of the same degree.
+
+    Chebyshev approximation is very useful if one needs repeated
+    evaluation of an expensive function, such as function defined
+    implicitly by an integral or a differential equation. (For
+    example, it could be used to turn a slow mpmath function
+    into a fast machine-precision version of the same.)
+
+    **Examples**
+
+    Here we use :func:`~mpmath.chebyfit` to generate a low-degree approximation
+    of `f(x) = \cos(x)`, valid on the interval `[1, 2]`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> poly, err = chebyfit(cos, [1, 2], 5, error=True)
+        >>> nprint(poly)
+        [0.00291682, 0.146166, -0.732491, 0.174141, 0.949553]
+        >>> nprint(err, 12)
+        1.61351758081e-5
+
+    The polynomial can be evaluated using ``polyval``::
+
+        >>> nprint(polyval(poly, 1.6), 12)
+        -0.0291858904138
+        >>> nprint(cos(1.6), 12)
+        -0.0291995223013
+
+    Sampling the true error at 1000 points shows that the error
+    estimate generated by ``chebyfit`` is remarkably good::
+
+        >>> error = lambda x: abs(cos(x) - polyval(poly, x))
+        >>> nprint(max([error(1+n/1000.) for n in range(1000)]), 12)
+        1.61349954245e-5
+
+    **Choice of degree**
+
+    The degree `N` can be set arbitrarily high, to obtain an
+    arbitrarily good approximation. As a rule of thumb, an
+    `N`-term Chebyshev approximation is good to `N/(b-a)` decimal
+    places on a unit interval (although this depends on how
+    well-behaved `f` is). The cost grows accordingly: ``chebyfit``
+    evaluates the function `(N^2)/2` times to compute the
+    coefficients and an additional `N` times to estimate the error.
+
+    **Possible issues**
+
+    One should be careful to use a sufficiently high working
+    precision both when calling ``chebyfit`` and when evaluating
+    the resulting polynomial, as the polynomial is sometimes
+    ill-conditioned. It is for example difficult to reach
+    15-digit accuracy when evaluating the polynomial using
+    machine precision floats, no matter the theoretical
+    accuracy of the polynomial. (The option to return the
+    coefficients in Chebyshev form should be made available
+    in the future.)
+
+    It is important to note the Chebyshev approximation works
+    poorly if `f` is not smooth. A function containing singularities,
+    rapid oscillation, etc can be approximated more effectively by
+    multiplying it by a weight function that cancels out the
+    nonsmooth features, or by dividing the interval into several
+    segments.
+    """
+    a, b = ctx._as_points(interval)
+    orig = ctx.prec
+    try:
+        ctx.prec = orig + int(N**0.5) + 20
+        c = [chebcoeff(ctx,f,a,b,k,N) for k in range(N)]
+        d = [ctx.zero] * N
+        d[0] = -c[0]/2
+        h = ctx.mpf(0.5)
+        T = chebT(ctx, ctx.mpf(2)/(b-a), ctx.mpf(-1)*(b+a)/(b-a))
+        for (k, Tk) in zip(range(N), T):
+            for i in range(len(Tk)):
+                d[i] += c[k]*Tk[i]
+        d = d[::-1]
+        # Estimate maximum error
+        err = ctx.zero
+        for k in range(N):
+            x = ctx.cos(ctx.pi*k/N) * (b-a)*h + (b+a)*h
+            err = max(err, abs(f(x) - ctx.polyval(d, x)))
+    finally:
+        ctx.prec = orig
+    if error:
+        return d, +err
+    else:
+        return d
+
+@defun
+def fourier(ctx, f, interval, N):
+    r"""
+    Computes the Fourier series of degree `N` of the given function
+    on the interval `[a, b]`. More precisely, :func:`~mpmath.fourier` returns
+    two lists `(c, s)` of coefficients (the cosine series and sine
+    series, respectively), such that
+
+    .. math ::
+
+        f(x) \sim \sum_{k=0}^N
+            c_k \cos(k m x) + s_k \sin(k m x)
+
+    where `m = 2 \pi / (b-a)`.
+
+    Note that many texts define the first coefficient as `2 c_0` instead
+    of `c_0`. The easiest way to evaluate the computed series correctly
+    is to pass it to :func:`~mpmath.fourierval`.
+
+    **Examples**
+
+    The function `f(x) = x` has a simple Fourier series on the standard
+    interval `[-\pi, \pi]`. The cosine coefficients are all zero (because
+    the function has odd symmetry), and the sine coefficients are
+    rational numbers::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> c, s = fourier(lambda x: x, [-pi, pi], 5)
+        >>> nprint(c)
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+        >>> nprint(s)
+        [0.0, 2.0, -1.0, 0.666667, -0.5, 0.4]
+
+    This computes a Fourier series of a nonsymmetric function on
+    a nonstandard interval::
+
+        >>> I = [-1, 1.5]
+        >>> f = lambda x: x**2 - 4*x + 1
+        >>> cs = fourier(f, I, 4)
+        >>> nprint(cs[0])
+        [0.583333, 1.12479, -1.27552, 0.904708, -0.441296]
+        >>> nprint(cs[1])
+        [0.0, -2.6255, 0.580905, 0.219974, -0.540057]
+
+    It is instructive to plot a function along with its truncated
+    Fourier series::
+
+        >>> plot([f, lambda x: fourierval(cs, I, x)], I) #doctest: +SKIP
+
+    Fourier series generally converge slowly (and may not converge
+    pointwise). For example, if `f(x) = \cosh(x)`, a 10-term Fourier
+    series gives an `L^2` error corresponding to 2-digit accuracy::
+
+        >>> I = [-1, 1]
+        >>> cs = fourier(cosh, I, 9)
+        >>> g = lambda x: (cosh(x) - fourierval(cs, I, x))**2
+        >>> nprint(sqrt(quad(g, I)))
+        0.00467963
+
+    :func:`~mpmath.fourier` uses numerical quadrature. For nonsmooth functions,
+    the accuracy (and speed) can be improved by including all singular
+    points in the interval specification::
+
+        >>> nprint(fourier(abs, [-1, 1], 0), 10)
+        ([0.5000441648], [0.0])
+        >>> nprint(fourier(abs, [-1, 0, 1], 0), 10)
+        ([0.5], [0.0])
+
+    """
+    interval = ctx._as_points(interval)
+    a = interval[0]
+    b = interval[-1]
+    L = b-a
+    cos_series = []
+    sin_series = []
+    cutoff = ctx.eps*10
+    for n in xrange(N+1):
+        m = 2*n*ctx.pi/L
+        an = 2*ctx.quadgl(lambda t: f(t)*ctx.cos(m*t), interval)/L
+        bn = 2*ctx.quadgl(lambda t: f(t)*ctx.sin(m*t), interval)/L
+        if n == 0:
+            an /= 2
+        if abs(an) < cutoff: an = ctx.zero
+        if abs(bn) < cutoff: bn = ctx.zero
+        cos_series.append(an)
+        sin_series.append(bn)
+    return cos_series, sin_series
+
+@defun
+def fourierval(ctx, series, interval, x):
+    """
+    Evaluates a Fourier series (in the format computed by
+    by :func:`~mpmath.fourier` for the given interval) at the point `x`.
+
+    The series should be a pair `(c, s)` where `c` is the
+    cosine series and `s` is the sine series. The two lists
+    need not have the same length.
+    """
+    cs, ss = series
+    ab = ctx._as_points(interval)
+    a = interval[0]
+    b = interval[-1]
+    m = 2*ctx.pi/(ab[-1]-ab[0])
+    s = ctx.zero
+    s += ctx.fsum(cs[n]*ctx.cos(m*n*x) for n in xrange(len(cs)) if cs[n])
+    s += ctx.fsum(ss[n]*ctx.sin(m*n*x) for n in xrange(len(ss)) if ss[n])
+    return s
diff --git a/lib/python3.10/site-packages/mpmath/calculus/calculus.py b/lib/python3.10/site-packages/mpmath/calculus/calculus.py
new file mode 100644
index 0000000000000000000000000000000000000000..24256f121d6c07e5ce954f2a5f5024f156f64016
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/calculus/calculus.py
@@ -0,0 +1,6 @@
+class CalculusMethods(object):
+    pass
+
+def defun(f):
+    setattr(CalculusMethods, f.__name__, f)
+    return f
diff --git a/lib/python3.10/site-packages/mpmath/calculus/differentiation.py b/lib/python3.10/site-packages/mpmath/calculus/differentiation.py
new file mode 100644
index 0000000000000000000000000000000000000000..f8186bebd4476476eded9e4b2f8dc3eb23ef5ff9
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/calculus/differentiation.py
@@ -0,0 +1,647 @@
+from ..libmp.backend import xrange
+from .calculus import defun
+
+try:
+    iteritems = dict.iteritems
+except AttributeError:
+    iteritems = dict.items
+
+#----------------------------------------------------------------------------#
+#                                Differentiation                             #
+#----------------------------------------------------------------------------#
+
+@defun
+def difference(ctx, s, n):
+    r"""
+    Given a sequence `(s_k)` containing at least `n+1` items, returns the
+    `n`-th forward difference,
+
+    .. math ::
+
+        \Delta^n = \sum_{k=0}^{\infty} (-1)^{k+n} {n \choose k} s_k.
+    """
+    n = int(n)
+    d = ctx.zero
+    b = (-1) ** (n & 1)
+    for k in xrange(n+1):
+        d += b * s[k]
+        b = (b * (k-n)) // (k+1)
+    return d
+
+def hsteps(ctx, f, x, n, prec, **options):
+    singular = options.get('singular')
+    addprec = options.get('addprec', 10)
+    direction = options.get('direction', 0)
+    workprec = (prec+2*addprec) * (n+1)
+    orig = ctx.prec
+    try:
+        ctx.prec = workprec
+        h = options.get('h')
+        if h is None:
+            if options.get('relative'):
+                hextramag = int(ctx.mag(x))
+            else:
+                hextramag = 0
+            h = ctx.ldexp(1, -prec-addprec-hextramag)
+        else:
+            h = ctx.convert(h)
+        # Directed: steps x, x+h, ... x+n*h
+        direction = options.get('direction', 0)
+        if direction:
+            h *= ctx.sign(direction)
+            steps = xrange(n+1)
+            norm = h
+        # Central: steps x-n*h, x-(n-2)*h ..., x, ..., x+(n-2)*h, x+n*h
+        else:
+            steps = xrange(-n, n+1, 2)
+            norm = (2*h)
+        # Perturb
+        if singular:
+            x += 0.5*h
+        values = [f(x+k*h) for k in steps]
+        return values, norm, workprec
+    finally:
+        ctx.prec = orig
+
+
+@defun
+def diff(ctx, f, x, n=1, **options):
+    r"""
+    Numerically computes the derivative of `f`, `f'(x)`, or generally for
+    an integer `n \ge 0`, the `n`-th derivative `f^{(n)}(x)`.
+    A few basic examples are::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> diff(lambda x: x**2 + x, 1.0)
+        3.0
+        >>> diff(lambda x: x**2 + x, 1.0, 2)
+        2.0
+        >>> diff(lambda x: x**2 + x, 1.0, 3)
+        0.0
+        >>> nprint([diff(exp, 3, n) for n in range(5)])   # exp'(x) = exp(x)
+        [20.0855, 20.0855, 20.0855, 20.0855, 20.0855]
+
+    Even more generally, given a tuple of arguments `(x_1, \ldots, x_k)`
+    and order `(n_1, \ldots, n_k)`, the partial derivative
+    `f^{(n_1,\ldots,n_k)}(x_1,\ldots,x_k)` is evaluated. For example::
+
+        >>> diff(lambda x,y: 3*x*y + 2*y - x, (0.25, 0.5), (0,1))
+        2.75
+        >>> diff(lambda x,y: 3*x*y + 2*y - x, (0.25, 0.5), (1,1))
+        3.0
+
+    **Options**
+
+    The following optional keyword arguments are recognized:
+
+    ``method``
+        Supported methods are ``'step'`` or ``'quad'``: derivatives may be
+        computed using either a finite difference with a small step
+        size `h` (default), or numerical quadrature.
+    ``direction``
+        Direction of finite difference: can be -1 for a left
+        difference, 0 for a central difference (default), or +1
+        for a right difference; more generally can be any complex number.
+    ``addprec``
+        Extra precision for `h` used to account for the function's
+        sensitivity to perturbations (default = 10).
+    ``relative``
+        Choose `h` relative to the magnitude of `x`, rather than an
+        absolute value; useful for large or tiny `x` (default = False).
+    ``h``
+        As an alternative to ``addprec`` and ``relative``, manually
+        select the step size `h`.
+    ``singular``
+        If True, evaluation exactly at the point `x` is avoided; this is
+        useful for differentiating functions with removable singularities.
+        Default = False.
+    ``radius``
+        Radius of integration contour (with ``method = 'quad'``).
+        Default = 0.25. A larger radius typically is faster and more
+        accurate, but it must be chosen so that `f` has no
+        singularities within the radius from the evaluation point.
+
+    A finite difference requires `n+1` function evaluations and must be
+    performed at `(n+1)` times the target precision. Accordingly, `f` must
+    support fast evaluation at high precision.
+
+    With integration, a larger number of function evaluations is
+    required, but not much extra precision is required. For high order
+    derivatives, this method may thus be faster if f is very expensive to
+    evaluate at high precision.
+
+    **Further examples**
+
+    The direction option is useful for computing left- or right-sided
+    derivatives of nonsmooth functions::
+
+        >>> diff(abs, 0, direction=0)
+        0.0
+        >>> diff(abs, 0, direction=1)
+        1.0
+        >>> diff(abs, 0, direction=-1)
+        -1.0
+
+    More generally, if the direction is nonzero, a right difference
+    is computed where the step size is multiplied by sign(direction).
+    For example, with direction=+j, the derivative from the positive
+    imaginary direction will be computed::
+
+        >>> diff(abs, 0, direction=j)
+        (0.0 - 1.0j)
+
+    With integration, the result may have a small imaginary part
+    even even if the result is purely real::
+
+        >>> diff(sqrt, 1, method='quad')    # doctest:+ELLIPSIS
+        (0.5 - 4.59...e-26j)
+        >>> chop(_)
+        0.5
+
+    Adding precision to obtain an accurate value::
+
+        >>> diff(cos, 1e-30)
+        0.0
+        >>> diff(cos, 1e-30, h=0.0001)
+        -9.99999998328279e-31
+        >>> diff(cos, 1e-30, addprec=100)
+        -1.0e-30
+
+    """
+    partial = False
+    try:
+        orders = list(n)
+        x = list(x)
+        partial = True
+    except TypeError:
+        pass
+    if partial:
+        x = [ctx.convert(_) for _ in x]
+        return _partial_diff(ctx, f, x, orders, options)
+    method = options.get('method', 'step')
+    if n == 0 and method != 'quad' and not options.get('singular'):
+        return f(ctx.convert(x))
+    prec = ctx.prec
+    try:
+        if method == 'step':
+            values, norm, workprec = hsteps(ctx, f, x, n, prec, **options)
+            ctx.prec = workprec
+            v = ctx.difference(values, n) / norm**n
+        elif method == 'quad':
+            ctx.prec += 10
+            radius = ctx.convert(options.get('radius', 0.25))
+            def g(t):
+                rei = radius*ctx.expj(t)
+                z = x + rei
+                return f(z) / rei**n
+            d = ctx.quadts(g, [0, 2*ctx.pi])
+            v = d * ctx.factorial(n) / (2*ctx.pi)
+        else:
+            raise ValueError("unknown method: %r" % method)
+    finally:
+        ctx.prec = prec
+    return +v
+
+def _partial_diff(ctx, f, xs, orders, options):
+    if not orders:
+        return f()
+    if not sum(orders):
+        return f(*xs)
+    i = 0
+    for i in range(len(orders)):
+        if orders[i]:
+            break
+    order = orders[i]
+    def fdiff_inner(*f_args):
+        def inner(t):
+            return f(*(f_args[:i] + (t,) + f_args[i+1:]))
+        return ctx.diff(inner, f_args[i], order, **options)
+    orders[i] = 0
+    return _partial_diff(ctx, fdiff_inner, xs, orders, options)
+
+@defun
+def diffs(ctx, f, x, n=None, **options):
+    r"""
+    Returns a generator that yields the sequence of derivatives
+
+    .. math ::
+
+        f(x), f'(x), f''(x), \ldots, f^{(k)}(x), \ldots
+
+    With ``method='step'``, :func:`~mpmath.diffs` uses only `O(k)`
+    function evaluations to generate the first `k` derivatives,
+    rather than the roughly `O(k^2)` evaluations
+    required if one calls :func:`~mpmath.diff` `k` separate times.
+
+    With `n < \infty`, the generator stops as soon as the
+    `n`-th derivative has been generated. If the exact number of
+    needed derivatives is known in advance, this is further
+    slightly more efficient.
+
+    Options are the same as for :func:`~mpmath.diff`.
+
+    **Examples**
+
+        >>> from mpmath import *
+        >>> mp.dps = 15
+        >>> nprint(list(diffs(cos, 1, 5)))
+        [0.540302, -0.841471, -0.540302, 0.841471, 0.540302, -0.841471]
+        >>> for i, d in zip(range(6), diffs(cos, 1)):
+        ...     print("%s %s" % (i, d))
+        ...
+        0 0.54030230586814
+        1 -0.841470984807897
+        2 -0.54030230586814
+        3 0.841470984807897
+        4 0.54030230586814
+        5 -0.841470984807897
+
+    """
+    if n is None:
+        n = ctx.inf
+    else:
+        n = int(n)
+    if options.get('method', 'step') != 'step':
+        k = 0
+        while k < n + 1:
+            yield ctx.diff(f, x, k, **options)
+            k += 1
+        return
+    singular = options.get('singular')
+    if singular:
+        yield ctx.diff(f, x, 0, singular=True)
+    else:
+        yield f(ctx.convert(x))
+    if n < 1:
+        return
+    if n == ctx.inf:
+        A, B = 1, 2
+    else:
+        A, B = 1, n+1
+    while 1:
+        callprec = ctx.prec
+        y, norm, workprec = hsteps(ctx, f, x, B, callprec, **options)
+        for k in xrange(A, B):
+            try:
+                ctx.prec = workprec
+                d = ctx.difference(y, k) / norm**k
+            finally:
+                ctx.prec = callprec
+            yield +d
+            if k >= n:
+                return
+        A, B = B, int(A*1.4+1)
+        B = min(B, n)
+
+def iterable_to_function(gen):
+    gen = iter(gen)
+    data = []
+    def f(k):
+        for i in xrange(len(data), k+1):
+            data.append(next(gen))
+        return data[k]
+    return f
+
+@defun
+def diffs_prod(ctx, factors):
+    r"""
+    Given a list of `N` iterables or generators yielding
+    `f_k(x), f'_k(x), f''_k(x), \ldots` for `k = 1, \ldots, N`,
+    generate `g(x), g'(x), g''(x), \ldots` where
+    `g(x) = f_1(x) f_2(x) \cdots f_N(x)`.
+
+    At high precision and for large orders, this is typically more efficient
+    than numerical differentiation if the derivatives of each `f_k(x)`
+    admit direct computation.
+
+    Note: This function does not increase the working precision internally,
+    so guard digits may have to be added externally for full accuracy.
+
+    **Examples**
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> f = lambda x: exp(x)*cos(x)*sin(x)
+        >>> u = diffs(f, 1)
+        >>> v = mp.diffs_prod([diffs(exp,1), diffs(cos,1), diffs(sin,1)])
+        >>> next(u); next(v)
+        1.23586333600241
+        1.23586333600241
+        >>> next(u); next(v)
+        0.104658952245596
+        0.104658952245596
+        >>> next(u); next(v)
+        -5.96999877552086
+        -5.96999877552086
+        >>> next(u); next(v)
+        -12.4632923122697
+        -12.4632923122697
+
+    """
+    N = len(factors)
+    if N == 1:
+        for c in factors[0]:
+            yield c
+    else:
+        u = iterable_to_function(ctx.diffs_prod(factors[:N//2]))
+        v = iterable_to_function(ctx.diffs_prod(factors[N//2:]))
+        n = 0
+        while 1:
+            #yield sum(binomial(n,k)*u(n-k)*v(k) for k in xrange(n+1))
+            s = u(n) * v(0)
+            a = 1
+            for k in xrange(1,n+1):
+                a = a * (n-k+1) // k
+                s += a * u(n-k) * v(k)
+            yield s
+            n += 1
+
+def dpoly(n, _cache={}):
+    """
+    nth differentiation polynomial for exp (Faa di Bruno's formula).
+
+    TODO: most exponents are zero, so maybe a sparse representation
+    would be better.
+    """
+    if n in _cache:
+        return _cache[n]
+    if not _cache:
+        _cache[0] = {(0,):1}
+    R = dpoly(n-1)
+    R = dict((c+(0,),v) for (c,v) in iteritems(R))
+    Ra = {}
+    for powers, count in iteritems(R):
+        powers1 = (powers[0]+1,) + powers[1:]
+        if powers1 in Ra:
+            Ra[powers1] += count
+        else:
+            Ra[powers1] = count
+    for powers, count in iteritems(R):
+        if not sum(powers):
+            continue
+        for k,p in enumerate(powers):
+            if p:
+                powers2 = powers[:k] + (p-1,powers[k+1]+1) + powers[k+2:]
+                if powers2 in Ra:
+                    Ra[powers2] += p*count
+                else:
+                    Ra[powers2] = p*count
+    _cache[n] = Ra
+    return _cache[n]
+
+@defun
+def diffs_exp(ctx, fdiffs):
+    r"""
+    Given an iterable or generator yielding `f(x), f'(x), f''(x), \ldots`
+    generate `g(x), g'(x), g''(x), \ldots` where `g(x) = \exp(f(x))`.
+
+    At high precision and for large orders, this is typically more efficient
+    than numerical differentiation if the derivatives of `f(x)`
+    admit direct computation.
+
+    Note: This function does not increase the working precision internally,
+    so guard digits may have to be added externally for full accuracy.
+
+    **Examples**
+
+    The derivatives of the gamma function can be computed using
+    logarithmic differentiation::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>>
+        >>> def diffs_loggamma(x):
+        ...     yield loggamma(x)
+        ...     i = 0
+        ...     while 1:
+        ...         yield psi(i,x)
+        ...         i += 1
+        ...
+        >>> u = diffs_exp(diffs_loggamma(3))
+        >>> v = diffs(gamma, 3)
+        >>> next(u); next(v)
+        2.0
+        2.0
+        >>> next(u); next(v)
+        1.84556867019693
+        1.84556867019693
+        >>> next(u); next(v)
+        2.49292999190269
+        2.49292999190269
+        >>> next(u); next(v)
+        3.44996501352367
+        3.44996501352367
+
+    """
+    fn = iterable_to_function(fdiffs)
+    f0 = ctx.exp(fn(0))
+    yield f0
+    i = 1
+    while 1:
+        s = ctx.mpf(0)
+        for powers, c in iteritems(dpoly(i)):
+            s += c*ctx.fprod(fn(k+1)**p for (k,p) in enumerate(powers) if p)
+        yield s * f0
+        i += 1
+
+@defun
+def differint(ctx, f, x, n=1, x0=0):
+    r"""
+    Calculates the Riemann-Liouville differintegral, or fractional
+    derivative, defined by
+
+    .. math ::
+
+        \,_{x_0}{\mathbb{D}}^n_xf(x) = \frac{1}{\Gamma(m-n)} \frac{d^m}{dx^m}
+        \int_{x_0}^{x}(x-t)^{m-n-1}f(t)dt
+
+    where `f` is a given (presumably well-behaved) function,
+    `x` is the evaluation point, `n` is the order, and `x_0` is
+    the reference point of integration (`m` is an arbitrary
+    parameter selected automatically).
+
+    With `n = 1`, this is just the standard derivative `f'(x)`; with `n = 2`,
+    the second derivative `f''(x)`, etc. With `n = -1`, it gives
+    `\int_{x_0}^x f(t) dt`, with `n = -2`
+    it gives `\int_{x_0}^x \left( \int_{x_0}^t f(u) du \right) dt`, etc.
+
+    As `n` is permitted to be any number, this operator generalizes
+    iterated differentiation and iterated integration to a single
+    operator with a continuous order parameter.
+
+    **Examples**
+
+    There is an exact formula for the fractional derivative of a
+    monomial `x^p`, which may be used as a reference. For example,
+    the following gives a half-derivative (order 0.5)::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> x = mpf(3); p = 2; n = 0.5
+        >>> differint(lambda t: t**p, x, n)
+        7.81764019044672
+        >>> gamma(p+1)/gamma(p-n+1) * x**(p-n)
+        7.81764019044672
+
+    Another useful test function is the exponential function, whose
+    integration / differentiation formula easy generalizes
+    to arbitrary order. Here we first compute a third derivative,
+    and then a triply nested integral. (The reference point `x_0`
+    is set to `-\infty` to avoid nonzero endpoint terms.)::
+
+        >>> differint(lambda x: exp(pi*x), -1.5, 3)
+        0.278538406900792
+        >>> exp(pi*-1.5) * pi**3
+        0.278538406900792
+        >>> differint(lambda x: exp(pi*x), 3.5, -3, -inf)
+        1922.50563031149
+        >>> exp(pi*3.5) / pi**3
+        1922.50563031149
+
+    However, for noninteger `n`, the differentiation formula for the
+    exponential function must be modified to give the same result as the
+    Riemann-Liouville differintegral::
+
+        >>> x = mpf(3.5)
+        >>> c = pi
+        >>> n = 1+2*j
+        >>> differint(lambda x: exp(c*x), x, n)
+        (-123295.005390743 + 140955.117867654j)
+        >>> x**(-n) * exp(c)**x * (x*c)**n * gammainc(-n, 0, x*c) / gamma(-n)
+        (-123295.005390743 + 140955.117867654j)
+
+
+    """
+    m = max(int(ctx.ceil(ctx.re(n)))+1, 1)
+    r = m-n-1
+    g = lambda x: ctx.quad(lambda t: (x-t)**r * f(t), [x0, x])
+    return ctx.diff(g, x, m) / ctx.gamma(m-n)
+
+@defun
+def diffun(ctx, f, n=1, **options):
+    r"""
+    Given a function `f`, returns a function `g(x)` that evaluates the nth
+    derivative `f^{(n)}(x)`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> cos2 = diffun(sin)
+        >>> sin2 = diffun(sin, 4)
+        >>> cos(1.3), cos2(1.3)
+        (0.267498828624587, 0.267498828624587)
+        >>> sin(1.3), sin2(1.3)
+        (0.963558185417193, 0.963558185417193)
+
+    The function `f` must support arbitrary precision evaluation.
+    See :func:`~mpmath.diff` for additional details and supported
+    keyword options.
+    """
+    if n == 0:
+        return f
+    def g(x):
+        return ctx.diff(f, x, n, **options)
+    return g
+
+@defun
+def taylor(ctx, f, x, n, **options):
+    r"""
+    Produces a degree-`n` Taylor polynomial around the point `x` of the
+    given function `f`. The coefficients are returned as a list.
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> nprint(chop(taylor(sin, 0, 5)))
+        [0.0, 1.0, 0.0, -0.166667, 0.0, 0.00833333]
+
+    The coefficients are computed using high-order numerical
+    differentiation. The function must be possible to evaluate
+    to arbitrary precision. See :func:`~mpmath.diff` for additional details
+    and supported keyword options.
+
+    Note that to evaluate the Taylor polynomial as an approximation
+    of `f`, e.g. with :func:`~mpmath.polyval`, the coefficients must be reversed,
+    and the point of the Taylor expansion must be subtracted from
+    the argument:
+
+        >>> p = taylor(exp, 2.0, 10)
+        >>> polyval(p[::-1], 2.5 - 2.0)
+        12.1824939606092
+        >>> exp(2.5)
+        12.1824939607035
+
+    """
+    gen = enumerate(ctx.diffs(f, x, n, **options))
+    if options.get("chop", True):
+        return [ctx.chop(d)/ctx.factorial(i) for i, d in gen]
+    else:
+        return [d/ctx.factorial(i) for i, d in gen]
+
+@defun
+def pade(ctx, a, L, M):
+    r"""
+    Computes a Pade approximation of degree `(L, M)` to a function.
+    Given at least `L+M+1` Taylor coefficients `a` approximating
+    a function `A(x)`, :func:`~mpmath.pade` returns coefficients of
+    polynomials `P, Q` satisfying
+
+    .. math ::
+
+        P = \sum_{k=0}^L p_k x^k
+
+        Q = \sum_{k=0}^M q_k x^k
+
+        Q_0 = 1
+
+        A(x) Q(x) = P(x) + O(x^{L+M+1})
+
+    `P(x)/Q(x)` can provide a good approximation to an analytic function
+    beyond the radius of convergence of its Taylor series (example
+    from G.A. Baker 'Essentials of Pade Approximants' Academic Press,
+    Ch.1A)::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> one = mpf(1)
+        >>> def f(x):
+        ...     return sqrt((one + 2*x)/(one + x))
+        ...
+        >>> a = taylor(f, 0, 6)
+        >>> p, q = pade(a, 3, 3)
+        >>> x = 10
+        >>> polyval(p[::-1], x)/polyval(q[::-1], x)
+        1.38169105566806
+        >>> f(x)
+        1.38169855941551
+
+    """
+    # To determine L+1 coefficients of P and M coefficients of Q
+    # L+M+1 coefficients of A must be provided
+    if len(a) < L+M+1:
+        raise ValueError("L+M+1 Coefficients should be provided")
+
+    if M == 0:
+        if L == 0:
+            return [ctx.one], [ctx.one]
+        else:
+            return a[:L+1], [ctx.one]
+
+    # Solve first
+    # a[L]*q[1] + ... + a[L-M+1]*q[M] = -a[L+1]
+    # ...
+    # a[L+M-1]*q[1] + ... + a[L]*q[M] = -a[L+M]
+    A = ctx.matrix(M)
+    for j in range(M):
+        for i in range(min(M, L+j+1)):
+            A[j, i] = a[L+j-i]
+    v = -ctx.matrix(a[(L+1):(L+M+1)])
+    x = ctx.lu_solve(A, v)
+    q = [ctx.one] + list(x)
+    # compute p
+    p = [0]*(L+1)
+    for i in range(L+1):
+        s = a[i]
+        for j in range(1, min(M,i) + 1):
+            s += q[j]*a[i-j]
+        p[i] = s
+    return p, q
diff --git a/lib/python3.10/site-packages/mpmath/calculus/extrapolation.py b/lib/python3.10/site-packages/mpmath/calculus/extrapolation.py
new file mode 100644
index 0000000000000000000000000000000000000000..7df0fea3c62c9b71ee24d3f39fd9b7fd3318ed23
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/calculus/extrapolation.py
@@ -0,0 +1,2115 @@
+try:
+    from itertools import izip
+except ImportError:
+    izip = zip
+
+from ..libmp.backend import xrange
+from .calculus import defun
+
+try:
+    next = next
+except NameError:
+    next = lambda _: _.next()
+
+@defun
+def richardson(ctx, seq):
+    r"""
+    Given a list ``seq`` of the first `N` elements of a slowly convergent
+    infinite sequence, :func:`~mpmath.richardson` computes the `N`-term
+    Richardson extrapolate for the limit.
+
+    :func:`~mpmath.richardson` returns `(v, c)` where `v` is the estimated
+    limit and `c` is the magnitude of the largest weight used during the
+    computation. The weight provides an estimate of the precision
+    lost to cancellation. Due to cancellation effects, the sequence must
+    be typically be computed at a much higher precision than the target
+    accuracy of the extrapolation.
+
+    **Applicability and issues**
+
+    The `N`-step Richardson extrapolation algorithm used by
+    :func:`~mpmath.richardson` is described in [1].
+
+    Richardson extrapolation only works for a specific type of sequence,
+    namely one converging like partial sums of
+    `P(1)/Q(1) + P(2)/Q(2) + \ldots` where `P` and `Q` are polynomials.
+    When the sequence does not convergence at such a rate
+    :func:`~mpmath.richardson` generally produces garbage.
+
+    Richardson extrapolation has the advantage of being fast: the `N`-term
+    extrapolate requires only `O(N)` arithmetic operations, and usually
+    produces an estimate that is accurate to `O(N)` digits. Contrast with
+    the Shanks transformation (see :func:`~mpmath.shanks`), which requires
+    `O(N^2)` operations.
+
+    :func:`~mpmath.richardson` is unable to produce an estimate for the
+    approximation error. One way to estimate the error is to perform
+    two extrapolations with slightly different `N` and comparing the
+    results.
+
+    Richardson extrapolation does not work for oscillating sequences.
+    As a simple workaround, :func:`~mpmath.richardson` detects if the last
+    three elements do not differ monotonically, and in that case
+    applies extrapolation only to the even-index elements.
+
+    **Example**
+
+    Applying Richardson extrapolation to the Leibniz series for `\pi`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 30; mp.pretty = True
+        >>> S = [4*sum(mpf(-1)**n/(2*n+1) for n in range(m))
+        ...     for m in range(1,30)]
+        >>> v, c = richardson(S[:10])
+        >>> v
+        3.2126984126984126984126984127
+        >>> nprint([v-pi, c])
+        [0.0711058, 2.0]
+
+        >>> v, c = richardson(S[:30])
+        >>> v
+        3.14159265468624052829954206226
+        >>> nprint([v-pi, c])
+        [1.09645e-9, 20833.3]
+
+    **References**
+
+    1. [BenderOrszag]_ pp. 375-376
+
+    """
+    if len(seq) < 3:
+        raise ValueError("seq should be of minimum length 3")
+    if ctx.sign(seq[-1]-seq[-2]) != ctx.sign(seq[-2]-seq[-3]):
+        seq = seq[::2]
+    N = len(seq)//2-1
+    s = ctx.zero
+    # The general weight is c[k] = (N+k)**N * (-1)**(k+N) / k! / (N-k)!
+    # To avoid repeated factorials, we simplify the quotient
+    # of successive weights to obtain a recurrence relation
+    c = (-1)**N * N**N / ctx.mpf(ctx._ifac(N))
+    maxc = 1
+    for k in xrange(N+1):
+        s += c * seq[N+k]
+        maxc = max(abs(c), maxc)
+        c *= (k-N)*ctx.mpf(k+N+1)**N
+        c /= ((1+k)*ctx.mpf(k+N)**N)
+    return s, maxc
+
+@defun
+def shanks(ctx, seq, table=None, randomized=False):
+    r"""
+    Given a list ``seq`` of the first `N` elements of a slowly
+    convergent infinite sequence `(A_k)`, :func:`~mpmath.shanks` computes the iterated
+    Shanks transformation `S(A), S(S(A)), \ldots, S^{N/2}(A)`. The Shanks
+    transformation often provides strong convergence acceleration,
+    especially if the sequence is oscillating.
+
+    The iterated Shanks transformation is computed using the Wynn
+    epsilon algorithm (see [1]). :func:`~mpmath.shanks` returns the full
+    epsilon table generated by Wynn's algorithm, which can be read
+    off as follows:
+
+    * The table is a list of lists forming a lower triangular matrix,
+      where higher row and column indices correspond to more accurate
+      values.
+    * The columns with even index hold dummy entries (required for the
+      computation) and the columns with odd index hold the actual
+      extrapolates.
+    * The last element in the last row is typically the most
+      accurate estimate of the limit.
+    * The difference to the third last element in the last row
+      provides an estimate of the approximation error.
+    * The magnitude of the second last element provides an estimate
+      of the numerical accuracy lost to cancellation.
+
+    For convenience, so the extrapolation is stopped at an odd index
+    so that ``shanks(seq)[-1][-1]`` always gives an estimate of the
+    limit.
+
+    Optionally, an existing table can be passed to :func:`~mpmath.shanks`.
+    This can be used to efficiently extend a previous computation after
+    new elements have been appended to the sequence. The table will
+    then be updated in-place.
+
+    **The Shanks transformation**
+
+    The Shanks transformation is defined as follows (see [2]): given
+    the input sequence `(A_0, A_1, \ldots)`, the transformed sequence is
+    given by
+
+    .. math ::
+
+        S(A_k) = \frac{A_{k+1}A_{k-1}-A_k^2}{A_{k+1}+A_{k-1}-2 A_k}
+
+    The Shanks transformation gives the exact limit `A_{\infty}` in a
+    single step if `A_k = A + a q^k`. Note in particular that it
+    extrapolates the exact sum of a geometric series in a single step.
+
+    Applying the Shanks transformation once often improves convergence
+    substantially for an arbitrary sequence, but the optimal effect is
+    obtained by applying it iteratively:
+    `S(S(A_k)), S(S(S(A_k))), \ldots`.
+
+    Wynn's epsilon algorithm provides an efficient way to generate
+    the table of iterated Shanks transformations. It reduces the
+    computation of each element to essentially a single division, at
+    the cost of requiring dummy elements in the table. See [1] for
+    details.
+
+    **Precision issues**
+
+    Due to cancellation effects, the sequence must be typically be
+    computed at a much higher precision than the target accuracy
+    of the extrapolation.
+
+    If the Shanks transformation converges to the exact limit (such
+    as if the sequence is a geometric series), then a division by
+    zero occurs. By default, :func:`~mpmath.shanks` handles this case by
+    terminating the iteration and returning the table it has
+    generated so far. With *randomized=True*, it will instead
+    replace the zero by a pseudorandom number close to zero.
+    (TODO: find a better solution to this problem.)
+
+    **Examples**
+
+    We illustrate by applying Shanks transformation to the Leibniz
+    series for `\pi`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 50
+        >>> S = [4*sum(mpf(-1)**n/(2*n+1) for n in range(m))
+        ...     for m in range(1,30)]
+        >>>
+        >>> T = shanks(S[:7])
+        >>> for row in T:
+        ...     nprint(row)
+        ...
+        [-0.75]
+        [1.25, 3.16667]
+        [-1.75, 3.13333, -28.75]
+        [2.25, 3.14524, 82.25, 3.14234]
+        [-2.75, 3.13968, -177.75, 3.14139, -969.937]
+        [3.25, 3.14271, 327.25, 3.14166, 3515.06, 3.14161]
+
+    The extrapolated accuracy is about 4 digits, and about 4 digits
+    may have been lost due to cancellation::
+
+        >>> L = T[-1]
+        >>> nprint([abs(L[-1] - pi), abs(L[-1] - L[-3]), abs(L[-2])])
+        [2.22532e-5, 4.78309e-5, 3515.06]
+
+    Now we extend the computation::
+
+        >>> T = shanks(S[:25], T)
+        >>> L = T[-1]
+        >>> nprint([abs(L[-1] - pi), abs(L[-1] - L[-3]), abs(L[-2])])
+        [3.75527e-19, 1.48478e-19, 2.96014e+17]
+
+    The value for pi is now accurate to 18 digits. About 18 digits may
+    also have been lost to cancellation.
+
+    Here is an example with a geometric series, where the convergence
+    is immediate (the sum is exactly 1)::
+
+        >>> mp.dps = 15
+        >>> for row in shanks([0.5, 0.75, 0.875, 0.9375, 0.96875]):
+        ...     nprint(row)
+        [4.0]
+        [8.0, 1.0]
+
+    **References**
+
+    1. [GravesMorris]_
+
+    2. [BenderOrszag]_ pp. 368-375
+
+    """
+    if len(seq) < 2:
+        raise ValueError("seq should be of minimum length 2")
+    if table:
+        START = len(table)
+    else:
+        START = 0
+        table = []
+    STOP = len(seq) - 1
+    if STOP & 1:
+        STOP -= 1
+    one = ctx.one
+    eps = +ctx.eps
+    if randomized:
+        from random import Random
+        rnd = Random()
+        rnd.seed(START)
+    for i in xrange(START, STOP):
+        row = []
+        for j in xrange(i+1):
+            if j == 0:
+                a, b = 0, seq[i+1]-seq[i]
+            else:
+                if j == 1:
+                    a = seq[i]
+                else:
+                    a = table[i-1][j-2]
+                b = row[j-1] - table[i-1][j-1]
+            if not b:
+                if randomized:
+                    b = (1 + rnd.getrandbits(10))*eps
+                elif i & 1:
+                    return table[:-1]
+                else:
+                    return table
+            row.append(a + one/b)
+        table.append(row)
+    return table
+
+
+class levin_class:
+    # levin: Copyright 2013 Timo Hartmann (thartmann15 at gmail.com)
+    r"""
+    This interface implements Levin's (nonlinear) sequence transformation for
+    convergence acceleration and summation of divergent series. It performs
+    better than the Shanks/Wynn-epsilon algorithm for logarithmic convergent
+    or alternating divergent series.
+
+    Let *A* be the series we want to sum:
+
+    .. math ::
+
+        A = \sum_{k=0}^{\infty} a_k
+
+    Attention: all `a_k` must be non-zero!
+
+    Let `s_n` be the partial sums of this series:
+
+    .. math ::
+
+        s_n = \sum_{k=0}^n a_k.
+
+    **Methods**
+
+    Calling ``levin`` returns an object with the following methods.
+
+    ``update(...)`` works with the list of individual terms `a_k` of *A*, and
+    ``update_step(...)`` works with the list of partial sums `s_k` of *A*:
+
+    .. code ::
+
+        v, e = ...update([a_0, a_1,..., a_k])
+        v, e = ...update_psum([s_0, s_1,..., s_k])
+
+    ``step(...)`` works with the individual terms `a_k` and ``step_psum(...)``
+    works with the partial sums `s_k`:
+
+    .. code ::
+
+        v, e = ...step(a_k)
+        v, e = ...step_psum(s_k)
+
+    *v* is the current estimate for *A*, and *e* is an error estimate which is
+    simply the difference between the current estimate and the last estimate.
+    One should not mix ``update``, ``update_psum``, ``step`` and ``step_psum``.
+
+    **A word of caution**
+
+    One can only hope for good results (i.e. convergence acceleration or
+    resummation) if the `s_n` have some well defind asymptotic behavior for
+    large `n` and are not erratic or random. Furthermore one usually needs very
+    high working precision because of the numerical cancellation. If the working
+    precision is insufficient, levin may produce silently numerical garbage.
+    Furthermore even if the Levin-transformation converges, in the general case
+    there is no proof that the result is mathematically sound. Only for very
+    special classes of problems one can prove that the Levin-transformation
+    converges to the expected result (for example Stieltjes-type integrals).
+    Furthermore the Levin-transform is quite expensive (i.e. slow) in comparison
+    to Shanks/Wynn-epsilon, Richardson & co.
+    In summary one can say that the Levin-transformation is powerful but
+    unreliable and that it may need a copious amount of working precision.
+
+    The Levin transform has several variants differing in the choice of weights.
+    Some variants are better suited for the possible flavours of convergence
+    behaviour of *A* than other variants:
+
+    .. code ::
+
+       convergence behaviour   levin-u   levin-t   levin-v   shanks/wynn-epsilon
+
+       logarithmic               +         -         +           -
+       linear                    +         +         +           +
+       alternating divergent     +         +         +           +
+
+         "+" means the variant is suitable,"-" means the variant is not suitable;
+         for comparison the Shanks/Wynn-epsilon transform is listed, too.
+
+    The variant is controlled though the variant keyword (i.e. ``variant="u"``,
+    ``variant="t"`` or ``variant="v"``). Overall "u" is probably the best choice.
+
+    Finally it is possible to use the Sidi-S transform instead of the Levin transform
+    by using the keyword ``method='sidi'``. The Sidi-S transform works better than the
+    Levin transformation for some divergent series (see the examples).
+
+    Parameters:
+
+    .. code ::
+
+       method      "levin" or "sidi" chooses either the Levin or the Sidi-S transformation
+       variant     "u","t" or "v" chooses the weight variant.
+
+    The Levin transform is also accessible through the nsum interface.
+    ``method="l"`` or ``method="levin"`` select the normal Levin transform while
+    ``method="sidi"``
+    selects the Sidi-S transform. The variant is in both cases selected through the
+    levin_variant keyword. The stepsize in :func:`~mpmath.nsum` must not be chosen too large, otherwise
+    it will miss the point where the Levin transform converges resulting in numerical
+    overflow/garbage. For highly divergent series a copious amount of working precision
+    must be chosen.
+
+    **Examples**
+
+    First we sum the zeta function::
+
+        >>> from mpmath import mp
+        >>> mp.prec = 53
+        >>> eps = mp.mpf(mp.eps)
+        >>> with mp.extraprec(2 * mp.prec): # levin needs a high working precision
+        ...     L = mp.levin(method = "levin", variant = "u")
+        ...     S, s, n = [], 0, 1
+        ...     while 1:
+        ...         s += mp.one / (n * n)
+        ...         n += 1
+        ...         S.append(s)
+        ...         v, e = L.update_psum(S)
+        ...         if e < eps:
+        ...             break
+        ...         if n > 1000: raise RuntimeError("iteration limit exceeded")
+        >>> print(mp.chop(v - mp.pi ** 2 / 6))
+        0.0
+        >>> w = mp.nsum(lambda n: 1 / (n*n), [1, mp.inf], method = "levin", levin_variant = "u")
+        >>> print(mp.chop(v - w))
+        0.0
+
+    Now we sum the zeta function outside its range of convergence
+    (attention: This does not work at the negative integers!)::
+
+        >>> eps = mp.mpf(mp.eps)
+        >>> with mp.extraprec(2 * mp.prec): # levin needs a high working precision
+        ...     L = mp.levin(method = "levin", variant = "v")
+        ...     A, n = [], 1
+        ...     while 1:
+        ...         s = mp.mpf(n) ** (2 + 3j)
+        ...         n += 1
+        ...         A.append(s)
+        ...         v, e = L.update(A)
+        ...         if e < eps:
+        ...             break
+        ...         if n > 1000: raise RuntimeError("iteration limit exceeded")
+        >>> print(mp.chop(v - mp.zeta(-2-3j)))
+        0.0
+        >>> w = mp.nsum(lambda n: n ** (2 + 3j), [1, mp.inf], method = "levin", levin_variant = "v")
+        >>> print(mp.chop(v - w))
+        0.0
+
+    Now we sum the divergent asymptotic expansion of an integral related to the
+    exponential integral (see also [2] p.373). The Sidi-S transform works best here::
+
+        >>> z = mp.mpf(10)
+        >>> exact = mp.quad(lambda x: mp.exp(-x)/(1+x/z),[0,mp.inf])
+        >>> # exact = z * mp.exp(z) * mp.expint(1,z) # this is the symbolic expression for the integral
+        >>> eps = mp.mpf(mp.eps)
+        >>> with mp.extraprec(2 * mp.prec): # high working precisions are mandatory for divergent resummation
+        ...     L = mp.levin(method = "sidi", variant = "t")
+        ...     n = 0
+        ...     while 1:
+        ...         s = (-1)**n * mp.fac(n) * z ** (-n)
+        ...         v, e = L.step(s)
+        ...         n += 1
+        ...         if e < eps:
+        ...             break
+        ...         if n > 1000: raise RuntimeError("iteration limit exceeded")
+        >>> print(mp.chop(v - exact))
+        0.0
+        >>> w = mp.nsum(lambda n: (-1) ** n * mp.fac(n) * z ** (-n), [0, mp.inf], method = "sidi", levin_variant = "t")
+        >>> print(mp.chop(v - w))
+        0.0
+
+    Another highly divergent integral is also summable::
+
+        >>> z = mp.mpf(2)
+        >>> eps = mp.mpf(mp.eps)
+        >>> exact = mp.quad(lambda x: mp.exp( -x * x / 2 - z * x ** 4), [0,mp.inf]) * 2 / mp.sqrt(2 * mp.pi)
+        >>> # exact = mp.exp(mp.one / (32 * z)) * mp.besselk(mp.one / 4, mp.one / (32 * z)) / (4 * mp.sqrt(z * mp.pi)) # this is the symbolic expression for the integral
+        >>> with mp.extraprec(7 * mp.prec):  # we need copious amount of precision to sum this highly divergent series
+        ...     L = mp.levin(method = "levin", variant = "t")
+        ...     n, s = 0, 0
+        ...     while 1:
+        ...         s += (-z)**n * mp.fac(4 * n) / (mp.fac(n) * mp.fac(2 * n) * (4 ** n))
+        ...         n += 1
+        ...         v, e = L.step_psum(s)
+        ...         if e < eps:
+        ...             break
+        ...         if n > 1000: raise RuntimeError("iteration limit exceeded")
+        >>> print(mp.chop(v - exact))
+        0.0
+        >>> w = mp.nsum(lambda n: (-z)**n * mp.fac(4 * n) / (mp.fac(n) * mp.fac(2 * n) * (4 ** n)),
+        ...   [0, mp.inf], method = "levin", levin_variant = "t", workprec = 8*mp.prec, steps = [2] + [1 for x in xrange(1000)])
+        >>> print(mp.chop(v - w))
+        0.0
+
+    These examples run with 15-20 decimal digits precision. For higher precision the
+    working precision must be raised.
+
+    **Examples for nsum**
+
+    Here we calculate Euler's constant as the constant term in the Laurent
+    expansion of `\zeta(s)` at `s=1`. This sum converges extremly slowly because of
+    the logarithmic convergence behaviour of the Dirichlet series for zeta::
+
+        >>> mp.dps = 30
+        >>> z = mp.mpf(10) ** (-10)
+        >>> a = mp.nsum(lambda n: n**(-(1+z)), [1, mp.inf], method = "l") - 1 / z
+        >>> print(mp.chop(a - mp.euler, tol = 1e-10))
+        0.0
+
+    The Sidi-S transform performs excellently for the alternating series of `\log(2)`::
+
+        >>> a = mp.nsum(lambda n: (-1)**(n-1) / n, [1, mp.inf], method = "sidi")
+        >>> print(mp.chop(a - mp.log(2)))
+        0.0
+
+    Hypergeometric series can also be summed outside their range of convergence.
+    The stepsize in :func:`~mpmath.nsum` must not be chosen too large, otherwise it will miss the
+    point where the Levin transform converges resulting in numerical overflow/garbage::
+
+        >>> z = 2 + 1j
+        >>> exact = mp.hyp2f1(2 / mp.mpf(3), 4 / mp.mpf(3), 1 / mp.mpf(3), z)
+        >>> f = lambda n: mp.rf(2 / mp.mpf(3), n) * mp.rf(4 / mp.mpf(3), n) * z**n / (mp.rf(1 / mp.mpf(3), n) * mp.fac(n))
+        >>> v = mp.nsum(f, [0, mp.inf], method = "levin", steps = [10 for x in xrange(1000)])
+        >>> print(mp.chop(exact-v))
+        0.0
+
+    References:
+
+      [1] E.J. Weniger - "Nonlinear Sequence Transformations for the Acceleration of
+          Convergence and the Summation of Divergent Series" arXiv:math/0306302
+
+      [2] A. Sidi - "Pratical Extrapolation Methods"
+
+      [3] H.H.H. Homeier - "Scalar Levin-Type Sequence Transformations" arXiv:math/0005209
+
+    """
+
+    def __init__(self, method = "levin", variant = "u"):
+        self.variant = variant
+        self.n = 0
+        self.a0 = 0
+        self.theta = 1
+        self.A = []
+        self.B = []
+        self.last = 0
+        self.last_s = False
+
+        if method == "levin":
+            self.factor = self.factor_levin
+        elif method == "sidi":
+            self.factor = self.factor_sidi
+        else:
+            raise ValueError("levin: unknown method \"%s\"" % method)
+
+    def factor_levin(self, i):
+        # original levin
+        # [1] p.50,e.7.5-7 (with n-j replaced by i)
+        return (self.theta + i) * (self.theta + self.n - 1) ** (self.n - i - 2) / self.ctx.mpf(self.theta + self.n) ** (self.n - i - 1)
+
+    def factor_sidi(self, i):
+        # sidi analogon to levin (factorial series)
+        # [1] p.59,e.8.3-16 (with n-j replaced by i)
+        return (self.theta + self.n - 1) * (self.theta + self.n - 2) / self.ctx.mpf((self.theta + 2 * self.n - i - 2) * (self.theta + 2 * self.n - i - 3))
+
+    def run(self, s, a0, a1 = 0):
+        if self.variant=="t":
+            # levin t
+            w=a0
+        elif self.variant=="u":
+            # levin u
+            w=a0*(self.theta+self.n)
+        elif self.variant=="v":
+            # levin v
+            w=a0*a1/(a0-a1)
+        else:
+            assert False, "unknown variant"
+
+        if w==0:
+            raise ValueError("levin: zero weight")
+
+        self.A.append(s/w)
+        self.B.append(1/w)
+
+        for i in range(self.n-1,-1,-1):
+            if i==self.n-1:
+                f=1
+            else:
+                f=self.factor(i)
+
+            self.A[i]=self.A[i+1]-f*self.A[i]
+            self.B[i]=self.B[i+1]-f*self.B[i]
+
+        self.n+=1
+
+    ###########################################################################
+
+    def update_psum(self,S):
+        """
+        This routine applies the convergence acceleration to the list of partial sums.
+
+        A   = sum(a_k, k = 0..infinity)
+        s_n = sum(a_k, k = 0..n)
+
+        v, e = ...update_psum([s_0, s_1,..., s_k])
+
+        output:
+          v      current estimate of the series A
+          e      an error estimate which is simply the difference between the current
+                 estimate and the last estimate.
+        """
+
+        if self.variant!="v":
+            if self.n==0:
+                self.run(S[0],S[0])
+            while self.n<len(S):
+                self.run(S[self.n],S[self.n]-S[self.n-1])
+        else:
+            if len(S)==1:
+                self.last=0
+                return S[0],abs(S[0])
+
+            if self.n==0:
+                self.a1=S[1]-S[0]
+                self.run(S[0],S[0],self.a1)
+
+            while self.n<len(S)-1:
+                na1=S[self.n+1]-S[self.n]
+                self.run(S[self.n],self.a1,na1)
+                self.a1=na1
+
+        value=self.A[0]/self.B[0]
+        err=abs(value-self.last)
+        self.last=value
+
+        return value,err
+
+    def update(self,X):
+        """
+        This routine applies the convergence acceleration to the list of individual terms.
+
+        A = sum(a_k, k = 0..infinity)
+
+        v, e = ...update([a_0, a_1,..., a_k])
+
+        output:
+          v      current estimate of the series A
+          e      an error estimate which is simply the difference between the current
+                 estimate and the last estimate.
+        """
+
+        if self.variant!="v":
+            if self.n==0:
+                self.s=X[0]
+                self.run(self.s,X[0])
+            while self.n<len(X):
+                self.s+=X[self.n]
+                self.run(self.s,X[self.n])
+        else:
+            if len(X)==1:
+                self.last=0
+                return X[0],abs(X[0])
+
+            if self.n==0:
+                self.s=X[0]
+                self.run(self.s,X[0],X[1])
+
+            while self.n<len(X)-1:
+                self.s+=X[self.n]
+                self.run(self.s,X[self.n],X[self.n+1])
+
+        value=self.A[0]/self.B[0]
+        err=abs(value-self.last)
+        self.last=value
+
+        return value,err
+
+    ###########################################################################
+
+    def step_psum(self,s):
+        """
+        This routine applies the convergence acceleration to the partial sums.
+
+        A   = sum(a_k, k = 0..infinity)
+        s_n = sum(a_k, k = 0..n)
+
+        v, e = ...step_psum(s_k)
+
+        output:
+          v      current estimate of the series A
+          e      an error estimate which is simply the difference between the current
+                 estimate and the last estimate.
+        """
+
+        if self.variant!="v":
+            if self.n==0:
+                self.last_s=s
+                self.run(s,s)
+            else:
+                self.run(s,s-self.last_s)
+                self.last_s=s
+        else:
+            if isinstance(self.last_s,bool):
+                self.last_s=s
+                self.last_w=s
+                self.last=0
+                return s,abs(s)
+
+            na1=s-self.last_s
+            self.run(self.last_s,self.last_w,na1)
+            self.last_w=na1
+            self.last_s=s
+
+        value=self.A[0]/self.B[0]
+        err=abs(value-self.last)
+        self.last=value
+
+        return value,err
+
+    def step(self,x):
+        """
+        This routine applies the convergence acceleration to the individual terms.
+
+        A = sum(a_k, k = 0..infinity)
+
+        v, e = ...step(a_k)
+
+        output:
+          v      current estimate of the series A
+          e      an error estimate which is simply the difference between the current
+                 estimate and the last estimate.
+        """
+
+        if self.variant!="v":
+            if self.n==0:
+                self.s=x
+                self.run(self.s,x)
+            else:
+                self.s+=x
+                self.run(self.s,x)
+        else:
+            if isinstance(self.last_s,bool):
+                self.last_s=x
+                self.s=0
+                self.last=0
+                return x,abs(x)
+
+            self.s+=self.last_s
+            self.run(self.s,self.last_s,x)
+            self.last_s=x
+
+        value=self.A[0]/self.B[0]
+        err=abs(value-self.last)
+        self.last=value
+
+        return value,err
+
+def levin(ctx, method = "levin", variant = "u"):
+    L = levin_class(method = method, variant = variant)
+    L.ctx = ctx
+    return L
+
+levin.__doc__ = levin_class.__doc__
+defun(levin)
+
+
+class cohen_alt_class:
+    # cohen_alt: Copyright 2013 Timo Hartmann (thartmann15 at gmail.com)
+    r"""
+    This interface implements the convergence acceleration of alternating series
+    as described in H. Cohen, F.R. Villegas, D. Zagier - "Convergence Acceleration
+    of Alternating Series". This series transformation works only well if the
+    individual terms of the series have an alternating sign. It belongs to the
+    class of linear series transformations (in contrast to the Shanks/Wynn-epsilon
+    or Levin transform). This series transformation is also able to sum some types
+    of divergent series. See the paper under which conditions this resummation is
+    mathematical sound.
+
+    Let *A* be the series we want to sum:
+
+    .. math ::
+
+        A = \sum_{k=0}^{\infty} a_k
+
+    Let `s_n` be the partial sums of this series:
+
+    .. math ::
+
+        s_n = \sum_{k=0}^n a_k.
+
+
+    **Interface**
+
+    Calling ``cohen_alt`` returns an object with the following methods.
+
+    Then ``update(...)`` works with the list of individual terms `a_k` and
+    ``update_psum(...)`` works with the list of partial sums `s_k`:
+
+    .. code ::
+
+        v, e = ...update([a_0, a_1,..., a_k])
+        v, e = ...update_psum([s_0, s_1,..., s_k])
+
+    *v* is the current estimate for *A*, and *e* is an error estimate which is
+    simply the difference between the current estimate and the last estimate.
+
+    **Examples**
+
+    Here we compute the alternating zeta function using ``update_psum``::
+
+        >>> from mpmath import mp
+        >>> AC = mp.cohen_alt()
+        >>> S, s, n = [], 0, 1
+        >>> while 1:
+        ...     s += -((-1) ** n) * mp.one / (n * n)
+        ...     n += 1
+        ...     S.append(s)
+        ...     v, e = AC.update_psum(S)
+        ...     if e < mp.eps:
+        ...         break
+        ...     if n > 1000: raise RuntimeError("iteration limit exceeded")
+        >>> print(mp.chop(v - mp.pi ** 2 / 12))
+        0.0
+
+    Here we compute the product `\prod_{n=1}^{\infty} \Gamma(1+1/(2n-1)) / \Gamma(1+1/(2n))`::
+
+        >>> A = []
+        >>> AC = mp.cohen_alt()
+        >>> n = 1
+        >>> while 1:
+        ...     A.append( mp.loggamma(1 + mp.one / (2 * n - 1)))
+        ...     A.append(-mp.loggamma(1 + mp.one / (2 * n)))
+        ...     n += 1
+        ...     v, e = AC.update(A)
+        ...     if e < mp.eps:
+        ...         break
+        ...     if n > 1000: raise RuntimeError("iteration limit exceeded")
+        >>> v = mp.exp(v)
+        >>> print(mp.chop(v - 1.06215090557106, tol = 1e-12))
+        0.0
+
+    ``cohen_alt`` is also accessible through the :func:`~mpmath.nsum` interface::
+
+        >>> v = mp.nsum(lambda n: (-1)**(n-1) / n, [1, mp.inf], method = "a")
+        >>> print(mp.chop(v - mp.log(2)))
+        0.0
+        >>> v = mp.nsum(lambda n: (-1)**n / (2 * n + 1), [0, mp.inf], method = "a")
+        >>> print(mp.chop(v - mp.pi / 4))
+        0.0
+        >>> v = mp.nsum(lambda n: (-1)**n * mp.log(n) * n, [1, mp.inf], method = "a")
+        >>> print(mp.chop(v - mp.diff(lambda s: mp.altzeta(s), -1)))
+        0.0
+
+    """
+
+    def __init__(self):
+        self.last=0
+
+    def update(self, A):
+        """
+        This routine applies the convergence acceleration to the list of individual terms.
+
+        A    = sum(a_k, k = 0..infinity)
+
+        v, e = ...update([a_0, a_1,..., a_k])
+
+        output:
+          v      current estimate of the series A
+          e      an error estimate which is simply the difference between the current
+                 estimate and the last estimate.
+        """
+
+        n = len(A)
+        d = (3 + self.ctx.sqrt(8)) ** n
+        d = (d + 1 / d) / 2
+        b = -self.ctx.one
+        c = -d
+        s = 0
+
+        for k in xrange(n):
+            c = b - c
+            if k % 2 == 0:
+                s = s + c * A[k]
+            else:
+                s = s - c * A[k]
+            b = 2 * (k + n) * (k - n) * b / ((2 * k + 1) * (k + self.ctx.one))
+
+        value = s / d
+
+        err = abs(value - self.last)
+        self.last = value
+
+        return value, err
+
+    def update_psum(self, S):
+        """
+        This routine applies the convergence acceleration to the list of partial sums.
+
+        A   = sum(a_k, k = 0..infinity)
+        s_n = sum(a_k ,k = 0..n)
+
+        v, e = ...update_psum([s_0, s_1,..., s_k])
+
+        output:
+          v      current estimate of the series A
+          e      an error estimate which is simply the difference between the current
+                 estimate and the last estimate.
+        """
+
+        n = len(S)
+        d = (3 + self.ctx.sqrt(8)) ** n
+        d = (d + 1 / d) / 2
+        b = self.ctx.one
+        s = 0
+
+        for k in xrange(n):
+            b = 2 * (n + k) * (n - k) * b / ((2 * k + 1) * (k + self.ctx.one))
+            s += b * S[k]
+
+        value = s / d
+
+        err = abs(value - self.last)
+        self.last = value
+
+        return value, err
+
+def cohen_alt(ctx):
+    L = cohen_alt_class()
+    L.ctx = ctx
+    return L
+
+cohen_alt.__doc__ = cohen_alt_class.__doc__
+defun(cohen_alt)
+
+
+@defun
+def sumap(ctx, f, interval, integral=None, error=False):
+    r"""
+    Evaluates an infinite series of an analytic summand *f* using the
+    Abel-Plana formula
+
+    .. math ::
+
+        \sum_{k=0}^{\infty} f(k) = \int_0^{\infty} f(t) dt + \frac{1}{2} f(0) +
+            i \int_0^{\infty} \frac{f(it)-f(-it)}{e^{2\pi t}-1} dt.
+
+    Unlike the Euler-Maclaurin formula (see :func:`~mpmath.sumem`),
+    the Abel-Plana formula does not require derivatives. However,
+    it only works when `|f(it)-f(-it)|` does not
+    increase too rapidly with `t`.
+
+    **Examples**
+
+    The Abel-Plana formula is particularly useful when the summand
+    decreases like a power of `k`; for example when the sum is a pure
+    zeta function::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> sumap(lambda k: 1/k**2.5, [1,inf])
+        1.34148725725091717975677
+        >>> zeta(2.5)
+        1.34148725725091717975677
+        >>> sumap(lambda k: 1/(k+1j)**(2.5+2.5j), [1,inf])
+        (-3.385361068546473342286084 - 0.7432082105196321803869551j)
+        >>> zeta(2.5+2.5j, 1+1j)
+        (-3.385361068546473342286084 - 0.7432082105196321803869551j)
+
+    If the series is alternating, numerical quadrature along the real
+    line is likely to give poor results, so it is better to evaluate
+    the first term symbolically whenever possible:
+
+        >>> n=3; z=-0.75
+        >>> I = expint(n,-log(z))
+        >>> chop(sumap(lambda k: z**k / k**n, [1,inf], integral=I))
+        -0.6917036036904594510141448
+        >>> polylog(n,z)
+        -0.6917036036904594510141448
+
+    """
+    prec = ctx.prec
+    try:
+        ctx.prec += 10
+        a, b = interval
+        if  b != ctx.inf:
+            raise ValueError("b should be equal to ctx.inf")
+        g = lambda x: f(x+a)
+        if integral is None:
+            i1, err1 = ctx.quad(g, [0,ctx.inf], error=True)
+        else:
+            i1, err1 = integral, 0
+        j = ctx.j
+        p = ctx.pi * 2
+        if ctx._is_real_type(i1):
+            h = lambda t: -2 * ctx.im(g(j*t)) / ctx.expm1(p*t)
+        else:
+            h = lambda t: j*(g(j*t)-g(-j*t)) / ctx.expm1(p*t)
+        i2, err2 = ctx.quad(h, [0,ctx.inf], error=True)
+        err = err1+err2
+        v = i1+i2+0.5*g(ctx.mpf(0))
+    finally:
+        ctx.prec = prec
+    if error:
+        return +v, err
+    return +v
+
+
+@defun
+def sumem(ctx, f, interval, tol=None, reject=10, integral=None,
+    adiffs=None, bdiffs=None, verbose=False, error=False,
+    _fast_abort=False):
+    r"""
+    Uses the Euler-Maclaurin formula to compute an approximation accurate
+    to within ``tol`` (which defaults to the present epsilon) of the sum
+
+    .. math ::
+
+        S = \sum_{k=a}^b f(k)
+
+    where `(a,b)` are given by ``interval`` and `a` or `b` may be
+    infinite. The approximation is
+
+    .. math ::
+
+        S \sim \int_a^b f(x) \,dx + \frac{f(a)+f(b)}{2} +
+        \sum_{k=1}^{\infty} \frac{B_{2k}}{(2k)!}
+        \left(f^{(2k-1)}(b)-f^{(2k-1)}(a)\right).
+
+    The last sum in the Euler-Maclaurin formula is not generally
+    convergent (a notable exception is if `f` is a polynomial, in
+    which case Euler-Maclaurin actually gives an exact result).
+
+    The summation is stopped as soon as the quotient between two
+    consecutive terms falls below *reject*. That is, by default
+    (*reject* = 10), the summation is continued as long as each
+    term adds at least one decimal.
+
+    Although not convergent, convergence to a given tolerance can
+    often be "forced" if `b = \infty` by summing up to `a+N` and then
+    applying the Euler-Maclaurin formula to the sum over the range
+    `(a+N+1, \ldots, \infty)`. This procedure is implemented by
+    :func:`~mpmath.nsum`.
+
+    By default numerical quadrature and differentiation is used.
+    If the symbolic values of the integral and endpoint derivatives
+    are known, it is more efficient to pass the value of the
+    integral explicitly as ``integral`` and the derivatives
+    explicitly as ``adiffs`` and ``bdiffs``. The derivatives
+    should be given as iterables that yield
+    `f(a), f'(a), f''(a), \ldots` (and the equivalent for `b`).
+
+    **Examples**
+
+    Summation of an infinite series, with automatic and symbolic
+    integral and derivative values (the second should be much faster)::
+
+        >>> from mpmath import *
+        >>> mp.dps = 50; mp.pretty = True
+        >>> sumem(lambda n: 1/n**2, [32, inf])
+        0.03174336652030209012658168043874142714132886413417
+        >>> I = mpf(1)/32
+        >>> D = adiffs=((-1)**n*fac(n+1)*32**(-2-n) for n in range(999))
+        >>> sumem(lambda n: 1/n**2, [32, inf], integral=I, adiffs=D)
+        0.03174336652030209012658168043874142714132886413417
+
+    An exact evaluation of a finite polynomial sum::
+
+        >>> sumem(lambda n: n**5-12*n**2+3*n, [-100000, 200000])
+        10500155000624963999742499550000.0
+        >>> print(sum(n**5-12*n**2+3*n for n in range(-100000, 200001)))
+        10500155000624963999742499550000
+
+    """
+    tol = tol or +ctx.eps
+    interval = ctx._as_points(interval)
+    a = ctx.convert(interval[0])
+    b = ctx.convert(interval[-1])
+    err = ctx.zero
+    prev = 0
+    M = 10000
+    if a == ctx.ninf: adiffs = (0 for n in xrange(M))
+    else:             adiffs = adiffs or ctx.diffs(f, a)
+    if b == ctx.inf:  bdiffs = (0 for n in xrange(M))
+    else:             bdiffs = bdiffs or ctx.diffs(f, b)
+    orig = ctx.prec
+    #verbose = 1
+    try:
+        ctx.prec += 10
+        s = ctx.zero
+        for k, (da, db) in enumerate(izip(adiffs, bdiffs)):
+            if k & 1:
+                term = (db-da) * ctx.bernoulli(k+1) / ctx.factorial(k+1)
+                mag = abs(term)
+                if verbose:
+                    print("term", k, "magnitude =", ctx.nstr(mag))
+                if k > 4 and mag < tol:
+                    s += term
+                    break
+                elif k > 4 and abs(prev) / mag < reject:
+                    err += mag
+                    if _fast_abort:
+                        return [s, (s, err)][error]
+                    if verbose:
+                        print("Failed to converge")
+                    break
+                else:
+                    s += term
+                prev = term
+        # Endpoint correction
+        if a != ctx.ninf: s += f(a)/2
+        if b != ctx.inf: s += f(b)/2
+        # Tail integral
+        if verbose:
+            print("Integrating f(x) from x = %s to %s" % (ctx.nstr(a), ctx.nstr(b)))
+        if integral:
+            s += integral
+        else:
+            integral, ierr = ctx.quad(f, interval, error=True)
+            if verbose:
+                print("Integration error:", ierr)
+            s += integral
+            err += ierr
+    finally:
+        ctx.prec = orig
+    if error:
+        return s, err
+    else:
+        return s
+
+@defun
+def adaptive_extrapolation(ctx, update, emfun, kwargs):
+    option = kwargs.get
+    if ctx._fixed_precision:
+        tol = option('tol', ctx.eps*2**10)
+    else:
+        tol = option('tol', ctx.eps/2**10)
+    verbose = option('verbose', False)
+    maxterms = option('maxterms', ctx.dps*10)
+    method = set(option('method', 'r+s').split('+'))
+    skip = option('skip', 0)
+    steps = iter(option('steps', xrange(10, 10**9, 10)))
+    strict = option('strict')
+    #steps = (10 for i in xrange(1000))
+    summer=[]
+    if 'd' in method or 'direct' in method:
+        TRY_RICHARDSON = TRY_SHANKS = TRY_EULER_MACLAURIN = False
+    else:
+        TRY_RICHARDSON = ('r' in method) or ('richardson' in method)
+        TRY_SHANKS = ('s' in method) or ('shanks' in method)
+        TRY_EULER_MACLAURIN = ('e' in method) or \
+            ('euler-maclaurin' in method)
+
+        def init_levin(m):
+            variant = kwargs.get("levin_variant", "u")
+            if isinstance(variant, str):
+                if variant == "all":
+                    variant = ["u", "v", "t"]
+                else:
+                    variant = [variant]
+            for s in variant:
+                L = levin_class(method = m, variant = s)
+                L.ctx = ctx
+                L.name = m + "(" + s + ")"
+                summer.append(L)
+
+        if ('l' in method) or ('levin' in method):
+            init_levin("levin")
+
+        if ('sidi' in method):
+            init_levin("sidi")
+
+        if ('a' in method) or ('alternating' in method):
+            L = cohen_alt_class()
+            L.ctx = ctx
+            L.name = "alternating"
+            summer.append(L)
+
+    last_richardson_value = 0
+    shanks_table = []
+    index = 0
+    step = 10
+    partial = []
+    best = ctx.zero
+    orig = ctx.prec
+    try:
+        if 'workprec' in kwargs:
+            ctx.prec = kwargs['workprec']
+        elif TRY_RICHARDSON or TRY_SHANKS or len(summer)!=0:
+            ctx.prec = (ctx.prec+10) * 4
+        else:
+            ctx.prec += 30
+        while 1:
+            if index >= maxterms:
+                break
+
+            # Get new batch of terms
+            try:
+                step = next(steps)
+            except StopIteration:
+                pass
+            if verbose:
+                print("-"*70)
+                print("Adding terms #%i-#%i" % (index, index+step))
+            update(partial, xrange(index, index+step))
+            index += step
+
+            # Check direct error
+            best = partial[-1]
+            error = abs(best - partial[-2])
+            if verbose:
+                print("Direct error: %s" % ctx.nstr(error))
+            if error <= tol:
+                return best
+
+            # Check each extrapolation method
+            if TRY_RICHARDSON:
+                value, maxc = ctx.richardson(partial)
+                # Convergence
+                richardson_error = abs(value - last_richardson_value)
+                if verbose:
+                    print("Richardson error: %s" % ctx.nstr(richardson_error))
+                # Convergence
+                if richardson_error <= tol:
+                    return value
+                last_richardson_value = value
+                # Unreliable due to cancellation
+                if ctx.eps*maxc > tol:
+                    if verbose:
+                        print("Ran out of precision for Richardson")
+                    TRY_RICHARDSON = False
+                if richardson_error < error:
+                    error = richardson_error
+                    best = value
+            if TRY_SHANKS:
+                shanks_table = ctx.shanks(partial, shanks_table, randomized=True)
+                row = shanks_table[-1]
+                if len(row) == 2:
+                    est1 = row[-1]
+                    shanks_error = 0
+                else:
+                    est1, maxc, est2 = row[-1], abs(row[-2]), row[-3]
+                    shanks_error = abs(est1-est2)
+                if verbose:
+                    print("Shanks error: %s" % ctx.nstr(shanks_error))
+                if shanks_error <= tol:
+                    return est1
+                if ctx.eps*maxc > tol:
+                    if verbose:
+                        print("Ran out of precision for Shanks")
+                    TRY_SHANKS = False
+                if shanks_error < error:
+                    error = shanks_error
+                    best = est1
+            for L in summer:
+                est, lerror = L.update_psum(partial)
+                if verbose:
+                    print("%s error: %s" % (L.name, ctx.nstr(lerror)))
+                if lerror <= tol:
+                    return est
+                if lerror < error:
+                    error = lerror
+                    best = est
+            if TRY_EULER_MACLAURIN:
+                if ctx.almosteq(ctx.mpc(ctx.sign(partial[-1]) / ctx.sign(partial[-2])), -1):
+                    if verbose:
+                        print ("NOT using Euler-Maclaurin: the series appears"
+                            " to be alternating, so numerical\n quadrature"
+                            " will most likely fail")
+                    TRY_EULER_MACLAURIN = False
+                else:
+                    value, em_error = emfun(index, tol)
+                    value += partial[-1]
+                    if verbose:
+                        print("Euler-Maclaurin error: %s" % ctx.nstr(em_error))
+                    if em_error <= tol:
+                        return value
+                    if em_error < error:
+                        best = value
+    finally:
+        ctx.prec = orig
+    if strict:
+        raise ctx.NoConvergence
+    if verbose:
+        print("Warning: failed to converge to target accuracy")
+    return best
+
+@defun
+def nsum(ctx, f, *intervals, **options):
+    r"""
+    Computes the sum
+
+    .. math :: S = \sum_{k=a}^b f(k)
+
+    where `(a, b)` = *interval*, and where `a = -\infty` and/or
+    `b = \infty` are allowed, or more generally
+
+    .. math :: S = \sum_{k_1=a_1}^{b_1} \cdots
+                   \sum_{k_n=a_n}^{b_n} f(k_1,\ldots,k_n)
+
+    if multiple intervals are given.
+
+    Two examples of infinite series that can be summed by :func:`~mpmath.nsum`,
+    where the first converges rapidly and the second converges slowly,
+    are::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> nsum(lambda n: 1/fac(n), [0, inf])
+        2.71828182845905
+        >>> nsum(lambda n: 1/n**2, [1, inf])
+        1.64493406684823
+
+    When appropriate, :func:`~mpmath.nsum` applies convergence acceleration to
+    accurately estimate the sums of slowly convergent series. If the series is
+    finite, :func:`~mpmath.nsum` currently does not attempt to perform any
+    extrapolation, and simply calls :func:`~mpmath.fsum`.
+
+    Multidimensional infinite series are reduced to a single-dimensional
+    series over expanding hypercubes; if both infinite and finite dimensions
+    are present, the finite ranges are moved innermost. For more advanced
+    control over the summation order, use nested calls to :func:`~mpmath.nsum`,
+    or manually rewrite the sum as a single-dimensional series.
+
+    **Options**
+
+    *tol*
+        Desired maximum final error. Defaults roughly to the
+        epsilon of the working precision.
+
+    *method*
+        Which summation algorithm to use (described below).
+        Default: ``'richardson+shanks'``.
+
+    *maxterms*
+        Cancel after at most this many terms. Default: 10*dps.
+
+    *steps*
+        An iterable giving the number of terms to add between
+        each extrapolation attempt. The default sequence is
+        [10, 20, 30, 40, ...]. For example, if you know that
+        approximately 100 terms will be required, efficiency might be
+        improved by setting this to [100, 10]. Then the first
+        extrapolation will be performed after 100 terms, the second
+        after 110, etc.
+
+    *verbose*
+        Print details about progress.
+
+    *ignore*
+        If enabled, any term that raises ``ArithmeticError``
+        or ``ValueError`` (e.g. through division by zero) is replaced
+        by a zero. This is convenient for lattice sums with
+        a singular term near the origin.
+
+    **Methods**
+
+    Unfortunately, an algorithm that can efficiently sum any infinite
+    series does not exist. :func:`~mpmath.nsum` implements several different
+    algorithms that each work well in different cases. The *method*
+    keyword argument selects a method.
+
+    The default method is ``'r+s'``, i.e. both Richardson extrapolation
+    and Shanks transformation is attempted. A slower method that
+    handles more cases is ``'r+s+e'``. For very high precision
+    summation, or if the summation needs to be fast (for example if
+    multiple sums need to be evaluated), it is a good idea to
+    investigate which one method works best and only use that.
+
+    ``'richardson'`` / ``'r'``:
+        Uses Richardson extrapolation. Provides useful extrapolation
+        when `f(k) \sim P(k)/Q(k)` or when `f(k) \sim (-1)^k P(k)/Q(k)`
+        for polynomials `P` and `Q`. See :func:`~mpmath.richardson` for
+        additional information.
+
+    ``'shanks'`` / ``'s'``:
+        Uses Shanks transformation. Typically provides useful
+        extrapolation when `f(k) \sim c^k` or when successive terms
+        alternate signs. Is able to sum some divergent series.
+        See :func:`~mpmath.shanks` for additional information.
+
+    ``'levin'`` / ``'l'``:
+        Uses the Levin transformation. It performs better than the Shanks
+        transformation for logarithmic convergent or alternating divergent
+        series. The ``'levin_variant'``-keyword selects the variant. Valid
+        choices are "u", "t", "v" and "all" whereby "all" uses all three
+        u,t and v simultanously (This is good for performance comparison in
+        conjunction with "verbose=True"). Instead of the Levin transform one can
+        also use the Sidi-S transform by selecting the method ``'sidi'``.
+        See :func:`~mpmath.levin` for additional details.
+
+    ``'alternating'`` / ``'a'``:
+        This is the convergence acceleration of alternating series developped
+        by Cohen, Villegras and Zagier.
+        See :func:`~mpmath.cohen_alt` for additional details.
+
+    ``'euler-maclaurin'`` / ``'e'``:
+        Uses the Euler-Maclaurin summation formula to approximate
+        the remainder sum by an integral. This requires high-order
+        numerical derivatives and numerical integration. The advantage
+        of this algorithm is that it works regardless of the
+        decay rate of `f`, as long as `f` is sufficiently smooth.
+        See :func:`~mpmath.sumem` for additional information.
+
+    ``'direct'`` / ``'d'``:
+        Does not perform any extrapolation. This can be used
+        (and should only be used for) rapidly convergent series.
+        The summation automatically stops when the terms
+        decrease below the target tolerance.
+
+    **Basic examples**
+
+    A finite sum::
+
+        >>> nsum(lambda k: 1/k, [1, 6])
+        2.45
+
+    Summation of a series going to negative infinity and a doubly
+    infinite series::
+
+        >>> nsum(lambda k: 1/k**2, [-inf, -1])
+        1.64493406684823
+        >>> nsum(lambda k: 1/(1+k**2), [-inf, inf])
+        3.15334809493716
+
+    :func:`~mpmath.nsum` handles sums of complex numbers::
+
+        >>> nsum(lambda k: (0.5+0.25j)**k, [0, inf])
+        (1.6 + 0.8j)
+
+    The following sum converges very rapidly, so it is most
+    efficient to sum it by disabling convergence acceleration::
+
+        >>> mp.dps = 1000
+        >>> a = nsum(lambda k: -(-1)**k * k**2 / fac(2*k), [1, inf],
+        ...     method='direct')
+        >>> b = (cos(1)+sin(1))/4
+        >>> abs(a-b) < mpf('1e-998')
+        True
+
+    **Examples with Richardson extrapolation**
+
+    Richardson extrapolation works well for sums over rational
+    functions, as well as their alternating counterparts::
+
+        >>> mp.dps = 50
+        >>> nsum(lambda k: 1 / k**3, [1, inf],
+        ...     method='richardson')
+        1.2020569031595942853997381615114499907649862923405
+        >>> zeta(3)
+        1.2020569031595942853997381615114499907649862923405
+
+        >>> nsum(lambda n: (n + 3)/(n**3 + n**2), [1, inf],
+        ...     method='richardson')
+        2.9348022005446793094172454999380755676568497036204
+        >>> pi**2/2-2
+        2.9348022005446793094172454999380755676568497036204
+
+        >>> nsum(lambda k: (-1)**k / k**3, [1, inf],
+        ...     method='richardson')
+        -0.90154267736969571404980362113358749307373971925537
+        >>> -3*zeta(3)/4
+        -0.90154267736969571404980362113358749307373971925538
+
+    **Examples with Shanks transformation**
+
+    The Shanks transformation works well for geometric series
+    and typically provides excellent acceleration for Taylor
+    series near the border of their disk of convergence.
+    Here we apply it to a series for `\log(2)`, which can be
+    seen as the Taylor series for `\log(1+x)` with `x = 1`::
+
+        >>> nsum(lambda k: -(-1)**k/k, [1, inf],
+        ...     method='shanks')
+        0.69314718055994530941723212145817656807550013436025
+        >>> log(2)
+        0.69314718055994530941723212145817656807550013436025
+
+    Here we apply it to a slowly convergent geometric series::
+
+        >>> nsum(lambda k: mpf('0.995')**k, [0, inf],
+        ...     method='shanks')
+        200.0
+
+    Finally, Shanks' method works very well for alternating series
+    where `f(k) = (-1)^k g(k)`, and often does so regardless of
+    the exact decay rate of `g(k)`::
+
+        >>> mp.dps = 15
+        >>> nsum(lambda k: (-1)**(k+1) / k**1.5, [1, inf],
+        ...     method='shanks')
+        0.765147024625408
+        >>> (2-sqrt(2))*zeta(1.5)/2
+        0.765147024625408
+
+    The following slowly convergent alternating series has no known
+    closed-form value. Evaluating the sum a second time at higher
+    precision indicates that the value is probably correct::
+
+        >>> nsum(lambda k: (-1)**k / log(k), [2, inf],
+        ...     method='shanks')
+        0.924299897222939
+        >>> mp.dps = 30
+        >>> nsum(lambda k: (-1)**k / log(k), [2, inf],
+        ...     method='shanks')
+        0.92429989722293885595957018136
+
+    **Examples with Levin transformation**
+
+    The following example calculates Euler's constant as the constant term in
+    the Laurent expansion of zeta(s) at s=1. This sum converges extremly slow
+    because of the logarithmic convergence behaviour of the Dirichlet series
+    for zeta.
+
+      >>> mp.dps = 30
+      >>> z = mp.mpf(10) ** (-10)
+      >>> a = mp.nsum(lambda n: n**(-(1+z)), [1, mp.inf], method = "levin") - 1 / z
+      >>> print(mp.chop(a - mp.euler, tol = 1e-10))
+      0.0
+
+    Now we sum the zeta function outside its range of convergence
+    (attention: This does not work at the negative integers!):
+
+      >>> mp.dps = 15
+      >>> w = mp.nsum(lambda n: n ** (2 + 3j), [1, mp.inf], method = "levin", levin_variant = "v")
+      >>> print(mp.chop(w - mp.zeta(-2-3j)))
+      0.0
+
+    The next example resummates an asymptotic series expansion of an integral
+    related to the exponential integral.
+
+      >>> mp.dps = 15
+      >>> z = mp.mpf(10)
+      >>> # exact = mp.quad(lambda x: mp.exp(-x)/(1+x/z),[0,mp.inf])
+      >>> exact = z * mp.exp(z) * mp.expint(1,z) # this is the symbolic expression for the integral
+      >>> w = mp.nsum(lambda n: (-1) ** n * mp.fac(n) * z ** (-n), [0, mp.inf], method = "sidi", levin_variant = "t")
+      >>> print(mp.chop(w - exact))
+      0.0
+
+    Following highly divergent asymptotic expansion needs some care. Firstly we
+    need copious amount of working precision. Secondly the stepsize must not be
+    chosen to large, otherwise nsum may miss the point where the Levin transform
+    converges and reach the point where only numerical garbage is produced due to
+    numerical cancellation.
+
+      >>> mp.dps = 15
+      >>> z = mp.mpf(2)
+      >>> # exact = mp.quad(lambda x: mp.exp( -x * x / 2 - z * x ** 4), [0,mp.inf]) * 2 / mp.sqrt(2 * mp.pi)
+      >>> exact = mp.exp(mp.one / (32 * z)) * mp.besselk(mp.one / 4, mp.one / (32 * z)) / (4 * mp.sqrt(z * mp.pi)) # this is the symbolic expression for the integral
+      >>> w = mp.nsum(lambda n: (-z)**n * mp.fac(4 * n) / (mp.fac(n) * mp.fac(2 * n) * (4 ** n)),
+      ...   [0, mp.inf], method = "levin", levin_variant = "t", workprec = 8*mp.prec, steps = [2] + [1 for x in xrange(1000)])
+      >>> print(mp.chop(w - exact))
+      0.0
+
+    The hypergeoemtric function can also be summed outside its range of convergence:
+
+      >>> mp.dps = 15
+      >>> z = 2 + 1j
+      >>> exact = mp.hyp2f1(2 / mp.mpf(3), 4 / mp.mpf(3), 1 / mp.mpf(3), z)
+      >>> f = lambda n: mp.rf(2 / mp.mpf(3), n) * mp.rf(4 / mp.mpf(3), n) * z**n / (mp.rf(1 / mp.mpf(3), n) * mp.fac(n))
+      >>> v = mp.nsum(f, [0, mp.inf], method = "levin", steps = [10 for x in xrange(1000)])
+      >>> print(mp.chop(exact-v))
+      0.0
+
+    **Examples with Cohen's alternating series resummation**
+
+      The next example sums the alternating zeta function:
+
+      >>> v = mp.nsum(lambda n: (-1)**(n-1) / n, [1, mp.inf], method = "a")
+      >>> print(mp.chop(v - mp.log(2)))
+      0.0
+
+      The derivate of the alternating zeta function outside its range of
+      convergence:
+
+      >>> v = mp.nsum(lambda n: (-1)**n * mp.log(n) * n, [1, mp.inf], method = "a")
+      >>> print(mp.chop(v - mp.diff(lambda s: mp.altzeta(s), -1)))
+      0.0
+
+    **Examples with Euler-Maclaurin summation**
+
+    The sum in the following example has the wrong rate of convergence
+    for either Richardson or Shanks to be effective.
+
+        >>> f = lambda k: log(k)/k**2.5
+        >>> mp.dps = 15
+        >>> nsum(f, [1, inf], method='euler-maclaurin')
+        0.38734195032621
+        >>> -diff(zeta, 2.5)
+        0.38734195032621
+
+    Increasing ``steps`` improves speed at higher precision::
+
+        >>> mp.dps = 50
+        >>> nsum(f, [1, inf], method='euler-maclaurin', steps=[250])
+        0.38734195032620997271199237593105101319948228874688
+        >>> -diff(zeta, 2.5)
+        0.38734195032620997271199237593105101319948228874688
+
+    **Divergent series**
+
+    The Shanks transformation is able to sum some *divergent*
+    series. In particular, it is often able to sum Taylor series
+    beyond their radius of convergence (this is due to a relation
+    between the Shanks transformation and Pade approximations;
+    see :func:`~mpmath.pade` for an alternative way to evaluate divergent
+    Taylor series). Furthermore the Levin-transform examples above
+    contain some divergent series resummation.
+
+    Here we apply it to `\log(1+x)` far outside the region of
+    convergence::
+
+        >>> mp.dps = 50
+        >>> nsum(lambda k: -(-9)**k/k, [1, inf],
+        ...     method='shanks')
+        2.3025850929940456840179914546843642076011014886288
+        >>> log(10)
+        2.3025850929940456840179914546843642076011014886288
+
+    A particular type of divergent series that can be summed
+    using the Shanks transformation is geometric series.
+    The result is the same as using the closed-form formula
+    for an infinite geometric series::
+
+        >>> mp.dps = 15
+        >>> for n in range(-8, 8):
+        ...     if n == 1:
+        ...         continue
+        ...     print("%s %s %s" % (mpf(n), mpf(1)/(1-n),
+        ...         nsum(lambda k: n**k, [0, inf], method='shanks')))
+        ...
+        -8.0 0.111111111111111 0.111111111111111
+        -7.0 0.125 0.125
+        -6.0 0.142857142857143 0.142857142857143
+        -5.0 0.166666666666667 0.166666666666667
+        -4.0 0.2 0.2
+        -3.0 0.25 0.25
+        -2.0 0.333333333333333 0.333333333333333
+        -1.0 0.5 0.5
+        0.0 1.0 1.0
+        2.0 -1.0 -1.0
+        3.0 -0.5 -0.5
+        4.0 -0.333333333333333 -0.333333333333333
+        5.0 -0.25 -0.25
+        6.0 -0.2 -0.2
+        7.0 -0.166666666666667 -0.166666666666667
+
+    **Multidimensional sums**
+
+    Any combination of finite and infinite ranges is allowed for the
+    summation indices::
+
+        >>> mp.dps = 15
+        >>> nsum(lambda x,y: x+y, [2,3], [4,5])
+        28.0
+        >>> nsum(lambda x,y: x/2**y, [1,3], [1,inf])
+        6.0
+        >>> nsum(lambda x,y: y/2**x, [1,inf], [1,3])
+        6.0
+        >>> nsum(lambda x,y,z: z/(2**x*2**y), [1,inf], [1,inf], [3,4])
+        7.0
+        >>> nsum(lambda x,y,z: y/(2**x*2**z), [1,inf], [3,4], [1,inf])
+        7.0
+        >>> nsum(lambda x,y,z: x/(2**z*2**y), [3,4], [1,inf], [1,inf])
+        7.0
+
+    Some nice examples of double series with analytic solutions or
+    reductions to single-dimensional series (see [1])::
+
+        >>> nsum(lambda m, n: 1/2**(m*n), [1,inf], [1,inf])
+        1.60669515241529
+        >>> nsum(lambda n: 1/(2**n-1), [1,inf])
+        1.60669515241529
+
+        >>> nsum(lambda i,j: (-1)**(i+j)/(i**2+j**2), [1,inf], [1,inf])
+        0.278070510848213
+        >>> pi*(pi-3*ln2)/12
+        0.278070510848213
+
+        >>> nsum(lambda i,j: (-1)**(i+j)/(i+j)**2, [1,inf], [1,inf])
+        0.129319852864168
+        >>> altzeta(2) - altzeta(1)
+        0.129319852864168
+
+        >>> nsum(lambda i,j: (-1)**(i+j)/(i+j)**3, [1,inf], [1,inf])
+        0.0790756439455825
+        >>> altzeta(3) - altzeta(2)
+        0.0790756439455825
+
+        >>> nsum(lambda m,n: m**2*n/(3**m*(n*3**m+m*3**n)),
+        ...     [1,inf], [1,inf])
+        0.28125
+        >>> mpf(9)/32
+        0.28125
+
+        >>> nsum(lambda i,j: fac(i-1)*fac(j-1)/fac(i+j),
+        ...     [1,inf], [1,inf], workprec=400)
+        1.64493406684823
+        >>> zeta(2)
+        1.64493406684823
+
+    A hard example of a multidimensional sum is the Madelung constant
+    in three dimensions (see [2]). The defining sum converges very
+    slowly and only conditionally, so :func:`~mpmath.nsum` is lucky to
+    obtain an accurate value through convergence acceleration. The
+    second evaluation below uses a much more efficient, rapidly
+    convergent 2D sum::
+
+        >>> nsum(lambda x,y,z: (-1)**(x+y+z)/(x*x+y*y+z*z)**0.5,
+        ...     [-inf,inf], [-inf,inf], [-inf,inf], ignore=True)
+        -1.74756459463318
+        >>> nsum(lambda x,y: -12*pi*sech(0.5*pi * \
+        ...     sqrt((2*x+1)**2+(2*y+1)**2))**2, [0,inf], [0,inf])
+        -1.74756459463318
+
+    Another example of a lattice sum in 2D::
+
+        >>> nsum(lambda x,y: (-1)**(x+y) / (x**2+y**2), [-inf,inf],
+        ...     [-inf,inf], ignore=True)
+        -2.1775860903036
+        >>> -pi*ln2
+        -2.1775860903036
+
+    An example of an Eisenstein series::
+
+        >>> nsum(lambda m,n: (m+n*1j)**(-4), [-inf,inf], [-inf,inf],
+        ...     ignore=True)
+        (3.1512120021539 + 0.0j)
+
+    **References**
+
+    1. [Weisstein]_ http://mathworld.wolfram.com/DoubleSeries.html,
+    2. [Weisstein]_ http://mathworld.wolfram.com/MadelungConstants.html
+
+    """
+    infinite, g = standardize(ctx, f, intervals, options)
+    if not infinite:
+        return +g()
+
+    def update(partial_sums, indices):
+        if partial_sums:
+            psum = partial_sums[-1]
+        else:
+            psum = ctx.zero
+        for k in indices:
+            psum = psum + g(ctx.mpf(k))
+            partial_sums.append(psum)
+
+    prec = ctx.prec
+
+    def emfun(point, tol):
+        workprec = ctx.prec
+        ctx.prec = prec + 10
+        v = ctx.sumem(g, [point, ctx.inf], tol, error=1)
+        ctx.prec = workprec
+        return v
+
+    return +ctx.adaptive_extrapolation(update, emfun, options)
+
+
+def wrapsafe(f):
+    def g(*args):
+        try:
+            return f(*args)
+        except (ArithmeticError, ValueError):
+            return 0
+    return g
+
+def standardize(ctx, f, intervals, options):
+    if options.get("ignore"):
+        f = wrapsafe(f)
+    finite = []
+    infinite = []
+    for k, points in enumerate(intervals):
+        a, b = ctx._as_points(points)
+        if b < a:
+            return False, (lambda: ctx.zero)
+        if a == ctx.ninf or b == ctx.inf:
+            infinite.append((k, (a,b)))
+        else:
+            finite.append((k, (int(a), int(b))))
+    if finite:
+        f = fold_finite(ctx, f, finite)
+        if not infinite:
+            return False, lambda: f(*([0]*len(intervals)))
+    if infinite:
+        f = standardize_infinite(ctx, f, infinite)
+        f = fold_infinite(ctx, f, infinite)
+        args = [0] * len(intervals)
+        d = infinite[0][0]
+        def g(k):
+            args[d] = k
+            return f(*args)
+        return True, g
+
+# backwards compatible itertools.product
+def cartesian_product(args):
+    pools = map(tuple, args)
+    result = [[]]
+    for pool in pools:
+        result = [x+[y] for x in result for y in pool]
+    for prod in result:
+        yield tuple(prod)
+
+def fold_finite(ctx, f, intervals):
+    if not intervals:
+        return f
+    indices = [v[0] for v in intervals]
+    points = [v[1] for v in intervals]
+    ranges = [xrange(a, b+1) for (a,b) in points]
+    def g(*args):
+        args = list(args)
+        s = ctx.zero
+        for xs in cartesian_product(ranges):
+            for dim, x in zip(indices, xs):
+                args[dim] = ctx.mpf(x)
+            s += f(*args)
+        return s
+    #print "Folded finite", indices
+    return g
+
+# Standardize each interval to [0,inf]
+def standardize_infinite(ctx, f, intervals):
+    if not intervals:
+        return f
+    dim, [a,b] = intervals[-1]
+    if a == ctx.ninf:
+        if b == ctx.inf:
+            def g(*args):
+                args = list(args)
+                k = args[dim]
+                if k:
+                    s = f(*args)
+                    args[dim] = -k
+                    s += f(*args)
+                    return s
+                else:
+                    return f(*args)
+        else:
+            def g(*args):
+                args = list(args)
+                args[dim] = b - args[dim]
+                return f(*args)
+    else:
+        def g(*args):
+            args = list(args)
+            args[dim] += a
+            return f(*args)
+    #print "Standardized infinity along dimension", dim, a, b
+    return standardize_infinite(ctx, g, intervals[:-1])
+
+def fold_infinite(ctx, f, intervals):
+    if len(intervals) < 2:
+        return f
+    dim1 = intervals[-2][0]
+    dim2 = intervals[-1][0]
+    # Assume intervals are [0,inf] x [0,inf] x ...
+    def g(*args):
+        args = list(args)
+        #args.insert(dim2, None)
+        n = int(args[dim1])
+        s = ctx.zero
+        #y = ctx.mpf(n)
+        args[dim2] = ctx.mpf(n) #y
+        for x in xrange(n+1):
+            args[dim1] = ctx.mpf(x)
+            s += f(*args)
+        args[dim1] = ctx.mpf(n) #ctx.mpf(n)
+        for y in xrange(n):
+            args[dim2] = ctx.mpf(y)
+            s += f(*args)
+        return s
+    #print "Folded infinite from", len(intervals), "to", (len(intervals)-1)
+    return fold_infinite(ctx, g, intervals[:-1])
+
+@defun
+def nprod(ctx, f, interval, nsum=False, **kwargs):
+    r"""
+    Computes the product
+
+    .. math ::
+
+        P = \prod_{k=a}^b f(k)
+
+    where `(a, b)` = *interval*, and where `a = -\infty` and/or
+    `b = \infty` are allowed.
+
+    By default, :func:`~mpmath.nprod` uses the same extrapolation methods as
+    :func:`~mpmath.nsum`, except applied to the partial products rather than
+    partial sums, and the same keyword options as for :func:`~mpmath.nsum` are
+    supported. If ``nsum=True``, the product is instead computed via
+    :func:`~mpmath.nsum` as
+
+    .. math ::
+
+        P = \exp\left( \sum_{k=a}^b \log(f(k)) \right).
+
+    This is slower, but can sometimes yield better results. It is
+    also required (and used automatically) when Euler-Maclaurin
+    summation is requested.
+
+    **Examples**
+
+    A simple finite product::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> nprod(lambda k: k, [1, 4])
+        24.0
+
+    A large number of infinite products have known exact values,
+    and can therefore be used as a reference. Most of the following
+    examples are taken from MathWorld [1].
+
+    A few infinite products with simple values are::
+
+        >>> 2*nprod(lambda k: (4*k**2)/(4*k**2-1), [1, inf])
+        3.141592653589793238462643
+        >>> nprod(lambda k: (1+1/k)**2/(1+2/k), [1, inf])
+        2.0
+        >>> nprod(lambda k: (k**3-1)/(k**3+1), [2, inf])
+        0.6666666666666666666666667
+        >>> nprod(lambda k: (1-1/k**2), [2, inf])
+        0.5
+
+    Next, several more infinite products with more complicated
+    values::
+
+        >>> nprod(lambda k: exp(1/k**2), [1, inf]); exp(pi**2/6)
+        5.180668317897115748416626
+        5.180668317897115748416626
+
+        >>> nprod(lambda k: (k**2-1)/(k**2+1), [2, inf]); pi*csch(pi)
+        0.2720290549821331629502366
+        0.2720290549821331629502366
+
+        >>> nprod(lambda k: (k**4-1)/(k**4+1), [2, inf])
+        0.8480540493529003921296502
+        >>> pi*sinh(pi)/(cosh(sqrt(2)*pi)-cos(sqrt(2)*pi))
+        0.8480540493529003921296502
+
+        >>> nprod(lambda k: (1+1/k+1/k**2)**2/(1+2/k+3/k**2), [1, inf])
+        1.848936182858244485224927
+        >>> 3*sqrt(2)*cosh(pi*sqrt(3)/2)**2*csch(pi*sqrt(2))/pi
+        1.848936182858244485224927
+
+        >>> nprod(lambda k: (1-1/k**4), [2, inf]); sinh(pi)/(4*pi)
+        0.9190194775937444301739244
+        0.9190194775937444301739244
+
+        >>> nprod(lambda k: (1-1/k**6), [2, inf])
+        0.9826842777421925183244759
+        >>> (1+cosh(pi*sqrt(3)))/(12*pi**2)
+        0.9826842777421925183244759
+
+        >>> nprod(lambda k: (1+1/k**2), [2, inf]); sinh(pi)/(2*pi)
+        1.838038955187488860347849
+        1.838038955187488860347849
+
+        >>> nprod(lambda n: (1+1/n)**n * exp(1/(2*n)-1), [1, inf])
+        1.447255926890365298959138
+        >>> exp(1+euler/2)/sqrt(2*pi)
+        1.447255926890365298959138
+
+    The following two products are equivalent and can be evaluated in
+    terms of a Jacobi theta function. Pi can be replaced by any value
+    (as long as convergence is preserved)::
+
+        >>> nprod(lambda k: (1-pi**-k)/(1+pi**-k), [1, inf])
+        0.3838451207481672404778686
+        >>> nprod(lambda k: tanh(k*log(pi)/2), [1, inf])
+        0.3838451207481672404778686
+        >>> jtheta(4,0,1/pi)
+        0.3838451207481672404778686
+
+    This product does not have a known closed form value::
+
+        >>> nprod(lambda k: (1-1/2**k), [1, inf])
+        0.2887880950866024212788997
+
+    A product taken from `-\infty`::
+
+        >>> nprod(lambda k: 1-k**(-3), [-inf,-2])
+        0.8093965973662901095786805
+        >>> cosh(pi*sqrt(3)/2)/(3*pi)
+        0.8093965973662901095786805
+
+    A doubly infinite product::
+
+        >>> nprod(lambda k: exp(1/(1+k**2)), [-inf, inf])
+        23.41432688231864337420035
+        >>> exp(pi/tanh(pi))
+        23.41432688231864337420035
+
+    A product requiring the use of Euler-Maclaurin summation to compute
+    an accurate value::
+
+        >>> nprod(lambda k: (1-1/k**2.5), [2, inf], method='e')
+        0.696155111336231052898125
+
+    **References**
+
+    1. [Weisstein]_ http://mathworld.wolfram.com/InfiniteProduct.html
+
+    """
+    if nsum or ('e' in kwargs.get('method', '')):
+        orig = ctx.prec
+        try:
+            # TODO: we are evaluating log(1+eps) -> eps, which is
+            # inaccurate. This currently works because nsum greatly
+            # increases the working precision. But we should be
+            # more intelligent and handle the precision here.
+            ctx.prec += 10
+            v = ctx.nsum(lambda n: ctx.ln(f(n)), interval, **kwargs)
+        finally:
+            ctx.prec = orig
+        return +ctx.exp(v)
+
+    a, b = ctx._as_points(interval)
+    if a == ctx.ninf:
+        if b == ctx.inf:
+            return f(0) * ctx.nprod(lambda k: f(-k) * f(k), [1, ctx.inf], **kwargs)
+        return ctx.nprod(f, [-b, ctx.inf], **kwargs)
+    elif b != ctx.inf:
+        return ctx.fprod(f(ctx.mpf(k)) for k in xrange(int(a), int(b)+1))
+
+    a = int(a)
+
+    def update(partial_products, indices):
+        if partial_products:
+            pprod = partial_products[-1]
+        else:
+            pprod = ctx.one
+        for k in indices:
+            pprod = pprod * f(a + ctx.mpf(k))
+            partial_products.append(pprod)
+
+    return +ctx.adaptive_extrapolation(update, None, kwargs)
+
+
+@defun
+def limit(ctx, f, x, direction=1, exp=False, **kwargs):
+    r"""
+    Computes an estimate of the limit
+
+    .. math ::
+
+        \lim_{t \to x} f(t)
+
+    where `x` may be finite or infinite.
+
+    For finite `x`, :func:`~mpmath.limit` evaluates `f(x + d/n)` for
+    consecutive integer values of `n`, where the approach direction
+    `d` may be specified using the *direction* keyword argument.
+    For infinite `x`, :func:`~mpmath.limit` evaluates values of
+    `f(\mathrm{sign}(x) \cdot n)`.
+
+    If the approach to the limit is not sufficiently fast to give
+    an accurate estimate directly, :func:`~mpmath.limit` attempts to find
+    the limit using Richardson extrapolation or the Shanks
+    transformation. You can select between these methods using
+    the *method* keyword (see documentation of :func:`~mpmath.nsum` for
+    more information).
+
+    **Options**
+
+    The following options are available with essentially the
+    same meaning as for :func:`~mpmath.nsum`: *tol*, *method*, *maxterms*,
+    *steps*, *verbose*.
+
+    If the option *exp=True* is set, `f` will be
+    sampled at exponentially spaced points `n = 2^1, 2^2, 2^3, \ldots`
+    instead of the linearly spaced points `n = 1, 2, 3, \ldots`.
+    This can sometimes improve the rate of convergence so that
+    :func:`~mpmath.limit` may return a more accurate answer (and faster).
+    However, do note that this can only be used if `f`
+    supports fast and accurate evaluation for arguments that
+    are extremely close to the limit point (or if infinite,
+    very large arguments).
+
+    **Examples**
+
+    A basic evaluation of a removable singularity::
+
+        >>> from mpmath import *
+        >>> mp.dps = 30; mp.pretty = True
+        >>> limit(lambda x: (x-sin(x))/x**3, 0)
+        0.166666666666666666666666666667
+
+    Computing the exponential function using its limit definition::
+
+        >>> limit(lambda n: (1+3/n)**n, inf)
+        20.0855369231876677409285296546
+        >>> exp(3)
+        20.0855369231876677409285296546
+
+    A limit for `\pi`::
+
+        >>> f = lambda n: 2**(4*n+1)*fac(n)**4/(2*n+1)/fac(2*n)**2
+        >>> limit(f, inf)
+        3.14159265358979323846264338328
+
+    Calculating the coefficient in Stirling's formula::
+
+        >>> limit(lambda n: fac(n) / (sqrt(n)*(n/e)**n), inf)
+        2.50662827463100050241576528481
+        >>> sqrt(2*pi)
+        2.50662827463100050241576528481
+
+    Evaluating Euler's constant `\gamma` using the limit representation
+
+    .. math ::
+
+        \gamma = \lim_{n \rightarrow \infty } \left[ \left(
+        \sum_{k=1}^n \frac{1}{k} \right) - \log(n) \right]
+
+    (which converges notoriously slowly)::
+
+        >>> f = lambda n: sum([mpf(1)/k for k in range(1,int(n)+1)]) - log(n)
+        >>> limit(f, inf)
+        0.577215664901532860606512090082
+        >>> +euler
+        0.577215664901532860606512090082
+
+    With default settings, the following limit converges too slowly
+    to be evaluated accurately. Changing to exponential sampling
+    however gives a perfect result::
+
+        >>> f = lambda x: sqrt(x**3+x**2)/(sqrt(x**3)+x)
+        >>> limit(f, inf)
+        0.992831158558330281129249686491
+        >>> limit(f, inf, exp=True)
+        1.0
+
+    """
+
+    if ctx.isinf(x):
+        direction = ctx.sign(x)
+        g = lambda k: f(ctx.mpf(k+1)*direction)
+    else:
+        direction *= ctx.one
+        g = lambda k: f(x + direction/(k+1))
+    if exp:
+        h = g
+        g = lambda k: h(2**k)
+
+    def update(values, indices):
+        for k in indices:
+            values.append(g(k+1))
+
+    # XXX: steps used by nsum don't work well
+    if not 'steps' in kwargs:
+        kwargs['steps'] = [10]
+
+    return +ctx.adaptive_extrapolation(update, None, kwargs)
diff --git a/lib/python3.10/site-packages/mpmath/calculus/inverselaplace.py b/lib/python3.10/site-packages/mpmath/calculus/inverselaplace.py
new file mode 100644
index 0000000000000000000000000000000000000000..d2206b05c1601ee781b09dcbedf3c0fcd89cfa59
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/calculus/inverselaplace.py
@@ -0,0 +1,973 @@
+# contributed to mpmath by Kristopher L. Kuhlman, February 2017
+# contributed to mpmath by Guillermo Navas-Palencia, February 2022
+
+class InverseLaplaceTransform(object):
+    r"""
+    Inverse Laplace transform methods are implemented using this
+    class, in order to simplify the code and provide a common
+    infrastructure.
+
+    Implement a custom inverse Laplace transform algorithm by
+    subclassing :class:`InverseLaplaceTransform` and implementing the
+    appropriate methods. The subclass can then be used by
+    :func:`~mpmath.invertlaplace` by passing it as the *method*
+    argument.
+    """
+
+    def __init__(self, ctx):
+        self.ctx = ctx
+
+    def calc_laplace_parameter(self, t, **kwargs):
+        r"""
+        Determine the vector of Laplace parameter values needed for an
+        algorithm, this will depend on the choice of algorithm (de
+        Hoog is default), the algorithm-specific parameters passed (or
+        default ones), and desired time.
+        """
+        raise NotImplementedError
+
+    def calc_time_domain_solution(self, fp):
+        r"""
+        Compute the time domain solution, after computing the
+        Laplace-space function evaluations at the abscissa required
+        for the algorithm. Abscissa computed for one algorithm are
+        typically not useful for another algorithm.
+        """
+        raise NotImplementedError
+
+
+class FixedTalbot(InverseLaplaceTransform):
+
+    def calc_laplace_parameter(self, t, **kwargs):
+        r"""The "fixed" Talbot method deforms the Bromwich contour towards
+        `-\infty` in the shape of a parabola. Traditionally the Talbot
+        algorithm has adjustable parameters, but the "fixed" version
+        does not. The `r` parameter could be passed in as a parameter,
+        if you want to override the default given by (Abate & Valko,
+        2004).
+
+        The Laplace parameter is sampled along a parabola opening
+        along the negative imaginary axis, with the base of the
+        parabola along the real axis at
+        `p=\frac{r}{t_\mathrm{max}}`. As the number of terms used in
+        the approximation (degree) grows, the abscissa required for
+        function evaluation tend towards `-\infty`, requiring high
+        precision to prevent overflow.  If any poles, branch cuts or
+        other singularities exist such that the deformed Bromwich
+        contour lies to the left of the singularity, the method will
+        fail.
+
+        **Optional arguments**
+
+        :class:`~mpmath.calculus.inverselaplace.FixedTalbot.calc_laplace_parameter`
+        recognizes the following keywords
+
+        *tmax*
+            maximum time associated with vector of times
+            (typically just the time requested)
+        *degree*
+            integer order of approximation (M = number of terms)
+        *r*
+            abscissa for `p_0` (otherwise computed using rule
+            of thumb `2M/5`)
+
+        The working precision will be increased according to a rule of
+        thumb. If 'degree' is not specified, the working precision and
+        degree are chosen to hopefully achieve the dps of the calling
+        context. If 'degree' is specified, the working precision is
+        chosen to achieve maximum resulting precision for the
+        specified degree.
+
+        .. math ::
+
+            p_0=\frac{r}{t}
+
+        .. math ::
+
+            p_i=\frac{i r \pi}{Mt_\mathrm{max}}\left[\cot\left(
+            \frac{i\pi}{M}\right) + j \right] \qquad 1\le i <M
+
+        where `j=\sqrt{-1}`, `r=2M/5`, and `t_\mathrm{max}` is the
+        maximum specified time.
+
+        """
+
+        # required
+        # ------------------------------
+        # time of desired approximation
+        self.t = self.ctx.convert(t)
+
+        # optional
+        # ------------------------------
+        # maximum time desired (used for scaling) default is requested
+        # time.
+        self.tmax = self.ctx.convert(kwargs.get('tmax', self.t))
+
+        # empirical relationships used here based on a linear fit of
+        # requested and delivered dps for exponentially decaying time
+        # functions for requested dps up to 512.
+
+        if 'degree' in kwargs:
+            self.degree = kwargs['degree']
+            self.dps_goal = self.degree
+        else:
+            self.dps_goal = int(1.72*self.ctx.dps)
+            self.degree = max(12, int(1.38*self.dps_goal))
+
+        M = self.degree
+
+        # this is adjusting the dps of the calling context hopefully
+        # the caller doesn't monkey around with it between calling
+        # this routine and calc_time_domain_solution()
+        self.dps_orig = self.ctx.dps
+        self.ctx.dps = self.dps_goal
+
+        # Abate & Valko rule of thumb for r parameter
+        self.r = kwargs.get('r', self.ctx.fraction(2, 5)*M)
+
+        self.theta = self.ctx.linspace(0.0, self.ctx.pi, M+1)
+
+        self.cot_theta = self.ctx.matrix(M, 1)
+        self.cot_theta[0] = 0  # not used
+
+        # all but time-dependent part of p
+        self.delta = self.ctx.matrix(M, 1)
+        self.delta[0] = self.r
+
+        for i in range(1, M):
+            self.cot_theta[i] = self.ctx.cot(self.theta[i])
+            self.delta[i] = self.r*self.theta[i]*(self.cot_theta[i] + 1j)
+
+        self.p = self.ctx.matrix(M, 1)
+        self.p = self.delta/self.tmax
+
+        # NB: p is complex (mpc)
+
+    def calc_time_domain_solution(self, fp, t, manual_prec=False):
+        r"""The fixed Talbot time-domain solution is computed from the
+        Laplace-space function evaluations using
+
+        .. math ::
+
+            f(t,M)=\frac{2}{5t}\sum_{k=0}^{M-1}\Re \left[
+            \gamma_k \bar{f}(p_k)\right]
+
+        where
+
+        .. math ::
+
+            \gamma_0 = \frac{1}{2}e^{r}\bar{f}(p_0)
+
+        .. math ::
+
+            \gamma_k = e^{tp_k}\left\lbrace 1 + \frac{jk\pi}{M}\left[1 +
+            \cot \left( \frac{k \pi}{M} \right)^2 \right] - j\cot\left(
+            \frac{k \pi}{M}\right)\right \rbrace \qquad 1\le k<M.
+
+        Again, `j=\sqrt{-1}`.
+
+        Before calling this function, call
+        :class:`~mpmath.calculus.inverselaplace.FixedTalbot.calc_laplace_parameter`
+        to set the parameters and compute the required coefficients.
+
+        **References**
+
+        1. Abate, J., P. Valko (2004). Multi-precision Laplace
+           transform inversion. *International Journal for Numerical
+           Methods in Engineering* 60:979-993,
+           http://dx.doi.org/10.1002/nme.995
+        2. Talbot, A. (1979). The accurate numerical inversion of
+           Laplace transforms. *IMA Journal of Applied Mathematics*
+           23(1):97, http://dx.doi.org/10.1093/imamat/23.1.97
+        """
+
+        # required
+        # ------------------------------
+        self.t = self.ctx.convert(t)
+
+        # assume fp was computed from p matrix returned from
+        # calc_laplace_parameter(), so is already a list or matrix of
+        # mpmath 'mpc' types
+
+        # these were computed in previous call to
+        # calc_laplace_parameter()
+        theta = self.theta
+        delta = self.delta
+        M = self.degree
+        p = self.p
+        r = self.r
+
+        ans = self.ctx.matrix(M, 1)
+        ans[0] = self.ctx.exp(delta[0])*fp[0]/2
+
+        for i in range(1, M):
+            ans[i] = self.ctx.exp(delta[i])*fp[i]*(
+                1 + 1j*theta[i]*(1 + self.cot_theta[i]**2) -
+                1j*self.cot_theta[i])
+
+        result = self.ctx.fraction(2, 5)*self.ctx.fsum(ans)/self.t
+
+        # setting dps back to value when calc_laplace_parameter was
+        # called, unless flag is set.
+        if not manual_prec:
+            self.ctx.dps = self.dps_orig
+
+        return result.real
+
+
+# ****************************************
+
+class Stehfest(InverseLaplaceTransform):
+
+    def calc_laplace_parameter(self, t, **kwargs):
+        r"""
+        The Gaver-Stehfest method is a discrete approximation of the
+        Widder-Post inversion algorithm, rather than a direct
+        approximation of the Bromwich contour integral.
+
+        The method abscissa along the real axis, and therefore has
+        issues inverting oscillatory functions (which have poles in
+        pairs away from the real axis).
+
+        The working precision will be increased according to a rule of
+        thumb. If 'degree' is not specified, the working precision and
+        degree are chosen to hopefully achieve the dps of the calling
+        context. If 'degree' is specified, the working precision is
+        chosen to achieve maximum resulting precision for the
+        specified degree.
+
+        .. math ::
+
+            p_k = \frac{k \log 2}{t} \qquad 1 \le k \le M
+        """
+
+        # required
+        # ------------------------------
+        # time of desired approximation
+        self.t = self.ctx.convert(t)
+
+        # optional
+        # ------------------------------
+
+        # empirical relationships used here based on a linear fit of
+        # requested and delivered dps for exponentially decaying time
+        # functions for requested dps up to 512.
+
+        if 'degree' in kwargs:
+            self.degree = kwargs['degree']
+            self.dps_goal = int(1.38*self.degree)
+        else:
+            self.dps_goal = int(2.93*self.ctx.dps)
+            self.degree = max(16, self.dps_goal)
+
+        # _coeff routine requires even degree
+        if self.degree % 2 > 0:
+            self.degree += 1
+
+        M = self.degree
+
+        # this is adjusting the dps of the calling context
+        # hopefully the caller doesn't monkey around with it
+        # between calling this routine and calc_time_domain_solution()
+        self.dps_orig = self.ctx.dps
+        self.ctx.dps = self.dps_goal
+
+        self.V = self._coeff()
+        self.p = self.ctx.matrix(self.ctx.arange(1, M+1))*self.ctx.ln2/self.t
+
+        # NB: p is real (mpf)
+
+    def _coeff(self):
+        r"""Salzer summation weights (aka, "Stehfest coefficients")
+        only depend on the approximation order (M) and the precision"""
+
+        M = self.degree
+        M2 = int(M/2)  # checked earlier that M is even
+
+        V = self.ctx.matrix(M, 1)
+
+        # Salzer summation weights
+        # get very large in magnitude and oscillate in sign,
+        # if the precision is not high enough, there will be
+        # catastrophic cancellation
+        for k in range(1, M+1):
+            z = self.ctx.matrix(min(k, M2)+1, 1)
+            for j in range(int((k+1)/2), min(k, M2)+1):
+                z[j] = (self.ctx.power(j, M2)*self.ctx.fac(2*j)/
+                        (self.ctx.fac(M2-j)*self.ctx.fac(j)*
+                         self.ctx.fac(j-1)*self.ctx.fac(k-j)*
+                         self.ctx.fac(2*j-k)))
+            V[k-1] = self.ctx.power(-1, k+M2)*self.ctx.fsum(z)
+
+        return V
+
+    def calc_time_domain_solution(self, fp, t, manual_prec=False):
+        r"""Compute time-domain Stehfest algorithm solution.
+
+        .. math ::
+
+            f(t,M) = \frac{\log 2}{t} \sum_{k=1}^{M} V_k \bar{f}\left(
+            p_k \right)
+
+        where
+
+        .. math ::
+
+            V_k = (-1)^{k + N/2} \sum^{\min(k,N/2)}_{i=\lfloor(k+1)/2 \rfloor}
+            \frac{i^{\frac{N}{2}}(2i)!}{\left(\frac{N}{2}-i \right)! \, i! \,
+            \left(i-1 \right)! \, \left(k-i\right)! \, \left(2i-k \right)!}
+
+        As the degree increases, the abscissa (`p_k`) only increase
+        linearly towards `\infty`, but the Stehfest coefficients
+        (`V_k`) alternate in sign and increase rapidly in sign,
+        requiring high precision to prevent overflow or loss of
+        significance when evaluating the sum.
+
+        **References**
+
+        1. Widder, D. (1941). *The Laplace Transform*. Princeton.
+        2. Stehfest, H. (1970). Algorithm 368: numerical inversion of
+           Laplace transforms. *Communications of the ACM* 13(1):47-49,
+           http://dx.doi.org/10.1145/361953.361969
+
+        """
+
+        # required
+        self.t = self.ctx.convert(t)
+
+        # assume fp was computed from p matrix returned from
+        # calc_laplace_parameter(), so is already
+        # a list or matrix of mpmath 'mpf' types
+
+        result = self.ctx.fdot(self.V, fp)*self.ctx.ln2/self.t
+
+        # setting dps back to value when calc_laplace_parameter was called
+        if not manual_prec:
+            self.ctx.dps = self.dps_orig
+
+        # ignore any small imaginary part
+        return result.real
+
+
+# ****************************************
+
+class deHoog(InverseLaplaceTransform):
+
+    def calc_laplace_parameter(self, t, **kwargs):
+        r"""the de Hoog, Knight & Stokes algorithm is an
+        accelerated form of the Fourier series numerical
+        inverse Laplace transform algorithms.
+
+        .. math ::
+
+            p_k = \gamma + \frac{jk}{T} \qquad 0 \le k < 2M+1
+
+        where
+
+        .. math ::
+
+            \gamma = \alpha - \frac{\log \mathrm{tol}}{2T},
+
+        `j=\sqrt{-1}`, `T = 2t_\mathrm{max}` is a scaled time,
+        `\alpha=10^{-\mathrm{dps\_goal}}` is the real part of the
+        rightmost pole or singularity, which is chosen based on the
+        desired accuracy (assuming the rightmost singularity is 0),
+        and `\mathrm{tol}=10\alpha` is the desired tolerance, which is
+        chosen in relation to `\alpha`.`
+
+        When increasing the degree, the abscissa increase towards
+        `j\infty`, but more slowly than the fixed Talbot
+        algorithm. The de Hoog et al. algorithm typically does better
+        with oscillatory functions of time, and less well-behaved
+        functions. The method tends to be slower than the Talbot and
+        Stehfest algorithsm, especially so at very high precision
+        (e.g., `>500` digits precision).
+
+        """
+
+        # required
+        # ------------------------------
+        self.t = self.ctx.convert(t)
+
+        # optional
+        # ------------------------------
+        self.tmax = kwargs.get('tmax', self.t)
+
+        # empirical relationships used here based on a linear fit of
+        # requested and delivered dps for exponentially decaying time
+        # functions for requested dps up to 512.
+
+        if 'degree' in kwargs:
+            self.degree = kwargs['degree']
+            self.dps_goal = int(1.38*self.degree)
+        else:
+            self.dps_goal = int(self.ctx.dps*1.36)
+            self.degree = max(10, self.dps_goal)
+
+        # 2*M+1 terms in approximation
+        M = self.degree
+
+        # adjust alpha component of abscissa of convergence for higher
+        # precision
+        tmp = self.ctx.power(10.0, -self.dps_goal)
+        self.alpha = self.ctx.convert(kwargs.get('alpha', tmp))
+
+        # desired tolerance (here simply related to alpha)
+        self.tol = self.ctx.convert(kwargs.get('tol', self.alpha*10.0))
+        self.np = 2*self.degree+1  # number of terms in approximation
+
+        # this is adjusting the dps of the calling context
+        # hopefully the caller doesn't monkey around with it
+        # between calling this routine and calc_time_domain_solution()
+        self.dps_orig = self.ctx.dps
+        self.ctx.dps = self.dps_goal
+
+        # scaling factor (likely tun-able, but 2 is typical)
+        self.scale = kwargs.get('scale', 2)
+        self.T = self.ctx.convert(kwargs.get('T', self.scale*self.tmax))
+
+        self.p = self.ctx.matrix(2*M+1, 1)
+        self.gamma = self.alpha - self.ctx.log(self.tol)/(self.scale*self.T)
+        self.p = (self.gamma + self.ctx.pi*
+                  self.ctx.matrix(self.ctx.arange(self.np))/self.T*1j)
+
+        # NB: p is complex (mpc)
+
+    def calc_time_domain_solution(self, fp, t, manual_prec=False):
+        r"""Calculate time-domain solution for
+        de Hoog, Knight & Stokes algorithm.
+
+        The un-accelerated Fourier series approach is:
+
+        .. math ::
+
+            f(t,2M+1) = \frac{e^{\gamma t}}{T} \sum_{k=0}^{2M}{}^{'}
+            \Re\left[\bar{f}\left( p_k \right)
+            e^{i\pi t/T} \right],
+
+        where the prime on the summation indicates the first term is halved.
+
+        This simplistic approach requires so many function evaluations
+        that it is not practical. Non-linear acceleration is
+        accomplished via Pade-approximation and an analytic expression
+        for the remainder of the continued fraction. See the original
+        paper (reference 2 below) a detailed description of the
+        numerical approach.
+
+        **References**
+
+        1. Davies, B. (2005). *Integral Transforms and their
+           Applications*, Third Edition. Springer.
+        2. de Hoog, F., J. Knight, A. Stokes (1982). An improved
+           method for numerical inversion of Laplace transforms. *SIAM
+           Journal of Scientific and Statistical Computing* 3:357-366,
+           http://dx.doi.org/10.1137/0903022
+
+        """
+
+        M = self.degree
+        np = self.np
+        T = self.T
+
+        self.t = self.ctx.convert(t)
+
+        # would it be useful to try re-using
+        # space between e&q and A&B?
+        e = self.ctx.zeros(np, M+1)
+        q = self.ctx.matrix(2*M, M)
+        d = self.ctx.matrix(np, 1)
+        A = self.ctx.zeros(np+1, 1)
+        B = self.ctx.ones(np+1, 1)
+
+        # initialize Q-D table
+        e[:, 0] = 0.0 + 0j
+        q[0, 0] = fp[1]/(fp[0]/2)
+        for i in range(1, 2*M):
+            q[i, 0] = fp[i+1]/fp[i]
+
+        # rhombus rule for filling triangular Q-D table (e & q)
+        for r in range(1, M+1):
+            # start with e, column 1, 0:2*M-2
+            mr = 2*(M-r) + 1
+            e[0:mr, r] = q[1:mr+1, r-1] - q[0:mr, r-1] + e[1:mr+1, r-1]
+            if not r == M:
+                rq = r+1
+                mr = 2*(M-rq)+1 + 2
+                for i in range(mr):
+                    q[i, rq-1] = q[i+1, rq-2]*e[i+1, rq-1]/e[i, rq-1]
+
+        # build up continued fraction coefficients (d)
+        d[0] = fp[0]/2
+        for r in range(1, M+1):
+            d[2*r-1] = -q[0, r-1]  # even terms
+            d[2*r]   = -e[0, r]    # odd terms
+
+        # seed A and B for recurrence
+        A[0] = 0.0 + 0.0j
+        A[1] = d[0]
+        B[0:2] = 1.0 + 0.0j
+
+        # base of the power series
+        z = self.ctx.expjpi(self.t/T)  # i*pi is already in fcn
+
+        # coefficients of Pade approximation (A & B)
+        # using recurrence for all but last term
+        for i in range(1, 2*M):
+            A[i+1] = A[i] + d[i]*A[i-1]*z
+            B[i+1] = B[i] + d[i]*B[i-1]*z
+
+        # "improved remainder" to continued fraction
+        brem = (1 + (d[2*M-1] - d[2*M])*z)/2
+        # powm1(x,y) computes x^y - 1 more accurately near zero
+        rem = brem*self.ctx.powm1(1 + d[2*M]*z/brem,
+                                  self.ctx.fraction(1, 2))
+
+        # last term of recurrence using new remainder
+        A[np] = A[2*M] + rem*A[2*M-1]
+        B[np] = B[2*M] + rem*B[2*M-1]
+
+        # diagonal Pade approximation
+        # F=A/B represents accelerated trapezoid rule
+        result = self.ctx.exp(self.gamma*self.t)/T*(A[np]/B[np]).real
+
+        # setting dps back to value when calc_laplace_parameter was called
+        if not manual_prec:
+            self.ctx.dps = self.dps_orig
+
+        return result
+
+
+# ****************************************
+
+class Cohen(InverseLaplaceTransform):
+
+    def calc_laplace_parameter(self, t, **kwargs):
+        r"""The Cohen algorithm accelerates the convergence of the nearly
+        alternating series resulting from the application of the trapezoidal
+        rule to the Bromwich contour inversion integral.
+
+        .. math ::
+
+            p_k = \frac{\gamma}{2 t} + \frac{\pi i k}{t} \qquad 0 \le k < M
+
+        where
+
+        .. math ::
+
+            \gamma = \frac{2}{3} (d + \log(10) + \log(2 t)),
+
+        `d = \mathrm{dps\_goal}`, which is chosen based on the desired
+        accuracy using the method developed in [1] to improve numerical
+        stability. The Cohen algorithm shows robustness similar to the de Hoog
+        et al. algorithm, but it is faster than the fixed Talbot algorithm.
+
+        **Optional arguments**
+
+        *degree*
+            integer order of the approximation (M = number of terms)
+        *alpha*
+            abscissa for `p_0` (controls the discretization error)
+
+        The working precision will be increased according to a rule of
+        thumb. If 'degree' is not specified, the working precision and
+        degree are chosen to hopefully achieve the dps of the calling
+        context. If 'degree' is specified, the working precision is
+        chosen to achieve maximum resulting precision for the
+        specified degree.
+
+        **References**
+
+        1. P. Glasserman, J. Ruiz-Mata (2006). Computing the credit loss
+        distribution in the Gaussian copula model: a comparison of methods.
+        *Journal of Credit Risk* 2(4):33-66, 10.21314/JCR.2006.057
+
+        """
+        self.t = self.ctx.convert(t)
+
+        if 'degree' in kwargs:
+            self.degree = kwargs['degree']
+            self.dps_goal = int(1.5 * self.degree)
+        else:
+            self.dps_goal = int(self.ctx.dps * 1.74)
+            self.degree = max(22, int(1.31 * self.dps_goal))
+
+        M = self.degree + 1
+
+        # this is adjusting the dps of the calling context hopefully
+        # the caller doesn't monkey around with it between calling
+        # this routine and calc_time_domain_solution()
+        self.dps_orig = self.ctx.dps
+        self.ctx.dps = self.dps_goal
+
+        ttwo = 2 * self.t
+        tmp = self.ctx.dps * self.ctx.log(10) + self.ctx.log(ttwo)
+        tmp = self.ctx.fraction(2, 3) * tmp
+        self.alpha = self.ctx.convert(kwargs.get('alpha', tmp))
+
+        # all but time-dependent part of p
+        a_t = self.alpha / ttwo
+        p_t = self.ctx.pi * 1j / self.t
+
+        self.p = self.ctx.matrix(M, 1)
+        self.p[0] = a_t
+
+        for i in range(1, M):
+            self.p[i] = a_t + i * p_t
+
+    def calc_time_domain_solution(self, fp, t, manual_prec=False):
+        r"""Calculate time-domain solution for Cohen algorithm.
+
+        The accelerated nearly alternating series is:
+
+        .. math ::
+
+            f(t, M) = \frac{e^{\gamma / 2}}{t} \left[\frac{1}{2}
+            \Re\left(\bar{f}\left(\frac{\gamma}{2t}\right) \right) -
+            \sum_{k=0}^{M-1}\frac{c_{M,k}}{d_M}\Re\left(\bar{f}
+            \left(\frac{\gamma + 2(k+1) \pi i}{2t}\right)\right)\right],
+
+        where coefficients `\frac{c_{M, k}}{d_M}` are described in [1].
+
+        1. H. Cohen, F. Rodriguez Villegas, D. Zagier (2000). Convergence
+        acceleration of alternating series. *Experiment. Math* 9(1):3-12
+
+        """
+        self.t = self.ctx.convert(t)
+
+        n = self.degree
+        M = n + 1
+
+        A = self.ctx.matrix(M, 1)
+        for i in range(M):
+            A[i] = fp[i].real
+
+        d = (3 + self.ctx.sqrt(8)) ** n
+        d = (d + 1 / d) / 2
+        b = -self.ctx.one
+        c = -d
+        s = 0
+
+        for k in range(n):
+            c = b - c
+            s = s + c * A[k + 1]
+            b = 2 * (k + n) * (k - n) * b / ((2 * k + 1) * (k + self.ctx.one))
+
+        result = self.ctx.exp(self.alpha / 2) / self.t * (A[0] / 2 - s / d)
+
+        # setting dps back to value when calc_laplace_parameter was
+        # called, unless flag is set.
+        if not manual_prec:
+            self.ctx.dps = self.dps_orig
+
+        return result
+
+
+# ****************************************
+
+class LaplaceTransformInversionMethods(object):
+    def __init__(ctx, *args, **kwargs):
+        ctx._fixed_talbot = FixedTalbot(ctx)
+        ctx._stehfest = Stehfest(ctx)
+        ctx._de_hoog = deHoog(ctx)
+        ctx._cohen = Cohen(ctx)
+
+    def invertlaplace(ctx, f, t, **kwargs):
+        r"""Computes the numerical inverse Laplace transform for a
+        Laplace-space function at a given time.  The function being
+        evaluated is assumed to be a real-valued function of time.
+
+        The user must supply a Laplace-space function `\bar{f}(p)`,
+        and a desired time at which to estimate the time-domain
+        solution `f(t)`.
+
+        A few basic examples of Laplace-space functions with known
+        inverses (see references [1,2]) :
+
+        .. math ::
+
+            \mathcal{L}\left\lbrace f(t) \right\rbrace=\bar{f}(p)
+
+        .. math ::
+
+            \mathcal{L}^{-1}\left\lbrace \bar{f}(p) \right\rbrace = f(t)
+
+        .. math ::
+
+            \bar{f}(p) = \frac{1}{(p+1)^2}
+
+        .. math ::
+
+            f(t) = t e^{-t}
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> tt = [0.001, 0.01, 0.1, 1, 10]
+        >>> fp = lambda p: 1/(p+1)**2
+        >>> ft = lambda t: t*exp(-t)
+        >>> ft(tt[0]),ft(tt[0])-invertlaplace(fp,tt[0],method='talbot')
+        (0.000999000499833375, 8.57923043561212e-20)
+        >>> ft(tt[1]),ft(tt[1])-invertlaplace(fp,tt[1],method='talbot')
+        (0.00990049833749168, 3.27007646698047e-19)
+        >>> ft(tt[2]),ft(tt[2])-invertlaplace(fp,tt[2],method='talbot')
+        (0.090483741803596, -1.75215800052168e-18)
+        >>> ft(tt[3]),ft(tt[3])-invertlaplace(fp,tt[3],method='talbot')
+        (0.367879441171442, 1.2428864009344e-17)
+        >>> ft(tt[4]),ft(tt[4])-invertlaplace(fp,tt[4],method='talbot')
+        (0.000453999297624849, 4.04513489306658e-20)
+
+        The methods also work for higher precision:
+
+        >>> mp.dps = 100; mp.pretty = True
+        >>> nstr(ft(tt[0]),15),nstr(ft(tt[0])-invertlaplace(fp,tt[0],method='talbot'),15)
+        ('0.000999000499833375', '-4.96868310693356e-105')
+        >>> nstr(ft(tt[1]),15),nstr(ft(tt[1])-invertlaplace(fp,tt[1],method='talbot'),15)
+        ('0.00990049833749168', '1.23032291513122e-104')
+
+        .. math ::
+
+            \bar{f}(p) = \frac{1}{p^2+1}
+
+        .. math ::
+
+            f(t) = \mathrm{J}_0(t)
+
+        >>> mp.dps = 15; mp.pretty = True
+        >>> fp = lambda p: 1/sqrt(p*p + 1)
+        >>> ft = lambda t: besselj(0,t)
+        >>> ft(tt[0]),ft(tt[0])-invertlaplace(fp,tt[0],method='dehoog')
+        (0.999999750000016, -6.09717765032273e-18)
+        >>> ft(tt[1]),ft(tt[1])-invertlaplace(fp,tt[1],method='dehoog')
+        (0.99997500015625, -5.61756281076169e-17)
+
+        .. math ::
+
+            \bar{f}(p) = \frac{\log p}{p}
+
+        .. math ::
+
+            f(t) = -\gamma -\log t
+
+        >>> mp.dps = 15; mp.pretty = True
+        >>> fp = lambda p: log(p)/p
+        >>> ft = lambda t: -euler-log(t)
+        >>> ft(tt[0]),ft(tt[0])-invertlaplace(fp,tt[0],method='stehfest')
+        (6.3305396140806, -1.92126634837863e-16)
+        >>> ft(tt[1]),ft(tt[1])-invertlaplace(fp,tt[1],method='stehfest')
+        (4.02795452108656, -4.81486093200704e-16)
+
+        **Options**
+
+        :func:`~mpmath.invertlaplace` recognizes the following optional
+        keywords valid for all methods:
+
+        *method*
+            Chooses numerical inverse Laplace transform algorithm
+            (described below).
+        *degree*
+            Number of terms used in the approximation
+
+        **Algorithms**
+
+        Mpmath implements four numerical inverse Laplace transform
+        algorithms, attributed to: Talbot, Stehfest, and de Hoog,
+        Knight and Stokes. These can be selected by using
+        *method='talbot'*, *method='stehfest'*, *method='dehoog'* or
+        *method='cohen'* or by passing the classes *method=FixedTalbot*,
+        *method=Stehfest*, *method=deHoog*, or *method=Cohen*. The functions
+        :func:`~mpmath.invlaptalbot`, :func:`~mpmath.invlapstehfest`,
+        :func:`~mpmath.invlapdehoog`, and :func:`~mpmath.invlapcohen`
+        are also available as shortcuts.
+
+        All four algorithms implement a heuristic balance between the
+        requested precision and the precision used internally for the
+        calculations. This has been tuned for a typical exponentially
+        decaying function and precision up to few hundred decimal
+        digits.
+
+        The Laplace transform converts the variable time (i.e., along
+        a line) into a parameter given by the right half of the
+        complex `p`-plane.  Singularities, poles, and branch cuts in
+        the complex `p`-plane contain all the information regarding
+        the time behavior of the corresponding function. Any numerical
+        method must therefore sample `p`-plane "close enough" to the
+        singularities to accurately characterize them, while not
+        getting too close to have catastrophic cancellation, overflow,
+        or underflow issues. Most significantly, if one or more of the
+        singularities in the `p`-plane is not on the left side of the
+        Bromwich contour, its effects will be left out of the computed
+        solution, and the answer will be completely wrong.
+
+        *Talbot*
+
+        The fixed Talbot method is high accuracy and fast, but the
+        method can catastrophically fail for certain classes of time-domain
+        behavior, including a Heaviside step function for positive
+        time (e.g., `H(t-2)`), or some oscillatory behaviors. The
+        Talbot method usually has adjustable parameters, but the
+        "fixed" variety implemented here does not. This method
+        deforms the Bromwich integral contour in the shape of a
+        parabola towards `-\infty`, which leads to problems
+        when the solution has a decaying exponential in it (e.g., a
+        Heaviside step function is equivalent to multiplying by a
+        decaying exponential in Laplace space).
+
+        *Stehfest*
+
+        The Stehfest algorithm only uses abscissa along the real axis
+        of the complex `p`-plane to estimate the time-domain
+        function. Oscillatory time-domain functions have poles away
+        from the real axis, so this method does not work well with
+        oscillatory functions, especially high-frequency ones. This
+        method also depends on summation of terms in a series that
+        grows very large, and will have catastrophic cancellation
+        during summation if the working precision is too low.
+
+        *de Hoog et al.*
+
+        The de Hoog, Knight, and Stokes method is essentially a
+        Fourier-series quadrature-type approximation to the Bromwich
+        contour integral, with non-linear series acceleration and an
+        analytical expression for the remainder term. This method is
+        typically one of the most robust. This method also involves the
+        greatest amount of overhead, so it is typically the slowest of the
+        four methods at high precision.
+
+        *Cohen*
+
+        The Cohen method is a trapezoidal rule approximation to the Bromwich
+        contour integral, with linear acceleration for alternating
+        series. This method is as robust as the de Hoog et al method and the
+        fastest of the four methods at high precision, and is therefore the
+        default method.
+
+        **Singularities**
+
+        All numerical inverse Laplace transform methods have problems
+        at large time when the Laplace-space function has poles,
+        singularities, or branch cuts to the right of the origin in
+        the complex plane. For simple poles in `\bar{f}(p)` at the
+        `p`-plane origin, the time function is constant in time (e.g.,
+        `\mathcal{L}\left\lbrace 1 \right\rbrace=1/p` has a pole at
+        `p=0`). A pole in `\bar{f}(p)` to the left of the origin is a
+        decreasing function of time (e.g., `\mathcal{L}\left\lbrace
+        e^{-t/2} \right\rbrace=1/(p+1/2)` has a pole at `p=-1/2`), and
+        a pole to the right of the origin leads to an increasing
+        function in time (e.g., `\mathcal{L}\left\lbrace t e^{t/4}
+        \right\rbrace = 1/(p-1/4)^2` has a pole at `p=1/4`).  When
+        singularities occur off the real `p` axis, the time-domain
+        function is oscillatory. For example `\mathcal{L}\left\lbrace
+        \mathrm{J}_0(t) \right\rbrace=1/\sqrt{p^2+1}` has a branch cut
+        starting at `p=j=\sqrt{-1}` and is a decaying oscillatory
+        function, This range of behaviors is illustrated in Duffy [3]
+        Figure 4.10.4, p. 228.
+
+        In general as `p \rightarrow \infty` `t \rightarrow 0` and
+        vice-versa. All numerical inverse Laplace transform methods
+        require their abscissa to shift closer to the origin for
+        larger times. If the abscissa shift left of the rightmost
+        singularity in the Laplace domain, the answer will be
+        completely wrong (the effect of singularities to the right of
+        the Bromwich contour are not included in the results).
+
+        For example, the following exponentially growing function has
+        a pole at `p=3`:
+
+        .. math ::
+
+            \bar{f}(p)=\frac{1}{p^2-9}
+
+        .. math ::
+
+            f(t)=\frac{1}{3}\sinh 3t
+
+        >>> mp.dps = 15; mp.pretty = True
+        >>> fp = lambda p: 1/(p*p-9)
+        >>> ft = lambda t: sinh(3*t)/3
+        >>> tt = [0.01,0.1,1.0,10.0]
+        >>> ft(tt[0]),invertlaplace(fp,tt[0],method='talbot')
+        (0.0100015000675014, 0.0100015000675014)
+        >>> ft(tt[1]),invertlaplace(fp,tt[1],method='talbot')
+        (0.101506764482381, 0.101506764482381)
+        >>> ft(tt[2]),invertlaplace(fp,tt[2],method='talbot')
+        (3.33929164246997, 3.33929164246997)
+        >>> ft(tt[3]),invertlaplace(fp,tt[3],method='talbot')
+        (1781079096920.74, -1.61331069624091e-14)
+
+        **References**
+
+        1. [DLMF]_ section 1.14 (http://dlmf.nist.gov/1.14T4)
+        2. Cohen, A.M. (2007). Numerical Methods for Laplace Transform
+           Inversion, Springer.
+        3. Duffy, D.G. (1998). Advanced Engineering Mathematics, CRC Press.
+
+        **Numerical Inverse Laplace Transform Reviews**
+
+        1. Bellman, R., R.E. Kalaba, J.A. Lockett (1966). *Numerical
+           inversion of the Laplace transform: Applications to Biology,
+           Economics, Engineering, and Physics*. Elsevier.
+        2. Davies, B., B. Martin (1979). Numerical inversion of the
+           Laplace transform: a survey and comparison of methods. *Journal
+           of Computational Physics* 33:1-32,
+           http://dx.doi.org/10.1016/0021-9991(79)90025-1
+        3. Duffy, D.G. (1993). On the numerical inversion of Laplace
+           transforms: Comparison of three new methods on characteristic
+           problems from applications. *ACM Transactions on Mathematical
+           Software* 19(3):333-359, http://dx.doi.org/10.1145/155743.155788
+        4. Kuhlman, K.L., (2013). Review of Inverse Laplace Transform
+           Algorithms for Laplace-Space Numerical Approaches, *Numerical
+           Algorithms*, 63(2):339-355.
+           http://dx.doi.org/10.1007/s11075-012-9625-3
+
+        """
+
+        rule = kwargs.get('method', 'cohen')
+        if type(rule) is str:
+            lrule = rule.lower()
+            if lrule == 'talbot':
+                rule = ctx._fixed_talbot
+            elif lrule == 'stehfest':
+                rule = ctx._stehfest
+            elif lrule == 'dehoog':
+                rule = ctx._de_hoog
+            elif rule == 'cohen':
+                rule = ctx._cohen
+            else:
+                raise ValueError("unknown invlap algorithm: %s" % rule)
+        else:
+            rule = rule(ctx)
+
+        # determine the vector of Laplace-space parameter
+        # needed for the requested method and desired time
+        rule.calc_laplace_parameter(t, **kwargs)
+
+        # compute the Laplace-space function evalutations
+        # at the required abscissa.
+        fp = [f(p) for p in rule.p]
+
+        # compute the time-domain solution from the
+        # Laplace-space function evaluations
+        return rule.calc_time_domain_solution(fp, t)
+
+    # shortcuts for the above function for specific methods
+    def invlaptalbot(ctx, *args, **kwargs):
+        kwargs['method'] = 'talbot'
+        return ctx.invertlaplace(*args, **kwargs)
+
+    def invlapstehfest(ctx, *args, **kwargs):
+        kwargs['method'] = 'stehfest'
+        return ctx.invertlaplace(*args, **kwargs)
+
+    def invlapdehoog(ctx, *args, **kwargs):
+        kwargs['method'] = 'dehoog'
+        return ctx.invertlaplace(*args, **kwargs)
+
+    def invlapcohen(ctx, *args, **kwargs):
+        kwargs['method'] = 'cohen'
+        return ctx.invertlaplace(*args, **kwargs)
+
+
+# ****************************************
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
diff --git a/lib/python3.10/site-packages/mpmath/calculus/odes.py b/lib/python3.10/site-packages/mpmath/calculus/odes.py
new file mode 100644
index 0000000000000000000000000000000000000000..ac6bd3cb056c8841e6cf77ba4d08a0b1abb2f2c9
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/calculus/odes.py
@@ -0,0 +1,288 @@
+from bisect import bisect
+from ..libmp.backend import xrange
+
+class ODEMethods(object):
+    pass
+
+def ode_taylor(ctx, derivs, x0, y0, tol_prec, n):
+    h = tol = ctx.ldexp(1, -tol_prec)
+    dim = len(y0)
+    xs = [x0]
+    ys = [y0]
+    x = x0
+    y = y0
+    orig = ctx.prec
+    try:
+        ctx.prec = orig*(1+n)
+        # Use n steps with Euler's method to get
+        # evaluation points for derivatives
+        for i in range(n):
+            fxy = derivs(x, y)
+            y = [y[i]+h*fxy[i] for i in xrange(len(y))]
+            x += h
+            xs.append(x)
+            ys.append(y)
+        # Compute derivatives
+        ser = [[] for d in range(dim)]
+        for j in range(n+1):
+            s = [0]*dim
+            b = (-1) ** (j & 1)
+            k = 1
+            for i in range(j+1):
+                for d in range(dim):
+                    s[d] += b * ys[i][d]
+                b = (b * (j-k+1)) // (-k)
+                k += 1
+            scale = h**(-j) / ctx.fac(j)
+            for d in range(dim):
+                s[d] = s[d] * scale
+                ser[d].append(s[d])
+    finally:
+        ctx.prec = orig
+    # Estimate radius for which we can get full accuracy.
+    # XXX: do this right for zeros
+    radius = ctx.one
+    for ts in ser:
+        if ts[-1]:
+            radius = min(radius, ctx.nthroot(tol/abs(ts[-1]), n))
+    radius /= 2  # XXX
+    return ser, x0+radius
+
+def odefun(ctx, F, x0, y0, tol=None, degree=None, method='taylor', verbose=False):
+    r"""
+    Returns a function `y(x) = [y_0(x), y_1(x), \ldots, y_n(x)]`
+    that is a numerical solution of the `n+1`-dimensional first-order
+    ordinary differential equation (ODE) system
+
+    .. math ::
+
+        y_0'(x) = F_0(x, [y_0(x), y_1(x), \ldots, y_n(x)])
+
+        y_1'(x) = F_1(x, [y_0(x), y_1(x), \ldots, y_n(x)])
+
+        \vdots
+
+        y_n'(x) = F_n(x, [y_0(x), y_1(x), \ldots, y_n(x)])
+
+    The derivatives are specified by the vector-valued function
+    *F* that evaluates
+    `[y_0', \ldots, y_n'] = F(x, [y_0, \ldots, y_n])`.
+    The initial point `x_0` is specified by the scalar argument *x0*,
+    and the initial value `y(x_0) =  [y_0(x_0), \ldots, y_n(x_0)]` is
+    specified by the vector argument *y0*.
+
+    For convenience, if the system is one-dimensional, you may optionally
+    provide just a scalar value for *y0*. In this case, *F* should accept
+    a scalar *y* argument and return a scalar. The solution function
+    *y* will return scalar values instead of length-1 vectors.
+
+    Evaluation of the solution function `y(x)` is permitted
+    for any `x \ge x_0`.
+
+    A high-order ODE can be solved by transforming it into first-order
+    vector form. This transformation is described in standard texts
+    on ODEs. Examples will also be given below.
+
+    **Options, speed and accuracy**
+
+    By default, :func:`~mpmath.odefun` uses a high-order Taylor series
+    method. For reasonably well-behaved problems, the solution will
+    be fully accurate to within the working precision. Note that
+    *F* must be possible to evaluate to very high precision
+    for the generation of Taylor series to work.
+
+    To get a faster but less accurate solution, you can set a large
+    value for *tol* (which defaults roughly to *eps*). If you just
+    want to plot the solution or perform a basic simulation,
+    *tol = 0.01* is likely sufficient.
+
+    The *degree* argument controls the degree of the solver (with
+    *method='taylor'*, this is the degree of the Taylor series
+    expansion). A higher degree means that a longer step can be taken
+    before a new local solution must be generated from *F*,
+    meaning that fewer steps are required to get from `x_0` to a given
+    `x_1`. On the other hand, a higher degree also means that each
+    local solution becomes more expensive (i.e., more evaluations of
+    *F* are required per step, and at higher precision).
+
+    The optimal setting therefore involves a tradeoff. Generally,
+    decreasing the *degree* for Taylor series is likely to give faster
+    solution at low precision, while increasing is likely to be better
+    at higher precision.
+
+    The function
+    object returned by :func:`~mpmath.odefun` caches the solutions at all step
+    points and uses polynomial interpolation between step points.
+    Therefore, once `y(x_1)` has been evaluated for some `x_1`,
+    `y(x)` can be evaluated very quickly for any `x_0 \le x \le x_1`.
+    and continuing the evaluation up to `x_2 > x_1` is also fast.
+
+    **Examples of first-order ODEs**
+
+    We will solve the standard test problem `y'(x) = y(x), y(0) = 1`
+    which has explicit solution `y(x) = \exp(x)`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> f = odefun(lambda x, y: y, 0, 1)
+        >>> for x in [0, 1, 2.5]:
+        ...     print((f(x), exp(x)))
+        ...
+        (1.0, 1.0)
+        (2.71828182845905, 2.71828182845905)
+        (12.1824939607035, 12.1824939607035)
+
+    The solution with high precision::
+
+        >>> mp.dps = 50
+        >>> f = odefun(lambda x, y: y, 0, 1)
+        >>> f(1)
+        2.7182818284590452353602874713526624977572470937
+        >>> exp(1)
+        2.7182818284590452353602874713526624977572470937
+
+    Using the more general vectorized form, the test problem
+    can be input as (note that *f* returns a 1-element vector)::
+
+        >>> mp.dps = 15
+        >>> f = odefun(lambda x, y: [y[0]], 0, [1])
+        >>> f(1)
+        [2.71828182845905]
+
+    :func:`~mpmath.odefun` can solve nonlinear ODEs, which are generally
+    impossible (and at best difficult) to solve analytically. As
+    an example of a nonlinear ODE, we will solve `y'(x) = x \sin(y(x))`
+    for `y(0) = \pi/2`. An exact solution happens to be known
+    for this problem, and is given by
+    `y(x) = 2 \tan^{-1}\left(\exp\left(x^2/2\right)\right)`::
+
+        >>> f = odefun(lambda x, y: x*sin(y), 0, pi/2)
+        >>> for x in [2, 5, 10]:
+        ...     print((f(x), 2*atan(exp(mpf(x)**2/2))))
+        ...
+        (2.87255666284091, 2.87255666284091)
+        (3.14158520028345, 3.14158520028345)
+        (3.14159265358979, 3.14159265358979)
+
+    If `F` is independent of `y`, an ODE can be solved using direct
+    integration. We can therefore obtain a reference solution with
+    :func:`~mpmath.quad`::
+
+        >>> f = lambda x: (1+x**2)/(1+x**3)
+        >>> g = odefun(lambda x, y: f(x), pi, 0)
+        >>> g(2*pi)
+        0.72128263801696
+        >>> quad(f, [pi, 2*pi])
+        0.72128263801696
+
+    **Examples of second-order ODEs**
+
+    We will solve the harmonic oscillator equation `y''(x) + y(x) = 0`.
+    To do this, we introduce the helper functions `y_0 = y, y_1 = y_0'`
+    whereby the original equation can be written as `y_1' + y_0' = 0`. Put
+    together, we get the first-order, two-dimensional vector ODE
+
+    .. math ::
+
+        \begin{cases}
+        y_0' = y_1 \\
+        y_1' = -y_0
+        \end{cases}
+
+    To get a well-defined IVP, we need two initial values. With
+    `y(0) = y_0(0) = 1` and `-y'(0) = y_1(0) = 0`, the problem will of
+    course be solved by `y(x) = y_0(x) = \cos(x)` and
+    `-y'(x) = y_1(x) = \sin(x)`. We check this::
+
+        >>> f = odefun(lambda x, y: [-y[1], y[0]], 0, [1, 0])
+        >>> for x in [0, 1, 2.5, 10]:
+        ...     nprint(f(x), 15)
+        ...     nprint([cos(x), sin(x)], 15)
+        ...     print("---")
+        ...
+        [1.0, 0.0]
+        [1.0, 0.0]
+        ---
+        [0.54030230586814, 0.841470984807897]
+        [0.54030230586814, 0.841470984807897]
+        ---
+        [-0.801143615546934, 0.598472144103957]
+        [-0.801143615546934, 0.598472144103957]
+        ---
+        [-0.839071529076452, -0.54402111088937]
+        [-0.839071529076452, -0.54402111088937]
+        ---
+
+    Note that we get both the sine and the cosine solutions
+    simultaneously.
+
+    **TODO**
+
+    * Better automatic choice of degree and step size
+    * Make determination of Taylor series convergence radius
+      more robust
+    * Allow solution for `x < x_0`
+    * Allow solution for complex `x`
+    * Test for difficult (ill-conditioned) problems
+    * Implement Runge-Kutta and other algorithms
+
+    """
+    if tol:
+        tol_prec = int(-ctx.log(tol, 2))+10
+    else:
+        tol_prec = ctx.prec+10
+    degree = degree or (3 + int(3*ctx.dps/2.))
+    workprec = ctx.prec + 40
+    try:
+        len(y0)
+        return_vector = True
+    except TypeError:
+        F_ = F
+        F = lambda x, y: [F_(x, y[0])]
+        y0 = [y0]
+        return_vector = False
+    ser, xb = ode_taylor(ctx, F, x0, y0, tol_prec, degree)
+    series_boundaries = [x0, xb]
+    series_data = [(ser, x0, xb)]
+    # We will be working with vectors of Taylor series
+    def mpolyval(ser, a):
+        return [ctx.polyval(s[::-1], a) for s in ser]
+    # Find nearest expansion point; compute if necessary
+    def get_series(x):
+        if x < x0:
+            raise ValueError
+        n = bisect(series_boundaries, x)
+        if n < len(series_boundaries):
+            return series_data[n-1]
+        while 1:
+            ser, xa, xb = series_data[-1]
+            if verbose:
+                print("Computing Taylor series for [%f, %f]" % (xa, xb))
+            y = mpolyval(ser, xb-xa)
+            xa = xb
+            ser, xb = ode_taylor(ctx, F, xb, y, tol_prec, degree)
+            series_boundaries.append(xb)
+            series_data.append((ser, xa, xb))
+            if x <= xb:
+                return series_data[-1]
+    # Evaluation function
+    def interpolant(x):
+        x = ctx.convert(x)
+        orig = ctx.prec
+        try:
+            ctx.prec = workprec
+            ser, xa, xb = get_series(x)
+            y = mpolyval(ser, x-xa)
+        finally:
+            ctx.prec = orig
+        if return_vector:
+            return [+yk for yk in y]
+        else:
+            return +y[0]
+    return interpolant
+
+ODEMethods.odefun = odefun
+
+if __name__ == "__main__":
+    import doctest
+    doctest.testmod()
diff --git a/lib/python3.10/site-packages/mpmath/calculus/optimization.py b/lib/python3.10/site-packages/mpmath/calculus/optimization.py
new file mode 100644
index 0000000000000000000000000000000000000000..69724f78336ee24856366db48917a47108b1b416
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/calculus/optimization.py
@@ -0,0 +1,1102 @@
+from __future__ import print_function
+
+from copy import copy
+
+from ..libmp.backend import xrange
+
+class OptimizationMethods(object):
+    def __init__(ctx):
+        pass
+
+##############
+# 1D-SOLVERS #
+##############
+
+class Newton:
+    """
+    1d-solver generating pairs of approximative root and error.
+
+    Needs starting points x0 close to the root.
+
+    Pro:
+
+    * converges fast
+    * sometimes more robust than secant with bad second starting point
+
+    Contra:
+
+    * converges slowly for multiple roots
+    * needs first derivative
+    * 2 function evaluations per iteration
+    """
+    maxsteps = 20
+
+    def __init__(self, ctx, f, x0, **kwargs):
+        self.ctx = ctx
+        if len(x0) == 1:
+            self.x0 = x0[0]
+        else:
+            raise ValueError('expected 1 starting point, got %i' % len(x0))
+        self.f = f
+        if not 'df' in kwargs:
+            def df(x):
+                return self.ctx.diff(f, x)
+        else:
+            df = kwargs['df']
+        self.df = df
+
+    def __iter__(self):
+        f = self.f
+        df = self.df
+        x0 = self.x0
+        while True:
+            x1 = x0 - f(x0) / df(x0)
+            error = abs(x1 - x0)
+            x0 = x1
+            yield (x1, error)
+
+class Secant:
+    """
+    1d-solver generating pairs of approximative root and error.
+
+    Needs starting points x0 and x1 close to the root.
+    x1 defaults to x0 + 0.25.
+
+    Pro:
+
+    * converges fast
+
+    Contra:
+
+    * converges slowly for multiple roots
+    """
+    maxsteps = 30
+
+    def __init__(self, ctx, f, x0, **kwargs):
+        self.ctx = ctx
+        if len(x0) == 1:
+            self.x0 = x0[0]
+            self.x1 = self.x0 + 0.25
+        elif len(x0) == 2:
+            self.x0 = x0[0]
+            self.x1 = x0[1]
+        else:
+            raise ValueError('expected 1 or 2 starting points, got %i' % len(x0))
+        self.f = f
+
+    def __iter__(self):
+        f = self.f
+        x0 = self.x0
+        x1 = self.x1
+        f0 = f(x0)
+        while True:
+            f1 = f(x1)
+            l = x1 - x0
+            if not l:
+                break
+            s = (f1 - f0) / l
+            if not s:
+                break
+            x0, x1 = x1, x1 - f1/s
+            f0 = f1
+            yield x1, abs(l)
+
+class MNewton:
+    """
+    1d-solver generating pairs of approximative root and error.
+
+    Needs starting point x0 close to the root.
+    Uses modified Newton's method that converges fast regardless of the
+    multiplicity of the root.
+
+    Pro:
+
+    * converges fast for multiple roots
+
+    Contra:
+
+    * needs first and second derivative of f
+    * 3 function evaluations per iteration
+    """
+    maxsteps = 20
+
+    def __init__(self, ctx, f, x0, **kwargs):
+        self.ctx = ctx
+        if not len(x0) == 1:
+            raise ValueError('expected 1 starting point, got %i' % len(x0))
+        self.x0 = x0[0]
+        self.f = f
+        if not 'df' in kwargs:
+            def df(x):
+                return self.ctx.diff(f, x)
+        else:
+            df = kwargs['df']
+        self.df = df
+        if not 'd2f' in kwargs:
+            def d2f(x):
+                return self.ctx.diff(df, x)
+        else:
+            d2f = kwargs['df']
+        self.d2f = d2f
+
+    def __iter__(self):
+        x = self.x0
+        f = self.f
+        df = self.df
+        d2f = self.d2f
+        while True:
+            prevx = x
+            fx = f(x)
+            if fx == 0:
+                break
+            dfx = df(x)
+            d2fx = d2f(x)
+            # x = x - F(x)/F'(x) with F(x) = f(x)/f'(x)
+            x -= fx / (dfx - fx * d2fx / dfx)
+            error = abs(x - prevx)
+            yield x, error
+
+class Halley:
+    """
+    1d-solver generating pairs of approximative root and error.
+
+    Needs a starting point x0 close to the root.
+    Uses Halley's method with cubic convergence rate.
+
+    Pro:
+
+    * converges even faster the Newton's method
+    * useful when computing with *many* digits
+
+    Contra:
+
+    * needs first and second derivative of f
+    * 3 function evaluations per iteration
+    * converges slowly for multiple roots
+    """
+
+    maxsteps = 20
+
+    def __init__(self, ctx, f, x0, **kwargs):
+        self.ctx = ctx
+        if not len(x0) == 1:
+            raise ValueError('expected 1 starting point, got %i' % len(x0))
+        self.x0 = x0[0]
+        self.f = f
+        if not 'df' in kwargs:
+            def df(x):
+                return self.ctx.diff(f, x)
+        else:
+            df = kwargs['df']
+        self.df = df
+        if not 'd2f' in kwargs:
+            def d2f(x):
+                return self.ctx.diff(df, x)
+        else:
+            d2f = kwargs['df']
+        self.d2f = d2f
+
+    def __iter__(self):
+        x = self.x0
+        f = self.f
+        df = self.df
+        d2f = self.d2f
+        while True:
+            prevx = x
+            fx = f(x)
+            dfx = df(x)
+            d2fx = d2f(x)
+            x -=  2*fx*dfx / (2*dfx**2 - fx*d2fx)
+            error = abs(x - prevx)
+            yield x, error
+
+class Muller:
+    """
+    1d-solver generating pairs of approximative root and error.
+
+    Needs starting points x0, x1 and x2 close to the root.
+    x1 defaults to x0 + 0.25; x2 to x1 + 0.25.
+    Uses Muller's method that converges towards complex roots.
+
+    Pro:
+
+    * converges fast (somewhat faster than secant)
+    * can find complex roots
+
+    Contra:
+
+    * converges slowly for multiple roots
+    * may have complex values for real starting points and real roots
+
+    http://en.wikipedia.org/wiki/Muller's_method
+    """
+    maxsteps = 30
+
+    def __init__(self, ctx, f, x0, **kwargs):
+        self.ctx = ctx
+        if len(x0) == 1:
+            self.x0 = x0[0]
+            self.x1 = self.x0 + 0.25
+            self.x2 = self.x1 + 0.25
+        elif len(x0) == 2:
+            self.x0 = x0[0]
+            self.x1 = x0[1]
+            self.x2 = self.x1 + 0.25
+        elif len(x0) == 3:
+            self.x0 = x0[0]
+            self.x1 = x0[1]
+            self.x2 = x0[2]
+        else:
+            raise ValueError('expected 1, 2 or 3 starting points, got %i'
+                             % len(x0))
+        self.f = f
+        self.verbose = kwargs['verbose']
+
+    def __iter__(self):
+        f = self.f
+        x0 = self.x0
+        x1 = self.x1
+        x2 = self.x2
+        fx0 = f(x0)
+        fx1 = f(x1)
+        fx2 = f(x2)
+        while True:
+            # TODO: maybe refactoring with function for divided differences
+            # calculate divided differences
+            fx2x1 = (fx1 - fx2) / (x1 - x2)
+            fx2x0 = (fx0 - fx2) / (x0 - x2)
+            fx1x0 = (fx0 - fx1) / (x0 - x1)
+            w = fx2x1 + fx2x0 - fx1x0
+            fx2x1x0 = (fx1x0 - fx2x1) / (x0 - x2)
+            if w == 0 and fx2x1x0 == 0:
+                if self.verbose:
+                    print('canceled with')
+                    print('x0 =', x0, ', x1 =', x1, 'and x2 =', x2)
+                break
+            x0 = x1
+            fx0 = fx1
+            x1 = x2
+            fx1 = fx2
+            # denominator should be as large as possible => choose sign
+            r = self.ctx.sqrt(w**2 - 4*fx2*fx2x1x0)
+            if abs(w - r) > abs(w + r):
+                r = -r
+            x2 -= 2*fx2 / (w + r)
+            fx2 = f(x2)
+            error = abs(x2 - x1)
+            yield x2, error
+
+# TODO: consider raising a ValueError when there's no sign change in a and b
+class Bisection:
+    """
+    1d-solver generating pairs of approximative root and error.
+
+    Uses bisection method to find a root of f in [a, b].
+    Might fail for multiple roots (needs sign change).
+
+    Pro:
+
+    * robust and reliable
+
+    Contra:
+
+    * converges slowly
+    * needs sign change
+    """
+    maxsteps = 100
+
+    def __init__(self, ctx, f, x0, **kwargs):
+        self.ctx = ctx
+        if len(x0) != 2:
+            raise ValueError('expected interval of 2 points, got %i' % len(x0))
+        self.f = f
+        self.a = x0[0]
+        self.b = x0[1]
+
+    def __iter__(self):
+        f = self.f
+        a = self.a
+        b = self.b
+        l = b - a
+        fb = f(b)
+        while True:
+            m = self.ctx.ldexp(a + b, -1)
+            fm = f(m)
+            sign = fm * fb
+            if sign < 0:
+                a = m
+            elif sign > 0:
+                b = m
+                fb = fm
+            else:
+                yield m, self.ctx.zero
+            l /= 2
+            yield (a + b)/2, abs(l)
+
+def _getm(method):
+    """
+    Return a function to calculate m for Illinois-like methods.
+    """
+    if method == 'illinois':
+        def getm(fz, fb):
+            return 0.5
+    elif method == 'pegasus':
+        def getm(fz, fb):
+            return fb/(fb + fz)
+    elif method == 'anderson':
+        def getm(fz, fb):
+            m = 1 - fz/fb
+            if m > 0:
+                return m
+            else:
+                return 0.5
+    else:
+        raise ValueError("method '%s' not recognized" % method)
+    return getm
+
+class Illinois:
+    """
+    1d-solver generating pairs of approximative root and error.
+
+    Uses Illinois method or similar to find a root of f in [a, b].
+    Might fail for multiple roots (needs sign change).
+    Combines bisect with secant (improved regula falsi).
+
+    The only difference between the methods is the scaling factor m, which is
+    used to ensure convergence (you can choose one using the 'method' keyword):
+
+    Illinois method ('illinois'):
+        m = 0.5
+
+    Pegasus method ('pegasus'):
+        m = fb/(fb + fz)
+
+    Anderson-Bjoerk method ('anderson'):
+        m = 1 - fz/fb if positive else 0.5
+
+    Pro:
+
+    * converges very fast
+
+    Contra:
+
+    * has problems with multiple roots
+    * needs sign change
+    """
+    maxsteps = 30
+
+    def __init__(self, ctx, f, x0, **kwargs):
+        self.ctx = ctx
+        if len(x0) != 2:
+            raise ValueError('expected interval of 2 points, got %i' % len(x0))
+        self.a = x0[0]
+        self.b = x0[1]
+        self.f = f
+        self.tol = kwargs['tol']
+        self.verbose = kwargs['verbose']
+        self.method = kwargs.get('method', 'illinois')
+        self.getm = _getm(self.method)
+        if self.verbose:
+            print('using %s method' % self.method)
+
+    def __iter__(self):
+        method = self.method
+        f = self.f
+        a = self.a
+        b = self.b
+        fa = f(a)
+        fb = f(b)
+        m = None
+        while True:
+            l = b - a
+            if l == 0:
+                break
+            s = (fb - fa) / l
+            z = a - fa/s
+            fz = f(z)
+            if abs(fz) < self.tol:
+                # TODO: better condition (when f is very flat)
+                if self.verbose:
+                    print('canceled with z =', z)
+                yield z, l
+                break
+            if fz * fb < 0: # root in [z, b]
+                a = b
+                fa = fb
+                b = z
+                fb = fz
+            else: # root in [a, z]
+                m = self.getm(fz, fb)
+                b = z
+                fb = fz
+                fa = m*fa # scale down to ensure convergence
+            if self.verbose and m and not method == 'illinois':
+                print('m:', m)
+            yield (a + b)/2, abs(l)
+
+def Pegasus(*args, **kwargs):
+    """
+    1d-solver generating pairs of approximative root and error.
+
+    Uses Pegasus method to find a root of f in [a, b].
+    Wrapper for illinois to use method='pegasus'.
+    """
+    kwargs['method'] = 'pegasus'
+    return Illinois(*args, **kwargs)
+
+def Anderson(*args, **kwargs):
+    """
+    1d-solver generating pairs of approximative root and error.
+
+    Uses Anderson-Bjoerk method to find a root of f in [a, b].
+    Wrapper for illinois to use method='pegasus'.
+    """
+    kwargs['method'] = 'anderson'
+    return Illinois(*args, **kwargs)
+
+# TODO: check whether it's possible to combine it with Illinois stuff
+class Ridder:
+    """
+    1d-solver generating pairs of approximative root and error.
+
+    Ridders' method to find a root of f in [a, b].
+    Is told to perform as well as Brent's method while being simpler.
+
+    Pro:
+
+    * very fast
+    * simpler than Brent's method
+
+    Contra:
+
+    * two function evaluations per step
+    * has problems with multiple roots
+    * needs sign change
+
+    http://en.wikipedia.org/wiki/Ridders'_method
+    """
+    maxsteps = 30
+
+    def __init__(self, ctx, f, x0, **kwargs):
+        self.ctx = ctx
+        self.f = f
+        if len(x0) != 2:
+            raise ValueError('expected interval of 2 points, got %i' % len(x0))
+        self.x1 = x0[0]
+        self.x2 = x0[1]
+        self.verbose = kwargs['verbose']
+        self.tol = kwargs['tol']
+
+    def __iter__(self):
+        ctx = self.ctx
+        f = self.f
+        x1 = self.x1
+        fx1 = f(x1)
+        x2 = self.x2
+        fx2 = f(x2)
+        while True:
+            x3 = 0.5*(x1 + x2)
+            fx3 = f(x3)
+            x4 = x3 + (x3 - x1) * ctx.sign(fx1 - fx2) * fx3 / ctx.sqrt(fx3**2 - fx1*fx2)
+            fx4 = f(x4)
+            if abs(fx4) < self.tol:
+                # TODO: better condition (when f is very flat)
+                if self.verbose:
+                    print('canceled with f(x4) =', fx4)
+                yield x4, abs(x1 - x2)
+                break
+            if fx4 * fx2 < 0: # root in [x4, x2]
+                x1 = x4
+                fx1 = fx4
+            else: # root in [x1, x4]
+                x2 = x4
+                fx2 = fx4
+            error = abs(x1 - x2)
+            yield (x1 + x2)/2, error
+
+class ANewton:
+    """
+    EXPERIMENTAL 1d-solver generating pairs of approximative root and error.
+
+    Uses Newton's method modified to use Steffensens method when convergence is
+    slow. (I.e. for multiple roots.)
+    """
+    maxsteps = 20
+
+    def __init__(self, ctx, f, x0, **kwargs):
+        self.ctx = ctx
+        if not len(x0) == 1:
+            raise ValueError('expected 1 starting point, got %i' % len(x0))
+        self.x0 = x0[0]
+        self.f = f
+        if not 'df' in kwargs:
+            def df(x):
+                return self.ctx.diff(f, x)
+        else:
+            df = kwargs['df']
+        self.df = df
+        def phi(x):
+            return x - f(x) / df(x)
+        self.phi = phi
+        self.verbose = kwargs['verbose']
+
+    def __iter__(self):
+        x0 = self.x0
+        f = self.f
+        df = self.df
+        phi = self.phi
+        error = 0
+        counter = 0
+        while True:
+            prevx = x0
+            try:
+                x0 = phi(x0)
+            except ZeroDivisionError:
+                if self.verbose:
+                    print('ZeroDivisionError: canceled with x =', x0)
+                break
+            preverror = error
+            error = abs(prevx - x0)
+            # TODO: decide not to use convergence acceleration
+            if error and abs(error - preverror) / error < 1:
+                if self.verbose:
+                    print('converging slowly')
+                counter += 1
+            if counter >= 3:
+                # accelerate convergence
+                phi = steffensen(phi)
+                counter = 0
+                if self.verbose:
+                    print('accelerating convergence')
+            yield x0, error
+
+# TODO: add Brent
+
+############################
+# MULTIDIMENSIONAL SOLVERS #
+############################
+
+def jacobian(ctx, f, x):
+    """
+    Calculate the Jacobian matrix of a function at the point x0.
+
+    This is the first derivative of a vectorial function:
+
+        f : R^m -> R^n with m >= n
+    """
+    x = ctx.matrix(x)
+    h = ctx.sqrt(ctx.eps)
+    fx = ctx.matrix(f(*x))
+    m = len(fx)
+    n = len(x)
+    J = ctx.matrix(m, n)
+    for j in xrange(n):
+        xj = x.copy()
+        xj[j] += h
+        Jj = (ctx.matrix(f(*xj)) - fx) / h
+        for i in xrange(m):
+            J[i,j] = Jj[i]
+    return J
+
+# TODO: test with user-specified jacobian matrix
+class MDNewton:
+    """
+    Find the root of a vector function numerically using Newton's method.
+
+    f is a vector function representing a nonlinear equation system.
+
+    x0 is the starting point close to the root.
+
+    J is a function returning the Jacobian matrix for a point.
+
+    Supports overdetermined systems.
+
+    Use the 'norm' keyword to specify which norm to use. Defaults to max-norm.
+    The function to calculate the Jacobian matrix can be given using the
+    keyword 'J'. Otherwise it will be calculated numerically.
+
+    Please note that this method converges only locally. Especially for high-
+    dimensional systems it is not trivial to find a good starting point being
+    close enough to the root.
+
+    It is recommended to use a faster, low-precision solver from SciPy [1] or
+    OpenOpt [2] to get an initial guess. Afterwards you can use this method for
+    root-polishing to any precision.
+
+    [1] http://scipy.org
+
+    [2] http://openopt.org/Welcome
+    """
+    maxsteps = 10
+
+    def __init__(self, ctx, f, x0, **kwargs):
+        self.ctx = ctx
+        self.f = f
+        if isinstance(x0, (tuple, list)):
+            x0 = ctx.matrix(x0)
+        assert x0.cols == 1, 'need a vector'
+        self.x0 = x0
+        if 'J' in kwargs:
+            self.J = kwargs['J']
+        else:
+            def J(*x):
+                return ctx.jacobian(f, x)
+            self.J = J
+        self.norm = kwargs['norm']
+        self.verbose = kwargs['verbose']
+
+    def __iter__(self):
+        f = self.f
+        x0 = self.x0
+        norm = self.norm
+        J = self.J
+        fx = self.ctx.matrix(f(*x0))
+        fxnorm = norm(fx)
+        cancel = False
+        while not cancel:
+            # get direction of descent
+            fxn = -fx
+            Jx = J(*x0)
+            s = self.ctx.lu_solve(Jx, fxn)
+            if self.verbose:
+                print('Jx:')
+                print(Jx)
+                print('s:', s)
+            # damping step size TODO: better strategy (hard task)
+            l = self.ctx.one
+            x1 = x0 + s
+            while True:
+                if x1 == x0:
+                    if self.verbose:
+                        print("canceled, won't get more excact")
+                    cancel = True
+                    break
+                fx = self.ctx.matrix(f(*x1))
+                newnorm = norm(fx)
+                if newnorm < fxnorm:
+                    # new x accepted
+                    fxnorm = newnorm
+                    x0 = x1
+                    break
+                l /= 2
+                x1 = x0 + l*s
+            yield (x0, fxnorm)
+
+#############
+# UTILITIES #
+#############
+
+str2solver = {'newton':Newton, 'secant':Secant, 'mnewton':MNewton,
+              'halley':Halley, 'muller':Muller, 'bisect':Bisection,
+              'illinois':Illinois, 'pegasus':Pegasus, 'anderson':Anderson,
+              'ridder':Ridder, 'anewton':ANewton, 'mdnewton':MDNewton}
+
+def findroot(ctx, f, x0, solver='secant', tol=None, verbose=False, verify=True, **kwargs):
+    r"""
+    Find an approximate solution to `f(x) = 0`, using *x0* as starting point or
+    interval for *x*.
+
+    Multidimensional overdetermined systems are supported.
+    You can specify them using a function or a list of functions.
+
+    Mathematically speaking, this function returns `x` such that
+    `|f(x)|^2 \leq \mathrm{tol}` is true within the current working precision.
+    If the computed value does not meet this criterion, an exception is raised.
+    This exception can be disabled with *verify=False*.
+
+    For interval arithmetic (``iv.findroot()``), please note that
+    the returned interval ``x`` is not guaranteed to contain `f(x)=0`!
+    It is only some `x` for which `|f(x)|^2 \leq \mathrm{tol}` certainly holds
+    regardless of numerical error. This may be improved in the future.
+
+    **Arguments**
+
+    *f*
+        one dimensional function
+    *x0*
+        starting point, several starting points or interval (depends on solver)
+    *tol*
+        the returned solution has an error smaller than this
+    *verbose*
+        print additional information for each iteration if true
+    *verify*
+        verify the solution and raise a ValueError if `|f(x)|^2 > \mathrm{tol}`
+    *solver*
+        a generator for *f* and *x0* returning approximative solution and error
+    *maxsteps*
+        after how many steps the solver will cancel
+    *df*
+        first derivative of *f* (used by some solvers)
+    *d2f*
+        second derivative of *f* (used by some solvers)
+    *multidimensional*
+        force multidimensional solving
+    *J*
+        Jacobian matrix of *f* (used by multidimensional solvers)
+    *norm*
+        used vector norm (used by multidimensional solvers)
+
+    solver has to be callable with ``(f, x0, **kwargs)`` and return an generator
+    yielding pairs of approximative solution and estimated error (which is
+    expected to be positive).
+    You can use the following string aliases:
+    'secant', 'mnewton', 'halley', 'muller', 'illinois', 'pegasus', 'anderson',
+    'ridder', 'anewton', 'bisect'
+
+    See mpmath.calculus.optimization for their documentation.
+
+    **Examples**
+
+    The function :func:`~mpmath.findroot` locates a root of a given function using the
+    secant method by default. A simple example use of the secant method is to
+    compute `\pi` as the root of `\sin x` closest to `x_0 = 3`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 30; mp.pretty = True
+        >>> findroot(sin, 3)
+        3.14159265358979323846264338328
+
+    The secant method can be used to find complex roots of analytic functions,
+    although it must in that case generally be given a nonreal starting value
+    (or else it will never leave the real line)::
+
+        >>> mp.dps = 15
+        >>> findroot(lambda x: x**3 + 2*x + 1, j)
+        (0.226698825758202 + 1.46771150871022j)
+
+    A nice application is to compute nontrivial roots of the Riemann zeta
+    function with many digits (good initial values are needed for convergence)::
+
+        >>> mp.dps = 30
+        >>> findroot(zeta, 0.5+14j)
+        (0.5 + 14.1347251417346937904572519836j)
+
+    The secant method can also be used as an optimization algorithm, by passing
+    it a derivative of a function. The following example locates the positive
+    minimum of the gamma function::
+
+        >>> mp.dps = 20
+        >>> findroot(lambda x: diff(gamma, x), 1)
+        1.4616321449683623413
+
+    Finally, a useful application is to compute inverse functions, such as the
+    Lambert W function which is the inverse of `w e^w`, given the first
+    term of the solution's asymptotic expansion as the initial value. In basic
+    cases, this gives identical results to mpmath's built-in ``lambertw``
+    function::
+
+        >>> def lambert(x):
+        ...     return findroot(lambda w: w*exp(w) - x, log(1+x))
+        ...
+        >>> mp.dps = 15
+        >>> lambert(1); lambertw(1)
+        0.567143290409784
+        0.567143290409784
+        >>> lambert(1000); lambert(1000)
+        5.2496028524016
+        5.2496028524016
+
+    Multidimensional functions are also supported::
+
+        >>> f = [lambda x1, x2: x1**2 + x2,
+        ...      lambda x1, x2: 5*x1**2 - 3*x1 + 2*x2 - 3]
+        >>> findroot(f, (0, 0))
+        [-0.618033988749895]
+        [-0.381966011250105]
+        >>> findroot(f, (10, 10))
+        [ 1.61803398874989]
+        [-2.61803398874989]
+
+    You can verify this by solving the system manually.
+
+    Please note that the following (more general) syntax also works::
+
+        >>> def f(x1, x2):
+        ...     return x1**2 + x2, 5*x1**2 - 3*x1 + 2*x2 - 3
+        ...
+        >>> findroot(f, (0, 0))
+        [-0.618033988749895]
+        [-0.381966011250105]
+
+
+    **Multiple roots**
+
+    For multiple roots all methods of the Newtonian family (including secant)
+    converge slowly. Consider this example::
+
+        >>> f = lambda x: (x - 1)**99
+        >>> findroot(f, 0.9, verify=False)
+        0.918073542444929
+
+    Even for a very close starting point the secant method converges very
+    slowly. Use ``verbose=True`` to illustrate this.
+
+    It is possible to modify Newton's method to make it converge regardless of
+    the root's multiplicity::
+
+        >>> findroot(f, -10, solver='mnewton')
+        1.0
+
+    This variant uses the first and second derivative of the function, which is
+    not very efficient.
+
+    Alternatively you can use an experimental Newtonian solver that keeps track
+    of the speed of convergence and accelerates it using Steffensen's method if
+    necessary::
+
+        >>> findroot(f, -10, solver='anewton', verbose=True)
+        x:     -9.88888888888888888889
+        error: 0.111111111111111111111
+        converging slowly
+        x:     -9.77890011223344556678
+        error: 0.10998877665544332211
+        converging slowly
+        x:     -9.67002233332199662166
+        error: 0.108877778911448945119
+        converging slowly
+        accelerating convergence
+        x:     -9.5622443299551077669
+        error: 0.107778003366888854764
+        converging slowly
+        x:     0.99999999999999999214
+        error: 10.562244329955107759
+        x:     1.0
+        error: 7.8598304758094664213e-18
+        ZeroDivisionError: canceled with x = 1.0
+        1.0
+
+    **Complex roots**
+
+    For complex roots it's recommended to use Muller's method as it converges
+    even for real starting points very fast::
+
+        >>> findroot(lambda x: x**4 + x + 1, (0, 1, 2), solver='muller')
+        (0.727136084491197 + 0.934099289460529j)
+
+
+    **Intersection methods**
+
+    When you need to find a root in a known interval, it's highly recommended to
+    use an intersection-based solver like ``'anderson'`` or ``'ridder'``.
+    Usually they converge faster and more reliable. They have however problems
+    with multiple roots and usually need a sign change to find a root::
+
+        >>> findroot(lambda x: x**3, (-1, 1), solver='anderson')
+        0.0
+
+    Be careful with symmetric functions::
+
+        >>> findroot(lambda x: x**2, (-1, 1), solver='anderson') #doctest:+ELLIPSIS
+        Traceback (most recent call last):
+          ...
+        ZeroDivisionError
+
+    It fails even for better starting points, because there is no sign change::
+
+        >>> findroot(lambda x: x**2, (-1, .5), solver='anderson')
+        Traceback (most recent call last):
+          ...
+        ValueError: Could not find root within given tolerance. (1.0 > 2.16840434497100886801e-19)
+        Try another starting point or tweak arguments.
+
+    """
+    prec = ctx.prec
+    try:
+        ctx.prec += 20
+
+        # initialize arguments
+        if tol is None:
+            tol = ctx.eps * 2**10
+
+        kwargs['verbose'] = kwargs.get('verbose', verbose)
+
+        if 'd1f' in kwargs:
+            kwargs['df'] = kwargs['d1f']
+
+        kwargs['tol'] = tol
+        if isinstance(x0, (list, tuple)):
+            x0 = [ctx.convert(x) for x in x0]
+        else:
+            x0 = [ctx.convert(x0)]
+
+        if isinstance(solver, str):
+            try:
+                solver = str2solver[solver]
+            except KeyError:
+                raise ValueError('could not recognize solver')
+
+        # accept list of functions
+        if isinstance(f, (list, tuple)):
+            f2 = copy(f)
+            def tmp(*args):
+                return [fn(*args) for fn in f2]
+            f = tmp
+
+        # detect multidimensional functions
+        try:
+            fx = f(*x0)
+            multidimensional = isinstance(fx, (list, tuple, ctx.matrix))
+        except TypeError:
+            fx = f(x0[0])
+            multidimensional = False
+        if 'multidimensional' in kwargs:
+            multidimensional = kwargs['multidimensional']
+        if multidimensional:
+            # only one multidimensional solver available at the moment
+            solver = MDNewton
+            if not 'norm' in kwargs:
+                norm = lambda x: ctx.norm(x, 'inf')
+                kwargs['norm'] = norm
+            else:
+                norm = kwargs['norm']
+        else:
+            norm = abs
+
+        # happily return starting point if it's a root
+        if norm(fx) == 0:
+            if multidimensional:
+                return ctx.matrix(x0)
+            else:
+                return x0[0]
+
+        # use solver
+        iterations = solver(ctx, f, x0, **kwargs)
+        if 'maxsteps' in kwargs:
+            maxsteps = kwargs['maxsteps']
+        else:
+            maxsteps = iterations.maxsteps
+        i = 0
+        for x, error in iterations:
+            if verbose:
+                print('x:    ', x)
+                print('error:', error)
+            i += 1
+            if error < tol * max(1, norm(x)) or i >= maxsteps:
+                break
+        else:
+            if not i:
+                raise ValueError('Could not find root using the given solver.\n'
+                                 'Try another starting point or tweak arguments.')
+        if not isinstance(x, (list, tuple, ctx.matrix)):
+            xl = [x]
+        else:
+            xl = x
+        if verify and norm(f(*xl))**2 > tol: # TODO: better condition?
+            raise ValueError('Could not find root within given tolerance. '
+                             '(%s > %s)\n'
+                             'Try another starting point or tweak arguments.'
+                             % (norm(f(*xl))**2, tol))
+        return x
+    finally:
+        ctx.prec = prec
+
+
+def multiplicity(ctx, f, root, tol=None, maxsteps=10, **kwargs):
+    """
+    Return the multiplicity of a given root of f.
+
+    Internally, numerical derivatives are used. This might be inefficient for
+    higher order derviatives. Due to this, ``multiplicity`` cancels after
+    evaluating 10 derivatives by default. You can be specify the n-th derivative
+    using the dnf keyword.
+
+    >>> from mpmath import *
+    >>> multiplicity(lambda x: sin(x) - 1, pi/2)
+    2
+
+    """
+    if tol is None:
+        tol = ctx.eps ** 0.8
+    kwargs['d0f'] = f
+    for i in xrange(maxsteps):
+        dfstr = 'd' + str(i) + 'f'
+        if dfstr in kwargs:
+            df = kwargs[dfstr]
+        else:
+            df = lambda x: ctx.diff(f, x, i)
+        if not abs(df(root)) < tol:
+            break
+    return i
+
+def steffensen(f):
+    """
+    linear convergent function -> quadratic convergent function
+
+    Steffensen's method for quadratic convergence of a linear converging
+    sequence.
+    Don not use it for higher rates of convergence.
+    It may even work for divergent sequences.
+
+    Definition:
+    F(x) = (x*f(f(x)) - f(x)**2) / (f(f(x)) - 2*f(x) + x)
+
+    Example
+    .......
+
+    You can use Steffensen's method to accelerate a fixpoint iteration of linear
+    (or less) convergence.
+
+    x* is a fixpoint of the iteration x_{k+1} = phi(x_k) if x* = phi(x*). For
+    phi(x) = x**2 there are two fixpoints: 0 and 1.
+
+    Let's try Steffensen's method:
+
+    >>> f = lambda x: x**2
+    >>> from mpmath.calculus.optimization import steffensen
+    >>> F = steffensen(f)
+    >>> for x in [0.5, 0.9, 2.0]:
+    ...     fx = Fx = x
+    ...     for i in xrange(9):
+    ...         try:
+    ...             fx = f(fx)
+    ...         except OverflowError:
+    ...             pass
+    ...         try:
+    ...             Fx = F(Fx)
+    ...         except ZeroDivisionError:
+    ...             pass
+    ...         print('%20g  %20g' % (fx, Fx))
+                    0.25                  -0.5
+                  0.0625                   0.1
+              0.00390625            -0.0011236
+             1.52588e-05           1.41691e-09
+             2.32831e-10          -2.84465e-27
+             5.42101e-20           2.30189e-80
+             2.93874e-39          -1.2197e-239
+             8.63617e-78                     0
+            7.45834e-155                     0
+                    0.81               1.02676
+                  0.6561               1.00134
+                0.430467                     1
+                0.185302                     1
+               0.0343368                     1
+              0.00117902                     1
+             1.39008e-06                     1
+             1.93233e-12                     1
+             3.73392e-24                     1
+                       4                   1.6
+                      16                1.2962
+                     256               1.10194
+                   65536               1.01659
+             4.29497e+09               1.00053
+             1.84467e+19                     1
+             3.40282e+38                     1
+             1.15792e+77                     1
+            1.34078e+154                     1
+
+    Unmodified, the iteration converges only towards 0. Modified it converges
+    not only much faster, it converges even to the repelling fixpoint 1.
+    """
+    def F(x):
+        fx = f(x)
+        ffx = f(fx)
+        return (x*ffx - fx**2) / (ffx - 2*fx + x)
+    return F
+
+OptimizationMethods.jacobian = jacobian
+OptimizationMethods.findroot = findroot
+OptimizationMethods.multiplicity = multiplicity
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
diff --git a/lib/python3.10/site-packages/mpmath/calculus/polynomials.py b/lib/python3.10/site-packages/mpmath/calculus/polynomials.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba75c1e88cbc5d40aa590a786c0af5229f193103
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/calculus/polynomials.py
@@ -0,0 +1,213 @@
+from ..libmp.backend import xrange
+from .calculus import defun
+
+#----------------------------------------------------------------------------#
+#                                Polynomials                                 #
+#----------------------------------------------------------------------------#
+
+# XXX: extra precision
+@defun
+def polyval(ctx, coeffs, x, derivative=False):
+    r"""
+    Given coefficients `[c_n, \ldots, c_2, c_1, c_0]` and a number `x`,
+    :func:`~mpmath.polyval` evaluates the polynomial
+
+    .. math ::
+
+        P(x) = c_n x^n + \ldots + c_2 x^2 + c_1 x + c_0.
+
+    If *derivative=True* is set, :func:`~mpmath.polyval` simultaneously
+    evaluates `P(x)` with the derivative, `P'(x)`, and returns the
+    tuple `(P(x), P'(x))`.
+
+        >>> from mpmath import *
+        >>> mp.pretty = True
+        >>> polyval([3, 0, 2], 0.5)
+        2.75
+        >>> polyval([3, 0, 2], 0.5, derivative=True)
+        (2.75, 3.0)
+
+    The coefficients and the evaluation point may be any combination
+    of real or complex numbers.
+    """
+    if not coeffs:
+        return ctx.zero
+    p = ctx.convert(coeffs[0])
+    q = ctx.zero
+    for c in coeffs[1:]:
+        if derivative:
+            q = p + x*q
+        p = c + x*p
+    if derivative:
+        return p, q
+    else:
+        return p
+
+@defun
+def polyroots(ctx, coeffs, maxsteps=50, cleanup=True, extraprec=10,
+        error=False, roots_init=None):
+    """
+    Computes all roots (real or complex) of a given polynomial.
+
+    The roots are returned as a sorted list, where real roots appear first
+    followed by complex conjugate roots as adjacent elements. The polynomial
+    should be given as a list of coefficients, in the format used by
+    :func:`~mpmath.polyval`. The leading coefficient must be nonzero.
+
+    With *error=True*, :func:`~mpmath.polyroots` returns a tuple *(roots, err)*
+    where *err* is an estimate of the maximum error among the computed roots.
+
+    **Examples**
+
+    Finding the three real roots of `x^3 - x^2 - 14x + 24`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> nprint(polyroots([1,-1,-14,24]), 4)
+        [-4.0, 2.0, 3.0]
+
+    Finding the two complex conjugate roots of `4x^2 + 3x + 2`, with an
+    error estimate::
+
+        >>> roots, err = polyroots([4,3,2], error=True)
+        >>> for r in roots:
+        ...     print(r)
+        ...
+        (-0.375 + 0.59947894041409j)
+        (-0.375 - 0.59947894041409j)
+        >>>
+        >>> err
+        2.22044604925031e-16
+        >>>
+        >>> polyval([4,3,2], roots[0])
+        (2.22044604925031e-16 + 0.0j)
+        >>> polyval([4,3,2], roots[1])
+        (2.22044604925031e-16 + 0.0j)
+
+    The following example computes all the 5th roots of unity; that is,
+    the roots of `x^5 - 1`::
+
+        >>> mp.dps = 20
+        >>> for r in polyroots([1, 0, 0, 0, 0, -1]):
+        ...     print(r)
+        ...
+        1.0
+        (-0.8090169943749474241 + 0.58778525229247312917j)
+        (-0.8090169943749474241 - 0.58778525229247312917j)
+        (0.3090169943749474241 + 0.95105651629515357212j)
+        (0.3090169943749474241 - 0.95105651629515357212j)
+
+    **Precision and conditioning**
+
+    The roots are computed to the current working precision accuracy. If this
+    accuracy cannot be achieved in ``maxsteps`` steps, then a
+    ``NoConvergence`` exception is raised. The algorithm internally is using
+    the current working precision extended by ``extraprec``. If
+    ``NoConvergence`` was raised, that is caused either by not having enough
+    extra precision to achieve convergence (in which case increasing
+    ``extraprec`` should fix the problem) or too low ``maxsteps`` (in which
+    case increasing ``maxsteps`` should fix the problem), or a combination of
+    both.
+
+    The user should always do a convergence study with regards to
+    ``extraprec`` to ensure accurate results. It is possible to get
+    convergence to a wrong answer with too low ``extraprec``.
+
+    Provided there are no repeated roots, :func:`~mpmath.polyroots` can
+    typically compute all roots of an arbitrary polynomial to high precision::
+
+        >>> mp.dps = 60
+        >>> for r in polyroots([1, 0, -10, 0, 1]):
+        ...     print(r)
+        ...
+        -3.14626436994197234232913506571557044551247712918732870123249
+        -0.317837245195782244725757617296174288373133378433432554879127
+        0.317837245195782244725757617296174288373133378433432554879127
+        3.14626436994197234232913506571557044551247712918732870123249
+        >>>
+        >>> sqrt(3) + sqrt(2)
+        3.14626436994197234232913506571557044551247712918732870123249
+        >>> sqrt(3) - sqrt(2)
+        0.317837245195782244725757617296174288373133378433432554879127
+
+    **Algorithm**
+
+    :func:`~mpmath.polyroots` implements the Durand-Kerner method [1], which
+    uses complex arithmetic to locate all roots simultaneously.
+    The Durand-Kerner method can be viewed as approximately performing
+    simultaneous Newton iteration for all the roots. In particular,
+    the convergence to simple roots is quadratic, just like Newton's
+    method.
+
+    Although all roots are internally calculated using complex arithmetic, any
+    root found to have an imaginary part smaller than the estimated numerical
+    error is truncated to a real number (small real parts are also chopped).
+    Real roots are placed first in the returned list, sorted by value. The
+    remaining complex roots are sorted by their real parts so that conjugate
+    roots end up next to each other.
+
+    **References**
+
+    1. http://en.wikipedia.org/wiki/Durand-Kerner_method
+
+    """
+    if len(coeffs) <= 1:
+        if not coeffs or not coeffs[0]:
+            raise ValueError("Input to polyroots must not be the zero polynomial")
+        # Constant polynomial with no roots
+        return []
+
+    orig = ctx.prec
+    tol = +ctx.eps
+    with ctx.extraprec(extraprec):
+        deg = len(coeffs) - 1
+        # Must be monic
+        lead = ctx.convert(coeffs[0])
+        if lead == 1:
+            coeffs = [ctx.convert(c) for c in coeffs]
+        else:
+            coeffs = [c/lead for c in coeffs]
+        f = lambda x: ctx.polyval(coeffs, x)
+        if roots_init is None:
+            roots = [ctx.mpc((0.4+0.9j)**n) for n in xrange(deg)]
+        else:
+            roots = [None]*deg;
+            deg_init = min(deg, len(roots_init))
+            roots[:deg_init] = list(roots_init[:deg_init])
+            roots[deg_init:] = [ctx.mpc((0.4+0.9j)**n) for n
+                                in xrange(deg_init,deg)]
+        err = [ctx.one for n in xrange(deg)]
+        # Durand-Kerner iteration until convergence
+        for step in xrange(maxsteps):
+            if abs(max(err)) < tol:
+                break
+            for i in xrange(deg):
+                p = roots[i]
+                x = f(p)
+                for j in range(deg):
+                    if i != j:
+                        try:
+                            x /= (p-roots[j])
+                        except ZeroDivisionError:
+                            continue
+                roots[i] = p - x
+                err[i] = abs(x)
+        if abs(max(err)) >= tol:
+            raise ctx.NoConvergence("Didn't converge in maxsteps=%d steps." \
+                    % maxsteps)
+        # Remove small real or imaginary parts
+        if cleanup:
+            for i in xrange(deg):
+                if abs(roots[i]) < tol:
+                    roots[i] = ctx.zero
+                elif abs(ctx._im(roots[i])) < tol:
+                    roots[i] = roots[i].real
+                elif abs(ctx._re(roots[i])) < tol:
+                    roots[i] = roots[i].imag * 1j
+        roots.sort(key=lambda x: (abs(ctx._im(x)), ctx._re(x)))
+    if error:
+        err = max(err)
+        err = max(err, ctx.ldexp(1, -orig+1))
+        return [+r for r in roots], +err
+    else:
+        return [+r for r in roots]
diff --git a/lib/python3.10/site-packages/mpmath/calculus/quadrature.py b/lib/python3.10/site-packages/mpmath/calculus/quadrature.py
new file mode 100644
index 0000000000000000000000000000000000000000..0545b3ad3e6f70a44f4ec31a0c3bcfb4ffde422b
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/calculus/quadrature.py
@@ -0,0 +1,1115 @@
+import math
+
+from ..libmp.backend import xrange
+
+class QuadratureRule(object):
+    """
+    Quadrature rules are implemented using this class, in order to
+    simplify the code and provide a common infrastructure
+    for tasks such as error estimation and node caching.
+
+    You can implement a custom quadrature rule by subclassing
+    :class:`QuadratureRule` and implementing the appropriate
+    methods. The subclass can then be used by :func:`~mpmath.quad` by
+    passing it as the *method* argument.
+
+    :class:`QuadratureRule` instances are supposed to be singletons.
+    :class:`QuadratureRule` therefore implements instance caching
+    in :func:`~mpmath.__new__`.
+    """
+
+    def __init__(self, ctx):
+        self.ctx = ctx
+        self.standard_cache = {}
+        self.transformed_cache = {}
+        self.interval_count = {}
+
+    def clear(self):
+        """
+        Delete cached node data.
+        """
+        self.standard_cache = {}
+        self.transformed_cache = {}
+        self.interval_count = {}
+
+    def calc_nodes(self, degree, prec, verbose=False):
+        r"""
+        Compute nodes for the standard interval `[-1, 1]`. Subclasses
+        should probably implement only this method, and use
+        :func:`~mpmath.get_nodes` method to retrieve the nodes.
+        """
+        raise NotImplementedError
+
+    def get_nodes(self, a, b, degree, prec, verbose=False):
+        """
+        Return nodes for given interval, degree and precision. The
+        nodes are retrieved from a cache if already computed;
+        otherwise they are computed by calling :func:`~mpmath.calc_nodes`
+        and are then cached.
+
+        Subclasses should probably not implement this method,
+        but just implement :func:`~mpmath.calc_nodes` for the actual
+        node computation.
+        """
+        key = (a, b, degree, prec)
+        if key in self.transformed_cache:
+            return self.transformed_cache[key]
+        orig = self.ctx.prec
+        try:
+            self.ctx.prec = prec+20
+            # Get nodes on standard interval
+            if (degree, prec) in self.standard_cache:
+                nodes = self.standard_cache[degree, prec]
+            else:
+                nodes = self.calc_nodes(degree, prec, verbose)
+                self.standard_cache[degree, prec] = nodes
+            # Transform to general interval
+            nodes = self.transform_nodes(nodes, a, b, verbose)
+            if key in self.interval_count:
+                self.transformed_cache[key] = nodes
+            else:
+                self.interval_count[key] = True
+        finally:
+            self.ctx.prec = orig
+        return nodes
+
+    def transform_nodes(self, nodes, a, b, verbose=False):
+        r"""
+        Rescale standardized nodes (for `[-1, 1]`) to a general
+        interval `[a, b]`. For a finite interval, a simple linear
+        change of variables is used. Otherwise, the following
+        transformations are used:
+
+        .. math ::
+
+            \lbrack a, \infty \rbrack : t = \frac{1}{x} + (a-1)
+
+            \lbrack -\infty, b \rbrack : t = (b+1) - \frac{1}{x}
+
+            \lbrack -\infty, \infty \rbrack : t = \frac{x}{\sqrt{1-x^2}}
+
+        """
+        ctx = self.ctx
+        a = ctx.convert(a)
+        b = ctx.convert(b)
+        one = ctx.one
+        if (a, b) == (-one, one):
+            return nodes
+        half = ctx.mpf(0.5)
+        new_nodes = []
+        if ctx.isinf(a) or ctx.isinf(b):
+            if (a, b) == (ctx.ninf, ctx.inf):
+                p05 = -half
+                for x, w in nodes:
+                    x2 = x*x
+                    px1 = one-x2
+                    spx1 = px1**p05
+                    x = x*spx1
+                    w *= spx1/px1
+                    new_nodes.append((x, w))
+            elif a == ctx.ninf:
+                b1 = b+1
+                for x, w in nodes:
+                    u = 2/(x+one)
+                    x = b1-u
+                    w *= half*u**2
+                    new_nodes.append((x, w))
+            elif b == ctx.inf:
+                a1 = a-1
+                for x, w in nodes:
+                    u = 2/(x+one)
+                    x = a1+u
+                    w *= half*u**2
+                    new_nodes.append((x, w))
+            elif a == ctx.inf or b == ctx.ninf:
+                return [(x,-w) for (x,w) in self.transform_nodes(nodes, b, a, verbose)]
+            else:
+                raise NotImplementedError
+        else:
+            # Simple linear change of variables
+            C = (b-a)/2
+            D = (b+a)/2
+            for x, w in nodes:
+                new_nodes.append((D+C*x, C*w))
+        return new_nodes
+
+    def guess_degree(self, prec):
+        """
+        Given a desired precision `p` in bits, estimate the degree `m`
+        of the quadrature required to accomplish full accuracy for
+        typical integrals. By default, :func:`~mpmath.quad` will perform up
+        to `m` iterations. The value of `m` should be a slight
+        overestimate, so that "slightly bad" integrals can be dealt
+        with automatically using a few extra iterations. On the
+        other hand, it should not be too big, so :func:`~mpmath.quad` can
+        quit within a reasonable amount of time when it is given
+        an "unsolvable" integral.
+
+        The default formula used by :func:`~mpmath.guess_degree` is tuned
+        for both :class:`TanhSinh` and :class:`GaussLegendre`.
+        The output is roughly as follows:
+
+            +---------+---------+
+            | `p`     | `m`     |
+            +=========+=========+
+            | 50      | 6       |
+            +---------+---------+
+            | 100     | 7       |
+            +---------+---------+
+            | 500     | 10      |
+            +---------+---------+
+            | 3000    | 12      |
+            +---------+---------+
+
+        This formula is based purely on a limited amount of
+        experimentation and will sometimes be wrong.
+        """
+        # Expected degree
+        # XXX: use mag
+        g = int(4 + max(0, self.ctx.log(prec/30.0, 2)))
+        # Reasonable "worst case"
+        g += 2
+        return g
+
+    def estimate_error(self, results, prec, epsilon):
+        r"""
+        Given results from integrations `[I_1, I_2, \ldots, I_k]` done
+        with a quadrature of rule of degree `1, 2, \ldots, k`, estimate
+        the error of `I_k`.
+
+        For `k = 2`, we estimate  `|I_{\infty}-I_2|` as `|I_2-I_1|`.
+
+        For `k > 2`, we extrapolate `|I_{\infty}-I_k| \approx |I_{k+1}-I_k|`
+        from `|I_k-I_{k-1}|` and `|I_k-I_{k-2}|` under the assumption
+        that each degree increment roughly doubles the accuracy of
+        the quadrature rule (this is true for both :class:`TanhSinh`
+        and :class:`GaussLegendre`). The extrapolation formula is given
+        by Borwein, Bailey & Girgensohn. Although not very conservative,
+        this method seems to be very robust in practice.
+        """
+        if len(results) == 2:
+            return abs(results[0]-results[1])
+        try:
+            if results[-1] == results[-2] == results[-3]:
+                return self.ctx.zero
+            D1 = self.ctx.log(abs(results[-1]-results[-2]), 10)
+            D2 = self.ctx.log(abs(results[-1]-results[-3]), 10)
+        except ValueError:
+            return epsilon
+        D3 = -prec
+        D4 = min(0, max(D1**2/D2, 2*D1, D3))
+        return self.ctx.mpf(10) ** int(D4)
+
+    def summation(self, f, points, prec, epsilon, max_degree, verbose=False):
+        """
+        Main integration function. Computes the 1D integral over
+        the interval specified by *points*. For each subinterval,
+        performs quadrature of degree from 1 up to *max_degree*
+        until :func:`~mpmath.estimate_error` signals convergence.
+
+        :func:`~mpmath.summation` transforms each subintegration to
+        the standard interval and then calls :func:`~mpmath.sum_next`.
+        """
+        ctx = self.ctx
+        I = total_err = ctx.zero
+        for i in xrange(len(points)-1):
+            a, b = points[i], points[i+1]
+            if a == b:
+                continue
+            # XXX: we could use a single variable transformation,
+            # but this is not good in practice. We get better accuracy
+            # by having 0 as an endpoint.
+            if (a, b) == (ctx.ninf, ctx.inf):
+                _f = f
+                f = lambda x: _f(-x) + _f(x)
+                a, b = (ctx.zero, ctx.inf)
+            results = []
+            err = ctx.zero
+            for degree in xrange(1, max_degree+1):
+                nodes = self.get_nodes(a, b, degree, prec, verbose)
+                if verbose:
+                    print("Integrating from %s to %s (degree %s of %s)" % \
+                        (ctx.nstr(a), ctx.nstr(b), degree, max_degree))
+                result = self.sum_next(f, nodes, degree, prec, results, verbose)
+                results.append(result)
+                if degree > 1:
+                    err = self.estimate_error(results, prec, epsilon)
+                    if verbose:
+                        print("Estimated error:", ctx.nstr(err), " epsilon:", ctx.nstr(epsilon), " result: ", ctx.nstr(result))
+                    if err <= epsilon:
+                        break
+            I += results[-1]
+            total_err += err
+        if total_err > epsilon:
+            if verbose:
+                print("Failed to reach full accuracy. Estimated error:", ctx.nstr(total_err))
+        return I, total_err
+
+    def sum_next(self, f, nodes, degree, prec, previous, verbose=False):
+        r"""
+        Evaluates the step sum `\sum w_k f(x_k)` where the *nodes* list
+        contains the `(w_k, x_k)` pairs.
+
+        :func:`~mpmath.summation` will supply the list *results* of
+        values computed by :func:`~mpmath.sum_next` at previous degrees, in
+        case the quadrature rule is able to reuse them.
+        """
+        return self.ctx.fdot((w, f(x)) for (x,w) in nodes)
+
+
+class TanhSinh(QuadratureRule):
+    r"""
+    This class implements "tanh-sinh" or "doubly exponential"
+    quadrature. This quadrature rule is based on the Euler-Maclaurin
+    integral formula. By performing a change of variables involving
+    nested exponentials / hyperbolic functions (hence the name), the
+    derivatives at the endpoints vanish rapidly. Since the error term
+    in the Euler-Maclaurin formula depends on the derivatives at the
+    endpoints, a simple step sum becomes extremely accurate. In
+    practice, this means that doubling the number of evaluation
+    points roughly doubles the number of accurate digits.
+
+    Comparison to Gauss-Legendre:
+      * Initial computation of nodes is usually faster
+      * Handles endpoint singularities better
+      * Handles infinite integration intervals better
+      * Is slower for smooth integrands once nodes have been computed
+
+    The implementation of the tanh-sinh algorithm is based on the
+    description given in Borwein, Bailey & Girgensohn, "Experimentation
+    in Mathematics - Computational Paths to Discovery", A K Peters,
+    2003, pages 312-313. In the present implementation, a few
+    improvements have been made:
+
+      * A more efficient scheme is used to compute nodes (exploiting
+        recurrence for the exponential function)
+      * The nodes are computed successively instead of all at once
+
+    **References**
+
+    * [Bailey]_
+    * http://users.cs.dal.ca/~jborwein/tanh-sinh.pdf
+
+    """
+
+    def sum_next(self, f, nodes, degree, prec, previous, verbose=False):
+        """
+        Step sum for tanh-sinh quadrature of degree `m`. We exploit the
+        fact that half of the abscissas at degree `m` are precisely the
+        abscissas from degree `m-1`. Thus reusing the result from
+        the previous level allows a 2x speedup.
+        """
+        h = self.ctx.mpf(2)**(-degree)
+        # Abscissas overlap, so reusing saves half of the time
+        if previous:
+            S = previous[-1]/(h*2)
+        else:
+            S = self.ctx.zero
+        S += self.ctx.fdot((w,f(x)) for (x,w) in nodes)
+        return h*S
+
+    def calc_nodes(self, degree, prec, verbose=False):
+        r"""
+        The abscissas and weights for tanh-sinh quadrature of degree
+        `m` are given by
+
+        .. math::
+
+            x_k = \tanh(\pi/2 \sinh(t_k))
+
+            w_k = \pi/2 \cosh(t_k) / \cosh(\pi/2 \sinh(t_k))^2
+
+        where `t_k = t_0 + hk` for a step length `h \sim 2^{-m}`. The
+        list of nodes is actually infinite, but the weights die off so
+        rapidly that only a few are needed.
+        """
+        ctx = self.ctx
+        nodes = []
+
+        extra = 20
+        ctx.prec += extra
+        tol = ctx.ldexp(1, -prec-10)
+        pi4 = ctx.pi/4
+
+        # For simplicity, we work in steps h = 1/2^n, with the first point
+        # offset so that we can reuse the sum from the previous degree
+
+        # We define degree 1 to include the "degree 0" steps, including
+        # the point x = 0. (It doesn't work well otherwise; not sure why.)
+        t0 = ctx.ldexp(1, -degree)
+        if degree == 1:
+            #nodes.append((mpf(0), pi4))
+            #nodes.append((-mpf(0), pi4))
+            nodes.append((ctx.zero, ctx.pi/2))
+            h = t0
+        else:
+            h = t0*2
+
+        # Since h is fixed, we can compute the next exponential
+        # by simply multiplying by exp(h)
+        expt0 = ctx.exp(t0)
+        a = pi4 * expt0
+        b = pi4 / expt0
+        udelta = ctx.exp(h)
+        urdelta = 1/udelta
+
+        for k in xrange(0, 20*2**degree+1):
+            # Reference implementation:
+            # t = t0 + k*h
+            # x = tanh(pi/2 * sinh(t))
+            # w = pi/2 * cosh(t) / cosh(pi/2 * sinh(t))**2
+
+            # Fast implementation. Note that c = exp(pi/2 * sinh(t))
+            c = ctx.exp(a-b)
+            d = 1/c
+            co = (c+d)/2
+            si = (c-d)/2
+            x = si / co
+            w = (a+b) / co**2
+            diff = abs(x-1)
+            if diff <= tol:
+                break
+
+            nodes.append((x, w))
+            nodes.append((-x, w))
+
+            a *= udelta
+            b *= urdelta
+
+            if verbose and k % 300 == 150:
+                # Note: the number displayed is rather arbitrary. Should
+                # figure out how to print something that looks more like a
+                # percentage
+                print("Calculating nodes:", ctx.nstr(-ctx.log(diff, 10) / prec))
+
+        ctx.prec -= extra
+        return nodes
+
+
+class GaussLegendre(QuadratureRule):
+    r"""
+    This class implements Gauss-Legendre quadrature, which is
+    exceptionally efficient for polynomials and polynomial-like (i.e.
+    very smooth) integrands.
+
+    The abscissas and weights are given by roots and values of
+    Legendre polynomials, which are the orthogonal polynomials
+    on `[-1, 1]` with respect to the unit weight
+    (see :func:`~mpmath.legendre`).
+
+    In this implementation, we take the "degree" `m` of the quadrature
+    to denote a Gauss-Legendre rule of degree `3 \cdot 2^m` (following
+    Borwein, Bailey & Girgensohn). This way we get quadratic, rather
+    than linear, convergence as the degree is incremented.
+
+    Comparison to tanh-sinh quadrature:
+      * Is faster for smooth integrands once nodes have been computed
+      * Initial computation of nodes is usually slower
+      * Handles endpoint singularities worse
+      * Handles infinite integration intervals worse
+
+    """
+
+    def calc_nodes(self, degree, prec, verbose=False):
+        r"""
+        Calculates the abscissas and weights for Gauss-Legendre
+        quadrature of degree of given degree (actually `3 \cdot 2^m`).
+        """
+        ctx = self.ctx
+        # It is important that the epsilon is set lower than the
+        # "real" epsilon
+        epsilon = ctx.ldexp(1, -prec-8)
+        # Fairly high precision might be required for accurate
+        # evaluation of the roots
+        orig = ctx.prec
+        ctx.prec = int(prec*1.5)
+        if degree == 1:
+            x = ctx.sqrt(ctx.mpf(3)/5)
+            w = ctx.mpf(5)/9
+            nodes = [(-x,w),(ctx.zero,ctx.mpf(8)/9),(x,w)]
+            ctx.prec = orig
+            return nodes
+        nodes = []
+        n = 3*2**(degree-1)
+        upto = n//2 + 1
+        for j in xrange(1, upto):
+            # Asymptotic formula for the roots
+            r = ctx.mpf(math.cos(math.pi*(j-0.25)/(n+0.5)))
+            # Newton iteration
+            while 1:
+                t1, t2 = 1, 0
+                # Evaluates the Legendre polynomial using its defining
+                # recurrence relation
+                for j1 in xrange(1,n+1):
+                    t3, t2, t1 = t2, t1, ((2*j1-1)*r*t1 - (j1-1)*t2)/j1
+                t4 = n*(r*t1-t2)/(r**2-1)
+                a = t1/t4
+                r = r - a
+                if abs(a) < epsilon:
+                    break
+            x = r
+            w = 2/((1-r**2)*t4**2)
+            if verbose  and j % 30 == 15:
+                print("Computing nodes (%i of %i)" % (j, upto))
+            nodes.append((x, w))
+            nodes.append((-x, w))
+        ctx.prec = orig
+        return nodes
+
+class QuadratureMethods(object):
+
+    def __init__(ctx, *args, **kwargs):
+        ctx._gauss_legendre = GaussLegendre(ctx)
+        ctx._tanh_sinh = TanhSinh(ctx)
+
+    def quad(ctx, f, *points, **kwargs):
+        r"""
+        Computes a single, double or triple integral over a given
+        1D interval, 2D rectangle, or 3D cuboid. A basic example::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = True
+            >>> quad(sin, [0, pi])
+            2.0
+
+        A basic 2D integral::
+
+            >>> f = lambda x, y: cos(x+y/2)
+            >>> quad(f, [-pi/2, pi/2], [0, pi])
+            4.0
+
+        **Interval format**
+
+        The integration range for each dimension may be specified
+        using a list or tuple. Arguments are interpreted as follows:
+
+        ``quad(f, [x1, x2])`` -- calculates
+        `\int_{x_1}^{x_2} f(x) \, dx`
+
+        ``quad(f, [x1, x2], [y1, y2])`` -- calculates
+        `\int_{x_1}^{x_2} \int_{y_1}^{y_2} f(x,y) \, dy \, dx`
+
+        ``quad(f, [x1, x2], [y1, y2], [z1, z2])`` -- calculates
+        `\int_{x_1}^{x_2} \int_{y_1}^{y_2} \int_{z_1}^{z_2} f(x,y,z)
+        \, dz \, dy \, dx`
+
+        Endpoints may be finite or infinite. An interval descriptor
+        may also contain more than two points. In this
+        case, the integration is split into subintervals, between
+        each pair of consecutive points. This is useful for
+        dealing with mid-interval discontinuities, or integrating
+        over large intervals where the function is irregular or
+        oscillates.
+
+        **Options**
+
+        :func:`~mpmath.quad` recognizes the following keyword arguments:
+
+        *method*
+            Chooses integration algorithm (described below).
+        *error*
+            If set to true, :func:`~mpmath.quad` returns `(v, e)` where `v` is the
+            integral and `e` is the estimated error.
+        *maxdegree*
+            Maximum degree of the quadrature rule to try before
+            quitting.
+        *verbose*
+            Print details about progress.
+
+        **Algorithms**
+
+        Mpmath presently implements two integration algorithms: tanh-sinh
+        quadrature and Gauss-Legendre quadrature. These can be selected
+        using *method='tanh-sinh'* or *method='gauss-legendre'* or by
+        passing the classes *method=TanhSinh*, *method=GaussLegendre*.
+        The functions :func:`~mpmath.quadts` and :func:`~mpmath.quadgl` are also available
+        as shortcuts.
+
+        Both algorithms have the property that doubling the number of
+        evaluation points roughly doubles the accuracy, so both are ideal
+        for high precision quadrature (hundreds or thousands of digits).
+
+        At high precision, computing the nodes and weights for the
+        integration can be expensive (more expensive than computing the
+        function values). To make repeated integrations fast, nodes
+        are automatically cached.
+
+        The advantages of the tanh-sinh algorithm are that it tends to
+        handle endpoint singularities well, and that the nodes are cheap
+        to compute on the first run. For these reasons, it is used by
+        :func:`~mpmath.quad` as the default algorithm.
+
+        Gauss-Legendre quadrature often requires fewer function
+        evaluations, and is therefore often faster for repeated use, but
+        the algorithm does not handle endpoint singularities as well and
+        the nodes are more expensive to compute. Gauss-Legendre quadrature
+        can be a better choice if the integrand is smooth and repeated
+        integrations are required (e.g. for multiple integrals).
+
+        See the documentation for :class:`TanhSinh` and
+        :class:`GaussLegendre` for additional details.
+
+        **Examples of 1D integrals**
+
+        Intervals may be infinite or half-infinite. The following two
+        examples evaluate the limits of the inverse tangent function
+        (`\int 1/(1+x^2) = \tan^{-1} x`), and the Gaussian integral
+        `\int_{\infty}^{\infty} \exp(-x^2)\,dx = \sqrt{\pi}`::
+
+            >>> mp.dps = 15
+            >>> quad(lambda x: 2/(x**2+1), [0, inf])
+            3.14159265358979
+            >>> quad(lambda x: exp(-x**2), [-inf, inf])**2
+            3.14159265358979
+
+        Integrals can typically be resolved to high precision.
+        The following computes 50 digits of `\pi` by integrating the
+        area of the half-circle defined by `x^2 + y^2 \le 1`,
+        `-1 \le x \le 1`, `y \ge 0`::
+
+            >>> mp.dps = 50
+            >>> 2*quad(lambda x: sqrt(1-x**2), [-1, 1])
+            3.1415926535897932384626433832795028841971693993751
+
+        One can just as well compute 1000 digits (output truncated)::
+
+            >>> mp.dps = 1000
+            >>> 2*quad(lambda x: sqrt(1-x**2), [-1, 1])  #doctest:+ELLIPSIS
+            3.141592653589793238462643383279502884...216420199
+
+        Complex integrals are supported. The following computes
+        a residue at `z = 0` by integrating counterclockwise along the
+        diamond-shaped path from `1` to `+i` to `-1` to `-i` to `1`::
+
+            >>> mp.dps = 15
+            >>> chop(quad(lambda z: 1/z, [1,j,-1,-j,1]))
+            (0.0 + 6.28318530717959j)
+
+        **Examples of 2D and 3D integrals**
+
+        Here are several nice examples of analytically solvable
+        2D integrals (taken from MathWorld [1]) that can be evaluated
+        to high precision fairly rapidly by :func:`~mpmath.quad`::
+
+            >>> mp.dps = 30
+            >>> f = lambda x, y: (x-1)/((1-x*y)*log(x*y))
+            >>> quad(f, [0, 1], [0, 1])
+            0.577215664901532860606512090082
+            >>> +euler
+            0.577215664901532860606512090082
+
+            >>> f = lambda x, y: 1/sqrt(1+x**2+y**2)
+            >>> quad(f, [-1, 1], [-1, 1])
+            3.17343648530607134219175646705
+            >>> 4*log(2+sqrt(3))-2*pi/3
+            3.17343648530607134219175646705
+
+            >>> f = lambda x, y: 1/(1-x**2 * y**2)
+            >>> quad(f, [0, 1], [0, 1])
+            1.23370055013616982735431137498
+            >>> pi**2 / 8
+            1.23370055013616982735431137498
+
+            >>> quad(lambda x, y: 1/(1-x*y), [0, 1], [0, 1])
+            1.64493406684822643647241516665
+            >>> pi**2 / 6
+            1.64493406684822643647241516665
+
+        Multiple integrals may be done over infinite ranges::
+
+            >>> mp.dps = 15
+            >>> print(quad(lambda x,y: exp(-x-y), [0, inf], [1, inf]))
+            0.367879441171442
+            >>> print(1/e)
+            0.367879441171442
+
+        For nonrectangular areas, one can call :func:`~mpmath.quad` recursively.
+        For example, we can replicate the earlier example of calculating
+        `\pi` by integrating over the unit-circle, and actually use double
+        quadrature to actually measure the area circle::
+
+            >>> f = lambda x: quad(lambda y: 1, [-sqrt(1-x**2), sqrt(1-x**2)])
+            >>> quad(f, [-1, 1])
+            3.14159265358979
+
+        Here is a simple triple integral::
+
+            >>> mp.dps = 15
+            >>> f = lambda x,y,z: x*y/(1+z)
+            >>> quad(f, [0,1], [0,1], [1,2], method='gauss-legendre')
+            0.101366277027041
+            >>> (log(3)-log(2))/4
+            0.101366277027041
+
+        **Singularities**
+
+        Both tanh-sinh and Gauss-Legendre quadrature are designed to
+        integrate smooth (infinitely differentiable) functions. Neither
+        algorithm copes well with mid-interval singularities (such as
+        mid-interval discontinuities in `f(x)` or `f'(x)`).
+        The best solution is to split the integral into parts::
+
+            >>> mp.dps = 15
+            >>> quad(lambda x: abs(sin(x)), [0, 2*pi])   # Bad
+            3.99900894176779
+            >>> quad(lambda x: abs(sin(x)), [0, pi, 2*pi])  # Good
+            4.0
+
+        The tanh-sinh rule often works well for integrands having a
+        singularity at one or both endpoints::
+
+            >>> mp.dps = 15
+            >>> quad(log, [0, 1], method='tanh-sinh')  # Good
+            -1.0
+            >>> quad(log, [0, 1], method='gauss-legendre')  # Bad
+            -0.999932197413801
+
+        However, the result may still be inaccurate for some functions::
+
+            >>> quad(lambda x: 1/sqrt(x), [0, 1], method='tanh-sinh')
+            1.99999999946942
+
+        This problem is not due to the quadrature rule per se, but to
+        numerical amplification of errors in the nodes. The problem can be
+        circumvented by temporarily increasing the precision::
+
+            >>> mp.dps = 30
+            >>> a = quad(lambda x: 1/sqrt(x), [0, 1], method='tanh-sinh')
+            >>> mp.dps = 15
+            >>> +a
+            2.0
+
+        **Highly variable functions**
+
+        For functions that are smooth (in the sense of being infinitely
+        differentiable) but contain sharp mid-interval peaks or many
+        "bumps", :func:`~mpmath.quad` may fail to provide full accuracy. For
+        example, with default settings, :func:`~mpmath.quad` is able to integrate
+        `\sin(x)` accurately over an interval of length 100 but not over
+        length 1000::
+
+            >>> quad(sin, [0, 100]); 1-cos(100)   # Good
+            0.137681127712316
+            0.137681127712316
+            >>> quad(sin, [0, 1000]); 1-cos(1000)   # Bad
+            -37.8587612408485
+            0.437620923709297
+
+        One solution is to break the integration into 10 intervals of
+        length 100::
+
+            >>> quad(sin, linspace(0, 1000, 10))   # Good
+            0.437620923709297
+
+        Another is to increase the degree of the quadrature::
+
+            >>> quad(sin, [0, 1000], maxdegree=10)   # Also good
+            0.437620923709297
+
+        Whether splitting the interval or increasing the degree is
+        more efficient differs from case to case. Another example is the
+        function `1/(1+x^2)`, which has a sharp peak centered around
+        `x = 0`::
+
+            >>> f = lambda x: 1/(1+x**2)
+            >>> quad(f, [-100, 100])   # Bad
+            3.64804647105268
+            >>> quad(f, [-100, 100], maxdegree=10)   # Good
+            3.12159332021646
+            >>> quad(f, [-100, 0, 100])   # Also good
+            3.12159332021646
+
+        **References**
+
+        1. http://mathworld.wolfram.com/DoubleIntegral.html
+
+        """
+        rule = kwargs.get('method', 'tanh-sinh')
+        if type(rule) is str:
+            if rule == 'tanh-sinh':
+                rule = ctx._tanh_sinh
+            elif rule == 'gauss-legendre':
+                rule = ctx._gauss_legendre
+            else:
+                raise ValueError("unknown quadrature rule: %s" % rule)
+        else:
+            rule = rule(ctx)
+        verbose = kwargs.get('verbose')
+        dim = len(points)
+        orig = prec = ctx.prec
+        epsilon = ctx.eps/8
+        m = kwargs.get('maxdegree') or rule.guess_degree(prec)
+        points = [ctx._as_points(p) for p in points]
+        try:
+            ctx.prec += 20
+            if dim == 1:
+                v, err = rule.summation(f, points[0], prec, epsilon, m, verbose)
+            elif dim == 2:
+                v, err = rule.summation(lambda x: \
+                        rule.summation(lambda y: f(x,y), \
+                        points[1], prec, epsilon, m)[0],
+                    points[0], prec, epsilon, m, verbose)
+            elif dim == 3:
+                v, err = rule.summation(lambda x: \
+                        rule.summation(lambda y: \
+                            rule.summation(lambda z: f(x,y,z), \
+                            points[2], prec, epsilon, m)[0],
+                        points[1], prec, epsilon, m)[0],
+                    points[0], prec, epsilon, m, verbose)
+            else:
+                raise NotImplementedError("quadrature must have dim 1, 2 or 3")
+        finally:
+            ctx.prec = orig
+        if kwargs.get("error"):
+            return +v, err
+        return +v
+
+    def quadts(ctx, *args, **kwargs):
+        """
+        Performs tanh-sinh quadrature. The call
+
+            quadts(func, *points, ...)
+
+        is simply a shortcut for:
+
+            quad(func, *points, ..., method=TanhSinh)
+
+        For example, a single integral and a double integral:
+
+            quadts(lambda x: exp(cos(x)), [0, 1])
+            quadts(lambda x, y: exp(cos(x+y)), [0, 1], [0, 1])
+
+        See the documentation for quad for information about how points
+        arguments and keyword arguments are parsed.
+
+        See documentation for TanhSinh for algorithmic information about
+        tanh-sinh quadrature.
+        """
+        kwargs['method'] = 'tanh-sinh'
+        return ctx.quad(*args, **kwargs)
+
+    def quadgl(ctx, *args, **kwargs):
+        """
+        Performs Gauss-Legendre quadrature. The call
+
+            quadgl(func, *points, ...)
+
+        is simply a shortcut for:
+
+            quad(func, *points, ..., method=GaussLegendre)
+
+        For example, a single integral and a double integral:
+
+            quadgl(lambda x: exp(cos(x)), [0, 1])
+            quadgl(lambda x, y: exp(cos(x+y)), [0, 1], [0, 1])
+
+        See the documentation for quad for information about how points
+        arguments and keyword arguments are parsed.
+
+        See documentation for TanhSinh for algorithmic information about
+        tanh-sinh quadrature.
+        """
+        kwargs['method'] = 'gauss-legendre'
+        return ctx.quad(*args, **kwargs)
+
+    def quadosc(ctx, f, interval, omega=None, period=None, zeros=None):
+        r"""
+        Calculates
+
+        .. math ::
+
+            I = \int_a^b f(x) dx
+
+        where at least one of `a` and `b` is infinite and where
+        `f(x) = g(x) \cos(\omega x  + \phi)` for some slowly
+        decreasing function `g(x)`. With proper input, :func:`~mpmath.quadosc`
+        can also handle oscillatory integrals where the oscillation
+        rate is different from a pure sine or cosine wave.
+
+        In the standard case when `|a| < \infty, b = \infty`,
+        :func:`~mpmath.quadosc` works by evaluating the infinite series
+
+        .. math ::
+
+            I = \int_a^{x_1} f(x) dx +
+            \sum_{k=1}^{\infty} \int_{x_k}^{x_{k+1}} f(x) dx
+
+        where `x_k` are consecutive zeros (alternatively
+        some other periodic reference point) of `f(x)`.
+        Accordingly, :func:`~mpmath.quadosc` requires information about the
+        zeros of `f(x)`. For a periodic function, you can specify
+        the zeros by either providing the angular frequency `\omega`
+        (*omega*) or the *period* `2 \pi/\omega`. In general, you can
+        specify the `n`-th zero by providing the *zeros* arguments.
+        Below is an example of each::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = True
+            >>> f = lambda x: sin(3*x)/(x**2+1)
+            >>> quadosc(f, [0,inf], omega=3)
+            0.37833007080198
+            >>> quadosc(f, [0,inf], period=2*pi/3)
+            0.37833007080198
+            >>> quadosc(f, [0,inf], zeros=lambda n: pi*n/3)
+            0.37833007080198
+            >>> (ei(3)*exp(-3)-exp(3)*ei(-3))/2  # Computed by Mathematica
+            0.37833007080198
+
+        Note that *zeros* was specified to multiply `n` by the
+        *half-period*, not the full period. In theory, it does not matter
+        whether each partial integral is done over a half period or a full
+        period. However, if done over half-periods, the infinite series
+        passed to :func:`~mpmath.nsum` becomes an *alternating series* and this
+        typically makes the extrapolation much more efficient.
+
+        Here is an example of an integration over the entire real line,
+        and a half-infinite integration starting at `-\infty`::
+
+            >>> quadosc(lambda x: cos(x)/(1+x**2), [-inf, inf], omega=1)
+            1.15572734979092
+            >>> pi/e
+            1.15572734979092
+            >>> quadosc(lambda x: cos(x)/x**2, [-inf, -1], period=2*pi)
+            -0.0844109505595739
+            >>> cos(1)+si(1)-pi/2
+            -0.0844109505595738
+
+        Of course, the integrand may contain a complex exponential just as
+        well as a real sine or cosine::
+
+            >>> quadosc(lambda x: exp(3*j*x)/(1+x**2), [-inf,inf], omega=3)
+            (0.156410688228254 + 0.0j)
+            >>> pi/e**3
+            0.156410688228254
+            >>> quadosc(lambda x: exp(3*j*x)/(2+x+x**2), [-inf,inf], omega=3)
+            (0.00317486988463794 - 0.0447701735209082j)
+            >>> 2*pi/sqrt(7)/exp(3*(j+sqrt(7))/2)
+            (0.00317486988463794 - 0.0447701735209082j)
+
+        **Non-periodic functions**
+
+        If `f(x) = g(x) h(x)` for some function `h(x)` that is not
+        strictly periodic, *omega* or *period* might not work, and it might
+        be necessary to use *zeros*.
+
+        A notable exception can be made for Bessel functions which, though not
+        periodic, are "asymptotically periodic" in a sufficiently strong sense
+        that the sum extrapolation will work out::
+
+            >>> quadosc(j0, [0, inf], period=2*pi)
+            1.0
+            >>> quadosc(j1, [0, inf], period=2*pi)
+            1.0
+
+        More properly, one should provide the exact Bessel function zeros::
+
+            >>> j0zero = lambda n: findroot(j0, pi*(n-0.25))
+            >>> quadosc(j0, [0, inf], zeros=j0zero)
+            1.0
+
+        For an example where *zeros* becomes necessary, consider the
+        complete Fresnel integrals
+
+        .. math ::
+
+            \int_0^{\infty} \cos x^2\,dx = \int_0^{\infty} \sin x^2\,dx
+            = \sqrt{\frac{\pi}{8}}.
+
+        Although the integrands do not decrease in magnitude as
+        `x \to \infty`, the integrals are convergent since the oscillation
+        rate increases (causing consecutive periods to asymptotically
+        cancel out). These integrals are virtually impossible to calculate
+        to any kind of accuracy using standard quadrature rules. However,
+        if one provides the correct asymptotic distribution of zeros
+        (`x_n \sim \sqrt{n}`), :func:`~mpmath.quadosc` works::
+
+            >>> mp.dps = 30
+            >>> f = lambda x: cos(x**2)
+            >>> quadosc(f, [0,inf], zeros=lambda n:sqrt(pi*n))
+            0.626657068657750125603941321203
+            >>> f = lambda x: sin(x**2)
+            >>> quadosc(f, [0,inf], zeros=lambda n:sqrt(pi*n))
+            0.626657068657750125603941321203
+            >>> sqrt(pi/8)
+            0.626657068657750125603941321203
+
+        (Interestingly, these integrals can still be evaluated if one
+        places some other constant than `\pi` in the square root sign.)
+
+        In general, if `f(x) \sim g(x) \cos(h(x))`, the zeros follow
+        the inverse-function distribution `h^{-1}(x)`::
+
+            >>> mp.dps = 15
+            >>> f = lambda x: sin(exp(x))
+            >>> quadosc(f, [1,inf], zeros=lambda n: log(n))
+            -0.25024394235267
+            >>> pi/2-si(e)
+            -0.250243942352671
+
+        **Non-alternating functions**
+
+        If the integrand oscillates around a positive value, without
+        alternating signs, the extrapolation might fail. A simple trick
+        that sometimes works is to multiply or divide the frequency by 2::
+
+            >>> f = lambda x: 1/x**2+sin(x)/x**4
+            >>> quadosc(f, [1,inf], omega=1)  # Bad
+            1.28642190869861
+            >>> quadosc(f, [1,inf], omega=0.5)  # Perfect
+            1.28652953559617
+            >>> 1+(cos(1)+ci(1)+sin(1))/6
+            1.28652953559617
+
+        **Fast decay**
+
+        :func:`~mpmath.quadosc` is primarily useful for slowly decaying
+        integrands. If the integrand decreases exponentially or faster,
+        :func:`~mpmath.quad` will likely handle it without trouble (and generally be
+        much faster than :func:`~mpmath.quadosc`)::
+
+            >>> quadosc(lambda x: cos(x)/exp(x), [0, inf], omega=1)
+            0.5
+            >>> quad(lambda x: cos(x)/exp(x), [0, inf])
+            0.5
+
+        """
+        a, b = ctx._as_points(interval)
+        a = ctx.convert(a)
+        b = ctx.convert(b)
+        if [omega, period, zeros].count(None) != 2:
+            raise ValueError( \
+                "must specify exactly one of omega, period, zeros")
+        if a == ctx.ninf and b == ctx.inf:
+            s1 = ctx.quadosc(f, [a, 0], omega=omega, zeros=zeros, period=period)
+            s2 = ctx.quadosc(f, [0, b], omega=omega, zeros=zeros, period=period)
+            return s1 + s2
+        if a == ctx.ninf:
+            if zeros:
+                return ctx.quadosc(lambda x:f(-x), [-b,-a], lambda n: zeros(-n))
+            else:
+                return ctx.quadosc(lambda x:f(-x), [-b,-a], omega=omega, period=period)
+        if b != ctx.inf:
+            raise ValueError("quadosc requires an infinite integration interval")
+        if not zeros:
+            if omega:
+                period = 2*ctx.pi/omega
+            zeros = lambda n: n*period/2
+        #for n in range(1,10):
+        #    p = zeros(n)
+        #    if p > a:
+        #        break
+        #if n >= 9:
+        #    raise ValueError("zeros do not appear to be correctly indexed")
+        n = 1
+        s = ctx.quadgl(f, [a, zeros(n)])
+        def term(k):
+            return ctx.quadgl(f, [zeros(k), zeros(k+1)])
+        s += ctx.nsum(term, [n, ctx.inf])
+        return s
+
+    def quadsubdiv(ctx, f, interval, tol=None, maxintervals=None, **kwargs):
+        """
+        Computes the integral of *f* over the interval or path specified
+        by *interval*, using :func:`~mpmath.quad` together with adaptive
+        subdivision of the interval.
+
+        This function gives an accurate answer for some integrals where
+        :func:`~mpmath.quad` fails::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = True
+            >>> quad(lambda x: abs(sin(x)), [0, 2*pi])
+            3.99900894176779
+            >>> quadsubdiv(lambda x: abs(sin(x)), [0, 2*pi])
+            4.0
+            >>> quadsubdiv(sin, [0, 1000])
+            0.437620923709297
+            >>> quadsubdiv(lambda x: 1/(1+x**2), [-100, 100])
+            3.12159332021646
+            >>> quadsubdiv(lambda x: ceil(x), [0, 100])
+            5050.0
+            >>> quadsubdiv(lambda x: sin(x+exp(x)), [0,8])
+            0.347400172657248
+
+        The argument *maxintervals* can be set to limit the permissible
+        subdivision::
+
+            >>> quadsubdiv(lambda x: sin(x**2), [0,100], maxintervals=5, error=True)
+            (-5.40487904307774, 5.011)
+            >>> quadsubdiv(lambda x: sin(x**2), [0,100], maxintervals=100, error=True)
+            (0.631417921866934, 1.10101120134116e-17)
+
+        Subdivision does not guarantee a correct answer since, the error
+        estimate on subintervals may be inaccurate::
+
+            >>> quadsubdiv(lambda x: sech(10*x-2)**2 + sech(100*x-40)**4 + sech(1000*x-600)**6, [0,1], error=True)
+            (0.210802735500549, 1.0001111101e-17)
+            >>> mp.dps = 20
+            >>> quadsubdiv(lambda x: sech(10*x-2)**2 + sech(100*x-40)**4 + sech(1000*x-600)**6, [0,1], error=True)
+            (0.21080273550054927738, 2.200000001e-24)
+
+        The second answer is correct. We can get an accurate result at lower
+        precision by forcing a finer initial subdivision::
+
+            >>> mp.dps = 15
+            >>> quadsubdiv(lambda x: sech(10*x-2)**2 + sech(100*x-40)**4 + sech(1000*x-600)**6, linspace(0,1,5))
+            0.210802735500549
+
+        The following integral is too oscillatory for convergence, but we can get a
+        reasonable estimate::
+
+            >>> v, err = fp.quadsubdiv(lambda x: fp.sin(1/x), [0,1], error=True)
+            >>> round(v, 6), round(err, 6)
+            (0.504067, 1e-06)
+            >>> sin(1) - ci(1)
+            0.504067061906928
+
+        """
+        queue = []
+        for i in range(len(interval)-1):
+            queue.append((interval[i], interval[i+1]))
+        total = ctx.zero
+        total_error = ctx.zero
+        if maxintervals is None:
+            maxintervals = 10 * ctx.prec
+        count = 0
+        quad_args = kwargs.copy()
+        quad_args["verbose"] = False
+        quad_args["error"] = True
+        if tol is None:
+            tol = +ctx.eps
+        orig = ctx.prec
+        try:
+            ctx.prec += 5
+            while queue:
+                a, b = queue.pop()
+                s, err = ctx.quad(f, [a, b], **quad_args)
+                if kwargs.get("verbose"):
+                    print("subinterval", count, a, b, err)
+                if err < tol or count > maxintervals:
+                    total += s
+                    total_error += err
+                else:
+                    count += 1
+                    if count == maxintervals and kwargs.get("verbose"):
+                        print("warning: number of intervals exceeded maxintervals")
+                    if a == -ctx.inf and b == ctx.inf:
+                        m = 0
+                    elif a == -ctx.inf:
+                        m = min(b-1, 2*b)
+                    elif b == ctx.inf:
+                        m = max(a+1, 2*a)
+                    else:
+                        m = a + (b - a) / 2
+                    queue.append((a, m))
+                    queue.append((m, b))
+        finally:
+            ctx.prec = orig
+        if kwargs.get("error"):
+            return +total, +total_error
+        else:
+            return +total
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
diff --git a/lib/python3.10/site-packages/mpmath/functions/__init__.py b/lib/python3.10/site-packages/mpmath/functions/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5896ed0579eceab086dc5c67eaa649b6061a53dc
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/functions/__init__.py
@@ -0,0 +1,14 @@
+from . import functions
+# Hack to update methods
+from . import factorials
+from . import hypergeometric
+from . import expintegrals
+from . import bessel
+from . import orthogonal
+from . import theta
+from . import elliptic
+from . import signals
+from . import zeta
+from . import rszeta
+from . import zetazeros
+from . import qfunctions
diff --git a/lib/python3.10/site-packages/mpmath/functions/bessel.py b/lib/python3.10/site-packages/mpmath/functions/bessel.py
new file mode 100644
index 0000000000000000000000000000000000000000..8b41d87bb0118de61d5561433dabcb181f872f84
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/functions/bessel.py
@@ -0,0 +1,1108 @@
+from .functions import defun, defun_wrapped
+
+@defun
+def j0(ctx, x):
+    """Computes the Bessel function `J_0(x)`. See :func:`~mpmath.besselj`."""
+    return ctx.besselj(0, x)
+
+@defun
+def j1(ctx, x):
+    """Computes the Bessel function `J_1(x)`.  See :func:`~mpmath.besselj`."""
+    return ctx.besselj(1, x)
+
+@defun
+def besselj(ctx, n, z, derivative=0, **kwargs):
+    if type(n) is int:
+        n_isint = True
+    else:
+        n = ctx.convert(n)
+        n_isint = ctx.isint(n)
+        if n_isint:
+            n = int(ctx._re(n))
+    if n_isint and n < 0:
+        return (-1)**n * ctx.besselj(-n, z, derivative, **kwargs)
+    z = ctx.convert(z)
+    M = ctx.mag(z)
+    if derivative:
+        d = ctx.convert(derivative)
+        # TODO: the integer special-casing shouldn't be necessary.
+        # However, the hypergeometric series gets inaccurate for large d
+        # because of inaccurate pole cancellation at a pole far from
+        # zero (needs to be fixed in hypercomb or hypsum)
+        if ctx.isint(d) and d >= 0:
+            d = int(d)
+            orig = ctx.prec
+            try:
+                ctx.prec += 15
+                v = ctx.fsum((-1)**k * ctx.binomial(d,k) * ctx.besselj(2*k+n-d,z)
+                    for k in range(d+1))
+            finally:
+                ctx.prec = orig
+            v *= ctx.mpf(2)**(-d)
+        else:
+            def h(n,d):
+                r = ctx.fmul(ctx.fmul(z, z, prec=ctx.prec+M), -0.25, exact=True)
+                B = [0.5*(n-d+1), 0.5*(n-d+2)]
+                T = [([2,ctx.pi,z],[d-2*n,0.5,n-d],[],B,[(n+1)*0.5,(n+2)*0.5],B+[n+1],r)]
+                return T
+            v = ctx.hypercomb(h, [n,d], **kwargs)
+    else:
+        # Fast case: J_n(x), n int, appropriate magnitude for fixed-point calculation
+        if (not derivative) and n_isint and abs(M) < 10 and abs(n) < 20:
+            try:
+                return ctx._besselj(n, z)
+            except NotImplementedError:
+                pass
+        if not z:
+            if not n:
+                v = ctx.one + n+z
+            elif ctx.re(n) > 0:
+                v = n*z
+            else:
+                v = ctx.inf + z + n
+        else:
+            #v = 0
+            orig = ctx.prec
+            try:
+                # XXX: workaround for accuracy in low level hypergeometric series
+                # when alternating, large arguments
+                ctx.prec += min(3*abs(M), ctx.prec)
+                w = ctx.fmul(z, 0.5, exact=True)
+                def h(n):
+                    r = ctx.fneg(ctx.fmul(w, w, prec=max(0,ctx.prec+M)), exact=True)
+                    return [([w], [n], [], [n+1], [], [n+1], r)]
+                v = ctx.hypercomb(h, [n], **kwargs)
+            finally:
+                ctx.prec = orig
+        v = +v
+    return v
+
+@defun
+def besseli(ctx, n, z, derivative=0, **kwargs):
+    n = ctx.convert(n)
+    z = ctx.convert(z)
+    if not z:
+        if derivative:
+            raise ValueError
+        if not n:
+            # I(0,0) = 1
+            return 1+n+z
+        if ctx.isint(n):
+            return 0*(n+z)
+        r = ctx.re(n)
+        if r == 0:
+            return ctx.nan*(n+z)
+        elif r > 0:
+            return 0*(n+z)
+        else:
+            return ctx.inf+(n+z)
+    M = ctx.mag(z)
+    if derivative:
+        d = ctx.convert(derivative)
+        def h(n,d):
+            r = ctx.fmul(ctx.fmul(z, z, prec=ctx.prec+M), 0.25, exact=True)
+            B = [0.5*(n-d+1), 0.5*(n-d+2), n+1]
+            T = [([2,ctx.pi,z],[d-2*n,0.5,n-d],[n+1],B,[(n+1)*0.5,(n+2)*0.5],B,r)]
+            return T
+        v = ctx.hypercomb(h, [n,d], **kwargs)
+    else:
+        def h(n):
+            w = ctx.fmul(z, 0.5, exact=True)
+            r = ctx.fmul(w, w, prec=max(0,ctx.prec+M))
+            return [([w], [n], [], [n+1], [], [n+1], r)]
+        v = ctx.hypercomb(h, [n], **kwargs)
+    return v
+
+@defun_wrapped
+def bessely(ctx, n, z, derivative=0, **kwargs):
+    if not z:
+        if derivative:
+            # Not implemented
+            raise ValueError
+        if not n:
+            # ~ log(z/2)
+            return -ctx.inf + (n+z)
+        if ctx.im(n):
+            return ctx.nan * (n+z)
+        r = ctx.re(n)
+        q = n+0.5
+        if ctx.isint(q):
+            if n > 0:
+                return -ctx.inf + (n+z)
+            else:
+                return 0 * (n+z)
+        if r < 0 and int(ctx.floor(q)) % 2:
+            return ctx.inf + (n+z)
+        else:
+            return ctx.ninf + (n+z)
+    # XXX: use hypercomb
+    ctx.prec += 10
+    m, d = ctx.nint_distance(n)
+    if d < -ctx.prec:
+        h = +ctx.eps
+        ctx.prec *= 2
+        n += h
+    elif d < 0:
+        ctx.prec -= d
+    # TODO: avoid cancellation for imaginary arguments
+    cos, sin = ctx.cospi_sinpi(n)
+    return (ctx.besselj(n,z,derivative,**kwargs)*cos - \
+        ctx.besselj(-n,z,derivative,**kwargs))/sin
+
+@defun_wrapped
+def besselk(ctx, n, z, **kwargs):
+    if not z:
+        return ctx.inf
+    M = ctx.mag(z)
+    if M < 1:
+        # Represent as limit definition
+        def h(n):
+            r = (z/2)**2
+            T1 = [z, 2], [-n, n-1], [n], [], [], [1-n], r
+            T2 = [z, 2], [n, -n-1], [-n], [], [], [1+n], r
+            return T1, T2
+    # We could use the limit definition always, but it leads
+    # to very bad cancellation (of exponentially large terms)
+    # for large real z
+    # Instead represent in terms of 2F0
+    else:
+        ctx.prec += M
+        def h(n):
+            return [([ctx.pi/2, z, ctx.exp(-z)], [0.5,-0.5,1], [], [], \
+                [n+0.5, 0.5-n], [], -1/(2*z))]
+    return ctx.hypercomb(h, [n], **kwargs)
+
+@defun_wrapped
+def hankel1(ctx,n,x,**kwargs):
+    return ctx.besselj(n,x,**kwargs) + ctx.j*ctx.bessely(n,x,**kwargs)
+
+@defun_wrapped
+def hankel2(ctx,n,x,**kwargs):
+    return ctx.besselj(n,x,**kwargs) - ctx.j*ctx.bessely(n,x,**kwargs)
+
+@defun_wrapped
+def whitm(ctx,k,m,z,**kwargs):
+    if z == 0:
+        # M(k,m,z) = 0^(1/2+m)
+        if ctx.re(m) > -0.5:
+            return z
+        elif ctx.re(m) < -0.5:
+            return ctx.inf + z
+        else:
+            return ctx.nan * z
+    x = ctx.fmul(-0.5, z, exact=True)
+    y = 0.5+m
+    return ctx.exp(x) * z**y * ctx.hyp1f1(y-k, 1+2*m, z, **kwargs)
+
+@defun_wrapped
+def whitw(ctx,k,m,z,**kwargs):
+    if z == 0:
+        g = abs(ctx.re(m))
+        if g < 0.5:
+            return z
+        elif g > 0.5:
+            return ctx.inf + z
+        else:
+            return ctx.nan * z
+    x = ctx.fmul(-0.5, z, exact=True)
+    y = 0.5+m
+    return ctx.exp(x) * z**y * ctx.hyperu(y-k, 1+2*m, z, **kwargs)
+
+@defun
+def hyperu(ctx, a, b, z, **kwargs):
+    a, atype = ctx._convert_param(a)
+    b, btype = ctx._convert_param(b)
+    z = ctx.convert(z)
+    if not z:
+        if ctx.re(b) <= 1:
+            return ctx.gammaprod([1-b],[a-b+1])
+        else:
+            return ctx.inf + z
+    bb = 1+a-b
+    bb, bbtype = ctx._convert_param(bb)
+    try:
+        orig = ctx.prec
+        try:
+            ctx.prec += 10
+            v = ctx.hypsum(2, 0, (atype, bbtype), [a, bb], -1/z, maxterms=ctx.prec)
+            return v / z**a
+        finally:
+            ctx.prec = orig
+    except ctx.NoConvergence:
+        pass
+    def h(a,b):
+        w = ctx.sinpi(b)
+        T1 = ([ctx.pi,w],[1,-1],[],[a-b+1,b],[a],[b],z)
+        T2 = ([-ctx.pi,w,z],[1,-1,1-b],[],[a,2-b],[a-b+1],[2-b],z)
+        return T1, T2
+    return ctx.hypercomb(h, [a,b], **kwargs)
+
+@defun
+def struveh(ctx,n,z, **kwargs):
+    n = ctx.convert(n)
+    z = ctx.convert(z)
+    # http://functions.wolfram.com/Bessel-TypeFunctions/StruveH/26/01/02/
+    def h(n):
+        return [([z/2, 0.5*ctx.sqrt(ctx.pi)], [n+1, -1], [], [n+1.5], [1], [1.5, n+1.5], -(z/2)**2)]
+    return ctx.hypercomb(h, [n], **kwargs)
+
+@defun
+def struvel(ctx,n,z, **kwargs):
+    n = ctx.convert(n)
+    z = ctx.convert(z)
+    # http://functions.wolfram.com/Bessel-TypeFunctions/StruveL/26/01/02/
+    def h(n):
+        return [([z/2, 0.5*ctx.sqrt(ctx.pi)], [n+1, -1], [], [n+1.5], [1], [1.5, n+1.5], (z/2)**2)]
+    return ctx.hypercomb(h, [n], **kwargs)
+
+def _anger(ctx,which,v,z,**kwargs):
+    v = ctx._convert_param(v)[0]
+    z = ctx.convert(z)
+    def h(v):
+        b = ctx.mpq_1_2
+        u = v*b
+        m = b*3
+        a1,a2,b1,b2 = m-u, m+u, 1-u, 1+u
+        c, s = ctx.cospi_sinpi(u)
+        if which == 0:
+            A, B = [b*z, s], [c]
+        if which == 1:
+            A, B = [b*z, -c], [s]
+        w = ctx.square_exp_arg(z, mult=-0.25)
+        T1 = A, [1, 1], [], [a1,a2], [1], [a1,a2], w
+        T2 = B, [1], [], [b1,b2], [1], [b1,b2], w
+        return T1, T2
+    return ctx.hypercomb(h, [v], **kwargs)
+
+@defun
+def angerj(ctx, v, z, **kwargs):
+    return _anger(ctx, 0, v, z, **kwargs)
+
+@defun
+def webere(ctx, v, z, **kwargs):
+    return _anger(ctx, 1, v, z, **kwargs)
+
+@defun
+def lommels1(ctx, u, v, z, **kwargs):
+    u = ctx._convert_param(u)[0]
+    v = ctx._convert_param(v)[0]
+    z = ctx.convert(z)
+    def h(u,v):
+        b = ctx.mpq_1_2
+        w = ctx.square_exp_arg(z, mult=-0.25)
+        return ([u-v+1, u+v+1, z], [-1, -1, u+1], [], [], [1], \
+            [b*(u-v+3),b*(u+v+3)], w),
+    return ctx.hypercomb(h, [u,v], **kwargs)
+
+@defun
+def lommels2(ctx, u, v, z, **kwargs):
+    u = ctx._convert_param(u)[0]
+    v = ctx._convert_param(v)[0]
+    z = ctx.convert(z)
+    # Asymptotic expansion (GR p. 947) -- need to be careful
+    # not to use for small arguments
+    # def h(u,v):
+    #    b = ctx.mpq_1_2
+    #    w = -(z/2)**(-2)
+    #    return ([z], [u-1], [], [], [b*(1-u+v)], [b*(1-u-v)], w),
+    def h(u,v):
+        b = ctx.mpq_1_2
+        w = ctx.square_exp_arg(z, mult=-0.25)
+        T1 = [u-v+1, u+v+1, z], [-1, -1, u+1], [], [], [1], [b*(u-v+3),b*(u+v+3)], w
+        T2 = [2, z], [u+v-1, -v], [v, b*(u+v+1)], [b*(v-u+1)], [], [1-v], w
+        T3 = [2, z], [u-v-1, v], [-v, b*(u-v+1)], [b*(1-u-v)], [], [1+v], w
+        #c1 = ctx.cospi((u-v)*b)
+        #c2 = ctx.cospi((u+v)*b)
+        #s = ctx.sinpi(v)
+        #r1 = (u-v+1)*b
+        #r2 = (u+v+1)*b
+        #T2 = [c1, s, z, 2], [1, -1, -v, v], [], [-v+1], [], [-v+1], w
+        #T3 = [-c2, s, z, 2], [1, -1, v, -v], [], [v+1], [], [v+1], w
+        #T2 = [c1, s, z, 2], [1, -1, -v, v+u-1], [r1, r2], [-v+1], [], [-v+1], w
+        #T3 = [-c2, s, z, 2], [1, -1, v, -v+u-1], [r1, r2], [v+1], [], [v+1], w
+        return T1, T2, T3
+    return ctx.hypercomb(h, [u,v], **kwargs)
+
+@defun
+def ber(ctx, n, z, **kwargs):
+    n = ctx.convert(n)
+    z = ctx.convert(z)
+    # http://functions.wolfram.com/Bessel-TypeFunctions/KelvinBer2/26/01/02/0001/
+    def h(n):
+        r = -(z/4)**4
+        cos, sin = ctx.cospi_sinpi(-0.75*n)
+        T1 = [cos, z/2], [1, n], [], [n+1], [], [0.5, 0.5*(n+1), 0.5*n+1], r
+        T2 = [sin, z/2], [1, n+2], [], [n+2], [], [1.5, 0.5*(n+3), 0.5*n+1], r
+        return T1, T2
+    return ctx.hypercomb(h, [n], **kwargs)
+
+@defun
+def bei(ctx, n, z, **kwargs):
+    n = ctx.convert(n)
+    z = ctx.convert(z)
+    # http://functions.wolfram.com/Bessel-TypeFunctions/KelvinBei2/26/01/02/0001/
+    def h(n):
+        r = -(z/4)**4
+        cos, sin = ctx.cospi_sinpi(0.75*n)
+        T1 = [cos, z/2], [1, n+2], [], [n+2], [], [1.5, 0.5*(n+3), 0.5*n+1], r
+        T2 = [sin, z/2], [1, n], [], [n+1], [], [0.5, 0.5*(n+1), 0.5*n+1], r
+        return T1, T2
+    return ctx.hypercomb(h, [n], **kwargs)
+
+@defun
+def ker(ctx, n, z, **kwargs):
+    n = ctx.convert(n)
+    z = ctx.convert(z)
+    # http://functions.wolfram.com/Bessel-TypeFunctions/KelvinKer2/26/01/02/0001/
+    def h(n):
+        r = -(z/4)**4
+        cos1, sin1 = ctx.cospi_sinpi(0.25*n)
+        cos2, sin2 = ctx.cospi_sinpi(0.75*n)
+        T1 = [2, z, 4*cos1], [-n-3, n, 1], [-n], [], [], [0.5, 0.5*(1+n), 0.5*(n+2)], r
+        T2 = [2, z, -sin1], [-n-3, 2+n, 1], [-n-1], [], [], [1.5, 0.5*(3+n), 0.5*(n+2)], r
+        T3 = [2, z, 4*cos2], [n-3, -n, 1], [n], [], [], [0.5, 0.5*(1-n), 1-0.5*n], r
+        T4 = [2, z, -sin2], [n-3, 2-n, 1], [n-1], [], [], [1.5, 0.5*(3-n), 1-0.5*n], r
+        return T1, T2, T3, T4
+    return ctx.hypercomb(h, [n], **kwargs)
+
+@defun
+def kei(ctx, n, z, **kwargs):
+    n = ctx.convert(n)
+    z = ctx.convert(z)
+    # http://functions.wolfram.com/Bessel-TypeFunctions/KelvinKei2/26/01/02/0001/
+    def h(n):
+        r = -(z/4)**4
+        cos1, sin1 = ctx.cospi_sinpi(0.75*n)
+        cos2, sin2 = ctx.cospi_sinpi(0.25*n)
+        T1 = [-cos1, 2, z], [1, n-3, 2-n], [n-1], [], [], [1.5, 0.5*(3-n), 1-0.5*n], r
+        T2 = [-sin1, 2, z], [1, n-1, -n], [n], [], [], [0.5, 0.5*(1-n), 1-0.5*n], r
+        T3 = [-sin2, 2, z], [1, -n-1, n], [-n], [], [], [0.5, 0.5*(n+1), 0.5*(n+2)], r
+        T4 = [-cos2, 2, z], [1, -n-3, n+2], [-n-1], [], [], [1.5, 0.5*(n+3), 0.5*(n+2)], r
+        return T1, T2, T3, T4
+    return ctx.hypercomb(h, [n], **kwargs)
+
+# TODO: do this more generically?
+def c_memo(f):
+    name = f.__name__
+    def f_wrapped(ctx):
+        cache = ctx._misc_const_cache
+        prec = ctx.prec
+        p,v = cache.get(name, (-1,0))
+        if p >= prec:
+            return +v
+        else:
+            cache[name] = (prec, f(ctx))
+            return cache[name][1]
+    return f_wrapped
+
+@c_memo
+def _airyai_C1(ctx):
+    return 1 / (ctx.cbrt(9) * ctx.gamma(ctx.mpf(2)/3))
+
+@c_memo
+def _airyai_C2(ctx):
+    return -1 / (ctx.cbrt(3) * ctx.gamma(ctx.mpf(1)/3))
+
+@c_memo
+def _airybi_C1(ctx):
+    return 1 / (ctx.nthroot(3,6) * ctx.gamma(ctx.mpf(2)/3))
+
+@c_memo
+def _airybi_C2(ctx):
+    return ctx.nthroot(3,6) / ctx.gamma(ctx.mpf(1)/3)
+
+def _airybi_n2_inf(ctx):
+    prec = ctx.prec
+    try:
+        v = ctx.power(3,'2/3')*ctx.gamma('2/3')/(2*ctx.pi)
+    finally:
+        ctx.prec = prec
+    return +v
+
+# Derivatives at z = 0
+# TODO: could be expressed more elegantly using triple factorials
+def _airyderiv_0(ctx, z, n, ntype, which):
+    if ntype == 'Z':
+        if n < 0:
+            return z
+        r = ctx.mpq_1_3
+        prec = ctx.prec
+        try:
+            ctx.prec += 10
+            v = ctx.gamma((n+1)*r) * ctx.power(3,n*r) / ctx.pi
+            if which == 0:
+                v *= ctx.sinpi(2*(n+1)*r)
+                v /= ctx.power(3,'2/3')
+            else:
+                v *= abs(ctx.sinpi(2*(n+1)*r))
+                v /= ctx.power(3,'1/6')
+        finally:
+            ctx.prec = prec
+        return +v + z
+    else:
+        # singular (does the limit exist?)
+        raise NotImplementedError
+
+@defun
+def airyai(ctx, z, derivative=0, **kwargs):
+    z = ctx.convert(z)
+    if derivative:
+        n, ntype = ctx._convert_param(derivative)
+    else:
+        n = 0
+    # Values at infinities
+    if not ctx.isnormal(z) and z:
+        if n and ntype == 'Z':
+            if n == -1:
+                if z == ctx.inf:
+                    return ctx.mpf(1)/3 + 1/z
+                if z == ctx.ninf:
+                    return ctx.mpf(-2)/3 + 1/z
+            if n < -1:
+                if z == ctx.inf:
+                    return z
+                if z == ctx.ninf:
+                    return (-1)**n * (-z)
+        if (not n) and z == ctx.inf or z == ctx.ninf:
+            return 1/z
+        # TODO: limits
+        raise ValueError("essential singularity of Ai(z)")
+    # Account for exponential scaling
+    if z:
+        extraprec = max(0, int(1.5*ctx.mag(z)))
+    else:
+        extraprec = 0
+    if n:
+        if n == 1:
+            def h():
+                # http://functions.wolfram.com/03.07.06.0005.01
+                if ctx._re(z) > 4:
+                    ctx.prec += extraprec
+                    w = z**1.5; r = -0.75/w; u = -2*w/3
+                    ctx.prec -= extraprec
+                    C = -ctx.exp(u)/(2*ctx.sqrt(ctx.pi))*ctx.nthroot(z,4)
+                    return ([C],[1],[],[],[(-1,6),(7,6)],[],r),
+                # http://functions.wolfram.com/03.07.26.0001.01
+                else:
+                    ctx.prec += extraprec
+                    w = z**3 / 9
+                    ctx.prec -= extraprec
+                    C1 = _airyai_C1(ctx) * 0.5
+                    C2 = _airyai_C2(ctx)
+                    T1 = [C1,z],[1,2],[],[],[],[ctx.mpq_5_3],w
+                    T2 = [C2],[1],[],[],[],[ctx.mpq_1_3],w
+                    return T1, T2
+            return ctx.hypercomb(h, [], **kwargs)
+        else:
+            if z == 0:
+                return _airyderiv_0(ctx, z, n, ntype, 0)
+            # http://functions.wolfram.com/03.05.20.0004.01
+            def h(n):
+                ctx.prec += extraprec
+                w = z**3/9
+                ctx.prec -= extraprec
+                q13,q23,q43 = ctx.mpq_1_3, ctx.mpq_2_3, ctx.mpq_4_3
+                a1=q13; a2=1; b1=(1-n)*q13; b2=(2-n)*q13; b3=1-n*q13
+                T1 = [3, z], [n-q23, -n], [a1], [b1,b2,b3], \
+                    [a1,a2], [b1,b2,b3], w
+                a1=q23; b1=(2-n)*q13; b2=1-n*q13; b3=(4-n)*q13
+                T2 = [3, z, -z], [n-q43, -n, 1], [a1], [b1,b2,b3], \
+                    [a1,a2], [b1,b2,b3], w
+                return T1, T2
+            v = ctx.hypercomb(h, [n], **kwargs)
+            if ctx._is_real_type(z) and ctx.isint(n):
+                v = ctx._re(v)
+            return v
+    else:
+        def h():
+            if ctx._re(z) > 4:
+                # We could use 1F1, but it results in huge cancellation;
+                # the following expansion is better.
+                # TODO: asymptotic series for derivatives
+                ctx.prec += extraprec
+                w = z**1.5; r = -0.75/w; u = -2*w/3
+                ctx.prec -= extraprec
+                C = ctx.exp(u)/(2*ctx.sqrt(ctx.pi)*ctx.nthroot(z,4))
+                return ([C],[1],[],[],[(1,6),(5,6)],[],r),
+            else:
+                ctx.prec += extraprec
+                w = z**3 / 9
+                ctx.prec -= extraprec
+                C1 = _airyai_C1(ctx)
+                C2 = _airyai_C2(ctx)
+                T1 = [C1],[1],[],[],[],[ctx.mpq_2_3],w
+                T2 = [z*C2],[1],[],[],[],[ctx.mpq_4_3],w
+                return T1, T2
+        return ctx.hypercomb(h, [], **kwargs)
+
+@defun
+def airybi(ctx, z, derivative=0, **kwargs):
+    z = ctx.convert(z)
+    if derivative:
+        n, ntype = ctx._convert_param(derivative)
+    else:
+        n = 0
+    # Values at infinities
+    if not ctx.isnormal(z) and z:
+        if n and ntype == 'Z':
+            if z == ctx.inf:
+                return z
+            if z == ctx.ninf:
+                if n == -1:
+                    return 1/z
+                if n == -2:
+                    return _airybi_n2_inf(ctx)
+                if n < -2:
+                    return (-1)**n * (-z)
+        if not n:
+            if z == ctx.inf:
+                return z
+            if z == ctx.ninf:
+                return 1/z
+        # TODO: limits
+        raise ValueError("essential singularity of Bi(z)")
+    if z:
+        extraprec = max(0, int(1.5*ctx.mag(z)))
+    else:
+        extraprec = 0
+    if n:
+        if n == 1:
+            # http://functions.wolfram.com/03.08.26.0001.01
+            def h():
+                ctx.prec += extraprec
+                w = z**3 / 9
+                ctx.prec -= extraprec
+                C1 = _airybi_C1(ctx)*0.5
+                C2 = _airybi_C2(ctx)
+                T1 = [C1,z],[1,2],[],[],[],[ctx.mpq_5_3],w
+                T2 = [C2],[1],[],[],[],[ctx.mpq_1_3],w
+                return T1, T2
+            return ctx.hypercomb(h, [], **kwargs)
+        else:
+            if z == 0:
+                return _airyderiv_0(ctx, z, n, ntype, 1)
+            def h(n):
+                ctx.prec += extraprec
+                w = z**3/9
+                ctx.prec -= extraprec
+                q13,q23,q43 = ctx.mpq_1_3, ctx.mpq_2_3, ctx.mpq_4_3
+                q16 = ctx.mpq_1_6
+                q56 = ctx.mpq_5_6
+                a1=q13; a2=1; b1=(1-n)*q13; b2=(2-n)*q13; b3=1-n*q13
+                T1 = [3, z], [n-q16, -n], [a1], [b1,b2,b3], \
+                    [a1,a2], [b1,b2,b3], w
+                a1=q23; b1=(2-n)*q13; b2=1-n*q13; b3=(4-n)*q13
+                T2 = [3, z], [n-q56, 1-n], [a1], [b1,b2,b3], \
+                    [a1,a2], [b1,b2,b3], w
+                return T1, T2
+            v = ctx.hypercomb(h, [n], **kwargs)
+            if ctx._is_real_type(z) and ctx.isint(n):
+                v = ctx._re(v)
+            return v
+    else:
+        def h():
+            ctx.prec += extraprec
+            w = z**3 / 9
+            ctx.prec -= extraprec
+            C1 = _airybi_C1(ctx)
+            C2 = _airybi_C2(ctx)
+            T1 = [C1],[1],[],[],[],[ctx.mpq_2_3],w
+            T2 = [z*C2],[1],[],[],[],[ctx.mpq_4_3],w
+            return T1, T2
+        return ctx.hypercomb(h, [], **kwargs)
+
+def _airy_zero(ctx, which, k, derivative, complex=False):
+    # Asymptotic formulas are given in DLMF section 9.9
+    def U(t): return t**(2/3.)*(1-7/(t**2*48))
+    def T(t): return t**(2/3.)*(1+5/(t**2*48))
+    k = int(k)
+    if k < 1:
+        raise ValueError("k cannot be less than 1")
+    if not derivative in (0,1):
+        raise ValueError("Derivative should lie between 0 and 1")
+    if which == 0:
+        if derivative:
+            return ctx.findroot(lambda z: ctx.airyai(z,1),
+                -U(3*ctx.pi*(4*k-3)/8))
+        return ctx.findroot(ctx.airyai, -T(3*ctx.pi*(4*k-1)/8))
+    if which == 1 and complex == False:
+        if derivative:
+            return ctx.findroot(lambda z: ctx.airybi(z,1),
+                -U(3*ctx.pi*(4*k-1)/8))
+        return ctx.findroot(ctx.airybi, -T(3*ctx.pi*(4*k-3)/8))
+    if which == 1 and complex == True:
+        if derivative:
+            t = 3*ctx.pi*(4*k-3)/8 + 0.75j*ctx.ln2
+            s = ctx.expjpi(ctx.mpf(1)/3) * T(t)
+            return ctx.findroot(lambda z: ctx.airybi(z,1), s)
+        t = 3*ctx.pi*(4*k-1)/8 + 0.75j*ctx.ln2
+        s = ctx.expjpi(ctx.mpf(1)/3) * U(t)
+        return ctx.findroot(ctx.airybi, s)
+
+@defun
+def airyaizero(ctx, k, derivative=0):
+    return _airy_zero(ctx, 0, k, derivative, False)
+
+@defun
+def airybizero(ctx, k, derivative=0, complex=False):
+    return _airy_zero(ctx, 1, k, derivative, complex)
+
+def _scorer(ctx, z, which, kwargs):
+    z = ctx.convert(z)
+    if ctx.isinf(z):
+        if z == ctx.inf:
+            if which == 0: return 1/z
+            if which == 1: return z
+        if z == ctx.ninf:
+            return 1/z
+        raise ValueError("essential singularity")
+    if z:
+        extraprec = max(0, int(1.5*ctx.mag(z)))
+    else:
+        extraprec = 0
+    if kwargs.get('derivative'):
+        raise NotImplementedError
+    # Direct asymptotic expansions, to avoid
+    # exponentially large cancellation
+    try:
+        if ctx.mag(z) > 3:
+            if which == 0 and abs(ctx.arg(z)) < ctx.pi/3 * 0.999:
+                def h():
+                    return (([ctx.pi,z],[-1,-1],[],[],[(1,3),(2,3),1],[],9/z**3),)
+                return ctx.hypercomb(h, [], maxterms=ctx.prec, force_series=True)
+            if which == 1 and abs(ctx.arg(-z)) < 2*ctx.pi/3 * 0.999:
+                def h():
+                    return (([-ctx.pi,z],[-1,-1],[],[],[(1,3),(2,3),1],[],9/z**3),)
+                return ctx.hypercomb(h, [], maxterms=ctx.prec, force_series=True)
+    except ctx.NoConvergence:
+        pass
+    def h():
+        A = ctx.airybi(z, **kwargs)/3
+        B = -2*ctx.pi
+        if which == 1:
+            A *= 2
+            B *= -1
+        ctx.prec += extraprec
+        w = z**3/9
+        ctx.prec -= extraprec
+        T1 = [A], [1], [], [], [], [], 0
+        T2 = [B,z], [-1,2], [], [], [1], [ctx.mpq_4_3,ctx.mpq_5_3], w
+        return T1, T2
+    return ctx.hypercomb(h, [], **kwargs)
+
+@defun
+def scorergi(ctx, z, **kwargs):
+    return _scorer(ctx, z, 0, kwargs)
+
+@defun
+def scorerhi(ctx, z, **kwargs):
+    return _scorer(ctx, z, 1, kwargs)
+
+@defun_wrapped
+def coulombc(ctx, l, eta, _cache={}):
+    if (l, eta) in _cache and _cache[l,eta][0] >= ctx.prec:
+        return +_cache[l,eta][1]
+    G3 = ctx.loggamma(2*l+2)
+    G1 = ctx.loggamma(1+l+ctx.j*eta)
+    G2 = ctx.loggamma(1+l-ctx.j*eta)
+    v = 2**l * ctx.exp((-ctx.pi*eta+G1+G2)/2 - G3)
+    if not (ctx.im(l) or ctx.im(eta)):
+        v = ctx.re(v)
+    _cache[l,eta] = (ctx.prec, v)
+    return v
+
+@defun_wrapped
+def coulombf(ctx, l, eta, z, w=1, chop=True, **kwargs):
+    # Regular Coulomb wave function
+    # Note: w can be either 1 or -1; the other may be better in some cases
+    # TODO: check that chop=True chops when and only when it should
+    #ctx.prec += 10
+    def h(l, eta):
+        try:
+            jw = ctx.j*w
+            jwz = ctx.fmul(jw, z, exact=True)
+            jwz2 = ctx.fmul(jwz, -2, exact=True)
+            C = ctx.coulombc(l, eta)
+            T1 = [C, z, ctx.exp(jwz)], [1, l+1, 1], [], [], [1+l+jw*eta], \
+                [2*l+2], jwz2
+        except ValueError:
+            T1 = [0], [-1], [], [], [], [], 0
+        return (T1,)
+    v = ctx.hypercomb(h, [l,eta], **kwargs)
+    if chop and (not ctx.im(l)) and (not ctx.im(eta)) and (not ctx.im(z)) and \
+        (ctx.re(z) >= 0):
+        v = ctx.re(v)
+    return v
+
+@defun_wrapped
+def _coulomb_chi(ctx, l, eta, _cache={}):
+    if (l, eta) in _cache and _cache[l,eta][0] >= ctx.prec:
+        return _cache[l,eta][1]
+    def terms():
+        l2 = -l-1
+        jeta = ctx.j*eta
+        return [ctx.loggamma(1+l+jeta) * (-0.5j),
+            ctx.loggamma(1+l-jeta) * (0.5j),
+            ctx.loggamma(1+l2+jeta) * (0.5j),
+            ctx.loggamma(1+l2-jeta) * (-0.5j),
+            -(l+0.5)*ctx.pi]
+    v = ctx.sum_accurately(terms, 1)
+    _cache[l,eta] = (ctx.prec, v)
+    return v
+
+@defun_wrapped
+def coulombg(ctx, l, eta, z, w=1, chop=True, **kwargs):
+    # Irregular Coulomb wave function
+    # Note: w can be either 1 or -1; the other may be better in some cases
+    # TODO: check that chop=True chops when and only when it should
+    if not ctx._im(l):
+        l = ctx._re(l)  # XXX: for isint
+    def h(l, eta):
+        # Force perturbation for integers and half-integers
+        if ctx.isint(l*2):
+            T1 = [0], [-1], [], [], [], [], 0
+            return (T1,)
+        l2 = -l-1
+        try:
+            chi = ctx._coulomb_chi(l, eta)
+            jw = ctx.j*w
+            s = ctx.sin(chi); c = ctx.cos(chi)
+            C1 = ctx.coulombc(l,eta)
+            C2 = ctx.coulombc(l2,eta)
+            u = ctx.exp(jw*z)
+            x = -2*jw*z
+            T1 = [s, C1, z, u, c], [-1, 1, l+1, 1, 1], [], [], \
+                [1+l+jw*eta], [2*l+2], x
+            T2 = [-s, C2, z, u],   [-1, 1, l2+1, 1],    [], [], \
+                [1+l2+jw*eta], [2*l2+2], x
+            return T1, T2
+        except ValueError:
+            T1 = [0], [-1], [], [], [], [], 0
+            return (T1,)
+    v = ctx.hypercomb(h, [l,eta], **kwargs)
+    if chop and (not ctx._im(l)) and (not ctx._im(eta)) and (not ctx._im(z)) and \
+        (ctx._re(z) >= 0):
+        v = ctx._re(v)
+    return v
+
+def mcmahon(ctx,kind,prime,v,m):
+    """
+    Computes an estimate for the location of the Bessel function zero
+    j_{v,m}, y_{v,m}, j'_{v,m} or y'_{v,m} using McMahon's asymptotic
+    expansion (Abramowitz & Stegun 9.5.12-13, DLMF 20.21(vi)).
+
+    Returns (r,err) where r is the estimated location of the root
+    and err is a positive number estimating the error of the
+    asymptotic expansion.
+    """
+    u = 4*v**2
+    if kind == 1 and not prime: b = (4*m+2*v-1)*ctx.pi/4
+    if kind == 2 and not prime: b = (4*m+2*v-3)*ctx.pi/4
+    if kind == 1 and prime: b = (4*m+2*v-3)*ctx.pi/4
+    if kind == 2 and prime: b = (4*m+2*v-1)*ctx.pi/4
+    if not prime:
+        s1 = b
+        s2 = -(u-1)/(8*b)
+        s3 = -4*(u-1)*(7*u-31)/(3*(8*b)**3)
+        s4 = -32*(u-1)*(83*u**2-982*u+3779)/(15*(8*b)**5)
+        s5 = -64*(u-1)*(6949*u**3-153855*u**2+1585743*u-6277237)/(105*(8*b)**7)
+    if prime:
+        s1 = b
+        s2 = -(u+3)/(8*b)
+        s3 = -4*(7*u**2+82*u-9)/(3*(8*b)**3)
+        s4 = -32*(83*u**3+2075*u**2-3039*u+3537)/(15*(8*b)**5)
+        s5 = -64*(6949*u**4+296492*u**3-1248002*u**2+7414380*u-5853627)/(105*(8*b)**7)
+    terms = [s1,s2,s3,s4,s5]
+    s = s1
+    err = 0.0
+    for i in range(1,len(terms)):
+        if abs(terms[i]) < abs(terms[i-1]):
+            s += terms[i]
+        else:
+            err = abs(terms[i])
+    if i == len(terms)-1:
+        err = abs(terms[-1])
+    return s, err
+
+def generalized_bisection(ctx,f,a,b,n):
+    """
+    Given f known to have exactly n simple roots within [a,b],
+    return a list of n intervals isolating the roots
+    and having opposite signs at the endpoints.
+
+    TODO: this can be optimized, e.g. by reusing evaluation points.
+    """
+    if n < 1:
+        raise ValueError("n cannot be less than 1")
+    N = n+1
+    points = []
+    signs = []
+    while 1:
+        points = ctx.linspace(a,b,N)
+        signs = [ctx.sign(f(x)) for x in points]
+        ok_intervals = [(points[i],points[i+1]) for i in range(N-1) \
+            if signs[i]*signs[i+1] == -1]
+        if len(ok_intervals) == n:
+            return ok_intervals
+        N = N*2
+
+def find_in_interval(ctx, f, ab):
+    return ctx.findroot(f, ab, solver='illinois', verify=False)
+
+def bessel_zero(ctx, kind, prime, v, m, isoltol=0.01, _interval_cache={}):
+    prec = ctx.prec
+    workprec = max(prec, ctx.mag(v), ctx.mag(m))+10
+    try:
+        ctx.prec = workprec
+        v = ctx.mpf(v)
+        m = int(m)
+        prime = int(prime)
+        if v < 0:
+            raise ValueError("v cannot be negative")
+        if m < 1:
+            raise ValueError("m cannot be less than 1")
+        if not prime in (0,1):
+            raise ValueError("prime should lie between 0 and 1")
+        if kind == 1:
+            if prime: f = lambda x: ctx.besselj(v,x,derivative=1)
+            else:     f = lambda x: ctx.besselj(v,x)
+        if kind == 2:
+            if prime: f = lambda x: ctx.bessely(v,x,derivative=1)
+            else:     f = lambda x: ctx.bessely(v,x)
+        # The first root of J' is very close to 0 for small
+        # orders, and this needs to be special-cased
+        if kind == 1 and prime and m == 1:
+            if v == 0:
+                return ctx.zero
+            if v <= 1:
+                # TODO: use v <= j'_{v,1} < y_{v,1}?
+                r = 2*ctx.sqrt(v*(1+v)/(v+2))
+                return find_in_interval(ctx, f, (r/10, 2*r))
+        if (kind,prime,v,m) in _interval_cache:
+            return find_in_interval(ctx, f, _interval_cache[kind,prime,v,m])
+        r, err = mcmahon(ctx, kind, prime, v, m)
+        if err < isoltol:
+            return find_in_interval(ctx, f, (r-isoltol, r+isoltol))
+        # An x such that 0 < x < r_{v,1}
+        if kind == 1 and not prime: low = 2.4
+        if kind == 1 and prime: low = 1.8
+        if kind == 2 and not prime: low = 0.8
+        if kind == 2 and prime: low = 2.0
+        n = m+1
+        while 1:
+            r1, err = mcmahon(ctx, kind, prime, v, n)
+            if err < isoltol:
+                r2, err2 = mcmahon(ctx, kind, prime, v, n+1)
+                intervals = generalized_bisection(ctx, f, low, 0.5*(r1+r2), n)
+                for k, ab in enumerate(intervals):
+                    _interval_cache[kind,prime,v,k+1] = ab
+                return find_in_interval(ctx, f, intervals[m-1])
+            else:
+                n = n*2
+    finally:
+        ctx.prec = prec
+
+@defun
+def besseljzero(ctx, v, m, derivative=0):
+    r"""
+    For a real order `\nu \ge 0` and a positive integer `m`, returns
+    `j_{\nu,m}`, the `m`-th positive zero of the Bessel function of the
+    first kind `J_{\nu}(z)` (see :func:`~mpmath.besselj`). Alternatively,
+    with *derivative=1*, gives the first nonnegative simple zero
+    `j'_{\nu,m}` of `J'_{\nu}(z)`.
+
+    The indexing convention is that used by Abramowitz & Stegun
+    and the DLMF. Note the special case `j'_{0,1} = 0`, while all other
+    zeros are positive. In effect, only simple zeros are counted
+    (all zeros of Bessel functions are simple except possibly `z = 0`)
+    and `j_{\nu,m}` becomes a monotonic function of both `\nu`
+    and `m`.
+
+    The zeros are interlaced according to the inequalities
+
+    .. math ::
+
+        j'_{\nu,k} < j_{\nu,k} < j'_{\nu,k+1}
+
+        j_{\nu,1} < j_{\nu+1,2} < j_{\nu,2} < j_{\nu+1,2} < j_{\nu,3} < \cdots
+
+    **Examples**
+
+    Initial zeros of the Bessel functions `J_0(z), J_1(z), J_2(z)`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> besseljzero(0,1); besseljzero(0,2); besseljzero(0,3)
+        2.404825557695772768621632
+        5.520078110286310649596604
+        8.653727912911012216954199
+        >>> besseljzero(1,1); besseljzero(1,2); besseljzero(1,3)
+        3.831705970207512315614436
+        7.01558666981561875353705
+        10.17346813506272207718571
+        >>> besseljzero(2,1); besseljzero(2,2); besseljzero(2,3)
+        5.135622301840682556301402
+        8.417244140399864857783614
+        11.61984117214905942709415
+
+    Initial zeros of `J'_0(z), J'_1(z), J'_2(z)`::
+
+        0.0
+        3.831705970207512315614436
+        7.01558666981561875353705
+        >>> besseljzero(1,1,1); besseljzero(1,2,1); besseljzero(1,3,1)
+        1.84118378134065930264363
+        5.331442773525032636884016
+        8.536316366346285834358961
+        >>> besseljzero(2,1,1); besseljzero(2,2,1); besseljzero(2,3,1)
+        3.054236928227140322755932
+        6.706133194158459146634394
+        9.969467823087595793179143
+
+    Zeros with large index::
+
+        >>> besseljzero(0,100); besseljzero(0,1000); besseljzero(0,10000)
+        313.3742660775278447196902
+        3140.807295225078628895545
+        31415.14114171350798533666
+        >>> besseljzero(5,100); besseljzero(5,1000); besseljzero(5,10000)
+        321.1893195676003157339222
+        3148.657306813047523500494
+        31422.9947255486291798943
+        >>> besseljzero(0,100,1); besseljzero(0,1000,1); besseljzero(0,10000,1)
+        311.8018681873704508125112
+        3139.236339643802482833973
+        31413.57032947022399485808
+
+    Zeros of functions with large order::
+
+        >>> besseljzero(50,1)
+        57.11689916011917411936228
+        >>> besseljzero(50,2)
+        62.80769876483536093435393
+        >>> besseljzero(50,100)
+        388.6936600656058834640981
+        >>> besseljzero(50,1,1)
+        52.99764038731665010944037
+        >>> besseljzero(50,2,1)
+        60.02631933279942589882363
+        >>> besseljzero(50,100,1)
+        387.1083151608726181086283
+
+    Zeros of functions with fractional order::
+
+        >>> besseljzero(0.5,1); besseljzero(1.5,1); besseljzero(2.25,4)
+        3.141592653589793238462643
+        4.493409457909064175307881
+        15.15657692957458622921634
+
+    Both `J_{\nu}(z)` and `J'_{\nu}(z)` can be expressed as infinite
+    products over their zeros::
+
+        >>> v,z = 2, mpf(1)
+        >>> (z/2)**v/gamma(v+1) * \
+        ...     nprod(lambda k: 1-(z/besseljzero(v,k))**2, [1,inf])
+        ...
+        0.1149034849319004804696469
+        >>> besselj(v,z)
+        0.1149034849319004804696469
+        >>> (z/2)**(v-1)/2/gamma(v) * \
+        ...     nprod(lambda k: 1-(z/besseljzero(v,k,1))**2, [1,inf])
+        ...
+        0.2102436158811325550203884
+        >>> besselj(v,z,1)
+        0.2102436158811325550203884
+
+    """
+    return +bessel_zero(ctx, 1, derivative, v, m)
+
+@defun
+def besselyzero(ctx, v, m, derivative=0):
+    r"""
+    For a real order `\nu \ge 0` and a positive integer `m`, returns
+    `y_{\nu,m}`, the `m`-th positive zero of the Bessel function of the
+    second kind `Y_{\nu}(z)` (see :func:`~mpmath.bessely`). Alternatively,
+    with *derivative=1*, gives the first positive zero `y'_{\nu,m}` of
+    `Y'_{\nu}(z)`.
+
+    The zeros are interlaced according to the inequalities
+
+    .. math ::
+
+        y_{\nu,k} < y'_{\nu,k} < y_{\nu,k+1}
+
+        y_{\nu,1} < y_{\nu+1,2} < y_{\nu,2} < y_{\nu+1,2} < y_{\nu,3} < \cdots
+
+    **Examples**
+
+    Initial zeros of the Bessel functions `Y_0(z), Y_1(z), Y_2(z)`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> besselyzero(0,1); besselyzero(0,2); besselyzero(0,3)
+        0.8935769662791675215848871
+        3.957678419314857868375677
+        7.086051060301772697623625
+        >>> besselyzero(1,1); besselyzero(1,2); besselyzero(1,3)
+        2.197141326031017035149034
+        5.429681040794135132772005
+        8.596005868331168926429606
+        >>> besselyzero(2,1); besselyzero(2,2); besselyzero(2,3)
+        3.384241767149593472701426
+        6.793807513268267538291167
+        10.02347797936003797850539
+
+    Initial zeros of `Y'_0(z), Y'_1(z), Y'_2(z)`::
+
+        >>> besselyzero(0,1,1); besselyzero(0,2,1); besselyzero(0,3,1)
+        2.197141326031017035149034
+        5.429681040794135132772005
+        8.596005868331168926429606
+        >>> besselyzero(1,1,1); besselyzero(1,2,1); besselyzero(1,3,1)
+        3.683022856585177699898967
+        6.941499953654175655751944
+        10.12340465543661307978775
+        >>> besselyzero(2,1,1); besselyzero(2,2,1); besselyzero(2,3,1)
+        5.002582931446063945200176
+        8.350724701413079526349714
+        11.57419546521764654624265
+
+    Zeros with large index::
+
+        >>> besselyzero(0,100); besselyzero(0,1000); besselyzero(0,10000)
+        311.8034717601871549333419
+        3139.236498918198006794026
+        31413.57034538691205229188
+        >>> besselyzero(5,100); besselyzero(5,1000); besselyzero(5,10000)
+        319.6183338562782156235062
+        3147.086508524556404473186
+        31421.42392920214673402828
+        >>> besselyzero(0,100,1); besselyzero(0,1000,1); besselyzero(0,10000,1)
+        313.3726705426359345050449
+        3140.807136030340213610065
+        31415.14112579761578220175
+
+    Zeros of functions with large order::
+
+        >>> besselyzero(50,1)
+        53.50285882040036394680237
+        >>> besselyzero(50,2)
+        60.11244442774058114686022
+        >>> besselyzero(50,100)
+        387.1096509824943957706835
+        >>> besselyzero(50,1,1)
+        56.96290427516751320063605
+        >>> besselyzero(50,2,1)
+        62.74888166945933944036623
+        >>> besselyzero(50,100,1)
+        388.6923300548309258355475
+
+    Zeros of functions with fractional order::
+
+        >>> besselyzero(0.5,1); besselyzero(1.5,1); besselyzero(2.25,4)
+        1.570796326794896619231322
+        2.798386045783887136720249
+        13.56721208770735123376018
+
+    """
+    return +bessel_zero(ctx, 2, derivative, v, m)
diff --git a/lib/python3.10/site-packages/mpmath/functions/elliptic.py b/lib/python3.10/site-packages/mpmath/functions/elliptic.py
new file mode 100644
index 0000000000000000000000000000000000000000..1e198697fa042b7cc8bcba9e9e770f5c8106dad6
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/functions/elliptic.py
@@ -0,0 +1,1431 @@
+r"""
+Elliptic functions historically comprise the elliptic integrals
+and their inverses, and originate from the problem of computing the
+arc length of an ellipse. From a more modern point of view,
+an elliptic function is defined as a doubly periodic function, i.e.
+a function which satisfies
+
+.. math ::
+
+    f(z + 2 \omega_1) = f(z + 2 \omega_2) = f(z)
+
+for some half-periods `\omega_1, \omega_2` with
+`\mathrm{Im}[\omega_1 / \omega_2] > 0`. The canonical elliptic
+functions are the Jacobi elliptic functions. More broadly, this section
+includes  quasi-doubly periodic functions (such as the Jacobi theta
+functions) and other functions useful in the study of elliptic functions.
+
+Many different conventions for the arguments of
+elliptic functions are in use. It is even standard to use
+different parameterizations for different functions in the same
+text or software (and mpmath is no exception).
+The usual parameters are the elliptic nome `q`, which usually
+must satisfy `|q| < 1`; the elliptic parameter `m` (an arbitrary
+complex number); the elliptic modulus `k` (an arbitrary complex
+number); and the half-period ratio `\tau`, which usually must
+satisfy `\mathrm{Im}[\tau] > 0`.
+These quantities can be expressed in terms of each other
+using the following relations:
+
+.. math ::
+
+    m = k^2
+
+.. math ::
+
+    \tau = i \frac{K(1-m)}{K(m)}
+
+.. math ::
+
+    q = e^{i \pi \tau}
+
+.. math ::
+
+    k = \frac{\vartheta_2^2(q)}{\vartheta_3^2(q)}
+
+In addition, an alternative definition is used for the nome in
+number theory, which we here denote by q-bar:
+
+.. math ::
+
+    \bar{q} = q^2 = e^{2 i \pi \tau}
+
+For convenience, mpmath provides functions to convert
+between the various parameters (:func:`~mpmath.qfrom`, :func:`~mpmath.mfrom`,
+:func:`~mpmath.kfrom`, :func:`~mpmath.taufrom`, :func:`~mpmath.qbarfrom`).
+
+**References**
+
+1. [AbramowitzStegun]_
+
+2. [WhittakerWatson]_
+
+"""
+
+from .functions import defun, defun_wrapped
+
+@defun_wrapped
+def eta(ctx, tau):
+    r"""
+    Returns the Dedekind eta function of tau in the upper half-plane.
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> eta(1j); gamma(0.25) / (2*pi**0.75)
+        (0.7682254223260566590025942 + 0.0j)
+        0.7682254223260566590025942
+        >>> tau = sqrt(2) + sqrt(5)*1j
+        >>> eta(-1/tau); sqrt(-1j*tau) * eta(tau)
+        (0.9022859908439376463573294 + 0.07985093673948098408048575j)
+        (0.9022859908439376463573295 + 0.07985093673948098408048575j)
+        >>> eta(tau+1); exp(pi*1j/12) * eta(tau)
+        (0.4493066139717553786223114 + 0.3290014793877986663915939j)
+        (0.4493066139717553786223114 + 0.3290014793877986663915939j)
+        >>> f = lambda z: diff(eta, z) / eta(z)
+        >>> chop(36*diff(f,tau)**2 - 24*diff(f,tau,2)*f(tau) + diff(f,tau,3))
+        0.0
+
+    """
+    if ctx.im(tau) <= 0.0:
+        raise ValueError("eta is only defined in the upper half-plane")
+    q = ctx.expjpi(tau/12)
+    return q * ctx.qp(q**24)
+
+def nome(ctx, m):
+    m = ctx.convert(m)
+    if not m:
+        return m
+    if m == ctx.one:
+        return m
+    if ctx.isnan(m):
+        return m
+    if ctx.isinf(m):
+        if m == ctx.ninf:
+            return type(m)(-1)
+        else:
+            return ctx.mpc(-1)
+    a = ctx.ellipk(ctx.one-m)
+    b = ctx.ellipk(m)
+    v = ctx.exp(-ctx.pi*a/b)
+    if not ctx._im(m) and ctx._re(m) < 1:
+        if ctx._is_real_type(m):
+            return v.real
+        else:
+            return v.real + 0j
+    elif m == 2:
+        v = ctx.mpc(0, v.imag)
+    return v
+
+@defun_wrapped
+def qfrom(ctx, q=None, m=None, k=None, tau=None, qbar=None):
+    r"""
+    Returns the elliptic nome `q`, given any of `q, m, k, \tau, \bar{q}`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> qfrom(q=0.25)
+        0.25
+        >>> qfrom(m=mfrom(q=0.25))
+        0.25
+        >>> qfrom(k=kfrom(q=0.25))
+        0.25
+        >>> qfrom(tau=taufrom(q=0.25))
+        (0.25 + 0.0j)
+        >>> qfrom(qbar=qbarfrom(q=0.25))
+        0.25
+
+    """
+    if q is not None:
+        return ctx.convert(q)
+    if m is not None:
+        return nome(ctx, m)
+    if k is not None:
+        return nome(ctx, ctx.convert(k)**2)
+    if tau is not None:
+        return ctx.expjpi(tau)
+    if qbar is not None:
+        return ctx.sqrt(qbar)
+
+@defun_wrapped
+def qbarfrom(ctx, q=None, m=None, k=None, tau=None, qbar=None):
+    r"""
+    Returns the number-theoretic nome `\bar q`, given any of
+    `q, m, k, \tau, \bar{q}`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> qbarfrom(qbar=0.25)
+        0.25
+        >>> qbarfrom(q=qfrom(qbar=0.25))
+        0.25
+        >>> qbarfrom(m=extraprec(20)(mfrom)(qbar=0.25))  # ill-conditioned
+        0.25
+        >>> qbarfrom(k=extraprec(20)(kfrom)(qbar=0.25))  # ill-conditioned
+        0.25
+        >>> qbarfrom(tau=taufrom(qbar=0.25))
+        (0.25 + 0.0j)
+
+    """
+    if qbar is not None:
+        return ctx.convert(qbar)
+    if q is not None:
+        return ctx.convert(q) ** 2
+    if m is not None:
+        return nome(ctx, m) ** 2
+    if k is not None:
+        return nome(ctx, ctx.convert(k)**2) ** 2
+    if tau is not None:
+        return ctx.expjpi(2*tau)
+
+@defun_wrapped
+def taufrom(ctx, q=None, m=None, k=None, tau=None, qbar=None):
+    r"""
+    Returns the elliptic half-period ratio `\tau`, given any of
+    `q, m, k, \tau, \bar{q}`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> taufrom(tau=0.5j)
+        (0.0 + 0.5j)
+        >>> taufrom(q=qfrom(tau=0.5j))
+        (0.0 + 0.5j)
+        >>> taufrom(m=mfrom(tau=0.5j))
+        (0.0 + 0.5j)
+        >>> taufrom(k=kfrom(tau=0.5j))
+        (0.0 + 0.5j)
+        >>> taufrom(qbar=qbarfrom(tau=0.5j))
+        (0.0 + 0.5j)
+
+    """
+    if tau is not None:
+        return ctx.convert(tau)
+    if m is not None:
+        m = ctx.convert(m)
+        return ctx.j*ctx.ellipk(1-m)/ctx.ellipk(m)
+    if k is not None:
+        k = ctx.convert(k)
+        return ctx.j*ctx.ellipk(1-k**2)/ctx.ellipk(k**2)
+    if q is not None:
+        return ctx.log(q) / (ctx.pi*ctx.j)
+    if qbar is not None:
+        qbar = ctx.convert(qbar)
+        return ctx.log(qbar) / (2*ctx.pi*ctx.j)
+
+@defun_wrapped
+def kfrom(ctx, q=None, m=None, k=None, tau=None, qbar=None):
+    r"""
+    Returns the elliptic modulus `k`, given any of
+    `q, m, k, \tau, \bar{q}`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> kfrom(k=0.25)
+        0.25
+        >>> kfrom(m=mfrom(k=0.25))
+        0.25
+        >>> kfrom(q=qfrom(k=0.25))
+        0.25
+        >>> kfrom(tau=taufrom(k=0.25))
+        (0.25 + 0.0j)
+        >>> kfrom(qbar=qbarfrom(k=0.25))
+        0.25
+
+    As `q \to 1` and `q \to -1`, `k` rapidly approaches
+    `1` and `i \infty` respectively::
+
+        >>> kfrom(q=0.75)
+        0.9999999999999899166471767
+        >>> kfrom(q=-0.75)
+        (0.0 + 7041781.096692038332790615j)
+        >>> kfrom(q=1)
+        1
+        >>> kfrom(q=-1)
+        (0.0 + +infj)
+    """
+    if k is not None:
+        return ctx.convert(k)
+    if m is not None:
+        return ctx.sqrt(m)
+    if tau is not None:
+        q = ctx.expjpi(tau)
+    if qbar is not None:
+        q = ctx.sqrt(qbar)
+    if q == 1:
+        return q
+    if q == -1:
+        return ctx.mpc(0,'inf')
+    return (ctx.jtheta(2,0,q)/ctx.jtheta(3,0,q))**2
+
+@defun_wrapped
+def mfrom(ctx, q=None, m=None, k=None, tau=None, qbar=None):
+    r"""
+    Returns the elliptic parameter `m`, given any of
+    `q, m, k, \tau, \bar{q}`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> mfrom(m=0.25)
+        0.25
+        >>> mfrom(q=qfrom(m=0.25))
+        0.25
+        >>> mfrom(k=kfrom(m=0.25))
+        0.25
+        >>> mfrom(tau=taufrom(m=0.25))
+        (0.25 + 0.0j)
+        >>> mfrom(qbar=qbarfrom(m=0.25))
+        0.25
+
+    As `q \to 1` and `q \to -1`, `m` rapidly approaches
+    `1` and `-\infty` respectively::
+
+        >>> mfrom(q=0.75)
+        0.9999999999999798332943533
+        >>> mfrom(q=-0.75)
+        -49586681013729.32611558353
+        >>> mfrom(q=1)
+        1.0
+        >>> mfrom(q=-1)
+        -inf
+
+    The inverse nome as a function of `q` has an integer
+    Taylor series expansion::
+
+        >>> taylor(lambda q: mfrom(q), 0, 7)
+        [0.0, 16.0, -128.0, 704.0, -3072.0, 11488.0, -38400.0, 117632.0]
+
+    """
+    if m is not None:
+        return m
+    if k is not None:
+        return k**2
+    if tau is not None:
+        q = ctx.expjpi(tau)
+    if qbar is not None:
+        q = ctx.sqrt(qbar)
+    if q == 1:
+        return ctx.convert(q)
+    if q == -1:
+        return q*ctx.inf
+    v = (ctx.jtheta(2,0,q)/ctx.jtheta(3,0,q))**4
+    if ctx._is_real_type(q) and q < 0:
+        v = v.real
+    return v
+
+jacobi_spec = {
+  'sn' : ([3],[2],[1],[4], 'sin', 'tanh'),
+  'cn' : ([4],[2],[2],[4], 'cos', 'sech'),
+  'dn' : ([4],[3],[3],[4], '1', 'sech'),
+  'ns' : ([2],[3],[4],[1], 'csc', 'coth'),
+  'nc' : ([2],[4],[4],[2], 'sec', 'cosh'),
+  'nd' : ([3],[4],[4],[3], '1', 'cosh'),
+  'sc' : ([3],[4],[1],[2], 'tan', 'sinh'),
+  'sd' : ([3,3],[2,4],[1],[3], 'sin', 'sinh'),
+  'cd' : ([3],[2],[2],[3], 'cos', '1'),
+  'cs' : ([4],[3],[2],[1], 'cot', 'csch'),
+  'dc' : ([2],[3],[3],[2], 'sec', '1'),
+  'ds' : ([2,4],[3,3],[3],[1], 'csc', 'csch'),
+  'cc' : None,
+  'ss' : None,
+  'nn' : None,
+  'dd' : None
+}
+
+@defun
+def ellipfun(ctx, kind, u=None, m=None, q=None, k=None, tau=None):
+    try:
+        S = jacobi_spec[kind]
+    except KeyError:
+        raise ValueError("First argument must be a two-character string "
+            "containing 's', 'c', 'd' or 'n', e.g.: 'sn'")
+    if u is None:
+        def f(*args, **kwargs):
+            return ctx.ellipfun(kind, *args, **kwargs)
+        f.__name__ = kind
+        return f
+    prec = ctx.prec
+    try:
+        ctx.prec += 10
+        u = ctx.convert(u)
+        q = ctx.qfrom(m=m, q=q, k=k, tau=tau)
+        if S is None:
+            v = ctx.one + 0*q*u
+        elif q == ctx.zero:
+            if S[4] == '1': v = ctx.one
+            else:           v = getattr(ctx, S[4])(u)
+            v += 0*q*u
+        elif q == ctx.one:
+            if S[5] == '1': v = ctx.one
+            else:           v = getattr(ctx, S[5])(u)
+            v += 0*q*u
+        else:
+            t = u / ctx.jtheta(3, 0, q)**2
+            v = ctx.one
+            for a in S[0]: v *= ctx.jtheta(a, 0, q)
+            for b in S[1]: v /= ctx.jtheta(b, 0, q)
+            for c in S[2]: v *= ctx.jtheta(c, t, q)
+            for d in S[3]: v /= ctx.jtheta(d, t, q)
+    finally:
+        ctx.prec = prec
+    return +v
+
+@defun_wrapped
+def kleinj(ctx, tau=None, **kwargs):
+    r"""
+    Evaluates the Klein j-invariant, which is a modular function defined for
+    `\tau` in the upper half-plane as
+
+    .. math ::
+
+        J(\tau) = \frac{g_2^3(\tau)}{g_2^3(\tau) - 27 g_3^2(\tau)}
+
+    where `g_2` and `g_3` are the modular invariants of the Weierstrass
+    elliptic function,
+
+    .. math ::
+
+        g_2(\tau) = 60 \sum_{(m,n) \in \mathbb{Z}^2 \setminus (0,0)} (m \tau+n)^{-4}
+
+        g_3(\tau) = 140 \sum_{(m,n) \in \mathbb{Z}^2 \setminus (0,0)} (m \tau+n)^{-6}.
+
+    An alternative, common notation is that of the j-function
+    `j(\tau) = 1728 J(\tau)`.
+
+    **Plots**
+
+    .. literalinclude :: /plots/kleinj.py
+    .. image :: /plots/kleinj.png
+    .. literalinclude :: /plots/kleinj2.py
+    .. image :: /plots/kleinj2.png
+
+    **Examples**
+
+    Verifying the functional equation `J(\tau) = J(\tau+1) = J(-\tau^{-1})`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> tau = 0.625+0.75*j
+        >>> tau = 0.625+0.75*j
+        >>> kleinj(tau)
+        (-0.1507492166511182267125242 + 0.07595948379084571927228948j)
+        >>> kleinj(tau+1)
+        (-0.1507492166511182267125242 + 0.07595948379084571927228948j)
+        >>> kleinj(-1/tau)
+        (-0.1507492166511182267125242 + 0.07595948379084571927228946j)
+
+    The j-function has a famous Laurent series expansion in terms of the nome
+    `\bar{q}`, `j(\tau) = \bar{q}^{-1} + 744 + 196884\bar{q} + \ldots`::
+
+        >>> mp.dps = 15
+        >>> taylor(lambda q: 1728*q*kleinj(qbar=q), 0, 5, singular=True)
+        [1.0, 744.0, 196884.0, 21493760.0, 864299970.0, 20245856256.0]
+
+    The j-function admits exact evaluation at special algebraic points
+    related to the Heegner numbers 1, 2, 3, 7, 11, 19, 43, 67, 163::
+
+        >>> @extraprec(10)
+        ... def h(n):
+        ...     v = (1+sqrt(n)*j)
+        ...     if n > 2:
+        ...         v *= 0.5
+        ...     return v
+        ...
+        >>> mp.dps = 25
+        >>> for n in [1,2,3,7,11,19,43,67,163]:
+        ...     n, chop(1728*kleinj(h(n)))
+        ...
+        (1, 1728.0)
+        (2, 8000.0)
+        (3, 0.0)
+        (7, -3375.0)
+        (11, -32768.0)
+        (19, -884736.0)
+        (43, -884736000.0)
+        (67, -147197952000.0)
+        (163, -262537412640768000.0)
+
+    Also at other special points, the j-function assumes explicit
+    algebraic values, e.g.::
+
+        >>> chop(1728*kleinj(j*sqrt(5)))
+        1264538.909475140509320227
+        >>> identify(cbrt(_))      # note: not simplified
+        '((100+sqrt(13520))/2)'
+        >>> (50+26*sqrt(5))**3
+        1264538.909475140509320227
+
+    """
+    q = ctx.qfrom(tau=tau, **kwargs)
+    t2 = ctx.jtheta(2,0,q)
+    t3 = ctx.jtheta(3,0,q)
+    t4 = ctx.jtheta(4,0,q)
+    P = (t2**8 + t3**8 + t4**8)**3
+    Q = 54*(t2*t3*t4)**8
+    return P/Q
+
+
+def RF_calc(ctx, x, y, z, r):
+    if y == z: return RC_calc(ctx, x, y, r)
+    if x == z: return RC_calc(ctx, y, x, r)
+    if x == y: return RC_calc(ctx, z, x, r)
+    if not (ctx.isnormal(x) and ctx.isnormal(y) and ctx.isnormal(z)):
+        if ctx.isnan(x) or ctx.isnan(y) or ctx.isnan(z):
+            return x*y*z
+        if ctx.isinf(x) or ctx.isinf(y) or ctx.isinf(z):
+            return ctx.zero
+    xm,ym,zm = x,y,z
+    A0 = Am = (x+y+z)/3
+    Q = ctx.root(3*r, -6) * max(abs(A0-x),abs(A0-y),abs(A0-z))
+    g = ctx.mpf(0.25)
+    pow4 = ctx.one
+    while 1:
+        xs = ctx.sqrt(xm)
+        ys = ctx.sqrt(ym)
+        zs = ctx.sqrt(zm)
+        lm = xs*ys + xs*zs + ys*zs
+        Am1 = (Am+lm)*g
+        xm, ym, zm = (xm+lm)*g, (ym+lm)*g, (zm+lm)*g
+        if pow4 * Q < abs(Am):
+            break
+        Am = Am1
+        pow4 *= g
+    t = pow4/Am
+    X = (A0-x)*t
+    Y = (A0-y)*t
+    Z = -X-Y
+    E2 = X*Y-Z**2
+    E3 = X*Y*Z
+    return ctx.power(Am,-0.5) * (9240-924*E2+385*E2**2+660*E3-630*E2*E3)/9240
+
+def RC_calc(ctx, x, y, r, pv=True):
+    if not (ctx.isnormal(x) and ctx.isnormal(y)):
+        if ctx.isinf(x) or ctx.isinf(y):
+            return 1/(x*y)
+        if y == 0:
+            return ctx.inf
+        if x == 0:
+            return ctx.pi / ctx.sqrt(y) / 2
+        raise ValueError
+    # Cauchy principal value
+    if pv and ctx._im(y) == 0 and ctx._re(y) < 0:
+        return ctx.sqrt(x/(x-y)) * RC_calc(ctx, x-y, -y, r)
+    if x == y:
+        return 1/ctx.sqrt(x)
+    extraprec = 2*max(0,-ctx.mag(x-y)+ctx.mag(x))
+    ctx.prec += extraprec
+    if ctx._is_real_type(x) and ctx._is_real_type(y):
+        x = ctx._re(x)
+        y = ctx._re(y)
+        a = ctx.sqrt(x/y)
+        if x < y:
+            b = ctx.sqrt(y-x)
+            v = ctx.acos(a)/b
+        else:
+            b = ctx.sqrt(x-y)
+            v = ctx.acosh(a)/b
+    else:
+        sx = ctx.sqrt(x)
+        sy = ctx.sqrt(y)
+        v = ctx.acos(sx/sy)/(ctx.sqrt((1-x/y))*sy)
+    ctx.prec -= extraprec
+    return v
+
+def RJ_calc(ctx, x, y, z, p, r, integration):
+    """
+    With integration == 0, computes RJ only using Carlson's algorithm
+    (may be wrong for some values).
+    With integration == 1, uses an initial integration to make sure
+    Carlson's algorithm is correct.
+    With integration == 2, uses only integration.
+    """
+    if not (ctx.isnormal(x) and ctx.isnormal(y) and \
+        ctx.isnormal(z) and ctx.isnormal(p)):
+        if ctx.isnan(x) or ctx.isnan(y) or ctx.isnan(z) or ctx.isnan(p):
+            return x*y*z
+        if ctx.isinf(x) or ctx.isinf(y) or ctx.isinf(z) or ctx.isinf(p):
+            return ctx.zero
+    if not p:
+        return ctx.inf
+    if (not x) + (not y) + (not z) > 1:
+        return ctx.inf
+    # Check conditions and fall back on integration for argument
+    # reduction if needed. The following conditions might be needlessly
+    # restrictive.
+    initial_integral = ctx.zero
+    if integration >= 1:
+        ok = (x.real >= 0 and y.real >= 0 and z.real >= 0 and p.real > 0)
+        if not ok:
+            if x == p or y == p or z == p:
+                ok = True
+        if not ok:
+            if p.imag != 0 or p.real >= 0:
+                if (x.imag == 0 and x.real >= 0 and ctx.conj(y) == z):
+                    ok = True
+                if (y.imag == 0 and y.real >= 0 and ctx.conj(x) == z):
+                    ok = True
+                if (z.imag == 0 and z.real >= 0 and ctx.conj(x) == y):
+                    ok = True
+        if not ok or (integration == 2):
+            N = ctx.ceil(-min(x.real, y.real, z.real, p.real)) + 1
+            # Integrate around any singularities
+            if all((t.imag >= 0 or t.real > 0) for t in [x, y, z, p]):
+                margin = ctx.j
+            elif all((t.imag < 0 or t.real > 0) for t in [x, y, z, p]):
+                margin = -ctx.j
+            else:
+                margin = 1
+                # Go through the upper half-plane, but low enough that any
+                # parameter starting in the lower plane doesn't cross the
+                # branch cut
+                for t in [x, y, z, p]:
+                    if t.imag >= 0 or t.real > 0:
+                        continue
+                    margin = min(margin, abs(t.imag) * 0.5)
+                margin *= ctx.j
+            N += margin
+            F = lambda t: 1/(ctx.sqrt(t+x)*ctx.sqrt(t+y)*ctx.sqrt(t+z)*(t+p))
+            if integration == 2:
+                return 1.5 * ctx.quadsubdiv(F, [0, N, ctx.inf])
+            initial_integral = 1.5 * ctx.quadsubdiv(F, [0, N])
+            x += N; y += N; z += N; p += N
+    xm,ym,zm,pm = x,y,z,p
+    A0 = Am = (x + y + z + 2*p)/5
+    delta = (p-x)*(p-y)*(p-z)
+    Q = ctx.root(0.25*r, -6) * max(abs(A0-x),abs(A0-y),abs(A0-z),abs(A0-p))
+    g = ctx.mpf(0.25)
+    pow4 = ctx.one
+    S = 0
+    while 1:
+        sx = ctx.sqrt(xm)
+        sy = ctx.sqrt(ym)
+        sz = ctx.sqrt(zm)
+        sp = ctx.sqrt(pm)
+        lm = sx*sy + sx*sz + sy*sz
+        Am1 = (Am+lm)*g
+        xm = (xm+lm)*g; ym = (ym+lm)*g; zm = (zm+lm)*g; pm = (pm+lm)*g
+        dm = (sp+sx) * (sp+sy) * (sp+sz)
+        em = delta * pow4**3 / dm**2
+        if pow4 * Q < abs(Am):
+            break
+        T = RC_calc(ctx, ctx.one, ctx.one+em, r) * pow4 / dm
+        S += T
+        pow4 *= g
+        Am = Am1
+    t = pow4 / Am
+    X = (A0-x)*t
+    Y = (A0-y)*t
+    Z = (A0-z)*t
+    P = (-X-Y-Z)/2
+    E2 = X*Y + X*Z + Y*Z - 3*P**2
+    E3 = X*Y*Z + 2*E2*P + 4*P**3
+    E4 = (2*X*Y*Z + E2*P + 3*P**3)*P
+    E5 = X*Y*Z*P**2
+    P = 24024 - 5148*E2 + 2457*E2**2 + 4004*E3 - 4158*E2*E3 - 3276*E4 + 2772*E5
+    Q = 24024
+    v1 = pow4 * ctx.power(Am, -1.5) * P/Q
+    v2 = 6*S
+    return initial_integral + v1 + v2
+
+@defun
+def elliprf(ctx, x, y, z):
+    r"""
+    Evaluates the Carlson symmetric elliptic integral of the first kind
+
+    .. math ::
+
+        R_F(x,y,z) = \frac{1}{2}
+            \int_0^{\infty} \frac{dt}{\sqrt{(t+x)(t+y)(t+z)}}
+
+    which is defined for `x,y,z \notin (-\infty,0)`, and with
+    at most one of `x,y,z` being zero.
+
+    For real `x,y,z \ge 0`, the principal square root is taken in the integrand.
+    For complex `x,y,z`, the principal square root is taken as `t \to \infty`
+    and as `t \to 0` non-principal branches are chosen as necessary so as to
+    make the integrand continuous.
+
+    **Examples**
+
+    Some basic values and limits::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> elliprf(0,1,1); pi/2
+        1.570796326794896619231322
+        1.570796326794896619231322
+        >>> elliprf(0,1,inf)
+        0.0
+        >>> elliprf(1,1,1)
+        1.0
+        >>> elliprf(2,2,2)**2
+        0.5
+        >>> elliprf(1,0,0); elliprf(0,0,1); elliprf(0,1,0); elliprf(0,0,0)
+        +inf
+        +inf
+        +inf
+        +inf
+
+    Representing complete elliptic integrals in terms of `R_F`::
+
+        >>> m = mpf(0.75)
+        >>> ellipk(m); elliprf(0,1-m,1)
+        2.156515647499643235438675
+        2.156515647499643235438675
+        >>> ellipe(m); elliprf(0,1-m,1)-m*elliprd(0,1-m,1)/3
+        1.211056027568459524803563
+        1.211056027568459524803563
+
+    Some symmetries and argument transformations::
+
+        >>> x,y,z = 2,3,4
+        >>> elliprf(x,y,z); elliprf(y,x,z); elliprf(z,y,x)
+        0.5840828416771517066928492
+        0.5840828416771517066928492
+        0.5840828416771517066928492
+        >>> k = mpf(100000)
+        >>> elliprf(k*x,k*y,k*z); k**(-0.5) * elliprf(x,y,z)
+        0.001847032121923321253219284
+        0.001847032121923321253219284
+        >>> l = sqrt(x*y) + sqrt(y*z) + sqrt(z*x)
+        >>> elliprf(x,y,z); 2*elliprf(x+l,y+l,z+l)
+        0.5840828416771517066928492
+        0.5840828416771517066928492
+        >>> elliprf((x+l)/4,(y+l)/4,(z+l)/4)
+        0.5840828416771517066928492
+
+    Comparing with numerical integration::
+
+        >>> x,y,z = 2,3,4
+        >>> elliprf(x,y,z)
+        0.5840828416771517066928492
+        >>> f = lambda t: 0.5*((t+x)*(t+y)*(t+z))**(-0.5)
+        >>> q = extradps(25)(quad)
+        >>> q(f, [0,inf])
+        0.5840828416771517066928492
+
+    With the following arguments, the square root in the integrand becomes
+    discontinuous at `t = 1/2` if the principal branch is used. To obtain
+    the right value, `-\sqrt{r}` must be taken instead of `\sqrt{r}`
+    on `t \in (0, 1/2)`::
+
+        >>> x,y,z = j-1,j,0
+        >>> elliprf(x,y,z)
+        (0.7961258658423391329305694 - 1.213856669836495986430094j)
+        >>> -q(f, [0,0.5]) + q(f, [0.5,inf])
+        (0.7961258658423391329305694 - 1.213856669836495986430094j)
+
+    The so-called *first lemniscate constant*, a transcendental number::
+
+        >>> elliprf(0,1,2)
+        1.31102877714605990523242
+        >>> extradps(25)(quad)(lambda t: 1/sqrt(1-t**4), [0,1])
+        1.31102877714605990523242
+        >>> gamma('1/4')**2/(4*sqrt(2*pi))
+        1.31102877714605990523242
+
+    **References**
+
+    1. [Carlson]_
+    2. [DLMF]_ Chapter 19. Elliptic Integrals
+
+    """
+    x = ctx.convert(x)
+    y = ctx.convert(y)
+    z = ctx.convert(z)
+    prec = ctx.prec
+    try:
+        ctx.prec += 20
+        tol = ctx.eps * 2**10
+        v = RF_calc(ctx, x, y, z, tol)
+    finally:
+        ctx.prec = prec
+    return +v
+
+@defun
+def elliprc(ctx, x, y, pv=True):
+    r"""
+    Evaluates the degenerate Carlson symmetric elliptic integral
+    of the first kind
+
+    .. math ::
+
+        R_C(x,y) = R_F(x,y,y) =
+            \frac{1}{2} \int_0^{\infty} \frac{dt}{(t+y) \sqrt{(t+x)}}.
+
+    If `y \in (-\infty,0)`, either a value defined by continuity,
+    or with *pv=True* the Cauchy principal value, can be computed.
+
+    If `x \ge 0, y > 0`, the value can be expressed in terms of
+    elementary functions as
+
+    .. math ::
+
+        R_C(x,y) =
+        \begin{cases}
+          \dfrac{1}{\sqrt{y-x}}
+            \cos^{-1}\left(\sqrt{\dfrac{x}{y}}\right),   & x < y \\
+          \dfrac{1}{\sqrt{y}},                          & x = y \\
+          \dfrac{1}{\sqrt{x-y}}
+            \cosh^{-1}\left(\sqrt{\dfrac{x}{y}}\right),  & x > y \\
+        \end{cases}.
+
+    **Examples**
+
+    Some special values and limits::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> elliprc(1,2)*4; elliprc(0,1)*2; +pi
+        3.141592653589793238462643
+        3.141592653589793238462643
+        3.141592653589793238462643
+        >>> elliprc(1,0)
+        +inf
+        >>> elliprc(5,5)**2
+        0.2
+        >>> elliprc(1,inf); elliprc(inf,1); elliprc(inf,inf)
+        0.0
+        0.0
+        0.0
+
+    Comparing with the elementary closed-form solution::
+
+        >>> elliprc('1/3', '1/5'); sqrt(7.5)*acosh(sqrt('5/3'))
+        2.041630778983498390751238
+        2.041630778983498390751238
+        >>> elliprc('1/5', '1/3'); sqrt(7.5)*acos(sqrt('3/5'))
+        1.875180765206547065111085
+        1.875180765206547065111085
+
+    Comparing with numerical integration::
+
+        >>> q = extradps(25)(quad)
+        >>> elliprc(2, -3, pv=True)
+        0.3333969101113672670749334
+        >>> elliprc(2, -3, pv=False)
+        (0.3333969101113672670749334 + 0.7024814731040726393156375j)
+        >>> 0.5*q(lambda t: 1/(sqrt(t+2)*(t-3)), [0,3-j,6,inf])
+        (0.3333969101113672670749334 + 0.7024814731040726393156375j)
+
+    """
+    x = ctx.convert(x)
+    y = ctx.convert(y)
+    prec = ctx.prec
+    try:
+        ctx.prec += 20
+        tol = ctx.eps * 2**10
+        v = RC_calc(ctx, x, y, tol, pv)
+    finally:
+        ctx.prec = prec
+    return +v
+
+@defun
+def elliprj(ctx, x, y, z, p, integration=1):
+    r"""
+    Evaluates the Carlson symmetric elliptic integral of the third kind
+
+    .. math ::
+
+        R_J(x,y,z,p) = \frac{3}{2}
+            \int_0^{\infty} \frac{dt}{(t+p)\sqrt{(t+x)(t+y)(t+z)}}.
+
+    Like :func:`~mpmath.elliprf`, the branch of the square root in the integrand
+    is defined so as to be continuous along the path of integration for
+    complex values of the arguments.
+
+    **Examples**
+
+    Some values and limits::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> elliprj(1,1,1,1)
+        1.0
+        >>> elliprj(2,2,2,2); 1/(2*sqrt(2))
+        0.3535533905932737622004222
+        0.3535533905932737622004222
+        >>> elliprj(0,1,2,2)
+        1.067937989667395702268688
+        >>> 3*(2*gamma('5/4')**2-pi**2/gamma('1/4')**2)/(sqrt(2*pi))
+        1.067937989667395702268688
+        >>> elliprj(0,1,1,2); 3*pi*(2-sqrt(2))/4
+        1.380226776765915172432054
+        1.380226776765915172432054
+        >>> elliprj(1,3,2,0); elliprj(0,1,1,0); elliprj(0,0,0,0)
+        +inf
+        +inf
+        +inf
+        >>> elliprj(1,inf,1,0); elliprj(1,1,1,inf)
+        0.0
+        0.0
+        >>> chop(elliprj(1+j, 1-j, 1, 1))
+        0.8505007163686739432927844
+
+    Scale transformation::
+
+        >>> x,y,z,p = 2,3,4,5
+        >>> k = mpf(100000)
+        >>> elliprj(k*x,k*y,k*z,k*p); k**(-1.5)*elliprj(x,y,z,p)
+        4.521291677592745527851168e-9
+        4.521291677592745527851168e-9
+
+    Comparing with numerical integration::
+
+        >>> elliprj(1,2,3,4)
+        0.2398480997495677621758617
+        >>> f = lambda t: 1/((t+4)*sqrt((t+1)*(t+2)*(t+3)))
+        >>> 1.5*quad(f, [0,inf])
+        0.2398480997495677621758617
+        >>> elliprj(1,2+1j,3,4-2j)
+        (0.216888906014633498739952 + 0.04081912627366673332369512j)
+        >>> f = lambda t: 1/((t+4-2j)*sqrt((t+1)*(t+2+1j)*(t+3)))
+        >>> 1.5*quad(f, [0,inf])
+        (0.216888906014633498739952 + 0.04081912627366673332369511j)
+
+    """
+    x = ctx.convert(x)
+    y = ctx.convert(y)
+    z = ctx.convert(z)
+    p = ctx.convert(p)
+    prec = ctx.prec
+    try:
+        ctx.prec += 20
+        tol = ctx.eps * 2**10
+        v = RJ_calc(ctx, x, y, z, p, tol, integration)
+    finally:
+        ctx.prec = prec
+    return +v
+
+@defun
+def elliprd(ctx, x, y, z):
+    r"""
+    Evaluates the degenerate Carlson symmetric elliptic integral
+    of the third kind or Carlson elliptic integral of the
+    second kind `R_D(x,y,z) = R_J(x,y,z,z)`.
+
+    See :func:`~mpmath.elliprj` for additional information.
+
+    **Examples**
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> elliprd(1,2,3)
+        0.2904602810289906442326534
+        >>> elliprj(1,2,3,3)
+        0.2904602810289906442326534
+
+    The so-called *second lemniscate constant*, a transcendental number::
+
+        >>> elliprd(0,2,1)/3
+        0.5990701173677961037199612
+        >>> extradps(25)(quad)(lambda t: t**2/sqrt(1-t**4), [0,1])
+        0.5990701173677961037199612
+        >>> gamma('3/4')**2/sqrt(2*pi)
+        0.5990701173677961037199612
+
+    """
+    return ctx.elliprj(x,y,z,z)
+
+@defun
+def elliprg(ctx, x, y, z):
+    r"""
+    Evaluates the Carlson completely symmetric elliptic integral
+    of the second kind
+
+    .. math ::
+
+        R_G(x,y,z) = \frac{1}{4} \int_0^{\infty}
+            \frac{t}{\sqrt{(t+x)(t+y)(t+z)}}
+            \left( \frac{x}{t+x} + \frac{y}{t+y} + \frac{z}{t+z}\right) dt.
+
+    **Examples**
+
+    Evaluation for real and complex arguments::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> elliprg(0,1,1)*4; +pi
+        3.141592653589793238462643
+        3.141592653589793238462643
+        >>> elliprg(0,0.5,1)
+        0.6753219405238377512600874
+        >>> chop(elliprg(1+j, 1-j, 2))
+        1.172431327676416604532822
+
+    A double integral that can be evaluated in terms of `R_G`::
+
+        >>> x,y,z = 2,3,4
+        >>> def f(t,u):
+        ...     st = fp.sin(t); ct = fp.cos(t)
+        ...     su = fp.sin(u); cu = fp.cos(u)
+        ...     return (x*(st*cu)**2 + y*(st*su)**2 + z*ct**2)**0.5 * st
+        ...
+        >>> nprint(mpf(fp.quad(f, [0,fp.pi], [0,2*fp.pi])/(4*fp.pi)), 13)
+        1.725503028069
+        >>> nprint(elliprg(x,y,z), 13)
+        1.725503028069
+
+    """
+    x = ctx.convert(x)
+    y = ctx.convert(y)
+    z = ctx.convert(z)
+    zeros = (not x) + (not y) + (not z)
+    if zeros == 3:
+        return (x+y+z)*0
+    if zeros == 2:
+        if x: return 0.5*ctx.sqrt(x)
+        if y: return 0.5*ctx.sqrt(y)
+        return 0.5*ctx.sqrt(z)
+    if zeros == 1:
+        if not z:
+            x, z = z, x
+    def terms():
+        T1 = 0.5*z*ctx.elliprf(x,y,z)
+        T2 = -0.5*(x-z)*(y-z)*ctx.elliprd(x,y,z)/3
+        T3 = 0.5*ctx.sqrt(x)*ctx.sqrt(y)/ctx.sqrt(z)
+        return T1,T2,T3
+    return ctx.sum_accurately(terms)
+
+
+@defun_wrapped
+def ellipf(ctx, phi, m):
+    r"""
+    Evaluates the Legendre incomplete elliptic integral of the first kind
+
+     .. math ::
+
+        F(\phi,m) = \int_0^{\phi} \frac{dt}{\sqrt{1-m \sin^2 t}}
+
+    or equivalently
+
+    .. math ::
+
+        F(\phi,m) = \int_0^{\sin \phi}
+        \frac{dt}{\left(\sqrt{1-t^2}\right)\left(\sqrt{1-mt^2}\right)}.
+
+    The function reduces to a complete elliptic integral of the first kind
+    (see :func:`~mpmath.ellipk`) when `\phi = \frac{\pi}{2}`; that is,
+
+    .. math ::
+
+        F\left(\frac{\pi}{2}, m\right) = K(m).
+
+    In the defining integral, it is assumed that the principal branch
+    of the square root is taken and that the path of integration avoids
+    crossing any branch cuts. Outside `-\pi/2 \le \Re(\phi) \le \pi/2`,
+    the function extends quasi-periodically as
+
+    .. math ::
+
+        F(\phi + n \pi, m) = 2 n K(m) + F(\phi,m), n \in \mathbb{Z}.
+
+    **Plots**
+
+    .. literalinclude :: /plots/ellipf.py
+    .. image :: /plots/ellipf.png
+
+    **Examples**
+
+    Basic values and limits::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> ellipf(0,1)
+        0.0
+        >>> ellipf(0,0)
+        0.0
+        >>> ellipf(1,0); ellipf(2+3j,0)
+        1.0
+        (2.0 + 3.0j)
+        >>> ellipf(1,1); log(sec(1)+tan(1))
+        1.226191170883517070813061
+        1.226191170883517070813061
+        >>> ellipf(pi/2, -0.5); ellipk(-0.5)
+        1.415737208425956198892166
+        1.415737208425956198892166
+        >>> ellipf(pi/2+eps, 1); ellipf(-pi/2-eps, 1)
+        +inf
+        +inf
+        >>> ellipf(1.5, 1)
+        3.340677542798311003320813
+
+    Comparing with numerical integration::
+
+        >>> z,m = 0.5, 1.25
+        >>> ellipf(z,m)
+        0.5287219202206327872978255
+        >>> quad(lambda t: (1-m*sin(t)**2)**(-0.5), [0,z])
+        0.5287219202206327872978255
+
+    The arguments may be complex numbers::
+
+        >>> ellipf(3j, 0.5)
+        (0.0 + 1.713602407841590234804143j)
+        >>> ellipf(3+4j, 5-6j)
+        (1.269131241950351323305741 - 0.3561052815014558335412538j)
+        >>> z,m = 2+3j, 1.25
+        >>> k = 1011
+        >>> ellipf(z+pi*k,m); ellipf(z,m) + 2*k*ellipk(m)
+        (4086.184383622179764082821 - 3003.003538923749396546871j)
+        (4086.184383622179764082821 - 3003.003538923749396546871j)
+
+    For `|\Re(z)| < \pi/2`, the function can be expressed as a
+    hypergeometric series of two variables
+    (see :func:`~mpmath.appellf1`)::
+
+        >>> z,m = 0.5, 0.25
+        >>> ellipf(z,m)
+        0.5050887275786480788831083
+        >>> sin(z)*appellf1(0.5,0.5,0.5,1.5,sin(z)**2,m*sin(z)**2)
+        0.5050887275786480788831083
+
+    """
+    z = phi
+    if not (ctx.isnormal(z) and ctx.isnormal(m)):
+        if m == 0:
+            return z + m
+        if z == 0:
+            return z * m
+        if m == ctx.inf or m == ctx.ninf: return z/m
+        raise ValueError
+    x = z.real
+    ctx.prec += max(0, ctx.mag(x))
+    pi = +ctx.pi
+    away = abs(x) > pi/2
+    if m == 1:
+        if away:
+            return ctx.inf
+    if away:
+        d = ctx.nint(x/pi)
+        z = z-pi*d
+        P = 2*d*ctx.ellipk(m)
+    else:
+        P = 0
+    c, s = ctx.cos_sin(z)
+    return s * ctx.elliprf(c**2, 1-m*s**2, 1) + P
+
+@defun_wrapped
+def ellipe(ctx, *args):
+    r"""
+    Called with a single argument `m`, evaluates the Legendre complete
+    elliptic integral of the second kind, `E(m)`, defined by
+
+        .. math :: E(m) = \int_0^{\pi/2} \sqrt{1-m \sin^2 t} \, dt \,=\,
+            \frac{\pi}{2}
+            \,_2F_1\left(\frac{1}{2}, -\frac{1}{2}, 1, m\right).
+
+    Called with two arguments `\phi, m`, evaluates the incomplete elliptic
+    integral of the second kind
+
+     .. math ::
+
+        E(\phi,m) = \int_0^{\phi} \sqrt{1-m \sin^2 t} \, dt =
+                    \int_0^{\sin z}
+                    \frac{\sqrt{1-mt^2}}{\sqrt{1-t^2}} \, dt.
+
+    The incomplete integral reduces to a complete integral when
+    `\phi = \frac{\pi}{2}`; that is,
+
+    .. math ::
+
+        E\left(\frac{\pi}{2}, m\right) = E(m).
+
+    In the defining integral, it is assumed that the principal branch
+    of the square root is taken and that the path of integration avoids
+    crossing any branch cuts. Outside `-\pi/2 \le \Re(z) \le \pi/2`,
+    the function extends quasi-periodically as
+
+    .. math ::
+
+        E(\phi + n \pi, m) = 2 n E(m) + E(\phi,m), n \in \mathbb{Z}.
+
+    **Plots**
+
+    .. literalinclude :: /plots/ellipe.py
+    .. image :: /plots/ellipe.png
+
+    **Examples for the complete integral**
+
+    Basic values and limits::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> ellipe(0)
+        1.570796326794896619231322
+        >>> ellipe(1)
+        1.0
+        >>> ellipe(-1)
+        1.910098894513856008952381
+        >>> ellipe(2)
+        (0.5990701173677961037199612 + 0.5990701173677961037199612j)
+        >>> ellipe(inf)
+        (0.0 + +infj)
+        >>> ellipe(-inf)
+        +inf
+
+    Verifying the defining integral and hypergeometric
+    representation::
+
+        >>> ellipe(0.5)
+        1.350643881047675502520175
+        >>> quad(lambda t: sqrt(1-0.5*sin(t)**2), [0, pi/2])
+        1.350643881047675502520175
+        >>> pi/2*hyp2f1(0.5,-0.5,1,0.5)
+        1.350643881047675502520175
+
+    Evaluation is supported for arbitrary complex `m`::
+
+        >>> ellipe(0.5+0.25j)
+        (1.360868682163129682716687 - 0.1238733442561786843557315j)
+        >>> ellipe(3+4j)
+        (1.499553520933346954333612 - 1.577879007912758274533309j)
+
+    A definite integral::
+
+        >>> quad(ellipe, [0,1])
+        1.333333333333333333333333
+
+    **Examples for the incomplete integral**
+
+    Basic values and limits::
+
+        >>> ellipe(0,1)
+        0.0
+        >>> ellipe(0,0)
+        0.0
+        >>> ellipe(1,0)
+        1.0
+        >>> ellipe(2+3j,0)
+        (2.0 + 3.0j)
+        >>> ellipe(1,1); sin(1)
+        0.8414709848078965066525023
+        0.8414709848078965066525023
+        >>> ellipe(pi/2, -0.5); ellipe(-0.5)
+        1.751771275694817862026502
+        1.751771275694817862026502
+        >>> ellipe(pi/2, 1); ellipe(-pi/2, 1)
+        1.0
+        -1.0
+        >>> ellipe(1.5, 1)
+        0.9974949866040544309417234
+
+    Comparing with numerical integration::
+
+        >>> z,m = 0.5, 1.25
+        >>> ellipe(z,m)
+        0.4740152182652628394264449
+        >>> quad(lambda t: sqrt(1-m*sin(t)**2), [0,z])
+        0.4740152182652628394264449
+
+    The arguments may be complex numbers::
+
+        >>> ellipe(3j, 0.5)
+        (0.0 + 7.551991234890371873502105j)
+        >>> ellipe(3+4j, 5-6j)
+        (24.15299022574220502424466 + 75.2503670480325997418156j)
+        >>> k = 35
+        >>> z,m = 2+3j, 1.25
+        >>> ellipe(z+pi*k,m); ellipe(z,m) + 2*k*ellipe(m)
+        (48.30138799412005235090766 + 17.47255216721987688224357j)
+        (48.30138799412005235090766 + 17.47255216721987688224357j)
+
+    For `|\Re(z)| < \pi/2`, the function can be expressed as a
+    hypergeometric series of two variables
+    (see :func:`~mpmath.appellf1`)::
+
+        >>> z,m = 0.5, 0.25
+        >>> ellipe(z,m)
+        0.4950017030164151928870375
+        >>> sin(z)*appellf1(0.5,0.5,-0.5,1.5,sin(z)**2,m*sin(z)**2)
+        0.4950017030164151928870376
+
+    """
+    if len(args) == 1:
+        return ctx._ellipe(args[0])
+    else:
+        phi, m = args
+    z = phi
+    if not (ctx.isnormal(z) and ctx.isnormal(m)):
+        if m == 0:
+            return z + m
+        if z == 0:
+            return z * m
+        if m == ctx.inf or m == ctx.ninf:
+            return ctx.inf
+        raise ValueError
+    x = z.real
+    ctx.prec += max(0, ctx.mag(x))
+    pi = +ctx.pi
+    away = abs(x) > pi/2
+    if away:
+        d = ctx.nint(x/pi)
+        z = z-pi*d
+        P = 2*d*ctx.ellipe(m)
+    else:
+        P = 0
+    def terms():
+        c, s = ctx.cos_sin(z)
+        x = c**2
+        y = 1-m*s**2
+        RF = ctx.elliprf(x, y, 1)
+        RD = ctx.elliprd(x, y, 1)
+        return s*RF, -m*s**3*RD/3
+    return ctx.sum_accurately(terms) + P
+
+@defun_wrapped
+def ellippi(ctx, *args):
+    r"""
+    Called with three arguments `n, \phi, m`, evaluates the Legendre
+    incomplete elliptic integral of the third kind
+
+    .. math ::
+
+        \Pi(n; \phi, m) = \int_0^{\phi}
+            \frac{dt}{(1-n \sin^2 t) \sqrt{1-m \sin^2 t}} =
+            \int_0^{\sin \phi}
+            \frac{dt}{(1-nt^2) \sqrt{1-t^2} \sqrt{1-mt^2}}.
+
+    Called with two arguments `n, m`, evaluates the complete
+    elliptic integral of the third kind
+    `\Pi(n,m) = \Pi(n; \frac{\pi}{2},m)`.
+
+    In the defining integral, it is assumed that the principal branch
+    of the square root is taken and that the path of integration avoids
+    crossing any branch cuts. Outside `-\pi/2 \le \Re(\phi) \le \pi/2`,
+    the function extends quasi-periodically as
+
+    .. math ::
+
+        \Pi(n,\phi+k\pi,m) = 2k\Pi(n,m) + \Pi(n,\phi,m), k \in \mathbb{Z}.
+
+    **Plots**
+
+    .. literalinclude :: /plots/ellippi.py
+    .. image :: /plots/ellippi.png
+
+    **Examples for the complete integral**
+
+    Some basic values and limits::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> ellippi(0,-5); ellipk(-5)
+        0.9555039270640439337379334
+        0.9555039270640439337379334
+        >>> ellippi(inf,2)
+        0.0
+        >>> ellippi(2,inf)
+        0.0
+        >>> abs(ellippi(1,5))
+        +inf
+        >>> abs(ellippi(0.25,1))
+        +inf
+
+    Evaluation in terms of simpler functions::
+
+        >>> ellippi(0.25,0.25); ellipe(0.25)/(1-0.25)
+        1.956616279119236207279727
+        1.956616279119236207279727
+        >>> ellippi(3,0); pi/(2*sqrt(-2))
+        (0.0 - 1.11072073453959156175397j)
+        (0.0 - 1.11072073453959156175397j)
+        >>> ellippi(-3,0); pi/(2*sqrt(4))
+        0.7853981633974483096156609
+        0.7853981633974483096156609
+
+    **Examples for the incomplete integral**
+
+    Basic values and limits::
+
+        >>> ellippi(0.25,-0.5); ellippi(0.25,pi/2,-0.5)
+        1.622944760954741603710555
+        1.622944760954741603710555
+        >>> ellippi(1,0,1)
+        0.0
+        >>> ellippi(inf,0,1)
+        0.0
+        >>> ellippi(0,0.25,0.5); ellipf(0.25,0.5)
+        0.2513040086544925794134591
+        0.2513040086544925794134591
+        >>> ellippi(1,1,1); (log(sec(1)+tan(1))+sec(1)*tan(1))/2
+        2.054332933256248668692452
+        2.054332933256248668692452
+        >>> ellippi(0.25, 53*pi/2, 0.75); 53*ellippi(0.25,0.75)
+        135.240868757890840755058
+        135.240868757890840755058
+        >>> ellippi(0.5,pi/4,0.5); 2*ellipe(pi/4,0.5)-1/sqrt(3)
+        0.9190227391656969903987269
+        0.9190227391656969903987269
+
+    Complex arguments are supported::
+
+        >>> ellippi(0.5, 5+6j-2*pi, -7-8j)
+        (-0.3612856620076747660410167 + 0.5217735339984807829755815j)
+
+    Some degenerate cases::
+
+        >>> ellippi(1,1)
+        +inf
+        >>> ellippi(1,0)
+        +inf
+        >>> ellippi(1,2,0)
+        +inf
+        >>> ellippi(1,2,1)
+        +inf
+        >>> ellippi(1,0,1)
+        0.0
+
+    """
+    if len(args) == 2:
+        n, m = args
+        complete = True
+        z = phi = ctx.pi/2
+    else:
+        n, phi, m = args
+        complete = False
+        z = phi
+    if not (ctx.isnormal(n) and ctx.isnormal(z) and ctx.isnormal(m)):
+        if ctx.isnan(n) or ctx.isnan(z) or ctx.isnan(m):
+            raise ValueError
+        if complete:
+            if m == 0:
+                if n == 1:
+                    return ctx.inf
+                return ctx.pi/(2*ctx.sqrt(1-n))
+            if n == 0: return ctx.ellipk(m)
+            if ctx.isinf(n) or ctx.isinf(m): return ctx.zero
+        else:
+            if z == 0: return z
+            if ctx.isinf(n): return ctx.zero
+            if ctx.isinf(m): return ctx.zero
+        if ctx.isinf(n) or ctx.isinf(z) or ctx.isinf(m):
+            raise ValueError
+    if complete:
+        if m == 1:
+            if n == 1:
+                return ctx.inf
+            return -ctx.inf/ctx.sign(n-1)
+        away = False
+    else:
+        x = z.real
+        ctx.prec += max(0, ctx.mag(x))
+        pi = +ctx.pi
+        away = abs(x) > pi/2
+    if away:
+        d = ctx.nint(x/pi)
+        z = z-pi*d
+        P = 2*d*ctx.ellippi(n,m)
+        if ctx.isinf(P):
+            return ctx.inf
+    else:
+        P = 0
+    def terms():
+        if complete:
+            c, s = ctx.zero, ctx.one
+        else:
+            c, s = ctx.cos_sin(z)
+        x = c**2
+        y = 1-m*s**2
+        RF = ctx.elliprf(x, y, 1)
+        RJ = ctx.elliprj(x, y, 1, 1-n*s**2)
+        return s*RF, n*s**3*RJ/3
+    return ctx.sum_accurately(terms) + P
diff --git a/lib/python3.10/site-packages/mpmath/functions/expintegrals.py b/lib/python3.10/site-packages/mpmath/functions/expintegrals.py
new file mode 100644
index 0000000000000000000000000000000000000000..0dee8356c0386819d8f0421fded476ee77229359
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/functions/expintegrals.py
@@ -0,0 +1,425 @@
+from .functions import defun, defun_wrapped
+
+@defun_wrapped
+def _erf_complex(ctx, z):
+    z2 = ctx.square_exp_arg(z, -1)
+    #z2 = -z**2
+    v = (2/ctx.sqrt(ctx.pi))*z * ctx.hyp1f1((1,2),(3,2), z2)
+    if not ctx._re(z):
+        v = ctx._im(v)*ctx.j
+    return v
+
+@defun_wrapped
+def _erfc_complex(ctx, z):
+    if ctx.re(z) > 2:
+        z2 = ctx.square_exp_arg(z)
+        nz2 = ctx.fneg(z2, exact=True)
+        v = ctx.exp(nz2)/ctx.sqrt(ctx.pi) * ctx.hyperu((1,2),(1,2), z2)
+    else:
+        v = 1 - ctx._erf_complex(z)
+    if not ctx._re(z):
+        v = 1+ctx._im(v)*ctx.j
+    return v
+
+@defun
+def erf(ctx, z):
+    z = ctx.convert(z)
+    if ctx._is_real_type(z):
+        try:
+            return ctx._erf(z)
+        except NotImplementedError:
+            pass
+    if ctx._is_complex_type(z) and not z.imag:
+        try:
+            return type(z)(ctx._erf(z.real))
+        except NotImplementedError:
+            pass
+    return ctx._erf_complex(z)
+
+@defun
+def erfc(ctx, z):
+    z = ctx.convert(z)
+    if ctx._is_real_type(z):
+        try:
+            return ctx._erfc(z)
+        except NotImplementedError:
+            pass
+    if ctx._is_complex_type(z) and not z.imag:
+        try:
+            return type(z)(ctx._erfc(z.real))
+        except NotImplementedError:
+            pass
+    return ctx._erfc_complex(z)
+
+@defun
+def square_exp_arg(ctx, z, mult=1, reciprocal=False):
+    prec = ctx.prec*4+20
+    if reciprocal:
+        z2 = ctx.fmul(z, z, prec=prec)
+        z2 = ctx.fdiv(ctx.one, z2, prec=prec)
+    else:
+        z2 = ctx.fmul(z, z, prec=prec)
+    if mult != 1:
+        z2 = ctx.fmul(z2, mult, exact=True)
+    return z2
+
+@defun_wrapped
+def erfi(ctx, z):
+    if not z:
+        return z
+    z2 = ctx.square_exp_arg(z)
+    v = (2/ctx.sqrt(ctx.pi)*z) * ctx.hyp1f1((1,2), (3,2), z2)
+    if not ctx._re(z):
+        v = ctx._im(v)*ctx.j
+    return v
+
+@defun_wrapped
+def erfinv(ctx, x):
+    xre = ctx._re(x)
+    if (xre != x) or (xre < -1) or (xre > 1):
+        return ctx.bad_domain("erfinv(x) is defined only for -1 <= x <= 1")
+    x = xre
+    #if ctx.isnan(x): return x
+    if not x: return x
+    if x == 1: return ctx.inf
+    if x == -1: return ctx.ninf
+    if abs(x) < 0.9:
+        a = 0.53728*x**3 + 0.813198*x
+    else:
+        # An asymptotic formula
+        u = ctx.ln(2/ctx.pi/(abs(x)-1)**2)
+        a = ctx.sign(x) * ctx.sqrt(u - ctx.ln(u))/ctx.sqrt(2)
+    ctx.prec += 10
+    return ctx.findroot(lambda t: ctx.erf(t)-x, a)
+
+@defun_wrapped
+def npdf(ctx, x, mu=0, sigma=1):
+    sigma = ctx.convert(sigma)
+    return ctx.exp(-(x-mu)**2/(2*sigma**2)) / (sigma*ctx.sqrt(2*ctx.pi))
+
+@defun_wrapped
+def ncdf(ctx, x, mu=0, sigma=1):
+    a = (x-mu)/(sigma*ctx.sqrt(2))
+    if a < 0:
+        return ctx.erfc(-a)/2
+    else:
+        return (1+ctx.erf(a))/2
+
+@defun_wrapped
+def betainc(ctx, a, b, x1=0, x2=1, regularized=False):
+    if x1 == x2:
+        v = 0
+    elif not x1:
+        if x1 == 0 and x2 == 1:
+            v = ctx.beta(a, b)
+        else:
+            v = x2**a * ctx.hyp2f1(a, 1-b, a+1, x2) / a
+    else:
+        m, d = ctx.nint_distance(a)
+        if m <= 0:
+            if d < -ctx.prec:
+                h = +ctx.eps
+                ctx.prec *= 2
+                a += h
+            elif d < -4:
+                ctx.prec -= d
+        s1 = x2**a * ctx.hyp2f1(a,1-b,a+1,x2)
+        s2 = x1**a * ctx.hyp2f1(a,1-b,a+1,x1)
+        v = (s1 - s2) / a
+    if regularized:
+        v /= ctx.beta(a,b)
+    return v
+
+@defun
+def gammainc(ctx, z, a=0, b=None, regularized=False):
+    regularized = bool(regularized)
+    z = ctx.convert(z)
+    if a is None:
+        a = ctx.zero
+        lower_modified = False
+    else:
+        a = ctx.convert(a)
+        lower_modified = a != ctx.zero
+    if b is None:
+        b = ctx.inf
+        upper_modified = False
+    else:
+        b = ctx.convert(b)
+        upper_modified = b != ctx.inf
+    # Complete gamma function
+    if not (upper_modified or lower_modified):
+        if regularized:
+            if ctx.re(z) < 0:
+                return ctx.inf
+            elif ctx.re(z) > 0:
+                return ctx.one
+            else:
+                return ctx.nan
+        return ctx.gamma(z)
+    if a == b:
+        return ctx.zero
+    # Standardize
+    if ctx.re(a) > ctx.re(b):
+        return -ctx.gammainc(z, b, a, regularized)
+    # Generalized gamma
+    if upper_modified and lower_modified:
+        return +ctx._gamma3(z, a, b, regularized)
+    # Upper gamma
+    elif lower_modified:
+        return ctx._upper_gamma(z, a, regularized)
+    # Lower gamma
+    elif upper_modified:
+        return ctx._lower_gamma(z, b, regularized)
+
+@defun
+def _lower_gamma(ctx, z, b, regularized=False):
+    # Pole
+    if ctx.isnpint(z):
+        return type(z)(ctx.inf)
+    G = [z] * regularized
+    negb = ctx.fneg(b, exact=True)
+    def h(z):
+        T1 = [ctx.exp(negb), b, z], [1, z, -1], [], G, [1], [1+z], b
+        return (T1,)
+    return ctx.hypercomb(h, [z])
+
+@defun
+def _upper_gamma(ctx, z, a, regularized=False):
+    # Fast integer case, when available
+    if ctx.isint(z):
+        try:
+            if regularized:
+                # Gamma pole
+                if ctx.isnpint(z):
+                    return type(z)(ctx.zero)
+                orig = ctx.prec
+                try:
+                    ctx.prec += 10
+                    return ctx._gamma_upper_int(z, a) / ctx.gamma(z)
+                finally:
+                    ctx.prec = orig
+            else:
+                return ctx._gamma_upper_int(z, a)
+        except NotImplementedError:
+            pass
+    # hypercomb is unable to detect the exact zeros, so handle them here
+    if z == 2 and a == -1:
+        return (z+a)*0
+    if z == 3 and (a == -1-1j or a == -1+1j):
+        return (z+a)*0
+    nega = ctx.fneg(a, exact=True)
+    G = [z] * regularized
+    # Use 2F0 series when possible; fall back to lower gamma representation
+    try:
+        def h(z):
+            r = z-1
+            return [([ctx.exp(nega), a], [1, r], [], G, [1, -r], [], 1/nega)]
+        return ctx.hypercomb(h, [z], force_series=True)
+    except ctx.NoConvergence:
+        def h(z):
+            T1 = [], [1, z-1], [z], G, [], [], 0
+            T2 = [-ctx.exp(nega), a, z], [1, z, -1], [], G, [1], [1+z], a
+            return T1, T2
+        return ctx.hypercomb(h, [z])
+
+@defun
+def _gamma3(ctx, z, a, b, regularized=False):
+    pole = ctx.isnpint(z)
+    if regularized and pole:
+        return ctx.zero
+    try:
+        ctx.prec += 15
+        # We don't know in advance whether it's better to write as a difference
+        # of lower or upper gamma functions, so try both
+        T1 = ctx.gammainc(z, a, regularized=regularized)
+        T2 = ctx.gammainc(z, b, regularized=regularized)
+        R = T1 - T2
+        if ctx.mag(R) - max(ctx.mag(T1), ctx.mag(T2)) > -10:
+            return R
+        if not pole:
+            T1 = ctx.gammainc(z, 0, b, regularized=regularized)
+            T2 = ctx.gammainc(z, 0, a, regularized=regularized)
+            R = T1 - T2
+            # May be ok, but should probably at least print a warning
+            # about possible cancellation
+            if 1: #ctx.mag(R) - max(ctx.mag(T1), ctx.mag(T2)) > -10:
+                return R
+    finally:
+        ctx.prec -= 15
+    raise NotImplementedError
+
+@defun_wrapped
+def expint(ctx, n, z):
+    if ctx.isint(n) and ctx._is_real_type(z):
+        try:
+            return ctx._expint_int(n, z)
+        except NotImplementedError:
+            pass
+    if ctx.isnan(n) or ctx.isnan(z):
+        return z*n
+    if z == ctx.inf:
+        return 1/z
+    if z == 0:
+        # integral from 1 to infinity of t^n
+        if ctx.re(n) <= 1:
+            # TODO: reasonable sign of infinity
+            return type(z)(ctx.inf)
+        else:
+            return ctx.one/(n-1)
+    if n == 0:
+        return ctx.exp(-z)/z
+    if n == -1:
+        return ctx.exp(-z)*(z+1)/z**2
+    return z**(n-1) * ctx.gammainc(1-n, z)
+
+@defun_wrapped
+def li(ctx, z, offset=False):
+    if offset:
+        if z == 2:
+            return ctx.zero
+        return ctx.ei(ctx.ln(z)) - ctx.ei(ctx.ln2)
+    if not z:
+        return z
+    if z == 1:
+        return ctx.ninf
+    return ctx.ei(ctx.ln(z))
+
+@defun
+def ei(ctx, z):
+    try:
+        return ctx._ei(z)
+    except NotImplementedError:
+        return ctx._ei_generic(z)
+
+@defun_wrapped
+def _ei_generic(ctx, z):
+    # Note: the following is currently untested because mp and fp
+    # both use special-case ei code
+    if z == ctx.inf:
+        return z
+    if z == ctx.ninf:
+        return ctx.zero
+    if ctx.mag(z) > 1:
+        try:
+            r = ctx.one/z
+            v = ctx.exp(z)*ctx.hyper([1,1],[],r,
+                maxterms=ctx.prec, force_series=True)/z
+            im = ctx._im(z)
+            if im > 0:
+                v += ctx.pi*ctx.j
+            if im < 0:
+                v -= ctx.pi*ctx.j
+            return v
+        except ctx.NoConvergence:
+            pass
+    v = z*ctx.hyp2f2(1,1,2,2,z) + ctx.euler
+    if ctx._im(z):
+        v += 0.5*(ctx.log(z) - ctx.log(ctx.one/z))
+    else:
+        v += ctx.log(abs(z))
+    return v
+
+@defun
+def e1(ctx, z):
+    try:
+        return ctx._e1(z)
+    except NotImplementedError:
+        return ctx.expint(1, z)
+
+@defun
+def ci(ctx, z):
+    try:
+        return ctx._ci(z)
+    except NotImplementedError:
+        return ctx._ci_generic(z)
+
+@defun_wrapped
+def _ci_generic(ctx, z):
+    if ctx.isinf(z):
+        if z == ctx.inf: return ctx.zero
+        if z == ctx.ninf: return ctx.pi*1j
+    jz = ctx.fmul(ctx.j,z,exact=True)
+    njz = ctx.fneg(jz,exact=True)
+    v = 0.5*(ctx.ei(jz) + ctx.ei(njz))
+    zreal = ctx._re(z)
+    zimag = ctx._im(z)
+    if zreal == 0:
+        if zimag > 0: v += ctx.pi*0.5j
+        if zimag < 0: v -= ctx.pi*0.5j
+    if zreal < 0:
+        if zimag >= 0: v += ctx.pi*1j
+        if zimag <  0: v -= ctx.pi*1j
+    if ctx._is_real_type(z) and zreal > 0:
+        v = ctx._re(v)
+    return v
+
+@defun
+def si(ctx, z):
+    try:
+        return ctx._si(z)
+    except NotImplementedError:
+        return ctx._si_generic(z)
+
+@defun_wrapped
+def _si_generic(ctx, z):
+    if ctx.isinf(z):
+        if z == ctx.inf: return 0.5*ctx.pi
+        if z == ctx.ninf: return -0.5*ctx.pi
+    # Suffers from cancellation near 0
+    if ctx.mag(z) >= -1:
+        jz = ctx.fmul(ctx.j,z,exact=True)
+        njz = ctx.fneg(jz,exact=True)
+        v = (-0.5j)*(ctx.ei(jz) - ctx.ei(njz))
+        zreal = ctx._re(z)
+        if zreal > 0:
+            v -= 0.5*ctx.pi
+        if zreal < 0:
+            v += 0.5*ctx.pi
+        if ctx._is_real_type(z):
+            v = ctx._re(v)
+        return v
+    else:
+        return z*ctx.hyp1f2((1,2),(3,2),(3,2),-0.25*z*z)
+
+@defun_wrapped
+def chi(ctx, z):
+    nz = ctx.fneg(z, exact=True)
+    v = 0.5*(ctx.ei(z) + ctx.ei(nz))
+    zreal = ctx._re(z)
+    zimag = ctx._im(z)
+    if zimag > 0:
+        v += ctx.pi*0.5j
+    elif zimag < 0:
+        v -= ctx.pi*0.5j
+    elif zreal < 0:
+        v += ctx.pi*1j
+    return v
+
+@defun_wrapped
+def shi(ctx, z):
+    # Suffers from cancellation near 0
+    if ctx.mag(z) >= -1:
+        nz = ctx.fneg(z, exact=True)
+        v = 0.5*(ctx.ei(z) - ctx.ei(nz))
+        zimag = ctx._im(z)
+        if zimag > 0: v -= 0.5j*ctx.pi
+        if zimag < 0: v += 0.5j*ctx.pi
+        return v
+    else:
+        return z * ctx.hyp1f2((1,2),(3,2),(3,2),0.25*z*z)
+
+@defun_wrapped
+def fresnels(ctx, z):
+    if z == ctx.inf:
+        return ctx.mpf(0.5)
+    if z == ctx.ninf:
+        return ctx.mpf(-0.5)
+    return ctx.pi*z**3/6*ctx.hyp1f2((3,4),(3,2),(7,4),-ctx.pi**2*z**4/16)
+
+@defun_wrapped
+def fresnelc(ctx, z):
+    if z == ctx.inf:
+        return ctx.mpf(0.5)
+    if z == ctx.ninf:
+        return ctx.mpf(-0.5)
+    return z*ctx.hyp1f2((1,4),(1,2),(5,4),-ctx.pi**2*z**4/16)
diff --git a/lib/python3.10/site-packages/mpmath/functions/factorials.py b/lib/python3.10/site-packages/mpmath/functions/factorials.py
new file mode 100644
index 0000000000000000000000000000000000000000..9259e40b95bf1c908a7ad98b59bbb33528606b07
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/functions/factorials.py
@@ -0,0 +1,187 @@
+from ..libmp.backend import xrange
+from .functions import defun, defun_wrapped
+
+@defun
+def gammaprod(ctx, a, b, _infsign=False):
+    a = [ctx.convert(x) for x in a]
+    b = [ctx.convert(x) for x in b]
+    poles_num = []
+    poles_den = []
+    regular_num = []
+    regular_den = []
+    for x in a: [regular_num, poles_num][ctx.isnpint(x)].append(x)
+    for x in b: [regular_den, poles_den][ctx.isnpint(x)].append(x)
+    # One more pole in numerator or denominator gives 0 or inf
+    if len(poles_num) < len(poles_den): return ctx.zero
+    if len(poles_num) > len(poles_den):
+        # Get correct sign of infinity for x+h, h -> 0 from above
+        # XXX: hack, this should be done properly
+        if _infsign:
+            a = [x and x*(1+ctx.eps) or x+ctx.eps for x in poles_num]
+            b = [x and x*(1+ctx.eps) or x+ctx.eps for x in poles_den]
+            return ctx.sign(ctx.gammaprod(a+regular_num,b+regular_den)) * ctx.inf
+        else:
+            return ctx.inf
+    # All poles cancel
+    # lim G(i)/G(j) = (-1)**(i+j) * gamma(1-j) / gamma(1-i)
+    p = ctx.one
+    orig = ctx.prec
+    try:
+        ctx.prec = orig + 15
+        while poles_num:
+            i = poles_num.pop()
+            j = poles_den.pop()
+            p *= (-1)**(i+j) * ctx.gamma(1-j) / ctx.gamma(1-i)
+        for x in regular_num: p *= ctx.gamma(x)
+        for x in regular_den: p /= ctx.gamma(x)
+    finally:
+        ctx.prec = orig
+    return +p
+
+@defun
+def beta(ctx, x, y):
+    x = ctx.convert(x)
+    y = ctx.convert(y)
+    if ctx.isinf(y):
+        x, y = y, x
+    if ctx.isinf(x):
+        if x == ctx.inf and not ctx._im(y):
+            if y == ctx.ninf:
+                return ctx.nan
+            if y > 0:
+                return ctx.zero
+            if ctx.isint(y):
+                return ctx.nan
+            if y < 0:
+                return ctx.sign(ctx.gamma(y)) * ctx.inf
+        return ctx.nan
+    xy = ctx.fadd(x, y, prec=2*ctx.prec)
+    return ctx.gammaprod([x, y], [xy])
+
+@defun
+def binomial(ctx, n, k):
+    n1 = ctx.fadd(n, 1, prec=2*ctx.prec)
+    k1 = ctx.fadd(k, 1, prec=2*ctx.prec)
+    nk1 = ctx.fsub(n1, k, prec=2*ctx.prec)
+    return ctx.gammaprod([n1], [k1, nk1])
+
+@defun
+def rf(ctx, x, n):
+    xn = ctx.fadd(x, n, prec=2*ctx.prec)
+    return ctx.gammaprod([xn], [x])
+
+@defun
+def ff(ctx, x, n):
+    x1 = ctx.fadd(x, 1, prec=2*ctx.prec)
+    xn1 = ctx.fadd(ctx.fsub(x, n, prec=2*ctx.prec), 1, prec=2*ctx.prec)
+    return ctx.gammaprod([x1], [xn1])
+
+@defun_wrapped
+def fac2(ctx, x):
+    if ctx.isinf(x):
+        if x == ctx.inf:
+            return x
+        return ctx.nan
+    return 2**(x/2)*(ctx.pi/2)**((ctx.cospi(x)-1)/4)*ctx.gamma(x/2+1)
+
+@defun_wrapped
+def barnesg(ctx, z):
+    if ctx.isinf(z):
+        if z == ctx.inf:
+            return z
+        return ctx.nan
+    if ctx.isnan(z):
+        return z
+    if (not ctx._im(z)) and ctx._re(z) <= 0 and ctx.isint(ctx._re(z)):
+        return z*0
+    # Account for size (would not be needed if computing log(G))
+    if abs(z) > 5:
+        ctx.dps += 2*ctx.log(abs(z),2)
+    # Reflection formula
+    if ctx.re(z) < -ctx.dps:
+        w = 1-z
+        pi2 = 2*ctx.pi
+        u = ctx.expjpi(2*w)
+        v = ctx.j*ctx.pi/12 - ctx.j*ctx.pi*w**2/2 + w*ctx.ln(1-u) - \
+            ctx.j*ctx.polylog(2, u)/pi2
+        v = ctx.barnesg(2-z)*ctx.exp(v)/pi2**w
+        if ctx._is_real_type(z):
+            v = ctx._re(v)
+        return v
+    # Estimate terms for asymptotic expansion
+    # TODO: fixme, obviously
+    N = ctx.dps // 2 + 5
+    G = 1
+    while abs(z) < N or ctx.re(z) < 1:
+        G /= ctx.gamma(z)
+        z += 1
+    z -= 1
+    s = ctx.mpf(1)/12
+    s -= ctx.log(ctx.glaisher)
+    s += z*ctx.log(2*ctx.pi)/2
+    s += (z**2/2-ctx.mpf(1)/12)*ctx.log(z)
+    s -= 3*z**2/4
+    z2k = z2 = z**2
+    for k in xrange(1, N+1):
+        t = ctx.bernoulli(2*k+2) / (4*k*(k+1)*z2k)
+        if abs(t) < ctx.eps:
+            #print k, N      # check how many terms were needed
+            break
+        z2k *= z2
+        s += t
+    #if k == N:
+    #    print "warning: series for barnesg failed to converge", ctx.dps
+    return G*ctx.exp(s)
+
+@defun
+def superfac(ctx, z):
+    return ctx.barnesg(z+2)
+
+@defun_wrapped
+def hyperfac(ctx, z):
+    # XXX: estimate needed extra bits accurately
+    if z == ctx.inf:
+        return z
+    if abs(z) > 5:
+        extra = 4*int(ctx.log(abs(z),2))
+    else:
+        extra = 0
+    ctx.prec += extra
+    if not ctx._im(z) and ctx._re(z) < 0 and ctx.isint(ctx._re(z)):
+        n = int(ctx.re(z))
+        h = ctx.hyperfac(-n-1)
+        if ((n+1)//2) & 1:
+            h = -h
+        if ctx._is_complex_type(z):
+            return h + 0j
+        return h
+    zp1 = z+1
+    # Wrong branch cut
+    #v = ctx.gamma(zp1)**z
+    #ctx.prec -= extra
+    #return v / ctx.barnesg(zp1)
+    v = ctx.exp(z*ctx.loggamma(zp1))
+    ctx.prec -= extra
+    return v / ctx.barnesg(zp1)
+
+'''
+@defun
+def psi0(ctx, z):
+    """Shortcut for psi(0,z) (the digamma function)"""
+    return ctx.psi(0, z)
+
+@defun
+def psi1(ctx, z):
+    """Shortcut for psi(1,z) (the trigamma function)"""
+    return ctx.psi(1, z)
+
+@defun
+def psi2(ctx, z):
+    """Shortcut for psi(2,z) (the tetragamma function)"""
+    return ctx.psi(2, z)
+
+@defun
+def psi3(ctx, z):
+    """Shortcut for psi(3,z) (the pentagamma function)"""
+    return ctx.psi(3, z)
+'''
diff --git a/lib/python3.10/site-packages/mpmath/functions/functions.py b/lib/python3.10/site-packages/mpmath/functions/functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..4cdf5dd921418db10847ea75b32f8e6dfacdba64
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/functions/functions.py
@@ -0,0 +1,645 @@
+from ..libmp.backend import xrange
+
+class SpecialFunctions(object):
+    """
+    This class implements special functions using high-level code.
+
+    Elementary and some other functions (e.g. gamma function, basecase
+    hypergeometric series) are assumed to be predefined by the context as
+    "builtins" or "low-level" functions.
+    """
+    defined_functions = {}
+
+    # The series for the Jacobi theta functions converge for |q| < 1;
+    # in the current implementation they throw a ValueError for
+    # abs(q) > THETA_Q_LIM
+    THETA_Q_LIM = 1 - 10**-7
+
+    def __init__(self):
+        cls = self.__class__
+        for name in cls.defined_functions:
+            f, wrap = cls.defined_functions[name]
+            cls._wrap_specfun(name, f, wrap)
+
+        self.mpq_1 = self._mpq((1,1))
+        self.mpq_0 = self._mpq((0,1))
+        self.mpq_1_2 = self._mpq((1,2))
+        self.mpq_3_2 = self._mpq((3,2))
+        self.mpq_1_4 = self._mpq((1,4))
+        self.mpq_1_16 = self._mpq((1,16))
+        self.mpq_3_16 = self._mpq((3,16))
+        self.mpq_5_2 = self._mpq((5,2))
+        self.mpq_3_4 = self._mpq((3,4))
+        self.mpq_7_4 = self._mpq((7,4))
+        self.mpq_5_4 = self._mpq((5,4))
+        self.mpq_1_3 = self._mpq((1,3))
+        self.mpq_2_3 = self._mpq((2,3))
+        self.mpq_4_3 = self._mpq((4,3))
+        self.mpq_1_6 = self._mpq((1,6))
+        self.mpq_5_6 = self._mpq((5,6))
+        self.mpq_5_3 = self._mpq((5,3))
+
+        self._misc_const_cache = {}
+
+        self._aliases.update({
+            'phase' : 'arg',
+            'conjugate' : 'conj',
+            'nthroot' : 'root',
+            'polygamma' : 'psi',
+            'hurwitz' : 'zeta',
+            #'digamma' : 'psi0',
+            #'trigamma' : 'psi1',
+            #'tetragamma' : 'psi2',
+            #'pentagamma' : 'psi3',
+            'fibonacci' : 'fib',
+            'factorial' : 'fac',
+        })
+
+        self.zetazero_memoized = self.memoize(self.zetazero)
+
+    # Default -- do nothing
+    @classmethod
+    def _wrap_specfun(cls, name, f, wrap):
+        setattr(cls, name, f)
+
+    # Optional fast versions of common functions in common cases.
+    # If not overridden, default (generic hypergeometric series)
+    # implementations will be used
+    def _besselj(ctx, n, z): raise NotImplementedError
+    def _erf(ctx, z): raise NotImplementedError
+    def _erfc(ctx, z): raise NotImplementedError
+    def _gamma_upper_int(ctx, z, a): raise NotImplementedError
+    def _expint_int(ctx, n, z): raise NotImplementedError
+    def _zeta(ctx, s): raise NotImplementedError
+    def _zetasum_fast(ctx, s, a, n, derivatives, reflect): raise NotImplementedError
+    def _ei(ctx, z): raise NotImplementedError
+    def _e1(ctx, z): raise NotImplementedError
+    def _ci(ctx, z): raise NotImplementedError
+    def _si(ctx, z): raise NotImplementedError
+    def _altzeta(ctx, s): raise NotImplementedError
+
+def defun_wrapped(f):
+    SpecialFunctions.defined_functions[f.__name__] = f, True
+    return f
+
+def defun(f):
+    SpecialFunctions.defined_functions[f.__name__] = f, False
+    return f
+
+def defun_static(f):
+    setattr(SpecialFunctions, f.__name__, f)
+    return f
+
+@defun_wrapped
+def cot(ctx, z): return ctx.one / ctx.tan(z)
+
+@defun_wrapped
+def sec(ctx, z): return ctx.one / ctx.cos(z)
+
+@defun_wrapped
+def csc(ctx, z): return ctx.one / ctx.sin(z)
+
+@defun_wrapped
+def coth(ctx, z): return ctx.one / ctx.tanh(z)
+
+@defun_wrapped
+def sech(ctx, z): return ctx.one / ctx.cosh(z)
+
+@defun_wrapped
+def csch(ctx, z): return ctx.one / ctx.sinh(z)
+
+@defun_wrapped
+def acot(ctx, z):
+    if not z:
+        return ctx.pi * 0.5
+    else:
+        return ctx.atan(ctx.one / z)
+
+@defun_wrapped
+def asec(ctx, z): return ctx.acos(ctx.one / z)
+
+@defun_wrapped
+def acsc(ctx, z): return ctx.asin(ctx.one / z)
+
+@defun_wrapped
+def acoth(ctx, z):
+    if not z:
+        return ctx.pi * 0.5j
+    else:
+        return ctx.atanh(ctx.one / z)
+
+
+@defun_wrapped
+def asech(ctx, z): return ctx.acosh(ctx.one / z)
+
+@defun_wrapped
+def acsch(ctx, z): return ctx.asinh(ctx.one / z)
+
+@defun
+def sign(ctx, x):
+    x = ctx.convert(x)
+    if not x or ctx.isnan(x):
+        return x
+    if ctx._is_real_type(x):
+        if x > 0:
+            return ctx.one
+        else:
+            return -ctx.one
+    return x / abs(x)
+
+@defun
+def agm(ctx, a, b=1):
+    if b == 1:
+        return ctx.agm1(a)
+    a = ctx.convert(a)
+    b = ctx.convert(b)
+    return ctx._agm(a, b)
+
+@defun_wrapped
+def sinc(ctx, x):
+    if ctx.isinf(x):
+        return 1/x
+    if not x:
+        return x+1
+    return ctx.sin(x)/x
+
+@defun_wrapped
+def sincpi(ctx, x):
+    if ctx.isinf(x):
+        return 1/x
+    if not x:
+        return x+1
+    return ctx.sinpi(x)/(ctx.pi*x)
+
+# TODO: tests; improve implementation
+@defun_wrapped
+def expm1(ctx, x):
+    if not x:
+        return ctx.zero
+    # exp(x) - 1 ~ x
+    if ctx.mag(x) < -ctx.prec:
+        return x + 0.5*x**2
+    # TODO: accurately eval the smaller of the real/imag parts
+    return ctx.sum_accurately(lambda: iter([ctx.exp(x),-1]),1)
+
+@defun_wrapped
+def log1p(ctx, x):
+    if not x:
+        return ctx.zero
+    if ctx.mag(x) < -ctx.prec:
+        return x - 0.5*x**2
+    return ctx.log(ctx.fadd(1, x, prec=2*ctx.prec))
+
+@defun_wrapped
+def powm1(ctx, x, y):
+    mag = ctx.mag
+    one = ctx.one
+    w = x**y - one
+    M = mag(w)
+    # Only moderate cancellation
+    if M > -8:
+        return w
+    # Check for the only possible exact cases
+    if not w:
+        if (not y) or (x in (1, -1, 1j, -1j) and ctx.isint(y)):
+            return w
+    x1 = x - one
+    magy = mag(y)
+    lnx = ctx.ln(x)
+    # Small y: x^y - 1 ~ log(x)*y + O(log(x)^2 * y^2)
+    if magy + mag(lnx) < -ctx.prec:
+        return lnx*y + (lnx*y)**2/2
+    # TODO: accurately eval the smaller of the real/imag part
+    return ctx.sum_accurately(lambda: iter([x**y, -1]), 1)
+
+@defun
+def _rootof1(ctx, k, n):
+    k = int(k)
+    n = int(n)
+    k %= n
+    if not k:
+        return ctx.one
+    elif 2*k == n:
+        return -ctx.one
+    elif 4*k == n:
+        return ctx.j
+    elif 4*k == 3*n:
+        return -ctx.j
+    return ctx.expjpi(2*ctx.mpf(k)/n)
+
+@defun
+def root(ctx, x, n, k=0):
+    n = int(n)
+    x = ctx.convert(x)
+    if k:
+        # Special case: there is an exact real root
+        if (n & 1 and 2*k == n-1) and (not ctx.im(x)) and (ctx.re(x) < 0):
+            return -ctx.root(-x, n)
+        # Multiply by root of unity
+        prec = ctx.prec
+        try:
+            ctx.prec += 10
+            v = ctx.root(x, n, 0) * ctx._rootof1(k, n)
+        finally:
+            ctx.prec = prec
+        return +v
+    return ctx._nthroot(x, n)
+
+@defun
+def unitroots(ctx, n, primitive=False):
+    gcd = ctx._gcd
+    prec = ctx.prec
+    try:
+        ctx.prec += 10
+        if primitive:
+            v = [ctx._rootof1(k,n) for k in range(n) if gcd(k,n) == 1]
+        else:
+            # TODO: this can be done *much* faster
+            v = [ctx._rootof1(k,n) for k in range(n)]
+    finally:
+        ctx.prec = prec
+    return [+x for x in v]
+
+@defun
+def arg(ctx, x):
+    x = ctx.convert(x)
+    re = ctx._re(x)
+    im = ctx._im(x)
+    return ctx.atan2(im, re)
+
+@defun
+def fabs(ctx, x):
+    return abs(ctx.convert(x))
+
+@defun
+def re(ctx, x):
+    x = ctx.convert(x)
+    if hasattr(x, "real"):    # py2.5 doesn't have .real/.imag for all numbers
+        return x.real
+    return x
+
+@defun
+def im(ctx, x):
+    x = ctx.convert(x)
+    if hasattr(x, "imag"):    # py2.5 doesn't have .real/.imag for all numbers
+        return x.imag
+    return ctx.zero
+
+@defun
+def conj(ctx, x):
+    x = ctx.convert(x)
+    try:
+        return x.conjugate()
+    except AttributeError:
+        return x
+
+@defun
+def polar(ctx, z):
+    return (ctx.fabs(z), ctx.arg(z))
+
+@defun_wrapped
+def rect(ctx, r, phi):
+    return r * ctx.mpc(*ctx.cos_sin(phi))
+
+@defun
+def log(ctx, x, b=None):
+    if b is None:
+        return ctx.ln(x)
+    wp = ctx.prec + 20
+    return ctx.ln(x, prec=wp) / ctx.ln(b, prec=wp)
+
+@defun
+def log10(ctx, x):
+    return ctx.log(x, 10)
+
+@defun
+def fmod(ctx, x, y):
+    return ctx.convert(x) % ctx.convert(y)
+
+@defun
+def degrees(ctx, x):
+    return x / ctx.degree
+
+@defun
+def radians(ctx, x):
+    return x * ctx.degree
+
+def _lambertw_special(ctx, z, k):
+    # W(0,0) = 0; all other branches are singular
+    if not z:
+        if not k:
+            return z
+        return ctx.ninf + z
+    if z == ctx.inf:
+        if k == 0:
+            return z
+        else:
+            return z + 2*k*ctx.pi*ctx.j
+    if z == ctx.ninf:
+        return (-z) + (2*k+1)*ctx.pi*ctx.j
+    # Some kind of nan or complex inf/nan?
+    return ctx.ln(z)
+
+import math
+import cmath
+
+def _lambertw_approx_hybrid(z, k):
+    imag_sign = 0
+    if hasattr(z, "imag"):
+        x = float(z.real)
+        y = z.imag
+        if y:
+            imag_sign = (-1) ** (y < 0)
+        y = float(y)
+    else:
+        x = float(z)
+        y = 0.0
+        imag_sign = 0
+    # hack to work regardless of whether Python supports -0.0
+    if not y:
+        y = 0.0
+    z = complex(x,y)
+    if k == 0:
+        if -4.0 < y < 4.0 and -1.0 < x < 2.5:
+            if imag_sign:
+                # Taylor series in upper/lower half-plane
+                if y > 1.00: return (0.876+0.645j) + (0.118-0.174j)*(z-(0.75+2.5j))
+                if y > 0.25: return (0.505+0.204j) + (0.375-0.132j)*(z-(0.75+0.5j))
+                if y < -1.00: return (0.876-0.645j) + (0.118+0.174j)*(z-(0.75-2.5j))
+                if y < -0.25: return (0.505-0.204j) + (0.375+0.132j)*(z-(0.75-0.5j))
+            # Taylor series near -1
+            if x < -0.5:
+                if imag_sign >= 0:
+                    return (-0.318+1.34j) + (-0.697-0.593j)*(z+1)
+                else:
+                    return (-0.318-1.34j) + (-0.697+0.593j)*(z+1)
+            # return real type
+            r = -0.367879441171442
+            if (not imag_sign) and x > r:
+                z = x
+            # Singularity near -1/e
+            if x < -0.2:
+                return -1 + 2.33164398159712*(z-r)**0.5 - 1.81218788563936*(z-r)
+            # Taylor series near 0
+            if x < 0.5: return z
+            # Simple linear approximation
+            return 0.2 + 0.3*z
+        if (not imag_sign) and x > 0.0:
+            L1 = math.log(x); L2 = math.log(L1)
+        else:
+            L1 = cmath.log(z); L2 = cmath.log(L1)
+    elif k == -1:
+        # return real type
+        r = -0.367879441171442
+        if (not imag_sign) and r < x < 0.0:
+            z = x
+        if (imag_sign >= 0) and y < 0.1 and -0.6 < x < -0.2:
+            return -1 - 2.33164398159712*(z-r)**0.5 - 1.81218788563936*(z-r)
+        if (not imag_sign) and -0.2 <= x < 0.0:
+            L1 = math.log(-x)
+            return L1 - math.log(-L1)
+        else:
+            if imag_sign == -1 and (not y) and x < 0.0:
+                L1 = cmath.log(z) - 3.1415926535897932j
+            else:
+                L1 = cmath.log(z) - 6.2831853071795865j
+            L2 = cmath.log(L1)
+    return L1 - L2 + L2/L1 + L2*(L2-2)/(2*L1**2)
+
+def _lambertw_series(ctx, z, k, tol):
+    """
+    Return rough approximation for W_k(z) from an asymptotic series,
+    sufficiently accurate for the Halley iteration to converge to
+    the correct value.
+    """
+    magz = ctx.mag(z)
+    if (-10 < magz < 900) and (-1000 < k < 1000):
+        # Near the branch point at -1/e
+        if magz < 1 and abs(z+0.36787944117144) < 0.05:
+            if k == 0 or (k == -1 and ctx._im(z) >= 0) or \
+                         (k == 1  and ctx._im(z) < 0):
+                delta = ctx.sum_accurately(lambda: [z, ctx.exp(-1)])
+                cancellation = -ctx.mag(delta)
+                ctx.prec += cancellation
+                # Use series given in Corless et al.
+                p = ctx.sqrt(2*(ctx.e*z+1))
+                ctx.prec -= cancellation
+                u = {0:ctx.mpf(-1), 1:ctx.mpf(1)}
+                a = {0:ctx.mpf(2), 1:ctx.mpf(-1)}
+                if k != 0:
+                    p = -p
+                s = ctx.zero
+                # The series converges, so we could use it directly, but unless
+                # *extremely* close, it is better to just use the first few
+                # terms to get a good approximation for the iteration
+                for l in xrange(max(2,cancellation)):
+                    if l not in u:
+                        a[l] = ctx.fsum(u[j]*u[l+1-j] for j in xrange(2,l))
+                        u[l] = (l-1)*(u[l-2]/2+a[l-2]/4)/(l+1)-a[l]/2-u[l-1]/(l+1)
+                    term = u[l] * p**l
+                    s += term
+                    if ctx.mag(term) < -tol:
+                        return s, True
+                    l += 1
+                ctx.prec += cancellation//2
+                return s, False
+        if k == 0 or k == -1:
+            return _lambertw_approx_hybrid(z, k), False
+    if k == 0:
+        if magz < -1:
+            return z*(1-z), False
+        L1 = ctx.ln(z)
+        L2 = ctx.ln(L1)
+    elif k == -1 and (not ctx._im(z)) and (-0.36787944117144 < ctx._re(z) < 0):
+        L1 = ctx.ln(-z)
+        return L1 - ctx.ln(-L1), False
+    else:
+        # This holds both as z -> 0 and z -> inf.
+        # Relative error is O(1/log(z)).
+        L1 = ctx.ln(z) + 2j*ctx.pi*k
+        L2 = ctx.ln(L1)
+    return L1 - L2 + L2/L1 + L2*(L2-2)/(2*L1**2), False
+
+@defun
+def lambertw(ctx, z, k=0):
+    z = ctx.convert(z)
+    k = int(k)
+    if not ctx.isnormal(z):
+        return _lambertw_special(ctx, z, k)
+    prec = ctx.prec
+    ctx.prec += 20 + ctx.mag(k or 1)
+    wp = ctx.prec
+    tol = wp - 5
+    w, done = _lambertw_series(ctx, z, k, tol)
+    if not done:
+        # Use Halley iteration to solve w*exp(w) = z
+        two = ctx.mpf(2)
+        for i in xrange(100):
+            ew = ctx.exp(w)
+            wew = w*ew
+            wewz = wew-z
+            wn = w - wewz/(wew+ew-(w+two)*wewz/(two*w+two))
+            if ctx.mag(wn-w) <= ctx.mag(wn) - tol:
+                w = wn
+                break
+            else:
+                w = wn
+        if i == 100:
+            ctx.warn("Lambert W iteration failed to converge for z = %s" % z)
+    ctx.prec = prec
+    return +w
+
+@defun_wrapped
+def bell(ctx, n, x=1):
+    x = ctx.convert(x)
+    if not n:
+        if ctx.isnan(x):
+            return x
+        return type(x)(1)
+    if ctx.isinf(x) or ctx.isinf(n) or ctx.isnan(x) or ctx.isnan(n):
+        return x**n
+    if n == 1: return x
+    if n == 2: return x*(x+1)
+    if x == 0: return ctx.sincpi(n)
+    return _polyexp(ctx, n, x, True) / ctx.exp(x)
+
+def _polyexp(ctx, n, x, extra=False):
+    def _terms():
+        if extra:
+            yield ctx.sincpi(n)
+        t = x
+        k = 1
+        while 1:
+            yield k**n * t
+            k += 1
+            t = t*x/k
+    return ctx.sum_accurately(_terms, check_step=4)
+
+@defun_wrapped
+def polyexp(ctx, s, z):
+    if ctx.isinf(z) or ctx.isinf(s) or ctx.isnan(z) or ctx.isnan(s):
+        return z**s
+    if z == 0: return z*s
+    if s == 0: return ctx.expm1(z)
+    if s == 1: return ctx.exp(z)*z
+    if s == 2: return ctx.exp(z)*z*(z+1)
+    return _polyexp(ctx, s, z)
+
+@defun_wrapped
+def cyclotomic(ctx, n, z):
+    n = int(n)
+    if n < 0:
+        raise ValueError("n cannot be negative")
+    p = ctx.one
+    if n == 0:
+        return p
+    if n == 1:
+        return z - p
+    if n == 2:
+        return z + p
+    # Use divisor product representation. Unfortunately, this sometimes
+    # includes singularities for roots of unity, which we have to cancel out.
+    # Matching zeros/poles pairwise, we have (1-z^a)/(1-z^b) ~ a/b + O(z-1).
+    a_prod = 1
+    b_prod = 1
+    num_zeros = 0
+    num_poles = 0
+    for d in range(1,n+1):
+        if not n % d:
+            w = ctx.moebius(n//d)
+            # Use powm1 because it is important that we get 0 only
+            # if it really is exactly 0
+            b = -ctx.powm1(z, d)
+            if b:
+                p *= b**w
+            else:
+                if w == 1:
+                    a_prod *= d
+                    num_zeros += 1
+                elif w == -1:
+                    b_prod *= d
+                    num_poles += 1
+    #print n, num_zeros, num_poles
+    if num_zeros:
+        if num_zeros > num_poles:
+            p *= 0
+        else:
+            p *= a_prod
+            p /= b_prod
+    return p
+
+@defun
+def mangoldt(ctx, n):
+    r"""
+    Evaluates the von Mangoldt function `\Lambda(n) = \log p`
+    if `n = p^k` a power of a prime, and `\Lambda(n) = 0` otherwise.
+
+    **Examples**
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> [mangoldt(n) for n in range(-2,3)]
+        [0.0, 0.0, 0.0, 0.0, 0.6931471805599453094172321]
+        >>> mangoldt(6)
+        0.0
+        >>> mangoldt(7)
+        1.945910149055313305105353
+        >>> mangoldt(8)
+        0.6931471805599453094172321
+        >>> fsum(mangoldt(n) for n in range(101))
+        94.04531122935739224600493
+        >>> fsum(mangoldt(n) for n in range(10001))
+        10013.39669326311478372032
+
+    """
+    n = int(n)
+    if n < 2:
+        return ctx.zero
+    if n % 2 == 0:
+        # Must be a power of two
+        if n & (n-1) == 0:
+            return +ctx.ln2
+        else:
+            return ctx.zero
+    # TODO: the following could be generalized into a perfect
+    # power testing function
+    # ---
+    # Look for a small factor
+    for p in (3,5,7,11,13,17,19,23,29,31):
+        if not n % p:
+            q, r = n // p, 0
+            while q > 1:
+                q, r = divmod(q, p)
+                if r:
+                    return ctx.zero
+            return ctx.ln(p)
+    if ctx.isprime(n):
+        return ctx.ln(n)
+    # Obviously, we could use arbitrary-precision arithmetic for this...
+    if n > 10**30:
+        raise NotImplementedError
+    k = 2
+    while 1:
+        p = int(n**(1./k) + 0.5)
+        if p < 2:
+            return ctx.zero
+        if p ** k == n:
+            if ctx.isprime(p):
+                return ctx.ln(p)
+        k += 1
+
+@defun
+def stirling1(ctx, n, k, exact=False):
+    v = ctx._stirling1(int(n), int(k))
+    if exact:
+        return int(v)
+    else:
+        return ctx.mpf(v)
+
+@defun
+def stirling2(ctx, n, k, exact=False):
+    v = ctx._stirling2(int(n), int(k))
+    if exact:
+        return int(v)
+    else:
+        return ctx.mpf(v)
diff --git a/lib/python3.10/site-packages/mpmath/functions/hypergeometric.py b/lib/python3.10/site-packages/mpmath/functions/hypergeometric.py
new file mode 100644
index 0000000000000000000000000000000000000000..ddb50cbf3ea6daa5982678d3c26157a67a7d7945
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/functions/hypergeometric.py
@@ -0,0 +1,1413 @@
+from ..libmp.backend import xrange
+from .functions import defun, defun_wrapped
+
+def _check_need_perturb(ctx, terms, prec, discard_known_zeros):
+    perturb = recompute = False
+    extraprec = 0
+    discard = []
+    for term_index, term in enumerate(terms):
+        w_s, c_s, alpha_s, beta_s, a_s, b_s, z = term
+        have_singular_nongamma_weight = False
+        # Avoid division by zero in leading factors (TODO:
+        # also check for near division by zero?)
+        for k, w in enumerate(w_s):
+            if not w:
+                if ctx.re(c_s[k]) <= 0 and c_s[k]:
+                    perturb = recompute = True
+                    have_singular_nongamma_weight = True
+        pole_count = [0, 0, 0]
+        # Check for gamma and series poles and near-poles
+        for data_index, data in enumerate([alpha_s, beta_s, b_s]):
+            for i, x in enumerate(data):
+                n, d = ctx.nint_distance(x)
+                # Poles
+                if n > 0:
+                    continue
+                if d == ctx.ninf:
+                    # OK if we have a polynomial
+                    # ------------------------------
+                    ok = False
+                    if data_index == 2:
+                        for u in a_s:
+                            if ctx.isnpint(u) and u >= int(n):
+                                ok = True
+                                break
+                    if ok:
+                        continue
+                    pole_count[data_index] += 1
+                    # ------------------------------
+                    #perturb = recompute = True
+                    #return perturb, recompute, extraprec
+                elif d < -4:
+                    extraprec += -d
+                    recompute = True
+        if discard_known_zeros and pole_count[1] > pole_count[0] + pole_count[2] \
+            and not have_singular_nongamma_weight:
+            discard.append(term_index)
+        elif sum(pole_count):
+            perturb = recompute = True
+    return perturb, recompute, extraprec, discard
+
+_hypercomb_msg = """
+hypercomb() failed to converge to the requested %i bits of accuracy
+using a working precision of %i bits. The function value may be zero or
+infinite; try passing zeroprec=N or infprec=M to bound finite values between
+2^(-N) and 2^M. Otherwise try a higher maxprec or maxterms.
+"""
+
+@defun
+def hypercomb(ctx, function, params=[], discard_known_zeros=True, **kwargs):
+    orig = ctx.prec
+    sumvalue = ctx.zero
+    dist = ctx.nint_distance
+    ninf = ctx.ninf
+    orig_params = params[:]
+    verbose = kwargs.get('verbose', False)
+    maxprec = kwargs.get('maxprec', ctx._default_hyper_maxprec(orig))
+    kwargs['maxprec'] = maxprec   # For calls to hypsum
+    zeroprec = kwargs.get('zeroprec')
+    infprec = kwargs.get('infprec')
+    perturbed_reference_value = None
+    hextra = 0
+    try:
+        while 1:
+            ctx.prec += 10
+            if ctx.prec > maxprec:
+                raise ValueError(_hypercomb_msg % (orig, ctx.prec))
+            orig2 = ctx.prec
+            params = orig_params[:]
+            terms = function(*params)
+            if verbose:
+                print()
+                print("ENTERING hypercomb main loop")
+                print("prec =", ctx.prec)
+                print("hextra", hextra)
+            perturb, recompute, extraprec, discard = \
+                _check_need_perturb(ctx, terms, orig, discard_known_zeros)
+            ctx.prec += extraprec
+            if perturb:
+                if "hmag" in kwargs:
+                    hmag = kwargs["hmag"]
+                elif ctx._fixed_precision:
+                    hmag = int(ctx.prec*0.3)
+                else:
+                    hmag = orig + 10 + hextra
+                h = ctx.ldexp(ctx.one, -hmag)
+                ctx.prec = orig2 + 10 + hmag + 10
+                for k in range(len(params)):
+                    params[k] += h
+                    # Heuristically ensure that the perturbations
+                    # are "independent" so that two perturbations
+                    # don't accidentally cancel each other out
+                    # in a subtraction.
+                    h += h/(k+1)
+            if recompute:
+                terms = function(*params)
+            if discard_known_zeros:
+                terms = [term for (i, term) in enumerate(terms) if i not in discard]
+            if not terms:
+                return ctx.zero
+            evaluated_terms = []
+            for term_index, term_data in enumerate(terms):
+                w_s, c_s, alpha_s, beta_s, a_s, b_s, z = term_data
+                if verbose:
+                    print()
+                    print("  Evaluating term %i/%i : %iF%i" % \
+                        (term_index+1, len(terms), len(a_s), len(b_s)))
+                    print("    powers", ctx.nstr(w_s), ctx.nstr(c_s))
+                    print("    gamma", ctx.nstr(alpha_s), ctx.nstr(beta_s))
+                    print("    hyper", ctx.nstr(a_s), ctx.nstr(b_s))
+                    print("    z", ctx.nstr(z))
+                #v = ctx.hyper(a_s, b_s, z, **kwargs)
+                #for a in alpha_s: v *= ctx.gamma(a)
+                #for b in beta_s: v *= ctx.rgamma(b)
+                #for w, c in zip(w_s, c_s): v *= ctx.power(w, c)
+                v = ctx.fprod([ctx.hyper(a_s, b_s, z, **kwargs)] + \
+                    [ctx.gamma(a) for a in alpha_s] + \
+                    [ctx.rgamma(b) for b in beta_s] + \
+                    [ctx.power(w,c) for (w,c) in zip(w_s,c_s)])
+                if verbose:
+                    print("    Value:", v)
+                evaluated_terms.append(v)
+
+            if len(terms) == 1 and (not perturb):
+                sumvalue = evaluated_terms[0]
+                break
+
+            if ctx._fixed_precision:
+                sumvalue = ctx.fsum(evaluated_terms)
+                break
+
+            sumvalue = ctx.fsum(evaluated_terms)
+            term_magnitudes = [ctx.mag(x) for x in evaluated_terms]
+            max_magnitude = max(term_magnitudes)
+            sum_magnitude = ctx.mag(sumvalue)
+            cancellation = max_magnitude - sum_magnitude
+            if verbose:
+                print()
+                print("  Cancellation:", cancellation, "bits")
+                print("  Increased precision:", ctx.prec - orig, "bits")
+
+            precision_ok = cancellation < ctx.prec - orig
+
+            if zeroprec is None:
+                zero_ok = False
+            else:
+                zero_ok = max_magnitude - ctx.prec < -zeroprec
+            if infprec is None:
+                inf_ok = False
+            else:
+                inf_ok = max_magnitude > infprec
+
+            if precision_ok and (not perturb) or ctx.isnan(cancellation):
+                break
+            elif precision_ok:
+                if perturbed_reference_value is None:
+                    hextra += 20
+                    perturbed_reference_value = sumvalue
+                    continue
+                elif ctx.mag(sumvalue - perturbed_reference_value) <= \
+                        ctx.mag(sumvalue) - orig:
+                    break
+                elif zero_ok:
+                    sumvalue = ctx.zero
+                    break
+                elif inf_ok:
+                    sumvalue = ctx.inf
+                    break
+                elif 'hmag' in kwargs:
+                    break
+                else:
+                    hextra *= 2
+                    perturbed_reference_value = sumvalue
+            # Increase precision
+            else:
+                increment = min(max(cancellation, orig//2), max(extraprec,orig))
+                ctx.prec += increment
+                if verbose:
+                    print("  Must start over with increased precision")
+                continue
+    finally:
+        ctx.prec = orig
+    return +sumvalue
+
+@defun
+def hyper(ctx, a_s, b_s, z, **kwargs):
+    """
+    Hypergeometric function, general case.
+    """
+    z = ctx.convert(z)
+    p = len(a_s)
+    q = len(b_s)
+    a_s = [ctx._convert_param(a) for a in a_s]
+    b_s = [ctx._convert_param(b) for b in b_s]
+    # Reduce degree by eliminating common parameters
+    if kwargs.get('eliminate', True):
+        elim_nonpositive = kwargs.get('eliminate_all', False)
+        i = 0
+        while i < q and a_s:
+            b = b_s[i]
+            if b in a_s and (elim_nonpositive or not ctx.isnpint(b[0])):
+                a_s.remove(b)
+                b_s.remove(b)
+                p -= 1
+                q -= 1
+            else:
+                i += 1
+    # Handle special cases
+    if p == 0:
+        if   q == 1: return ctx._hyp0f1(b_s, z, **kwargs)
+        elif q == 0: return ctx.exp(z)
+    elif p == 1:
+        if   q == 1: return ctx._hyp1f1(a_s, b_s, z, **kwargs)
+        elif q == 2: return ctx._hyp1f2(a_s, b_s, z, **kwargs)
+        elif q == 0: return ctx._hyp1f0(a_s[0][0], z)
+    elif p == 2:
+        if   q == 1: return ctx._hyp2f1(a_s, b_s, z, **kwargs)
+        elif q == 2: return ctx._hyp2f2(a_s, b_s, z, **kwargs)
+        elif q == 3: return ctx._hyp2f3(a_s, b_s, z, **kwargs)
+        elif q == 0: return ctx._hyp2f0(a_s, b_s, z, **kwargs)
+    elif p == q+1:
+        return ctx._hypq1fq(p, q, a_s, b_s, z, **kwargs)
+    elif p > q+1 and not kwargs.get('force_series'):
+        return ctx._hyp_borel(p, q, a_s, b_s, z, **kwargs)
+    coeffs, types = zip(*(a_s+b_s))
+    return ctx.hypsum(p, q, types, coeffs, z, **kwargs)
+
+@defun
+def hyp0f1(ctx,b,z,**kwargs):
+    return ctx.hyper([],[b],z,**kwargs)
+
+@defun
+def hyp1f1(ctx,a,b,z,**kwargs):
+    return ctx.hyper([a],[b],z,**kwargs)
+
+@defun
+def hyp1f2(ctx,a1,b1,b2,z,**kwargs):
+    return ctx.hyper([a1],[b1,b2],z,**kwargs)
+
+@defun
+def hyp2f1(ctx,a,b,c,z,**kwargs):
+    return ctx.hyper([a,b],[c],z,**kwargs)
+
+@defun
+def hyp2f2(ctx,a1,a2,b1,b2,z,**kwargs):
+    return ctx.hyper([a1,a2],[b1,b2],z,**kwargs)
+
+@defun
+def hyp2f3(ctx,a1,a2,b1,b2,b3,z,**kwargs):
+    return ctx.hyper([a1,a2],[b1,b2,b3],z,**kwargs)
+
+@defun
+def hyp2f0(ctx,a,b,z,**kwargs):
+    return ctx.hyper([a,b],[],z,**kwargs)
+
+@defun
+def hyp3f2(ctx,a1,a2,a3,b1,b2,z,**kwargs):
+    return ctx.hyper([a1,a2,a3],[b1,b2],z,**kwargs)
+
+@defun_wrapped
+def _hyp1f0(ctx, a, z):
+    return (1-z) ** (-a)
+
+@defun
+def _hyp0f1(ctx, b_s, z, **kwargs):
+    (b, btype), = b_s
+    if z:
+        magz = ctx.mag(z)
+    else:
+        magz = 0
+    if magz >= 8 and not kwargs.get('force_series'):
+        try:
+            # http://functions.wolfram.com/HypergeometricFunctions/
+            # Hypergeometric0F1/06/02/03/0004/
+            # TODO: handle the all-real case more efficiently!
+            # TODO: figure out how much precision is needed (exponential growth)
+            orig = ctx.prec
+            try:
+                ctx.prec += 12 + magz//2
+                def h():
+                    w = ctx.sqrt(-z)
+                    jw = ctx.j*w
+                    u = 1/(4*jw)
+                    c = ctx.mpq_1_2 - b
+                    E = ctx.exp(2*jw)
+                    T1 = ([-jw,E], [c,-1], [], [], [b-ctx.mpq_1_2, ctx.mpq_3_2-b], [], -u)
+                    T2 = ([jw,E], [c,1], [], [], [b-ctx.mpq_1_2, ctx.mpq_3_2-b], [], u)
+                    return T1, T2
+                v = ctx.hypercomb(h, [], force_series=True)
+                v = ctx.gamma(b)/(2*ctx.sqrt(ctx.pi))*v
+            finally:
+                ctx.prec = orig
+            if ctx._is_real_type(b) and ctx._is_real_type(z):
+                v = ctx._re(v)
+            return +v
+        except ctx.NoConvergence:
+            pass
+    return ctx.hypsum(0, 1, (btype,), [b], z, **kwargs)
+
+@defun
+def _hyp1f1(ctx, a_s, b_s, z, **kwargs):
+    (a, atype), = a_s
+    (b, btype), = b_s
+    if not z:
+        return ctx.one+z
+    magz = ctx.mag(z)
+    if magz >= 7 and not (ctx.isint(a) and ctx.re(a) <= 0):
+        if ctx.isinf(z):
+            if ctx.sign(a) == ctx.sign(b) == ctx.sign(z) == 1:
+                return ctx.inf
+            return ctx.nan * z
+        try:
+            try:
+                ctx.prec += magz
+                sector = ctx._im(z) < 0
+                def h(a,b):
+                    if sector:
+                        E = ctx.expjpi(ctx.fneg(a, exact=True))
+                    else:
+                        E = ctx.expjpi(a)
+                    rz = 1/z
+                    T1 = ([E,z], [1,-a], [b], [b-a], [a, 1+a-b], [], -rz)
+                    T2 = ([ctx.exp(z),z], [1,a-b], [b], [a], [b-a, 1-a], [], rz)
+                    return T1, T2
+                v = ctx.hypercomb(h, [a,b], force_series=True)
+                if ctx._is_real_type(a) and ctx._is_real_type(b) and ctx._is_real_type(z):
+                    v = ctx._re(v)
+                return +v
+            except ctx.NoConvergence:
+                pass
+        finally:
+            ctx.prec -= magz
+    v = ctx.hypsum(1, 1, (atype, btype), [a, b], z, **kwargs)
+    return v
+
+def _hyp2f1_gosper(ctx,a,b,c,z,**kwargs):
+    # Use Gosper's recurrence
+    # See http://www.math.utexas.edu/pipermail/maxima/2006/000126.html
+    _a,_b,_c,_z = a, b, c, z
+    orig = ctx.prec
+    maxprec = kwargs.get('maxprec', 100*orig)
+    extra = 10
+    while 1:
+        ctx.prec = orig + extra
+        #a = ctx.convert(_a)
+        #b = ctx.convert(_b)
+        #c = ctx.convert(_c)
+        z = ctx.convert(_z)
+        d = ctx.mpf(0)
+        e = ctx.mpf(1)
+        f = ctx.mpf(0)
+        k = 0
+        # Common subexpression elimination, unfortunately making
+        # things a bit unreadable. The formula is quite messy to begin
+        # with, though...
+        abz = a*b*z
+        ch = c * ctx.mpq_1_2
+        c1h = (c+1) * ctx.mpq_1_2
+        nz = 1-z
+        g = z/nz
+        abg = a*b*g
+        cba = c-b-a
+        z2 = z-2
+        tol = -ctx.prec - 10
+        nstr = ctx.nstr
+        nprint = ctx.nprint
+        mag = ctx.mag
+        maxmag = ctx.ninf
+        while 1:
+            kch = k+ch
+            kakbz = (k+a)*(k+b)*z / (4*(k+1)*kch*(k+c1h))
+            d1 = kakbz*(e-(k+cba)*d*g)
+            e1 = kakbz*(d*abg+(k+c)*e)
+            ft = d*(k*(cba*z+k*z2-c)-abz)/(2*kch*nz)
+            f1 = f + e - ft
+            maxmag = max(maxmag, mag(f1))
+            if mag(f1-f) < tol:
+                break
+            d, e, f = d1, e1, f1
+            k += 1
+        cancellation = maxmag - mag(f1)
+        if cancellation < extra:
+            break
+        else:
+            extra += cancellation
+            if extra > maxprec:
+                raise ctx.NoConvergence
+    return f1
+
+@defun
+def _hyp2f1(ctx, a_s, b_s, z, **kwargs):
+    (a, atype), (b, btype) = a_s
+    (c, ctype), = b_s
+    if z == 1:
+        # TODO: the following logic can be simplified
+        convergent = ctx.re(c-a-b) > 0
+        finite = (ctx.isint(a) and a <= 0) or (ctx.isint(b) and b <= 0)
+        zerodiv = ctx.isint(c) and c <= 0 and not \
+            ((ctx.isint(a) and c <= a <= 0) or (ctx.isint(b) and c <= b <= 0))
+        #print "bz", a, b, c, z, convergent, finite, zerodiv
+        # Gauss's theorem gives the value if convergent
+        if (convergent or finite) and not zerodiv:
+            return ctx.gammaprod([c, c-a-b], [c-a, c-b], _infsign=True)
+        # Otherwise, there is a pole and we take the
+        # sign to be that when approaching from below
+        # XXX: this evaluation is not necessarily correct in all cases
+        return ctx.hyp2f1(a,b,c,1-ctx.eps*2) * ctx.inf
+
+    # Equal to 1 (first term), unless there is a subsequent
+    # division by zero
+    if not z:
+        # Division by zero but power of z is higher than
+        # first order so cancels
+        if c or a == 0 or b == 0:
+            return 1+z
+        # Indeterminate
+        return ctx.nan
+
+    # Hit zero denominator unless numerator goes to 0 first
+    if ctx.isint(c) and c <= 0:
+        if (ctx.isint(a) and c <= a <= 0) or \
+           (ctx.isint(b) and c <= b <= 0):
+            pass
+        else:
+            # Pole in series
+            return ctx.inf
+
+    absz = abs(z)
+
+    # Fast case: standard series converges rapidly,
+    # possibly in finitely many terms
+    if absz <= 0.8 or (ctx.isint(a) and a <= 0 and a >= -1000) or \
+                      (ctx.isint(b) and b <= 0 and b >= -1000):
+        return ctx.hypsum(2, 1, (atype, btype, ctype), [a, b, c], z, **kwargs)
+
+    orig = ctx.prec
+    try:
+        ctx.prec += 10
+
+        # Use 1/z transformation
+        if absz >= 1.3:
+            def h(a,b):
+                t = ctx.mpq_1-c; ab = a-b; rz = 1/z
+                T1 = ([-z],[-a], [c,-ab],[b,c-a], [a,t+a],[ctx.mpq_1+ab],  rz)
+                T2 = ([-z],[-b], [c,ab],[a,c-b], [b,t+b],[ctx.mpq_1-ab],  rz)
+                return T1, T2
+            v = ctx.hypercomb(h, [a,b], **kwargs)
+
+        # Use 1-z transformation
+        elif abs(1-z) <= 0.75:
+            def h(a,b):
+                t = c-a-b; ca = c-a; cb = c-b; rz = 1-z
+                T1 = [], [], [c,t], [ca,cb], [a,b], [1-t], rz
+                T2 = [rz], [t], [c,a+b-c], [a,b], [ca,cb], [1+t], rz
+                return T1, T2
+            v = ctx.hypercomb(h, [a,b], **kwargs)
+
+        # Use z/(z-1) transformation
+        elif abs(z/(z-1)) <= 0.75:
+            v = ctx.hyp2f1(a, c-b, c, z/(z-1)) / (1-z)**a
+
+        # Remaining part of unit circle
+        else:
+            v = _hyp2f1_gosper(ctx,a,b,c,z,**kwargs)
+
+    finally:
+        ctx.prec = orig
+    return +v
+
+@defun
+def _hypq1fq(ctx, p, q, a_s, b_s, z, **kwargs):
+    r"""
+    Evaluates 3F2, 4F3, 5F4, ...
+    """
+    a_s, a_types = zip(*a_s)
+    b_s, b_types = zip(*b_s)
+    a_s = list(a_s)
+    b_s = list(b_s)
+    absz = abs(z)
+    ispoly = False
+    for a in a_s:
+        if ctx.isint(a) and a <= 0:
+            ispoly = True
+            break
+    # Direct summation
+    if absz < 1 or ispoly:
+        try:
+            return ctx.hypsum(p, q, a_types+b_types, a_s+b_s, z, **kwargs)
+        except ctx.NoConvergence:
+            if absz > 1.1 or ispoly:
+                raise
+    # Use expansion at |z-1| -> 0.
+    # Reference: Wolfgang Buhring, "Generalized Hypergeometric Functions at
+    #   Unit Argument", Proc. Amer. Math. Soc., Vol. 114, No. 1 (Jan. 1992),
+    #   pp.145-153
+    # The current implementation has several problems:
+    # 1. We only implement it for 3F2. The expansion coefficients are
+    #    given by extremely messy nested sums in the higher degree cases
+    #    (see reference). Is efficient sequential generation of the coefficients
+    #    possible in the > 3F2 case?
+    # 2. Although the series converges, it may do so slowly, so we need
+    #    convergence acceleration. The acceleration implemented by
+    #    nsum does not always help, so results returned are sometimes
+    #    inaccurate! Can we do better?
+    # 3. We should check conditions for convergence, and possibly
+    #    do a better job of cancelling out gamma poles if possible.
+    if z == 1:
+        # XXX: should also check for division by zero in the
+        # denominator of the series (cf. hyp2f1)
+        S = ctx.re(sum(b_s)-sum(a_s))
+        if S <= 0:
+            #return ctx.hyper(a_s, b_s, 1-ctx.eps*2, **kwargs) * ctx.inf
+            return ctx.hyper(a_s, b_s, 0.9, **kwargs) * ctx.inf
+    if (p,q) == (3,2) and abs(z-1) < 0.05:   # and kwargs.get('sum1')
+        #print "Using alternate summation (experimental)"
+        a1,a2,a3 = a_s
+        b1,b2 = b_s
+        u = b1+b2-a3
+        initial = ctx.gammaprod([b2-a3,b1-a3,a1,a2],[b2-a3,b1-a3,1,u])
+        def term(k, _cache={0:initial}):
+            u = b1+b2-a3+k
+            if k in _cache:
+                t = _cache[k]
+            else:
+                t = _cache[k-1]
+                t *= (b1+k-a3-1)*(b2+k-a3-1)
+                t /= k*(u-1)
+                _cache[k] = t
+            return t * ctx.hyp2f1(a1,a2,u,z)
+        try:
+            S = ctx.nsum(term, [0,ctx.inf], verbose=kwargs.get('verbose'),
+                strict=kwargs.get('strict', True))
+            return S * ctx.gammaprod([b1,b2],[a1,a2,a3])
+        except ctx.NoConvergence:
+            pass
+    # Try to use convergence acceleration on and close to the unit circle.
+    # Problem: the convergence acceleration degenerates as |z-1| -> 0,
+    # except for special cases. Everywhere else, the Shanks transformation
+    # is very efficient.
+    if absz < 1.1 and ctx._re(z) <= 1:
+
+        def term(kk, _cache={0:ctx.one}):
+            k = int(kk)
+            if k != kk:
+                t = z ** ctx.mpf(kk) / ctx.fac(kk)
+                for a in a_s: t *= ctx.rf(a,kk)
+                for b in b_s: t /= ctx.rf(b,kk)
+                return t
+            if k in _cache:
+                return _cache[k]
+            t = term(k-1)
+            m = k-1
+            for j in xrange(p): t *= (a_s[j]+m)
+            for j in xrange(q): t /= (b_s[j]+m)
+            t *= z
+            t /= k
+            _cache[k] = t
+            return t
+
+        sum_method = kwargs.get('sum_method', 'r+s+e')
+
+        try:
+            return ctx.nsum(term, [0,ctx.inf], verbose=kwargs.get('verbose'),
+                strict=kwargs.get('strict', True),
+                method=sum_method.replace('e',''))
+        except ctx.NoConvergence:
+            if 'e' not in sum_method:
+                raise
+            pass
+
+        if kwargs.get('verbose'):
+            print("Attempting Euler-Maclaurin summation")
+
+
+        """
+        Somewhat slower version (one diffs_exp for each factor).
+        However, this would be faster with fast direct derivatives
+        of the gamma function.
+
+        def power_diffs(k0):
+            r = 0
+            l = ctx.log(z)
+            while 1:
+                yield z**ctx.mpf(k0) * l**r
+                r += 1
+
+        def loggamma_diffs(x, reciprocal=False):
+            sign = (-1) ** reciprocal
+            yield sign * ctx.loggamma(x)
+            i = 0
+            while 1:
+                yield sign * ctx.psi(i,x)
+                i += 1
+
+        def hyper_diffs(k0):
+            b2 = b_s + [1]
+            A = [ctx.diffs_exp(loggamma_diffs(a+k0)) for a in a_s]
+            B = [ctx.diffs_exp(loggamma_diffs(b+k0,True)) for b in b2]
+            Z = [power_diffs(k0)]
+            C = ctx.gammaprod([b for b in b2], [a for a in a_s])
+            for d in ctx.diffs_prod(A + B + Z):
+                v = C * d
+                yield v
+        """
+
+        def log_diffs(k0):
+            b2 = b_s + [1]
+            yield sum(ctx.loggamma(a+k0) for a in a_s) - \
+                sum(ctx.loggamma(b+k0) for b in b2) + k0*ctx.log(z)
+            i = 0
+            while 1:
+                v = sum(ctx.psi(i,a+k0) for a in a_s) - \
+                    sum(ctx.psi(i,b+k0) for b in b2)
+                if i == 0:
+                    v += ctx.log(z)
+                yield v
+                i += 1
+
+        def hyper_diffs(k0):
+            C = ctx.gammaprod([b for b in b_s], [a for a in a_s])
+            for d in ctx.diffs_exp(log_diffs(k0)):
+                v = C * d
+                yield v
+
+        tol = ctx.eps / 1024
+        prec = ctx.prec
+        try:
+            trunc = 50 * ctx.dps
+            ctx.prec += 20
+            for i in xrange(5):
+                head = ctx.fsum(term(k) for k in xrange(trunc))
+                tail, err = ctx.sumem(term, [trunc, ctx.inf], tol=tol,
+                    adiffs=hyper_diffs(trunc),
+                    verbose=kwargs.get('verbose'),
+                    error=True,
+                    _fast_abort=True)
+                if err < tol:
+                    v = head + tail
+                    break
+                trunc *= 2
+                # Need to increase precision because calculation of
+                # derivatives may be inaccurate
+                ctx.prec += ctx.prec//2
+                if i == 4:
+                    raise ctx.NoConvergence(\
+                        "Euler-Maclaurin summation did not converge")
+        finally:
+            ctx.prec = prec
+        return +v
+
+    # Use 1/z transformation
+    # http://functions.wolfram.com/HypergeometricFunctions/
+    #   HypergeometricPFQ/06/01/05/02/0004/
+    def h(*args):
+        a_s = list(args[:p])
+        b_s = list(args[p:])
+        Ts = []
+        recz = ctx.one/z
+        negz = ctx.fneg(z, exact=True)
+        for k in range(q+1):
+            ak = a_s[k]
+            C = [negz]
+            Cp = [-ak]
+            Gn = b_s + [ak] + [a_s[j]-ak for j in range(q+1) if j != k]
+            Gd = a_s + [b_s[j]-ak for j in range(q)]
+            Fn = [ak] + [ak-b_s[j]+1 for j in range(q)]
+            Fd = [1-a_s[j]+ak for j in range(q+1) if j != k]
+            Ts.append((C, Cp, Gn, Gd, Fn, Fd, recz))
+        return Ts
+    return ctx.hypercomb(h, a_s+b_s, **kwargs)
+
+@defun
+def _hyp_borel(ctx, p, q, a_s, b_s, z, **kwargs):
+    if a_s:
+        a_s, a_types = zip(*a_s)
+        a_s = list(a_s)
+    else:
+        a_s, a_types = [], ()
+    if b_s:
+        b_s, b_types = zip(*b_s)
+        b_s = list(b_s)
+    else:
+        b_s, b_types = [], ()
+    kwargs['maxterms'] = kwargs.get('maxterms', ctx.prec)
+    try:
+        return ctx.hypsum(p, q, a_types+b_types, a_s+b_s, z, **kwargs)
+    except ctx.NoConvergence:
+        pass
+    prec = ctx.prec
+    try:
+        tol = kwargs.get('asymp_tol', ctx.eps/4)
+        ctx.prec += 10
+        # hypsum is has a conservative tolerance. So we try again:
+        def term(k, cache={0:ctx.one}):
+            if k in cache:
+                return cache[k]
+            t = term(k-1)
+            for a in a_s: t *= (a+(k-1))
+            for b in b_s: t /= (b+(k-1))
+            t *= z
+            t /= k
+            cache[k] = t
+            return t
+        s = ctx.one
+        for k in xrange(1, ctx.prec):
+            t = term(k)
+            s += t
+            if abs(t) <= tol:
+                return s
+    finally:
+        ctx.prec = prec
+    if p <= q+3:
+        contour = kwargs.get('contour')
+        if not contour:
+            if ctx.arg(z) < 0.25:
+                u = z / max(1, abs(z))
+                if ctx.arg(z) >= 0:
+                    contour = [0, 2j, (2j+2)/u, 2/u, ctx.inf]
+                else:
+                    contour = [0, -2j, (-2j+2)/u, 2/u, ctx.inf]
+                #contour = [0, 2j/z, 2/z, ctx.inf]
+                #contour = [0, 2j, 2/z, ctx.inf]
+                #contour = [0, 2j, ctx.inf]
+            else:
+                contour = [0, ctx.inf]
+        quad_kwargs = kwargs.get('quad_kwargs', {})
+        def g(t):
+            return ctx.exp(-t)*ctx.hyper(a_s, b_s+[1], t*z)
+        I, err = ctx.quad(g, contour, error=True, **quad_kwargs)
+        if err <= abs(I)*ctx.eps*8:
+            return I
+    raise ctx.NoConvergence
+
+
+@defun
+def _hyp2f2(ctx, a_s, b_s, z, **kwargs):
+    (a1, a1type), (a2, a2type) = a_s
+    (b1, b1type), (b2, b2type) = b_s
+
+    absz = abs(z)
+    magz = ctx.mag(z)
+    orig = ctx.prec
+
+    # Asymptotic expansion is ~ exp(z)
+    asymp_extraprec = magz
+
+    # Asymptotic series is in terms of 3F1
+    can_use_asymptotic = (not kwargs.get('force_series')) and \
+        (ctx.mag(absz) > 3)
+
+    # TODO: much of the following could be shared with 2F3 instead of
+    # copypasted
+    if can_use_asymptotic:
+        #print "using asymp"
+        try:
+            try:
+                ctx.prec += asymp_extraprec
+                # http://functions.wolfram.com/HypergeometricFunctions/
+                # Hypergeometric2F2/06/02/02/0002/
+                def h(a1,a2,b1,b2):
+                    X = a1+a2-b1-b2
+                    A2 = a1+a2
+                    B2 = b1+b2
+                    c = {}
+                    c[0] = ctx.one
+                    c[1] = (A2-1)*X+b1*b2-a1*a2
+                    s1 = 0
+                    k = 0
+                    tprev = 0
+                    while 1:
+                        if k not in c:
+                            uu1 = 1-B2+2*a1+a1**2+2*a2+a2**2-A2*B2+a1*a2+b1*b2+(2*B2-3*(A2+1))*k+2*k**2
+                            uu2 = (k-A2+b1-1)*(k-A2+b2-1)*(k-X-2)
+                            c[k] = ctx.one/k * (uu1*c[k-1]-uu2*c[k-2])
+                        t1 = c[k] * z**(-k)
+                        if abs(t1) < 0.1*ctx.eps:
+                            #print "Convergence :)"
+                            break
+                        # Quit if the series doesn't converge quickly enough
+                        if k > 5 and abs(tprev) / abs(t1) < 1.5:
+                            #print "No convergence :("
+                            raise ctx.NoConvergence
+                        s1 += t1
+                        tprev = t1
+                        k += 1
+                    S = ctx.exp(z)*s1
+                    T1 = [z,S], [X,1], [b1,b2],[a1,a2],[],[],0
+                    T2 = [-z],[-a1],[b1,b2,a2-a1],[a2,b1-a1,b2-a1],[a1,a1-b1+1,a1-b2+1],[a1-a2+1],-1/z
+                    T3 = [-z],[-a2],[b1,b2,a1-a2],[a1,b1-a2,b2-a2],[a2,a2-b1+1,a2-b2+1],[-a1+a2+1],-1/z
+                    return T1, T2, T3
+                v = ctx.hypercomb(h, [a1,a2,b1,b2], force_series=True, maxterms=4*ctx.prec)
+                if sum(ctx._is_real_type(u) for u in [a1,a2,b1,b2,z]) == 5:
+                    v = ctx.re(v)
+                return v
+            except ctx.NoConvergence:
+                pass
+        finally:
+            ctx.prec = orig
+
+    return ctx.hypsum(2, 2, (a1type, a2type, b1type, b2type), [a1, a2, b1, b2], z, **kwargs)
+
+
+
+@defun
+def _hyp1f2(ctx, a_s, b_s, z, **kwargs):
+    (a1, a1type), = a_s
+    (b1, b1type), (b2, b2type) = b_s
+
+    absz = abs(z)
+    magz = ctx.mag(z)
+    orig = ctx.prec
+
+    # Asymptotic expansion is ~ exp(sqrt(z))
+    asymp_extraprec = z and magz//2
+
+    # Asymptotic series is in terms of 3F0
+    can_use_asymptotic = (not kwargs.get('force_series')) and \
+        (ctx.mag(absz) > 19) and \
+        (ctx.sqrt(absz) > 1.5*orig)  # and \
+    #   ctx._hyp_check_convergence([a1, a1-b1+1, a1-b2+1], [],
+    #                              1/absz, orig+40+asymp_extraprec)
+
+    # TODO: much of the following could be shared with 2F3 instead of
+    # copypasted
+    if can_use_asymptotic:
+        #print "using asymp"
+        try:
+            try:
+                ctx.prec += asymp_extraprec
+                # http://functions.wolfram.com/HypergeometricFunctions/
+                # Hypergeometric1F2/06/02/03/
+                def h(a1,b1,b2):
+                    X = ctx.mpq_1_2*(a1-b1-b2+ctx.mpq_1_2)
+                    c = {}
+                    c[0] = ctx.one
+                    c[1] = 2*(ctx.mpq_1_4*(3*a1+b1+b2-2)*(a1-b1-b2)+b1*b2-ctx.mpq_3_16)
+                    c[2] = 2*(b1*b2+ctx.mpq_1_4*(a1-b1-b2)*(3*a1+b1+b2-2)-ctx.mpq_3_16)**2+\
+                        ctx.mpq_1_16*(-16*(2*a1-3)*b1*b2 + \
+                        4*(a1-b1-b2)*(-8*a1**2+11*a1+b1+b2-2)-3)
+                    s1 = 0
+                    s2 = 0
+                    k = 0
+                    tprev = 0
+                    while 1:
+                        if k not in c:
+                            uu1 = (3*k**2+(-6*a1+2*b1+2*b2-4)*k + 3*a1**2 - \
+                                (b1-b2)**2 - 2*a1*(b1+b2-2) + ctx.mpq_1_4)
+                            uu2 = (k-a1+b1-b2-ctx.mpq_1_2)*(k-a1-b1+b2-ctx.mpq_1_2)*\
+                                (k-a1+b1+b2-ctx.mpq_5_2)
+                            c[k] = ctx.one/(2*k)*(uu1*c[k-1]-uu2*c[k-2])
+                        w = c[k] * (-z)**(-0.5*k)
+                        t1 = (-ctx.j)**k * ctx.mpf(2)**(-k) * w
+                        t2 = ctx.j**k * ctx.mpf(2)**(-k) * w
+                        if abs(t1) < 0.1*ctx.eps:
+                            #print "Convergence :)"
+                            break
+                        # Quit if the series doesn't converge quickly enough
+                        if k > 5 and abs(tprev) / abs(t1) < 1.5:
+                            #print "No convergence :("
+                            raise ctx.NoConvergence
+                        s1 += t1
+                        s2 += t2
+                        tprev = t1
+                        k += 1
+                    S = ctx.expj(ctx.pi*X+2*ctx.sqrt(-z))*s1 + \
+                        ctx.expj(-(ctx.pi*X+2*ctx.sqrt(-z)))*s2
+                    T1 = [0.5*S, ctx.pi, -z], [1, -0.5, X], [b1, b2], [a1],\
+                        [], [], 0
+                    T2 = [-z], [-a1], [b1,b2],[b1-a1,b2-a1], \
+                        [a1,a1-b1+1,a1-b2+1], [], 1/z
+                    return T1, T2
+                v = ctx.hypercomb(h, [a1,b1,b2], force_series=True, maxterms=4*ctx.prec)
+                if sum(ctx._is_real_type(u) for u in [a1,b1,b2,z]) == 4:
+                    v = ctx.re(v)
+                return v
+            except ctx.NoConvergence:
+                pass
+        finally:
+            ctx.prec = orig
+
+    #print "not using asymp"
+    return ctx.hypsum(1, 2, (a1type, b1type, b2type), [a1, b1, b2], z, **kwargs)
+
+
+
+@defun
+def _hyp2f3(ctx, a_s, b_s, z, **kwargs):
+    (a1, a1type), (a2, a2type) = a_s
+    (b1, b1type), (b2, b2type), (b3, b3type) = b_s
+
+    absz = abs(z)
+    magz = ctx.mag(z)
+
+    # Asymptotic expansion is ~ exp(sqrt(z))
+    asymp_extraprec = z and magz//2
+    orig = ctx.prec
+
+    # Asymptotic series is in terms of 4F1
+    # The square root below empirically provides a plausible criterion
+    # for the leading series to converge
+    can_use_asymptotic = (not kwargs.get('force_series')) and \
+        (ctx.mag(absz) > 19) and (ctx.sqrt(absz) > 1.5*orig)
+
+    if can_use_asymptotic:
+        #print "using asymp"
+        try:
+            try:
+                ctx.prec += asymp_extraprec
+                # http://functions.wolfram.com/HypergeometricFunctions/
+                # Hypergeometric2F3/06/02/03/01/0002/
+                def h(a1,a2,b1,b2,b3):
+                    X = ctx.mpq_1_2*(a1+a2-b1-b2-b3+ctx.mpq_1_2)
+                    A2 = a1+a2
+                    B3 = b1+b2+b3
+                    A = a1*a2
+                    B = b1*b2+b3*b2+b1*b3
+                    R = b1*b2*b3
+                    c = {}
+                    c[0] = ctx.one
+                    c[1] = 2*(B - A + ctx.mpq_1_4*(3*A2+B3-2)*(A2-B3) - ctx.mpq_3_16)
+                    c[2] = ctx.mpq_1_2*c[1]**2 + ctx.mpq_1_16*(-16*(2*A2-3)*(B-A) + 32*R +\
+                        4*(-8*A2**2 + 11*A2 + 8*A + B3 - 2)*(A2-B3)-3)
+                    s1 = 0
+                    s2 = 0
+                    k = 0
+                    tprev = 0
+                    while 1:
+                        if k not in c:
+                            uu1 = (k-2*X-3)*(k-2*X-2*b1-1)*(k-2*X-2*b2-1)*\
+                                (k-2*X-2*b3-1)
+                            uu2 = (4*(k-1)**3 - 6*(4*X+B3)*(k-1)**2 + \
+                                2*(24*X**2+12*B3*X+4*B+B3-1)*(k-1) - 32*X**3 - \
+                                24*B3*X**2 - 4*B - 8*R - 4*(4*B+B3-1)*X + 2*B3-1)
+                            uu3 = (5*(k-1)**2+2*(-10*X+A2-3*B3+3)*(k-1)+2*c[1])
+                            c[k] = ctx.one/(2*k)*(uu1*c[k-3]-uu2*c[k-2]+uu3*c[k-1])
+                        w = c[k] * ctx.power(-z, -0.5*k)
+                        t1 = (-ctx.j)**k * ctx.mpf(2)**(-k) * w
+                        t2 = ctx.j**k * ctx.mpf(2)**(-k) * w
+                        if abs(t1) < 0.1*ctx.eps:
+                            break
+                        # Quit if the series doesn't converge quickly enough
+                        if k > 5 and abs(tprev) / abs(t1) < 1.5:
+                            raise ctx.NoConvergence
+                        s1 += t1
+                        s2 += t2
+                        tprev = t1
+                        k += 1
+                    S = ctx.expj(ctx.pi*X+2*ctx.sqrt(-z))*s1 + \
+                        ctx.expj(-(ctx.pi*X+2*ctx.sqrt(-z)))*s2
+                    T1 = [0.5*S, ctx.pi, -z], [1, -0.5, X], [b1, b2, b3], [a1, a2],\
+                        [], [], 0
+                    T2 = [-z], [-a1], [b1,b2,b3,a2-a1],[a2,b1-a1,b2-a1,b3-a1], \
+                        [a1,a1-b1+1,a1-b2+1,a1-b3+1], [a1-a2+1], 1/z
+                    T3 = [-z], [-a2], [b1,b2,b3,a1-a2],[a1,b1-a2,b2-a2,b3-a2], \
+                        [a2,a2-b1+1,a2-b2+1,a2-b3+1],[-a1+a2+1], 1/z
+                    return T1, T2, T3
+                v = ctx.hypercomb(h, [a1,a2,b1,b2,b3], force_series=True, maxterms=4*ctx.prec)
+                if sum(ctx._is_real_type(u) for u in [a1,a2,b1,b2,b3,z]) == 6:
+                    v = ctx.re(v)
+                return v
+            except ctx.NoConvergence:
+                pass
+        finally:
+            ctx.prec = orig
+
+    return ctx.hypsum(2, 3, (a1type, a2type, b1type, b2type, b3type), [a1, a2, b1, b2, b3], z, **kwargs)
+
+@defun
+def _hyp2f0(ctx, a_s, b_s, z, **kwargs):
+    (a, atype), (b, btype) = a_s
+    # We want to try aggressively to use the asymptotic expansion,
+    # and fall back only when absolutely necessary
+    try:
+        kwargsb = kwargs.copy()
+        kwargsb['maxterms'] = kwargsb.get('maxterms', ctx.prec)
+        return ctx.hypsum(2, 0, (atype,btype), [a,b], z, **kwargsb)
+    except ctx.NoConvergence:
+        if kwargs.get('force_series'):
+            raise
+        pass
+    def h(a, b):
+        w = ctx.sinpi(b)
+        rz = -1/z
+        T1 = ([ctx.pi,w,rz],[1,-1,a],[],[a-b+1,b],[a],[b],rz)
+        T2 = ([-ctx.pi,w,rz],[1,-1,1+a-b],[],[a,2-b],[a-b+1],[2-b],rz)
+        return T1, T2
+    return ctx.hypercomb(h, [a, 1+a-b], **kwargs)
+
+@defun
+def meijerg(ctx, a_s, b_s, z, r=1, series=None, **kwargs):
+    an, ap = a_s
+    bm, bq = b_s
+    n = len(an)
+    p = n + len(ap)
+    m = len(bm)
+    q = m + len(bq)
+    a = an+ap
+    b = bm+bq
+    a = [ctx.convert(_) for _ in a]
+    b = [ctx.convert(_) for _ in b]
+    z = ctx.convert(z)
+    if series is None:
+        if p < q: series = 1
+        if p > q: series = 2
+        if p == q:
+            if m+n == p and abs(z) > 1:
+                series = 2
+            else:
+                series = 1
+    if kwargs.get('verbose'):
+        print("Meijer G m,n,p,q,series =", m,n,p,q,series)
+    if series == 1:
+        def h(*args):
+            a = args[:p]
+            b = args[p:]
+            terms = []
+            for k in range(m):
+                bases = [z]
+                expts = [b[k]/r]
+                gn = [b[j]-b[k] for j in range(m) if j != k]
+                gn += [1-a[j]+b[k] for j in range(n)]
+                gd = [a[j]-b[k] for j in range(n,p)]
+                gd += [1-b[j]+b[k] for j in range(m,q)]
+                hn = [1-a[j]+b[k] for j in range(p)]
+                hd = [1-b[j]+b[k] for j in range(q) if j != k]
+                hz = (-ctx.one)**(p-m-n) * z**(ctx.one/r)
+                terms.append((bases, expts, gn, gd, hn, hd, hz))
+            return terms
+    else:
+        def h(*args):
+            a = args[:p]
+            b = args[p:]
+            terms = []
+            for k in range(n):
+                bases = [z]
+                if r == 1:
+                    expts = [a[k]-1]
+                else:
+                    expts = [(a[k]-1)/ctx.convert(r)]
+                gn = [a[k]-a[j] for j in range(n) if j != k]
+                gn += [1-a[k]+b[j] for j in range(m)]
+                gd = [a[k]-b[j] for j in range(m,q)]
+                gd += [1-a[k]+a[j] for j in range(n,p)]
+                hn = [1-a[k]+b[j] for j in range(q)]
+                hd = [1+a[j]-a[k] for j in range(p) if j != k]
+                hz = (-ctx.one)**(q-m-n) / z**(ctx.one/r)
+                terms.append((bases, expts, gn, gd, hn, hd, hz))
+            return terms
+    return ctx.hypercomb(h, a+b, **kwargs)
+
+@defun_wrapped
+def appellf1(ctx,a,b1,b2,c,x,y,**kwargs):
+    # Assume x smaller
+    # We will use x for the outer loop
+    if abs(x) > abs(y):
+        x, y = y, x
+        b1, b2 = b2, b1
+    def ok(x):
+        return abs(x) < 0.99
+    # Finite cases
+    if ctx.isnpint(a):
+        pass
+    elif ctx.isnpint(b1):
+        pass
+    elif ctx.isnpint(b2):
+        x, y, b1, b2 = y, x, b2, b1
+    else:
+        #print x, y
+        # Note: ok if |y| > 1, because
+        # 2F1 implements analytic continuation
+        if not ok(x):
+            u1 = (x-y)/(x-1)
+            if not ok(u1):
+                raise ValueError("Analytic continuation not implemented")
+            #print "Using analytic continuation"
+            return (1-x)**(-b1)*(1-y)**(c-a-b2)*\
+                ctx.appellf1(c-a,b1,c-b1-b2,c,u1,y,**kwargs)
+    return ctx.hyper2d({'m+n':[a],'m':[b1],'n':[b2]}, {'m+n':[c]}, x,y, **kwargs)
+
+@defun
+def appellf2(ctx,a,b1,b2,c1,c2,x,y,**kwargs):
+    # TODO: continuation
+    return ctx.hyper2d({'m+n':[a],'m':[b1],'n':[b2]},
+        {'m':[c1],'n':[c2]}, x,y, **kwargs)
+
+@defun
+def appellf3(ctx,a1,a2,b1,b2,c,x,y,**kwargs):
+    outer_polynomial = ctx.isnpint(a1) or ctx.isnpint(b1)
+    inner_polynomial = ctx.isnpint(a2) or ctx.isnpint(b2)
+    if not outer_polynomial:
+        if inner_polynomial or abs(x) > abs(y):
+            x, y = y, x
+            a1,a2,b1,b2 = a2,a1,b2,b1
+    return ctx.hyper2d({'m':[a1,b1],'n':[a2,b2]}, {'m+n':[c]},x,y,**kwargs)
+
+@defun
+def appellf4(ctx,a,b,c1,c2,x,y,**kwargs):
+    # TODO: continuation
+    return ctx.hyper2d({'m+n':[a,b]}, {'m':[c1],'n':[c2]},x,y,**kwargs)
+
+@defun
+def hyper2d(ctx, a, b, x, y, **kwargs):
+    r"""
+    Sums the generalized 2D hypergeometric series
+
+    .. math ::
+
+        \sum_{m=0}^{\infty} \sum_{n=0}^{\infty}
+            \frac{P((a),m,n)}{Q((b),m,n)}
+            \frac{x^m y^n} {m! n!}
+
+    where `(a) = (a_1,\ldots,a_r)`, `(b) = (b_1,\ldots,b_s)` and where
+    `P` and `Q` are products of rising factorials such as `(a_j)_n` or
+    `(a_j)_{m+n}`. `P` and `Q` are specified in the form of dicts, with
+    the `m` and `n` dependence as keys and parameter lists as values.
+    The supported rising factorials are given in the following table
+    (note that only a few are supported in `Q`):
+
+    +------------+-------------------+--------+
+    | Key        |  Rising factorial | `Q`    |
+    +============+===================+========+
+    | ``'m'``    |   `(a_j)_m`       | Yes    |
+    +------------+-------------------+--------+
+    | ``'n'``    |   `(a_j)_n`       | Yes    |
+    +------------+-------------------+--------+
+    | ``'m+n'``  |   `(a_j)_{m+n}`   | Yes    |
+    +------------+-------------------+--------+
+    | ``'m-n'``  |   `(a_j)_{m-n}`   | No     |
+    +------------+-------------------+--------+
+    | ``'n-m'``  |   `(a_j)_{n-m}`   | No     |
+    +------------+-------------------+--------+
+    | ``'2m+n'`` |   `(a_j)_{2m+n}`  | No     |
+    +------------+-------------------+--------+
+    | ``'2m-n'`` |   `(a_j)_{2m-n}`  | No     |
+    +------------+-------------------+--------+
+    | ``'2n-m'`` |   `(a_j)_{2n-m}`  | No     |
+    +------------+-------------------+--------+
+
+    For example, the Appell F1 and F4 functions
+
+    .. math ::
+
+        F_1 = \sum_{m=0}^{\infty} \sum_{n=0}^{\infty}
+              \frac{(a)_{m+n} (b)_m (c)_n}{(d)_{m+n}}
+              \frac{x^m y^n}{m! n!}
+
+        F_4 = \sum_{m=0}^{\infty} \sum_{n=0}^{\infty}
+              \frac{(a)_{m+n} (b)_{m+n}}{(c)_m (d)_{n}}
+              \frac{x^m y^n}{m! n!}
+
+    can be represented respectively as
+
+        ``hyper2d({'m+n':[a], 'm':[b], 'n':[c]}, {'m+n':[d]}, x, y)``
+
+        ``hyper2d({'m+n':[a,b]}, {'m':[c], 'n':[d]}, x, y)``
+
+    More generally, :func:`~mpmath.hyper2d` can evaluate any of the 34 distinct
+    convergent second-order (generalized Gaussian) hypergeometric
+    series enumerated by Horn, as well as the Kampe de Feriet
+    function.
+
+    The series is computed by rewriting it so that the inner
+    series (i.e. the series containing `n` and `y`) has the form of an
+    ordinary generalized hypergeometric series and thereby can be
+    evaluated efficiently using :func:`~mpmath.hyper`. If possible,
+    manually swapping `x` and `y` and the corresponding parameters
+    can sometimes give better results.
+
+    **Examples**
+
+    Two separable cases: a product of two geometric series, and a
+    product of two Gaussian hypergeometric functions::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> x, y = mpf(0.25), mpf(0.5)
+        >>> hyper2d({'m':1,'n':1}, {}, x,y)
+        2.666666666666666666666667
+        >>> 1/(1-x)/(1-y)
+        2.666666666666666666666667
+        >>> hyper2d({'m':[1,2],'n':[3,4]}, {'m':[5],'n':[6]}, x,y)
+        4.164358531238938319669856
+        >>> hyp2f1(1,2,5,x)*hyp2f1(3,4,6,y)
+        4.164358531238938319669856
+
+    Some more series that can be done in closed form::
+
+        >>> hyper2d({'m':1,'n':1},{'m+n':1},x,y)
+        2.013417124712514809623881
+        >>> (exp(x)*x-exp(y)*y)/(x-y)
+        2.013417124712514809623881
+
+    Six of the 34 Horn functions, G1-G3 and H1-H3::
+
+        >>> from mpmath import *
+        >>> mp.dps = 10; mp.pretty = True
+        >>> x, y = 0.0625, 0.125
+        >>> a1,a2,b1,b2,c1,c2,d = 1.1,-1.2,-1.3,-1.4,1.5,-1.6,1.7
+        >>> hyper2d({'m+n':a1,'n-m':b1,'m-n':b2},{},x,y)  # G1
+        1.139090746
+        >>> nsum(lambda m,n: rf(a1,m+n)*rf(b1,n-m)*rf(b2,m-n)*\
+        ...     x**m*y**n/fac(m)/fac(n), [0,inf], [0,inf])
+        1.139090746
+        >>> hyper2d({'m':a1,'n':a2,'n-m':b1,'m-n':b2},{},x,y)  # G2
+        0.9503682696
+        >>> nsum(lambda m,n: rf(a1,m)*rf(a2,n)*rf(b1,n-m)*rf(b2,m-n)*\
+        ...     x**m*y**n/fac(m)/fac(n), [0,inf], [0,inf])
+        0.9503682696
+        >>> hyper2d({'2n-m':a1,'2m-n':a2},{},x,y)  # G3
+        1.029372029
+        >>> nsum(lambda m,n: rf(a1,2*n-m)*rf(a2,2*m-n)*\
+        ...     x**m*y**n/fac(m)/fac(n), [0,inf], [0,inf])
+        1.029372029
+        >>> hyper2d({'m-n':a1,'m+n':b1,'n':c1},{'m':d},x,y)  # H1
+        -1.605331256
+        >>> nsum(lambda m,n: rf(a1,m-n)*rf(b1,m+n)*rf(c1,n)/rf(d,m)*\
+        ...     x**m*y**n/fac(m)/fac(n), [0,inf], [0,inf])
+        -1.605331256
+        >>> hyper2d({'m-n':a1,'m':b1,'n':[c1,c2]},{'m':d},x,y)  # H2
+        -2.35405404
+        >>> nsum(lambda m,n: rf(a1,m-n)*rf(b1,m)*rf(c1,n)*rf(c2,n)/rf(d,m)*\
+        ...     x**m*y**n/fac(m)/fac(n), [0,inf], [0,inf])
+        -2.35405404
+        >>> hyper2d({'2m+n':a1,'n':b1},{'m+n':c1},x,y)  # H3
+        0.974479074
+        >>> nsum(lambda m,n: rf(a1,2*m+n)*rf(b1,n)/rf(c1,m+n)*\
+        ...     x**m*y**n/fac(m)/fac(n), [0,inf], [0,inf])
+        0.974479074
+
+    **References**
+
+    1. [SrivastavaKarlsson]_
+    2. [Weisstein]_ http://mathworld.wolfram.com/HornFunction.html
+    3. [Weisstein]_ http://mathworld.wolfram.com/AppellHypergeometricFunction.html
+
+    """
+    x = ctx.convert(x)
+    y = ctx.convert(y)
+    def parse(dct, key):
+        args = dct.pop(key, [])
+        try:
+            args = list(args)
+        except TypeError:
+            args = [args]
+        return [ctx.convert(arg) for arg in args]
+    a_s = dict(a)
+    b_s = dict(b)
+    a_m = parse(a, 'm')
+    a_n = parse(a, 'n')
+    a_m_add_n = parse(a, 'm+n')
+    a_m_sub_n = parse(a, 'm-n')
+    a_n_sub_m = parse(a, 'n-m')
+    a_2m_add_n = parse(a, '2m+n')
+    a_2m_sub_n = parse(a, '2m-n')
+    a_2n_sub_m = parse(a, '2n-m')
+    b_m = parse(b, 'm')
+    b_n = parse(b, 'n')
+    b_m_add_n = parse(b, 'm+n')
+    if a: raise ValueError("unsupported key: %r" % a.keys()[0])
+    if b: raise ValueError("unsupported key: %r" % b.keys()[0])
+    s = 0
+    outer = ctx.one
+    m = ctx.mpf(0)
+    ok_count = 0
+    prec = ctx.prec
+    maxterms = kwargs.get('maxterms', 20*prec)
+    try:
+        ctx.prec += 10
+        tol = +ctx.eps
+        while 1:
+            inner_sign = 1
+            outer_sign = 1
+            inner_a = list(a_n)
+            inner_b = list(b_n)
+            outer_a = [a+m for a in a_m]
+            outer_b = [b+m for b in b_m]
+            # (a)_{m+n} = (a)_m (a+m)_n
+            for a in a_m_add_n:
+                a = a+m
+                inner_a.append(a)
+                outer_a.append(a)
+            # (b)_{m+n} = (b)_m (b+m)_n
+            for b in b_m_add_n:
+                b = b+m
+                inner_b.append(b)
+                outer_b.append(b)
+            # (a)_{n-m} = (a-m)_n / (a-m)_m
+            for a in a_n_sub_m:
+                inner_a.append(a-m)
+                outer_b.append(a-m-1)
+            # (a)_{m-n} = (-1)^(m+n) (1-a-m)_m / (1-a-m)_n
+            for a in a_m_sub_n:
+                inner_sign *= (-1)
+                outer_sign *= (-1)**(m)
+                inner_b.append(1-a-m)
+                outer_a.append(-a-m)
+            # (a)_{2m+n} = (a)_{2m} (a+2m)_n
+            for a in a_2m_add_n:
+                inner_a.append(a+2*m)
+                outer_a.append((a+2*m)*(1+a+2*m))
+            # (a)_{2m-n} = (-1)^(2m+n) (1-a-2m)_{2m} / (1-a-2m)_n
+            for a in a_2m_sub_n:
+                inner_sign *= (-1)
+                inner_b.append(1-a-2*m)
+                outer_a.append((a+2*m)*(1+a+2*m))
+            # (a)_{2n-m} = 4^n ((a-m)/2)_n ((a-m+1)/2)_n / (a-m)_m
+            for a in a_2n_sub_m:
+                inner_sign *= 4
+                inner_a.append(0.5*(a-m))
+                inner_a.append(0.5*(a-m+1))
+                outer_b.append(a-m-1)
+            inner = ctx.hyper(inner_a, inner_b, inner_sign*y,
+                zeroprec=ctx.prec, **kwargs)
+            term = outer * inner * outer_sign
+            if abs(term) < tol:
+                ok_count += 1
+            else:
+                ok_count = 0
+            if ok_count >= 3 or not outer:
+                break
+            s += term
+            for a in outer_a: outer *= a
+            for b in outer_b: outer /= b
+            m += 1
+            outer = outer * x / m
+            if m > maxterms:
+                raise ctx.NoConvergence("maxterms exceeded in hyper2d")
+    finally:
+        ctx.prec = prec
+    return +s
+
+"""
+@defun
+def kampe_de_feriet(ctx,a,b,c,d,e,f,x,y,**kwargs):
+    return ctx.hyper2d({'m+n':a,'m':b,'n':c},
+        {'m+n':d,'m':e,'n':f}, x,y, **kwargs)
+"""
+
+@defun
+def bihyper(ctx, a_s, b_s, z, **kwargs):
+    r"""
+    Evaluates the bilateral hypergeometric series
+
+    .. math ::
+
+        \,_AH_B(a_1, \ldots, a_k; b_1, \ldots, b_B; z) =
+            \sum_{n=-\infty}^{\infty}
+            \frac{(a_1)_n \ldots (a_A)_n}
+                 {(b_1)_n \ldots (b_B)_n} \, z^n
+
+    where, for direct convergence, `A = B` and `|z| = 1`, although a
+    regularized sum exists more generally by considering the
+    bilateral series as a sum of two ordinary hypergeometric
+    functions. In order for the series to make sense, none of the
+    parameters may be integers.
+
+    **Examples**
+
+    The value of `\,_2H_2` at `z = 1` is given by Dougall's formula::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> a,b,c,d = 0.5, 1.5, 2.25, 3.25
+        >>> bihyper([a,b],[c,d],1)
+        -14.49118026212345786148847
+        >>> gammaprod([c,d,1-a,1-b,c+d-a-b-1],[c-a,d-a,c-b,d-b])
+        -14.49118026212345786148847
+
+    The regularized function `\,_1H_0` can be expressed as the
+    sum of one `\,_2F_0` function and one `\,_1F_1` function::
+
+        >>> a = mpf(0.25)
+        >>> z = mpf(0.75)
+        >>> bihyper([a], [], z)
+        (0.2454393389657273841385582 + 0.2454393389657273841385582j)
+        >>> hyper([a,1],[],z) + (hyper([1],[1-a],-1/z)-1)
+        (0.2454393389657273841385582 + 0.2454393389657273841385582j)
+        >>> hyper([a,1],[],z) + hyper([1],[2-a],-1/z)/z/(a-1)
+        (0.2454393389657273841385582 + 0.2454393389657273841385582j)
+
+    **References**
+
+    1. [Slater]_ (chapter 6: "Bilateral Series", pp. 180-189)
+    2. [Wikipedia]_ http://en.wikipedia.org/wiki/Bilateral_hypergeometric_series
+
+    """
+    z = ctx.convert(z)
+    c_s = a_s + b_s
+    p = len(a_s)
+    q = len(b_s)
+    if (p, q) == (0,0) or (p, q) == (1,1):
+        return ctx.zero * z
+    neg = (p-q) % 2
+    def h(*c_s):
+        a_s = list(c_s[:p])
+        b_s = list(c_s[p:])
+        aa_s = [2-b for b in b_s]
+        bb_s = [2-a for a in a_s]
+        rp = [(-1)**neg * z] + [1-b for b in b_s] + [1-a for a in a_s]
+        rc = [-1] + [1]*len(b_s) + [-1]*len(a_s)
+        T1 = [], [], [], [], a_s + [1], b_s, z
+        T2 = rp, rc, [], [], aa_s + [1], bb_s, (-1)**neg / z
+        return T1, T2
+    return ctx.hypercomb(h, c_s, **kwargs)
diff --git a/lib/python3.10/site-packages/mpmath/functions/orthogonal.py b/lib/python3.10/site-packages/mpmath/functions/orthogonal.py
new file mode 100644
index 0000000000000000000000000000000000000000..aa33d8bd78290f55a970e78dab7a317d5f652dee
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/functions/orthogonal.py
@@ -0,0 +1,493 @@
+from .functions import defun, defun_wrapped
+
+def _hermite_param(ctx, n, z, parabolic_cylinder):
+    """
+    Combined calculation of the Hermite polynomial H_n(z) (and its
+    generalization to complex n) and the parabolic cylinder
+    function D.
+    """
+    n, ntyp = ctx._convert_param(n)
+    z = ctx.convert(z)
+    q = -ctx.mpq_1_2
+    # For re(z) > 0, 2F0 -- http://functions.wolfram.com/
+    #     HypergeometricFunctions/HermiteHGeneral/06/02/0009/
+    # Otherwise, there is a reflection formula
+    # 2F0 + http://functions.wolfram.com/HypergeometricFunctions/
+    #           HermiteHGeneral/16/01/01/0006/
+    #
+    # TODO:
+    # An alternative would be to use
+    # http://functions.wolfram.com/HypergeometricFunctions/
+    #     HermiteHGeneral/06/02/0006/
+    #
+    # Also, the 1F1 expansion
+    # http://functions.wolfram.com/HypergeometricFunctions/
+    #     HermiteHGeneral/26/01/02/0001/
+    # should probably be used for tiny z
+    if not z:
+        T1 = [2, ctx.pi], [n, 0.5], [], [q*(n-1)], [], [], 0
+        if parabolic_cylinder:
+            T1[1][0] += q*n
+        return T1,
+    can_use_2f0 = ctx.isnpint(-n) or ctx.re(z) > 0 or \
+        (ctx.re(z) == 0 and ctx.im(z) > 0)
+    expprec = ctx.prec*4 + 20
+    if parabolic_cylinder:
+        u = ctx.fmul(ctx.fmul(z,z,prec=expprec), -0.25, exact=True)
+        w = ctx.fmul(z, ctx.sqrt(0.5,prec=expprec), prec=expprec)
+    else:
+        w = z
+    w2 = ctx.fmul(w, w, prec=expprec)
+    rw2 = ctx.fdiv(1, w2, prec=expprec)
+    nrw2 = ctx.fneg(rw2, exact=True)
+    nw = ctx.fneg(w, exact=True)
+    if can_use_2f0:
+        T1 = [2, w], [n, n], [], [], [q*n, q*(n-1)], [], nrw2
+        terms = [T1]
+    else:
+        T1 = [2, nw], [n, n], [], [], [q*n, q*(n-1)], [], nrw2
+        T2 = [2, ctx.pi, nw], [n+2, 0.5, 1], [], [q*n], [q*(n-1)], [1-q], w2
+        terms = [T1,T2]
+    # Multiply by prefactor for D_n
+    if parabolic_cylinder:
+        expu = ctx.exp(u)
+        for i in range(len(terms)):
+            terms[i][1][0] += q*n
+            terms[i][0].append(expu)
+            terms[i][1].append(1)
+    return tuple(terms)
+
+@defun
+def hermite(ctx, n, z, **kwargs):
+    return ctx.hypercomb(lambda: _hermite_param(ctx, n, z, 0), [], **kwargs)
+
+@defun
+def pcfd(ctx, n, z, **kwargs):
+    r"""
+    Gives the parabolic cylinder function in Whittaker's notation
+    `D_n(z) = U(-n-1/2, z)` (see :func:`~mpmath.pcfu`).
+    It solves the differential equation
+
+    .. math ::
+
+        y'' + \left(n + \frac{1}{2} - \frac{1}{4} z^2\right) y = 0.
+
+    and can be represented in terms of Hermite polynomials
+    (see :func:`~mpmath.hermite`) as
+
+    .. math ::
+
+        D_n(z) = 2^{-n/2} e^{-z^2/4} H_n\left(\frac{z}{\sqrt{2}}\right).
+
+    **Plots**
+
+    .. literalinclude :: /plots/pcfd.py
+    .. image :: /plots/pcfd.png
+
+    **Examples**
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> pcfd(0,0); pcfd(1,0); pcfd(2,0); pcfd(3,0)
+        1.0
+        0.0
+        -1.0
+        0.0
+        >>> pcfd(4,0); pcfd(-3,0)
+        3.0
+        0.6266570686577501256039413
+        >>> pcfd('1/2', 2+3j)
+        (-5.363331161232920734849056 - 3.858877821790010714163487j)
+        >>> pcfd(2, -10)
+        1.374906442631438038871515e-9
+
+    Verifying the differential equation::
+
+        >>> n = mpf(2.5)
+        >>> y = lambda z: pcfd(n,z)
+        >>> z = 1.75
+        >>> chop(diff(y,z,2) + (n+0.5-0.25*z**2)*y(z))
+        0.0
+
+    Rational Taylor series expansion when `n` is an integer::
+
+        >>> taylor(lambda z: pcfd(5,z), 0, 7)
+        [0.0, 15.0, 0.0, -13.75, 0.0, 3.96875, 0.0, -0.6015625]
+
+    """
+    return ctx.hypercomb(lambda: _hermite_param(ctx, n, z, 1), [], **kwargs)
+
+@defun
+def pcfu(ctx, a, z, **kwargs):
+    r"""
+    Gives the parabolic cylinder function `U(a,z)`, which may be
+    defined for `\Re(z) > 0` in terms of the confluent
+    U-function (see :func:`~mpmath.hyperu`) by
+
+    .. math ::
+
+        U(a,z) = 2^{-\frac{1}{4}-\frac{a}{2}} e^{-\frac{1}{4} z^2}
+            U\left(\frac{a}{2}+\frac{1}{4},
+            \frac{1}{2}, \frac{1}{2}z^2\right)
+
+    or, for arbitrary `z`,
+
+    .. math ::
+
+        e^{-\frac{1}{4}z^2} U(a,z) =
+            U(a,0) \,_1F_1\left(-\tfrac{a}{2}+\tfrac{1}{4};
+            \tfrac{1}{2}; -\tfrac{1}{2}z^2\right) +
+            U'(a,0) z \,_1F_1\left(-\tfrac{a}{2}+\tfrac{3}{4};
+            \tfrac{3}{2}; -\tfrac{1}{2}z^2\right).
+
+    **Examples**
+
+    Connection to other functions::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> z = mpf(3)
+        >>> pcfu(0.5,z)
+        0.03210358129311151450551963
+        >>> sqrt(pi/2)*exp(z**2/4)*erfc(z/sqrt(2))
+        0.03210358129311151450551963
+        >>> pcfu(0.5,-z)
+        23.75012332835297233711255
+        >>> sqrt(pi/2)*exp(z**2/4)*erfc(-z/sqrt(2))
+        23.75012332835297233711255
+        >>> pcfu(0.5,-z)
+        23.75012332835297233711255
+        >>> sqrt(pi/2)*exp(z**2/4)*erfc(-z/sqrt(2))
+        23.75012332835297233711255
+
+    """
+    n, _ = ctx._convert_param(a)
+    return ctx.pcfd(-n-ctx.mpq_1_2, z)
+
+@defun
+def pcfv(ctx, a, z, **kwargs):
+    r"""
+    Gives the parabolic cylinder function `V(a,z)`, which can be
+    represented in terms of :func:`~mpmath.pcfu` as
+
+    .. math ::
+
+        V(a,z) = \frac{\Gamma(a+\tfrac{1}{2}) (U(a,-z)-\sin(\pi a) U(a,z)}{\pi}.
+
+    **Examples**
+
+    Wronskian relation between `U` and `V`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> a, z = 2, 3
+        >>> pcfu(a,z)*diff(pcfv,(a,z),(0,1))-diff(pcfu,(a,z),(0,1))*pcfv(a,z)
+        0.7978845608028653558798921
+        >>> sqrt(2/pi)
+        0.7978845608028653558798921
+        >>> a, z = 2.5, 3
+        >>> pcfu(a,z)*diff(pcfv,(a,z),(0,1))-diff(pcfu,(a,z),(0,1))*pcfv(a,z)
+        0.7978845608028653558798921
+        >>> a, z = 0.25, -1
+        >>> pcfu(a,z)*diff(pcfv,(a,z),(0,1))-diff(pcfu,(a,z),(0,1))*pcfv(a,z)
+        0.7978845608028653558798921
+        >>> a, z = 2+1j, 2+3j
+        >>> chop(pcfu(a,z)*diff(pcfv,(a,z),(0,1))-diff(pcfu,(a,z),(0,1))*pcfv(a,z))
+        0.7978845608028653558798921
+
+    """
+    n, ntype = ctx._convert_param(a)
+    z = ctx.convert(z)
+    q = ctx.mpq_1_2
+    r = ctx.mpq_1_4
+    if ntype == 'Q' and ctx.isint(n*2):
+        # Faster for half-integers
+        def h():
+            jz = ctx.fmul(z, -1j, exact=True)
+            T1terms = _hermite_param(ctx, -n-q, z, 1)
+            T2terms = _hermite_param(ctx, n-q, jz, 1)
+            for T in T1terms:
+                T[0].append(1j)
+                T[1].append(1)
+                T[3].append(q-n)
+            u = ctx.expjpi((q*n-r)) * ctx.sqrt(2/ctx.pi)
+            for T in T2terms:
+                T[0].append(u)
+                T[1].append(1)
+            return T1terms + T2terms
+        v = ctx.hypercomb(h, [], **kwargs)
+        if ctx._is_real_type(n) and ctx._is_real_type(z):
+            v = ctx._re(v)
+        return v
+    else:
+        def h(n):
+            w = ctx.square_exp_arg(z, -0.25)
+            u = ctx.square_exp_arg(z, 0.5)
+            e = ctx.exp(w)
+            l = [ctx.pi, q, ctx.exp(w)]
+            Y1 = l, [-q, n*q+r, 1], [r-q*n], [], [q*n+r], [q], u
+            Y2 = l + [z], [-q, n*q-r, 1, 1], [1-r-q*n], [], [q*n+1-r], [1+q], u
+            c, s = ctx.cospi_sinpi(r+q*n)
+            Y1[0].append(s)
+            Y2[0].append(c)
+            for Y in (Y1, Y2):
+                Y[1].append(1)
+                Y[3].append(q-n)
+            return Y1, Y2
+        return ctx.hypercomb(h, [n], **kwargs)
+
+
+@defun
+def pcfw(ctx, a, z, **kwargs):
+    r"""
+    Gives the parabolic cylinder function `W(a,z)` defined in (DLMF 12.14).
+
+    **Examples**
+
+    Value at the origin::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> a = mpf(0.25)
+        >>> pcfw(a,0)
+        0.9722833245718180765617104
+        >>> power(2,-0.75)*sqrt(abs(gamma(0.25+0.5j*a)/gamma(0.75+0.5j*a)))
+        0.9722833245718180765617104
+        >>> diff(pcfw,(a,0),(0,1))
+        -0.5142533944210078966003624
+        >>> -power(2,-0.25)*sqrt(abs(gamma(0.75+0.5j*a)/gamma(0.25+0.5j*a)))
+        -0.5142533944210078966003624
+
+    """
+    n, _ = ctx._convert_param(a)
+    z = ctx.convert(z)
+    def terms():
+        phi2 = ctx.arg(ctx.gamma(0.5 + ctx.j*n))
+        phi2 = (ctx.loggamma(0.5+ctx.j*n) - ctx.loggamma(0.5-ctx.j*n))/2j
+        rho = ctx.pi/8 + 0.5*phi2
+        # XXX: cancellation computing k
+        k = ctx.sqrt(1 + ctx.exp(2*ctx.pi*n)) - ctx.exp(ctx.pi*n)
+        C = ctx.sqrt(k/2) * ctx.exp(0.25*ctx.pi*n)
+        yield C * ctx.expj(rho) * ctx.pcfu(ctx.j*n, z*ctx.expjpi(-0.25))
+        yield C * ctx.expj(-rho) * ctx.pcfu(-ctx.j*n, z*ctx.expjpi(0.25))
+    v = ctx.sum_accurately(terms)
+    if ctx._is_real_type(n) and ctx._is_real_type(z):
+        v = ctx._re(v)
+    return v
+
+"""
+Even/odd PCFs. Useful?
+
+@defun
+def pcfy1(ctx, a, z, **kwargs):
+    a, _ = ctx._convert_param(n)
+    z = ctx.convert(z)
+    def h():
+        w = ctx.square_exp_arg(z)
+        w1 = ctx.fmul(w, -0.25, exact=True)
+        w2 = ctx.fmul(w, 0.5, exact=True)
+        e = ctx.exp(w1)
+        return [e], [1], [], [], [ctx.mpq_1_2*a+ctx.mpq_1_4], [ctx.mpq_1_2], w2
+    return ctx.hypercomb(h, [], **kwargs)
+
+@defun
+def pcfy2(ctx, a, z, **kwargs):
+    a, _ = ctx._convert_param(n)
+    z = ctx.convert(z)
+    def h():
+        w = ctx.square_exp_arg(z)
+        w1 = ctx.fmul(w, -0.25, exact=True)
+        w2 = ctx.fmul(w, 0.5, exact=True)
+        e = ctx.exp(w1)
+        return [e, z], [1, 1], [], [], [ctx.mpq_1_2*a+ctx.mpq_3_4], \
+            [ctx.mpq_3_2], w2
+    return ctx.hypercomb(h, [], **kwargs)
+"""
+
+@defun_wrapped
+def gegenbauer(ctx, n, a, z, **kwargs):
+    # Special cases: a+0.5, a*2 poles
+    if ctx.isnpint(a):
+        return 0*(z+n)
+    if ctx.isnpint(a+0.5):
+        # TODO: something else is required here
+        # E.g.: gegenbauer(-2, -0.5, 3) == -12
+        if ctx.isnpint(n+1):
+            raise NotImplementedError("Gegenbauer function with two limits")
+        def h(a):
+            a2 = 2*a
+            T = [], [], [n+a2], [n+1, a2], [-n, n+a2], [a+0.5], 0.5*(1-z)
+            return [T]
+        return ctx.hypercomb(h, [a], **kwargs)
+    def h(n):
+        a2 = 2*a
+        T = [], [], [n+a2], [n+1, a2], [-n, n+a2], [a+0.5], 0.5*(1-z)
+        return [T]
+    return ctx.hypercomb(h, [n], **kwargs)
+
+@defun_wrapped
+def jacobi(ctx, n, a, b, x, **kwargs):
+    if not ctx.isnpint(a):
+        def h(n):
+            return (([], [], [a+n+1], [n+1, a+1], [-n, a+b+n+1], [a+1], (1-x)*0.5),)
+        return ctx.hypercomb(h, [n], **kwargs)
+    if not ctx.isint(b):
+        def h(n, a):
+            return (([], [], [-b], [n+1, -b-n], [-n, a+b+n+1], [b+1], (x+1)*0.5),)
+        return ctx.hypercomb(h, [n, a], **kwargs)
+    # XXX: determine appropriate limit
+    return ctx.binomial(n+a,n) * ctx.hyp2f1(-n,1+n+a+b,a+1,(1-x)/2, **kwargs)
+
+@defun_wrapped
+def laguerre(ctx, n, a, z, **kwargs):
+    # XXX: limits, poles
+    #if ctx.isnpint(n):
+    #    return 0*(a+z)
+    def h(a):
+        return (([], [], [a+n+1], [a+1, n+1], [-n], [a+1], z),)
+    return ctx.hypercomb(h, [a], **kwargs)
+
+@defun_wrapped
+def legendre(ctx, n, x, **kwargs):
+    if ctx.isint(n):
+        n = int(n)
+        # Accuracy near zeros
+        if (n + (n < 0)) & 1:
+            if not x:
+                return x
+            mag = ctx.mag(x)
+            if mag < -2*ctx.prec-10:
+                return x
+            if mag < -5:
+                ctx.prec += -mag
+    return ctx.hyp2f1(-n,n+1,1,(1-x)/2, **kwargs)
+
+@defun
+def legenp(ctx, n, m, z, type=2, **kwargs):
+    # Legendre function, 1st kind
+    n = ctx.convert(n)
+    m = ctx.convert(m)
+    # Faster
+    if not m:
+        return ctx.legendre(n, z, **kwargs)
+    # TODO: correct evaluation at singularities
+    if type == 2:
+        def h(n,m):
+            g = m*0.5
+            T = [1+z, 1-z], [g, -g], [], [1-m], [-n, n+1], [1-m], 0.5*(1-z)
+            return (T,)
+        return ctx.hypercomb(h, [n,m], **kwargs)
+    if type == 3:
+        def h(n,m):
+            g = m*0.5
+            T = [z+1, z-1], [g, -g], [], [1-m], [-n, n+1], [1-m], 0.5*(1-z)
+            return (T,)
+        return ctx.hypercomb(h, [n,m], **kwargs)
+    raise ValueError("requires type=2 or type=3")
+
+@defun
+def legenq(ctx, n, m, z, type=2, **kwargs):
+    # Legendre function, 2nd kind
+    n = ctx.convert(n)
+    m = ctx.convert(m)
+    z = ctx.convert(z)
+    if z in (1, -1):
+        #if ctx.isint(m):
+        #    return ctx.nan
+        #return ctx.inf  # unsigned
+        return ctx.nan
+    if type == 2:
+        def h(n, m):
+            cos, sin = ctx.cospi_sinpi(m)
+            s = 2 * sin / ctx.pi
+            c = cos
+            a = 1+z
+            b = 1-z
+            u = m/2
+            w = (1-z)/2
+            T1 = [s, c, a, b], [-1, 1, u, -u], [], [1-m], \
+                [-n, n+1], [1-m], w
+            T2 = [-s, a, b], [-1, -u, u], [n+m+1], [n-m+1, m+1], \
+                [-n, n+1], [m+1], w
+            return T1, T2
+        return ctx.hypercomb(h, [n, m], **kwargs)
+    if type == 3:
+        # The following is faster when there only is a single series
+        # Note: not valid for -1 < z < 0 (?)
+        if abs(z) > 1:
+            def h(n, m):
+                T1 = [ctx.expjpi(m), 2, ctx.pi, z, z-1, z+1], \
+                     [1, -n-1, 0.5, -n-m-1, 0.5*m, 0.5*m], \
+                     [n+m+1], [n+1.5], \
+                     [0.5*(2+n+m), 0.5*(1+n+m)], [n+1.5], z**(-2)
+                return [T1]
+            return ctx.hypercomb(h, [n, m], **kwargs)
+        else:
+            # not valid for 1 < z < inf ?
+            def h(n, m):
+                s = 2 * ctx.sinpi(m) / ctx.pi
+                c = ctx.expjpi(m)
+                a = 1+z
+                b = z-1
+                u = m/2
+                w = (1-z)/2
+                T1 = [s, c, a, b], [-1, 1, u, -u], [], [1-m], \
+                    [-n, n+1], [1-m], w
+                T2 = [-s, c, a, b], [-1, 1, -u, u], [n+m+1], [n-m+1, m+1], \
+                    [-n, n+1], [m+1], w
+                return T1, T2
+            return ctx.hypercomb(h, [n, m], **kwargs)
+    raise ValueError("requires type=2 or type=3")
+
+@defun_wrapped
+def chebyt(ctx, n, x, **kwargs):
+    if (not x) and ctx.isint(n) and int(ctx._re(n)) % 2 == 1:
+        return x * 0
+    return ctx.hyp2f1(-n,n,(1,2),(1-x)/2, **kwargs)
+
+@defun_wrapped
+def chebyu(ctx, n, x, **kwargs):
+    if (not x) and ctx.isint(n) and int(ctx._re(n)) % 2 == 1:
+        return x * 0
+    return (n+1) * ctx.hyp2f1(-n, n+2, (3,2), (1-x)/2, **kwargs)
+
+@defun
+def spherharm(ctx, l, m, theta, phi, **kwargs):
+    l = ctx.convert(l)
+    m = ctx.convert(m)
+    theta = ctx.convert(theta)
+    phi = ctx.convert(phi)
+    l_isint = ctx.isint(l)
+    l_natural = l_isint and l >= 0
+    m_isint = ctx.isint(m)
+    if l_isint and l < 0 and m_isint:
+        return ctx.spherharm(-(l+1), m, theta, phi, **kwargs)
+    if theta == 0 and m_isint and m < 0:
+        return ctx.zero * 1j
+    if l_natural and m_isint:
+        if abs(m) > l:
+            return ctx.zero * 1j
+        # http://functions.wolfram.com/Polynomials/
+        #     SphericalHarmonicY/26/01/02/0004/
+        def h(l,m):
+            absm = abs(m)
+            C = [-1, ctx.expj(m*phi),
+                 (2*l+1)*ctx.fac(l+absm)/ctx.pi/ctx.fac(l-absm),
+                 ctx.sin(theta)**2,
+                 ctx.fac(absm), 2]
+            P = [0.5*m*(ctx.sign(m)+1), 1, 0.5, 0.5*absm, -1, -absm-1]
+            return ((C, P, [], [], [absm-l, l+absm+1], [absm+1],
+                ctx.sin(0.5*theta)**2),)
+    else:
+        # http://functions.wolfram.com/HypergeometricFunctions/
+        #     SphericalHarmonicYGeneral/26/01/02/0001/
+        def h(l,m):
+            if ctx.isnpint(l-m+1) or ctx.isnpint(l+m+1) or ctx.isnpint(1-m):
+                return (([0], [-1], [], [], [], [], 0),)
+            cos, sin = ctx.cos_sin(0.5*theta)
+            C = [0.5*ctx.expj(m*phi), (2*l+1)/ctx.pi,
+                 ctx.gamma(l-m+1), ctx.gamma(l+m+1),
+                 cos**2, sin**2]
+            P = [1, 0.5, 0.5, -0.5, 0.5*m, -0.5*m]
+            return ((C, P, [], [1-m], [-l,l+1], [1-m], sin**2),)
+    return ctx.hypercomb(h, [l,m], **kwargs)
diff --git a/lib/python3.10/site-packages/mpmath/functions/qfunctions.py b/lib/python3.10/site-packages/mpmath/functions/qfunctions.py
new file mode 100644
index 0000000000000000000000000000000000000000..5a20e53a8b6fa0d8fbc9ad098614d2694998f49a
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/functions/qfunctions.py
@@ -0,0 +1,280 @@
+from .functions import defun, defun_wrapped
+
+@defun
+def qp(ctx, a, q=None, n=None, **kwargs):
+    r"""
+    Evaluates the q-Pochhammer symbol (or q-rising factorial)
+
+    .. math ::
+
+        (a; q)_n = \prod_{k=0}^{n-1} (1-a q^k)
+
+    where `n = \infty` is permitted if `|q| < 1`. Called with two arguments,
+    ``qp(a,q)`` computes `(a;q)_{\infty}`; with a single argument, ``qp(q)``
+    computes `(q;q)_{\infty}`. The special case
+
+    .. math ::
+
+        \phi(q) = (q; q)_{\infty} = \prod_{k=1}^{\infty} (1-q^k) =
+            \sum_{k=-\infty}^{\infty} (-1)^k q^{(3k^2-k)/2}
+
+    is also known as the Euler function, or (up to a factor `q^{-1/24}`)
+    the Dedekind eta function.
+
+    **Examples**
+
+    If `n` is a positive integer, the function amounts to a finite product::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> qp(2,3,5)
+        -725305.0
+        >>> fprod(1-2*3**k for k in range(5))
+        -725305.0
+        >>> qp(2,3,0)
+        1.0
+
+    Complex arguments are allowed::
+
+        >>> qp(2-1j, 0.75j)
+        (0.4628842231660149089976379 + 4.481821753552703090628793j)
+
+    The regular Pochhammer symbol `(a)_n` is obtained in the
+    following limit as `q \to 1`::
+
+        >>> a, n = 4, 7
+        >>> limit(lambda q: qp(q**a,q,n) / (1-q)**n, 1)
+        604800.0
+        >>> rf(a,n)
+        604800.0
+
+    The Taylor series of the reciprocal Euler function gives
+    the partition function `P(n)`, i.e. the number of ways of writing
+    `n` as a sum of positive integers::
+
+        >>> taylor(lambda q: 1/qp(q), 0, 10)
+        [1.0, 1.0, 2.0, 3.0, 5.0, 7.0, 11.0, 15.0, 22.0, 30.0, 42.0]
+
+    Special values include::
+
+        >>> qp(0)
+        1.0
+        >>> findroot(diffun(qp), -0.4)   # location of maximum
+        -0.4112484791779547734440257
+        >>> qp(_)
+        1.228348867038575112586878
+
+    The q-Pochhammer symbol is related to the Jacobi theta functions.
+    For example, the following identity holds::
+
+        >>> q = mpf(0.5)    # arbitrary
+        >>> qp(q)
+        0.2887880950866024212788997
+        >>> root(3,-2)*root(q,-24)*jtheta(2,pi/6,root(q,6))
+        0.2887880950866024212788997
+
+    """
+    a = ctx.convert(a)
+    if n is None:
+        n = ctx.inf
+    else:
+        n = ctx.convert(n)
+    if n < 0:
+        raise ValueError("n cannot be negative")
+    if q is None:
+        q = a
+    else:
+        q = ctx.convert(q)
+    if n == 0:
+        return ctx.one + 0*(a+q)
+    infinite = (n == ctx.inf)
+    same = (a == q)
+    if infinite:
+        if abs(q) >= 1:
+            if same and (q == -1 or q == 1):
+                return ctx.zero * q
+            raise ValueError("q-function only defined for |q| < 1")
+        elif q == 0:
+            return ctx.one - a
+    maxterms = kwargs.get('maxterms', 50*ctx.prec)
+    if infinite and same:
+        # Euler's pentagonal theorem
+        def terms():
+            t = 1
+            yield t
+            k = 1
+            x1 = q
+            x2 = q**2
+            while 1:
+                yield (-1)**k * x1
+                yield (-1)**k * x2
+                x1 *= q**(3*k+1)
+                x2 *= q**(3*k+2)
+                k += 1
+                if k > maxterms:
+                    raise ctx.NoConvergence
+        return ctx.sum_accurately(terms)
+    # return ctx.nprod(lambda k: 1-a*q**k, [0,n-1])
+    def factors():
+        k = 0
+        r = ctx.one
+        while 1:
+            yield 1 - a*r
+            r *= q
+            k += 1
+            if k >= n:
+                return
+            if k > maxterms:
+                raise ctx.NoConvergence
+    return ctx.mul_accurately(factors)
+
+@defun_wrapped
+def qgamma(ctx, z, q, **kwargs):
+    r"""
+    Evaluates the q-gamma function
+
+    .. math ::
+
+        \Gamma_q(z) = \frac{(q; q)_{\infty}}{(q^z; q)_{\infty}} (1-q)^{1-z}.
+
+
+    **Examples**
+
+    Evaluation for real and complex arguments::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> qgamma(4,0.75)
+        4.046875
+        >>> qgamma(6,6)
+        121226245.0
+        >>> qgamma(3+4j, 0.5j)
+        (0.1663082382255199834630088 + 0.01952474576025952984418217j)
+
+    The q-gamma function satisfies a functional equation similar
+    to that of the ordinary gamma function::
+
+        >>> q = mpf(0.25)
+        >>> z = mpf(2.5)
+        >>> qgamma(z+1,q)
+        1.428277424823760954685912
+        >>> (1-q**z)/(1-q)*qgamma(z,q)
+        1.428277424823760954685912
+
+    """
+    if abs(q) > 1:
+        return ctx.qgamma(z,1/q)*q**((z-2)*(z-1)*0.5)
+    return ctx.qp(q, q, None, **kwargs) / \
+        ctx.qp(q**z, q, None, **kwargs) * (1-q)**(1-z)
+
+@defun_wrapped
+def qfac(ctx, z, q, **kwargs):
+    r"""
+    Evaluates the q-factorial,
+
+    .. math ::
+
+        [n]_q! = (1+q)(1+q+q^2)\cdots(1+q+\cdots+q^{n-1})
+
+    or more generally
+
+    .. math ::
+
+        [z]_q! = \frac{(q;q)_z}{(1-q)^z}.
+
+    **Examples**
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> qfac(0,0)
+        1.0
+        >>> qfac(4,3)
+        2080.0
+        >>> qfac(5,6)
+        121226245.0
+        >>> qfac(1+1j, 2+1j)
+        (0.4370556551322672478613695 + 0.2609739839216039203708921j)
+
+    """
+    if ctx.isint(z) and ctx._re(z) > 0:
+        n = int(ctx._re(z))
+        return ctx.qp(q, q, n, **kwargs) / (1-q)**n
+    return ctx.qgamma(z+1, q, **kwargs)
+
+@defun
+def qhyper(ctx, a_s, b_s, q, z, **kwargs):
+    r"""
+    Evaluates the basic hypergeometric series or hypergeometric q-series
+
+    .. math ::
+
+        \,_r\phi_s \left[\begin{matrix}
+            a_1 & a_2 & \ldots & a_r \\
+            b_1 & b_2 & \ldots & b_s
+        \end{matrix} ; q,z \right] =
+        \sum_{n=0}^\infty
+        \frac{(a_1;q)_n, \ldots, (a_r;q)_n}
+             {(b_1;q)_n, \ldots, (b_s;q)_n}
+        \left((-1)^n q^{n\choose 2}\right)^{1+s-r}
+        \frac{z^n}{(q;q)_n}
+
+    where `(a;q)_n` denotes the q-Pochhammer symbol (see :func:`~mpmath.qp`).
+
+    **Examples**
+
+    Evaluation works for real and complex arguments::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> qhyper([0.5], [2.25], 0.25, 4)
+        -0.1975849091263356009534385
+        >>> qhyper([0.5], [2.25], 0.25-0.25j, 4)
+        (2.806330244925716649839237 + 3.568997623337943121769938j)
+        >>> qhyper([1+j], [2,3+0.5j], 0.25, 3+4j)
+        (9.112885171773400017270226 - 1.272756997166375050700388j)
+
+    Comparing with a summation of the defining series, using
+    :func:`~mpmath.nsum`::
+
+        >>> b, q, z = 3, 0.25, 0.5
+        >>> qhyper([], [b], q, z)
+        0.6221136748254495583228324
+        >>> nsum(lambda n: z**n / qp(q,q,n)/qp(b,q,n) * q**(n*(n-1)), [0,inf])
+        0.6221136748254495583228324
+
+    """
+    #a_s = [ctx._convert_param(a)[0] for a in a_s]
+    #b_s = [ctx._convert_param(b)[0] for b in b_s]
+    #q = ctx._convert_param(q)[0]
+    a_s = [ctx.convert(a) for a in a_s]
+    b_s = [ctx.convert(b) for b in b_s]
+    q = ctx.convert(q)
+    z = ctx.convert(z)
+    r = len(a_s)
+    s = len(b_s)
+    d = 1+s-r
+    maxterms = kwargs.get('maxterms', 50*ctx.prec)
+    def terms():
+        t = ctx.one
+        yield t
+        qk = 1
+        k = 0
+        x = 1
+        while 1:
+            for a in a_s:
+                p = 1 - a*qk
+                t *= p
+            for b in b_s:
+                p = 1 - b*qk
+                if not p:
+                    raise ValueError
+                t /= p
+            t *= z
+            x *= (-1)**d * qk ** d
+            qk *= q
+            t /= (1 - qk)
+            k += 1
+            yield t * x
+            if k > maxterms:
+                raise ctx.NoConvergence
+    return ctx.sum_accurately(terms)
diff --git a/lib/python3.10/site-packages/mpmath/functions/rszeta.py b/lib/python3.10/site-packages/mpmath/functions/rszeta.py
new file mode 100644
index 0000000000000000000000000000000000000000..19e2c9a251b81bafe8cf77a2b0180636b1078ee4
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/functions/rszeta.py
@@ -0,0 +1,1403 @@
+"""
+---------------------------------------------------------------------
+.. sectionauthor:: Juan Arias de Reyna <arias@us.es>
+
+This module implements zeta-related functions using the Riemann-Siegel
+expansion: zeta_offline(s,k=0)
+
+* coef(J, eps): Need in the computation of Rzeta(s,k)
+
+* Rzeta_simul(s, der=0) computes Rzeta^(k)(s) and Rzeta^(k)(1-s) simultaneously
+  for  0 <= k <= der. Used by zeta_offline and z_offline
+
+* Rzeta_set(s, derivatives) computes Rzeta^(k)(s) for given derivatives, used by
+  z_half(t,k) and zeta_half
+
+* z_offline(w,k): Z(w) and its derivatives of order k <= 4
+* z_half(t,k): Z(t) (Riemann Siegel function) and its derivatives of order k <= 4
+* zeta_offline(s): zeta(s) and its derivatives of order k<= 4
+* zeta_half(1/2+it,k):  zeta(s)  and its derivatives of order k<= 4
+
+* rs_zeta(s,k=0) Computes zeta^(k)(s)   Unifies zeta_half and zeta_offline
+* rs_z(w,k=0)    Computes Z^(k)(w)      Unifies z_offline and z_half
+----------------------------------------------------------------------
+
+This program uses Riemann-Siegel expansion even to compute
+zeta(s) on points s = sigma + i t  with sigma arbitrary not
+necessarily equal to 1/2.
+
+It is founded on a new deduction of the formula, with rigorous
+and sharp bounds for the  terms and rest of this expansion.
+
+More information on the papers:
+
+ J. Arias de Reyna, High Precision Computation of Riemann's
+ Zeta Function by the Riemann-Siegel Formula I, II
+
+ We refer to them as I, II.
+
+ In them we shall find detailed explanation of all the
+ procedure.
+
+The program uses Riemann-Siegel expansion.
+This  is useful when t is big, ( say  t > 10000 ).
+The precision is limited, roughly it can compute zeta(sigma+it)
+with an error less than exp(-c t) for some constant c depending
+on sigma.  The program gives an error when the Riemann-Siegel
+formula can not compute to the wanted precision.
+
+"""
+
+import math
+
+class RSCache(object):
+    def __init__(ctx):
+        ctx._rs_cache = [0, 10, {}, {}]
+
+from .functions import defun
+
+#-------------------------------------------------------------------------------#
+#                                                                               #
+#                       coef(ctx, J, eps, _cache=[0, 10, {} ] )                 #
+#                                                                               #
+#-------------------------------------------------------------------------------#
+
+#  This function computes the coefficients c[n] defined on (I, equation (47))
+#  but see also  (II, section 3.14).
+#
+#  Since these coefficients are very difficult to compute we save the values
+#  in a cache. So if we compute several values of the functions Rzeta(s) for
+#  near values of s, we do not recompute these coefficients.
+#
+#  c[n] are the Taylor coefficients of the function:
+#
+#  F(z):= (exp(pi*j*(z*z/2+3/8))-j* sqrt(2) cos(pi*z/2))/(2*cos(pi *z))
+#
+#
+
+def _coef(ctx, J, eps):
+    r"""
+    Computes the coefficients  `c_n`  for `0\le n\le 2J` with error less than eps
+
+    **Definition**
+
+    The coefficients c_n are defined by
+
+    .. math ::
+
+        \begin{equation}
+        F(z)=\frac{e^{\pi i
+        \bigl(\frac{z^2}{2}+\frac38\bigr)}-i\sqrt{2}\cos\frac{\pi}{2}z}{2\cos\pi
+        z}=\sum_{n=0}^\infty c_{2n} z^{2n}
+        \end{equation}
+
+    they are computed applying the relation
+
+    .. math ::
+
+        \begin{multline}
+        c_{2n}=-\frac{i}{\sqrt{2}}\Bigl(\frac{\pi}{2}\Bigr)^{2n}
+        \sum_{k=0}^n\frac{(-1)^k}{(2k)!}
+        2^{2n-2k}\frac{(-1)^{n-k}E_{2n-2k}}{(2n-2k)!}+\\
+        +e^{3\pi i/8}\sum_{j=0}^n(-1)^j\frac{
+        E_{2j}}{(2j)!}\frac{i^{n-j}\pi^{n+j}}{(n-j)!2^{n-j+1}}.
+        \end{multline}
+    """
+
+    newJ = J+2        # compute more coefficients that are needed
+    neweps6 = eps/2.  # compute with a slight more precision that are needed
+
+    #  PREPARATION FOR THE COMPUTATION OF V(N) AND W(N)
+    #    See II Section 3.16
+    #
+    #  Computing the exponent wpvw of the error II equation (81)
+    wpvw = max(ctx.mag(10*(newJ+3)), 4*newJ+5-ctx.mag(neweps6))
+
+    #  Preparation of Euler numbers (we need until the 2*RS_NEWJ)
+    E = ctx._eulernum(2*newJ)
+
+    #  Now we have in the cache all the needed Euler numbers.
+    #
+    #  Computing the powers of pi
+    #
+    # We need to compute the powers pi**n for 1<= n <= 2*J
+    # with relative error less than 2**(-wpvw)
+    # it is easy to show that this is obtained
+    # taking wppi as the least d with
+    # 2**d>40*J and 2**d> 4.24 *newJ + 2**wpvw
+    # In II Section 3.9 we need also that
+    #  wppi > wptcoef[0], and that the powers
+    # here computed  0<= k <= 2*newJ are more
+    # than those needed there that are 2*L-2.
+    # so we need  J >= L this will be checked
+    # before computing tcoef[]
+    wppi = max(ctx.mag(40*newJ), ctx.mag(newJ)+3 +wpvw)
+    ctx.prec = wppi
+    pipower = {}
+    pipower[0] = ctx.one
+    pipower[1] = ctx.pi
+    for n in range(2,2*newJ+1):
+        pipower[n] = pipower[n-1]*ctx.pi
+
+    # COMPUTING THE COEFFICIENTS v(n) AND w(n)
+    #  see II equation (61) and equations (81) and (82)
+    ctx.prec = wpvw+2
+    v={}
+    w={}
+    for n in range(0,newJ+1):
+        va = (-1)**n * ctx._eulernum(2*n)
+        va = ctx.mpf(va)/ctx.fac(2*n)
+        v[n]=va*pipower[2*n]
+    for n in range(0,2*newJ+1):
+        wa = ctx.one/ctx.fac(n)
+        wa=wa/(2**n)
+        w[n]=wa*pipower[n]
+
+    # COMPUTATION OF THE CONVOLUTIONS RS_P1 AND RS_P2
+    #  See II Section 3.16
+    ctx.prec = 15
+    wpp1a = 9 - ctx.mag(neweps6)
+    P1 = {}
+    for n in range(0,newJ+1):
+        ctx.prec = 15
+        wpp1 = max(ctx.mag(10*(n+4)),4*n+wpp1a)
+        ctx.prec = wpp1
+        sump = 0
+        for k in range(0,n+1):
+            sump += ((-1)**k) * v[k]*w[2*n-2*k]
+        P1[n]=((-1)**(n+1))*ctx.j*sump
+    P2={}
+    for n in range(0,newJ+1):
+        ctx.prec = 15
+        wpp2 = max(ctx.mag(10*(n+4)),4*n+wpp1a)
+        ctx.prec = wpp2
+        sump = 0
+        for k in range(0,n+1):
+            sump += (ctx.j**(n-k)) * v[k]*w[n-k]
+        P2[n]=sump
+    # COMPUTING THE COEFFICIENTS c[2n]
+    # See II Section 3.14
+    ctx.prec = 15
+    wpc0 = 5 - ctx.mag(neweps6)
+    wpc = max(6,4*newJ+wpc0)
+    ctx.prec = wpc
+    mu = ctx.sqrt(ctx.mpf('2'))/2
+    nu = ctx.expjpi(3./8)/2
+    c={}
+    for n in range(0,newJ):
+        ctx.prec = 15
+        wpc = max(6,4*n+wpc0)
+        ctx.prec = wpc
+        c[2*n] = mu*P1[n]+nu*P2[n]
+    for n in range(1,2*newJ,2):
+        c[n] = 0
+    return [newJ, neweps6, c, pipower]
+
+def coef(ctx, J, eps):
+    _cache = ctx._rs_cache
+    if J <= _cache[0] and eps >= _cache[1]:
+        return _cache[2], _cache[3]
+    orig = ctx._mp.prec
+    try:
+        data = _coef(ctx._mp, J, eps)
+    finally:
+        ctx._mp.prec = orig
+    if ctx is not ctx._mp:
+        data[2] = dict((k,ctx.convert(v)) for (k,v) in data[2].items())
+        data[3] = dict((k,ctx.convert(v)) for (k,v) in data[3].items())
+    ctx._rs_cache[:] = data
+    return ctx._rs_cache[2], ctx._rs_cache[3]
+
+#-------------------------------------------------------------------------------#
+#                                                                               #
+#                          Rzeta_simul(s,k=0)                                   #
+#                                                                               #
+#-------------------------------------------------------------------------------#
+#  This function return a list with the values:
+#  Rzeta(sigma+it), conj(Rzeta(1-sigma+it)),Rzeta'(sigma+it), conj(Rzeta'(1-sigma+it)),
+#  .... , Rzeta^{(k)}(sigma+it), conj(Rzeta^{(k)}(1-sigma+it))
+#
+#  Useful to compute  the function zeta(s) and Z(w)  or its derivatives.
+#
+
+def aux_M_Fp(ctx, xA, xeps4, a, xB1, xL):
+    # COMPUTING M  NUMBER OF DERIVATIVES Fp[m] TO COMPUTE
+    #  See II Section 3.11  equations (47) and (48)
+    aux1 = 126.0657606*xA/xeps4   # 126.06.. = 316/sqrt(2*pi)
+    aux1 = ctx.ln(aux1)
+    aux2 = (2*ctx.ln(ctx.pi)+ctx.ln(xB1)+ctx.ln(a))/3 -ctx.ln(2*ctx.pi)/2
+    m = 3*xL-3
+    aux3= (ctx.loggamma(m+1)-ctx.loggamma(m/3.0+2))/2 -ctx.loggamma((m+1)/2.)
+    while((aux1 < m*aux2+ aux3)and (m>1)):
+        m = m - 1
+        aux3 = (ctx.loggamma(m+1)-ctx.loggamma(m/3.0+2))/2 -ctx.loggamma((m+1)/2.)
+    xM = m
+    return xM
+
+def aux_J_needed(ctx, xA, xeps4, a, xB1, xM):
+    #  DETERMINATION OF  J  THE NUMBER OF TERMS NEEDED
+    #            IN THE TAYLOR SERIES OF F.
+    #  See II Section 3.11 equation (49))
+    #  Only determine one
+    h1 = xeps4/(632*xA)
+    h2 = xB1*a * 126.31337419529260248  # = pi^2*e^2*sqrt(3)
+    h2 = h1 * ctx.power((h2/xM**2),(xM-1)/3) / xM
+    h3 = min(h1,h2)
+    return h3
+
+def Rzeta_simul(ctx, s, der=0):
+    # First we take the value of ctx.prec
+    wpinitial = ctx.prec
+
+    # INITIALIZATION
+    # Take the real and imaginary part of s
+    t = ctx._im(s)
+    xsigma = ctx._re(s)
+    ysigma = 1 - xsigma
+
+    # Now compute several parameter that appear on the program
+    ctx.prec = 15
+    a = ctx.sqrt(t/(2*ctx.pi))
+    xasigma = a ** xsigma
+    yasigma = a ** ysigma
+
+    # We need a simple bound A1 < asigma  (see II Section 3.1 and 3.3)
+    xA1=ctx.power(2, ctx.mag(xasigma)-1)
+    yA1=ctx.power(2, ctx.mag(yasigma)-1)
+
+    # We compute various epsilon's  (see II end of Section 3.1)
+    eps = ctx.power(2, -wpinitial)
+    eps1 = eps/6.
+    xeps2 = eps * xA1/3.
+    yeps2 = eps * yA1/3.
+
+    #  COMPUTING SOME COEFFICIENTS THAT DEPENDS
+    #                ON  sigma
+    #  constant b and c  (see I  Theorem 2 formula (26) )
+    #  coefficients A and B1  (see I Section 6.1 equation (50))
+    #
+    # here we not need high precision
+    ctx.prec = 15
+    if xsigma > 0:
+        xb = 2.
+        xc = math.pow(9,xsigma)/4.44288
+        # 4.44288 =(math.sqrt(2)*math.pi)
+        xA = math.pow(9,xsigma)
+        xB1 = 1
+    else:
+        xb = 2.25158  #  math.sqrt( (3-2* math.log(2))*math.pi )
+        xc = math.pow(2,-xsigma)/4.44288
+        xA = math.pow(2,-xsigma)
+        xB1 = 1.10789   #  = 2*sqrt(1-log(2))
+
+    if(ysigma > 0):
+        yb = 2.
+        yc = math.pow(9,ysigma)/4.44288
+        # 4.44288 =(math.sqrt(2)*math.pi)
+        yA = math.pow(9,ysigma)
+        yB1 = 1
+    else:
+        yb = 2.25158  #  math.sqrt( (3-2* math.log(2))*math.pi )
+        yc = math.pow(2,-ysigma)/4.44288
+        yA = math.pow(2,-ysigma)
+        yB1 = 1.10789   #  = 2*sqrt(1-log(2))
+
+    #  COMPUTING L THE NUMBER OF TERMS NEEDED IN THE RIEMANN-SIEGEL
+    #                         CORRECTION
+    #  See II Section 3.2
+    ctx.prec = 15
+    xL = 1
+    while 3*xc*ctx.gamma(xL*0.5) * ctx.power(xb*a,-xL) >= xeps2:
+        xL = xL+1
+    xL = max(2,xL)
+    yL = 1
+    while 3*yc*ctx.gamma(yL*0.5) * ctx.power(yb*a,-yL) >= yeps2:
+        yL = yL+1
+    yL = max(2,yL)
+
+    #  The number L has to satify some conditions.
+    #  If not RS can not compute Rzeta(s) with the prescribed precision
+    #  (see II, Section 3.2 condition (20)  ) and
+    #  (II, Section 3.3 condition (22) ). Also we have added
+    #  an additional technical  condition in Section 3.17 Proposition 17
+    if ((3*xL >= 2*a*a/25.) or (3*xL+2+xsigma<0) or (abs(xsigma) > a/2.) or \
+        (3*yL >= 2*a*a/25.) or (3*yL+2+ysigma<0) or (abs(ysigma) > a/2.)):
+        ctx.prec = wpinitial
+        raise NotImplementedError("Riemann-Siegel can not compute with such precision")
+
+    #  We take the maximum of the two values
+    L = max(xL, yL)
+
+    #  INITIALIZATION (CONTINUATION)
+    #
+    # eps3 is the constant defined on (II, Section 3.5 equation (27) )
+    # each term of the RS correction must be computed with error <= eps3
+    xeps3 =  xeps2/(4*xL)
+    yeps3 =  yeps2/(4*yL)
+
+    # eps4 is defined on (II Section 3.6  equation (30) )
+    # each component of the formula (II Section 3.6 equation (29) )
+    # must be computed with error <= eps4
+    xeps4 = xeps3/(3*xL)
+    yeps4 = yeps3/(3*yL)
+
+    # COMPUTING M NUMBER OF DERIVATIVES Fp[m] TO COMPUTE
+    xM = aux_M_Fp(ctx, xA, xeps4, a, xB1, xL)
+    yM = aux_M_Fp(ctx, yA, yeps4, a, yB1, yL)
+    M = max(xM, yM)
+
+    # COMPUTING NUMBER OF TERMS J NEEDED
+    h3 = aux_J_needed(ctx, xA, xeps4, a, xB1, xM)
+    h4 = aux_J_needed(ctx, yA, yeps4, a, yB1, yM)
+    h3 = min(h3,h4)
+    J = 12
+    jvalue = (2*ctx.pi)**J / ctx.gamma(J+1)
+    while jvalue > h3:
+        J = J+1
+        jvalue = (2*ctx.pi)*jvalue/J
+
+    # COMPUTING eps5[m] for 1 <= m <= 21
+    #  See II Section 10 equation (43)
+    #  We choose the minimum of the two possibilities
+    eps5={}
+    xforeps5 = math.pi*math.pi*xB1*a
+    yforeps5 = math.pi*math.pi*yB1*a
+    for m in range(0,22):
+        xaux1 = math.pow(xforeps5, m/3)/(316.*xA)
+        yaux1 = math.pow(yforeps5, m/3)/(316.*yA)
+        aux1 = min(xaux1, yaux1)
+        aux2 = ctx.gamma(m+1)/ctx.gamma(m/3.0+0.5)
+        aux2 = math.sqrt(aux2)
+        eps5[m] = (aux1*aux2*min(xeps4,yeps4))
+
+    # COMPUTING wpfp
+    #  See II Section 3.13 equation (59)
+    twenty = min(3*L-3, 21)+1
+    aux = 6812*J
+    wpfp = ctx.mag(44*J)
+    for m in range(0,twenty):
+        wpfp = max(wpfp, ctx.mag(aux*ctx.gamma(m+1)/eps5[m]))
+
+    # COMPUTING N AND p
+    #  See II Section
+    ctx.prec = wpfp + ctx.mag(t)+20
+    a = ctx.sqrt(t/(2*ctx.pi))
+    N = ctx.floor(a)
+    p = 1-2*(a-N)
+
+    # now we get a rounded version of p
+    # to the precision wpfp
+    # this possibly is not necessary
+    num=ctx.floor(p*(ctx.mpf('2')**wpfp))
+    difference = p * (ctx.mpf('2')**wpfp)-num
+    if (difference < 0.5):
+        num = num
+    else:
+        num = num+1
+    p = ctx.convert(num * (ctx.mpf('2')**(-wpfp)))
+
+    # COMPUTING THE COEFFICIENTS c[n] = cc[n]
+    # We shall use the notation cc[n], since there is
+    # a constant that is called c
+    # See II Section 3.14
+    # We compute the coefficients and also save then in a
+    # cache.  The bulk of the computation is passed to
+    # the function  coef()
+    #
+    #  eps6 is defined in II Section 3.13  equation (58)
+    eps6 = ctx.power(ctx.convert(2*ctx.pi), J)/(ctx.gamma(J+1)*3*J)
+
+    #  Now we compute the coefficients
+    cc = {}
+    cont = {}
+    cont, pipowers = coef(ctx, J, eps6)
+    cc=cont.copy()   # we need a copy since we have to change his values.
+    Fp={}            # this is the adequate locus of this
+    for n in range(M, 3*L-2):
+        Fp[n] = 0
+    Fp={}
+    ctx.prec = wpfp
+    for m in range(0,M+1):
+        sumP = 0
+        for k in range(2*J-m-1,-1,-1):
+            sumP = (sumP * p)+ cc[k]
+        Fp[m] = sumP
+        # preparation of the new coefficients
+        for k in range(0,2*J-m-1):
+            cc[k] = (k+1)* cc[k+1]
+
+    # COMPUTING THE NUMBERS  xd[u,n,k], yd[u,n,k]
+    #  See II Section 3.17
+    #
+    #  First we compute the working precisions xwpd[k]
+    #   Se II equation (92)
+    xwpd={}
+    d1 = max(6,ctx.mag(40*L*L))
+    xd2 = 13+ctx.mag((1+abs(xsigma))*xA)-ctx.mag(xeps4)-1
+    xconst = ctx.ln(8/(ctx.pi*ctx.pi*a*a*xB1*xB1)) /2
+    for n in range(0,L):
+        xd3 = ctx.mag(ctx.sqrt(ctx.gamma(n-0.5)))-ctx.floor(n*xconst)+xd2
+        xwpd[n]=max(xd3,d1)
+
+    # procedure of II Section 3.17
+    ctx.prec = xwpd[1]+10
+    xpsigma = 1-(2*xsigma)
+    xd = {}
+    xd[0,0,-2]=0; xd[0,0,-1]=0; xd[0,0,0]=1; xd[0,0,1]=0
+    xd[0,-1,-2]=0; xd[0,-1,-1]=0; xd[0,-1,0]=1; xd[0,-1,1]=0
+    for n in range(1,L):
+        ctx.prec = xwpd[n]+10
+        for k in range(0,3*n//2+1):
+            m = 3*n-2*k
+            if(m!=0):
+                m1 = ctx.one/m
+                c1= m1/4
+                c2=(xpsigma*m1)/2
+                c3=-(m+1)
+                xd[0,n,k]=c3*xd[0,n-1,k-2]+c1*xd[0,n-1,k]+c2*xd[0,n-1,k-1]
+            else:
+                xd[0,n,k]=0
+                for r in range(0,k):
+                    add=xd[0,n,r]*(ctx.mpf('1.0')*ctx.fac(2*k-2*r)/ctx.fac(k-r))
+                    xd[0,n,k] -= ((-1)**(k-r))*add
+        xd[0,n,-2]=0; xd[0,n,-1]=0; xd[0,n,3*n//2+1]=0
+    for mu in range(-2,der+1):
+        for n in range(-2,L):
+            for k in range(-3,max(1,3*n//2+2)):
+                if( (mu<0)or (n<0) or(k<0)or (k>3*n//2)):
+                    xd[mu,n,k] = 0
+    for mu in range(1,der+1):
+        for n in range(0,L):
+            ctx.prec = xwpd[n]+10
+            for k in range(0,3*n//2+1):
+                aux=(2*mu-2)*xd[mu-2,n-2,k-3]+2*(xsigma+n-2)*xd[mu-1,n-2,k-3]
+                xd[mu,n,k] = aux - xd[mu-1,n-1,k-1]
+
+    #  Now we compute the working precisions ywpd[k]
+    #   Se II equation (92)
+    ywpd={}
+    d1 = max(6,ctx.mag(40*L*L))
+    yd2 = 13+ctx.mag((1+abs(ysigma))*yA)-ctx.mag(yeps4)-1
+    yconst = ctx.ln(8/(ctx.pi*ctx.pi*a*a*yB1*yB1)) /2
+    for n in range(0,L):
+        yd3 = ctx.mag(ctx.sqrt(ctx.gamma(n-0.5)))-ctx.floor(n*yconst)+yd2
+        ywpd[n]=max(yd3,d1)
+
+    # procedure of II Section 3.17
+    ctx.prec = ywpd[1]+10
+    ypsigma = 1-(2*ysigma)
+    yd = {}
+    yd[0,0,-2]=0; yd[0,0,-1]=0; yd[0,0,0]=1; yd[0,0,1]=0
+    yd[0,-1,-2]=0; yd[0,-1,-1]=0; yd[0,-1,0]=1; yd[0,-1,1]=0
+    for n in range(1,L):
+        ctx.prec = ywpd[n]+10
+        for k in range(0,3*n//2+1):
+            m = 3*n-2*k
+            if(m!=0):
+                m1 = ctx.one/m
+                c1= m1/4
+                c2=(ypsigma*m1)/2
+                c3=-(m+1)
+                yd[0,n,k]=c3*yd[0,n-1,k-2]+c1*yd[0,n-1,k]+c2*yd[0,n-1,k-1]
+            else:
+                yd[0,n,k]=0
+                for r in range(0,k):
+                    add=yd[0,n,r]*(ctx.mpf('1.0')*ctx.fac(2*k-2*r)/ctx.fac(k-r))
+                    yd[0,n,k] -= ((-1)**(k-r))*add
+        yd[0,n,-2]=0; yd[0,n,-1]=0; yd[0,n,3*n//2+1]=0
+
+    for mu in range(-2,der+1):
+        for n in range(-2,L):
+            for k in range(-3,max(1,3*n//2+2)):
+                if( (mu<0)or (n<0) or(k<0)or (k>3*n//2)):
+                    yd[mu,n,k] = 0
+    for mu in range(1,der+1):
+        for n in range(0,L):
+            ctx.prec = ywpd[n]+10
+            for k in range(0,3*n//2+1):
+                aux=(2*mu-2)*yd[mu-2,n-2,k-3]+2*(ysigma+n-2)*yd[mu-1,n-2,k-3]
+                yd[mu,n,k] = aux - yd[mu-1,n-1,k-1]
+
+    # COMPUTING THE COEFFICIENTS xtcoef[k,l]
+    #  See II Section 3.9
+    #
+    # computing the needed wp
+    xwptcoef={}
+    xwpterm={}
+    ctx.prec = 15
+    c1 = ctx.mag(40*(L+2))
+    xc2 = ctx.mag(68*(L+2)*xA)
+    xc4 = ctx.mag(xB1*a*math.sqrt(ctx.pi))-1
+    for k in range(0,L):
+        xc3 = xc2 - k*xc4+ctx.mag(ctx.fac(k+0.5))/2.
+        xwptcoef[k] = (max(c1,xc3-ctx.mag(xeps4)+1)+1 +20)*1.5
+        xwpterm[k] = (max(c1,ctx.mag(L+2)+xc3-ctx.mag(xeps3)+1)+1 +20)
+    ywptcoef={}
+    ywpterm={}
+    ctx.prec = 15
+    c1 = ctx.mag(40*(L+2))
+    yc2 = ctx.mag(68*(L+2)*yA)
+    yc4 = ctx.mag(yB1*a*math.sqrt(ctx.pi))-1
+    for k in range(0,L):
+        yc3 = yc2 - k*yc4+ctx.mag(ctx.fac(k+0.5))/2.
+        ywptcoef[k] = ((max(c1,yc3-ctx.mag(yeps4)+1))+10)*1.5
+        ywpterm[k] = (max(c1,ctx.mag(L+2)+yc3-ctx.mag(yeps3)+1)+1)+10
+
+    # check of power of pi
+    # computing the fortcoef[mu,k,ell]
+    xfortcoef={}
+    for mu in range(0,der+1):
+        for k in range(0,L):
+            for ell in range(-2,3*k//2+1):
+                xfortcoef[mu,k,ell]=0
+    for mu in range(0,der+1):
+        for k in range(0,L):
+            ctx.prec = xwptcoef[k]
+            for ell in range(0,3*k//2+1):
+                xfortcoef[mu,k,ell]=xd[mu,k,ell]*Fp[3*k-2*ell]/pipowers[2*k-ell]
+                xfortcoef[mu,k,ell]=xfortcoef[mu,k,ell]/((2*ctx.j)**ell)
+
+    def trunc_a(t):
+        wp = ctx.prec
+        ctx.prec = wp + 2
+        aa = ctx.sqrt(t/(2*ctx.pi))
+        ctx.prec = wp
+        return aa
+
+    # computing the tcoef[k,ell]
+    xtcoef={}
+    for mu in range(0,der+1):
+        for k in range(0,L):
+            for ell in range(-2,3*k//2+1):
+                xtcoef[mu,k,ell]=0
+    ctx.prec = max(xwptcoef[0],ywptcoef[0])+3
+    aa= trunc_a(t)
+    la = -ctx.ln(aa)
+
+    for chi in range(0,der+1):
+        for k in range(0,L):
+            ctx.prec = xwptcoef[k]
+            for ell in range(0,3*k//2+1):
+                xtcoef[chi,k,ell] =0
+                for mu in range(0, chi+1):
+                    tcoefter=ctx.binomial(chi,mu)*ctx.power(la,mu)*xfortcoef[chi-mu,k,ell]
+                    xtcoef[chi,k,ell] += tcoefter
+
+    # COMPUTING THE COEFFICIENTS ytcoef[k,l]
+    #  See II Section 3.9
+    #
+    # computing the needed wp
+    # check of power of pi
+    # computing the fortcoef[mu,k,ell]
+    yfortcoef={}
+    for mu in range(0,der+1):
+        for k in range(0,L):
+            for ell in range(-2,3*k//2+1):
+                yfortcoef[mu,k,ell]=0
+    for mu in range(0,der+1):
+        for k in range(0,L):
+            ctx.prec = ywptcoef[k]
+            for ell in range(0,3*k//2+1):
+                yfortcoef[mu,k,ell]=yd[mu,k,ell]*Fp[3*k-2*ell]/pipowers[2*k-ell]
+                yfortcoef[mu,k,ell]=yfortcoef[mu,k,ell]/((2*ctx.j)**ell)
+    # computing the tcoef[k,ell]
+    ytcoef={}
+    for chi in range(0,der+1):
+        for k in range(0,L):
+            for ell in range(-2,3*k//2+1):
+                ytcoef[chi,k,ell]=0
+    for chi in range(0,der+1):
+        for k in range(0,L):
+            ctx.prec = ywptcoef[k]
+            for ell in range(0,3*k//2+1):
+                ytcoef[chi,k,ell] =0
+                for mu in range(0, chi+1):
+                    tcoefter=ctx.binomial(chi,mu)*ctx.power(la,mu)*yfortcoef[chi-mu,k,ell]
+                    ytcoef[chi,k,ell] += tcoefter
+
+    # COMPUTING tv[k,ell]
+    # See II Section 3.8
+    #
+    #  a has a good value
+    ctx.prec = max(xwptcoef[0], ywptcoef[0])+2
+    av = {}
+    av[0] = 1
+    av[1] = av[0]/a
+
+    ctx.prec = max(xwptcoef[0],ywptcoef[0])
+    for k in range(2,L):
+        av[k] = av[k-1] * av[1]
+
+    # Computing the quotients
+    xtv = {}
+    for chi in range(0,der+1):
+        for k in range(0,L):
+            ctx.prec = xwptcoef[k]
+            for ell in range(0,3*k//2+1):
+                xtv[chi,k,ell] = xtcoef[chi,k,ell]* av[k]
+    # Computing the quotients
+    ytv = {}
+    for chi in range(0,der+1):
+        for k in range(0,L):
+            ctx.prec = ywptcoef[k]
+            for ell in range(0,3*k//2+1):
+                ytv[chi,k,ell] = ytcoef[chi,k,ell]* av[k]
+
+    # COMPUTING THE TERMS xterm[k]
+    # See II Section 3.6
+    xterm = {}
+    for chi in range(0,der+1):
+        for n in range(0,L):
+            ctx.prec = xwpterm[n]
+            te = 0
+            for k in range(0, 3*n//2+1):
+                te += xtv[chi,n,k]
+            xterm[chi,n] = te
+
+    # COMPUTING THE TERMS yterm[k]
+    # See II Section 3.6
+    yterm = {}
+    for chi in range(0,der+1):
+        for n in range(0,L):
+            ctx.prec = ywpterm[n]
+            te = 0
+            for k in range(0, 3*n//2+1):
+                te += ytv[chi,n,k]
+            yterm[chi,n] = te
+
+    # COMPUTING  rssum
+    # See II Section 3.5
+    xrssum={}
+    ctx.prec=15
+    xrsbound = math.sqrt(ctx.pi) * xc /(xb*a)
+    ctx.prec=15
+    xwprssum = ctx.mag(4.4*((L+3)**2)*xrsbound / xeps2)
+    xwprssum = max(xwprssum, ctx.mag(10*(L+1)))
+    ctx.prec = xwprssum
+    for chi in range(0,der+1):
+        xrssum[chi] = 0
+        for k in range(1,L+1):
+            xrssum[chi] += xterm[chi,L-k]
+    yrssum={}
+    ctx.prec=15
+    yrsbound = math.sqrt(ctx.pi) * yc /(yb*a)
+    ctx.prec=15
+    ywprssum = ctx.mag(4.4*((L+3)**2)*yrsbound / yeps2)
+    ywprssum = max(ywprssum, ctx.mag(10*(L+1)))
+    ctx.prec = ywprssum
+    for chi in range(0,der+1):
+        yrssum[chi] = 0
+        for k in range(1,L+1):
+            yrssum[chi] += yterm[chi,L-k]
+
+    # COMPUTING S3
+    # See II Section 3.19
+    ctx.prec = 15
+    A2 = 2**(max(ctx.mag(abs(xrssum[0])), ctx.mag(abs(yrssum[0]))))
+    eps8 = eps/(3*A2)
+    T = t *ctx.ln(t/(2*ctx.pi))
+    xwps3 = 5 +  ctx.mag((1+(2/eps8)*ctx.power(a,-xsigma))*T)
+    ywps3 = 5 +  ctx.mag((1+(2/eps8)*ctx.power(a,-ysigma))*T)
+
+    ctx.prec = max(xwps3, ywps3)
+
+    tpi = t/(2*ctx.pi)
+    arg = (t/2)*ctx.ln(tpi)-(t/2)-ctx.pi/8
+    U = ctx.expj(-arg)
+    a = trunc_a(t)
+    xasigma = ctx.power(a, -xsigma)
+    yasigma = ctx.power(a, -ysigma)
+    xS3 = ((-1)**(N-1)) * xasigma * U
+    yS3 = ((-1)**(N-1)) * yasigma * U
+
+    # COMPUTING S1 the zetasum
+    # See II Section 3.18
+    ctx.prec = 15
+    xwpsum =  4+ ctx.mag((N+ctx.power(N,1-xsigma))*ctx.ln(N) /eps1)
+    ywpsum =  4+ ctx.mag((N+ctx.power(N,1-ysigma))*ctx.ln(N) /eps1)
+    wpsum = max(xwpsum, ywpsum)
+
+    ctx.prec = wpsum +10
+    '''
+    # This can be improved
+    xS1={}
+    yS1={}
+    for chi in range(0,der+1):
+        xS1[chi] = 0
+        yS1[chi] = 0
+    for n in range(1,int(N)+1):
+        ln = ctx.ln(n)
+        xexpn = ctx.exp(-ln*(xsigma+ctx.j*t))
+        yexpn = ctx.conj(1/(n*xexpn))
+        for chi in range(0,der+1):
+            pown = ctx.power(-ln, chi)
+            xterm = pown*xexpn
+            yterm = pown*yexpn
+            xS1[chi] += xterm
+            yS1[chi] += yterm
+    '''
+    xS1, yS1 = ctx._zetasum(s, 1, int(N)-1, range(0,der+1), True)
+
+    # END OF COMPUTATION of xrz, yrz
+    #  See II Section 3.1
+    ctx.prec = 15
+    xabsS1 = abs(xS1[der])
+    xabsS2 = abs(xrssum[der] * xS3)
+    xwpend = max(6, wpinitial+ctx.mag(6*(3*xabsS1+7*xabsS2) ) )
+
+    ctx.prec = xwpend
+    xrz={}
+    for chi in range(0,der+1):
+        xrz[chi] = xS1[chi]+xrssum[chi]*xS3
+
+    ctx.prec = 15
+    yabsS1 = abs(yS1[der])
+    yabsS2 = abs(yrssum[der] * yS3)
+    ywpend = max(6, wpinitial+ctx.mag(6*(3*yabsS1+7*yabsS2) ) )
+
+    ctx.prec = ywpend
+    yrz={}
+    for chi in range(0,der+1):
+        yrz[chi] = yS1[chi]+yrssum[chi]*yS3
+        yrz[chi] = ctx.conj(yrz[chi])
+    ctx.prec = wpinitial
+    return xrz, yrz
+
+def Rzeta_set(ctx, s, derivatives=[0]):
+    r"""
+    Computes several derivatives of the auxiliary function of Riemann `R(s)`.
+
+    **Definition**
+
+    The function is defined by
+
+    .. math ::
+
+        \begin{equation}
+        {\mathop{\mathcal R }\nolimits}(s)=
+        \int_{0\swarrow1}\frac{x^{-s} e^{\pi i x^2}}{e^{\pi i x}-
+        e^{-\pi i x}}\,dx
+        \end{equation}
+
+    To this function we apply the Riemann-Siegel expansion.
+    """
+    der = max(derivatives)
+    # First we take the value of ctx.prec
+    # During the computation we will change ctx.prec, and finally we will
+    # restaurate the initial value
+    wpinitial = ctx.prec
+    # Take the real and imaginary part of s
+    t = ctx._im(s)
+    sigma = ctx._re(s)
+    # Now compute several parameter that appear on the program
+    ctx.prec = 15
+    a = ctx.sqrt(t/(2*ctx.pi))     #  Careful
+    asigma = ctx.power(a, sigma)  #  Careful
+    # We need a simple bound A1 < asigma  (see II Section 3.1 and 3.3)
+    A1 = ctx.power(2, ctx.mag(asigma)-1)
+    # We compute various epsilon's  (see II end of Section 3.1)
+    eps = ctx.power(2, -wpinitial)
+    eps1 = eps/6.
+    eps2 = eps * A1/3.
+    # COMPUTING SOME COEFFICIENTS THAT DEPENDS
+    #               ON  sigma
+    # constant b and c  (see I  Theorem 2 formula (26) )
+    # coefficients A and B1  (see I Section 6.1 equation (50))
+    # here we not need high precision
+    ctx.prec = 15
+    if sigma > 0:
+        b = 2.
+        c = math.pow(9,sigma)/4.44288
+        # 4.44288 =(math.sqrt(2)*math.pi)
+        A = math.pow(9,sigma)
+        B1 = 1
+    else:
+        b = 2.25158  #  math.sqrt( (3-2* math.log(2))*math.pi )
+        c = math.pow(2,-sigma)/4.44288
+        A = math.pow(2,-sigma)
+        B1 = 1.10789   #  = 2*sqrt(1-log(2))
+    #  COMPUTING L THE NUMBER OF TERMS NEEDED IN THE RIEMANN-SIEGEL
+    #                         CORRECTION
+    #  See II Section 3.2
+    ctx.prec = 15
+    L = 1
+    while 3*c*ctx.gamma(L*0.5) * ctx.power(b*a,-L) >= eps2:
+        L = L+1
+    L = max(2,L)
+    #  The number L has to satify some conditions.
+    #  If not RS can not compute Rzeta(s) with the prescribed precision
+    #  (see II, Section 3.2 condition (20)  ) and
+    #  (II, Section 3.3 condition (22) ). Also we have added
+    #  an additional technical  condition in Section 3.17 Proposition 17
+    if ((3*L >= 2*a*a/25.) or (3*L+2+sigma<0) or (abs(sigma)> a/2.)):
+        #print 'Error Riemann-Siegel can not compute with such precision'
+        ctx.prec = wpinitial
+        raise NotImplementedError("Riemann-Siegel can not compute with such precision")
+
+    #  INITIALIZATION (CONTINUATION)
+    #
+    # eps3 is the constant defined on (II, Section 3.5 equation (27) )
+    # each term of the RS correction must be computed with error <= eps3
+    eps3 =  eps2/(4*L)
+
+    # eps4 is defined on (II Section 3.6  equation (30) )
+    # each component of the formula (II Section 3.6 equation (29) )
+    # must be computed with error <= eps4
+    eps4 = eps3/(3*L)
+
+    # COMPUTING M.  NUMBER OF DERIVATIVES Fp[m] TO COMPUTE
+    M = aux_M_Fp(ctx, A, eps4, a, B1, L)
+    Fp = {}
+    for n in range(M, 3*L-2):
+        Fp[n] = 0
+
+    #  But I have not seen an instance of  M != 3*L-3
+    #
+    #  DETERMINATION OF  J  THE NUMBER OF TERMS NEEDED
+    #            IN THE TAYLOR SERIES OF F.
+    #  See II Section 3.11 equation (49))
+    h1 = eps4/(632*A)
+    h2 = ctx.pi*ctx.pi*B1*a *ctx.sqrt(3)*math.e*math.e
+    h2 = h1 * ctx.power((h2/M**2),(M-1)/3) / M
+    h3 = min(h1,h2)
+    J=12
+    jvalue = (2*ctx.pi)**J / ctx.gamma(J+1)
+    while jvalue > h3:
+        J = J+1
+        jvalue = (2*ctx.pi)*jvalue/J
+
+    # COMPUTING eps5[m] for 1 <= m <= 21
+    #  See II Section 10 equation (43)
+    eps5={}
+    foreps5 = math.pi*math.pi*B1*a
+    for m in range(0,22):
+        aux1 = math.pow(foreps5, m/3)/(316.*A)
+        aux2 = ctx.gamma(m+1)/ctx.gamma(m/3.0+0.5)
+        aux2 = math.sqrt(aux2)
+        eps5[m] = aux1*aux2*eps4
+
+    # COMPUTING wpfp
+    #  See II Section 3.13 equation (59)
+    twenty = min(3*L-3, 21)+1
+    aux = 6812*J
+    wpfp = ctx.mag(44*J)
+    for m in range(0, twenty):
+        wpfp = max(wpfp, ctx.mag(aux*ctx.gamma(m+1)/eps5[m]))
+    # COMPUTING N AND p
+    #  See II Section
+    ctx.prec = wpfp + ctx.mag(t) + 20
+    a = ctx.sqrt(t/(2*ctx.pi))
+    N = ctx.floor(a)
+    p = 1-2*(a-N)
+
+    # now we get a rounded version of p to the precision wpfp
+    # this possibly is not necessary
+    num = ctx.floor(p*(ctx.mpf(2)**wpfp))
+    difference = p * (ctx.mpf(2)**wpfp)-num
+    if difference < 0.5:
+        num = num
+    else:
+        num = num+1
+    p = ctx.convert(num * (ctx.mpf(2)**(-wpfp)))
+
+    # COMPUTING THE COEFFICIENTS c[n] = cc[n]
+    # We shall use the notation cc[n], since there is
+    # a constant that is called c
+    # See II Section 3.14
+    # We compute the coefficients and also save then in a
+    # cache.  The bulk of the computation is passed to
+    # the function  coef()
+    #
+    #  eps6 is defined in II Section 3.13  equation (58)
+    eps6 = ctx.power(2*ctx.pi, J)/(ctx.gamma(J+1)*3*J)
+
+    #  Now we compute the coefficients
+    cc={}
+    cont={}
+    cont, pipowers = coef(ctx, J, eps6)
+    cc = cont.copy()   # we need a copy since we have
+    Fp={}
+    for n in range(M, 3*L-2):
+        Fp[n] = 0
+    ctx.prec = wpfp
+    for m in range(0,M+1):
+        sumP = 0
+        for k in range(2*J-m-1,-1,-1):
+            sumP = (sumP * p) + cc[k]
+        Fp[m] = sumP
+        # preparation of the new coefficients
+        for k in range(0, 2*J-m-1):
+            cc[k] = (k+1) * cc[k+1]
+
+    # COMPUTING THE NUMBERS  d[n,k]
+    #  See II Section 3.17
+
+    #  First we compute the working precisions wpd[k]
+    #   Se II equation (92)
+    wpd = {}
+    d1 = max(6, ctx.mag(40*L*L))
+    d2 = 13+ctx.mag((1+abs(sigma))*A)-ctx.mag(eps4)-1
+    const = ctx.ln(8/(ctx.pi*ctx.pi*a*a*B1*B1)) /2
+    for n in range(0,L):
+        d3 = ctx.mag(ctx.sqrt(ctx.gamma(n-0.5)))-ctx.floor(n*const)+d2
+        wpd[n] = max(d3,d1)
+
+    # procedure of II Section 3.17
+    ctx.prec = wpd[1]+10
+    psigma = 1-(2*sigma)
+    d = {}
+    d[0,0,-2]=0; d[0,0,-1]=0; d[0,0,0]=1; d[0,0,1]=0
+    d[0,-1,-2]=0; d[0,-1,-1]=0; d[0,-1,0]=1; d[0,-1,1]=0
+    for n in range(1,L):
+        ctx.prec = wpd[n]+10
+        for k in range(0,3*n//2+1):
+            m = 3*n-2*k
+            if (m!=0):
+                m1 = ctx.one/m
+                c1 = m1/4
+                c2 = (psigma*m1)/2
+                c3 = -(m+1)
+                d[0,n,k] = c3*d[0,n-1,k-2]+c1*d[0,n-1,k]+c2*d[0,n-1,k-1]
+            else:
+                d[0,n,k]=0
+                for r in range(0,k):
+                    add = d[0,n,r]*(ctx.one*ctx.fac(2*k-2*r)/ctx.fac(k-r))
+                    d[0,n,k] -= ((-1)**(k-r))*add
+        d[0,n,-2]=0; d[0,n,-1]=0; d[0,n,3*n//2+1]=0
+
+    for mu in range(-2,der+1):
+        for n in range(-2,L):
+            for k in range(-3,max(1,3*n//2+2)):
+                if ((mu<0)or (n<0) or(k<0)or (k>3*n//2)):
+                    d[mu,n,k] = 0
+
+    for mu in range(1,der+1):
+        for n in range(0,L):
+            ctx.prec = wpd[n]+10
+            for k in range(0,3*n//2+1):
+                aux=(2*mu-2)*d[mu-2,n-2,k-3]+2*(sigma+n-2)*d[mu-1,n-2,k-3]
+                d[mu,n,k] = aux - d[mu-1,n-1,k-1]
+
+    # COMPUTING THE COEFFICIENTS t[k,l]
+    #  See II Section 3.9
+    #
+    # computing the needed wp
+    wptcoef = {}
+    wpterm = {}
+    ctx.prec = 15
+    c1 = ctx.mag(40*(L+2))
+    c2 = ctx.mag(68*(L+2)*A)
+    c4 = ctx.mag(B1*a*math.sqrt(ctx.pi))-1
+    for k in range(0,L):
+        c3 = c2 - k*c4+ctx.mag(ctx.fac(k+0.5))/2.
+        wptcoef[k] = max(c1,c3-ctx.mag(eps4)+1)+1 +10
+        wpterm[k] = max(c1,ctx.mag(L+2)+c3-ctx.mag(eps3)+1)+1 +10
+
+    # check of power of pi
+
+    # computing the fortcoef[mu,k,ell]
+    fortcoef={}
+    for mu in derivatives:
+        for k in range(0,L):
+            for ell in range(-2,3*k//2+1):
+                fortcoef[mu,k,ell]=0
+
+    for mu in derivatives:
+        for k in range(0,L):
+            ctx.prec = wptcoef[k]
+            for ell in range(0,3*k//2+1):
+                fortcoef[mu,k,ell]=d[mu,k,ell]*Fp[3*k-2*ell]/pipowers[2*k-ell]
+                fortcoef[mu,k,ell]=fortcoef[mu,k,ell]/((2*ctx.j)**ell)
+
+    def trunc_a(t):
+        wp = ctx.prec
+        ctx.prec = wp + 2
+        aa = ctx.sqrt(t/(2*ctx.pi))
+        ctx.prec = wp
+        return aa
+
+    # computing the tcoef[chi,k,ell]
+    tcoef={}
+    for chi in derivatives:
+        for k in range(0,L):
+            for ell in range(-2,3*k//2+1):
+                tcoef[chi,k,ell]=0
+    ctx.prec = wptcoef[0]+3
+    aa = trunc_a(t)
+    la = -ctx.ln(aa)
+
+    for chi in derivatives:
+        for k in range(0,L):
+            ctx.prec = wptcoef[k]
+            for ell in range(0,3*k//2+1):
+                tcoef[chi,k,ell] = 0
+                for mu in range(0, chi+1):
+                    tcoefter = ctx.binomial(chi,mu) * la**mu * \
+                        fortcoef[chi-mu,k,ell]
+                    tcoef[chi,k,ell] += tcoefter
+
+    # COMPUTING tv[k,ell]
+    # See II Section 3.8
+
+    # Computing the powers av[k] = a**(-k)
+    ctx.prec = wptcoef[0] + 2
+
+    # a has a good value of a.
+    # See II Section 3.6
+    av = {}
+    av[0] = 1
+    av[1] = av[0]/a
+
+    ctx.prec = wptcoef[0]
+    for k in range(2,L):
+        av[k] = av[k-1] * av[1]
+
+    # Computing the quotients
+    tv = {}
+    for chi in derivatives:
+        for k in range(0,L):
+            ctx.prec = wptcoef[k]
+            for ell in range(0,3*k//2+1):
+                tv[chi,k,ell] = tcoef[chi,k,ell]* av[k]
+
+    # COMPUTING THE TERMS term[k]
+    # See II Section 3.6
+    term = {}
+    for chi in derivatives:
+        for n in range(0,L):
+            ctx.prec = wpterm[n]
+            te = 0
+            for k in range(0, 3*n//2+1):
+                te += tv[chi,n,k]
+            term[chi,n] = te
+
+    # COMPUTING  rssum
+    # See II Section 3.5
+    rssum={}
+    ctx.prec=15
+    rsbound = math.sqrt(ctx.pi) * c /(b*a)
+    ctx.prec=15
+    wprssum = ctx.mag(4.4*((L+3)**2)*rsbound / eps2)
+    wprssum = max(wprssum, ctx.mag(10*(L+1)))
+    ctx.prec = wprssum
+    for chi in derivatives:
+        rssum[chi] = 0
+        for k in range(1,L+1):
+            rssum[chi] += term[chi,L-k]
+
+    # COMPUTING S3
+    # See II Section 3.19
+    ctx.prec = 15
+    A2 = 2**(ctx.mag(rssum[0]))
+    eps8 = eps/(3* A2)
+    T = t * ctx.ln(t/(2*ctx.pi))
+    wps3 = 5 + ctx.mag((1+(2/eps8)*ctx.power(a,-sigma))*T)
+
+    ctx.prec = wps3
+    tpi = t/(2*ctx.pi)
+    arg = (t/2)*ctx.ln(tpi)-(t/2)-ctx.pi/8
+    U = ctx.expj(-arg)
+    a = trunc_a(t)
+    asigma = ctx.power(a, -sigma)
+    S3 = ((-1)**(N-1)) * asigma * U
+
+    # COMPUTING S1 the zetasum
+    # See II Section 3.18
+    ctx.prec = 15
+    wpsum = 4 + ctx.mag((N+ctx.power(N,1-sigma))*ctx.ln(N)/eps1)
+
+    ctx.prec = wpsum + 10
+    '''
+    # This can be improved
+    S1 = {}
+    for chi in derivatives:
+        S1[chi] = 0
+    for n in range(1,int(N)+1):
+        ln = ctx.ln(n)
+        expn = ctx.exp(-ln*(sigma+ctx.j*t))
+        for chi in derivatives:
+            term = ctx.power(-ln, chi)*expn
+            S1[chi] += term
+    '''
+    S1 = ctx._zetasum(s, 1, int(N)-1, derivatives)[0]
+
+    # END OF COMPUTATION
+    #  See II Section 3.1
+    ctx.prec = 15
+    absS1 = abs(S1[der])
+    absS2 = abs(rssum[der] * S3)
+    wpend = max(6, wpinitial + ctx.mag(6*(3*absS1+7*absS2)))
+    ctx.prec = wpend
+    rz = {}
+    for chi in derivatives:
+        rz[chi] = S1[chi]+rssum[chi]*S3
+    ctx.prec = wpinitial
+    return rz
+
+
+def z_half(ctx,t,der=0):
+    r"""
+    z_half(t,der=0) Computes Z^(der)(t)
+    """
+    s=ctx.mpf('0.5')+ctx.j*t
+    wpinitial = ctx.prec
+    ctx.prec = 15
+    tt = t/(2*ctx.pi)
+    wptheta = wpinitial +1 + ctx.mag(3*(tt**1.5)*ctx.ln(tt))
+    wpz = wpinitial + 1 + ctx.mag(12*tt*ctx.ln(tt))
+    ctx.prec = wptheta
+    theta = ctx.siegeltheta(t)
+    ctx.prec = wpz
+    rz = Rzeta_set(ctx,s, range(der+1))
+    if der > 0: ps1 = ctx._re(ctx.psi(0,s/2)/2 - ctx.ln(ctx.pi)/2)
+    if der > 1: ps2 = ctx._re(ctx.j*ctx.psi(1,s/2)/4)
+    if der > 2: ps3 = ctx._re(-ctx.psi(2,s/2)/8)
+    if der > 3: ps4 = ctx._re(-ctx.j*ctx.psi(3,s/2)/16)
+    exptheta = ctx.expj(theta)
+    if der == 0:
+        z = 2*exptheta*rz[0]
+    if der == 1:
+        zf = 2j*exptheta
+        z = zf*(ps1*rz[0]+rz[1])
+    if der == 2:
+        zf = 2 * exptheta
+        z = -zf*(2*rz[1]*ps1+rz[0]*ps1**2+rz[2]-ctx.j*rz[0]*ps2)
+    if der == 3:
+        zf = -2j*exptheta
+        z = 3*rz[1]*ps1**2+rz[0]*ps1**3+3*ps1*rz[2]
+        z = zf*(z-3j*rz[1]*ps2-3j*rz[0]*ps1*ps2+rz[3]-rz[0]*ps3)
+    if der == 4:
+        zf = 2*exptheta
+        z = 4*rz[1]*ps1**3+rz[0]*ps1**4+6*ps1**2*rz[2]
+        z = z-12j*rz[1]*ps1*ps2-6j*rz[0]*ps1**2*ps2-6j*rz[2]*ps2-3*rz[0]*ps2*ps2
+        z = z + 4*ps1*rz[3]-4*rz[1]*ps3-4*rz[0]*ps1*ps3+rz[4]+ctx.j*rz[0]*ps4
+        z = zf*z
+    ctx.prec = wpinitial
+    return ctx._re(z)
+
+def zeta_half(ctx, s, k=0):
+    """
+    zeta_half(s,k=0) Computes zeta^(k)(s) when Re s = 0.5
+    """
+    wpinitial = ctx.prec
+    sigma = ctx._re(s)
+    t = ctx._im(s)
+    #--- compute wptheta, wpR, wpbasic ---
+    ctx.prec = 53
+    #  X see II Section 3.21 (109) and (110)
+    if sigma > 0:
+        X = ctx.sqrt(abs(s))
+    else:
+        X = (2*ctx.pi)**(sigma-1) * abs(1-s)**(0.5-sigma)
+    # M1  see II Section 3.21 (111) and (112)
+    if sigma > 0:
+        M1 = 2*ctx.sqrt(t/(2*ctx.pi))
+    else:
+        M1 = 4 * t * X
+    # T  see II Section 3.21 (113)
+    abst = abs(0.5-s)
+    T = 2* abst*math.log(abst)
+    # computing wpbasic, wptheta, wpR  see II Section 3.21
+    wpbasic = max(6,3+ctx.mag(t))
+    wpbasic2 = 2+ctx.mag(2.12*M1+21.2*M1*X+1.3*M1*X*T)+wpinitial+1
+    wpbasic = max(wpbasic, wpbasic2)
+    wptheta = max(4, 3+ctx.mag(2.7*M1*X)+wpinitial+1)
+    wpR = 3+ctx.mag(1.1+2*X)+wpinitial+1
+    ctx.prec = wptheta
+    theta = ctx.siegeltheta(t-ctx.j*(sigma-ctx.mpf('0.5')))
+    if k > 0: ps1 = (ctx._re(ctx.psi(0,s/2)))/2 - ctx.ln(ctx.pi)/2
+    if k > 1: ps2 = -(ctx._im(ctx.psi(1,s/2)))/4
+    if k > 2: ps3 = -(ctx._re(ctx.psi(2,s/2)))/8
+    if k > 3: ps4 = (ctx._im(ctx.psi(3,s/2)))/16
+    ctx.prec = wpR
+    xrz = Rzeta_set(ctx,s,range(k+1))
+    yrz={}
+    for chi in range(0,k+1):
+        yrz[chi] = ctx.conj(xrz[chi])
+    ctx.prec = wpbasic
+    exptheta = ctx.expj(-2*theta)
+    if k==0:
+        zv = xrz[0]+exptheta*yrz[0]
+    if k==1:
+        zv1 = -yrz[1] - 2*yrz[0]*ps1
+        zv = xrz[1] + exptheta*zv1
+    if k==2:
+        zv1 = 4*yrz[1]*ps1+4*yrz[0]*(ps1**2)+yrz[2]+2j*yrz[0]*ps2
+        zv = xrz[2]+exptheta*zv1
+    if k==3:
+        zv1 = -12*yrz[1]*ps1**2-8*yrz[0]*ps1**3-6*yrz[2]*ps1-6j*yrz[1]*ps2
+        zv1 = zv1 - 12j*yrz[0]*ps1*ps2-yrz[3]+2*yrz[0]*ps3
+        zv = xrz[3]+exptheta*zv1
+    if k == 4:
+        zv1 = 32*yrz[1]*ps1**3 +16*yrz[0]*ps1**4+24*yrz[2]*ps1**2
+        zv1 = zv1 +48j*yrz[1]*ps1*ps2+48j*yrz[0]*(ps1**2)*ps2
+        zv1 = zv1+12j*yrz[2]*ps2-12*yrz[0]*ps2**2+8*yrz[3]*ps1-8*yrz[1]*ps3
+        zv1 = zv1-16*yrz[0]*ps1*ps3+yrz[4]-2j*yrz[0]*ps4
+        zv = xrz[4]+exptheta*zv1
+    ctx.prec = wpinitial
+    return zv
+
+def zeta_offline(ctx, s, k=0):
+    """
+    Computes zeta^(k)(s) off the line
+    """
+    wpinitial = ctx.prec
+    sigma = ctx._re(s)
+    t = ctx._im(s)
+    #--- compute wptheta, wpR, wpbasic ---
+    ctx.prec = 53
+    #  X see II Section 3.21 (109) and (110)
+    if sigma > 0:
+        X = ctx.power(abs(s), 0.5)
+    else:
+        X = ctx.power(2*ctx.pi, sigma-1)*ctx.power(abs(1-s),0.5-sigma)
+    # M1  see II Section 3.21 (111) and (112)
+    if (sigma > 0):
+        M1 = 2*ctx.sqrt(t/(2*ctx.pi))
+    else:
+        M1 = 4 * t * X
+    # M2  see II Section 3.21 (111) and (112)
+    if (1-sigma > 0):
+        M2 = 2*ctx.sqrt(t/(2*ctx.pi))
+    else:
+        M2 = 4*t*ctx.power(2*ctx.pi, -sigma)*ctx.power(abs(s),sigma-0.5)
+    # T  see II Section 3.21 (113)
+    abst = abs(0.5-s)
+    T = 2* abst*math.log(abst)
+    # computing wpbasic, wptheta, wpR  see II Section 3.21
+    wpbasic = max(6,3+ctx.mag(t))
+    wpbasic2 = 2+ctx.mag(2.12*M1+21.2*M2*X+1.3*M2*X*T)+wpinitial+1
+    wpbasic = max(wpbasic, wpbasic2)
+    wptheta = max(4, 3+ctx.mag(2.7*M2*X)+wpinitial+1)
+    wpR = 3+ctx.mag(1.1+2*X)+wpinitial+1
+    ctx.prec = wptheta
+    theta = ctx.siegeltheta(t-ctx.j*(sigma-ctx.mpf('0.5')))
+    s1 = s
+    s2 = ctx.conj(1-s1)
+    ctx.prec = wpR
+    xrz, yrz = Rzeta_simul(ctx, s, k)
+    if k > 0: ps1 = (ctx.psi(0,s1/2)+ctx.psi(0,(1-s1)/2))/4 - ctx.ln(ctx.pi)/2
+    if k > 1: ps2 = ctx.j*(ctx.psi(1,s1/2)-ctx.psi(1,(1-s1)/2))/8
+    if k > 2: ps3 = -(ctx.psi(2,s1/2)+ctx.psi(2,(1-s1)/2))/16
+    if k > 3: ps4 = -ctx.j*(ctx.psi(3,s1/2)-ctx.psi(3,(1-s1)/2))/32
+    ctx.prec = wpbasic
+    exptheta = ctx.expj(-2*theta)
+    if k == 0:
+        zv = xrz[0]+exptheta*yrz[0]
+    if k == 1:
+        zv1 = -yrz[1]-2*yrz[0]*ps1
+        zv = xrz[1]+exptheta*zv1
+    if k == 2:
+        zv1 = 4*yrz[1]*ps1+4*yrz[0]*(ps1**2) +yrz[2]+2j*yrz[0]*ps2
+        zv = xrz[2]+exptheta*zv1
+    if k == 3:
+        zv1 = -12*yrz[1]*ps1**2 -8*yrz[0]*ps1**3-6*yrz[2]*ps1-6j*yrz[1]*ps2
+        zv1 = zv1 - 12j*yrz[0]*ps1*ps2-yrz[3]+2*yrz[0]*ps3
+        zv = xrz[3]+exptheta*zv1
+    if k == 4:
+        zv1 = 32*yrz[1]*ps1**3 +16*yrz[0]*ps1**4+24*yrz[2]*ps1**2
+        zv1 = zv1 +48j*yrz[1]*ps1*ps2+48j*yrz[0]*(ps1**2)*ps2
+        zv1 = zv1+12j*yrz[2]*ps2-12*yrz[0]*ps2**2+8*yrz[3]*ps1-8*yrz[1]*ps3
+        zv1 = zv1-16*yrz[0]*ps1*ps3+yrz[4]-2j*yrz[0]*ps4
+        zv = xrz[4]+exptheta*zv1
+    ctx.prec = wpinitial
+    return zv
+
+def z_offline(ctx, w, k=0):
+    r"""
+    Computes Z(w) and its derivatives off the line
+    """
+    s = ctx.mpf('0.5')+ctx.j*w
+    s1 = s
+    s2 = ctx.conj(1-s1)
+    wpinitial = ctx.prec
+    ctx.prec = 35
+    #  X see II Section 3.21 (109) and (110)
+    # M1  see II Section 3.21 (111) and (112)
+    if (ctx._re(s1) >= 0):
+        M1 = 2*ctx.sqrt(ctx._im(s1)/(2 * ctx.pi))
+        X = ctx.sqrt(abs(s1))
+    else:
+        X = (2*ctx.pi)**(ctx._re(s1)-1) * abs(1-s1)**(0.5-ctx._re(s1))
+        M1 = 4 * ctx._im(s1)*X
+    # M2  see II Section 3.21 (111) and (112)
+    if (ctx._re(s2) >= 0):
+        M2 = 2*ctx.sqrt(ctx._im(s2)/(2 * ctx.pi))
+    else:
+        M2 = 4 * ctx._im(s2)*(2*ctx.pi)**(ctx._re(s2)-1)*abs(1-s2)**(0.5-ctx._re(s2))
+    # T  see II Section 3.21  Prop. 27
+    T = 2*abs(ctx.siegeltheta(w))
+    # defining some precisions
+    # see II Section 3.22 (115), (116), (117)
+    aux1 = ctx.sqrt(X)
+    aux2 = aux1*(M1+M2)
+    aux3 = 3 +wpinitial
+    wpbasic = max(6, 3+ctx.mag(T), ctx.mag(aux2*(26+2*T))+aux3)
+    wptheta = max(4,ctx.mag(2.04*aux2)+aux3)
+    wpR = ctx.mag(4*aux1)+aux3
+    # now the computations
+    ctx.prec = wptheta
+    theta = ctx.siegeltheta(w)
+    ctx.prec = wpR
+    xrz, yrz = Rzeta_simul(ctx,s,k)
+    pta = 0.25 + 0.5j*w
+    ptb = 0.25 - 0.5j*w
+    if k > 0: ps1 = 0.25*(ctx.psi(0,pta)+ctx.psi(0,ptb)) - ctx.ln(ctx.pi)/2
+    if k > 1: ps2 = (1j/8)*(ctx.psi(1,pta)-ctx.psi(1,ptb))
+    if k > 2: ps3 = (-1./16)*(ctx.psi(2,pta)+ctx.psi(2,ptb))
+    if k > 3: ps4 = (-1j/32)*(ctx.psi(3,pta)-ctx.psi(3,ptb))
+    ctx.prec = wpbasic
+    exptheta = ctx.expj(theta)
+    if k == 0:
+        zv = exptheta*xrz[0]+yrz[0]/exptheta
+    j = ctx.j
+    if k == 1:
+        zv = j*exptheta*(xrz[1]+xrz[0]*ps1)-j*(yrz[1]+yrz[0]*ps1)/exptheta
+    if k == 2:
+        zv = exptheta*(-2*xrz[1]*ps1-xrz[0]*ps1**2-xrz[2]+j*xrz[0]*ps2)
+        zv =zv + (-2*yrz[1]*ps1-yrz[0]*ps1**2-yrz[2]-j*yrz[0]*ps2)/exptheta
+    if k == 3:
+        zv1 = -3*xrz[1]*ps1**2-xrz[0]*ps1**3-3*xrz[2]*ps1+j*3*xrz[1]*ps2
+        zv1 = (zv1+ 3j*xrz[0]*ps1*ps2-xrz[3]+xrz[0]*ps3)*j*exptheta
+        zv2 = 3*yrz[1]*ps1**2+yrz[0]*ps1**3+3*yrz[2]*ps1+j*3*yrz[1]*ps2
+        zv2 = j*(zv2 + 3j*yrz[0]*ps1*ps2+ yrz[3]-yrz[0]*ps3)/exptheta
+        zv = zv1+zv2
+    if k == 4:
+        zv1 = 4*xrz[1]*ps1**3+xrz[0]*ps1**4 + 6*xrz[2]*ps1**2
+        zv1 = zv1-12j*xrz[1]*ps1*ps2-6j*xrz[0]*ps1**2*ps2-6j*xrz[2]*ps2
+        zv1 = zv1-3*xrz[0]*ps2*ps2+4*xrz[3]*ps1-4*xrz[1]*ps3-4*xrz[0]*ps1*ps3
+        zv1 = zv1+xrz[4]+j*xrz[0]*ps4
+        zv2 = 4*yrz[1]*ps1**3+yrz[0]*ps1**4 + 6*yrz[2]*ps1**2
+        zv2 = zv2+12j*yrz[1]*ps1*ps2+6j*yrz[0]*ps1**2*ps2+6j*yrz[2]*ps2
+        zv2 = zv2-3*yrz[0]*ps2*ps2+4*yrz[3]*ps1-4*yrz[1]*ps3-4*yrz[0]*ps1*ps3
+        zv2 = zv2+yrz[4]-j*yrz[0]*ps4
+        zv = exptheta*zv1+zv2/exptheta
+    ctx.prec = wpinitial
+    return zv
+
+@defun
+def rs_zeta(ctx, s, derivative=0, **kwargs):
+    if derivative > 4:
+        raise NotImplementedError
+    s = ctx.convert(s)
+    re = ctx._re(s); im = ctx._im(s)
+    if im < 0:
+        z = ctx.conj(ctx.rs_zeta(ctx.conj(s), derivative))
+        return z
+    critical_line = (re == 0.5)
+    if critical_line:
+        return zeta_half(ctx, s, derivative)
+    else:
+        return zeta_offline(ctx, s, derivative)
+
+@defun
+def rs_z(ctx, w, derivative=0):
+    w = ctx.convert(w)
+    re = ctx._re(w); im = ctx._im(w)
+    if re < 0:
+        return rs_z(ctx, -w, derivative)
+    critical_line = (im == 0)
+    if critical_line :
+        return z_half(ctx, w, derivative)
+    else:
+        return z_offline(ctx, w, derivative)
diff --git a/lib/python3.10/site-packages/mpmath/functions/signals.py b/lib/python3.10/site-packages/mpmath/functions/signals.py
new file mode 100644
index 0000000000000000000000000000000000000000..6fadafb2dbb44fe19a2defa8d807d81d7c8e2789
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/functions/signals.py
@@ -0,0 +1,32 @@
+from .functions import defun_wrapped
+
+@defun_wrapped
+def squarew(ctx, t, amplitude=1, period=1):
+    P = period
+    A = amplitude
+    return A*((-1)**ctx.floor(2*t/P))
+
+@defun_wrapped
+def trianglew(ctx, t, amplitude=1, period=1):
+    A = amplitude
+    P = period
+
+    return 2*A*(0.5 - ctx.fabs(1 - 2*ctx.frac(t/P + 0.25)))
+
+@defun_wrapped
+def sawtoothw(ctx, t, amplitude=1, period=1):
+    A = amplitude
+    P = period
+    return A*ctx.frac(t/P)
+
+@defun_wrapped
+def unit_triangle(ctx, t, amplitude=1):
+    A = amplitude
+    if t <= -1 or t >= 1:
+        return ctx.zero
+    return A*(-ctx.fabs(t) + 1)
+
+@defun_wrapped
+def sigmoid(ctx, t, amplitude=1):
+    A = amplitude
+    return A / (1 + ctx.exp(-t))
diff --git a/lib/python3.10/site-packages/mpmath/functions/theta.py b/lib/python3.10/site-packages/mpmath/functions/theta.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b3d8323a163a43186b85417a1b40f3b656c30d0
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/functions/theta.py
@@ -0,0 +1,1049 @@
+from .functions import defun, defun_wrapped
+
+@defun
+def _jacobi_theta2(ctx, z, q):
+    extra1 = 10
+    extra2 = 20
+    # the loops below break when the fixed precision quantities
+    # a and b go to zero;
+    # right shifting small negative numbers by wp one obtains -1, not zero,
+    # so the condition a**2 + b**2 > MIN is used to break the loops.
+    MIN = 2
+    if z == ctx.zero:
+        if (not ctx._im(q)):
+            wp = ctx.prec + extra1
+            x = ctx.to_fixed(ctx._re(q), wp)
+            x2 = (x*x) >> wp
+            a = b = x2
+            s = x2
+            while abs(a) > MIN:
+                b = (b*x2) >> wp
+                a = (a*b) >> wp
+                s += a
+            s = (1 << (wp+1)) + (s << 1)
+            s = ctx.ldexp(s, -wp)
+        else:
+            wp = ctx.prec + extra1
+            xre = ctx.to_fixed(ctx._re(q), wp)
+            xim = ctx.to_fixed(ctx._im(q), wp)
+            x2re = (xre*xre - xim*xim) >> wp
+            x2im = (xre*xim) >> (wp-1)
+            are = bre = x2re
+            aim = bim = x2im
+            sre = (1<<wp) + are
+            sim = aim
+            while are**2 + aim**2 > MIN:
+                bre, bim = (bre * x2re - bim * x2im) >> wp, \
+                           (bre * x2im + bim * x2re) >> wp
+                are, aim = (are * bre - aim * bim) >> wp,   \
+                           (are * bim + aim * bre) >> wp
+                sre += are
+                sim += aim
+            sre = (sre << 1)
+            sim = (sim << 1)
+            sre = ctx.ldexp(sre, -wp)
+            sim = ctx.ldexp(sim, -wp)
+            s = ctx.mpc(sre, sim)
+    else:
+        if (not ctx._im(q)) and (not ctx._im(z)):
+            wp = ctx.prec + extra1
+            x = ctx.to_fixed(ctx._re(q), wp)
+            x2 = (x*x) >> wp
+            a = b = x2
+            c1, s1 = ctx.cos_sin(ctx._re(z), prec=wp)
+            cn = c1 = ctx.to_fixed(c1, wp)
+            sn = s1 = ctx.to_fixed(s1, wp)
+            c2 = (c1*c1 - s1*s1) >> wp
+            s2 = (c1 * s1) >> (wp - 1)
+            cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp
+            s = c1 + ((a * cn) >> wp)
+            while abs(a) > MIN:
+                b = (b*x2) >> wp
+                a = (a*b) >> wp
+                cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp
+                s += (a * cn) >> wp
+            s = (s << 1)
+            s = ctx.ldexp(s, -wp)
+            s *= ctx.nthroot(q, 4)
+            return s
+        # case z real, q complex
+        elif not ctx._im(z):
+            wp = ctx.prec + extra2
+            xre = ctx.to_fixed(ctx._re(q), wp)
+            xim = ctx.to_fixed(ctx._im(q), wp)
+            x2re = (xre*xre - xim*xim) >> wp
+            x2im = (xre*xim) >> (wp - 1)
+            are = bre = x2re
+            aim = bim = x2im
+            c1, s1 = ctx.cos_sin(ctx._re(z), prec=wp)
+            cn = c1 = ctx.to_fixed(c1, wp)
+            sn = s1 = ctx.to_fixed(s1, wp)
+            c2 = (c1*c1 - s1*s1) >> wp
+            s2 = (c1 * s1) >> (wp - 1)
+            cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp
+            sre = c1 + ((are * cn) >> wp)
+            sim = ((aim * cn) >> wp)
+            while are**2 + aim**2 > MIN:
+                bre, bim = (bre * x2re - bim * x2im) >> wp, \
+                           (bre * x2im + bim * x2re) >> wp
+                are, aim = (are * bre - aim * bim) >> wp,   \
+                           (are * bim + aim * bre) >> wp
+                cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp
+                sre += ((are * cn) >> wp)
+                sim += ((aim * cn) >> wp)
+            sre = (sre << 1)
+            sim = (sim << 1)
+            sre = ctx.ldexp(sre, -wp)
+            sim = ctx.ldexp(sim, -wp)
+            s = ctx.mpc(sre, sim)
+        #case z complex, q real
+        elif not ctx._im(q):
+            wp = ctx.prec + extra2
+            x = ctx.to_fixed(ctx._re(q), wp)
+            x2 = (x*x) >> wp
+            a = b = x2
+            prec0 = ctx.prec
+            ctx.prec = wp
+            c1, s1 = ctx.cos_sin(z)
+            ctx.prec = prec0
+            cnre = c1re = ctx.to_fixed(ctx._re(c1), wp)
+            cnim = c1im = ctx.to_fixed(ctx._im(c1), wp)
+            snre = s1re = ctx.to_fixed(ctx._re(s1), wp)
+            snim = s1im = ctx.to_fixed(ctx._im(s1), wp)
+            #c2 = (c1*c1 - s1*s1) >> wp
+            c2re = (c1re*c1re - c1im*c1im - s1re*s1re + s1im*s1im) >> wp
+            c2im = (c1re*c1im - s1re*s1im) >> (wp - 1)
+            #s2 = (c1 * s1) >> (wp - 1)
+            s2re = (c1re*s1re - c1im*s1im) >> (wp - 1)
+            s2im = (c1re*s1im + c1im*s1re) >> (wp - 1)
+            #cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp
+            t1 = (cnre*c2re - cnim*c2im - snre*s2re + snim*s2im) >> wp
+            t2 = (cnre*c2im + cnim*c2re - snre*s2im - snim*s2re) >> wp
+            t3 = (snre*c2re - snim*c2im + cnre*s2re - cnim*s2im) >> wp
+            t4 = (snre*c2im + snim*c2re + cnre*s2im + cnim*s2re) >> wp
+            cnre = t1
+            cnim = t2
+            snre = t3
+            snim = t4
+            sre = c1re + ((a * cnre) >> wp)
+            sim = c1im + ((a * cnim) >> wp)
+            while abs(a) > MIN:
+                b = (b*x2) >> wp
+                a = (a*b) >> wp
+                t1 = (cnre*c2re - cnim*c2im - snre*s2re + snim*s2im) >> wp
+                t2 = (cnre*c2im + cnim*c2re - snre*s2im - snim*s2re) >> wp
+                t3 = (snre*c2re - snim*c2im + cnre*s2re - cnim*s2im) >> wp
+                t4 = (snre*c2im + snim*c2re + cnre*s2im + cnim*s2re) >> wp
+                cnre = t1
+                cnim = t2
+                snre = t3
+                snim = t4
+                sre += ((a * cnre) >> wp)
+                sim += ((a * cnim) >> wp)
+            sre = (sre << 1)
+            sim = (sim << 1)
+            sre = ctx.ldexp(sre, -wp)
+            sim = ctx.ldexp(sim, -wp)
+            s = ctx.mpc(sre, sim)
+        # case z and q complex
+        else:
+            wp = ctx.prec + extra2
+            xre = ctx.to_fixed(ctx._re(q), wp)
+            xim = ctx.to_fixed(ctx._im(q), wp)
+            x2re = (xre*xre - xim*xim) >> wp
+            x2im = (xre*xim) >> (wp - 1)
+            are = bre = x2re
+            aim = bim = x2im
+            prec0 = ctx.prec
+            ctx.prec = wp
+            # cos(z), sin(z) with z complex
+            c1, s1 = ctx.cos_sin(z)
+            ctx.prec = prec0
+            cnre = c1re = ctx.to_fixed(ctx._re(c1), wp)
+            cnim = c1im = ctx.to_fixed(ctx._im(c1), wp)
+            snre = s1re = ctx.to_fixed(ctx._re(s1), wp)
+            snim = s1im = ctx.to_fixed(ctx._im(s1), wp)
+            c2re = (c1re*c1re - c1im*c1im - s1re*s1re + s1im*s1im) >> wp
+            c2im = (c1re*c1im - s1re*s1im) >> (wp - 1)
+            s2re = (c1re*s1re - c1im*s1im) >> (wp - 1)
+            s2im = (c1re*s1im + c1im*s1re) >> (wp - 1)
+            t1 = (cnre*c2re - cnim*c2im - snre*s2re + snim*s2im) >> wp
+            t2 = (cnre*c2im + cnim*c2re - snre*s2im - snim*s2re) >> wp
+            t3 = (snre*c2re - snim*c2im + cnre*s2re - cnim*s2im) >> wp
+            t4 = (snre*c2im + snim*c2re + cnre*s2im + cnim*s2re) >> wp
+            cnre = t1
+            cnim = t2
+            snre = t3
+            snim = t4
+            n = 1
+            termre = c1re
+            termim = c1im
+            sre = c1re + ((are * cnre - aim * cnim) >> wp)
+            sim = c1im + ((are * cnim + aim * cnre) >> wp)
+            n = 3
+            termre = ((are * cnre - aim * cnim) >> wp)
+            termim = ((are * cnim + aim * cnre) >> wp)
+            sre = c1re + ((are * cnre - aim * cnim) >> wp)
+            sim = c1im + ((are * cnim + aim * cnre) >> wp)
+            n = 5
+            while are**2 + aim**2 > MIN:
+                bre, bim = (bre * x2re - bim * x2im) >> wp, \
+                           (bre * x2im + bim * x2re) >> wp
+                are, aim = (are * bre - aim * bim) >> wp,   \
+                           (are * bim + aim * bre) >> wp
+                #cn, sn = (cn*c1 - sn*s1) >> wp, (sn*c1 + cn*s1) >> wp
+                t1 = (cnre*c2re - cnim*c2im - snre*s2re + snim*s2im) >> wp
+                t2 = (cnre*c2im + cnim*c2re - snre*s2im - snim*s2re) >> wp
+                t3 = (snre*c2re - snim*c2im + cnre*s2re - cnim*s2im) >> wp
+                t4 = (snre*c2im + snim*c2re + cnre*s2im + cnim*s2re) >> wp
+                cnre = t1
+                cnim = t2
+                snre = t3
+                snim = t4
+                termre = ((are * cnre - aim * cnim) >> wp)
+                termim = ((aim * cnre + are * cnim) >> wp)
+                sre += ((are * cnre - aim * cnim) >> wp)
+                sim += ((aim * cnre + are * cnim) >> wp)
+                n += 2
+            sre = (sre << 1)
+            sim = (sim << 1)
+            sre = ctx.ldexp(sre, -wp)
+            sim = ctx.ldexp(sim, -wp)
+            s = ctx.mpc(sre, sim)
+    s *= ctx.nthroot(q, 4)
+    return s
+
+@defun
+def _djacobi_theta2(ctx, z, q, nd):
+    MIN = 2
+    extra1 = 10
+    extra2 = 20
+    if (not ctx._im(q)) and (not ctx._im(z)):
+        wp = ctx.prec + extra1
+        x = ctx.to_fixed(ctx._re(q), wp)
+        x2 = (x*x) >> wp
+        a = b = x2
+        c1, s1 = ctx.cos_sin(ctx._re(z), prec=wp)
+        cn = c1 = ctx.to_fixed(c1, wp)
+        sn = s1 = ctx.to_fixed(s1, wp)
+        c2 = (c1*c1 - s1*s1) >> wp
+        s2 = (c1 * s1) >> (wp - 1)
+        cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp
+        if (nd&1):
+            s = s1 + ((a * sn * 3**nd) >> wp)
+        else:
+            s = c1 + ((a * cn * 3**nd) >> wp)
+        n = 2
+        while abs(a) > MIN:
+            b = (b*x2) >> wp
+            a = (a*b) >> wp
+            cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp
+            if nd&1:
+                s += (a * sn * (2*n+1)**nd) >> wp
+            else:
+                s += (a * cn * (2*n+1)**nd) >> wp
+            n += 1
+        s = -(s << 1)
+        s = ctx.ldexp(s, -wp)
+        # case z real, q complex
+    elif not ctx._im(z):
+        wp = ctx.prec + extra2
+        xre = ctx.to_fixed(ctx._re(q), wp)
+        xim = ctx.to_fixed(ctx._im(q), wp)
+        x2re = (xre*xre - xim*xim) >> wp
+        x2im = (xre*xim) >> (wp - 1)
+        are = bre = x2re
+        aim = bim = x2im
+        c1, s1 = ctx.cos_sin(ctx._re(z), prec=wp)
+        cn = c1 = ctx.to_fixed(c1, wp)
+        sn = s1 = ctx.to_fixed(s1, wp)
+        c2 = (c1*c1 - s1*s1) >> wp
+        s2 = (c1 * s1) >> (wp - 1)
+        cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp
+        if (nd&1):
+            sre = s1 + ((are * sn * 3**nd) >> wp)
+            sim = ((aim * sn * 3**nd) >> wp)
+        else:
+            sre = c1 + ((are * cn * 3**nd) >> wp)
+            sim = ((aim * cn * 3**nd) >> wp)
+        n = 5
+        while are**2 + aim**2 > MIN:
+            bre, bim = (bre * x2re - bim * x2im) >> wp, \
+                       (bre * x2im + bim * x2re) >> wp
+            are, aim = (are * bre - aim * bim) >> wp,   \
+                       (are * bim + aim * bre) >> wp
+            cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp
+
+            if (nd&1):
+                sre += ((are * sn * n**nd) >> wp)
+                sim += ((aim * sn * n**nd) >> wp)
+            else:
+                sre += ((are * cn * n**nd) >> wp)
+                sim += ((aim * cn * n**nd) >> wp)
+            n += 2
+        sre = -(sre << 1)
+        sim = -(sim << 1)
+        sre = ctx.ldexp(sre, -wp)
+        sim = ctx.ldexp(sim, -wp)
+        s = ctx.mpc(sre, sim)
+    #case z complex, q real
+    elif not ctx._im(q):
+        wp = ctx.prec + extra2
+        x = ctx.to_fixed(ctx._re(q), wp)
+        x2 = (x*x) >> wp
+        a = b = x2
+        prec0 = ctx.prec
+        ctx.prec = wp
+        c1, s1 = ctx.cos_sin(z)
+        ctx.prec = prec0
+        cnre = c1re = ctx.to_fixed(ctx._re(c1), wp)
+        cnim = c1im = ctx.to_fixed(ctx._im(c1), wp)
+        snre = s1re = ctx.to_fixed(ctx._re(s1), wp)
+        snim = s1im = ctx.to_fixed(ctx._im(s1), wp)
+        #c2 = (c1*c1 - s1*s1) >> wp
+        c2re = (c1re*c1re - c1im*c1im - s1re*s1re + s1im*s1im) >> wp
+        c2im = (c1re*c1im - s1re*s1im) >> (wp - 1)
+        #s2 = (c1 * s1) >> (wp - 1)
+        s2re = (c1re*s1re - c1im*s1im) >> (wp - 1)
+        s2im = (c1re*s1im + c1im*s1re) >> (wp - 1)
+        #cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp
+        t1 = (cnre*c2re - cnim*c2im - snre*s2re + snim*s2im) >> wp
+        t2 = (cnre*c2im + cnim*c2re - snre*s2im - snim*s2re) >> wp
+        t3 = (snre*c2re - snim*c2im + cnre*s2re - cnim*s2im) >> wp
+        t4 = (snre*c2im + snim*c2re + cnre*s2im + cnim*s2re) >> wp
+        cnre = t1
+        cnim = t2
+        snre = t3
+        snim = t4
+        if (nd&1):
+            sre = s1re + ((a * snre * 3**nd) >> wp)
+            sim = s1im + ((a * snim * 3**nd) >> wp)
+        else:
+            sre = c1re + ((a * cnre * 3**nd) >> wp)
+            sim = c1im + ((a * cnim * 3**nd) >> wp)
+        n = 5
+        while abs(a) > MIN:
+            b = (b*x2) >> wp
+            a = (a*b) >> wp
+            t1 = (cnre*c2re - cnim*c2im - snre*s2re + snim*s2im) >> wp
+            t2 = (cnre*c2im + cnim*c2re - snre*s2im - snim*s2re) >> wp
+            t3 = (snre*c2re - snim*c2im + cnre*s2re - cnim*s2im) >> wp
+            t4 = (snre*c2im + snim*c2re + cnre*s2im + cnim*s2re) >> wp
+            cnre = t1
+            cnim = t2
+            snre = t3
+            snim = t4
+            if (nd&1):
+                sre += ((a * snre * n**nd) >> wp)
+                sim += ((a * snim * n**nd) >> wp)
+            else:
+                sre += ((a * cnre * n**nd) >> wp)
+                sim += ((a * cnim * n**nd) >> wp)
+            n += 2
+        sre = -(sre << 1)
+        sim = -(sim << 1)
+        sre = ctx.ldexp(sre, -wp)
+        sim = ctx.ldexp(sim, -wp)
+        s = ctx.mpc(sre, sim)
+    # case z and q complex
+    else:
+        wp = ctx.prec + extra2
+        xre = ctx.to_fixed(ctx._re(q), wp)
+        xim = ctx.to_fixed(ctx._im(q), wp)
+        x2re = (xre*xre - xim*xim) >> wp
+        x2im = (xre*xim) >> (wp - 1)
+        are = bre = x2re
+        aim = bim = x2im
+        prec0 = ctx.prec
+        ctx.prec = wp
+        # cos(2*z), sin(2*z) with z complex
+        c1, s1 = ctx.cos_sin(z)
+        ctx.prec = prec0
+        cnre = c1re = ctx.to_fixed(ctx._re(c1), wp)
+        cnim = c1im = ctx.to_fixed(ctx._im(c1), wp)
+        snre = s1re = ctx.to_fixed(ctx._re(s1), wp)
+        snim = s1im = ctx.to_fixed(ctx._im(s1), wp)
+        c2re = (c1re*c1re - c1im*c1im - s1re*s1re + s1im*s1im) >> wp
+        c2im = (c1re*c1im - s1re*s1im) >> (wp - 1)
+        s2re = (c1re*s1re - c1im*s1im) >> (wp - 1)
+        s2im = (c1re*s1im + c1im*s1re) >> (wp - 1)
+        t1 = (cnre*c2re - cnim*c2im - snre*s2re + snim*s2im) >> wp
+        t2 = (cnre*c2im + cnim*c2re - snre*s2im - snim*s2re) >> wp
+        t3 = (snre*c2re - snim*c2im + cnre*s2re - cnim*s2im) >> wp
+        t4 = (snre*c2im + snim*c2re + cnre*s2im + cnim*s2re) >> wp
+        cnre = t1
+        cnim = t2
+        snre = t3
+        snim = t4
+        if (nd&1):
+            sre = s1re + (((are * snre - aim * snim) * 3**nd) >> wp)
+            sim = s1im + (((are * snim + aim * snre)* 3**nd) >> wp)
+        else:
+            sre = c1re + (((are * cnre - aim * cnim) * 3**nd) >> wp)
+            sim = c1im + (((are * cnim + aim * cnre)* 3**nd) >> wp)
+        n = 5
+        while are**2 + aim**2 > MIN:
+            bre, bim = (bre * x2re - bim * x2im) >> wp, \
+                       (bre * x2im + bim * x2re) >> wp
+            are, aim = (are * bre - aim * bim) >> wp,   \
+                       (are * bim + aim * bre) >> wp
+            #cn, sn = (cn*c1 - sn*s1) >> wp, (sn*c1 + cn*s1) >> wp
+            t1 = (cnre*c2re - cnim*c2im - snre*s2re + snim*s2im) >> wp
+            t2 = (cnre*c2im + cnim*c2re - snre*s2im - snim*s2re) >> wp
+            t3 = (snre*c2re - snim*c2im + cnre*s2re - cnim*s2im) >> wp
+            t4 = (snre*c2im + snim*c2re + cnre*s2im + cnim*s2re) >> wp
+            cnre = t1
+            cnim = t2
+            snre = t3
+            snim = t4
+            if (nd&1):
+                sre += (((are * snre - aim * snim) * n**nd) >> wp)
+                sim += (((aim * snre + are * snim) * n**nd) >> wp)
+            else:
+                sre += (((are * cnre - aim * cnim) * n**nd) >> wp)
+                sim += (((aim * cnre + are * cnim) * n**nd) >> wp)
+            n += 2
+        sre = -(sre << 1)
+        sim = -(sim << 1)
+        sre = ctx.ldexp(sre, -wp)
+        sim = ctx.ldexp(sim, -wp)
+        s = ctx.mpc(sre, sim)
+    s *= ctx.nthroot(q, 4)
+    if (nd&1):
+        return (-1)**(nd//2) * s
+    else:
+        return (-1)**(1 + nd//2) * s
+
+@defun
+def _jacobi_theta3(ctx, z, q):
+    extra1 = 10
+    extra2 = 20
+    MIN = 2
+    if z == ctx.zero:
+        if not ctx._im(q):
+            wp = ctx.prec + extra1
+            x = ctx.to_fixed(ctx._re(q), wp)
+            s = x
+            a = b = x
+            x2 = (x*x) >> wp
+            while abs(a) > MIN:
+                b = (b*x2) >> wp
+                a = (a*b) >> wp
+                s += a
+            s = (1 << wp) + (s << 1)
+            s = ctx.ldexp(s, -wp)
+            return s
+        else:
+            wp = ctx.prec + extra1
+            xre = ctx.to_fixed(ctx._re(q), wp)
+            xim = ctx.to_fixed(ctx._im(q), wp)
+            x2re = (xre*xre - xim*xim) >> wp
+            x2im = (xre*xim) >> (wp - 1)
+            sre = are = bre = xre
+            sim = aim = bim = xim
+            while are**2 + aim**2 > MIN:
+                bre, bim = (bre * x2re - bim * x2im) >> wp, \
+                           (bre * x2im + bim * x2re) >> wp
+                are, aim = (are * bre - aim * bim) >> wp,   \
+                           (are * bim + aim * bre) >> wp
+                sre += are
+                sim += aim
+            sre = (1 << wp) + (sre << 1)
+            sim = (sim << 1)
+            sre = ctx.ldexp(sre, -wp)
+            sim = ctx.ldexp(sim, -wp)
+            s = ctx.mpc(sre, sim)
+            return s
+    else:
+        if (not ctx._im(q)) and (not ctx._im(z)):
+            s = 0
+            wp = ctx.prec + extra1
+            x = ctx.to_fixed(ctx._re(q), wp)
+            a = b = x
+            x2 = (x*x) >> wp
+            c1, s1 = ctx.cos_sin(ctx._re(z)*2, prec=wp)
+            c1 = ctx.to_fixed(c1, wp)
+            s1 = ctx.to_fixed(s1, wp)
+            cn = c1
+            sn = s1
+            s += (a * cn) >> wp
+            while abs(a) > MIN:
+                b = (b*x2) >> wp
+                a = (a*b) >> wp
+                cn, sn = (cn*c1 - sn*s1) >> wp, (sn*c1 + cn*s1) >> wp
+                s += (a * cn) >> wp
+            s = (1 << wp) + (s << 1)
+            s = ctx.ldexp(s, -wp)
+            return s
+        # case z real, q complex
+        elif not ctx._im(z):
+            wp = ctx.prec + extra2
+            xre = ctx.to_fixed(ctx._re(q), wp)
+            xim = ctx.to_fixed(ctx._im(q), wp)
+            x2re = (xre*xre - xim*xim) >> wp
+            x2im = (xre*xim) >> (wp - 1)
+            are = bre = xre
+            aim = bim = xim
+            c1, s1 = ctx.cos_sin(ctx._re(z)*2, prec=wp)
+            c1 = ctx.to_fixed(c1, wp)
+            s1 = ctx.to_fixed(s1, wp)
+            cn = c1
+            sn = s1
+            sre = (are * cn) >> wp
+            sim = (aim * cn) >> wp
+            while are**2 + aim**2 > MIN:
+                bre, bim = (bre * x2re - bim * x2im) >> wp, \
+                           (bre * x2im + bim * x2re) >> wp
+                are, aim = (are * bre - aim * bim) >> wp,   \
+                           (are * bim + aim * bre) >> wp
+                cn, sn = (cn*c1 - sn*s1) >> wp, (sn*c1 + cn*s1) >> wp
+                sre += (are * cn) >> wp
+                sim += (aim * cn) >> wp
+            sre = (1 << wp) + (sre << 1)
+            sim = (sim << 1)
+            sre = ctx.ldexp(sre, -wp)
+            sim = ctx.ldexp(sim, -wp)
+            s = ctx.mpc(sre, sim)
+            return s
+        #case z complex, q real
+        elif not ctx._im(q):
+            wp = ctx.prec + extra2
+            x = ctx.to_fixed(ctx._re(q), wp)
+            a = b = x
+            x2 = (x*x) >> wp
+            prec0 = ctx.prec
+            ctx.prec = wp
+            c1, s1 = ctx.cos_sin(2*z)
+            ctx.prec = prec0
+            cnre = c1re = ctx.to_fixed(ctx._re(c1), wp)
+            cnim = c1im = ctx.to_fixed(ctx._im(c1), wp)
+            snre = s1re = ctx.to_fixed(ctx._re(s1), wp)
+            snim = s1im = ctx.to_fixed(ctx._im(s1), wp)
+            sre = (a * cnre) >> wp
+            sim = (a * cnim) >> wp
+            while abs(a) > MIN:
+                b = (b*x2) >> wp
+                a = (a*b) >> wp
+                t1 = (cnre*c1re - cnim*c1im - snre*s1re + snim*s1im) >> wp
+                t2 = (cnre*c1im + cnim*c1re - snre*s1im - snim*s1re) >> wp
+                t3 = (snre*c1re - snim*c1im + cnre*s1re - cnim*s1im) >> wp
+                t4 = (snre*c1im + snim*c1re + cnre*s1im + cnim*s1re) >> wp
+                cnre = t1
+                cnim = t2
+                snre = t3
+                snim = t4
+                sre += (a * cnre) >> wp
+                sim += (a * cnim) >> wp
+            sre = (1 << wp) + (sre << 1)
+            sim = (sim << 1)
+            sre = ctx.ldexp(sre, -wp)
+            sim = ctx.ldexp(sim, -wp)
+            s = ctx.mpc(sre, sim)
+            return s
+        # case z and q complex
+        else:
+            wp = ctx.prec + extra2
+            xre = ctx.to_fixed(ctx._re(q), wp)
+            xim = ctx.to_fixed(ctx._im(q), wp)
+            x2re = (xre*xre - xim*xim) >> wp
+            x2im = (xre*xim) >> (wp - 1)
+            are = bre = xre
+            aim = bim = xim
+            prec0 = ctx.prec
+            ctx.prec = wp
+            # cos(2*z), sin(2*z) with z complex
+            c1, s1 = ctx.cos_sin(2*z)
+            ctx.prec = prec0
+            cnre = c1re = ctx.to_fixed(ctx._re(c1), wp)
+            cnim = c1im = ctx.to_fixed(ctx._im(c1), wp)
+            snre = s1re = ctx.to_fixed(ctx._re(s1), wp)
+            snim = s1im = ctx.to_fixed(ctx._im(s1), wp)
+            sre = (are * cnre - aim * cnim) >> wp
+            sim = (aim * cnre + are * cnim) >> wp
+            while are**2 + aim**2 > MIN:
+                bre, bim = (bre * x2re - bim * x2im) >> wp, \
+                           (bre * x2im + bim * x2re) >> wp
+                are, aim = (are * bre - aim * bim) >> wp,   \
+                           (are * bim + aim * bre) >> wp
+                t1 = (cnre*c1re - cnim*c1im - snre*s1re + snim*s1im) >> wp
+                t2 = (cnre*c1im + cnim*c1re - snre*s1im - snim*s1re) >> wp
+                t3 = (snre*c1re - snim*c1im + cnre*s1re - cnim*s1im) >> wp
+                t4 = (snre*c1im + snim*c1re + cnre*s1im + cnim*s1re) >> wp
+                cnre = t1
+                cnim = t2
+                snre = t3
+                snim = t4
+                sre += (are * cnre - aim * cnim) >> wp
+                sim += (aim * cnre + are * cnim) >> wp
+            sre = (1 << wp) + (sre << 1)
+            sim = (sim << 1)
+            sre = ctx.ldexp(sre, -wp)
+            sim = ctx.ldexp(sim, -wp)
+            s = ctx.mpc(sre, sim)
+            return s
+
+@defun
+def _djacobi_theta3(ctx, z, q, nd):
+    """nd=1,2,3 order of the derivative with respect to z"""
+    MIN = 2
+    extra1 = 10
+    extra2 = 20
+    if (not ctx._im(q)) and (not ctx._im(z)):
+        s = 0
+        wp = ctx.prec + extra1
+        x = ctx.to_fixed(ctx._re(q), wp)
+        a = b = x
+        x2 = (x*x) >> wp
+        c1, s1 = ctx.cos_sin(ctx._re(z)*2, prec=wp)
+        c1 = ctx.to_fixed(c1, wp)
+        s1 = ctx.to_fixed(s1, wp)
+        cn = c1
+        sn = s1
+        if (nd&1):
+            s += (a * sn) >> wp
+        else:
+            s += (a * cn) >> wp
+        n = 2
+        while abs(a) > MIN:
+            b = (b*x2) >> wp
+            a = (a*b) >> wp
+            cn, sn = (cn*c1 - sn*s1) >> wp, (sn*c1 + cn*s1) >> wp
+            if nd&1:
+                s += (a * sn * n**nd) >> wp
+            else:
+                s += (a * cn * n**nd) >> wp
+            n += 1
+        s = -(s << (nd+1))
+        s = ctx.ldexp(s, -wp)
+    # case z real, q complex
+    elif not ctx._im(z):
+        wp = ctx.prec + extra2
+        xre = ctx.to_fixed(ctx._re(q), wp)
+        xim = ctx.to_fixed(ctx._im(q), wp)
+        x2re = (xre*xre - xim*xim) >> wp
+        x2im = (xre*xim) >> (wp - 1)
+        are = bre = xre
+        aim = bim = xim
+        c1, s1 = ctx.cos_sin(ctx._re(z)*2, prec=wp)
+        c1 = ctx.to_fixed(c1, wp)
+        s1 = ctx.to_fixed(s1, wp)
+        cn = c1
+        sn = s1
+        if (nd&1):
+            sre = (are * sn) >> wp
+            sim = (aim * sn) >> wp
+        else:
+            sre = (are * cn) >> wp
+            sim = (aim * cn) >> wp
+        n = 2
+        while are**2 + aim**2 > MIN:
+            bre, bim = (bre * x2re - bim * x2im) >> wp, \
+                       (bre * x2im + bim * x2re) >> wp
+            are, aim = (are * bre - aim * bim) >> wp,   \
+                       (are * bim + aim * bre) >> wp
+            cn, sn = (cn*c1 - sn*s1) >> wp, (sn*c1 + cn*s1) >> wp
+            if nd&1:
+                sre += (are * sn * n**nd) >> wp
+                sim += (aim * sn * n**nd) >> wp
+            else:
+                sre += (are * cn * n**nd) >> wp
+                sim += (aim * cn * n**nd) >> wp
+            n += 1
+        sre = -(sre << (nd+1))
+        sim = -(sim << (nd+1))
+        sre = ctx.ldexp(sre, -wp)
+        sim = ctx.ldexp(sim, -wp)
+        s = ctx.mpc(sre, sim)
+    #case z complex, q real
+    elif not ctx._im(q):
+        wp = ctx.prec + extra2
+        x = ctx.to_fixed(ctx._re(q), wp)
+        a = b = x
+        x2 = (x*x) >> wp
+        prec0 = ctx.prec
+        ctx.prec = wp
+        c1, s1 = ctx.cos_sin(2*z)
+        ctx.prec = prec0
+        cnre = c1re = ctx.to_fixed(ctx._re(c1), wp)
+        cnim = c1im = ctx.to_fixed(ctx._im(c1), wp)
+        snre = s1re = ctx.to_fixed(ctx._re(s1), wp)
+        snim = s1im = ctx.to_fixed(ctx._im(s1), wp)
+        if (nd&1):
+            sre = (a * snre) >> wp
+            sim = (a * snim) >> wp
+        else:
+            sre = (a * cnre) >> wp
+            sim = (a * cnim) >> wp
+        n = 2
+        while abs(a) > MIN:
+            b = (b*x2) >> wp
+            a = (a*b) >> wp
+            t1 = (cnre*c1re - cnim*c1im - snre*s1re + snim*s1im) >> wp
+            t2 = (cnre*c1im + cnim*c1re - snre*s1im - snim*s1re) >> wp
+            t3 = (snre*c1re - snim*c1im + cnre*s1re - cnim*s1im) >> wp
+            t4 = (snre*c1im + snim*c1re + cnre*s1im + cnim*s1re) >> wp
+            cnre = t1
+            cnim = t2
+            snre = t3
+            snim = t4
+            if (nd&1):
+                sre += (a * snre * n**nd) >> wp
+                sim += (a * snim * n**nd) >> wp
+            else:
+                sre += (a * cnre * n**nd) >> wp
+                sim += (a * cnim * n**nd) >> wp
+            n += 1
+        sre = -(sre << (nd+1))
+        sim = -(sim << (nd+1))
+        sre = ctx.ldexp(sre, -wp)
+        sim = ctx.ldexp(sim, -wp)
+        s = ctx.mpc(sre, sim)
+    # case z and q complex
+    else:
+        wp = ctx.prec + extra2
+        xre = ctx.to_fixed(ctx._re(q), wp)
+        xim = ctx.to_fixed(ctx._im(q), wp)
+        x2re = (xre*xre - xim*xim) >> wp
+        x2im = (xre*xim) >> (wp - 1)
+        are = bre = xre
+        aim = bim = xim
+        prec0 = ctx.prec
+        ctx.prec = wp
+        # cos(2*z), sin(2*z) with z complex
+        c1, s1 = ctx.cos_sin(2*z)
+        ctx.prec = prec0
+        cnre = c1re = ctx.to_fixed(ctx._re(c1), wp)
+        cnim = c1im = ctx.to_fixed(ctx._im(c1), wp)
+        snre = s1re = ctx.to_fixed(ctx._re(s1), wp)
+        snim = s1im = ctx.to_fixed(ctx._im(s1), wp)
+        if (nd&1):
+            sre = (are * snre - aim * snim) >> wp
+            sim = (aim * snre + are * snim) >> wp
+        else:
+            sre = (are * cnre - aim * cnim) >> wp
+            sim = (aim * cnre + are * cnim) >> wp
+        n = 2
+        while are**2 + aim**2 > MIN:
+            bre, bim = (bre * x2re - bim * x2im) >> wp, \
+                       (bre * x2im + bim * x2re) >> wp
+            are, aim = (are * bre - aim * bim) >> wp,   \
+                       (are * bim + aim * bre) >> wp
+            t1 = (cnre*c1re - cnim*c1im - snre*s1re + snim*s1im) >> wp
+            t2 = (cnre*c1im + cnim*c1re - snre*s1im - snim*s1re) >> wp
+            t3 = (snre*c1re - snim*c1im + cnre*s1re - cnim*s1im) >> wp
+            t4 = (snre*c1im + snim*c1re + cnre*s1im + cnim*s1re) >> wp
+            cnre = t1
+            cnim = t2
+            snre = t3
+            snim = t4
+            if(nd&1):
+                sre += ((are * snre - aim * snim) * n**nd) >> wp
+                sim += ((aim * snre + are * snim) * n**nd) >> wp
+            else:
+                sre += ((are * cnre - aim * cnim) * n**nd) >> wp
+                sim += ((aim * cnre + are * cnim) * n**nd) >> wp
+            n += 1
+        sre = -(sre << (nd+1))
+        sim = -(sim << (nd+1))
+        sre = ctx.ldexp(sre, -wp)
+        sim = ctx.ldexp(sim, -wp)
+        s = ctx.mpc(sre, sim)
+    if (nd&1):
+        return (-1)**(nd//2) * s
+    else:
+        return (-1)**(1 + nd//2) * s
+
+@defun
+def _jacobi_theta2a(ctx, z, q):
+    """
+    case ctx._im(z) != 0
+    theta(2, z, q) =
+    q**1/4 * Sum(q**(n*n + n) * exp(j*(2*n + 1)*z), n=-inf, inf)
+    max term for minimum (2*n+1)*log(q).real - 2* ctx._im(z)
+    n0 = int(ctx._im(z)/log(q).real - 1/2)
+    theta(2, z, q) =
+    q**1/4 * Sum(q**(n*n + n) * exp(j*(2*n + 1)*z), n=n0, inf) +
+    q**1/4 * Sum(q**(n*n + n) * exp(j*(2*n + 1)*z), n, n0-1, -inf)
+    """
+    n = n0 = int(ctx._im(z)/ctx._re(ctx.log(q)) - 1/2)
+    e2 = ctx.expj(2*z)
+    e = e0 = ctx.expj((2*n+1)*z)
+    a = q**(n*n + n)
+    # leading term
+    term = a * e
+    s = term
+    eps1 = ctx.eps*abs(term)
+    while 1:
+        n += 1
+        e = e * e2
+        term = q**(n*n + n) * e
+        if abs(term) < eps1:
+            break
+        s += term
+    e = e0
+    e2 = ctx.expj(-2*z)
+    n = n0
+    while 1:
+        n -= 1
+        e = e * e2
+        term = q**(n*n + n) * e
+        if abs(term) < eps1:
+            break
+        s += term
+    s = s * ctx.nthroot(q, 4)
+    return s
+
+@defun
+def _jacobi_theta3a(ctx, z, q):
+    """
+    case ctx._im(z) != 0
+    theta3(z, q) = Sum(q**(n*n) * exp(j*2*n*z), n, -inf, inf)
+    max term for n*abs(log(q).real) + ctx._im(z) ~= 0
+    n0 = int(- ctx._im(z)/abs(log(q).real))
+    """
+    n = n0 = int(-ctx._im(z)/abs(ctx._re(ctx.log(q))))
+    e2 = ctx.expj(2*z)
+    e = e0 = ctx.expj(2*n*z)
+    s = term = q**(n*n) * e
+    eps1 = ctx.eps*abs(term)
+    while 1:
+        n += 1
+        e = e * e2
+        term = q**(n*n) * e
+        if abs(term) < eps1:
+            break
+        s += term
+    e = e0
+    e2 = ctx.expj(-2*z)
+    n = n0
+    while 1:
+        n -= 1
+        e = e * e2
+        term = q**(n*n) * e
+        if abs(term) < eps1:
+            break
+        s += term
+    return s
+
+@defun
+def _djacobi_theta2a(ctx, z, q, nd):
+    """
+    case ctx._im(z) != 0
+    dtheta(2, z, q, nd) =
+    j* q**1/4 * Sum(q**(n*n + n) * (2*n+1)*exp(j*(2*n + 1)*z), n=-inf, inf)
+    max term for (2*n0+1)*log(q).real - 2* ctx._im(z) ~= 0
+    n0 = int(ctx._im(z)/log(q).real - 1/2)
+    """
+    n = n0 = int(ctx._im(z)/ctx._re(ctx.log(q)) - 1/2)
+    e2 = ctx.expj(2*z)
+    e = e0 = ctx.expj((2*n + 1)*z)
+    a = q**(n*n + n)
+    # leading term
+    term = (2*n+1)**nd * a * e
+    s = term
+    eps1 = ctx.eps*abs(term)
+    while 1:
+        n += 1
+        e = e * e2
+        term = (2*n+1)**nd * q**(n*n + n) * e
+        if abs(term) < eps1:
+            break
+        s += term
+    e = e0
+    e2 = ctx.expj(-2*z)
+    n = n0
+    while 1:
+        n -= 1
+        e = e * e2
+        term = (2*n+1)**nd * q**(n*n + n) * e
+        if abs(term) < eps1:
+            break
+        s += term
+    return ctx.j**nd * s * ctx.nthroot(q, 4)
+
+@defun
+def _djacobi_theta3a(ctx, z, q, nd):
+    """
+    case ctx._im(z) != 0
+    djtheta3(z, q, nd) = (2*j)**nd *
+      Sum(q**(n*n) * n**nd * exp(j*2*n*z), n, -inf, inf)
+    max term for minimum n*abs(log(q).real) + ctx._im(z)
+    """
+    n = n0 = int(-ctx._im(z)/abs(ctx._re(ctx.log(q))))
+    e2 = ctx.expj(2*z)
+    e = e0 = ctx.expj(2*n*z)
+    a = q**(n*n) * e
+    s = term = n**nd * a
+    if n != 0:
+        eps1 = ctx.eps*abs(term)
+    else:
+        eps1 = ctx.eps*abs(a)
+    while 1:
+        n += 1
+        e = e * e2
+        a = q**(n*n) * e
+        term = n**nd * a
+        if n != 0:
+            aterm = abs(term)
+        else:
+            aterm = abs(a)
+        if aterm < eps1:
+            break
+        s += term
+    e = e0
+    e2 = ctx.expj(-2*z)
+    n = n0
+    while 1:
+        n -= 1
+        e = e * e2
+        a = q**(n*n) * e
+        term = n**nd * a
+        if n != 0:
+            aterm = abs(term)
+        else:
+            aterm = abs(a)
+        if aterm < eps1:
+            break
+        s += term
+    return (2*ctx.j)**nd * s
+
+@defun
+def jtheta(ctx, n, z, q, derivative=0):
+    if derivative:
+        return ctx._djtheta(n, z, q, derivative)
+
+    z = ctx.convert(z)
+    q = ctx.convert(q)
+
+    # Implementation note
+    # If ctx._im(z) is close to zero, _jacobi_theta2 and _jacobi_theta3
+    # are used,
+    # which compute the series starting from n=0 using fixed precision
+    # numbers;
+    # otherwise  _jacobi_theta2a and _jacobi_theta3a are used, which compute
+    # the series starting from n=n0, which is the largest term.
+
+    # TODO: write _jacobi_theta2a and _jacobi_theta3a using fixed-point
+
+    if abs(q) > ctx.THETA_Q_LIM:
+        raise ValueError('abs(q) > THETA_Q_LIM = %f' % ctx.THETA_Q_LIM)
+
+    extra = 10
+    if z:
+        M = ctx.mag(z)
+        if M > 5 or (n == 1 and M < -5):
+            extra += 2*abs(M)
+    cz = 0.5
+    extra2 = 50
+    prec0 = ctx.prec
+    try:
+        ctx.prec += extra
+        if n == 1:
+            if ctx._im(z):
+                if abs(ctx._im(z)) < cz * abs(ctx._re(ctx.log(q))):
+                    ctx.dps += extra2
+                    res = ctx._jacobi_theta2(z - ctx.pi/2, q)
+                else:
+                    ctx.dps += 10
+                    res = ctx._jacobi_theta2a(z - ctx.pi/2, q)
+            else:
+                res = ctx._jacobi_theta2(z - ctx.pi/2, q)
+        elif n == 2:
+            if ctx._im(z):
+                if abs(ctx._im(z)) < cz * abs(ctx._re(ctx.log(q))):
+                    ctx.dps += extra2
+                    res = ctx._jacobi_theta2(z, q)
+                else:
+                    ctx.dps += 10
+                    res = ctx._jacobi_theta2a(z, q)
+            else:
+                res = ctx._jacobi_theta2(z, q)
+        elif n == 3:
+            if ctx._im(z):
+                if abs(ctx._im(z)) < cz * abs(ctx._re(ctx.log(q))):
+                    ctx.dps += extra2
+                    res = ctx._jacobi_theta3(z, q)
+                else:
+                    ctx.dps += 10
+                    res = ctx._jacobi_theta3a(z, q)
+            else:
+                res = ctx._jacobi_theta3(z, q)
+        elif n == 4:
+            if ctx._im(z):
+                if abs(ctx._im(z)) < cz * abs(ctx._re(ctx.log(q))):
+                    ctx.dps += extra2
+                    res = ctx._jacobi_theta3(z, -q)
+                else:
+                    ctx.dps += 10
+                    res = ctx._jacobi_theta3a(z, -q)
+            else:
+                res = ctx._jacobi_theta3(z, -q)
+        else:
+            raise ValueError
+    finally:
+        ctx.prec = prec0
+    return res
+
+@defun
+def _djtheta(ctx, n, z, q, derivative=1):
+    z = ctx.convert(z)
+    q = ctx.convert(q)
+    nd = int(derivative)
+
+    if abs(q) > ctx.THETA_Q_LIM:
+        raise ValueError('abs(q) > THETA_Q_LIM = %f' % ctx.THETA_Q_LIM)
+    extra = 10 + ctx.prec * nd // 10
+    if z:
+        M = ctx.mag(z)
+        if M > 5 or (n != 1 and M < -5):
+            extra += 2*abs(M)
+    cz = 0.5
+    extra2 = 50
+    prec0 = ctx.prec
+    try:
+        ctx.prec += extra
+        if n == 1:
+            if ctx._im(z):
+                if abs(ctx._im(z)) < cz * abs(ctx._re(ctx.log(q))):
+                    ctx.dps += extra2
+                    res = ctx._djacobi_theta2(z - ctx.pi/2, q, nd)
+                else:
+                    ctx.dps += 10
+                    res = ctx._djacobi_theta2a(z - ctx.pi/2, q, nd)
+            else:
+                res = ctx._djacobi_theta2(z - ctx.pi/2, q, nd)
+        elif n == 2:
+            if ctx._im(z):
+                if abs(ctx._im(z)) < cz * abs(ctx._re(ctx.log(q))):
+                    ctx.dps += extra2
+                    res = ctx._djacobi_theta2(z, q, nd)
+                else:
+                    ctx.dps += 10
+                    res = ctx._djacobi_theta2a(z, q, nd)
+            else:
+                res = ctx._djacobi_theta2(z, q, nd)
+        elif n == 3:
+            if ctx._im(z):
+                if abs(ctx._im(z)) < cz * abs(ctx._re(ctx.log(q))):
+                    ctx.dps += extra2
+                    res = ctx._djacobi_theta3(z, q, nd)
+                else:
+                    ctx.dps += 10
+                    res = ctx._djacobi_theta3a(z, q, nd)
+            else:
+                res = ctx._djacobi_theta3(z, q, nd)
+        elif n == 4:
+            if ctx._im(z):
+                if abs(ctx._im(z)) < cz * abs(ctx._re(ctx.log(q))):
+                    ctx.dps += extra2
+                    res = ctx._djacobi_theta3(z, -q, nd)
+                else:
+                    ctx.dps += 10
+                    res = ctx._djacobi_theta3a(z, -q, nd)
+            else:
+                res = ctx._djacobi_theta3(z, -q, nd)
+        else:
+            raise ValueError
+    finally:
+        ctx.prec = prec0
+    return +res
diff --git a/lib/python3.10/site-packages/mpmath/functions/zeta.py b/lib/python3.10/site-packages/mpmath/functions/zeta.py
new file mode 100644
index 0000000000000000000000000000000000000000..d7ede50d95e5b6eff511619620c934529942cbdd
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/functions/zeta.py
@@ -0,0 +1,1154 @@
+from __future__ import print_function
+
+from ..libmp.backend import xrange
+from .functions import defun, defun_wrapped, defun_static
+
+@defun
+def stieltjes(ctx, n, a=1):
+    n = ctx.convert(n)
+    a = ctx.convert(a)
+    if n < 0:
+        return ctx.bad_domain("Stieltjes constants defined for n >= 0")
+    if hasattr(ctx, "stieltjes_cache"):
+        stieltjes_cache = ctx.stieltjes_cache
+    else:
+        stieltjes_cache = ctx.stieltjes_cache = {}
+    if a == 1:
+        if n == 0:
+            return +ctx.euler
+        if n in stieltjes_cache:
+            prec, s = stieltjes_cache[n]
+            if prec >= ctx.prec:
+                return +s
+    mag = 1
+    def f(x):
+        xa = x/a
+        v = (xa-ctx.j)*ctx.ln(a-ctx.j*x)**n/(1+xa**2)/(ctx.exp(2*ctx.pi*x)-1)
+        return ctx._re(v) / mag
+    orig = ctx.prec
+    try:
+        # Normalize integrand by approx. magnitude to
+        # speed up quadrature (which uses absolute error)
+        if n > 50:
+            ctx.prec = 20
+            mag = ctx.quad(f, [0,ctx.inf], maxdegree=3)
+        ctx.prec = orig + 10 + int(n**0.5)
+        s = ctx.quad(f, [0,ctx.inf], maxdegree=20)
+        v = ctx.ln(a)**n/(2*a) - ctx.ln(a)**(n+1)/(n+1) + 2*s/a*mag
+    finally:
+        ctx.prec = orig
+    if a == 1 and ctx.isint(n):
+        stieltjes_cache[n] = (ctx.prec, v)
+    return +v
+
+@defun_wrapped
+def siegeltheta(ctx, t, derivative=0):
+    d = int(derivative)
+    if  (t == ctx.inf or t == ctx.ninf):
+        if d < 2:
+            if t == ctx.ninf and d == 0:
+                return ctx.ninf
+            return ctx.inf
+        else:
+            return ctx.zero
+    if d == 0:
+        if ctx._im(t):
+            # XXX: cancellation occurs
+            a = ctx.loggamma(0.25+0.5j*t)
+            b = ctx.loggamma(0.25-0.5j*t)
+            return -ctx.ln(ctx.pi)/2*t - 0.5j*(a-b)
+        else:
+            if ctx.isinf(t):
+                return t
+            return ctx._im(ctx.loggamma(0.25+0.5j*t)) - ctx.ln(ctx.pi)/2*t
+    if d > 0:
+        a = (-0.5j)**(d-1)*ctx.polygamma(d-1, 0.25-0.5j*t)
+        b = (0.5j)**(d-1)*ctx.polygamma(d-1, 0.25+0.5j*t)
+        if ctx._im(t):
+            if d == 1:
+                return -0.5*ctx.log(ctx.pi)+0.25*(a+b)
+            else:
+                return 0.25*(a+b)
+        else:
+            if d == 1:
+                return ctx._re(-0.5*ctx.log(ctx.pi)+0.25*(a+b))
+            else:
+                return ctx._re(0.25*(a+b))
+
+@defun_wrapped
+def grampoint(ctx, n):
+    # asymptotic expansion, from
+    # http://mathworld.wolfram.com/GramPoint.html
+    g = 2*ctx.pi*ctx.exp(1+ctx.lambertw((8*n+1)/(8*ctx.e)))
+    return ctx.findroot(lambda t: ctx.siegeltheta(t)-ctx.pi*n, g)
+
+
+@defun_wrapped
+def siegelz(ctx, t, **kwargs):
+    d = int(kwargs.get("derivative", 0))
+    t = ctx.convert(t)
+    t1 = ctx._re(t)
+    t2 = ctx._im(t)
+    prec = ctx.prec
+    try:
+        if abs(t1) > 500*prec and t2**2 < t1:
+            v = ctx.rs_z(t, d)
+            if ctx._is_real_type(t):
+                return ctx._re(v)
+            return v
+    except NotImplementedError:
+        pass
+    ctx.prec += 21
+    e1 = ctx.expj(ctx.siegeltheta(t))
+    z = ctx.zeta(0.5+ctx.j*t)
+    if d == 0:
+        v = e1*z
+        ctx.prec=prec
+        if ctx._is_real_type(t):
+            return ctx._re(v)
+        return +v
+    z1 = ctx.zeta(0.5+ctx.j*t, derivative=1)
+    theta1 = ctx.siegeltheta(t, derivative=1)
+    if d == 1:
+        v =  ctx.j*e1*(z1+z*theta1)
+        ctx.prec=prec
+        if ctx._is_real_type(t):
+            return ctx._re(v)
+        return +v
+    z2 = ctx.zeta(0.5+ctx.j*t, derivative=2)
+    theta2 = ctx.siegeltheta(t, derivative=2)
+    comb1 = theta1**2-ctx.j*theta2
+    if d == 2:
+        def terms():
+            return [2*z1*theta1, z2, z*comb1]
+        v = ctx.sum_accurately(terms, 1)
+        v =  -e1*v
+        ctx.prec = prec
+        if ctx._is_real_type(t):
+            return ctx._re(v)
+        return +v
+    ctx.prec += 10
+    z3 = ctx.zeta(0.5+ctx.j*t, derivative=3)
+    theta3 = ctx.siegeltheta(t, derivative=3)
+    comb2 = theta1**3-3*ctx.j*theta1*theta2-theta3
+    if d == 3:
+        def terms():
+            return  [3*theta1*z2, 3*z1*comb1, z3+z*comb2]
+        v = ctx.sum_accurately(terms, 1)
+        v =  -ctx.j*e1*v
+        ctx.prec = prec
+        if ctx._is_real_type(t):
+            return ctx._re(v)
+        return +v
+    z4 = ctx.zeta(0.5+ctx.j*t, derivative=4)
+    theta4 = ctx.siegeltheta(t, derivative=4)
+    def terms():
+        return [theta1**4, -6*ctx.j*theta1**2*theta2, -3*theta2**2,
+            -4*theta1*theta3, ctx.j*theta4]
+    comb3 = ctx.sum_accurately(terms, 1)
+    if d == 4:
+        def terms():
+            return  [6*theta1**2*z2, -6*ctx.j*z2*theta2, 4*theta1*z3,
+                 4*z1*comb2, z4, z*comb3]
+        v = ctx.sum_accurately(terms, 1)
+        v =  e1*v
+        ctx.prec = prec
+        if ctx._is_real_type(t):
+            return ctx._re(v)
+        return +v
+    if d > 4:
+        h = lambda x: ctx.siegelz(x, derivative=4)
+        return ctx.diff(h, t, n=d-4)
+
+
+_zeta_zeros = [
+14.134725142,21.022039639,25.010857580,30.424876126,32.935061588,
+37.586178159,40.918719012,43.327073281,48.005150881,49.773832478,
+52.970321478,56.446247697,59.347044003,60.831778525,65.112544048,
+67.079810529,69.546401711,72.067157674,75.704690699,77.144840069,
+79.337375020,82.910380854,84.735492981,87.425274613,88.809111208,
+92.491899271,94.651344041,95.870634228,98.831194218,101.317851006,
+103.725538040,105.446623052,107.168611184,111.029535543,111.874659177,
+114.320220915,116.226680321,118.790782866,121.370125002,122.946829294,
+124.256818554,127.516683880,129.578704200,131.087688531,133.497737203,
+134.756509753,138.116042055,139.736208952,141.123707404,143.111845808,
+146.000982487,147.422765343,150.053520421,150.925257612,153.024693811,
+156.112909294,157.597591818,158.849988171,161.188964138,163.030709687,
+165.537069188,167.184439978,169.094515416,169.911976479,173.411536520,
+174.754191523,176.441434298,178.377407776,179.916484020,182.207078484,
+184.874467848,185.598783678,187.228922584,189.416158656,192.026656361,
+193.079726604,195.265396680,196.876481841,198.015309676,201.264751944,
+202.493594514,204.189671803,205.394697202,207.906258888,209.576509717,
+211.690862595,213.347919360,214.547044783,216.169538508,219.067596349,
+220.714918839,221.430705555,224.007000255,224.983324670,227.421444280,
+229.337413306,231.250188700,231.987235253,233.693404179,236.524229666,
+]
+
+def _load_zeta_zeros(url):
+    import urllib
+    d = urllib.urlopen(url)
+    L = [float(x) for x in d.readlines()]
+    # Sanity check
+    assert round(L[0]) == 14
+    _zeta_zeros[:] = L
+
+@defun
+def oldzetazero(ctx, n, url='http://www.dtc.umn.edu/~odlyzko/zeta_tables/zeros1'):
+    n = int(n)
+    if n < 0:
+        return ctx.zetazero(-n).conjugate()
+    if n == 0:
+        raise ValueError("n must be nonzero")
+    if n > len(_zeta_zeros) and n <= 100000:
+        _load_zeta_zeros(url)
+    if n > len(_zeta_zeros):
+        raise NotImplementedError("n too large for zetazeros")
+    return ctx.mpc(0.5, ctx.findroot(ctx.siegelz, _zeta_zeros[n-1]))
+
+@defun_wrapped
+def riemannr(ctx, x):
+    if x == 0:
+        return ctx.zero
+    # Check if a simple asymptotic estimate is accurate enough
+    if abs(x) > 1000:
+        a = ctx.li(x)
+        b = 0.5*ctx.li(ctx.sqrt(x))
+        if abs(b) < abs(a)*ctx.eps:
+            return a
+    if abs(x) < 0.01:
+        # XXX
+        ctx.prec += int(-ctx.log(abs(x),2))
+    # Sum Gram's series
+    s = t = ctx.one
+    u = ctx.ln(x)
+    k = 1
+    while abs(t) > abs(s)*ctx.eps:
+        t = t * u / k
+        s += t / (k * ctx._zeta_int(k+1))
+        k += 1
+    return s
+
+@defun_static
+def primepi(ctx, x):
+    x = int(x)
+    if x < 2:
+        return 0
+    return len(ctx.list_primes(x))
+
+# TODO: fix the interface wrt contexts
+@defun_wrapped
+def primepi2(ctx, x):
+    x = int(x)
+    if x < 2:
+        return ctx._iv.zero
+    if x < 2657:
+        return ctx._iv.mpf(ctx.primepi(x))
+    mid = ctx.li(x)
+    # Schoenfeld's estimate for x >= 2657, assuming RH
+    err = ctx.sqrt(x,rounding='u')*ctx.ln(x,rounding='u')/8/ctx.pi(rounding='d')
+    a = ctx.floor((ctx._iv.mpf(mid)-err).a, rounding='d')
+    b = ctx.ceil((ctx._iv.mpf(mid)+err).b, rounding='u')
+    return ctx._iv.mpf([a,b])
+
+@defun_wrapped
+def primezeta(ctx, s):
+    if ctx.isnan(s):
+        return s
+    if ctx.re(s) <= 0:
+        raise ValueError("prime zeta function defined only for re(s) > 0")
+    if s == 1:
+        return ctx.inf
+    if s == 0.5:
+        return ctx.mpc(ctx.ninf, ctx.pi)
+    r = ctx.re(s)
+    if r > ctx.prec:
+        return 0.5**s
+    else:
+        wp = ctx.prec + int(r)
+        def terms():
+            orig = ctx.prec
+            # zeta ~ 1+eps; need to set precision
+            # to get logarithm accurately
+            k = 0
+            while 1:
+                k += 1
+                u = ctx.moebius(k)
+                if not u:
+                    continue
+                ctx.prec = wp
+                t = u*ctx.ln(ctx.zeta(k*s))/k
+                if not t:
+                    return
+                #print ctx.prec, ctx.nstr(t)
+                ctx.prec = orig
+                yield t
+    return ctx.sum_accurately(terms)
+
+# TODO: for bernpoly and eulerpoly, ensure that all exact zeros are covered
+
+@defun_wrapped
+def bernpoly(ctx, n, z):
+    # Slow implementation:
+    #return sum(ctx.binomial(n,k)*ctx.bernoulli(k)*z**(n-k) for k in xrange(0,n+1))
+    n = int(n)
+    if n < 0:
+        raise ValueError("Bernoulli polynomials only defined for n >= 0")
+    if z == 0 or (z == 1 and n > 1):
+        return ctx.bernoulli(n)
+    if z == 0.5:
+        return (ctx.ldexp(1,1-n)-1)*ctx.bernoulli(n)
+    if n <= 3:
+        if n == 0: return z ** 0
+        if n == 1: return z - 0.5
+        if n == 2: return (6*z*(z-1)+1)/6
+        if n == 3: return z*(z*(z-1.5)+0.5)
+    if ctx.isinf(z):
+        return z ** n
+    if ctx.isnan(z):
+        return z
+    if abs(z) > 2:
+        def terms():
+            t = ctx.one
+            yield t
+            r = ctx.one/z
+            k = 1
+            while k <= n:
+                t = t*(n+1-k)/k*r
+                if not (k > 2 and k & 1):
+                    yield t*ctx.bernoulli(k)
+                k += 1
+        return ctx.sum_accurately(terms) * z**n
+    else:
+        def terms():
+            yield ctx.bernoulli(n)
+            t = ctx.one
+            k = 1
+            while k <= n:
+                t = t*(n+1-k)/k * z
+                m = n-k
+                if not (m > 2 and m & 1):
+                    yield t*ctx.bernoulli(m)
+                k += 1
+        return ctx.sum_accurately(terms)
+
+@defun_wrapped
+def eulerpoly(ctx, n, z):
+    n = int(n)
+    if n < 0:
+        raise ValueError("Euler polynomials only defined for n >= 0")
+    if n <= 2:
+        if n == 0: return z ** 0
+        if n == 1: return z - 0.5
+        if n == 2: return z*(z-1)
+    if ctx.isinf(z):
+        return z**n
+    if ctx.isnan(z):
+        return z
+    m = n+1
+    if z == 0:
+        return -2*(ctx.ldexp(1,m)-1)*ctx.bernoulli(m)/m * z**0
+    if z == 1:
+        return 2*(ctx.ldexp(1,m)-1)*ctx.bernoulli(m)/m * z**0
+    if z == 0.5:
+        if n % 2:
+            return ctx.zero
+        # Use exact code for Euler numbers
+        if n < 100 or n*ctx.mag(0.46839865*n) < ctx.prec*0.25:
+            return ctx.ldexp(ctx._eulernum(n), -n)
+    # http://functions.wolfram.com/Polynomials/EulerE2/06/01/02/01/0002/
+    def terms():
+        t = ctx.one
+        k = 0
+        w = ctx.ldexp(1,n+2)
+        while 1:
+            v = n-k+1
+            if not (v > 2 and v & 1):
+                yield (2-w)*ctx.bernoulli(v)*t
+            k += 1
+            if k > n:
+                break
+            t = t*z*(n-k+2)/k
+            w *= 0.5
+    return ctx.sum_accurately(terms) / m
+
+@defun
+def eulernum(ctx, n, exact=False):
+    n = int(n)
+    if exact:
+        return int(ctx._eulernum(n))
+    if n < 100:
+        return ctx.mpf(ctx._eulernum(n))
+    if n % 2:
+        return ctx.zero
+    return ctx.ldexp(ctx.eulerpoly(n,0.5), n)
+
+# TODO: this should be implemented low-level
+def polylog_series(ctx, s, z):
+    tol = +ctx.eps
+    l = ctx.zero
+    k = 1
+    zk = z
+    while 1:
+        term = zk / k**s
+        l += term
+        if abs(term) < tol:
+            break
+        zk *= z
+        k += 1
+    return l
+
+def polylog_continuation(ctx, n, z):
+    if n < 0:
+        return z*0
+    twopij = 2j * ctx.pi
+    a = -twopij**n/ctx.fac(n) * ctx.bernpoly(n, ctx.ln(z)/twopij)
+    if ctx._is_real_type(z) and z < 0:
+        a = ctx._re(a)
+    if ctx._im(z) < 0 or (ctx._im(z) == 0 and ctx._re(z) >= 1):
+        a -= twopij*ctx.ln(z)**(n-1)/ctx.fac(n-1)
+    return a
+
+def polylog_unitcircle(ctx, n, z):
+    tol = +ctx.eps
+    if n > 1:
+        l = ctx.zero
+        logz = ctx.ln(z)
+        logmz = ctx.one
+        m = 0
+        while 1:
+            if (n-m) != 1:
+                term = ctx.zeta(n-m) * logmz / ctx.fac(m)
+                if term and abs(term) < tol:
+                    break
+                l += term
+            logmz *= logz
+            m += 1
+        l += ctx.ln(z)**(n-1)/ctx.fac(n-1)*(ctx.harmonic(n-1)-ctx.ln(-ctx.ln(z)))
+    elif n < 1:  # else
+        l = ctx.fac(-n)*(-ctx.ln(z))**(n-1)
+        logz = ctx.ln(z)
+        logkz = ctx.one
+        k = 0
+        while 1:
+            b = ctx.bernoulli(k-n+1)
+            if b:
+                term = b*logkz/(ctx.fac(k)*(k-n+1))
+                if abs(term) < tol:
+                    break
+                l -= term
+            logkz *= logz
+            k += 1
+    else:
+        raise ValueError
+    if ctx._is_real_type(z) and z < 0:
+        l = ctx._re(l)
+    return l
+
+def polylog_general(ctx, s, z):
+    v = ctx.zero
+    u = ctx.ln(z)
+    if not abs(u) < 5: # theoretically |u| < 2*pi
+        j = ctx.j
+        v = 1-s
+        y = ctx.ln(-z)/(2*ctx.pi*j)
+        return ctx.gamma(v)*(j**v*ctx.zeta(v,0.5+y) + j**-v*ctx.zeta(v,0.5-y))/(2*ctx.pi)**v
+    t = 1
+    k = 0
+    while 1:
+        term = ctx.zeta(s-k) * t
+        if abs(term) < ctx.eps:
+            break
+        v += term
+        k += 1
+        t *= u
+        t /= k
+    return ctx.gamma(1-s)*(-u)**(s-1) + v
+
+@defun_wrapped
+def polylog(ctx, s, z):
+    s = ctx.convert(s)
+    z = ctx.convert(z)
+    if z == 1:
+        return ctx.zeta(s)
+    if z == -1:
+        return -ctx.altzeta(s)
+    if s == 0:
+        return z/(1-z)
+    if s == 1:
+        return -ctx.ln(1-z)
+    if s == -1:
+        return z/(1-z)**2
+    if abs(z) <= 0.75 or (not ctx.isint(s) and abs(z) < 0.9):
+        return polylog_series(ctx, s, z)
+    if abs(z) >= 1.4 and ctx.isint(s):
+        return (-1)**(s+1)*polylog_series(ctx, s, 1/z) + polylog_continuation(ctx, int(ctx.re(s)), z)
+    if ctx.isint(s):
+        return polylog_unitcircle(ctx, int(ctx.re(s)), z)
+    return polylog_general(ctx, s, z)
+
+@defun_wrapped
+def clsin(ctx, s, z, pi=False):
+    if ctx.isint(s) and s < 0 and int(s) % 2 == 1:
+        return z*0
+    if pi:
+        a = ctx.expjpi(z)
+    else:
+        a = ctx.expj(z)
+    if ctx._is_real_type(z) and ctx._is_real_type(s):
+        return ctx.im(ctx.polylog(s,a))
+    b = 1/a
+    return (-0.5j)*(ctx.polylog(s,a) - ctx.polylog(s,b))
+
+@defun_wrapped
+def clcos(ctx, s, z, pi=False):
+    if ctx.isint(s) and s < 0 and int(s) % 2 == 0:
+        return z*0
+    if pi:
+        a = ctx.expjpi(z)
+    else:
+        a = ctx.expj(z)
+    if ctx._is_real_type(z) and ctx._is_real_type(s):
+        return ctx.re(ctx.polylog(s,a))
+    b = 1/a
+    return 0.5*(ctx.polylog(s,a) + ctx.polylog(s,b))
+
+@defun
+def altzeta(ctx, s, **kwargs):
+    try:
+        return ctx._altzeta(s, **kwargs)
+    except NotImplementedError:
+        return ctx._altzeta_generic(s)
+
+@defun_wrapped
+def _altzeta_generic(ctx, s):
+    if s == 1:
+        return ctx.ln2 + 0*s
+    return -ctx.powm1(2, 1-s) * ctx.zeta(s)
+
+@defun
+def zeta(ctx, s, a=1, derivative=0, method=None, **kwargs):
+    d = int(derivative)
+    if a == 1 and not (d or method):
+        try:
+            return ctx._zeta(s, **kwargs)
+        except NotImplementedError:
+            pass
+    s = ctx.convert(s)
+    prec = ctx.prec
+    method = kwargs.get('method')
+    verbose = kwargs.get('verbose')
+    if (not s) and (not derivative):
+        return ctx.mpf(0.5) - ctx._convert_param(a)[0]
+    if a == 1 and method != 'euler-maclaurin':
+        im = abs(ctx._im(s))
+        re = abs(ctx._re(s))
+        #if (im < prec or method == 'borwein') and not derivative:
+        #    try:
+        #        if verbose:
+        #            print "zeta: Attempting to use the Borwein algorithm"
+        #        return ctx._zeta(s, **kwargs)
+        #    except NotImplementedError:
+        #        if verbose:
+        #            print "zeta: Could not use the Borwein algorithm"
+        #        pass
+        if abs(im) > 500*prec and 10*re < prec and derivative <= 4 or \
+            method == 'riemann-siegel':
+            try:   #  py2.4 compatible try block
+                try:
+                    if verbose:
+                        print("zeta: Attempting to use the Riemann-Siegel algorithm")
+                    return ctx.rs_zeta(s, derivative, **kwargs)
+                except NotImplementedError:
+                    if verbose:
+                        print("zeta: Could not use the Riemann-Siegel algorithm")
+                    pass
+            finally:
+                ctx.prec = prec
+    if s == 1:
+        return ctx.inf
+    abss = abs(s)
+    if abss == ctx.inf:
+        if ctx.re(s) == ctx.inf:
+            if d == 0:
+                return ctx.one
+            return ctx.zero
+        return s*0
+    elif ctx.isnan(abss):
+        return 1/s
+    if ctx.re(s) > 2*ctx.prec and a == 1 and not derivative:
+        return ctx.one + ctx.power(2, -s)
+    return +ctx._hurwitz(s, a, d, **kwargs)
+
+@defun
+def _hurwitz(ctx, s, a=1, d=0, **kwargs):
+    prec = ctx.prec
+    verbose = kwargs.get('verbose')
+    try:
+        extraprec = 10
+        ctx.prec += extraprec
+        # We strongly want to special-case rational a
+        a, atype = ctx._convert_param(a)
+        if ctx.re(s) < 0:
+            if verbose:
+                print("zeta: Attempting reflection formula")
+            try:
+                return _hurwitz_reflection(ctx, s, a, d, atype)
+            except NotImplementedError:
+                pass
+            if verbose:
+                print("zeta: Reflection formula failed")
+        if verbose:
+            print("zeta: Using the Euler-Maclaurin algorithm")
+        while 1:
+            ctx.prec = prec + extraprec
+            T1, T2 = _hurwitz_em(ctx, s, a, d, prec+10, verbose)
+            cancellation = ctx.mag(T1) - ctx.mag(T1+T2)
+            if verbose:
+                print("Term 1:", T1)
+                print("Term 2:", T2)
+                print("Cancellation:", cancellation, "bits")
+            if cancellation < extraprec:
+                return T1 + T2
+            else:
+                extraprec = max(2*extraprec, min(cancellation + 5, 100*prec))
+                if extraprec > kwargs.get('maxprec', 100*prec):
+                    raise ctx.NoConvergence("zeta: too much cancellation")
+    finally:
+        ctx.prec = prec
+
+def _hurwitz_reflection(ctx, s, a, d, atype):
+    # TODO: implement for derivatives
+    if d != 0:
+        raise NotImplementedError
+    res = ctx.re(s)
+    negs = -s
+    # Integer reflection formula
+    if ctx.isnpint(s):
+        n = int(res)
+        if n <= 0:
+            return ctx.bernpoly(1-n, a) / (n-1)
+    if not (atype == 'Q' or atype == 'Z'):
+        raise NotImplementedError
+    t = 1-s
+    # We now require a to be standardized
+    v = 0
+    shift = 0
+    b = a
+    while ctx.re(b) > 1:
+        b -= 1
+        v -= b**negs
+        shift -= 1
+    while ctx.re(b) <= 0:
+        v += b**negs
+        b += 1
+        shift += 1
+    # Rational reflection formula
+    try:
+        p, q = a._mpq_
+    except:
+        assert a == int(a)
+        p = int(a)
+        q = 1
+    p += shift*q
+    assert 1 <= p <= q
+    g = ctx.fsum(ctx.cospi(t/2-2*k*b)*ctx._hurwitz(t,(k,q)) \
+        for k in range(1,q+1))
+    g *= 2*ctx.gamma(t)/(2*ctx.pi*q)**t
+    v += g
+    return v
+
+def _hurwitz_em(ctx, s, a, d, prec, verbose):
+    # May not be converted at this point
+    a = ctx.convert(a)
+    tol = -prec
+    # Estimate number of terms for Euler-Maclaurin summation; could be improved
+    M1 = 0
+    M2 = prec // 3
+    N = M2
+    lsum = 0
+    # This speeds up the recurrence for derivatives
+    if ctx.isint(s):
+        s = int(ctx._re(s))
+    s1 = s-1
+    while 1:
+        # Truncated L-series
+        l = ctx._zetasum(s, M1+a, M2-M1-1, [d])[0][0]
+        #if d:
+        #    l = ctx.fsum((-ctx.ln(n+a))**d * (n+a)**negs for n in range(M1,M2))
+        #else:
+        #    l = ctx.fsum((n+a)**negs for n in range(M1,M2))
+        lsum += l
+        M2a = M2+a
+        logM2a = ctx.ln(M2a)
+        logM2ad = logM2a**d
+        logs = [logM2ad]
+        logr = 1/logM2a
+        rM2a = 1/M2a
+        M2as = M2a**(-s)
+        if d:
+            tailsum = ctx.gammainc(d+1, s1*logM2a) / s1**(d+1)
+        else:
+            tailsum = 1/((s1)*(M2a)**s1)
+        tailsum += 0.5 * logM2ad * M2as
+        U = [1]
+        r = M2as
+        fact = 2
+        for j in range(1, N+1):
+            # TODO: the following could perhaps be tidied a bit
+            j2 = 2*j
+            if j == 1:
+                upds = [1]
+            else:
+                upds = [j2-2, j2-1]
+            for m in upds:
+                D = min(m,d+1)
+                if m <= d:
+                    logs.append(logs[-1] * logr)
+                Un = [0]*(D+1)
+                for i in xrange(D): Un[i] = (1-m-s)*U[i]
+                for i in xrange(1,D+1): Un[i] += (d-(i-1))*U[i-1]
+                U = Un
+                r *= rM2a
+            t = ctx.fdot(U, logs) * r * ctx.bernoulli(j2)/(-fact)
+            tailsum += t
+            if ctx.mag(t) < tol:
+                return lsum, (-1)**d * tailsum
+            fact *= (j2+1)*(j2+2)
+        if verbose:
+            print("Sum range:", M1, M2, "term magnitude", ctx.mag(t), "tolerance", tol)
+        M1, M2 = M2, M2*2
+        if ctx.re(s) < 0:
+            N += N//2
+
+
+
+@defun
+def _zetasum(ctx, s, a, n, derivatives=[0], reflect=False):
+    """
+    Returns [xd0,xd1,...,xdr], [yd0,yd1,...ydr] where
+
+    xdk = D^k     ( 1/a^s     +  1/(a+1)^s      +  ...  +  1/(a+n)^s     )
+    ydk = D^k conj( 1/a^(1-s) +  1/(a+1)^(1-s)  +  ...  +  1/(a+n)^(1-s) )
+
+    D^k = kth derivative with respect to s, k ranges over the given list of
+    derivatives (which should consist of either a single element
+    or a range 0,1,...r). If reflect=False, the ydks are not computed.
+    """
+    #print "zetasum", s, a, n
+    # don't use the fixed-point code if there are large exponentials
+    if abs(ctx.re(s)) < 0.5 * ctx.prec:
+        try:
+            return ctx._zetasum_fast(s, a, n, derivatives, reflect)
+        except NotImplementedError:
+            pass
+    negs = ctx.fneg(s, exact=True)
+    have_derivatives = derivatives != [0]
+    have_one_derivative = len(derivatives) == 1
+    if not reflect:
+        if not have_derivatives:
+            return [ctx.fsum((a+k)**negs for k in xrange(n+1))], []
+        if have_one_derivative:
+            d = derivatives[0]
+            x = ctx.fsum(ctx.ln(a+k)**d * (a+k)**negs for k in xrange(n+1))
+            return [(-1)**d * x], []
+    maxd = max(derivatives)
+    if not have_one_derivative:
+        derivatives = range(maxd+1)
+    xs = [ctx.zero for d in derivatives]
+    if reflect:
+        ys = [ctx.zero for d in derivatives]
+    else:
+        ys = []
+    for k in xrange(n+1):
+        w = a + k
+        xterm = w ** negs
+        if reflect:
+            yterm = ctx.conj(ctx.one / (w * xterm))
+        if have_derivatives:
+            logw = -ctx.ln(w)
+            if have_one_derivative:
+                logw = logw ** maxd
+                xs[0] += xterm * logw
+                if reflect:
+                    ys[0] += yterm * logw
+            else:
+                t = ctx.one
+                for d in derivatives:
+                    xs[d] += xterm * t
+                    if reflect:
+                        ys[d] += yterm * t
+                    t *= logw
+        else:
+            xs[0] += xterm
+            if reflect:
+                ys[0] += yterm
+    return xs, ys
+
+@defun
+def dirichlet(ctx, s, chi=[1], derivative=0):
+    s = ctx.convert(s)
+    q = len(chi)
+    d = int(derivative)
+    if d > 2:
+        raise NotImplementedError("arbitrary order derivatives")
+    prec = ctx.prec
+    try:
+        ctx.prec += 10
+        if s == 1:
+            have_pole = True
+            for x in chi:
+                if x and x != 1:
+                    have_pole = False
+                    h = +ctx.eps
+                    ctx.prec *= 2*(d+1)
+                    s += h
+            if have_pole:
+                return +ctx.inf
+        z = ctx.zero
+        for p in range(1,q+1):
+            if chi[p%q]:
+                if d == 1:
+                    z += chi[p%q] * (ctx.zeta(s, (p,q), 1) - \
+                        ctx.zeta(s, (p,q))*ctx.log(q))
+                else:
+                    z += chi[p%q] * ctx.zeta(s, (p,q))
+        z /= q**s
+    finally:
+        ctx.prec = prec
+    return +z
+
+
+def secondzeta_main_term(ctx, s, a, **kwargs):
+    tol = ctx.eps
+    f = lambda n: ctx.gammainc(0.5*s, a*gamm**2, regularized=True)*gamm**(-s)
+    totsum = term = ctx.zero
+    mg = ctx.inf
+    n = 0
+    while mg > tol:
+        totsum += term
+        n += 1
+        gamm = ctx.im(ctx.zetazero_memoized(n))
+        term = f(n)
+        mg = abs(term)
+    err = 0
+    if kwargs.get("error"):
+        sg = ctx.re(s)
+        err = 0.5*ctx.pi**(-1)*max(1,sg)*a**(sg-0.5)*ctx.log(gamm/(2*ctx.pi))*\
+             ctx.gammainc(-0.5, a*gamm**2)/abs(ctx.gamma(s/2))
+        err = abs(err)
+    return +totsum, err, n
+
+def secondzeta_prime_term(ctx, s, a, **kwargs):
+    tol = ctx.eps
+    f = lambda n: ctx.gammainc(0.5*(1-s),0.25*ctx.log(n)**2 * a**(-1))*\
+        ((0.5*ctx.log(n))**(s-1))*ctx.mangoldt(n)/ctx.sqrt(n)/\
+        (2*ctx.gamma(0.5*s)*ctx.sqrt(ctx.pi))
+    totsum = term = ctx.zero
+    mg = ctx.inf
+    n = 1
+    while mg > tol or n < 9:
+        totsum += term
+        n += 1
+        term = f(n)
+        if term == 0:
+            mg = ctx.inf
+        else:
+            mg = abs(term)
+    if kwargs.get("error"):
+        err = mg
+    return +totsum, err, n
+
+def secondzeta_exp_term(ctx, s, a):
+    if ctx.isint(s) and ctx.re(s) <= 0:
+        m = int(round(ctx.re(s)))
+        if not m & 1:
+            return ctx.mpf('-0.25')**(-m//2)
+    tol = ctx.eps
+    f = lambda n: (0.25*a)**n/((n+0.5*s)*ctx.fac(n))
+    totsum = ctx.zero
+    term = f(0)
+    mg = ctx.inf
+    n = 0
+    while mg > tol:
+        totsum += term
+        n += 1
+        term = f(n)
+        mg = abs(term)
+    v = a**(0.5*s)*totsum/ctx.gamma(0.5*s)
+    return v
+
+def secondzeta_singular_term(ctx, s, a, **kwargs):
+    factor = a**(0.5*(s-1))/(4*ctx.sqrt(ctx.pi)*ctx.gamma(0.5*s))
+    extraprec = ctx.mag(factor)
+    ctx.prec += extraprec
+    factor = a**(0.5*(s-1))/(4*ctx.sqrt(ctx.pi)*ctx.gamma(0.5*s))
+    tol = ctx.eps
+    f = lambda n: ctx.bernpoly(n,0.75)*(4*ctx.sqrt(a))**n*\
+       ctx.gamma(0.5*n)/((s+n-1)*ctx.fac(n))
+    totsum = ctx.zero
+    mg1 = ctx.inf
+    n = 1
+    term = f(n)
+    mg2 = abs(term)
+    while mg2 > tol and mg2 <= mg1:
+        totsum += term
+        n += 1
+        term = f(n)
+        totsum += term
+        n +=1
+        term = f(n)
+        mg1 = mg2
+        mg2 = abs(term)
+    totsum += term
+    pole = -2*(s-1)**(-2)+(ctx.euler+ctx.log(16*ctx.pi**2*a))*(s-1)**(-1)
+    st = factor*(pole+totsum)
+    err = 0
+    if kwargs.get("error"):
+        if not ((mg2 > tol) and (mg2 <= mg1)):
+            if mg2 <= tol:
+                err = ctx.mpf(10)**int(ctx.log(abs(factor*tol),10))
+            if mg2 > mg1:
+                err = ctx.mpf(10)**int(ctx.log(abs(factor*mg1),10))
+        err = max(err, ctx.eps*1.)
+    ctx.prec -= extraprec
+    return +st, err
+
+@defun
+def secondzeta(ctx, s, a = 0.015, **kwargs):
+    r"""
+    Evaluates the secondary zeta function `Z(s)`, defined for
+    `\mathrm{Re}(s)>1` by
+
+    .. math ::
+
+        Z(s) = \sum_{n=1}^{\infty} \frac{1}{\tau_n^s}
+
+    where `\frac12+i\tau_n` runs through the zeros of `\zeta(s)` with
+    imaginary part positive.
+
+    `Z(s)` extends to a meromorphic function on `\mathbb{C}`  with a
+    double pole at `s=1` and  simple poles at the points `-2n` for
+    `n=0`,  1, 2, ...
+
+    **Examples**
+
+        >>> from mpmath import *
+        >>> mp.pretty = True; mp.dps = 15
+        >>> secondzeta(2)
+        0.023104993115419
+        >>> xi = lambda s: 0.5*s*(s-1)*pi**(-0.5*s)*gamma(0.5*s)*zeta(s)
+        >>> Xi = lambda t: xi(0.5+t*j)
+        >>> chop(-0.5*diff(Xi,0,n=2)/Xi(0))
+        0.023104993115419
+
+    We may ask for an approximate error value::
+
+        >>> secondzeta(0.5+100j, error=True)
+        ((-0.216272011276718 - 0.844952708937228j), 2.22044604925031e-16)
+
+    The function has poles at the negative odd integers,
+    and dyadic rational values at the negative even integers::
+
+        >>> mp.dps = 30
+        >>> secondzeta(-8)
+        -0.67236328125
+        >>> secondzeta(-7)
+        +inf
+
+    **Implementation notes**
+
+    The function is computed as sum of four terms `Z(s)=A(s)-P(s)+E(s)-S(s)`
+    respectively main, prime, exponential and singular terms.
+    The main term `A(s)` is computed from the zeros of zeta.
+    The prime term depends on the von Mangoldt function.
+    The singular term is responsible for the poles of the function.
+
+    The four terms depends on a small parameter `a`. We may change the
+    value of `a`. Theoretically this has no effect on the sum of the four
+    terms, but in practice may be important.
+
+    A smaller value of the parameter `a` makes `A(s)` depend on
+    a smaller number of zeros of zeta, but `P(s)`  uses more values of
+    von Mangoldt function.
+
+    We may also add a verbose option to obtain data about the
+    values of the four terms.
+
+        >>> mp.dps = 10
+        >>> secondzeta(0.5 + 40j, error=True, verbose=True)
+        main term = (-30190318549.138656312556 - 13964804384.624622876523j)
+            computed using 19 zeros of zeta
+        prime term = (132717176.89212754625045 + 188980555.17563978290601j)
+            computed using 9 values of the von Mangoldt function
+        exponential term = (542447428666.07179812536 + 362434922978.80192435203j)
+        singular term = (512124392939.98154322355 + 348281138038.65531023921j)
+        ((0.059471043 + 0.3463514534j), 1.455191523e-11)
+
+        >>> secondzeta(0.5 + 40j, a=0.04, error=True, verbose=True)
+        main term = (-151962888.19606243907725 - 217930683.90210294051982j)
+            computed using 9 zeros of zeta
+        prime term = (2476659342.3038722372461 + 28711581821.921627163136j)
+            computed using 37 values of the von Mangoldt function
+        exponential term = (178506047114.7838188264 + 819674143244.45677330576j)
+        singular term = (175877424884.22441310708 + 790744630738.28669174871j)
+        ((0.059471043 + 0.3463514534j), 1.455191523e-11)
+
+    Notice the great cancellation between the four terms. Changing `a`, the
+    four terms are very different numbers but the cancellation gives
+    the good value of Z(s).
+
+    **References**
+
+    A. Voros, Zeta functions for the Riemann zeros, Ann. Institute Fourier,
+    53, (2003) 665--699.
+
+    A. Voros, Zeta functions over Zeros of Zeta Functions, Lecture Notes
+    of the Unione Matematica Italiana, Springer, 2009.
+    """
+    s = ctx.convert(s)
+    a = ctx.convert(a)
+    tol = ctx.eps
+    if ctx.isint(s) and ctx.re(s) <= 1:
+        if abs(s-1) < tol*1000:
+            return ctx.inf
+        m = int(round(ctx.re(s)))
+        if m & 1:
+            return ctx.inf
+        else:
+            return ((-1)**(-m//2)*\
+                   ctx.fraction(8-ctx.eulernum(-m,exact=True),2**(-m+3)))
+    prec = ctx.prec
+    try:
+        t3 = secondzeta_exp_term(ctx, s, a)
+        extraprec = max(ctx.mag(t3),0)
+        ctx.prec += extraprec + 3
+        t1, r1, gt = secondzeta_main_term(ctx,s,a,error='True', verbose='True')
+        t2, r2, pt = secondzeta_prime_term(ctx,s,a,error='True', verbose='True')
+        t4, r4 = secondzeta_singular_term(ctx,s,a,error='True')
+        t3 = secondzeta_exp_term(ctx, s, a)
+        err = r1+r2+r4
+        t = t1-t2+t3-t4
+        if kwargs.get("verbose"):
+            print('main term =', t1)
+            print('    computed using', gt, 'zeros of zeta')
+            print('prime term =', t2)
+            print('    computed using', pt, 'values of the von Mangoldt function')
+            print('exponential term =', t3)
+            print('singular term =', t4)
+    finally:
+        ctx.prec = prec
+    if kwargs.get("error"):
+        w = max(ctx.mag(abs(t)),0)
+        err = max(err*2**w, ctx.eps*1.*2**w)
+        return +t, err
+    return +t
+
+
+@defun_wrapped
+def lerchphi(ctx, z, s, a):
+    r"""
+    Gives the Lerch transcendent, defined for `|z| < 1` and
+    `\Re{a} > 0` by
+
+    .. math ::
+
+        \Phi(z,s,a) = \sum_{k=0}^{\infty} \frac{z^k}{(a+k)^s}
+
+    and generally by the recurrence `\Phi(z,s,a) = z \Phi(z,s,a+1) + a^{-s}`
+    along with the integral representation valid for `\Re{a} > 0`
+
+    .. math ::
+
+        \Phi(z,s,a) = \frac{1}{2 a^s} +
+                \int_0^{\infty} \frac{z^t}{(a+t)^s} dt -
+                2 \int_0^{\infty} \frac{\sin(t \log z - s
+                    \operatorname{arctan}(t/a)}{(a^2 + t^2)^{s/2}
+                    (e^{2 \pi t}-1)} dt.
+
+    The Lerch transcendent generalizes the Hurwitz zeta function :func:`zeta`
+    (`z = 1`) and the polylogarithm :func:`polylog` (`a = 1`).
+
+    **Examples**
+
+    Several evaluations in terms of simpler functions::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> lerchphi(-1,2,0.5); 4*catalan
+        3.663862376708876060218414
+        3.663862376708876060218414
+        >>> diff(lerchphi, (-1,-2,1), (0,1,0)); 7*zeta(3)/(4*pi**2)
+        0.2131391994087528954617607
+        0.2131391994087528954617607
+        >>> lerchphi(-4,1,1); log(5)/4
+        0.4023594781085250936501898
+        0.4023594781085250936501898
+        >>> lerchphi(-3+2j,1,0.5); 2*atanh(sqrt(-3+2j))/sqrt(-3+2j)
+        (1.142423447120257137774002 + 0.2118232380980201350495795j)
+        (1.142423447120257137774002 + 0.2118232380980201350495795j)
+
+    Evaluation works for complex arguments and `|z| \ge 1`::
+
+        >>> lerchphi(1+2j, 3-j, 4+2j)
+        (0.002025009957009908600539469 + 0.003327897536813558807438089j)
+        >>> lerchphi(-2,2,-2.5)
+        -12.28676272353094275265944
+        >>> lerchphi(10,10,10)
+        (-4.462130727102185701817349e-11 - 1.575172198981096218823481e-12j)
+        >>> lerchphi(10,10,-10.5)
+        (112658784011940.5605789002 - 498113185.5756221777743631j)
+
+    Some degenerate cases::
+
+        >>> lerchphi(0,1,2)
+        0.5
+        >>> lerchphi(0,1,-2)
+        -0.5
+
+    Reduction to simpler functions::
+
+        >>> lerchphi(1, 4.25+1j, 1)
+        (1.044674457556746668033975 - 0.04674508654012658932271226j)
+        >>> zeta(4.25+1j)
+        (1.044674457556746668033975 - 0.04674508654012658932271226j)
+        >>> lerchphi(1 - 0.5**10, 4.25+1j, 1)
+        (1.044629338021507546737197 - 0.04667768813963388181708101j)
+        >>> lerchphi(3, 4, 1)
+        (1.249503297023366545192592 - 0.2314252413375664776474462j)
+        >>> polylog(4, 3) / 3
+        (1.249503297023366545192592 - 0.2314252413375664776474462j)
+        >>> lerchphi(3, 4, 1 - 0.5**10)
+        (1.253978063946663945672674 - 0.2316736622836535468765376j)
+
+    **References**
+
+    1. [DLMF]_ section 25.14
+
+    """
+    if z == 0:
+        return a ** (-s)
+    # Faster, but these cases are useful for testing right now
+    if z == 1:
+        return ctx.zeta(s, a)
+    if a == 1:
+        return ctx.polylog(s, z) / z
+    if ctx.re(a) < 1:
+        if ctx.isnpint(a):
+            raise ValueError("Lerch transcendent complex infinity")
+        m = int(ctx.ceil(1-ctx.re(a)))
+        v = ctx.zero
+        zpow = ctx.one
+        for n in xrange(m):
+            v += zpow / (a+n)**s
+            zpow *= z
+        return zpow * ctx.lerchphi(z,s, a+m) + v
+    g = ctx.ln(z)
+    v = 1/(2*a**s) + ctx.gammainc(1-s, -a*g) * (-g)**(s-1) / z**a
+    h = s / 2
+    r = 2*ctx.pi
+    f = lambda t: ctx.sin(s*ctx.atan(t/a)-t*g) / \
+        ((a**2+t**2)**h * ctx.expm1(r*t))
+    v += 2*ctx.quad(f, [0, ctx.inf])
+    if not ctx.im(z) and not ctx.im(s) and not ctx.im(a) and ctx.re(z) < 1:
+        v = ctx.chop(v)
+    return v
diff --git a/lib/python3.10/site-packages/mpmath/functions/zetazeros.py b/lib/python3.10/site-packages/mpmath/functions/zetazeros.py
new file mode 100644
index 0000000000000000000000000000000000000000..37c11a29426b0114053ae61664541f7ae7de95d8
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/functions/zetazeros.py
@@ -0,0 +1,1018 @@
+"""
+The function zetazero(n) computes the n-th nontrivial zero of zeta(s).
+
+The general strategy is to locate a block of Gram intervals B where we
+know exactly the number of zeros contained and which of those zeros
+is that which we search.
+
+If n <= 400 000 000  we know exactly the Rosser exceptions, contained
+in a list in this file. Hence for n<=400 000 000 we simply
+look at these list of exceptions. If our zero is implicated in one of
+these exceptions we have our block B.  In other case we simply locate
+the good Rosser block containing our zero.
+
+For n > 400 000 000 we apply the method of Turing, as complemented by
+Lehman, Brent and Trudgian  to find a suitable B.
+"""
+
+from .functions import defun, defun_wrapped
+
+def find_rosser_block_zero(ctx, n):
+    """for n<400 000 000 determines a block were one find our zero"""
+    for k in range(len(_ROSSER_EXCEPTIONS)//2):
+        a=_ROSSER_EXCEPTIONS[2*k][0]
+        b=_ROSSER_EXCEPTIONS[2*k][1]
+        if ((a<= n-2) and (n-1 <= b)):
+            t0 = ctx.grampoint(a)
+            t1 = ctx.grampoint(b)
+            v0 = ctx._fp.siegelz(t0)
+            v1 = ctx._fp.siegelz(t1)
+            my_zero_number = n-a-1
+            zero_number_block = b-a
+            pattern = _ROSSER_EXCEPTIONS[2*k+1]
+            return (my_zero_number, [a,b], [t0,t1], [v0,v1])
+    k = n-2
+    t,v,b = compute_triple_tvb(ctx, k)
+    T = [t]
+    V = [v]
+    while b < 0:
+        k -= 1
+        t,v,b = compute_triple_tvb(ctx, k)
+        T.insert(0,t)
+        V.insert(0,v)
+    my_zero_number = n-k-1
+    m = n-1
+    t,v,b = compute_triple_tvb(ctx, m)
+    T.append(t)
+    V.append(v)
+    while b < 0:
+        m += 1
+        t,v,b = compute_triple_tvb(ctx, m)
+        T.append(t)
+        V.append(v)
+    return (my_zero_number, [k,m], T, V)
+
+def wpzeros(t):
+    """Precision needed to compute higher zeros"""
+    wp = 53
+    if t > 3*10**8:
+        wp = 63
+    if t > 10**11:
+        wp = 70
+    if t > 10**14:
+        wp = 83
+    return wp
+
+def separate_zeros_in_block(ctx, zero_number_block, T, V, limitloop=None,
+    fp_tolerance=None):
+    """Separate the zeros contained in the block T, limitloop
+    determines how long one must search"""
+    if limitloop is None:
+        limitloop = ctx.inf
+    loopnumber = 0
+    variations = count_variations(V)
+    while ((variations < zero_number_block) and (loopnumber <limitloop)):
+        a = T[0]
+        v = V[0]
+        newT = [a]
+        newV = [v]
+        variations = 0
+        for n in range(1,len(T)):
+            b2 = T[n]
+            u = V[n]
+            if (u*v>0):
+                alpha = ctx.sqrt(u/v)
+                b= (alpha*a+b2)/(alpha+1)
+            else:
+                b = (a+b2)/2
+            if fp_tolerance < 10:
+                w = ctx._fp.siegelz(b)
+                if abs(w)<fp_tolerance:
+                    w = ctx.siegelz(b)
+            else:
+                w=ctx.siegelz(b)
+            if v*w<0:
+                variations += 1
+            newT.append(b)
+            newV.append(w)
+            u = V[n]
+            if u*w <0:
+                variations += 1
+            newT.append(b2)
+            newV.append(u)
+            a = b2
+            v = u
+        T = newT
+        V = newV
+        loopnumber +=1
+        if (limitloop>ITERATION_LIMIT)and(loopnumber>2)and(variations+2==zero_number_block):
+            dtMax=0
+            dtSec=0
+            kMax = 0
+            for k1 in range(1,len(T)):
+                dt = T[k1]-T[k1-1]
+                if dt > dtMax:
+                    kMax=k1
+                    dtSec = dtMax
+                    dtMax = dt
+                elif  (dt<dtMax) and(dt >dtSec):
+                    dtSec = dt
+            if dtMax>3*dtSec:
+                f = lambda x: ctx.rs_z(x,derivative=1)
+                t0=T[kMax-1]
+                t1 = T[kMax]
+                t=ctx.findroot(f,  (t0,t1), solver ='illinois',verify=False, verbose=False)
+                v = ctx.siegelz(t)
+                if (t0<t) and (t<t1) and (v*V[kMax]<0):
+                    T.insert(kMax,t)
+                    V.insert(kMax,v)
+        variations = count_variations(V)
+    if variations == zero_number_block:
+        separated = True
+    else:
+        separated = False
+    return (T,V, separated)
+
+def separate_my_zero(ctx, my_zero_number, zero_number_block, T, V, prec):
+    """If we know which zero of this block is mine,
+    the function separates the zero"""
+    variations = 0
+    v0 = V[0]
+    for k in range(1,len(V)):
+        v1 = V[k]
+        if v0*v1 < 0:
+            variations +=1
+            if variations == my_zero_number:
+                k0 = k
+                leftv = v0
+                rightv = v1
+        v0 = v1
+    t1 = T[k0]
+    t0 = T[k0-1]
+    ctx.prec = prec
+    wpz = wpzeros(my_zero_number*ctx.log(my_zero_number))
+
+    guard = 4*ctx.mag(my_zero_number)
+    precs = [ctx.prec+4]
+    index=0
+    while precs[0] > 2*wpz:
+        index +=1
+        precs = [precs[0] // 2 +3+2*index] + precs
+    ctx.prec = precs[0] + guard
+    r = ctx.findroot(lambda x:ctx.siegelz(x), (t0,t1), solver ='illinois', verbose=False)
+    #print "first step at", ctx.dps, "digits"
+    z=ctx.mpc(0.5,r)
+    for prec in precs[1:]:
+        ctx.prec = prec + guard
+        #print "refining to", ctx.dps, "digits"
+        znew = z - ctx.zeta(z) / ctx.zeta(z, derivative=1)
+        #print "difference", ctx.nstr(abs(z-znew))
+        z=ctx.mpc(0.5,ctx.im(znew))
+    return ctx.im(z)
+
+def sure_number_block(ctx, n):
+    """The number of good Rosser blocks needed to apply
+    Turing method
+    References:
+    R. P. Brent, On the Zeros of the Riemann Zeta Function
+    in the Critical Strip, Math. Comp. 33 (1979) 1361--1372
+    T. Trudgian, Improvements to Turing Method, Math. Comp."""
+    if n < 9*10**5:
+        return(2)
+    g = ctx.grampoint(n-100)
+    lg = ctx._fp.ln(g)
+    brent = 0.0061 * lg**2 +0.08*lg
+    trudgian = 0.0031 * lg**2 +0.11*lg
+    N = ctx.ceil(min(brent,trudgian))
+    N = int(N)
+    return N
+
+def compute_triple_tvb(ctx, n):
+    t = ctx.grampoint(n)
+    v = ctx._fp.siegelz(t)
+    if ctx.mag(abs(v))<ctx.mag(t)-45:
+        v = ctx.siegelz(t)
+    b = v*(-1)**n
+    return t,v,b
+
+
+
+ITERATION_LIMIT = 4
+
+def search_supergood_block(ctx, n, fp_tolerance):
+    """To use for n>400 000 000"""
+    sb = sure_number_block(ctx, n)
+    number_goodblocks = 0
+    m2 = n-1
+    t, v, b = compute_triple_tvb(ctx, m2)
+    Tf = [t]
+    Vf = [v]
+    while b < 0:
+        m2 += 1
+        t,v,b = compute_triple_tvb(ctx, m2)
+        Tf.append(t)
+        Vf.append(v)
+    goodpoints = [m2]
+    T = [t]
+    V = [v]
+    while number_goodblocks < 2*sb:
+        m2 += 1
+        t, v, b = compute_triple_tvb(ctx, m2)
+        T.append(t)
+        V.append(v)
+        while b < 0:
+            m2 += 1
+            t,v,b = compute_triple_tvb(ctx, m2)
+            T.append(t)
+            V.append(v)
+        goodpoints.append(m2)
+        zn = len(T)-1
+        A, B, separated =\
+           separate_zeros_in_block(ctx, zn, T, V, limitloop=ITERATION_LIMIT,
+                fp_tolerance=fp_tolerance)
+        Tf.pop()
+        Tf.extend(A)
+        Vf.pop()
+        Vf.extend(B)
+        if separated:
+            number_goodblocks += 1
+        else:
+            number_goodblocks = 0
+        T = [t]
+        V = [v]
+    # Now the same procedure to the left
+    number_goodblocks = 0
+    m2 = n-2
+    t, v, b = compute_triple_tvb(ctx, m2)
+    Tf.insert(0,t)
+    Vf.insert(0,v)
+    while b < 0:
+        m2 -= 1
+        t,v,b = compute_triple_tvb(ctx, m2)
+        Tf.insert(0,t)
+        Vf.insert(0,v)
+    goodpoints.insert(0,m2)
+    T = [t]
+    V = [v]
+    while number_goodblocks < 2*sb:
+        m2 -= 1
+        t, v, b = compute_triple_tvb(ctx, m2)
+        T.insert(0,t)
+        V.insert(0,v)
+        while b < 0:
+            m2 -= 1
+            t,v,b = compute_triple_tvb(ctx, m2)
+            T.insert(0,t)
+            V.insert(0,v)
+        goodpoints.insert(0,m2)
+        zn = len(T)-1
+        A, B, separated =\
+           separate_zeros_in_block(ctx, zn, T, V, limitloop=ITERATION_LIMIT, fp_tolerance=fp_tolerance)
+        A.pop()
+        Tf = A+Tf
+        B.pop()
+        Vf = B+Vf
+        if separated:
+            number_goodblocks += 1
+        else:
+            number_goodblocks = 0
+        T = [t]
+        V = [v]
+    r = goodpoints[2*sb]
+    lg = len(goodpoints)
+    s = goodpoints[lg-2*sb-1]
+    tr, vr, br = compute_triple_tvb(ctx, r)
+    ar = Tf.index(tr)
+    ts, vs, bs = compute_triple_tvb(ctx, s)
+    as1 = Tf.index(ts)
+    T = Tf[ar:as1+1]
+    V = Vf[ar:as1+1]
+    zn = s-r
+    A, B, separated =\
+       separate_zeros_in_block(ctx, zn,T,V,limitloop=ITERATION_LIMIT, fp_tolerance=fp_tolerance)
+    if separated:
+        return (n-r-1,[r,s],A,B)
+    q = goodpoints[sb]
+    lg = len(goodpoints)
+    t = goodpoints[lg-sb-1]
+    tq, vq, bq = compute_triple_tvb(ctx, q)
+    aq = Tf.index(tq)
+    tt, vt, bt = compute_triple_tvb(ctx, t)
+    at = Tf.index(tt)
+    T = Tf[aq:at+1]
+    V = Vf[aq:at+1]
+    return (n-q-1,[q,t],T,V)
+
+def count_variations(V):
+    count = 0
+    vold = V[0]
+    for n in range(1, len(V)):
+        vnew = V[n]
+        if vold*vnew < 0:
+            count +=1
+        vold = vnew
+    return count
+
+def pattern_construct(ctx, block, T, V):
+    pattern = '('
+    a = block[0]
+    b = block[1]
+    t0,v0,b0 = compute_triple_tvb(ctx, a)
+    k = 0
+    k0 = 0
+    for n in range(a+1,b+1):
+        t1,v1,b1 = compute_triple_tvb(ctx, n)
+        lgT =len(T)
+        while (k < lgT) and (T[k] <= t1):
+            k += 1
+        L = V[k0:k]
+        L.append(v1)
+        L.insert(0,v0)
+        count = count_variations(L)
+        pattern = pattern + ("%s" % count)
+        if b1 > 0:
+            pattern = pattern + ')('
+        k0 = k
+        t0,v0,b0 = t1,v1,b1
+    pattern = pattern[:-1]
+    return pattern
+
+@defun
+def zetazero(ctx, n, info=False, round=True):
+    r"""
+    Computes the `n`-th nontrivial zero of `\zeta(s)` on the critical line,
+    i.e. returns an approximation of the `n`-th largest complex number
+    `s = \frac{1}{2} + ti` for which `\zeta(s) = 0`. Equivalently, the
+    imaginary part `t` is a zero of the Z-function (:func:`~mpmath.siegelz`).
+
+    **Examples**
+
+    The first few zeros::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> zetazero(1)
+        (0.5 + 14.13472514173469379045725j)
+        >>> zetazero(2)
+        (0.5 + 21.02203963877155499262848j)
+        >>> zetazero(20)
+        (0.5 + 77.14484006887480537268266j)
+
+    Verifying that the values are zeros::
+
+        >>> for n in range(1,5):
+        ...     s = zetazero(n)
+        ...     chop(zeta(s)), chop(siegelz(s.imag))
+        ...
+        (0.0, 0.0)
+        (0.0, 0.0)
+        (0.0, 0.0)
+        (0.0, 0.0)
+
+    Negative indices give the conjugate zeros (`n = 0` is undefined)::
+
+        >>> zetazero(-1)
+        (0.5 - 14.13472514173469379045725j)
+
+    :func:`~mpmath.zetazero` supports arbitrarily large `n` and arbitrary precision::
+
+        >>> mp.dps = 15
+        >>> zetazero(1234567)
+        (0.5 + 727690.906948208j)
+        >>> mp.dps = 50
+        >>> zetazero(1234567)
+        (0.5 + 727690.9069482075392389420041147142092708393819935j)
+        >>> chop(zeta(_)/_)
+        0.0
+
+    with *info=True*, :func:`~mpmath.zetazero` gives additional information::
+
+        >>> mp.dps = 15
+        >>> zetazero(542964976,info=True)
+        ((0.5 + 209039046.578535j), [542964969, 542964978], 6, '(013111110)')
+
+    This means that the zero is between Gram points 542964969 and 542964978;
+    it is the 6-th zero between them. Finally (01311110) is the pattern
+    of zeros in this interval. The numbers indicate the number of zeros
+    in each Gram interval (Rosser blocks between parenthesis). In this case
+    there is only one Rosser block of length nine.
+    """
+    n = int(n)
+    if n < 0:
+        return ctx.zetazero(-n).conjugate()
+    if n == 0:
+        raise ValueError("n must be nonzero")
+    wpinitial = ctx.prec
+    try:
+        wpz, fp_tolerance = comp_fp_tolerance(ctx, n)
+        ctx.prec = wpz
+        if n < 400000000:
+            my_zero_number, block, T, V =\
+             find_rosser_block_zero(ctx, n)
+        else:
+            my_zero_number, block, T, V =\
+             search_supergood_block(ctx, n, fp_tolerance)
+        zero_number_block = block[1]-block[0]
+        T, V, separated = separate_zeros_in_block(ctx, zero_number_block, T, V,
+            limitloop=ctx.inf, fp_tolerance=fp_tolerance)
+        if info:
+            pattern = pattern_construct(ctx,block,T,V)
+        prec = max(wpinitial, wpz)
+        t = separate_my_zero(ctx, my_zero_number, zero_number_block,T,V,prec)
+        v = ctx.mpc(0.5,t)
+    finally:
+        ctx.prec = wpinitial
+    if round:
+        v =+v
+    if info:
+        return (v,block,my_zero_number,pattern)
+    else:
+        return v
+
+def gram_index(ctx, t):
+    if t > 10**13:
+        wp = 3*ctx.log(t, 10)
+    else:
+        wp = 0
+    prec = ctx.prec
+    try:
+        ctx.prec += wp
+        h = int(ctx.siegeltheta(t)/ctx.pi)
+    finally:
+        ctx.prec = prec
+    return(h)
+
+def count_to(ctx, t, T, V):
+    count = 0
+    vold = V[0]
+    told = T[0]
+    tnew = T[1]
+    k = 1
+    while tnew < t:
+        vnew = V[k]
+        if vold*vnew < 0:
+            count += 1
+        vold = vnew
+        k += 1
+        tnew = T[k]
+    a = ctx.siegelz(t)
+    if a*vold < 0:
+        count += 1
+    return count
+
+def comp_fp_tolerance(ctx, n):
+    wpz = wpzeros(n*ctx.log(n))
+    if n < 15*10**8:
+        fp_tolerance = 0.0005
+    elif n <= 10**14:
+        fp_tolerance = 0.1
+    else:
+        fp_tolerance = 100
+    return wpz, fp_tolerance
+
+@defun
+def nzeros(ctx, t):
+    r"""
+    Computes the number of zeros of the Riemann zeta function in
+    `(0,1) \times (0,t]`, usually denoted by `N(t)`.
+
+    **Examples**
+
+    The first zero has imaginary part between 14 and 15::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> nzeros(14)
+        0
+        >>> nzeros(15)
+        1
+        >>> zetazero(1)
+        (0.5 + 14.1347251417347j)
+
+    Some closely spaced zeros::
+
+        >>> nzeros(10**7)
+        21136125
+        >>> zetazero(21136125)
+        (0.5 + 9999999.32718175j)
+        >>> zetazero(21136126)
+        (0.5 + 10000000.2400236j)
+        >>> nzeros(545439823.215)
+        1500000001
+        >>> zetazero(1500000001)
+        (0.5 + 545439823.201985j)
+        >>> zetazero(1500000002)
+        (0.5 + 545439823.325697j)
+
+    This confirms the data given by J. van de Lune,
+    H. J. J. te Riele and D. T. Winter in 1986.
+    """
+    if t < 14.1347251417347:
+        return 0
+    x = gram_index(ctx, t)
+    k = int(ctx.floor(x))
+    wpinitial = ctx.prec
+    wpz, fp_tolerance = comp_fp_tolerance(ctx, k)
+    ctx.prec = wpz
+    a = ctx.siegelz(t)
+    if k == -1 and a < 0:
+        return 0
+    elif k == -1 and a > 0:
+        return 1
+    if k+2 < 400000000:
+        Rblock = find_rosser_block_zero(ctx, k+2)
+    else:
+        Rblock = search_supergood_block(ctx, k+2, fp_tolerance)
+    n1, n2 = Rblock[1]
+    if n2-n1 == 1:
+        b = Rblock[3][0]
+        if a*b > 0:
+            ctx.prec = wpinitial
+            return k+1
+        else:
+            ctx.prec = wpinitial
+            return k+2
+    my_zero_number,block, T, V = Rblock
+    zero_number_block = n2-n1
+    T, V, separated = separate_zeros_in_block(ctx,\
+                                              zero_number_block, T, V,\
+                                              limitloop=ctx.inf,\
+                                            fp_tolerance=fp_tolerance)
+    n = count_to(ctx, t, T, V)
+    ctx.prec = wpinitial
+    return n+n1+1
+
+@defun_wrapped
+def backlunds(ctx, t):
+    r"""
+    Computes the function
+    `S(t) = \operatorname{arg} \zeta(\frac{1}{2} + it) / \pi`.
+
+    See Titchmarsh Section 9.3 for details of the definition.
+
+    **Examples**
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> backlunds(217.3)
+        0.16302205431184
+
+    Generally, the value is a small number. At Gram points it is an integer,
+    frequently equal to 0::
+
+        >>> chop(backlunds(grampoint(200)))
+        0.0
+        >>> backlunds(extraprec(10)(grampoint)(211))
+        1.0
+        >>> backlunds(extraprec(10)(grampoint)(232))
+        -1.0
+
+    The number of zeros of the Riemann zeta function up to height `t`
+    satisfies `N(t) = \theta(t)/\pi + 1 + S(t)` (see :func:nzeros` and
+    :func:`siegeltheta`)::
+
+        >>> t = 1234.55
+        >>> nzeros(t)
+        842
+        >>> siegeltheta(t)/pi+1+backlunds(t)
+        842.0
+
+    """
+    return ctx.nzeros(t)-1-ctx.siegeltheta(t)/ctx.pi
+
+
+"""
+_ROSSER_EXCEPTIONS is a list of all  exceptions to
+Rosser's rule for n <= 400 000 000.
+
+Alternately the  entry is of type   [n,m], or a string.
+The string is the zero pattern of the Block and the relevant
+adjacent.  For example (010)3 corresponds to a block
+composed of three Gram intervals, the first ant third without
+a zero and the intermediate with a zero. The next Gram interval
+contain three zeros. So that in total we have 4 zeros in 4 Gram
+blocks. n and m are the indices of the Gram points  of this
+interval of four Gram intervals. The Rosser exception is therefore
+formed by the three Gram intervals that are signaled between
+parenthesis.
+
+We have included also some Rosser's exceptions beyond n=400 000 000
+that are noted in the literature by some reason.
+
+The list is composed from the data published in the references:
+
+R. P. Brent, J. van de Lune, H. J. J. te Riele, D. T. Winter,
+'On the Zeros of the Riemann Zeta Function in the Critical Strip. II',
+Math. Comp. 39 (1982) 681--688.
+See also Corrigenda in Math. Comp. 46 (1986) 771.
+
+J. van de Lune, H. J. J. te Riele,
+'On the Zeros of the Riemann Zeta Function in the Critical Strip. III',
+Math. Comp. 41 (1983) 759--767.
+See also  Corrigenda in Math. Comp. 46 (1986) 771.
+
+J. van de Lune,
+'Sums of Equal Powers of Positive Integers',
+Dissertation,
+Vrije Universiteit te Amsterdam, Centrum voor Wiskunde en Informatica,
+Amsterdam, 1984.
+
+Thanks to the authors all this papers and those others that have
+contributed to make this possible.
+"""
+
+
+
+
+
+
+
+_ROSSER_EXCEPTIONS = \
+[[13999525, 13999528], '(00)3',
+[30783329, 30783332], '(00)3',
+[30930926, 30930929], '3(00)',
+[37592215, 37592218], '(00)3',
+[40870156, 40870159], '(00)3',
+[43628107, 43628110], '(00)3',
+[46082042, 46082045], '(00)3',
+[46875667, 46875670], '(00)3',
+[49624540, 49624543], '3(00)',
+[50799238, 50799241], '(00)3',
+[55221453, 55221456], '3(00)',
+[56948779, 56948782], '3(00)',
+[60515663, 60515666], '(00)3',
+[61331766, 61331770], '(00)40',
+[69784843, 69784846], '3(00)',
+[75052114, 75052117], '(00)3',
+[79545240, 79545243], '3(00)',
+[79652247, 79652250], '3(00)',
+[83088043, 83088046], '(00)3',
+[83689522, 83689525], '3(00)',
+[85348958, 85348961], '(00)3',
+[86513820, 86513823], '(00)3',
+[87947596, 87947599], '3(00)',
+[88600095, 88600098], '(00)3',
+[93681183, 93681186], '(00)3',
+[100316551, 100316554], '3(00)',
+[100788444, 100788447], '(00)3',
+[106236172, 106236175], '(00)3',
+[106941327, 106941330], '3(00)',
+[107287955, 107287958], '(00)3',
+[107532016, 107532019], '3(00)',
+[110571044, 110571047], '(00)3',
+[111885253, 111885256], '3(00)',
+[113239783, 113239786], '(00)3',
+[120159903, 120159906], '(00)3',
+[121424391, 121424394], '3(00)',
+[121692931, 121692934], '3(00)',
+[121934170, 121934173], '3(00)',
+[122612848, 122612851], '3(00)',
+[126116567, 126116570], '(00)3',
+[127936513, 127936516], '(00)3',
+[128710277, 128710280], '3(00)',
+[129398902, 129398905], '3(00)',
+[130461096, 130461099], '3(00)',
+[131331947, 131331950], '3(00)',
+[137334071, 137334074], '3(00)',
+[137832603, 137832606], '(00)3',
+[138799471, 138799474], '3(00)',
+[139027791, 139027794], '(00)3',
+[141617806, 141617809], '(00)3',
+[144454931, 144454934], '(00)3',
+[145402379, 145402382], '3(00)',
+[146130245, 146130248], '3(00)',
+[147059770, 147059773], '(00)3',
+[147896099, 147896102], '3(00)',
+[151097113, 151097116], '(00)3',
+[152539438, 152539441], '(00)3',
+[152863168, 152863171], '3(00)',
+[153522726, 153522729], '3(00)',
+[155171524, 155171527], '3(00)',
+[155366607, 155366610], '(00)3',
+[157260686, 157260689], '3(00)',
+[157269224, 157269227], '(00)3',
+[157755123, 157755126], '(00)3',
+[158298484, 158298487], '3(00)',
+[160369050, 160369053], '3(00)',
+[162962787, 162962790], '(00)3',
+[163724709, 163724712], '(00)3',
+[164198113, 164198116], '3(00)',
+[164689301, 164689305], '(00)40',
+[164880228, 164880231], '3(00)',
+[166201932, 166201935], '(00)3',
+[168573836, 168573839], '(00)3',
+[169750763, 169750766], '(00)3',
+[170375507, 170375510], '(00)3',
+[170704879, 170704882], '3(00)',
+[172000992, 172000995], '3(00)',
+[173289941, 173289944], '(00)3',
+[173737613, 173737616], '3(00)',
+[174102513, 174102516], '(00)3',
+[174284990, 174284993], '(00)3',
+[174500513, 174500516], '(00)3',
+[175710609, 175710612], '(00)3',
+[176870843, 176870846], '3(00)',
+[177332732, 177332735], '3(00)',
+[177902861, 177902864], '3(00)',
+[179979095, 179979098], '(00)3',
+[181233726, 181233729], '3(00)',
+[181625435, 181625438], '(00)3',
+[182105255, 182105259], '22(00)',
+[182223559, 182223562], '3(00)',
+[191116404, 191116407], '3(00)',
+[191165599, 191165602], '3(00)',
+[191297535, 191297539], '(00)22',
+[192485616, 192485619], '(00)3',
+[193264634, 193264638], '22(00)',
+[194696968, 194696971], '(00)3',
+[195876805, 195876808], '(00)3',
+[195916548, 195916551], '3(00)',
+[196395160, 196395163], '3(00)',
+[196676303, 196676306], '(00)3',
+[197889882, 197889885], '3(00)',
+[198014122, 198014125], '(00)3',
+[199235289, 199235292], '(00)3',
+[201007375, 201007378], '(00)3',
+[201030605, 201030608], '3(00)',
+[201184290, 201184293], '3(00)',
+[201685414, 201685418], '(00)22',
+[202762875, 202762878], '3(00)',
+[202860957, 202860960], '3(00)',
+[203832577, 203832580], '3(00)',
+[205880544, 205880547], '(00)3',
+[206357111, 206357114], '(00)3',
+[207159767, 207159770], '3(00)',
+[207167343, 207167346], '3(00)',
+[207482539, 207482543], '3(010)',
+[207669540, 207669543], '3(00)',
+[208053426, 208053429], '(00)3',
+[208110027, 208110030], '3(00)',
+[209513826, 209513829], '3(00)',
+[212623522, 212623525], '(00)3',
+[213841715, 213841718], '(00)3',
+[214012333, 214012336], '(00)3',
+[214073567, 214073570], '(00)3',
+[215170600, 215170603], '3(00)',
+[215881039, 215881042], '3(00)',
+[216274604, 216274607], '3(00)',
+[216957120, 216957123], '3(00)',
+[217323208, 217323211], '(00)3',
+[218799264, 218799267], '(00)3',
+[218803557, 218803560], '3(00)',
+[219735146, 219735149], '(00)3',
+[219830062, 219830065], '3(00)',
+[219897904, 219897907], '(00)3',
+[221205545, 221205548], '(00)3',
+[223601929, 223601932], '(00)3',
+[223907076, 223907079], '3(00)',
+[223970397, 223970400], '(00)3',
+[224874044, 224874048], '22(00)',
+[225291157, 225291160], '(00)3',
+[227481734, 227481737], '(00)3',
+[228006442, 228006445], '3(00)',
+[228357900, 228357903], '(00)3',
+[228386399, 228386402], '(00)3',
+[228907446, 228907449], '(00)3',
+[228984552, 228984555], '3(00)',
+[229140285, 229140288], '3(00)',
+[231810024, 231810027], '(00)3',
+[232838062, 232838065], '3(00)',
+[234389088, 234389091], '3(00)',
+[235588194, 235588197], '(00)3',
+[236645695, 236645698], '(00)3',
+[236962876, 236962879], '3(00)',
+[237516723, 237516727], '04(00)',
+[240004911, 240004914], '(00)3',
+[240221306, 240221309], '3(00)',
+[241389213, 241389217], '(010)3',
+[241549003, 241549006], '(00)3',
+[241729717, 241729720], '(00)3',
+[241743684, 241743687], '3(00)',
+[243780200, 243780203], '3(00)',
+[243801317, 243801320], '(00)3',
+[244122072, 244122075], '(00)3',
+[244691224, 244691227], '3(00)',
+[244841577, 244841580], '(00)3',
+[245813461, 245813464], '(00)3',
+[246299475, 246299478], '(00)3',
+[246450176, 246450179], '3(00)',
+[249069349, 249069352], '(00)3',
+[250076378, 250076381], '(00)3',
+[252442157, 252442160], '3(00)',
+[252904231, 252904234], '3(00)',
+[255145220, 255145223], '(00)3',
+[255285971, 255285974], '3(00)',
+[256713230, 256713233], '(00)3',
+[257992082, 257992085], '(00)3',
+[258447955, 258447959], '22(00)',
+[259298045, 259298048], '3(00)',
+[262141503, 262141506], '(00)3',
+[263681743, 263681746], '3(00)',
+[266527881, 266527885], '(010)3',
+[266617122, 266617125], '(00)3',
+[266628044, 266628047], '3(00)',
+[267305763, 267305766], '(00)3',
+[267388404, 267388407], '3(00)',
+[267441672, 267441675], '3(00)',
+[267464886, 267464889], '(00)3',
+[267554907, 267554910], '3(00)',
+[269787480, 269787483], '(00)3',
+[270881434, 270881437], '(00)3',
+[270997583, 270997586], '3(00)',
+[272096378, 272096381], '3(00)',
+[272583009, 272583012], '(00)3',
+[274190881, 274190884], '3(00)',
+[274268747, 274268750], '(00)3',
+[275297429, 275297432], '3(00)',
+[275545476, 275545479], '3(00)',
+[275898479, 275898482], '3(00)',
+[275953000, 275953003], '(00)3',
+[277117197, 277117201], '(00)22',
+[277447310, 277447313], '3(00)',
+[279059657, 279059660], '3(00)',
+[279259144, 279259147], '3(00)',
+[279513636, 279513639], '3(00)',
+[279849069, 279849072], '3(00)',
+[280291419, 280291422], '(00)3',
+[281449425, 281449428], '3(00)',
+[281507953, 281507956], '3(00)',
+[281825600, 281825603], '(00)3',
+[282547093, 282547096], '3(00)',
+[283120963, 283120966], '3(00)',
+[283323493, 283323496], '(00)3',
+[284764535, 284764538], '3(00)',
+[286172639, 286172642], '3(00)',
+[286688824, 286688827], '(00)3',
+[287222172, 287222175], '3(00)',
+[287235534, 287235537], '3(00)',
+[287304861, 287304864], '3(00)',
+[287433571, 287433574], '(00)3',
+[287823551, 287823554], '(00)3',
+[287872422, 287872425], '3(00)',
+[288766615, 288766618], '3(00)',
+[290122963, 290122966], '3(00)',
+[290450849, 290450853], '(00)22',
+[291426141, 291426144], '3(00)',
+[292810353, 292810356], '3(00)',
+[293109861, 293109864], '3(00)',
+[293398054, 293398057], '3(00)',
+[294134426, 294134429], '3(00)',
+[294216438, 294216441], '(00)3',
+[295367141, 295367144], '3(00)',
+[297834111, 297834114], '3(00)',
+[299099969, 299099972], '3(00)',
+[300746958, 300746961], '3(00)',
+[301097423, 301097426], '(00)3',
+[301834209, 301834212], '(00)3',
+[302554791, 302554794], '(00)3',
+[303497445, 303497448], '3(00)',
+[304165344, 304165347], '3(00)',
+[304790218, 304790222], '3(010)',
+[305302352, 305302355], '(00)3',
+[306785996, 306785999], '3(00)',
+[307051443, 307051446], '3(00)',
+[307481539, 307481542], '3(00)',
+[308605569, 308605572], '3(00)',
+[309237610, 309237613], '3(00)',
+[310509287, 310509290], '(00)3',
+[310554057, 310554060], '3(00)',
+[310646345, 310646348], '3(00)',
+[311274896, 311274899], '(00)3',
+[311894272, 311894275], '3(00)',
+[312269470, 312269473], '(00)3',
+[312306601, 312306605], '(00)40',
+[312683193, 312683196], '3(00)',
+[314499804, 314499807], '3(00)',
+[314636802, 314636805], '(00)3',
+[314689897, 314689900], '3(00)',
+[314721319, 314721322], '3(00)',
+[316132890, 316132893], '3(00)',
+[316217470, 316217474], '(010)3',
+[316465705, 316465708], '3(00)',
+[316542790, 316542793], '(00)3',
+[320822347, 320822350], '3(00)',
+[321733242, 321733245], '3(00)',
+[324413970, 324413973], '(00)3',
+[325950140, 325950143], '(00)3',
+[326675884, 326675887], '(00)3',
+[326704208, 326704211], '3(00)',
+[327596247, 327596250], '3(00)',
+[328123172, 328123175], '3(00)',
+[328182212, 328182215], '(00)3',
+[328257498, 328257501], '3(00)',
+[328315836, 328315839], '(00)3',
+[328800974, 328800977], '(00)3',
+[328998509, 328998512], '3(00)',
+[329725370, 329725373], '(00)3',
+[332080601, 332080604], '(00)3',
+[332221246, 332221249], '(00)3',
+[332299899, 332299902], '(00)3',
+[332532822, 332532825], '(00)3',
+[333334544, 333334548], '(00)22',
+[333881266, 333881269], '3(00)',
+[334703267, 334703270], '3(00)',
+[334875138, 334875141], '3(00)',
+[336531451, 336531454], '3(00)',
+[336825907, 336825910], '(00)3',
+[336993167, 336993170], '(00)3',
+[337493998, 337494001], '3(00)',
+[337861034, 337861037], '3(00)',
+[337899191, 337899194], '(00)3',
+[337958123, 337958126], '(00)3',
+[342331982, 342331985], '3(00)',
+[342676068, 342676071], '3(00)',
+[347063781, 347063784], '3(00)',
+[347697348, 347697351], '3(00)',
+[347954319, 347954322], '3(00)',
+[348162775, 348162778], '3(00)',
+[349210702, 349210705], '(00)3',
+[349212913, 349212916], '3(00)',
+[349248650, 349248653], '(00)3',
+[349913500, 349913503], '3(00)',
+[350891529, 350891532], '3(00)',
+[351089323, 351089326], '3(00)',
+[351826158, 351826161], '3(00)',
+[352228580, 352228583], '(00)3',
+[352376244, 352376247], '3(00)',
+[352853758, 352853761], '(00)3',
+[355110439, 355110442], '(00)3',
+[355808090, 355808094], '(00)40',
+[355941556, 355941559], '3(00)',
+[356360231, 356360234], '(00)3',
+[356586657, 356586660], '3(00)',
+[356892926, 356892929], '(00)3',
+[356908232, 356908235], '3(00)',
+[357912730, 357912733], '3(00)',
+[358120344, 358120347], '3(00)',
+[359044096, 359044099], '(00)3',
+[360819357, 360819360], '3(00)',
+[361399662, 361399666], '(010)3',
+[362361315, 362361318], '(00)3',
+[363610112, 363610115], '(00)3',
+[363964804, 363964807], '3(00)',
+[364527375, 364527378], '(00)3',
+[365090327, 365090330], '(00)3',
+[365414539, 365414542], '3(00)',
+[366738474, 366738477], '3(00)',
+[368714778, 368714783], '04(010)',
+[368831545, 368831548], '(00)3',
+[368902387, 368902390], '(00)3',
+[370109769, 370109772], '3(00)',
+[370963333, 370963336], '3(00)',
+[372541136, 372541140], '3(010)',
+[372681562, 372681565], '(00)3',
+[373009410, 373009413], '(00)3',
+[373458970, 373458973], '3(00)',
+[375648658, 375648661], '3(00)',
+[376834728, 376834731], '3(00)',
+[377119945, 377119948], '(00)3',
+[377335703, 377335706], '(00)3',
+[378091745, 378091748], '3(00)',
+[379139522, 379139525], '3(00)',
+[380279160, 380279163], '(00)3',
+[380619442, 380619445], '3(00)',
+[381244231, 381244234], '3(00)',
+[382327446, 382327450], '(010)3',
+[382357073, 382357076], '3(00)',
+[383545479, 383545482], '3(00)',
+[384363766, 384363769], '(00)3',
+[384401786, 384401790], '22(00)',
+[385198212, 385198215], '3(00)',
+[385824476, 385824479], '(00)3',
+[385908194, 385908197], '3(00)',
+[386946806, 386946809], '3(00)',
+[387592175, 387592179], '22(00)',
+[388329293, 388329296], '(00)3',
+[388679566, 388679569], '3(00)',
+[388832142, 388832145], '3(00)',
+[390087103, 390087106], '(00)3',
+[390190926, 390190930], '(00)22',
+[390331207, 390331210], '3(00)',
+[391674495, 391674498], '3(00)',
+[391937831, 391937834], '3(00)',
+[391951632, 391951636], '(00)22',
+[392963986, 392963989], '(00)3',
+[393007921, 393007924], '3(00)',
+[393373210, 393373213], '3(00)',
+[393759572, 393759575], '(00)3',
+[394036662, 394036665], '(00)3',
+[395813866, 395813869], '(00)3',
+[395956690, 395956693], '3(00)',
+[396031670, 396031673], '3(00)',
+[397076433, 397076436], '3(00)',
+[397470601, 397470604], '3(00)',
+[398289458, 398289461], '3(00)',
+#
+[368714778, 368714783], '04(010)',
+[437953499, 437953504], '04(010)',
+[526196233, 526196238], '032(00)',
+[744719566, 744719571], '(010)40',
+[750375857, 750375862], '032(00)',
+[958241932, 958241937], '04(010)',
+[983377342, 983377347], '(00)410',
+[1003780080, 1003780085], '04(010)',
+[1070232754, 1070232759], '(00)230',
+[1209834865, 1209834870], '032(00)',
+[1257209100, 1257209105], '(00)410',
+[1368002233, 1368002238], '(00)230'
+]
diff --git a/lib/python3.10/site-packages/mpmath/libmp/__init__.py b/lib/python3.10/site-packages/mpmath/libmp/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1573114afc4fbce73f2ba9d2ddc99882c00027c0
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/libmp/__init__.py
@@ -0,0 +1,77 @@
+from .libmpf import (prec_to_dps, dps_to_prec, repr_dps,
+  round_down, round_up, round_floor, round_ceiling, round_nearest,
+  to_pickable, from_pickable, ComplexResult,
+  fzero, fnzero, fone, fnone, ftwo, ften, fhalf, fnan, finf, fninf,
+  math_float_inf, round_int, normalize, normalize1,
+  from_man_exp, from_int, to_man_exp, to_int, mpf_ceil, mpf_floor,
+  mpf_nint, mpf_frac,
+  from_float, from_npfloat, from_Decimal, to_float, from_rational, to_rational, to_fixed,
+  mpf_rand, mpf_eq, mpf_hash, mpf_cmp, mpf_lt, mpf_le, mpf_gt, mpf_ge,
+  mpf_pos, mpf_neg, mpf_abs, mpf_sign, mpf_add, mpf_sub, mpf_sum,
+  mpf_mul, mpf_mul_int, mpf_shift, mpf_frexp,
+  mpf_div, mpf_rdiv_int, mpf_mod, mpf_pow_int,
+  mpf_perturb,
+  to_digits_exp, to_str, str_to_man_exp, from_str, from_bstr, to_bstr,
+  mpf_sqrt, mpf_hypot)
+
+from .libmpc import (mpc_one, mpc_zero, mpc_two, mpc_half,
+  mpc_is_inf, mpc_is_infnan, mpc_to_str, mpc_to_complex, mpc_hash,
+  mpc_conjugate, mpc_is_nonzero, mpc_add, mpc_add_mpf,
+  mpc_sub, mpc_sub_mpf, mpc_pos, mpc_neg, mpc_shift, mpc_abs,
+  mpc_arg, mpc_floor, mpc_ceil,  mpc_nint, mpc_frac, mpc_mul, mpc_square,
+  mpc_mul_mpf, mpc_mul_imag_mpf, mpc_mul_int,
+  mpc_div, mpc_div_mpf, mpc_reciprocal, mpc_mpf_div,
+  complex_int_pow, mpc_pow, mpc_pow_mpf, mpc_pow_int,
+  mpc_sqrt, mpc_nthroot, mpc_cbrt, mpc_exp, mpc_log, mpc_cos, mpc_sin,
+  mpc_tan, mpc_cos_pi, mpc_sin_pi, mpc_cosh, mpc_sinh, mpc_tanh,
+  mpc_atan, mpc_acos, mpc_asin, mpc_asinh, mpc_acosh, mpc_atanh,
+  mpc_fibonacci, mpf_expj, mpf_expjpi, mpc_expj, mpc_expjpi,
+  mpc_cos_sin, mpc_cos_sin_pi)
+
+from .libelefun import (ln2_fixed, mpf_ln2, ln10_fixed, mpf_ln10,
+  pi_fixed, mpf_pi, e_fixed, mpf_e, phi_fixed, mpf_phi,
+  degree_fixed, mpf_degree,
+  mpf_pow, mpf_nthroot, mpf_cbrt, log_int_fixed, agm_fixed,
+  mpf_log, mpf_log_hypot, mpf_exp, mpf_cos_sin, mpf_cos, mpf_sin, mpf_tan,
+  mpf_cos_sin_pi, mpf_cos_pi, mpf_sin_pi, mpf_cosh_sinh,
+  mpf_cosh, mpf_sinh, mpf_tanh, mpf_atan, mpf_atan2, mpf_asin,
+  mpf_acos, mpf_asinh, mpf_acosh, mpf_atanh, mpf_fibonacci)
+
+from .libhyper import (NoConvergence, make_hyp_summator,
+  mpf_erf, mpf_erfc, mpf_ei, mpc_ei, mpf_e1, mpc_e1, mpf_expint,
+  mpf_ci_si, mpf_ci, mpf_si, mpc_ci, mpc_si, mpf_besseljn,
+  mpc_besseljn, mpf_agm, mpf_agm1, mpc_agm, mpc_agm1,
+  mpf_ellipk, mpc_ellipk, mpf_ellipe, mpc_ellipe)
+
+from .gammazeta import (catalan_fixed, mpf_catalan,
+  khinchin_fixed, mpf_khinchin, glaisher_fixed, mpf_glaisher,
+  apery_fixed, mpf_apery, euler_fixed, mpf_euler, mertens_fixed,
+  mpf_mertens, twinprime_fixed, mpf_twinprime,
+  mpf_bernoulli, bernfrac, mpf_gamma_int,
+  mpf_factorial, mpc_factorial, mpf_gamma, mpc_gamma,
+  mpf_loggamma, mpc_loggamma, mpf_rgamma, mpc_rgamma,
+  mpf_harmonic, mpc_harmonic, mpf_psi0, mpc_psi0,
+  mpf_psi, mpc_psi, mpf_zeta_int, mpf_zeta, mpc_zeta,
+  mpf_altzeta, mpc_altzeta, mpf_zetasum, mpc_zetasum)
+
+from .libmpi import (mpi_str,
+  mpi_from_str, mpi_to_str,
+  mpi_eq, mpi_ne,
+  mpi_lt, mpi_le, mpi_gt, mpi_ge,
+  mpi_add, mpi_sub, mpi_delta, mpi_mid,
+  mpi_pos, mpi_neg, mpi_abs, mpi_mul, mpi_div, mpi_exp,
+  mpi_log, mpi_sqrt, mpi_pow_int, mpi_pow, mpi_cos_sin,
+  mpi_cos, mpi_sin, mpi_tan, mpi_cot,
+  mpi_atan, mpi_atan2,
+  mpci_pos, mpci_neg, mpci_add, mpci_sub, mpci_mul, mpci_div, mpci_pow,
+  mpci_abs, mpci_pow, mpci_exp, mpci_log, mpci_cos, mpci_sin,
+  mpi_gamma, mpci_gamma, mpi_loggamma, mpci_loggamma,
+  mpi_rgamma, mpci_rgamma, mpi_factorial, mpci_factorial)
+
+from .libintmath import (trailing, bitcount, numeral, bin_to_radix,
+  isqrt, isqrt_small, isqrt_fast, sqrt_fixed, sqrtrem, ifib, ifac,
+  list_primes, isprime, moebius, gcd, eulernum, stirling1, stirling2)
+
+from .backend import (gmpy, sage, BACKEND, STRICT, MPZ, MPZ_TYPE,
+  MPZ_ZERO, MPZ_ONE, MPZ_TWO, MPZ_THREE, MPZ_FIVE, int_types,
+  HASH_MODULUS, HASH_BITS)
diff --git a/lib/python3.10/site-packages/mpmath/libmp/backend.py b/lib/python3.10/site-packages/mpmath/libmp/backend.py
new file mode 100644
index 0000000000000000000000000000000000000000..5610221290a05078f21f09df3c1a76b0e4ccdc02
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/libmp/backend.py
@@ -0,0 +1,115 @@
+import os
+import sys
+
+#----------------------------------------------------------------------------#
+# Support GMPY for high-speed large integer arithmetic.                      #
+#                                                                            #
+# To allow an external module to handle arithmetic, we need to make sure     #
+# that all high-precision variables are declared of the correct type. MPZ    #
+# is the constructor for the high-precision type. It defaults to Python's    #
+# long type but can be assinged another type, typically gmpy.mpz.            #
+#                                                                            #
+# MPZ must be used for the mantissa component of an mpf and must be used     #
+# for internal fixed-point operations.                                       #
+#                                                                            #
+# Side-effects                                                               #
+# 1) "is" cannot be used to test for special values. Must use "==".          #
+# 2) There are bugs in GMPY prior to v1.02 so we must use v1.03 or later.    #
+#----------------------------------------------------------------------------#
+
+# So we can import it from this module
+gmpy = None
+sage = None
+sage_utils = None
+
+if sys.version_info[0] < 3:
+    python3 = False
+else:
+    python3 = True
+
+BACKEND = 'python'
+
+if not python3:
+    MPZ = long
+    xrange = xrange
+    basestring = basestring
+
+    def exec_(_code_, _globs_=None, _locs_=None):
+        """Execute code in a namespace."""
+        if _globs_ is None:
+            frame = sys._getframe(1)
+            _globs_ = frame.f_globals
+            if _locs_ is None:
+                _locs_ = frame.f_locals
+            del frame
+        elif _locs_ is None:
+            _locs_ = _globs_
+        exec("""exec _code_ in _globs_, _locs_""")
+else:
+    MPZ = int
+    xrange = range
+    basestring = str
+
+    import builtins
+    exec_ = getattr(builtins, "exec")
+
+# Define constants for calculating hash on Python 3.2.
+if sys.version_info >= (3, 2):
+    HASH_MODULUS = sys.hash_info.modulus
+    if sys.hash_info.width == 32:
+        HASH_BITS = 31
+    else:
+        HASH_BITS = 61
+else:
+    HASH_MODULUS = None
+    HASH_BITS = None
+
+if 'MPMATH_NOGMPY' not in os.environ:
+    try:
+        try:
+            import gmpy2 as gmpy
+        except ImportError:
+            try:
+                import gmpy
+            except ImportError:
+                raise ImportError
+        if gmpy.version() >= '1.03':
+            BACKEND = 'gmpy'
+            MPZ = gmpy.mpz
+    except:
+        pass
+
+if ('MPMATH_NOSAGE' not in os.environ and 'SAGE_ROOT' in os.environ or
+        'MPMATH_SAGE' in os.environ):
+    try:
+        import sage.all
+        import sage.libs.mpmath.utils as _sage_utils
+        sage = sage.all
+        sage_utils = _sage_utils
+        BACKEND = 'sage'
+        MPZ = sage.Integer
+    except:
+        pass
+
+if 'MPMATH_STRICT' in os.environ:
+    STRICT = True
+else:
+    STRICT = False
+
+MPZ_TYPE = type(MPZ(0))
+MPZ_ZERO = MPZ(0)
+MPZ_ONE = MPZ(1)
+MPZ_TWO = MPZ(2)
+MPZ_THREE = MPZ(3)
+MPZ_FIVE = MPZ(5)
+
+try:
+    if BACKEND == 'python':
+        int_types = (int, long)
+    else:
+        int_types = (int, long, MPZ_TYPE)
+except NameError:
+    if BACKEND == 'python':
+        int_types = (int,)
+    else:
+        int_types = (int, MPZ_TYPE)
diff --git a/lib/python3.10/site-packages/mpmath/libmp/gammazeta.py b/lib/python3.10/site-packages/mpmath/libmp/gammazeta.py
new file mode 100644
index 0000000000000000000000000000000000000000..3b05cc63c5f00e6c76d8383853dba06f15e46030
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/libmp/gammazeta.py
@@ -0,0 +1,2167 @@
+"""
+-----------------------------------------------------------------------
+This module implements gamma- and zeta-related functions:
+
+* Bernoulli numbers
+* Factorials
+* The gamma function
+* Polygamma functions
+* Harmonic numbers
+* The Riemann zeta function
+* Constants related to these functions
+
+-----------------------------------------------------------------------
+"""
+
+import math
+import sys
+
+from .backend import xrange
+from .backend import MPZ, MPZ_ZERO, MPZ_ONE, MPZ_THREE, gmpy
+
+from .libintmath import list_primes, ifac, ifac2, moebius
+
+from .libmpf import (\
+    round_floor, round_ceiling, round_down, round_up,
+    round_nearest, round_fast,
+    lshift, sqrt_fixed, isqrt_fast,
+    fzero, fone, fnone, fhalf, ftwo, finf, fninf, fnan,
+    from_int, to_int, to_fixed, from_man_exp, from_rational,
+    mpf_pos, mpf_neg, mpf_abs, mpf_add, mpf_sub,
+    mpf_mul, mpf_mul_int, mpf_div, mpf_sqrt, mpf_pow_int,
+    mpf_rdiv_int,
+    mpf_perturb, mpf_le, mpf_lt, mpf_gt, mpf_shift,
+    negative_rnd, reciprocal_rnd,
+    bitcount, to_float, mpf_floor, mpf_sign, ComplexResult
+)
+
+from .libelefun import (\
+    constant_memo,
+    def_mpf_constant,
+    mpf_pi, pi_fixed, ln2_fixed, log_int_fixed, mpf_ln2,
+    mpf_exp, mpf_log, mpf_pow, mpf_cosh,
+    mpf_cos_sin, mpf_cosh_sinh, mpf_cos_sin_pi, mpf_cos_pi, mpf_sin_pi,
+    ln_sqrt2pi_fixed, mpf_ln_sqrt2pi, sqrtpi_fixed, mpf_sqrtpi,
+    cos_sin_fixed, exp_fixed
+)
+
+from .libmpc import (\
+    mpc_zero, mpc_one, mpc_half, mpc_two,
+    mpc_abs, mpc_shift, mpc_pos, mpc_neg,
+    mpc_add, mpc_sub, mpc_mul, mpc_div,
+    mpc_add_mpf, mpc_mul_mpf, mpc_div_mpf, mpc_mpf_div,
+    mpc_mul_int, mpc_pow_int,
+    mpc_log, mpc_exp, mpc_pow,
+    mpc_cos_pi, mpc_sin_pi,
+    mpc_reciprocal, mpc_square,
+    mpc_sub_mpf
+)
+
+
+
+# Catalan's constant is computed using Lupas's rapidly convergent series
+# (listed on http://mathworld.wolfram.com/CatalansConstant.html)
+#            oo
+#            ___       n-1  8n     2                   3    2
+#        1  \      (-1)    2   (40n  - 24n + 3) [(2n)!] (n!)
+#  K =  ---  )     -----------------------------------------
+#       64  /___               3               2
+#                             n  (2n-1) [(4n)!]
+#           n = 1
+
+@constant_memo
+def catalan_fixed(prec):
+    prec = prec + 20
+    a = one = MPZ_ONE << prec
+    s, t, n = 0, 1, 1
+    while t:
+        a *= 32 * n**3 * (2*n-1)
+        a //= (3-16*n+16*n**2)**2
+        t = a * (-1)**(n-1) * (40*n**2-24*n+3) // (n**3 * (2*n-1))
+        s += t
+        n += 1
+    return s >> (20 + 6)
+
+# Khinchin's constant is relatively difficult to compute. Here
+# we use the rational zeta series
+
+#                    oo                2*n-1
+#                   ___                ___
+#                   \   ` zeta(2*n)-1  \   ` (-1)^(k+1)
+#  log(K)*log(2) =   )    ------------  )    ----------
+#                   /___.      n       /___.      k
+#                   n = 1              k = 1
+
+# which adds half a digit per term. The essential trick for achieving
+# reasonable efficiency is to recycle both the values of the zeta
+# function (essentially Bernoulli numbers) and the partial terms of
+# the inner sum.
+
+# An alternative might be to use K = 2*exp[1/log(2) X] where
+
+#      / 1     1       [ pi*x*(1-x^2) ]
+#  X = |    ------ log [ ------------ ].
+#      / 0  x(1+x)     [  sin(pi*x)   ]
+
+# and integrate numerically. In practice, this seems to be slightly
+# slower than the zeta series at high precision.
+
+@constant_memo
+def khinchin_fixed(prec):
+    wp = int(prec + prec**0.5 + 15)
+    s = MPZ_ZERO
+    fac = from_int(4)
+    t = ONE = MPZ_ONE << wp
+    pi = mpf_pi(wp)
+    pipow = twopi2 = mpf_shift(mpf_mul(pi, pi, wp), 2)
+    n = 1
+    while 1:
+        zeta2n = mpf_abs(mpf_bernoulli(2*n, wp))
+        zeta2n = mpf_mul(zeta2n, pipow, wp)
+        zeta2n = mpf_div(zeta2n, fac, wp)
+        zeta2n = to_fixed(zeta2n, wp)
+        term = (((zeta2n - ONE) * t) // n) >> wp
+        if term < 100:
+            break
+        #if not n % 10:
+        #    print n, math.log(int(abs(term)))
+        s += term
+        t += ONE//(2*n+1) - ONE//(2*n)
+        n += 1
+        fac = mpf_mul_int(fac, (2*n)*(2*n-1), wp)
+        pipow = mpf_mul(pipow, twopi2, wp)
+    s = (s << wp) // ln2_fixed(wp)
+    K = mpf_exp(from_man_exp(s, -wp), wp)
+    K = to_fixed(K, prec)
+    return K
+
+
+# Glaisher's constant is defined as A = exp(1/2 - zeta'(-1)).
+# One way to compute it would be to perform direct numerical
+# differentiation, but computing arbitrary Riemann zeta function
+# values at high precision is expensive. We instead use the formula
+
+#     A = exp((6 (-zeta'(2))/pi^2 + log 2 pi + gamma)/12)
+
+# and compute zeta'(2) from the series representation
+
+#              oo
+#              ___
+#             \     log k
+#  -zeta'(2) = )    -----
+#             /___     2
+#                    k
+#            k = 2
+
+# This series converges exceptionally slowly, but can be accelerated
+# using Euler-Maclaurin formula. The important insight is that the
+# E-M integral can be done in closed form and that the high order
+# are given by
+
+#    n  /       \
+#   d   | log x |   a + b log x
+#   --- | ----- | = -----------
+#     n |   2   |      2 + n
+#   dx  \  x    /     x
+
+# where a and b are integers given by a simple recurrence. Note
+# that just one logarithm is needed. However, lots of integer
+# logarithms are required for the initial summation.
+
+# This algorithm could possibly be turned into a faster algorithm
+# for general evaluation of zeta(s) or zeta'(s); this should be
+# looked into.
+
+@constant_memo
+def glaisher_fixed(prec):
+    wp = prec + 30
+    # Number of direct terms to sum before applying the Euler-Maclaurin
+    # formula to the tail. TODO: choose more intelligently
+    N = int(0.33*prec + 5)
+    ONE = MPZ_ONE << wp
+    # Euler-Maclaurin, step 1: sum log(k)/k**2 for k from 2 to N-1
+    s = MPZ_ZERO
+    for k in range(2, N):
+        #print k, N
+        s += log_int_fixed(k, wp) // k**2
+    logN = log_int_fixed(N, wp)
+    #logN = to_fixed(mpf_log(from_int(N), wp+20), wp)
+    # E-M step 2: integral of log(x)/x**2 from N to inf
+    s += (ONE + logN) // N
+    # E-M step 3: endpoint correction term f(N)/2
+    s += logN // (N**2 * 2)
+    # E-M step 4: the series of derivatives
+    pN = N**3
+    a = 1
+    b = -2
+    j = 3
+    fac = from_int(2)
+    k = 1
+    while 1:
+        # D(2*k-1) * B(2*k) / fac(2*k) [D(n) = nth derivative]
+        D = ((a << wp) + b*logN) // pN
+        D = from_man_exp(D, -wp)
+        B = mpf_bernoulli(2*k, wp)
+        term = mpf_mul(B, D, wp)
+        term = mpf_div(term, fac, wp)
+        term = to_fixed(term, wp)
+        if abs(term) < 100:
+            break
+        #if not k % 10:
+        #    print k, math.log(int(abs(term)), 10)
+        s -= term
+        # Advance derivative twice
+        a, b, pN, j = b-a*j, -j*b, pN*N, j+1
+        a, b, pN, j = b-a*j, -j*b, pN*N, j+1
+        k += 1
+        fac = mpf_mul_int(fac, (2*k)*(2*k-1), wp)
+    # A = exp((6*s/pi**2 + log(2*pi) + euler)/12)
+    pi = pi_fixed(wp)
+    s *= 6
+    s = (s << wp) // (pi**2 >> wp)
+    s += euler_fixed(wp)
+    s += to_fixed(mpf_log(from_man_exp(2*pi, -wp), wp), wp)
+    s //= 12
+    A = mpf_exp(from_man_exp(s, -wp), wp)
+    return to_fixed(A, prec)
+
+# Apery's constant can be computed using the very rapidly convergent
+# series
+#              oo
+#              ___              2                      10
+#             \         n  205 n  + 250 n + 77     (n!)
+#  zeta(3) =   )    (-1)   -------------------  ----------
+#             /___               64                      5
+#             n = 0                             ((2n+1)!)
+
+@constant_memo
+def apery_fixed(prec):
+    prec += 20
+    d = MPZ_ONE << prec
+    term = MPZ(77) << prec
+    n = 1
+    s = MPZ_ZERO
+    while term:
+        s += term
+        d *= (n**10)
+        d //= (((2*n+1)**5) * (2*n)**5)
+        term = (-1)**n * (205*(n**2) + 250*n + 77) * d
+        n += 1
+    return s >> (20 + 6)
+
+"""
+Euler's constant (gamma) is computed using the Brent-McMillan formula,
+gamma ~= I(n)/J(n) - log(n), where
+
+   I(n) = sum_{k=0,1,2,...} (n**k / k!)**2 * H(k)
+   J(n) = sum_{k=0,1,2,...} (n**k / k!)**2
+   H(k) = 1 + 1/2 + 1/3 + ... + 1/k
+
+The error is bounded by O(exp(-4n)). Choosing n to be a power
+of two, 2**p, the logarithm becomes particularly easy to calculate.[1]
+
+We use the formulation of Algorithm 3.9 in [2] to make the summation
+more efficient.
+
+Reference:
+[1] Xavier Gourdon & Pascal Sebah, The Euler constant: gamma
+http://numbers.computation.free.fr/Constants/Gamma/gamma.pdf
+
+[2] [BorweinBailey]_
+"""
+
+@constant_memo
+def euler_fixed(prec):
+    extra = 30
+    prec += extra
+    # choose p such that exp(-4*(2**p)) < 2**-n
+    p = int(math.log((prec/4) * math.log(2), 2)) + 1
+    n = 2**p
+    A = U = -p*ln2_fixed(prec)
+    B = V = MPZ_ONE << prec
+    k = 1
+    while 1:
+        B = B*n**2//k**2
+        A = (A*n**2//k + B)//k
+        U += A
+        V += B
+        if max(abs(A), abs(B)) < 100:
+            break
+        k += 1
+    return (U<<(prec-extra))//V
+
+# Use zeta accelerated formulas for the Mertens and twin
+# prime constants; see
+# http://mathworld.wolfram.com/MertensConstant.html
+# http://mathworld.wolfram.com/TwinPrimesConstant.html
+
+@constant_memo
+def mertens_fixed(prec):
+    wp = prec + 20
+    m = 2
+    s = mpf_euler(wp)
+    while 1:
+        t = mpf_zeta_int(m, wp)
+        if t == fone:
+            break
+        t = mpf_log(t, wp)
+        t = mpf_mul_int(t, moebius(m), wp)
+        t = mpf_div(t, from_int(m), wp)
+        s = mpf_add(s, t)
+        m += 1
+    return to_fixed(s, prec)
+
+@constant_memo
+def twinprime_fixed(prec):
+    def I(n):
+        return sum(moebius(d)<<(n//d) for d in xrange(1,n+1) if not n%d)//n
+    wp = 2*prec + 30
+    res = fone
+    primes = [from_rational(1,p,wp) for p in [2,3,5,7]]
+    ppowers = [mpf_mul(p,p,wp) for p in primes]
+    n = 2
+    while 1:
+        a = mpf_zeta_int(n, wp)
+        for i in range(4):
+            a = mpf_mul(a, mpf_sub(fone, ppowers[i]), wp)
+            ppowers[i] = mpf_mul(ppowers[i], primes[i], wp)
+        a = mpf_pow_int(a, -I(n), wp)
+        if mpf_pos(a, prec+10, 'n') == fone:
+            break
+        #from libmpf import to_str
+        #print n, to_str(mpf_sub(fone, a), 6)
+        res = mpf_mul(res, a, wp)
+        n += 1
+    res = mpf_mul(res, from_int(3*15*35), wp)
+    res = mpf_div(res, from_int(4*16*36), wp)
+    return to_fixed(res, prec)
+
+
+mpf_euler = def_mpf_constant(euler_fixed)
+mpf_apery = def_mpf_constant(apery_fixed)
+mpf_khinchin = def_mpf_constant(khinchin_fixed)
+mpf_glaisher = def_mpf_constant(glaisher_fixed)
+mpf_catalan = def_mpf_constant(catalan_fixed)
+mpf_mertens = def_mpf_constant(mertens_fixed)
+mpf_twinprime = def_mpf_constant(twinprime_fixed)
+
+
+#-----------------------------------------------------------------------#
+#                                                                       #
+#                          Bernoulli numbers                            #
+#                                                                       #
+#-----------------------------------------------------------------------#
+
+MAX_BERNOULLI_CACHE = 3000
+
+
+r"""
+Small Bernoulli numbers and factorials are used in numerous summations,
+so it is critical for speed that sequential computation is fast and that
+values are cached up to a fairly high threshold.
+
+On the other hand, we also want to support fast computation of isolated
+large numbers. Currently, no such acceleration is provided for integer
+factorials (though it is for large floating-point factorials, which are
+computed via gamma if the precision is low enough).
+
+For sequential computation of Bernoulli numbers, we use Ramanujan's formula
+
+                           / n + 3 \
+  B   =  (A(n) - S(n))  /  |       |
+   n                       \   n   /
+
+where A(n) = (n+3)/3 when n = 0 or 2 (mod 6), A(n) = -(n+3)/6
+when n = 4 (mod 6), and
+
+         [n/6]
+          ___
+         \      /  n + 3  \
+  S(n) =  )     |         | * B
+         /___   \ n - 6*k /    n-6*k
+         k = 1
+
+For isolated large Bernoulli numbers, we use the Riemann zeta function
+to calculate a numerical value for B_n. The von Staudt-Clausen theorem
+can then be used to optionally find the exact value of the
+numerator and denominator.
+"""
+
+bernoulli_cache = {}
+f3 = from_int(3)
+f6 = from_int(6)
+
+def bernoulli_size(n):
+    """Accurately estimate the size of B_n (even n > 2 only)"""
+    lgn = math.log(n,2)
+    return int(2.326 + 0.5*lgn + n*(lgn - 4.094))
+
+BERNOULLI_PREC_CUTOFF = bernoulli_size(MAX_BERNOULLI_CACHE)
+
+def mpf_bernoulli(n, prec, rnd=None):
+    """Computation of Bernoulli numbers (numerically)"""
+    if n < 2:
+        if n < 0:
+            raise ValueError("Bernoulli numbers only defined for n >= 0")
+        if n == 0:
+            return fone
+        if n == 1:
+            return mpf_neg(fhalf)
+    # For odd n > 1, the Bernoulli numbers are zero
+    if n & 1:
+        return fzero
+    # If precision is extremely high, we can save time by computing
+    # the Bernoulli number at a lower precision that is sufficient to
+    # obtain the exact fraction, round to the exact fraction, and
+    # convert the fraction back to an mpf value at the original precision
+    if prec > BERNOULLI_PREC_CUTOFF and prec > bernoulli_size(n)*1.1 + 1000:
+        p, q = bernfrac(n)
+        return from_rational(p, q, prec, rnd or round_floor)
+    if n > MAX_BERNOULLI_CACHE:
+        return mpf_bernoulli_huge(n, prec, rnd)
+    wp = prec + 30
+    # Reuse nearby precisions
+    wp += 32 - (prec & 31)
+    cached = bernoulli_cache.get(wp)
+    if cached:
+        numbers, state = cached
+        if n in numbers:
+            if not rnd:
+                return numbers[n]
+            return mpf_pos(numbers[n], prec, rnd)
+        m, bin, bin1 = state
+        if n - m > 10:
+            return mpf_bernoulli_huge(n, prec, rnd)
+    else:
+        if n > 10:
+            return mpf_bernoulli_huge(n, prec, rnd)
+        numbers = {0:fone}
+        m, bin, bin1 = state = [2, MPZ(10), MPZ_ONE]
+        bernoulli_cache[wp] = (numbers, state)
+    while m <= n:
+        #print m
+        case = m % 6
+        # Accurately estimate size of B_m so we can use
+        # fixed point math without using too much precision
+        szbm = bernoulli_size(m)
+        s = 0
+        sexp = max(0, szbm)  - wp
+        if m < 6:
+            a = MPZ_ZERO
+        else:
+            a = bin1
+        for j in xrange(1, m//6+1):
+            usign, uman, uexp, ubc = u = numbers[m-6*j]
+            if usign:
+                uman = -uman
+            s += lshift(a*uman, uexp-sexp)
+            # Update inner binomial coefficient
+            j6 = 6*j
+            a *= ((m-5-j6)*(m-4-j6)*(m-3-j6)*(m-2-j6)*(m-1-j6)*(m-j6))
+            a //= ((4+j6)*(5+j6)*(6+j6)*(7+j6)*(8+j6)*(9+j6))
+        if case == 0: b = mpf_rdiv_int(m+3, f3, wp)
+        if case == 2: b = mpf_rdiv_int(m+3, f3, wp)
+        if case == 4: b = mpf_rdiv_int(-m-3, f6, wp)
+        s = from_man_exp(s, sexp, wp)
+        b = mpf_div(mpf_sub(b, s, wp), from_int(bin), wp)
+        numbers[m] = b
+        m += 2
+        # Update outer binomial coefficient
+        bin = bin * ((m+2)*(m+3)) // (m*(m-1))
+        if m > 6:
+            bin1 = bin1 * ((2+m)*(3+m)) // ((m-7)*(m-6))
+        state[:] = [m, bin, bin1]
+    return numbers[n]
+
+def mpf_bernoulli_huge(n, prec, rnd=None):
+    wp = prec + 10
+    piprec = wp + int(math.log(n,2))
+    v = mpf_gamma_int(n+1, wp)
+    v = mpf_mul(v, mpf_zeta_int(n, wp), wp)
+    v = mpf_mul(v, mpf_pow_int(mpf_pi(piprec), -n, wp))
+    v = mpf_shift(v, 1-n)
+    if not n & 3:
+        v = mpf_neg(v)
+    return mpf_pos(v, prec, rnd or round_fast)
+
+def bernfrac(n):
+    r"""
+    Returns a tuple of integers `(p, q)` such that `p/q = B_n` exactly,
+    where `B_n` denotes the `n`-th Bernoulli number. The fraction is
+    always reduced to lowest terms. Note that for `n > 1` and `n` odd,
+    `B_n = 0`, and `(0, 1)` is returned.
+
+    **Examples**
+
+    The first few Bernoulli numbers are exactly::
+
+        >>> from mpmath import *
+        >>> for n in range(15):
+        ...     p, q = bernfrac(n)
+        ...     print("%s %s/%s" % (n, p, q))
+        ...
+        0 1/1
+        1 -1/2
+        2 1/6
+        3 0/1
+        4 -1/30
+        5 0/1
+        6 1/42
+        7 0/1
+        8 -1/30
+        9 0/1
+        10 5/66
+        11 0/1
+        12 -691/2730
+        13 0/1
+        14 7/6
+
+    This function works for arbitrarily large `n`::
+
+        >>> p, q = bernfrac(10**4)
+        >>> print(q)
+        2338224387510
+        >>> print(len(str(p)))
+        27692
+        >>> mp.dps = 15
+        >>> print(mpf(p) / q)
+        -9.04942396360948e+27677
+        >>> print(bernoulli(10**4))
+        -9.04942396360948e+27677
+
+    .. note ::
+
+        :func:`~mpmath.bernoulli` computes a floating-point approximation
+        directly, without computing the exact fraction first.
+        This is much faster for large `n`.
+
+    **Algorithm**
+
+    :func:`~mpmath.bernfrac` works by computing the value of `B_n` numerically
+    and then using the von Staudt-Clausen theorem [1] to reconstruct
+    the exact fraction. For large `n`, this is significantly faster than
+    computing `B_1, B_2, \ldots, B_2` recursively with exact arithmetic.
+    The implementation has been tested for `n = 10^m` up to `m = 6`.
+
+    In practice, :func:`~mpmath.bernfrac` appears to be about three times
+    slower than the specialized program calcbn.exe [2]
+
+    **References**
+
+    1. MathWorld, von Staudt-Clausen Theorem:
+       http://mathworld.wolfram.com/vonStaudt-ClausenTheorem.html
+
+    2. The Bernoulli Number Page:
+       http://www.bernoulli.org/
+
+    """
+    n = int(n)
+    if n < 3:
+        return [(1, 1), (-1, 2), (1, 6)][n]
+    if n & 1:
+        return (0, 1)
+    q = 1
+    for k in list_primes(n+1):
+        if not (n % (k-1)):
+            q *= k
+    prec = bernoulli_size(n) + int(math.log(q,2)) + 20
+    b = mpf_bernoulli(n, prec)
+    p = mpf_mul(b, from_int(q))
+    pint = to_int(p, round_nearest)
+    return (pint, q)
+
+
+#-----------------------------------------------------------------------#
+#                                                                       #
+#                         Polygamma functions                           #
+#                                                                       #
+#-----------------------------------------------------------------------#
+
+r"""
+For all polygamma (psi) functions, we use the Euler-Maclaurin summation
+formula. It looks slightly different in the m = 0 and m > 0 cases.
+
+For m = 0, we have
+                                 oo
+                                ___   B
+       (0)                1    \       2 k    -2 k
+    psi   (z)  ~ log z + --- -  )    ------  z
+                         2 z   /___  (2 k)!
+                               k = 1
+
+Experiment shows that the minimum term of the asymptotic series
+reaches 2^(-p) when Re(z) > 0.11*p. So we simply use the recurrence
+for psi (equivalent, in fact, to summing to the first few terms
+directly before applying E-M) to obtain z large enough.
+
+Since, very crudely, log z ~= 1 for Re(z) > 1, we can use
+fixed-point arithmetic  (if z is extremely large, log(z) itself
+is a sufficient approximation, so we can stop there already).
+
+For Re(z) << 0, we could use recurrence, but this is of course
+inefficient for large negative z, so there we use the
+reflection formula instead.
+
+For m > 0, we have
+
+                  N - 1
+                   ___
+  ~~~(m)       [  \          1    ]         1            1
+  psi   (z)  ~ [   )     -------- ] +  ---------- +  -------- +
+               [  /___        m+1 ]           m+1           m
+                  k = 1  (z+k)    ]    2 (z+N)       m (z+N)
+
+      oo
+     ___    B
+    \        2 k   (m+1) (m+2) ... (m+2k-1)
+  +  )     ------  ------------------------
+    /___   (2 k)!            m + 2 k
+    k = 1               (z+N)
+
+where ~~~ denotes the function rescaled by 1/((-1)^(m+1) m!).
+
+Here again N is chosen to make z+N large enough for the minimum
+term in the last series to become smaller than eps.
+
+TODO: the current estimation of N for m > 0 is *very suboptimal*.
+
+TODO: implement the reflection formula for m > 0, Re(z) << 0.
+It is generally a combination of multiple cotangents. Need to
+figure out a reasonably simple way to generate these formulas
+on the fly.
+
+TODO: maybe use exact algorithms to compute psi for integral
+and certain rational arguments, as this can be much more
+efficient. (On the other hand, the availability of these
+special values provides a convenient way to test the general
+algorithm.)
+"""
+
+# Harmonic numbers are just shifted digamma functions
+# We should calculate these exactly when x is an integer
+# and when doing so is faster.
+
+def mpf_harmonic(x, prec, rnd):
+    if x in (fzero, fnan, finf):
+        return x
+    a = mpf_psi0(mpf_add(fone, x, prec+5), prec)
+    return mpf_add(a, mpf_euler(prec+5, rnd), prec, rnd)
+
+def mpc_harmonic(z, prec, rnd):
+    if z[1] == fzero:
+        return (mpf_harmonic(z[0], prec, rnd), fzero)
+    a = mpc_psi0(mpc_add_mpf(z, fone, prec+5), prec)
+    return mpc_add_mpf(a, mpf_euler(prec+5, rnd), prec, rnd)
+
+def mpf_psi0(x, prec, rnd=round_fast):
+    """
+    Computation of the digamma function (psi function of order 0)
+    of a real argument.
+    """
+    sign, man, exp, bc = x
+    wp = prec + 10
+    if not man:
+        if x == finf: return x
+        if x == fninf or x == fnan: return fnan
+    if x == fzero or (exp >= 0 and sign):
+        raise ValueError("polygamma pole")
+    # Near 0 -- fixed-point arithmetic becomes bad
+    if exp+bc < -5:
+        v = mpf_psi0(mpf_add(x, fone, prec, rnd), prec, rnd)
+        return mpf_sub(v, mpf_div(fone, x, wp, rnd), prec, rnd)
+    # Reflection formula
+    if sign and exp+bc > 3:
+        c, s = mpf_cos_sin_pi(x, wp)
+        q = mpf_mul(mpf_div(c, s, wp), mpf_pi(wp), wp)
+        p = mpf_psi0(mpf_sub(fone, x, wp), wp)
+        return mpf_sub(p, q, prec, rnd)
+    # The logarithmic term is accurate enough
+    if (not sign) and bc + exp > wp:
+        return mpf_log(mpf_sub(x, fone, wp), prec, rnd)
+    # Initial recurrence to obtain a large enough x
+    m = to_int(x)
+    n = int(0.11*wp) + 2
+    s = MPZ_ZERO
+    x = to_fixed(x, wp)
+    one = MPZ_ONE << wp
+    if m < n:
+        for k in xrange(m, n):
+            s -= (one << wp) // x
+            x += one
+    x -= one
+    # Logarithmic term
+    s += to_fixed(mpf_log(from_man_exp(x, -wp, wp), wp), wp)
+    # Endpoint term in Euler-Maclaurin expansion
+    s += (one << wp) // (2*x)
+    # Euler-Maclaurin remainder sum
+    x2 = (x*x) >> wp
+    t = one
+    prev = 0
+    k = 1
+    while 1:
+        t = (t*x2) >> wp
+        bsign, bman, bexp, bbc = mpf_bernoulli(2*k, wp)
+        offset = (bexp + 2*wp)
+        if offset >= 0: term = (bman << offset) // (t*(2*k))
+        else:           term = (bman >> (-offset)) // (t*(2*k))
+        if k & 1: s -= term
+        else:     s += term
+        if k > 2 and term >= prev:
+            break
+        prev = term
+        k += 1
+    return from_man_exp(s, -wp, wp, rnd)
+
+def mpc_psi0(z, prec, rnd=round_fast):
+    """
+    Computation of the digamma function (psi function of order 0)
+    of a complex argument.
+    """
+    re, im = z
+    # Fall back to the real case
+    if im == fzero:
+        return (mpf_psi0(re, prec, rnd), fzero)
+    wp = prec + 20
+    sign, man, exp, bc = re
+    # Reflection formula
+    if sign and exp+bc > 3:
+        c = mpc_cos_pi(z, wp)
+        s = mpc_sin_pi(z, wp)
+        q = mpc_mul_mpf(mpc_div(c, s, wp), mpf_pi(wp), wp)
+        p = mpc_psi0(mpc_sub(mpc_one, z, wp), wp)
+        return mpc_sub(p, q, prec, rnd)
+    # Just the logarithmic term
+    if (not sign) and bc + exp > wp:
+        return mpc_log(mpc_sub(z, mpc_one, wp), prec, rnd)
+    # Initial recurrence to obtain a large enough z
+    w = to_int(re)
+    n = int(0.11*wp) + 2
+    s = mpc_zero
+    if w < n:
+        for k in xrange(w, n):
+            s = mpc_sub(s, mpc_reciprocal(z, wp), wp)
+            z = mpc_add_mpf(z, fone, wp)
+    z = mpc_sub(z, mpc_one, wp)
+    # Logarithmic and endpoint term
+    s = mpc_add(s, mpc_log(z, wp), wp)
+    s = mpc_add(s, mpc_div(mpc_half, z, wp), wp)
+    # Euler-Maclaurin remainder sum
+    z2 = mpc_square(z, wp)
+    t = mpc_one
+    prev = mpc_zero
+    szprev = fzero
+    k = 1
+    eps = mpf_shift(fone, -wp+2)
+    while 1:
+        t = mpc_mul(t, z2, wp)
+        bern = mpf_bernoulli(2*k, wp)
+        term = mpc_mpf_div(bern, mpc_mul_int(t, 2*k, wp), wp)
+        s = mpc_sub(s, term, wp)
+        szterm = mpc_abs(term, 10)
+        if k > 2 and (mpf_le(szterm, eps) or mpf_le(szprev, szterm)):
+            break
+        prev = term
+        szprev = szterm
+        k += 1
+    return s
+
+# Currently unoptimized
+def mpf_psi(m, x, prec, rnd=round_fast):
+    """
+    Computation of the polygamma function of arbitrary integer order
+    m >= 0, for a real argument x.
+    """
+    if m == 0:
+        return mpf_psi0(x, prec, rnd=round_fast)
+    return mpc_psi(m, (x, fzero), prec, rnd)[0]
+
+def mpc_psi(m, z, prec, rnd=round_fast):
+    """
+    Computation of the polygamma function of arbitrary integer order
+    m >= 0, for a complex argument z.
+    """
+    if m == 0:
+        return mpc_psi0(z, prec, rnd)
+    re, im = z
+    wp = prec + 20
+    sign, man, exp, bc = re
+    if not im[1]:
+        if im in (finf, fninf, fnan):
+            return (fnan, fnan)
+    if not man:
+        if re == finf and im == fzero:
+            return (fzero, fzero)
+        if re == fnan:
+            return (fnan, fnan)
+    # Recurrence
+    w = to_int(re)
+    n = int(0.4*wp + 4*m)
+    s = mpc_zero
+    if w < n:
+        for k in xrange(w, n):
+            t = mpc_pow_int(z, -m-1, wp)
+            s = mpc_add(s, t, wp)
+            z = mpc_add_mpf(z, fone, wp)
+    zm = mpc_pow_int(z, -m, wp)
+    z2 = mpc_pow_int(z, -2, wp)
+    # 1/m*(z+N)^m
+    integral_term = mpc_div_mpf(zm, from_int(m), wp)
+    s = mpc_add(s, integral_term, wp)
+    # 1/2*(z+N)^(-(m+1))
+    s = mpc_add(s, mpc_mul_mpf(mpc_div(zm, z, wp), fhalf, wp), wp)
+    a = m + 1
+    b = 2
+    k = 1
+    # Important: we want to sum up to the *relative* error,
+    # not the absolute error, because psi^(m)(z) might be tiny
+    magn = mpc_abs(s, 10)
+    magn = magn[2]+magn[3]
+    eps = mpf_shift(fone, magn-wp+2)
+    while 1:
+        zm = mpc_mul(zm, z2, wp)
+        bern = mpf_bernoulli(2*k, wp)
+        scal = mpf_mul_int(bern, a, wp)
+        scal = mpf_div(scal, from_int(b), wp)
+        term = mpc_mul_mpf(zm, scal, wp)
+        s = mpc_add(s, term, wp)
+        szterm = mpc_abs(term, 10)
+        if k > 2 and mpf_le(szterm, eps):
+            break
+        #print k, to_str(szterm, 10), to_str(eps, 10)
+        a *= (m+2*k)*(m+2*k+1)
+        b *= (2*k+1)*(2*k+2)
+        k += 1
+    # Scale and sign factor
+    v = mpc_mul_mpf(s, mpf_gamma(from_int(m+1), wp), prec, rnd)
+    if not (m & 1):
+        v = mpf_neg(v[0]), mpf_neg(v[1])
+    return v
+
+
+#-----------------------------------------------------------------------#
+#                                                                       #
+#                         Riemann zeta function                         #
+#                                                                       #
+#-----------------------------------------------------------------------#
+
+r"""
+We use zeta(s) = eta(s) / (1 - 2**(1-s)) and Borwein's approximation
+
+                  n-1
+                  ___       k
+             -1  \      (-1)  (d_k - d_n)
+  eta(s) ~= ----  )     ------------------
+             d_n /___              s
+                 k = 0      (k + 1)
+where
+             k
+             ___                i
+            \     (n + i - 1)! 4
+  d_k  =  n  )    ---------------.
+            /___   (n - i)! (2i)!
+            i = 0
+
+If s = a + b*I, the absolute error for eta(s) is bounded by
+
+    3 (1 + 2|b|)
+    ------------ * exp(|b| pi/2)
+               n
+    (3+sqrt(8))
+
+Disregarding the linear term, we have approximately,
+
+  log(err) ~= log(exp(1.58*|b|)) - log(5.8**n)
+  log(err) ~= 1.58*|b| - log(5.8)*n
+  log(err) ~= 1.58*|b| - 1.76*n
+  log2(err) ~= 2.28*|b| - 2.54*n
+
+So for p bits, we should choose n > (p + 2.28*|b|) / 2.54.
+
+References:
+-----------
+
+Peter Borwein, "An Efficient Algorithm for the Riemann Zeta Function"
+http://www.cecm.sfu.ca/personal/pborwein/PAPERS/P117.ps
+
+http://en.wikipedia.org/wiki/Dirichlet_eta_function
+"""
+
+borwein_cache = {}
+
+def borwein_coefficients(n):
+    if n in borwein_cache:
+        return borwein_cache[n]
+    ds = [MPZ_ZERO] * (n+1)
+    d = MPZ_ONE
+    s = ds[0] = MPZ_ONE
+    for i in range(1, n+1):
+        d = d * 4 * (n+i-1) * (n-i+1)
+        d //= ((2*i) * ((2*i)-1))
+        s += d
+        ds[i] = s
+    borwein_cache[n] = ds
+    return ds
+
+ZETA_INT_CACHE_MAX_PREC = 1000
+zeta_int_cache = {}
+
+def mpf_zeta_int(s, prec, rnd=round_fast):
+    """
+    Optimized computation of zeta(s) for an integer s.
+    """
+    wp = prec + 20
+    s = int(s)
+    if s in zeta_int_cache and zeta_int_cache[s][0] >= wp:
+        return mpf_pos(zeta_int_cache[s][1], prec, rnd)
+    if s < 2:
+        if s == 1:
+            raise ValueError("zeta(1) pole")
+        if not s:
+            return mpf_neg(fhalf)
+        return mpf_div(mpf_bernoulli(-s+1, wp), from_int(s-1), prec, rnd)
+    # 2^-s term vanishes?
+    if s >= wp:
+        return mpf_perturb(fone, 0, prec, rnd)
+    # 5^-s term vanishes?
+    elif s >= wp*0.431:
+        t = one = 1 << wp
+        t += 1 << (wp - s)
+        t += one // (MPZ_THREE ** s)
+        t += 1 << max(0, wp - s*2)
+        return from_man_exp(t, -wp, prec, rnd)
+    else:
+        # Fast enough to sum directly?
+        # Even better, we use the Euler product (idea stolen from pari)
+        m = (float(wp)/(s-1) + 1)
+        if m < 30:
+            needed_terms = int(2.0**m + 1)
+            if needed_terms < int(wp/2.54 + 5) / 10:
+                t = fone
+                for k in list_primes(needed_terms):
+                    #print k, needed_terms
+                    powprec = int(wp - s*math.log(k,2))
+                    if powprec < 2:
+                        break
+                    a = mpf_sub(fone, mpf_pow_int(from_int(k), -s, powprec), wp)
+                    t = mpf_mul(t, a, wp)
+                return mpf_div(fone, t, wp)
+    # Use Borwein's algorithm
+    n = int(wp/2.54 + 5)
+    d = borwein_coefficients(n)
+    t = MPZ_ZERO
+    s = MPZ(s)
+    for k in xrange(n):
+        t += (((-1)**k * (d[k] - d[n])) << wp) // (k+1)**s
+    t = (t << wp) // (-d[n])
+    t = (t << wp) // ((1 << wp) - (1 << (wp+1-s)))
+    if (s in zeta_int_cache and zeta_int_cache[s][0] < wp) or (s not in zeta_int_cache):
+        zeta_int_cache[s] = (wp, from_man_exp(t, -wp-wp))
+    return from_man_exp(t, -wp-wp, prec, rnd)
+
+def mpf_zeta(s, prec, rnd=round_fast, alt=0):
+    sign, man, exp, bc = s
+    if not man:
+        if s == fzero:
+            if alt:
+                return fhalf
+            else:
+                return mpf_neg(fhalf)
+        if s == finf:
+            return fone
+        return fnan
+    wp = prec + 20
+    # First term vanishes?
+    if (not sign) and (exp + bc > (math.log(wp,2) + 2)):
+        return mpf_perturb(fone, alt, prec, rnd)
+    # Optimize for integer arguments
+    elif exp >= 0:
+        if alt:
+            if s == fone:
+                return mpf_ln2(prec, rnd)
+            z = mpf_zeta_int(to_int(s), wp, negative_rnd[rnd])
+            q = mpf_sub(fone, mpf_pow(ftwo, mpf_sub(fone, s, wp), wp), wp)
+            return mpf_mul(z, q, prec, rnd)
+        else:
+            return mpf_zeta_int(to_int(s), prec, rnd)
+    # Negative: use the reflection formula
+    # Borwein only proves the accuracy bound for x >= 1/2. However, based on
+    # tests, the accuracy without reflection is quite good even some distance
+    # to the left of 1/2. XXX: verify this.
+    if sign:
+        # XXX: could use the separate refl. formula for Dirichlet eta
+        if alt:
+            q = mpf_sub(fone, mpf_pow(ftwo, mpf_sub(fone, s, wp), wp), wp)
+            return mpf_mul(mpf_zeta(s, wp), q, prec, rnd)
+        # XXX: -1 should be done exactly
+        y = mpf_sub(fone, s, 10*wp)
+        a = mpf_gamma(y, wp)
+        b = mpf_zeta(y, wp)
+        c = mpf_sin_pi(mpf_shift(s, -1), wp)
+        wp2 = wp + max(0,exp+bc)
+        pi = mpf_pi(wp+wp2)
+        d = mpf_div(mpf_pow(mpf_shift(pi, 1), s, wp2), pi, wp2)
+        return mpf_mul(a,mpf_mul(b,mpf_mul(c,d,wp),wp),prec,rnd)
+
+    # Near pole
+    r = mpf_sub(fone, s, wp)
+    asign, aman, aexp, abc = mpf_abs(r)
+    pole_dist = -2*(aexp+abc)
+    if pole_dist > wp:
+        if alt:
+            return mpf_ln2(prec, rnd)
+        else:
+            q = mpf_neg(mpf_div(fone, r, wp))
+            return mpf_add(q, mpf_euler(wp), prec, rnd)
+    else:
+        wp += max(0, pole_dist)
+
+    t = MPZ_ZERO
+    #wp += 16 - (prec & 15)
+    # Use Borwein's algorithm
+    n = int(wp/2.54 + 5)
+    d = borwein_coefficients(n)
+    t = MPZ_ZERO
+    sf = to_fixed(s, wp)
+    ln2 = ln2_fixed(wp)
+    for k in xrange(n):
+        u = (-sf*log_int_fixed(k+1, wp, ln2)) >> wp
+        #esign, eman, eexp, ebc = mpf_exp(u, wp)
+        #offset = eexp + wp
+        #if offset >= 0:
+        #    w = ((d[k] - d[n]) * eman) << offset
+        #else:
+        #    w = ((d[k] - d[n]) * eman) >> (-offset)
+        eman = exp_fixed(u, wp, ln2)
+        w = (d[k] - d[n]) * eman
+        if k & 1:
+            t -= w
+        else:
+            t += w
+    t = t // (-d[n])
+    t = from_man_exp(t, -wp, wp)
+    if alt:
+        return mpf_pos(t, prec, rnd)
+    else:
+        q = mpf_sub(fone, mpf_pow(ftwo, mpf_sub(fone, s, wp), wp), wp)
+        return mpf_div(t, q, prec, rnd)
+
+def mpc_zeta(s, prec, rnd=round_fast, alt=0, force=False):
+    re, im = s
+    if im == fzero:
+        return mpf_zeta(re, prec, rnd, alt), fzero
+
+    # slow for large s
+    if (not force) and mpf_gt(mpc_abs(s, 10), from_int(prec)):
+        raise NotImplementedError
+
+    wp = prec + 20
+
+    # Near pole
+    r = mpc_sub(mpc_one, s, wp)
+    asign, aman, aexp, abc = mpc_abs(r, 10)
+    pole_dist = -2*(aexp+abc)
+    if pole_dist > wp:
+        if alt:
+            q = mpf_ln2(wp)
+            y = mpf_mul(q, mpf_euler(wp), wp)
+            g = mpf_shift(mpf_mul(q, q, wp), -1)
+            g = mpf_sub(y, g)
+            z = mpc_mul_mpf(r, mpf_neg(g), wp)
+            z = mpc_add_mpf(z, q, wp)
+            return mpc_pos(z, prec, rnd)
+        else:
+            q = mpc_neg(mpc_div(mpc_one, r, wp))
+            q = mpc_add_mpf(q, mpf_euler(wp), wp)
+            return mpc_pos(q, prec, rnd)
+    else:
+        wp += max(0, pole_dist)
+
+    # Reflection formula. To be rigorous, we should reflect to the left of
+    # re = 1/2 (see comments for mpf_zeta), but this leads to unnecessary
+    # slowdown for interesting values of s
+    if mpf_lt(re, fzero):
+        # XXX: could use the separate refl. formula for Dirichlet eta
+        if alt:
+            q = mpc_sub(mpc_one, mpc_pow(mpc_two, mpc_sub(mpc_one, s, wp),
+                wp), wp)
+            return mpc_mul(mpc_zeta(s, wp), q, prec, rnd)
+        # XXX: -1 should be done exactly
+        y = mpc_sub(mpc_one, s, 10*wp)
+        a = mpc_gamma(y, wp)
+        b = mpc_zeta(y, wp)
+        c = mpc_sin_pi(mpc_shift(s, -1), wp)
+        rsign, rman, rexp, rbc = re
+        isign, iman, iexp, ibc = im
+        mag = max(rexp+rbc, iexp+ibc)
+        wp2 = wp + max(0, mag)
+        pi = mpf_pi(wp+wp2)
+        pi2 = (mpf_shift(pi, 1), fzero)
+        d = mpc_div_mpf(mpc_pow(pi2, s, wp2), pi, wp2)
+        return mpc_mul(a,mpc_mul(b,mpc_mul(c,d,wp),wp),prec,rnd)
+    n = int(wp/2.54 + 5)
+    n += int(0.9*abs(to_int(im)))
+    d = borwein_coefficients(n)
+    ref = to_fixed(re, wp)
+    imf = to_fixed(im, wp)
+    tre = MPZ_ZERO
+    tim = MPZ_ZERO
+    one = MPZ_ONE << wp
+    one_2wp = MPZ_ONE << (2*wp)
+    critical_line = re == fhalf
+    ln2 = ln2_fixed(wp)
+    pi2 = pi_fixed(wp-1)
+    wp2 = wp+wp
+    for k in xrange(n):
+        log = log_int_fixed(k+1, wp, ln2)
+        # A square root is much cheaper than an exp
+        if critical_line:
+            w = one_2wp // isqrt_fast((k+1) << wp2)
+        else:
+            w = exp_fixed((-ref*log) >> wp, wp)
+        if k & 1:
+            w *= (d[n] - d[k])
+        else:
+            w *= (d[k] - d[n])
+        wre, wim = cos_sin_fixed((-imf*log)>>wp, wp, pi2)
+        tre += (w * wre) >> wp
+        tim += (w * wim) >> wp
+    tre //= (-d[n])
+    tim //= (-d[n])
+    tre = from_man_exp(tre, -wp, wp)
+    tim = from_man_exp(tim, -wp, wp)
+    if alt:
+        return mpc_pos((tre, tim), prec, rnd)
+    else:
+        q = mpc_sub(mpc_one, mpc_pow(mpc_two, r, wp), wp)
+        return mpc_div((tre, tim), q, prec, rnd)
+
+def mpf_altzeta(s, prec, rnd=round_fast):
+    return mpf_zeta(s, prec, rnd, 1)
+
+def mpc_altzeta(s, prec, rnd=round_fast):
+    return mpc_zeta(s, prec, rnd, 1)
+
+# Not optimized currently
+mpf_zetasum = None
+
+
+def pow_fixed(x, n, wp):
+    if n == 1:
+        return x
+    y = MPZ_ONE << wp
+    while n:
+        if n & 1:
+            y = (y*x) >> wp
+            n -= 1
+        x = (x*x) >> wp
+        n //= 2
+    return y
+
+# TODO: optimize / cleanup interface / unify with list_primes
+sieve_cache = []
+primes_cache = []
+mult_cache = []
+
+def primesieve(n):
+    global sieve_cache, primes_cache, mult_cache
+    if n < len(sieve_cache):
+        sieve = sieve_cache#[:n+1]
+        primes = primes_cache[:primes_cache.index(max(sieve))+1]
+        mult = mult_cache#[:n+1]
+        return sieve, primes, mult
+    sieve = [0] * (n+1)
+    mult = [0] * (n+1)
+    primes = list_primes(n)
+    for p in primes:
+        #sieve[p::p] = p
+        for k in xrange(p,n+1,p):
+            sieve[k] = p
+    for i, p in enumerate(sieve):
+        if i >= 2:
+            m = 1
+            n = i // p
+            while not n % p:
+                n //= p
+                m += 1
+            mult[i] = m
+    sieve_cache = sieve
+    primes_cache = primes
+    mult_cache = mult
+    return sieve, primes, mult
+
+def zetasum_sieved(critical_line, sre, sim, a, n, wp):
+    if a < 1:
+        raise ValueError("a cannot be less than 1")
+    sieve, primes, mult = primesieve(a+n)
+    basic_powers = {}
+    one = MPZ_ONE << wp
+    one_2wp = MPZ_ONE << (2*wp)
+    wp2 = wp+wp
+    ln2 = ln2_fixed(wp)
+    pi2 = pi_fixed(wp-1)
+    for p in primes:
+        if p*2 > a+n:
+            break
+        log = log_int_fixed(p, wp, ln2)
+        cos, sin = cos_sin_fixed((-sim*log)>>wp, wp, pi2)
+        if critical_line:
+            u = one_2wp // isqrt_fast(p<<wp2)
+        else:
+            u = exp_fixed((-sre*log)>>wp, wp)
+        pre = (u*cos) >> wp
+        pim = (u*sin) >> wp
+        basic_powers[p] = [(pre, pim)]
+        tre, tim = pre, pim
+        for m in range(1,int(math.log(a+n,p)+0.01)+1):
+            tre, tim = ((pre*tre-pim*tim)>>wp), ((pim*tre+pre*tim)>>wp)
+            basic_powers[p].append((tre,tim))
+    xre = MPZ_ZERO
+    xim = MPZ_ZERO
+    if a == 1:
+        xre += one
+    aa = max(a,2)
+    for k in xrange(aa, a+n+1):
+        p = sieve[k]
+        if p in basic_powers:
+            m = mult[k]
+            tre, tim = basic_powers[p][m-1]
+            while 1:
+                k //= p**m
+                if k == 1:
+                    break
+                p = sieve[k]
+                m = mult[k]
+                pre, pim = basic_powers[p][m-1]
+                tre, tim = ((pre*tre-pim*tim)>>wp), ((pim*tre+pre*tim)>>wp)
+        else:
+            log = log_int_fixed(k, wp, ln2)
+            cos, sin = cos_sin_fixed((-sim*log)>>wp, wp, pi2)
+            if critical_line:
+                u = one_2wp // isqrt_fast(k<<wp2)
+            else:
+                u = exp_fixed((-sre*log)>>wp, wp)
+            tre = (u*cos) >> wp
+            tim = (u*sin) >> wp
+        xre += tre
+        xim += tim
+    return xre, xim
+
+# Set to something large to disable
+ZETASUM_SIEVE_CUTOFF = 10
+
+def mpc_zetasum(s, a, n, derivatives, reflect, prec):
+    """
+    Fast version of mp._zetasum, assuming s = complex, a = integer.
+    """
+
+    wp = prec + 10
+    derivatives = list(derivatives)
+    have_derivatives = derivatives != [0]
+    have_one_derivative = len(derivatives) == 1
+
+    # parse s
+    sre, sim = s
+    critical_line = (sre == fhalf)
+    sre = to_fixed(sre, wp)
+    sim = to_fixed(sim, wp)
+
+    if a > 0 and n > ZETASUM_SIEVE_CUTOFF and not have_derivatives \
+            and not reflect and (n < 4e7 or sys.maxsize > 2**32):
+        re, im = zetasum_sieved(critical_line, sre, sim, a, n, wp)
+        xs = [(from_man_exp(re, -wp, prec, 'n'), from_man_exp(im, -wp, prec, 'n'))]
+        return xs, []
+
+    maxd = max(derivatives)
+    if not have_one_derivative:
+        derivatives = range(maxd+1)
+
+    # x_d = 0, y_d = 0
+    xre = [MPZ_ZERO for d in derivatives]
+    xim = [MPZ_ZERO for d in derivatives]
+    if reflect:
+        yre = [MPZ_ZERO for d in derivatives]
+        yim = [MPZ_ZERO for d in derivatives]
+    else:
+        yre = yim = []
+
+    one = MPZ_ONE << wp
+    one_2wp = MPZ_ONE << (2*wp)
+
+    ln2 = ln2_fixed(wp)
+    pi2 = pi_fixed(wp-1)
+    wp2 = wp+wp
+
+    for w in xrange(a, a+n+1):
+        log = log_int_fixed(w, wp, ln2)
+        cos, sin = cos_sin_fixed((-sim*log)>>wp, wp, pi2)
+        if critical_line:
+            u = one_2wp // isqrt_fast(w<<wp2)
+        else:
+            u = exp_fixed((-sre*log)>>wp, wp)
+        xterm_re = (u * cos) >> wp
+        xterm_im = (u * sin) >> wp
+        if reflect:
+            reciprocal = (one_2wp // (u*w))
+            yterm_re = (reciprocal * cos) >> wp
+            yterm_im = (reciprocal * sin) >> wp
+
+        if have_derivatives:
+            if have_one_derivative:
+                log = pow_fixed(log, maxd, wp)
+                xre[0] += (xterm_re * log) >> wp
+                xim[0] += (xterm_im * log) >> wp
+                if reflect:
+                    yre[0] += (yterm_re * log) >> wp
+                    yim[0] += (yterm_im * log) >> wp
+            else:
+                t = MPZ_ONE << wp
+                for d in derivatives:
+                    xre[d] += (xterm_re * t) >> wp
+                    xim[d] += (xterm_im * t) >> wp
+                    if reflect:
+                        yre[d] += (yterm_re * t) >> wp
+                        yim[d] += (yterm_im * t) >> wp
+                    t = (t * log) >> wp
+        else:
+            xre[0] += xterm_re
+            xim[0] += xterm_im
+            if reflect:
+                yre[0] += yterm_re
+                yim[0] += yterm_im
+    if have_derivatives:
+        if have_one_derivative:
+            if maxd % 2:
+                xre[0] = -xre[0]
+                xim[0] = -xim[0]
+                if reflect:
+                    yre[0] = -yre[0]
+                    yim[0] = -yim[0]
+        else:
+            xre = [(-1)**d * xre[d] for d in derivatives]
+            xim = [(-1)**d * xim[d] for d in derivatives]
+            if reflect:
+                yre = [(-1)**d * yre[d] for d in derivatives]
+                yim = [(-1)**d * yim[d] for d in derivatives]
+    xs = [(from_man_exp(xa, -wp, prec, 'n'), from_man_exp(xb, -wp, prec, 'n'))
+        for (xa, xb) in zip(xre, xim)]
+    ys = [(from_man_exp(ya, -wp, prec, 'n'), from_man_exp(yb, -wp, prec, 'n'))
+        for (ya, yb) in zip(yre, yim)]
+    return xs, ys
+
+
+#-----------------------------------------------------------------------#
+#                                                                       #
+#              The gamma function  (NEW IMPLEMENTATION)                 #
+#                                                                       #
+#-----------------------------------------------------------------------#
+
+# Higher means faster, but more precomputation time
+MAX_GAMMA_TAYLOR_PREC = 5000
+# Need to derive higher bounds for Taylor series to go higher
+assert MAX_GAMMA_TAYLOR_PREC < 15000
+
+# Use Stirling's series if abs(x) > beta*prec
+# Important: must be large enough for convergence!
+GAMMA_STIRLING_BETA = 0.2
+
+SMALL_FACTORIAL_CACHE_SIZE = 150
+
+gamma_taylor_cache = {}
+gamma_stirling_cache = {}
+
+small_factorial_cache = [from_int(ifac(n)) for \
+    n in range(SMALL_FACTORIAL_CACHE_SIZE+1)]
+
+def zeta_array(N, prec):
+    """
+    zeta(n) = A * pi**n / n! + B
+
+    where A is a rational number (A = Bernoulli number
+    for n even) and B is an infinite sum over powers of exp(2*pi).
+    (B = 0 for n even).
+
+    TODO: this is currently only used for gamma, but could
+    be very useful elsewhere.
+    """
+    extra = 30
+    wp = prec+extra
+    zeta_values = [MPZ_ZERO] * (N+2)
+    pi = pi_fixed(wp)
+    # STEP 1:
+    one = MPZ_ONE << wp
+    zeta_values[0] = -one//2
+    f_2pi = mpf_shift(mpf_pi(wp),1)
+    exp_2pi_k = exp_2pi = mpf_exp(f_2pi, wp)
+    # Compute exponential series
+    # Store values of 1/(exp(2*pi*k)-1),
+    # exp(2*pi*k)/(exp(2*pi*k)-1)**2, 1/(exp(2*pi*k)-1)**2
+    # pi*k*exp(2*pi*k)/(exp(2*pi*k)-1)**2
+    exps3 = []
+    k = 1
+    while 1:
+        tp = wp - 9*k
+        if tp < 1:
+            break
+        # 1/(exp(2*pi*k-1)
+        q1 = mpf_div(fone, mpf_sub(exp_2pi_k, fone, tp), tp)
+        # pi*k*exp(2*pi*k)/(exp(2*pi*k)-1)**2
+        q2 = mpf_mul(exp_2pi_k, mpf_mul(q1,q1,tp), tp)
+        q1 = to_fixed(q1, wp)
+        q2 = to_fixed(q2, wp)
+        q2 = (k * q2 * pi) >> wp
+        exps3.append((q1, q2))
+        # Multiply for next round
+        exp_2pi_k = mpf_mul(exp_2pi_k, exp_2pi, wp)
+        k += 1
+    # Exponential sum
+    for n in xrange(3, N+1, 2):
+        s = MPZ_ZERO
+        k = 1
+        for e1, e2 in exps3:
+            if n%4 == 3:
+                t = e1 // k**n
+            else:
+                U = (n-1)//4
+                t = (e1 + e2//U) // k**n
+            if not t:
+                break
+            s += t
+            k += 1
+        zeta_values[n] = -2*s
+    # Even zeta values
+    B = [mpf_abs(mpf_bernoulli(k,wp)) for k in xrange(N+2)]
+    pi_pow = fpi = mpf_pow_int(mpf_shift(mpf_pi(wp), 1), 2, wp)
+    pi_pow = mpf_div(pi_pow, from_int(4), wp)
+    for n in xrange(2,N+2,2):
+        z = mpf_mul(B[n], pi_pow, wp)
+        zeta_values[n] = to_fixed(z, wp)
+        pi_pow = mpf_mul(pi_pow, fpi, wp)
+        pi_pow = mpf_div(pi_pow, from_int((n+1)*(n+2)), wp)
+    # Zeta sum
+    reciprocal_pi = (one << wp) // pi
+    for n in xrange(3, N+1, 4):
+        U = (n-3)//4
+        s = zeta_values[4*U+4]*(4*U+7)//4
+        for k in xrange(1, U+1):
+            s -= (zeta_values[4*k] * zeta_values[4*U+4-4*k]) >> wp
+        zeta_values[n] += (2*s*reciprocal_pi) >> wp
+    for n in xrange(5, N+1, 4):
+        U = (n-1)//4
+        s = zeta_values[4*U+2]*(2*U+1)
+        for k in xrange(1, 2*U+1):
+            s += ((-1)**k*2*k* zeta_values[2*k] * zeta_values[4*U+2-2*k])>>wp
+        zeta_values[n] += ((s*reciprocal_pi)>>wp)//(2*U)
+    return [x>>extra for x in zeta_values]
+
+def gamma_taylor_coefficients(inprec):
+    """
+    Gives the Taylor coefficients of 1/gamma(1+x) as
+    a list of fixed-point numbers. Enough coefficients are returned
+    to ensure that the series converges to the given precision
+    when x is in [0.5, 1.5].
+    """
+    # Reuse nearby cache values (small case)
+    if inprec < 400:
+        prec = inprec + (10-(inprec%10))
+    elif inprec < 1000:
+        prec = inprec + (30-(inprec%30))
+    else:
+        prec = inprec
+    if prec in gamma_taylor_cache:
+        return gamma_taylor_cache[prec], prec
+
+    # Experimentally determined bounds
+    if prec < 1000:
+        N = int(prec**0.76 + 2)
+    else:
+        # Valid to at least 15000 bits
+        N = int(prec**0.787 + 2)
+
+    # Reuse higher precision values
+    for cprec in gamma_taylor_cache:
+        if cprec > prec:
+            coeffs = [x>>(cprec-prec) for x in gamma_taylor_cache[cprec][-N:]]
+            if inprec < 1000:
+                gamma_taylor_cache[prec] = coeffs
+            return coeffs, prec
+
+    # Cache at a higher precision (large case)
+    if prec > 1000:
+        prec = int(prec * 1.2)
+
+    wp = prec + 20
+    A = [0] * N
+    A[0] = MPZ_ZERO
+    A[1] = MPZ_ONE << wp
+    A[2] = euler_fixed(wp)
+    # SLOW, reference implementation
+    #zeta_values = [0,0]+[to_fixed(mpf_zeta_int(k,wp),wp) for k in xrange(2,N)]
+    zeta_values = zeta_array(N, wp)
+    for k in xrange(3, N):
+        a = (-A[2]*A[k-1])>>wp
+        for j in xrange(2,k):
+            a += ((-1)**j * zeta_values[j] * A[k-j]) >> wp
+        a //= (1-k)
+        A[k] = a
+    A = [a>>20 for a in A]
+    A = A[::-1]
+    A = A[:-1]
+    gamma_taylor_cache[prec] = A
+    #return A, prec
+    return gamma_taylor_coefficients(inprec)
+
+def gamma_fixed_taylor(xmpf, x, wp, prec, rnd, type):
+    # Determine nearest multiple of N/2
+    #n = int(x >> (wp-1))
+    #steps = (n-1)>>1
+    nearest_int = ((x >> (wp-1)) + MPZ_ONE) >> 1
+    one = MPZ_ONE << wp
+    coeffs, cwp = gamma_taylor_coefficients(wp)
+    if nearest_int > 0:
+        r = one
+        for i in xrange(nearest_int-1):
+            x -= one
+            r = (r*x) >> wp
+        x -= one
+        p = MPZ_ZERO
+        for c in coeffs:
+            p = c + ((x*p)>>wp)
+        p >>= (cwp-wp)
+        if type == 0:
+            return from_man_exp((r<<wp)//p, -wp, prec, rnd)
+        if type == 2:
+            return mpf_shift(from_rational(p, (r<<wp), prec, rnd), wp)
+        if type == 3:
+            return mpf_log(mpf_abs(from_man_exp((r<<wp)//p, -wp)), prec, rnd)
+    else:
+        r = one
+        for i in xrange(-nearest_int):
+            r = (r*x) >> wp
+            x += one
+        p = MPZ_ZERO
+        for c in coeffs:
+            p = c + ((x*p)>>wp)
+        p >>= (cwp-wp)
+        if wp - bitcount(abs(x)) > 10:
+            # pass very close to 0, so do floating-point multiply
+            g = mpf_add(xmpf, from_int(-nearest_int))  # exact
+            r = from_man_exp(p*r,-wp-wp)
+            r = mpf_mul(r, g, wp)
+            if type == 0:
+                return mpf_div(fone, r, prec, rnd)
+            if type == 2:
+                return mpf_pos(r, prec, rnd)
+            if type == 3:
+                return mpf_log(mpf_abs(mpf_div(fone, r, wp)), prec, rnd)
+        else:
+            r = from_man_exp(x*p*r,-3*wp)
+            if type == 0: return mpf_div(fone, r, prec, rnd)
+            if type == 2: return mpf_pos(r, prec, rnd)
+            if type == 3: return mpf_neg(mpf_log(mpf_abs(r), prec, rnd))
+
+def stirling_coefficient(n):
+    if n in gamma_stirling_cache:
+        return gamma_stirling_cache[n]
+    p, q = bernfrac(n)
+    q *= MPZ(n*(n-1))
+    gamma_stirling_cache[n] = p, q, bitcount(abs(p)), bitcount(q)
+    return gamma_stirling_cache[n]
+
+def real_stirling_series(x, prec):
+    """
+    Sums the rational part of Stirling's expansion,
+
+    log(sqrt(2*pi)) - z + 1/(12*z) - 1/(360*z^3) + ...
+
+    """
+    t = (MPZ_ONE<<(prec+prec)) // x   # t = 1/x
+    u = (t*t)>>prec                  # u = 1/x**2
+    s = ln_sqrt2pi_fixed(prec) - x
+    # Add initial terms of Stirling's series
+    s += t//12;            t = (t*u)>>prec
+    s -= t//360;           t = (t*u)>>prec
+    s += t//1260;          t = (t*u)>>prec
+    s -= t//1680;          t = (t*u)>>prec
+    if not t: return s
+    s += t//1188;          t = (t*u)>>prec
+    s -= 691*t//360360;    t = (t*u)>>prec
+    s += t//156;           t = (t*u)>>prec
+    if not t: return s
+    s -= 3617*t//122400;   t = (t*u)>>prec
+    s += 43867*t//244188;  t = (t*u)>>prec
+    s -= 174611*t//125400;  t = (t*u)>>prec
+    if not t: return s
+    k = 22
+    # From here on, the coefficients are growing, so we
+    # have to keep t at a roughly constant size
+    usize = bitcount(abs(u))
+    tsize = bitcount(abs(t))
+    texp = 0
+    while 1:
+        p, q, pb, qb = stirling_coefficient(k)
+        term_mag = tsize + pb + texp
+        shift = -texp
+        m = pb - term_mag
+        if m > 0 and shift < m:
+            p >>= m
+            shift -= m
+        m = tsize - term_mag
+        if m > 0 and shift < m:
+            w = t >> m
+            shift -= m
+        else:
+            w = t
+        term = (t*p//q) >> shift
+        if not term:
+            break
+        s += term
+        t = (t*u) >> usize
+        texp -= (prec - usize)
+        k += 2
+    return s
+
+def complex_stirling_series(x, y, prec):
+    # t = 1/z
+    _m = (x*x + y*y) >> prec
+    tre = (x << prec) // _m
+    tim = (-y << prec) // _m
+    # u = 1/z**2
+    ure = (tre*tre - tim*tim) >> prec
+    uim = tim*tre >> (prec-1)
+    # s = log(sqrt(2*pi)) - z
+    sre = ln_sqrt2pi_fixed(prec) - x
+    sim = -y
+
+    # Add initial terms of Stirling's series
+    sre += tre//12; sim += tim//12;
+    tre, tim = ((tre*ure-tim*uim)>>prec), ((tre*uim+tim*ure)>>prec)
+    sre -= tre//360; sim -= tim//360;
+    tre, tim = ((tre*ure-tim*uim)>>prec), ((tre*uim+tim*ure)>>prec)
+    sre += tre//1260; sim += tim//1260;
+    tre, tim = ((tre*ure-tim*uim)>>prec), ((tre*uim+tim*ure)>>prec)
+    sre -= tre//1680; sim -= tim//1680;
+    tre, tim = ((tre*ure-tim*uim)>>prec), ((tre*uim+tim*ure)>>prec)
+    if abs(tre) + abs(tim) < 5: return sre, sim
+    sre += tre//1188; sim += tim//1188;
+    tre, tim = ((tre*ure-tim*uim)>>prec), ((tre*uim+tim*ure)>>prec)
+    sre -= 691*tre//360360; sim -= 691*tim//360360;
+    tre, tim = ((tre*ure-tim*uim)>>prec), ((tre*uim+tim*ure)>>prec)
+    sre += tre//156; sim += tim//156;
+    tre, tim = ((tre*ure-tim*uim)>>prec), ((tre*uim+tim*ure)>>prec)
+    if abs(tre) + abs(tim) < 5: return sre, sim
+    sre -= 3617*tre//122400; sim -= 3617*tim//122400;
+    tre, tim = ((tre*ure-tim*uim)>>prec), ((tre*uim+tim*ure)>>prec)
+    sre += 43867*tre//244188; sim += 43867*tim//244188;
+    tre, tim = ((tre*ure-tim*uim)>>prec), ((tre*uim+tim*ure)>>prec)
+    sre -= 174611*tre//125400; sim -= 174611*tim//125400;
+    tre, tim = ((tre*ure-tim*uim)>>prec), ((tre*uim+tim*ure)>>prec)
+    if abs(tre) + abs(tim) < 5: return sre, sim
+
+    k = 22
+    # From here on, the coefficients are growing, so we
+    # have to keep t at a roughly constant size
+    usize = bitcount(max(abs(ure), abs(uim)))
+    tsize = bitcount(max(abs(tre), abs(tim)))
+    texp = 0
+    while 1:
+        p, q, pb, qb = stirling_coefficient(k)
+        term_mag = tsize + pb + texp
+        shift = -texp
+        m = pb - term_mag
+        if m > 0 and shift < m:
+            p >>= m
+            shift -= m
+        m = tsize - term_mag
+        if m > 0 and shift < m:
+            wre = tre >> m
+            wim = tim >> m
+            shift -= m
+        else:
+            wre = tre
+            wim = tim
+        termre = (tre*p//q) >> shift
+        termim = (tim*p//q) >> shift
+        if abs(termre) + abs(termim) < 5:
+            break
+        sre += termre
+        sim += termim
+        tre, tim = ((tre*ure - tim*uim)>>usize), \
+            ((tre*uim + tim*ure)>>usize)
+        texp -= (prec - usize)
+        k += 2
+    return sre, sim
+
+
+def mpf_gamma(x, prec, rnd='d', type=0):
+    """
+    This function implements multipurpose evaluation of the gamma
+    function, G(x), as well as the following versions of the same:
+
+    type = 0 -- G(x)                    [standard gamma function]
+    type = 1 -- G(x+1) = x*G(x+1) = x!  [factorial]
+    type = 2 -- 1/G(x)                  [reciprocal gamma function]
+    type = 3 -- log(|G(x)|)             [log-gamma function, real part]
+    """
+
+    # Specal values
+    sign, man, exp, bc = x
+    if not man:
+        if x == fzero:
+            if type == 1: return fone
+            if type == 2: return fzero
+            raise ValueError("gamma function pole")
+        if x == finf:
+            if type == 2: return fzero
+            return finf
+        return fnan
+
+    # First of all, for log gamma, numbers can be well beyond the fixed-point
+    # range, so we must take care of huge numbers before e.g. trying
+    # to convert x to the nearest integer
+    if type == 3:
+        wp = prec+20
+        if exp+bc > wp and not sign:
+            return mpf_sub(mpf_mul(x, mpf_log(x, wp), wp), x, prec, rnd)
+
+    # We strongly want to special-case small integers
+    is_integer = exp >= 0
+    if is_integer:
+        # Poles
+        if sign:
+            if type == 2:
+                return fzero
+            raise ValueError("gamma function pole")
+        # n = x
+        n = man << exp
+        if n < SMALL_FACTORIAL_CACHE_SIZE:
+            if type == 0:
+                return mpf_pos(small_factorial_cache[n-1], prec, rnd)
+            if type == 1:
+                return mpf_pos(small_factorial_cache[n], prec, rnd)
+            if type == 2:
+                return mpf_div(fone, small_factorial_cache[n-1], prec, rnd)
+            if type == 3:
+                return mpf_log(small_factorial_cache[n-1], prec, rnd)
+    else:
+        # floor(abs(x))
+        n = int(man >> (-exp))
+
+    # Estimate size and precision
+    # Estimate log(gamma(|x|),2) as x*log(x,2)
+    mag = exp + bc
+    gamma_size = n*mag
+
+    if type == 3:
+        wp = prec + 20
+    else:
+        wp = prec + bitcount(gamma_size) + 20
+
+    # Very close to 0, pole
+    if mag < -wp:
+        if type == 0:
+            return mpf_sub(mpf_div(fone,x, wp),mpf_shift(fone,-wp),prec,rnd)
+        if type == 1: return mpf_sub(fone, x, prec, rnd)
+        if type == 2: return mpf_add(x, mpf_shift(fone,mag-wp), prec, rnd)
+        if type == 3: return mpf_neg(mpf_log(mpf_abs(x), prec, rnd))
+
+    # From now on, we assume having a gamma function
+    if type == 1:
+        return mpf_gamma(mpf_add(x, fone), prec, rnd, 0)
+
+    # Special case integers (those not small enough to be caught above,
+    # but still small enough for an exact factorial to be faster
+    # than an approximate algorithm), and half-integers
+    if exp >= -1:
+        if is_integer:
+            if gamma_size < 10*wp:
+                if type == 0:
+                    return from_int(ifac(n-1), prec, rnd)
+                if type == 2:
+                    return from_rational(MPZ_ONE, ifac(n-1), prec, rnd)
+                if type == 3:
+                    return mpf_log(from_int(ifac(n-1)), prec, rnd)
+        # half-integer
+        if n < 100 or gamma_size < 10*wp:
+            if sign:
+                w = sqrtpi_fixed(wp)
+                if n % 2: f = ifac2(2*n+1)
+                else:     f = -ifac2(2*n+1)
+                if type == 0:
+                    return mpf_shift(from_rational(w, f, prec, rnd), -wp+n+1)
+                if type == 2:
+                    return mpf_shift(from_rational(f, w, prec, rnd), wp-n-1)
+                if type == 3:
+                    return mpf_log(mpf_shift(from_rational(w, abs(f),
+                        prec, rnd), -wp+n+1), prec, rnd)
+            elif n == 0:
+                if type == 0: return mpf_sqrtpi(prec, rnd)
+                if type == 2: return mpf_div(fone, mpf_sqrtpi(wp), prec, rnd)
+                if type == 3: return mpf_log(mpf_sqrtpi(wp), prec, rnd)
+            else:
+                w = sqrtpi_fixed(wp)
+                w = from_man_exp(w * ifac2(2*n-1), -wp-n)
+                if type == 0: return mpf_pos(w, prec, rnd)
+                if type == 2: return mpf_div(fone, w, prec, rnd)
+                if type == 3: return mpf_log(mpf_abs(w), prec, rnd)
+
+    # Convert to fixed point
+    offset = exp + wp
+    if offset >= 0: absxman = man << offset
+    else:           absxman = man >> (-offset)
+
+    # For log gamma, provide accurate evaluation for x = 1+eps and 2+eps
+    if type == 3 and not sign:
+        one = MPZ_ONE << wp
+        one_dist = abs(absxman-one)
+        two_dist = abs(absxman-2*one)
+        cancellation = (wp - bitcount(min(one_dist, two_dist)))
+        if cancellation > 10:
+            xsub1 = mpf_sub(fone, x)
+            xsub2 = mpf_sub(ftwo, x)
+            xsub1mag = xsub1[2]+xsub1[3]
+            xsub2mag = xsub2[2]+xsub2[3]
+            if xsub1mag < -wp:
+                return mpf_mul(mpf_euler(wp), mpf_sub(fone, x), prec, rnd)
+            if xsub2mag < -wp:
+                return mpf_mul(mpf_sub(fone, mpf_euler(wp)),
+                    mpf_sub(x, ftwo), prec, rnd)
+            # Proceed but increase precision
+            wp += max(-xsub1mag, -xsub2mag)
+            offset = exp + wp
+            if offset >= 0: absxman = man << offset
+            else:           absxman = man >> (-offset)
+
+    # Use Taylor series if appropriate
+    n_for_stirling = int(GAMMA_STIRLING_BETA*wp)
+    if n < max(100, n_for_stirling) and wp < MAX_GAMMA_TAYLOR_PREC:
+        if sign:
+            absxman = -absxman
+        return gamma_fixed_taylor(x, absxman, wp, prec, rnd, type)
+
+    # Use Stirling's series
+    # First ensure that |x| is large enough for rapid convergence
+    xorig = x
+
+    # Argument reduction
+    r = 0
+    if n < n_for_stirling:
+        r = one = MPZ_ONE << wp
+        d = n_for_stirling - n
+        for k in xrange(d):
+            r = (r * absxman) >> wp
+            absxman += one
+        x = xabs = from_man_exp(absxman, -wp)
+        if sign:
+            x = mpf_neg(x)
+    else:
+        xabs = mpf_abs(x)
+
+    # Asymptotic series
+    y = real_stirling_series(absxman, wp)
+    u = to_fixed(mpf_log(xabs, wp), wp)
+    u = ((absxman - (MPZ_ONE<<(wp-1))) * u) >> wp
+    y += u
+    w = from_man_exp(y, -wp)
+
+    # Compute final value
+    if sign:
+        # Reflection formula
+        A = mpf_mul(mpf_sin_pi(xorig, wp), xorig, wp)
+        B = mpf_neg(mpf_pi(wp))
+        if type == 0 or type == 2:
+            A = mpf_mul(A, mpf_exp(w, wp))
+            if r:
+                B = mpf_mul(B, from_man_exp(r, -wp), wp)
+            if type == 0:
+                return mpf_div(B, A, prec, rnd)
+            if type == 2:
+                return mpf_div(A, B, prec, rnd)
+        if type == 3:
+            if r:
+                B = mpf_mul(B, from_man_exp(r, -wp), wp)
+            A = mpf_add(mpf_log(mpf_abs(A), wp), w, wp)
+            return mpf_sub(mpf_log(mpf_abs(B), wp), A, prec, rnd)
+    else:
+        if type == 0:
+            if r:
+                return mpf_div(mpf_exp(w, wp),
+                    from_man_exp(r, -wp), prec, rnd)
+            return mpf_exp(w, prec, rnd)
+        if type == 2:
+            if r:
+                return mpf_div(from_man_exp(r, -wp),
+                    mpf_exp(w, wp), prec, rnd)
+            return mpf_exp(mpf_neg(w), prec, rnd)
+        if type == 3:
+            if r:
+                return mpf_sub(w, mpf_log(from_man_exp(r,-wp), wp), prec, rnd)
+            return mpf_pos(w, prec, rnd)
+
+
+def mpc_gamma(z, prec, rnd='d', type=0):
+    a, b = z
+    asign, aman, aexp, abc = a
+    bsign, bman, bexp, bbc = b
+
+    if b == fzero:
+        # Imaginary part on negative half-axis for log-gamma function
+        if type == 3 and asign:
+            re = mpf_gamma(a, prec, rnd, 3)
+            n = (-aman) >> (-aexp)
+            im = mpf_mul_int(mpf_pi(prec+10), n, prec, rnd)
+            return re, im
+        return mpf_gamma(a, prec, rnd, type), fzero
+
+    # Some kind of complex inf/nan
+    if (not aman and aexp) or (not bman and bexp):
+        return (fnan, fnan)
+
+    # Initial working precision
+    wp = prec + 20
+
+    amag = aexp+abc
+    bmag = bexp+bbc
+    if aman:
+        mag = max(amag, bmag)
+    else:
+        mag = bmag
+
+    # Close to 0
+    if mag < -8:
+        if mag < -wp:
+            # 1/gamma(z) = z + euler*z^2 + O(z^3)
+            v = mpc_add(z, mpc_mul_mpf(mpc_mul(z,z,wp),mpf_euler(wp),wp), wp)
+            if type == 0: return mpc_reciprocal(v, prec, rnd)
+            if type == 1: return mpc_div(z, v, prec, rnd)
+            if type == 2: return mpc_pos(v, prec, rnd)
+            if type == 3: return mpc_log(mpc_reciprocal(v, prec), prec, rnd)
+        elif type != 1:
+            wp += (-mag)
+
+    # Handle huge log-gamma values; must do this before converting to
+    # a fixed-point value. TODO: determine a precise cutoff of validity
+    # depending on amag and bmag
+    if type == 3 and mag > wp and ((not asign) or (bmag >= amag)):
+        return mpc_sub(mpc_mul(z, mpc_log(z, wp), wp), z, prec, rnd)
+
+    # From now on, we assume having a gamma function
+    if type == 1:
+        return mpc_gamma((mpf_add(a, fone), b), prec, rnd, 0)
+
+    an = abs(to_int(a))
+    bn = abs(to_int(b))
+    absn = max(an, bn)
+    gamma_size = absn*mag
+    if type == 3:
+        pass
+    else:
+        wp += bitcount(gamma_size)
+
+    # Reflect to the right half-plane. Note that Stirling's expansion
+    # is valid in the left half-plane too, as long as we're not too close
+    # to the real axis, but in order to use this argument reduction
+    # in the negative direction must be implemented.
+    #need_reflection = asign and ((bmag < 0) or (amag-bmag > 4))
+    need_reflection = asign
+    zorig = z
+    if need_reflection:
+        z = mpc_neg(z)
+        asign, aman, aexp, abc = a = z[0]
+        bsign, bman, bexp, bbc = b = z[1]
+
+    # Imaginary part very small compared to real one?
+    yfinal = 0
+    balance_prec = 0
+    if bmag < -10:
+        # Check z ~= 1 and z ~= 2 for loggamma
+        if type == 3:
+            zsub1 = mpc_sub_mpf(z, fone)
+            if zsub1[0] == fzero:
+                cancel1 = -bmag
+            else:
+                cancel1 = -max(zsub1[0][2]+zsub1[0][3], bmag)
+            if cancel1 > wp:
+                pi = mpf_pi(wp)
+                x = mpc_mul_mpf(zsub1, pi, wp)
+                x = mpc_mul(x, x, wp)
+                x = mpc_div_mpf(x, from_int(12), wp)
+                y = mpc_mul_mpf(zsub1, mpf_neg(mpf_euler(wp)), wp)
+                yfinal = mpc_add(x, y, wp)
+                if not need_reflection:
+                    return mpc_pos(yfinal, prec, rnd)
+            elif cancel1 > 0:
+                wp += cancel1
+            zsub2 = mpc_sub_mpf(z, ftwo)
+            if zsub2[0] == fzero:
+                cancel2 = -bmag
+            else:
+                cancel2 = -max(zsub2[0][2]+zsub2[0][3], bmag)
+            if cancel2 > wp:
+                pi = mpf_pi(wp)
+                t = mpf_sub(mpf_mul(pi, pi), from_int(6))
+                x = mpc_mul_mpf(mpc_mul(zsub2, zsub2, wp), t, wp)
+                x = mpc_div_mpf(x, from_int(12), wp)
+                y = mpc_mul_mpf(zsub2, mpf_sub(fone, mpf_euler(wp)), wp)
+                yfinal = mpc_add(x, y, wp)
+                if not need_reflection:
+                    return mpc_pos(yfinal, prec, rnd)
+            elif cancel2 > 0:
+                wp += cancel2
+        if bmag < -wp:
+            # Compute directly from the real gamma function.
+            pp = 2*(wp+10)
+            aabs = mpf_abs(a)
+            eps = mpf_shift(fone, amag-wp)
+            x1 = mpf_gamma(aabs, pp, type=type)
+            x2 = mpf_gamma(mpf_add(aabs, eps), pp, type=type)
+            xprime = mpf_div(mpf_sub(x2, x1, pp), eps, pp)
+            y = mpf_mul(b, xprime, prec, rnd)
+            yfinal = (x1, y)
+            # Note: we still need to use the reflection formula for
+            # near-poles, and the correct branch of the log-gamma function
+            if not need_reflection:
+                return mpc_pos(yfinal, prec, rnd)
+        else:
+            balance_prec += (-bmag)
+
+    wp += balance_prec
+    n_for_stirling = int(GAMMA_STIRLING_BETA*wp)
+    need_reduction = absn < n_for_stirling
+
+    afix = to_fixed(a, wp)
+    bfix = to_fixed(b, wp)
+
+    r = 0
+    if not yfinal:
+        zprered = z
+        # Argument reduction
+        if absn < n_for_stirling:
+            absn = complex(an, bn)
+            d = int((1 + n_for_stirling**2 - bn**2)**0.5 - an)
+            rre = one = MPZ_ONE << wp
+            rim = MPZ_ZERO
+            for k in xrange(d):
+                rre, rim = ((afix*rre-bfix*rim)>>wp), ((afix*rim + bfix*rre)>>wp)
+                afix += one
+            r = from_man_exp(rre, -wp), from_man_exp(rim, -wp)
+            a = from_man_exp(afix, -wp)
+            z = a, b
+
+        yre, yim = complex_stirling_series(afix, bfix, wp)
+        # (z-1/2)*log(z) + S
+        lre, lim = mpc_log(z, wp)
+        lre = to_fixed(lre, wp)
+        lim = to_fixed(lim, wp)
+        yre = ((lre*afix - lim*bfix)>>wp) - (lre>>1) + yre
+        yim = ((lre*bfix + lim*afix)>>wp) - (lim>>1) + yim
+        y = from_man_exp(yre, -wp), from_man_exp(yim, -wp)
+
+        if r and type == 3:
+            # If re(z) > 0 and abs(z) <= 4, the branches of loggamma(z)
+            # and log(gamma(z)) coincide. Otherwise, use the zeroth order
+            # Stirling expansion to compute the correct imaginary part.
+            y = mpc_sub(y, mpc_log(r, wp), wp)
+            zfa = to_float(zprered[0])
+            zfb = to_float(zprered[1])
+            zfabs = math.hypot(zfa,zfb)
+            #if not (zfa > 0.0 and zfabs <= 4):
+            yfb = to_float(y[1])
+            u = math.atan2(zfb, zfa)
+            if zfabs <= 0.5:
+                gi = 0.577216*zfb - u
+            else:
+                gi = -zfb - 0.5*u + zfa*u + zfb*math.log(zfabs)
+            n = int(math.floor((gi-yfb)/(2*math.pi)+0.5))
+            y = (y[0], mpf_add(y[1], mpf_mul_int(mpf_pi(wp), 2*n, wp), wp))
+
+    if need_reflection:
+        if type == 0 or type == 2:
+            A = mpc_mul(mpc_sin_pi(zorig, wp), zorig, wp)
+            B = (mpf_neg(mpf_pi(wp)), fzero)
+            if yfinal:
+                if type == 2:
+                    A = mpc_div(A, yfinal, wp)
+                else:
+                    A = mpc_mul(A, yfinal, wp)
+            else:
+                A = mpc_mul(A, mpc_exp(y, wp), wp)
+            if r:
+                B = mpc_mul(B, r, wp)
+            if type == 0: return mpc_div(B, A, prec, rnd)
+            if type == 2: return mpc_div(A, B, prec, rnd)
+
+        # Reflection formula for the log-gamma function with correct branch
+        # http://functions.wolfram.com/GammaBetaErf/LogGamma/16/01/01/0006/
+        # LogGamma[z] == -LogGamma[-z] - Log[-z] +
+        # Sign[Im[z]] Floor[Re[z]] Pi I + Log[Pi] -
+        #      Log[Sin[Pi (z - Floor[Re[z]])]] -
+        # Pi I (1 - Abs[Sign[Im[z]]]) Abs[Floor[Re[z]]]
+        if type == 3:
+            if yfinal:
+                s1 = mpc_neg(yfinal)
+            else:
+                s1 = mpc_neg(y)
+            # s -= log(-z)
+            s1 = mpc_sub(s1, mpc_log(mpc_neg(zorig), wp), wp)
+            # floor(re(z))
+            rezfloor = mpf_floor(zorig[0])
+            imzsign = mpf_sign(zorig[1])
+            pi = mpf_pi(wp)
+            t = mpf_mul(pi, rezfloor)
+            t = mpf_mul_int(t, imzsign, wp)
+            s1 = (s1[0], mpf_add(s1[1], t, wp))
+            s1 = mpc_add_mpf(s1, mpf_log(pi, wp), wp)
+            t = mpc_sin_pi(mpc_sub_mpf(zorig, rezfloor), wp)
+            t = mpc_log(t, wp)
+            s1 = mpc_sub(s1, t, wp)
+            # Note: may actually be unused, because we fall back
+            # to the mpf_ function for real arguments
+            if not imzsign:
+                t = mpf_mul(pi, mpf_floor(rezfloor), wp)
+                s1 = (s1[0], mpf_sub(s1[1], t, wp))
+            return mpc_pos(s1, prec, rnd)
+    else:
+        if type == 0:
+            if r:
+                return mpc_div(mpc_exp(y, wp), r, prec, rnd)
+            return mpc_exp(y, prec, rnd)
+        if type == 2:
+            if r:
+                return mpc_div(r, mpc_exp(y, wp), prec, rnd)
+            return mpc_exp(mpc_neg(y), prec, rnd)
+        if type == 3:
+            return mpc_pos(y, prec, rnd)
+
+def mpf_factorial(x, prec, rnd='d'):
+    return mpf_gamma(x, prec, rnd, 1)
+
+def mpc_factorial(x, prec, rnd='d'):
+    return mpc_gamma(x, prec, rnd, 1)
+
+def mpf_rgamma(x, prec, rnd='d'):
+    return mpf_gamma(x, prec, rnd, 2)
+
+def mpc_rgamma(x, prec, rnd='d'):
+    return mpc_gamma(x, prec, rnd, 2)
+
+def mpf_loggamma(x, prec, rnd='d'):
+    sign, man, exp, bc = x
+    if sign:
+        raise ComplexResult
+    return mpf_gamma(x, prec, rnd, 3)
+
+def mpc_loggamma(z, prec, rnd='d'):
+    a, b = z
+    asign, aman, aexp, abc = a
+    bsign, bman, bexp, bbc = b
+    if b == fzero and asign:
+        re = mpf_gamma(a, prec, rnd, 3)
+        n = (-aman) >> (-aexp)
+        im = mpf_mul_int(mpf_pi(prec+10), n, prec, rnd)
+        return re, im
+    return mpc_gamma(z, prec, rnd, 3)
+
+def mpf_gamma_int(n, prec, rnd=round_fast):
+    if n < SMALL_FACTORIAL_CACHE_SIZE:
+        return mpf_pos(small_factorial_cache[n-1], prec, rnd)
+    return mpf_gamma(from_int(n), prec, rnd)
diff --git a/lib/python3.10/site-packages/mpmath/libmp/libelefun.py b/lib/python3.10/site-packages/mpmath/libmp/libelefun.py
new file mode 100644
index 0000000000000000000000000000000000000000..3de2e5aaef02296ed03dec3df3021b56823f3728
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/libmp/libelefun.py
@@ -0,0 +1,1428 @@
+"""
+This module implements computation of elementary transcendental
+functions (powers, logarithms, trigonometric and hyperbolic
+functions, inverse trigonometric and hyperbolic) for real
+floating-point numbers.
+
+For complex and interval implementations of the same functions,
+see libmpc and libmpi.
+
+"""
+
+import math
+from bisect import bisect
+
+from .backend import xrange
+from .backend import MPZ, MPZ_ZERO, MPZ_ONE, MPZ_TWO, MPZ_FIVE, BACKEND
+
+from .libmpf import (
+    round_floor, round_ceiling, round_down, round_up,
+    round_nearest, round_fast,
+    ComplexResult,
+    bitcount, bctable, lshift, rshift, giant_steps, sqrt_fixed,
+    from_int, to_int, from_man_exp, to_fixed, to_float, from_float,
+    from_rational, normalize,
+    fzero, fone, fnone, fhalf, finf, fninf, fnan,
+    mpf_cmp, mpf_sign, mpf_abs,
+    mpf_pos, mpf_neg, mpf_add, mpf_sub, mpf_mul, mpf_div, mpf_shift,
+    mpf_rdiv_int, mpf_pow_int, mpf_sqrt,
+    reciprocal_rnd, negative_rnd, mpf_perturb,
+    isqrt_fast
+)
+
+from .libintmath import ifib
+
+
+#-------------------------------------------------------------------------------
+# Tuning parameters
+#-------------------------------------------------------------------------------
+
+# Cutoff for computing exp from cosh+sinh. This reduces the
+# number of terms by half, but also requires a square root which
+# is expensive with the pure-Python square root code.
+if BACKEND == 'python':
+    EXP_COSH_CUTOFF = 600
+else:
+    EXP_COSH_CUTOFF = 400
+# Cutoff for using more than 2 series
+EXP_SERIES_U_CUTOFF = 1500
+
+# Also basically determined by sqrt
+if BACKEND == 'python':
+    COS_SIN_CACHE_PREC = 400
+else:
+    COS_SIN_CACHE_PREC = 200
+COS_SIN_CACHE_STEP = 8
+cos_sin_cache = {}
+
+# Number of integer logarithms to cache (for zeta sums)
+MAX_LOG_INT_CACHE = 2000
+log_int_cache = {}
+
+LOG_TAYLOR_PREC = 2500  # Use Taylor series with caching up to this prec
+LOG_TAYLOR_SHIFT = 9    # Cache log values in steps of size 2^-N
+log_taylor_cache = {}
+# prec/size ratio of x for fastest convergence in AGM formula
+LOG_AGM_MAG_PREC_RATIO = 20
+
+ATAN_TAYLOR_PREC = 3000  # Same as for log
+ATAN_TAYLOR_SHIFT = 7   # steps of size 2^-N
+atan_taylor_cache = {}
+
+
+# ~= next power of two + 20
+cache_prec_steps = [22,22]
+for k in xrange(1, bitcount(LOG_TAYLOR_PREC)+1):
+    cache_prec_steps += [min(2**k,LOG_TAYLOR_PREC)+20] * 2**(k-1)
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                   Elementary mathematical constants                        #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def constant_memo(f):
+    """
+    Decorator for caching computed values of mathematical
+    constants. This decorator should be applied to a
+    function taking a single argument prec as input and
+    returning a fixed-point value with the given precision.
+    """
+    f.memo_prec = -1
+    f.memo_val = None
+    def g(prec, **kwargs):
+        memo_prec = f.memo_prec
+        if prec <= memo_prec:
+            return f.memo_val >> (memo_prec-prec)
+        newprec = int(prec*1.05+10)
+        f.memo_val = f(newprec, **kwargs)
+        f.memo_prec = newprec
+        return f.memo_val >> (newprec-prec)
+    g.__name__ = f.__name__
+    g.__doc__ = f.__doc__
+    return g
+
+def def_mpf_constant(fixed):
+    """
+    Create a function that computes the mpf value for a mathematical
+    constant, given a function that computes the fixed-point value.
+
+    Assumptions: the constant is positive and has magnitude ~= 1;
+    the fixed-point function rounds to floor.
+    """
+    def f(prec, rnd=round_fast):
+        wp = prec + 20
+        v = fixed(wp)
+        if rnd in (round_up, round_ceiling):
+            v += 1
+        return normalize(0, v, -wp, bitcount(v), prec, rnd)
+    f.__doc__ = fixed.__doc__
+    return f
+
+def bsp_acot(q, a, b, hyperbolic):
+    if b - a == 1:
+        a1 = MPZ(2*a + 3)
+        if hyperbolic or a&1:
+            return MPZ_ONE, a1 * q**2, a1
+        else:
+            return -MPZ_ONE, a1 * q**2, a1
+    m = (a+b)//2
+    p1, q1, r1 = bsp_acot(q, a, m, hyperbolic)
+    p2, q2, r2 = bsp_acot(q, m, b, hyperbolic)
+    return q2*p1 + r1*p2, q1*q2, r1*r2
+
+# the acoth(x) series converges like the geometric series for x^2
+# N = ceil(p*log(2)/(2*log(x)))
+def acot_fixed(a, prec, hyperbolic):
+    """
+    Compute acot(a) or acoth(a) for an integer a with binary splitting; see
+    http://numbers.computation.free.fr/Constants/Algorithms/splitting.html
+    """
+    N = int(0.35 * prec/math.log(a) + 20)
+    p, q, r = bsp_acot(a, 0,N, hyperbolic)
+    return ((p+q)<<prec)//(q*a)
+
+def machin(coefs, prec, hyperbolic=False):
+    """
+    Evaluate a Machin-like formula, i.e., a linear combination of
+    acot(n) or acoth(n) for specific integer values of n, using fixed-
+    point arithmetic. The input should be a list [(c, n), ...], giving
+    c*acot[h](n) + ...
+    """
+    extraprec = 10
+    s = MPZ_ZERO
+    for a, b in coefs:
+        s += MPZ(a) * acot_fixed(MPZ(b), prec+extraprec, hyperbolic)
+    return (s >> extraprec)
+
+# Logarithms of integers are needed for various computations involving
+# logarithms, powers, radix conversion, etc
+
+@constant_memo
+def ln2_fixed(prec):
+    """
+    Computes ln(2). This is done with a hyperbolic Machin-type formula,
+    with binary splitting at high precision.
+    """
+    return machin([(18, 26), (-2, 4801), (8, 8749)], prec, True)
+
+@constant_memo
+def ln10_fixed(prec):
+    """
+    Computes ln(10). This is done with a hyperbolic Machin-type formula.
+    """
+    return machin([(46, 31), (34, 49), (20, 161)], prec, True)
+
+
+r"""
+For computation of pi, we use the Chudnovsky series:
+
+             oo
+             ___        k
+      1     \       (-1)  (6 k)! (A + B k)
+    ----- =  )     -----------------------
+    12 pi   /___               3  3k+3/2
+                    (3 k)! (k!)  C
+            k = 0
+
+where A, B, and C are certain integer constants. This series adds roughly
+14 digits per term. Note that C^(3/2) can be extracted so that the
+series contains only rational terms. This makes binary splitting very
+efficient.
+
+The recurrence formulas for the binary splitting were taken from
+ftp://ftp.gmplib.org/pub/src/gmp-chudnovsky.c
+
+Previously, Machin's formula was used at low precision and the AGM iteration
+was used at high precision. However, the Chudnovsky series is essentially as
+fast as the Machin formula at low precision and in practice about 3x faster
+than the AGM at high precision (despite theoretically having a worse
+asymptotic complexity), so there is no reason not to use it in all cases.
+
+"""
+
+# Constants in Chudnovsky's series
+CHUD_A = MPZ(13591409)
+CHUD_B = MPZ(545140134)
+CHUD_C = MPZ(640320)
+CHUD_D = MPZ(12)
+
+def bs_chudnovsky(a, b, level, verbose):
+    """
+    Computes the sum from a to b of the series in the Chudnovsky
+    formula. Returns g, p, q where p/q is the sum as an exact
+    fraction and g is a temporary value used to save work
+    for recursive calls.
+    """
+    if b-a == 1:
+        g = MPZ((6*b-5)*(2*b-1)*(6*b-1))
+        p = b**3 * CHUD_C**3 // 24
+        q = (-1)**b * g * (CHUD_A+CHUD_B*b)
+    else:
+        if verbose and level < 4:
+            print("  binary splitting", a, b)
+        mid = (a+b)//2
+        g1, p1, q1 = bs_chudnovsky(a, mid, level+1, verbose)
+        g2, p2, q2 = bs_chudnovsky(mid, b, level+1, verbose)
+        p = p1*p2
+        g = g1*g2
+        q = q1*p2 + q2*g1
+    return g, p, q
+
+@constant_memo
+def pi_fixed(prec, verbose=False, verbose_base=None):
+    """
+    Compute floor(pi * 2**prec) as a big integer.
+
+    This is done using Chudnovsky's series (see comments in
+    libelefun.py for details).
+    """
+    # The Chudnovsky series gives 14.18 digits per term
+    N = int(prec/3.3219280948/14.181647462 + 2)
+    if verbose:
+        print("binary splitting with N =", N)
+    g, p, q = bs_chudnovsky(0, N, 0, verbose)
+    sqrtC = isqrt_fast(CHUD_C<<(2*prec))
+    v = p*CHUD_C*sqrtC//((q+CHUD_A*p)*CHUD_D)
+    return v
+
+def degree_fixed(prec):
+    return pi_fixed(prec)//180
+
+def bspe(a, b):
+    """
+    Sum series for exp(1)-1 between a, b, returning the result
+    as an exact fraction (p, q).
+    """
+    if b-a == 1:
+        return MPZ_ONE, MPZ(b)
+    m = (a+b)//2
+    p1, q1 = bspe(a, m)
+    p2, q2 = bspe(m, b)
+    return p1*q2+p2, q1*q2
+
+@constant_memo
+def e_fixed(prec):
+    """
+    Computes exp(1). This is done using the ordinary Taylor series for
+    exp, with binary splitting. For a description of the algorithm,
+    see:
+
+        http://numbers.computation.free.fr/Constants/
+            Algorithms/splitting.html
+    """
+    # Slight overestimate of N needed for 1/N! < 2**(-prec)
+    # This could be tightened for large N.
+    N = int(1.1*prec/math.log(prec) + 20)
+    p, q = bspe(0,N)
+    return ((p+q)<<prec)//q
+
+@constant_memo
+def phi_fixed(prec):
+    """
+    Computes the golden ratio, (1+sqrt(5))/2
+    """
+    prec += 10
+    a = isqrt_fast(MPZ_FIVE<<(2*prec)) + (MPZ_ONE << prec)
+    return a >> 11
+
+mpf_phi    = def_mpf_constant(phi_fixed)
+mpf_pi     = def_mpf_constant(pi_fixed)
+mpf_e      = def_mpf_constant(e_fixed)
+mpf_degree = def_mpf_constant(degree_fixed)
+mpf_ln2    = def_mpf_constant(ln2_fixed)
+mpf_ln10   = def_mpf_constant(ln10_fixed)
+
+
+@constant_memo
+def ln_sqrt2pi_fixed(prec):
+    wp = prec + 10
+    # ln(sqrt(2*pi)) = ln(2*pi)/2
+    return to_fixed(mpf_log(mpf_shift(mpf_pi(wp), 1), wp), prec-1)
+
+@constant_memo
+def sqrtpi_fixed(prec):
+    return sqrt_fixed(pi_fixed(prec), prec)
+
+mpf_sqrtpi   = def_mpf_constant(sqrtpi_fixed)
+mpf_ln_sqrt2pi   = def_mpf_constant(ln_sqrt2pi_fixed)
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                                    Powers                                  #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def mpf_pow(s, t, prec, rnd=round_fast):
+    """
+    Compute s**t. Raises ComplexResult if s is negative and t is
+    fractional.
+    """
+    ssign, sman, sexp, sbc = s
+    tsign, tman, texp, tbc = t
+    if ssign and texp < 0:
+        raise ComplexResult("negative number raised to a fractional power")
+    if texp >= 0:
+        return mpf_pow_int(s, (-1)**tsign * (tman<<texp), prec, rnd)
+    # s**(n/2) = sqrt(s)**n
+    if texp == -1:
+        if tman == 1:
+            if tsign:
+                return mpf_div(fone, mpf_sqrt(s, prec+10,
+                    reciprocal_rnd[rnd]), prec, rnd)
+            return mpf_sqrt(s, prec, rnd)
+        else:
+            if tsign:
+                return mpf_pow_int(mpf_sqrt(s, prec+10,
+                    reciprocal_rnd[rnd]), -tman, prec, rnd)
+            return mpf_pow_int(mpf_sqrt(s, prec+10, rnd), tman, prec, rnd)
+    # General formula: s**t = exp(t*log(s))
+    # TODO: handle rnd direction of the logarithm carefully
+    c = mpf_log(s, prec+10, rnd)
+    return mpf_exp(mpf_mul(t, c), prec, rnd)
+
+def int_pow_fixed(y, n, prec):
+    """n-th power of a fixed point number with precision prec
+
+       Returns the power in the form man, exp,
+       man * 2**exp ~= y**n
+    """
+    if n == 2:
+        return (y*y), 0
+    bc = bitcount(y)
+    exp = 0
+    workprec = 2 * (prec + 4*bitcount(n) + 4)
+    _, pm, pe, pbc = fone
+    while 1:
+        if n & 1:
+            pm = pm*y
+            pe = pe+exp
+            pbc += bc - 2
+            pbc = pbc + bctable[int(pm >> pbc)]
+            if pbc > workprec:
+                pm = pm >> (pbc-workprec)
+                pe += pbc - workprec
+                pbc = workprec
+            n -= 1
+            if not n:
+                break
+        y = y*y
+        exp = exp+exp
+        bc = bc + bc - 2
+        bc = bc + bctable[int(y >> bc)]
+        if bc > workprec:
+            y = y >> (bc-workprec)
+            exp += bc - workprec
+            bc = workprec
+        n = n // 2
+    return pm, pe
+
+# froot(s, n, prec, rnd) computes the real n-th root of a
+# positive mpf tuple s.
+# To compute the root we start from a 50-bit estimate for r
+# generated with ordinary floating-point arithmetic, and then refine
+# the value to full accuracy using the iteration
+
+#            1  /                     y       \
+#   r     = --- | (n-1)  * r   +  ----------  |
+#    n+1     n  \           n     r_n**(n-1)  /
+
+# which is simply Newton's method applied to the equation r**n = y.
+# With giant_steps(start, prec+extra) = [p0,...,pm, prec+extra]
+# and y = man * 2**-shift  one has
+# (man * 2**exp)**(1/n) =
+# y**(1/n) * 2**(start-prec/n) * 2**(p0-start) * ... * 2**(prec+extra-pm) *
+# 2**((exp+shift-(n-1)*prec)/n -extra))
+# The last factor is accounted for in the last line of froot.
+
+def nthroot_fixed(y, n, prec, exp1):
+    start = 50
+    try:
+        y1 = rshift(y, prec - n*start)
+        r = MPZ(int(y1**(1.0/n)))
+    except OverflowError:
+        y1 = from_int(y1, start)
+        fn = from_int(n)
+        fn = mpf_rdiv_int(1, fn, start)
+        r = mpf_pow(y1, fn, start)
+        r = to_int(r)
+    extra = 10
+    extra1 = n
+    prevp = start
+    for p in giant_steps(start, prec+extra):
+        pm, pe = int_pow_fixed(r, n-1, prevp)
+        r2 = rshift(pm, (n-1)*prevp - p - pe - extra1)
+        B = lshift(y, 2*p-prec+extra1)//r2
+        r = (B + (n-1) * lshift(r, p-prevp))//n
+        prevp = p
+    return r
+
+def mpf_nthroot(s, n, prec, rnd=round_fast):
+    """nth-root of a positive number
+
+    Use the Newton method when faster, otherwise use x**(1/n)
+    """
+    sign, man, exp, bc = s
+    if sign:
+        raise ComplexResult("nth root of a negative number")
+    if not man:
+        if s == fnan:
+            return fnan
+        if s == fzero:
+            if n > 0:
+                return fzero
+            if n == 0:
+                return fone
+            return finf
+        # Infinity
+        if not n:
+            return fnan
+        if n < 0:
+            return fzero
+        return finf
+    flag_inverse = False
+    if n < 2:
+        if n == 0:
+            return fone
+        if n == 1:
+            return mpf_pos(s, prec, rnd)
+        if n == -1:
+            return mpf_div(fone, s, prec, rnd)
+        # n < 0
+        rnd = reciprocal_rnd[rnd]
+        flag_inverse = True
+        extra_inverse = 5
+        prec += extra_inverse
+        n = -n
+    if n > 20 and (n >= 20000 or prec < int(233 + 28.3 * n**0.62)):
+        prec2 = prec + 10
+        fn = from_int(n)
+        nth = mpf_rdiv_int(1, fn, prec2)
+        r = mpf_pow(s, nth, prec2, rnd)
+        s = normalize(r[0], r[1], r[2], r[3], prec, rnd)
+        if flag_inverse:
+            return mpf_div(fone, s, prec-extra_inverse, rnd)
+        else:
+            return s
+    # Convert to a fixed-point number with prec2 bits.
+    prec2 = prec + 2*n - (prec%n)
+    # a few tests indicate that
+    # for 10 < n < 10**4 a bit more precision is needed
+    if n > 10:
+        prec2 += prec2//10
+        prec2 = prec2 - prec2%n
+    # Mantissa may have more bits than we need. Trim it down.
+    shift = bc - prec2
+    # Adjust exponents to make prec2 and exp+shift multiples of n.
+    sign1 = 0
+    es = exp+shift
+    if es < 0:
+        sign1 = 1
+        es = -es
+    if sign1:
+        shift += es%n
+    else:
+        shift -= es%n
+    man = rshift(man, shift)
+    extra = 10
+    exp1 = ((exp+shift-(n-1)*prec2)//n) - extra
+    rnd_shift = 0
+    if flag_inverse:
+        if rnd == 'u' or rnd == 'c':
+            rnd_shift = 1
+    else:
+        if rnd == 'd' or rnd == 'f':
+            rnd_shift = 1
+    man = nthroot_fixed(man+rnd_shift, n, prec2, exp1)
+    s = from_man_exp(man, exp1, prec, rnd)
+    if flag_inverse:
+        return mpf_div(fone, s, prec-extra_inverse, rnd)
+    else:
+        return s
+
+def mpf_cbrt(s, prec, rnd=round_fast):
+    """cubic root of a positive number"""
+    return mpf_nthroot(s, 3, prec, rnd)
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                                Logarithms                                  #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+def log_int_fixed(n, prec, ln2=None):
+    """
+    Fast computation of log(n), caching the value for small n,
+    intended for zeta sums.
+    """
+    if n in log_int_cache:
+        value, vprec = log_int_cache[n]
+        if vprec >= prec:
+            return value >> (vprec - prec)
+    wp = prec + 10
+    if wp <= LOG_TAYLOR_SHIFT:
+        if ln2 is None:
+            ln2 = ln2_fixed(wp)
+        r = bitcount(n)
+        x = n << (wp-r)
+        v = log_taylor_cached(x, wp) + r*ln2
+    else:
+        v = to_fixed(mpf_log(from_int(n), wp+5), wp)
+    if n < MAX_LOG_INT_CACHE:
+        log_int_cache[n] = (v, wp)
+    return v >> (wp-prec)
+
+def agm_fixed(a, b, prec):
+    """
+    Fixed-point computation of agm(a,b), assuming
+    a, b both close to unit magnitude.
+    """
+    i = 0
+    while 1:
+        anew = (a+b)>>1
+        if i > 4 and abs(a-anew) < 8:
+            return a
+        b = isqrt_fast(a*b)
+        a = anew
+        i += 1
+    return a
+
+def log_agm(x, prec):
+    """
+    Fixed-point computation of -log(x) = log(1/x), suitable
+    for large precision. It is required that 0 < x < 1. The
+    algorithm used is the Sasaki-Kanada formula
+
+        -log(x) = pi/agm(theta2(x)^2,theta3(x)^2). [1]
+
+    For faster convergence in the theta functions, x should
+    be chosen closer to 0.
+
+    Guard bits must be added by the caller.
+
+    HYPOTHESIS: if x = 2^(-n), n bits need to be added to
+    account for the truncation to a fixed-point number,
+    and this is the only significant cancellation error.
+
+    The number of bits lost to roundoff is small and can be
+    considered constant.
+
+    [1] Richard P. Brent, "Fast Algorithms for High-Precision
+        Computation of Elementary Functions (extended abstract)",
+        http://wwwmaths.anu.edu.au/~brent/pd/RNC7-Brent.pdf
+
+    """
+    x2 = (x*x) >> prec
+    # Compute jtheta2(x)**2
+    s = a = b = x2
+    while a:
+        b = (b*x2) >> prec
+        a = (a*b) >> prec
+        s += a
+    s += (MPZ_ONE<<prec)
+    s = (s*s)>>(prec-2)
+    s = (s*isqrt_fast(x<<prec))>>prec
+    # Compute jtheta3(x)**2
+    t = a = b = x
+    while a:
+        b = (b*x2) >> prec
+        a = (a*b) >> prec
+        t += a
+    t = (MPZ_ONE<<prec) + (t<<1)
+    t = (t*t)>>prec
+    # Final formula
+    p = agm_fixed(s, t, prec)
+    return (pi_fixed(prec) << prec) // p
+
+def log_taylor(x, prec, r=0):
+    """
+    Fixed-point calculation of log(x). It is assumed that x is close
+    enough to 1 for the Taylor series to converge quickly. Convergence
+    can be improved by specifying r > 0 to compute
+    log(x^(1/2^r))*2^r, at the cost of performing r square roots.
+
+    The caller must provide sufficient guard bits.
+    """
+    for i in xrange(r):
+        x = isqrt_fast(x<<prec)
+    one = MPZ_ONE << prec
+    v = ((x-one)<<prec)//(x+one)
+    sign = v < 0
+    if sign:
+        v = -v
+    v2 = (v*v) >> prec
+    v4 = (v2*v2) >> prec
+    s0 = v
+    s1 = v//3
+    v = (v*v4) >> prec
+    k = 5
+    while v:
+        s0 += v // k
+        k += 2
+        s1 += v // k
+        v = (v*v4) >> prec
+        k += 2
+    s1 = (s1*v2) >> prec
+    s = (s0+s1) << (1+r)
+    if sign:
+        return -s
+    return s
+
+def log_taylor_cached(x, prec):
+    """
+    Fixed-point computation of log(x), assuming x in (0.5, 2)
+    and prec <= LOG_TAYLOR_PREC.
+    """
+    n = x >> (prec-LOG_TAYLOR_SHIFT)
+    cached_prec = cache_prec_steps[prec]
+    dprec = cached_prec - prec
+    if (n, cached_prec) in log_taylor_cache:
+        a, log_a = log_taylor_cache[n, cached_prec]
+    else:
+        a = n << (cached_prec - LOG_TAYLOR_SHIFT)
+        log_a = log_taylor(a, cached_prec, 8)
+        log_taylor_cache[n, cached_prec] = (a, log_a)
+    a >>= dprec
+    log_a >>= dprec
+    u = ((x - a) << prec) // a
+    v = (u << prec) // ((MPZ_TWO << prec) + u)
+    v2 = (v*v) >> prec
+    v4 = (v2*v2) >> prec
+    s0 = v
+    s1 = v//3
+    v = (v*v4) >> prec
+    k = 5
+    while v:
+        s0 += v//k
+        k += 2
+        s1 += v//k
+        v = (v*v4) >> prec
+        k += 2
+    s1 = (s1*v2) >> prec
+    s = (s0+s1) << 1
+    return log_a + s
+
+def mpf_log(x, prec, rnd=round_fast):
+    """
+    Compute the natural logarithm of the mpf value x. If x is negative,
+    ComplexResult is raised.
+    """
+    sign, man, exp, bc = x
+    #------------------------------------------------------------------
+    # Handle special values
+    if not man:
+        if x == fzero: return fninf
+        if x == finf: return finf
+        if x == fnan: return fnan
+    if sign:
+        raise ComplexResult("logarithm of a negative number")
+    wp = prec + 20
+    #------------------------------------------------------------------
+    # Handle log(2^n) = log(n)*2.
+    # Here we catch the only possible exact value, log(1) = 0
+    if man == 1:
+        if not exp:
+            return fzero
+        return from_man_exp(exp*ln2_fixed(wp), -wp, prec, rnd)
+    mag = exp+bc
+    abs_mag = abs(mag)
+    #------------------------------------------------------------------
+    # Handle x = 1+eps, where log(x) ~ x. We need to check for
+    # cancellation when moving to fixed-point math and compensate
+    # by increasing the precision. Note that abs_mag in (0, 1) <=>
+    # 0.5 < x < 2 and x != 1
+    if abs_mag <= 1:
+        # Calculate t = x-1 to measure distance from 1 in bits
+        tsign = 1-abs_mag
+        if tsign:
+            tman = (MPZ_ONE<<bc) - man
+        else:
+            tman = man - (MPZ_ONE<<(bc-1))
+        tbc = bitcount(tman)
+        cancellation = bc - tbc
+        if cancellation > wp:
+            t = normalize(tsign, tman, abs_mag-bc, tbc, tbc, 'n')
+            return mpf_perturb(t, tsign, prec, rnd)
+        else:
+            wp += cancellation
+        # TODO: if close enough to 1, we could use Taylor series
+        # even in the AGM precision range, since the Taylor series
+        # converges rapidly
+    #------------------------------------------------------------------
+    # Another special case:
+    # n*log(2) is a good enough approximation
+    if abs_mag > 10000:
+        if bitcount(abs_mag) > wp:
+            return from_man_exp(exp*ln2_fixed(wp), -wp, prec, rnd)
+    #------------------------------------------------------------------
+    # General case.
+    # Perform argument reduction using log(x) = log(x*2^n) - n*log(2):
+    # If we are in the Taylor precision range, choose magnitude 0 or 1.
+    # If we are in the AGM precision range, choose magnitude -m for
+    # some large m; benchmarking on one machine showed m = prec/20 to be
+    # optimal between 1000 and 100,000 digits.
+    if wp <= LOG_TAYLOR_PREC:
+        m = log_taylor_cached(lshift(man, wp-bc), wp)
+        if mag:
+            m += mag*ln2_fixed(wp)
+    else:
+        optimal_mag = -wp//LOG_AGM_MAG_PREC_RATIO
+        n = optimal_mag - mag
+        x = mpf_shift(x, n)
+        wp += (-optimal_mag)
+        m = -log_agm(to_fixed(x, wp), wp)
+        m -= n*ln2_fixed(wp)
+    return from_man_exp(m, -wp, prec, rnd)
+
+def mpf_log_hypot(a, b, prec, rnd):
+    """
+    Computes log(sqrt(a^2+b^2)) accurately.
+    """
+    # If either a or b is inf/nan/0, assume it to be a
+    if not b[1]:
+        a, b = b, a
+    # a is inf/nan/0
+    if not a[1]:
+        # both are inf/nan/0
+        if not b[1]:
+            if a == b == fzero:
+                return fninf
+            if fnan in (a, b):
+                return fnan
+            # at least one term is (+/- inf)^2
+            return finf
+        # only a is inf/nan/0
+        if a == fzero:
+            # log(sqrt(0+b^2)) = log(|b|)
+            return mpf_log(mpf_abs(b), prec, rnd)
+        if a == fnan:
+            return fnan
+        return finf
+    # Exact
+    a2 = mpf_mul(a,a)
+    b2 = mpf_mul(b,b)
+    extra = 20
+    # Not exact
+    h2 = mpf_add(a2, b2, prec+extra)
+    cancelled = mpf_add(h2, fnone, 10)
+    mag_cancelled = cancelled[2]+cancelled[3]
+    # Just redo the sum exactly if necessary (could be smarter
+    # and avoid memory allocation when a or b is precisely 1
+    # and the other is tiny...)
+    if cancelled == fzero or mag_cancelled < -extra//2:
+        h2 = mpf_add(a2, b2, prec+extra-min(a2[2],b2[2]))
+    return mpf_shift(mpf_log(h2, prec, rnd), -1)
+
+
+#----------------------------------------------------------------------
+# Inverse tangent
+#
+
+def atan_newton(x, prec):
+    if prec >= 100:
+        r = math.atan(int((x>>(prec-53)))/2.0**53)
+    else:
+        r = math.atan(int(x)/2.0**prec)
+    prevp = 50
+    r = MPZ(int(r * 2.0**53) >> (53-prevp))
+    extra_p = 50
+    for wp in giant_steps(prevp, prec):
+        wp += extra_p
+        r = r << (wp-prevp)
+        cos, sin = cos_sin_fixed(r, wp)
+        tan = (sin << wp) // cos
+        a = ((tan-rshift(x, prec-wp)) << wp) // ((MPZ_ONE<<wp) + ((tan**2)>>wp))
+        r = r - a
+        prevp = wp
+    return rshift(r, prevp-prec)
+
+def atan_taylor_get_cached(n, prec):
+    # Taylor series with caching wins up to huge precisions
+    # To avoid unnecessary precomputation at low precision, we
+    # do it in steps
+    # Round to next power of 2
+    prec2 = (1<<(bitcount(prec-1))) + 20
+    dprec = prec2 - prec
+    if (n, prec2) in atan_taylor_cache:
+        a, atan_a = atan_taylor_cache[n, prec2]
+    else:
+        a = n << (prec2 - ATAN_TAYLOR_SHIFT)
+        atan_a = atan_newton(a, prec2)
+        atan_taylor_cache[n, prec2] = (a, atan_a)
+    return (a >> dprec), (atan_a >> dprec)
+
+def atan_taylor(x, prec):
+    n = (x >> (prec-ATAN_TAYLOR_SHIFT))
+    a, atan_a = atan_taylor_get_cached(n, prec)
+    d = x - a
+    s0 = v = (d << prec) // ((a**2 >> prec) + (a*d >> prec) + (MPZ_ONE << prec))
+    v2 = (v**2 >> prec)
+    v4 = (v2 * v2) >> prec
+    s1 = v//3
+    v = (v * v4) >> prec
+    k = 5
+    while v:
+        s0 += v // k
+        k += 2
+        s1 += v // k
+        v = (v * v4) >> prec
+        k += 2
+    s1 = (s1 * v2) >> prec
+    s = s0 - s1
+    return atan_a + s
+
+def atan_inf(sign, prec, rnd):
+    if not sign:
+        return mpf_shift(mpf_pi(prec, rnd), -1)
+    return mpf_neg(mpf_shift(mpf_pi(prec, negative_rnd[rnd]), -1))
+
+def mpf_atan(x, prec, rnd=round_fast):
+    sign, man, exp, bc = x
+    if not man:
+        if x == fzero: return fzero
+        if x == finf: return atan_inf(0, prec, rnd)
+        if x == fninf: return atan_inf(1, prec, rnd)
+        return fnan
+    mag = exp + bc
+    # Essentially infinity
+    if mag > prec+20:
+        return atan_inf(sign, prec, rnd)
+    # Essentially ~ x
+    if -mag > prec+20:
+        return mpf_perturb(x, 1-sign, prec, rnd)
+    wp = prec + 30 + abs(mag)
+    # For large x, use atan(x) = pi/2 - atan(1/x)
+    if mag >= 2:
+        x = mpf_rdiv_int(1, x, wp)
+        reciprocal = True
+    else:
+        reciprocal = False
+    t = to_fixed(x, wp)
+    if sign:
+        t = -t
+    if wp < ATAN_TAYLOR_PREC:
+        a = atan_taylor(t, wp)
+    else:
+        a = atan_newton(t, wp)
+    if reciprocal:
+        a = ((pi_fixed(wp)>>1)+1) - a
+    if sign:
+        a = -a
+    return from_man_exp(a, -wp, prec, rnd)
+
+# TODO: cleanup the special cases
+def mpf_atan2(y, x, prec, rnd=round_fast):
+    xsign, xman, xexp, xbc = x
+    ysign, yman, yexp, ybc = y
+    if not yman:
+        if y == fzero and x != fnan:
+            if mpf_sign(x) >= 0:
+                return fzero
+            return mpf_pi(prec, rnd)
+        if y in (finf, fninf):
+            if x in (finf, fninf):
+                return fnan
+            # pi/2
+            if y == finf:
+                return mpf_shift(mpf_pi(prec, rnd), -1)
+            # -pi/2
+            return mpf_neg(mpf_shift(mpf_pi(prec, negative_rnd[rnd]), -1))
+        return fnan
+    if ysign:
+        return mpf_neg(mpf_atan2(mpf_neg(y), x, prec, negative_rnd[rnd]))
+    if not xman:
+        if x == fnan:
+            return fnan
+        if x == finf:
+            return fzero
+        if x == fninf:
+            return mpf_pi(prec, rnd)
+        if y == fzero:
+            return fzero
+        return mpf_shift(mpf_pi(prec, rnd), -1)
+    tquo = mpf_atan(mpf_div(y, x, prec+4), prec+4)
+    if xsign:
+        return mpf_add(mpf_pi(prec+4), tquo, prec, rnd)
+    else:
+        return mpf_pos(tquo, prec, rnd)
+
+def mpf_asin(x, prec, rnd=round_fast):
+    sign, man, exp, bc = x
+    if bc+exp > 0 and x not in (fone, fnone):
+        raise ComplexResult("asin(x) is real only for -1 <= x <= 1")
+    # asin(x) = 2*atan(x/(1+sqrt(1-x**2)))
+    wp = prec + 15
+    a = mpf_mul(x, x)
+    b = mpf_add(fone, mpf_sqrt(mpf_sub(fone, a, wp), wp), wp)
+    c = mpf_div(x, b, wp)
+    return mpf_shift(mpf_atan(c, prec, rnd), 1)
+
+def mpf_acos(x, prec, rnd=round_fast):
+    # acos(x) = 2*atan(sqrt(1-x**2)/(1+x))
+    sign, man, exp, bc = x
+    if bc + exp > 0:
+        if x not in (fone, fnone):
+            raise ComplexResult("acos(x) is real only for -1 <= x <= 1")
+        if x == fnone:
+            return mpf_pi(prec, rnd)
+    wp = prec + 15
+    a = mpf_mul(x, x)
+    b = mpf_sqrt(mpf_sub(fone, a, wp), wp)
+    c = mpf_div(b, mpf_add(fone, x, wp), wp)
+    return mpf_shift(mpf_atan(c, prec, rnd), 1)
+
+def mpf_asinh(x, prec, rnd=round_fast):
+    wp = prec + 20
+    sign, man, exp, bc = x
+    mag = exp+bc
+    if mag < -8:
+        if mag < -wp:
+            return mpf_perturb(x, 1-sign, prec, rnd)
+        wp += (-mag)
+    # asinh(x) = log(x+sqrt(x**2+1))
+    # use reflection symmetry to avoid cancellation
+    q = mpf_sqrt(mpf_add(mpf_mul(x, x), fone, wp), wp)
+    q = mpf_add(mpf_abs(x), q, wp)
+    if sign:
+        return mpf_neg(mpf_log(q, prec, negative_rnd[rnd]))
+    else:
+        return mpf_log(q, prec, rnd)
+
+def mpf_acosh(x, prec, rnd=round_fast):
+    # acosh(x) = log(x+sqrt(x**2-1))
+    wp = prec + 15
+    if mpf_cmp(x, fone) == -1:
+        raise ComplexResult("acosh(x) is real only for x >= 1")
+    q = mpf_sqrt(mpf_add(mpf_mul(x,x), fnone, wp), wp)
+    return mpf_log(mpf_add(x, q, wp), prec, rnd)
+
+def mpf_atanh(x, prec, rnd=round_fast):
+    # atanh(x) = log((1+x)/(1-x))/2
+    sign, man, exp, bc = x
+    if (not man) and exp:
+        if x in (fzero, fnan):
+            return x
+        raise ComplexResult("atanh(x) is real only for -1 <= x <= 1")
+    mag = bc + exp
+    if mag > 0:
+        if mag == 1 and man == 1:
+            return [finf, fninf][sign]
+        raise ComplexResult("atanh(x) is real only for -1 <= x <= 1")
+    wp = prec + 15
+    if mag < -8:
+        if mag < -wp:
+            return mpf_perturb(x, sign, prec, rnd)
+        wp += (-mag)
+    a = mpf_add(x, fone, wp)
+    b = mpf_sub(fone, x, wp)
+    return mpf_shift(mpf_log(mpf_div(a, b, wp), prec, rnd), -1)
+
+def mpf_fibonacci(x, prec, rnd=round_fast):
+    sign, man, exp, bc = x
+    if not man:
+        if x == fninf:
+            return fnan
+        return x
+    # F(2^n) ~= 2^(2^n)
+    size = abs(exp+bc)
+    if exp >= 0:
+        # Exact
+        if size < 10 or size <= bitcount(prec):
+            return from_int(ifib(to_int(x)), prec, rnd)
+    # Use the modified Binet formula
+    wp = prec + size + 20
+    a = mpf_phi(wp)
+    b = mpf_add(mpf_shift(a, 1), fnone, wp)
+    u = mpf_pow(a, x, wp)
+    v = mpf_cos_pi(x, wp)
+    v = mpf_div(v, u, wp)
+    u = mpf_sub(u, v, wp)
+    u = mpf_div(u, b, prec, rnd)
+    return u
+
+
+#-------------------------------------------------------------------------------
+# Exponential-type functions
+#-------------------------------------------------------------------------------
+
+def exponential_series(x, prec, type=0):
+    """
+    Taylor series for cosh/sinh or cos/sin.
+
+    type = 0 -- returns exp(x)  (slightly faster than cosh+sinh)
+    type = 1 -- returns (cosh(x), sinh(x))
+    type = 2 -- returns (cos(x), sin(x))
+    """
+    if x < 0:
+        x = -x
+        sign = 1
+    else:
+        sign = 0
+    r = int(0.5*prec**0.5)
+    xmag = bitcount(x) - prec
+    r = max(0, xmag + r)
+    extra = 10 + 2*max(r,-xmag)
+    wp = prec + extra
+    x <<= (extra - r)
+    one = MPZ_ONE << wp
+    alt = (type == 2)
+    if prec < EXP_SERIES_U_CUTOFF:
+        x2 = a = (x*x) >> wp
+        x4 = (x2*x2) >> wp
+        s0 = s1 = MPZ_ZERO
+        k = 2
+        while a:
+            a //= (k-1)*k; s0 += a; k += 2
+            a //= (k-1)*k; s1 += a; k += 2
+            a = (a*x4) >> wp
+        s1 = (x2*s1) >> wp
+        if alt:
+            c = s1 - s0 + one
+        else:
+            c = s1 + s0 + one
+    else:
+        u = int(0.3*prec**0.35)
+        x2 = a = (x*x) >> wp
+        xpowers = [one, x2]
+        for i in xrange(1, u):
+            xpowers.append((xpowers[-1]*x2)>>wp)
+        sums = [MPZ_ZERO] * u
+        k = 2
+        while a:
+            for i in xrange(u):
+                a //= (k-1)*k
+                if alt and k & 2: sums[i] -= a
+                else:             sums[i] += a
+                k += 2
+            a = (a*xpowers[-1]) >> wp
+        for i in xrange(1, u):
+            sums[i] = (sums[i]*xpowers[i]) >> wp
+        c = sum(sums) + one
+    if type == 0:
+        s = isqrt_fast(c*c - (one<<wp))
+        if sign:
+            v = c - s
+        else:
+            v = c + s
+        for i in xrange(r):
+            v = (v*v) >> wp
+        return v >> extra
+    else:
+        # Repeatedly apply the double-angle formula
+        # cosh(2*x) = 2*cosh(x)^2 - 1
+        # cos(2*x) = 2*cos(x)^2 - 1
+        pshift = wp-1
+        for i in xrange(r):
+            c = ((c*c) >> pshift) - one
+        # With the abs, this is the same for sinh and sin
+        s = isqrt_fast(abs((one<<wp) - c*c))
+        if sign:
+            s = -s
+        return (c>>extra), (s>>extra)
+
+def exp_basecase(x, prec):
+    """
+    Compute exp(x) as a fixed-point number. Works for any x,
+    but for speed should have |x| < 1. For an arbitrary number,
+    use exp(x) = exp(x-m*log(2)) * 2^m where m = floor(x/log(2)).
+    """
+    if prec > EXP_COSH_CUTOFF:
+        return exponential_series(x, prec, 0)
+    r = int(prec**0.5)
+    prec += r
+    s0 = s1 = (MPZ_ONE << prec)
+    k = 2
+    a = x2 = (x*x) >> prec
+    while a:
+        a //= k; s0 += a; k += 1
+        a //= k; s1 += a; k += 1
+        a = (a*x2) >> prec
+    s1 = (s1*x) >> prec
+    s = s0 + s1
+    u = r
+    while r:
+        s = (s*s) >> prec
+        r -= 1
+    return s >> u
+
+def exp_expneg_basecase(x, prec):
+    """
+    Computation of exp(x), exp(-x)
+    """
+    if prec > EXP_COSH_CUTOFF:
+        cosh, sinh = exponential_series(x, prec, 1)
+        return cosh+sinh, cosh-sinh
+    a = exp_basecase(x, prec)
+    b = (MPZ_ONE << (prec+prec)) // a
+    return a, b
+
+def cos_sin_basecase(x, prec):
+    """
+    Compute cos(x), sin(x) as fixed-point numbers, assuming x
+    in [0, pi/2). For an arbitrary number, use x' = x - m*(pi/2)
+    where m = floor(x/(pi/2)) along with quarter-period symmetries.
+    """
+    if prec > COS_SIN_CACHE_PREC:
+        return exponential_series(x, prec, 2)
+    precs = prec - COS_SIN_CACHE_STEP
+    t = x >> precs
+    n = int(t)
+    if n not in cos_sin_cache:
+        w = t<<(10+COS_SIN_CACHE_PREC-COS_SIN_CACHE_STEP)
+        cos_t, sin_t = exponential_series(w, 10+COS_SIN_CACHE_PREC, 2)
+        cos_sin_cache[n] = (cos_t>>10), (sin_t>>10)
+    cos_t, sin_t = cos_sin_cache[n]
+    offset = COS_SIN_CACHE_PREC - prec
+    cos_t >>= offset
+    sin_t >>= offset
+    x -= t << precs
+    cos = MPZ_ONE << prec
+    sin = x
+    k = 2
+    a = -((x*x) >> prec)
+    while a:
+        a //= k; cos += a; k += 1; a = (a*x) >> prec
+        a //= k; sin += a; k += 1; a = -((a*x) >> prec)
+    return ((cos*cos_t-sin*sin_t) >> prec), ((sin*cos_t+cos*sin_t) >> prec)
+
+def mpf_exp(x, prec, rnd=round_fast):
+    sign, man, exp, bc = x
+    if man:
+        mag = bc + exp
+        wp = prec + 14
+        if sign:
+            man = -man
+        # TODO: the best cutoff depends on both x and the precision.
+        if prec > 600 and exp >= 0:
+            # Need about log2(exp(n)) ~= 1.45*mag extra precision
+            e = mpf_e(wp+int(1.45*mag))
+            return mpf_pow_int(e, man<<exp, prec, rnd)
+        if mag < -wp:
+            return mpf_perturb(fone, sign, prec, rnd)
+        # |x| >= 2
+        if mag > 1:
+            # For large arguments: exp(2^mag*(1+eps)) =
+            # exp(2^mag)*exp(2^mag*eps) = exp(2^mag)*(1 + 2^mag*eps + ...)
+            # so about mag extra bits is required.
+            wpmod = wp + mag
+            offset = exp + wpmod
+            if offset >= 0:
+                t = man << offset
+            else:
+                t = man >> (-offset)
+            lg2 = ln2_fixed(wpmod)
+            n, t = divmod(t, lg2)
+            n = int(n)
+            t >>= mag
+        else:
+            offset = exp + wp
+            if offset >= 0:
+                t = man << offset
+            else:
+                t = man >> (-offset)
+            n = 0
+        man = exp_basecase(t, wp)
+        return from_man_exp(man, n-wp, prec, rnd)
+    if not exp:
+        return fone
+    if x == fninf:
+        return fzero
+    return x
+
+
+def mpf_cosh_sinh(x, prec, rnd=round_fast, tanh=0):
+    """Simultaneously compute (cosh(x), sinh(x)) for real x"""
+    sign, man, exp, bc = x
+    if (not man) and exp:
+        if tanh:
+            if x == finf: return fone
+            if x == fninf: return fnone
+            return fnan
+        if x == finf: return (finf, finf)
+        if x == fninf: return (finf, fninf)
+        return fnan, fnan
+    mag = exp+bc
+    wp = prec+14
+    if mag < -4:
+        # Extremely close to 0, sinh(x) ~= x and cosh(x) ~= 1
+        if mag < -wp:
+            if tanh:
+                return mpf_perturb(x, 1-sign, prec, rnd)
+            cosh = mpf_perturb(fone, 0, prec, rnd)
+            sinh = mpf_perturb(x, sign, prec, rnd)
+            return cosh, sinh
+        # Fix for cancellation when computing sinh
+        wp += (-mag)
+    # Does exp(-2*x) vanish?
+    if mag > 10:
+        if 3*(1<<(mag-1)) > wp:
+            # XXX: rounding
+            if tanh:
+                return mpf_perturb([fone,fnone][sign], 1-sign, prec, rnd)
+            c = s = mpf_shift(mpf_exp(mpf_abs(x), prec, rnd), -1)
+            if sign:
+                s = mpf_neg(s)
+            return c, s
+    # |x| > 1
+    if mag > 1:
+        wpmod = wp + mag
+        offset = exp + wpmod
+        if offset >= 0:
+            t = man << offset
+        else:
+            t = man >> (-offset)
+        lg2 = ln2_fixed(wpmod)
+        n, t = divmod(t, lg2)
+        n = int(n)
+        t >>= mag
+    else:
+        offset = exp + wp
+        if offset >= 0:
+            t = man << offset
+        else:
+            t = man >> (-offset)
+        n = 0
+    a, b = exp_expneg_basecase(t, wp)
+    # TODO: optimize division precision
+    cosh = a + (b>>(2*n))
+    sinh = a - (b>>(2*n))
+    if sign:
+        sinh = -sinh
+    if tanh:
+        man = (sinh << wp) // cosh
+        return from_man_exp(man, -wp, prec, rnd)
+    else:
+        cosh = from_man_exp(cosh, n-wp-1, prec, rnd)
+        sinh = from_man_exp(sinh, n-wp-1, prec, rnd)
+        return cosh, sinh
+
+
+def mod_pi2(man, exp, mag, wp):
+    # Reduce to standard interval
+    if mag > 0:
+        i = 0
+        while 1:
+            cancellation_prec = 20 << i
+            wpmod = wp + mag + cancellation_prec
+            pi2 = pi_fixed(wpmod-1)
+            pi4 = pi2 >> 1
+            offset = wpmod + exp
+            if offset >= 0:
+                t = man << offset
+            else:
+                t = man >> (-offset)
+            n, y = divmod(t, pi2)
+            if y > pi4:
+                small = pi2 - y
+            else:
+                small = y
+            if small >> (wp+mag-10):
+                n = int(n)
+                t = y >> mag
+                wp = wpmod - mag
+                break
+            i += 1
+    else:
+        wp += (-mag)
+        offset = exp + wp
+        if offset >= 0:
+            t = man << offset
+        else:
+            t = man >> (-offset)
+        n = 0
+    return t, n, wp
+
+
+def mpf_cos_sin(x, prec, rnd=round_fast, which=0, pi=False):
+    """
+    which:
+    0 -- return cos(x), sin(x)
+    1 -- return cos(x)
+    2 -- return sin(x)
+    3 -- return tan(x)
+
+    if pi=True, compute for pi*x
+    """
+    sign, man, exp, bc = x
+    if not man:
+        if exp:
+            c, s = fnan, fnan
+        else:
+            c, s = fone, fzero
+        if which == 0: return c, s
+        if which == 1: return c
+        if which == 2: return s
+        if which == 3: return s
+
+    mag = bc + exp
+    wp = prec + 10
+
+    # Extremely small?
+    if mag < 0:
+        if mag < -wp:
+            if pi:
+                x = mpf_mul(x, mpf_pi(wp))
+            c = mpf_perturb(fone, 1, prec, rnd)
+            s = mpf_perturb(x, 1-sign, prec, rnd)
+            if which == 0: return c, s
+            if which == 1: return c
+            if which == 2: return s
+            if which == 3: return mpf_perturb(x, sign, prec, rnd)
+    if pi:
+        if exp >= -1:
+            if exp == -1:
+                c = fzero
+                s = (fone, fnone)[bool(man & 2) ^ sign]
+            elif exp == 0:
+                c, s = (fnone, fzero)
+            else:
+                c, s = (fone, fzero)
+            if which == 0: return c, s
+            if which == 1: return c
+            if which == 2: return s
+            if which == 3: return mpf_div(s, c, prec, rnd)
+        # Subtract nearest half-integer (= mod by pi/2)
+        n = ((man >> (-exp-2)) + 1) >> 1
+        man = man - (n << (-exp-1))
+        mag2 = bitcount(man) + exp
+        wp = prec + 10 - mag2
+        offset = exp + wp
+        if offset >= 0:
+            t = man << offset
+        else:
+            t = man >> (-offset)
+        t = (t*pi_fixed(wp)) >> wp
+    else:
+        t, n, wp = mod_pi2(man, exp, mag, wp)
+    c, s = cos_sin_basecase(t, wp)
+    m = n & 3
+    if   m == 1: c, s = -s, c
+    elif m == 2: c, s = -c, -s
+    elif m == 3: c, s = s, -c
+    if sign:
+        s = -s
+    if which == 0:
+        c = from_man_exp(c, -wp, prec, rnd)
+        s = from_man_exp(s, -wp, prec, rnd)
+        return c, s
+    if which == 1:
+        return from_man_exp(c, -wp, prec, rnd)
+    if which == 2:
+        return from_man_exp(s, -wp, prec, rnd)
+    if which == 3:
+        return from_rational(s, c, prec, rnd)
+
+def mpf_cos(x, prec, rnd=round_fast): return mpf_cos_sin(x, prec, rnd, 1)
+def mpf_sin(x, prec, rnd=round_fast): return mpf_cos_sin(x, prec, rnd, 2)
+def mpf_tan(x, prec, rnd=round_fast): return mpf_cos_sin(x, prec, rnd, 3)
+def mpf_cos_sin_pi(x, prec, rnd=round_fast): return mpf_cos_sin(x, prec, rnd, 0, 1)
+def mpf_cos_pi(x, prec, rnd=round_fast): return mpf_cos_sin(x, prec, rnd, 1, 1)
+def mpf_sin_pi(x, prec, rnd=round_fast): return mpf_cos_sin(x, prec, rnd, 2, 1)
+def mpf_cosh(x, prec, rnd=round_fast): return mpf_cosh_sinh(x, prec, rnd)[0]
+def mpf_sinh(x, prec, rnd=round_fast): return mpf_cosh_sinh(x, prec, rnd)[1]
+def mpf_tanh(x, prec, rnd=round_fast): return mpf_cosh_sinh(x, prec, rnd, tanh=1)
+
+
+# Low-overhead fixed-point versions
+
+def cos_sin_fixed(x, prec, pi2=None):
+    if pi2 is None:
+        pi2 = pi_fixed(prec-1)
+    n, t = divmod(x, pi2)
+    n = int(n)
+    c, s = cos_sin_basecase(t, prec)
+    m = n & 3
+    if m == 0: return c, s
+    if m == 1: return -s, c
+    if m == 2: return -c, -s
+    if m == 3: return s, -c
+
+def exp_fixed(x, prec, ln2=None):
+    if ln2 is None:
+        ln2 = ln2_fixed(prec)
+    n, t = divmod(x, ln2)
+    n = int(n)
+    v = exp_basecase(t, prec)
+    if n >= 0:
+        return v << n
+    else:
+        return v >> (-n)
+
+
+if BACKEND == 'sage':
+    try:
+        import sage.libs.mpmath.ext_libmp as _lbmp
+        mpf_sqrt = _lbmp.mpf_sqrt
+        mpf_exp = _lbmp.mpf_exp
+        mpf_log = _lbmp.mpf_log
+        mpf_cos = _lbmp.mpf_cos
+        mpf_sin = _lbmp.mpf_sin
+        mpf_pow = _lbmp.mpf_pow
+        exp_fixed = _lbmp.exp_fixed
+        cos_sin_fixed = _lbmp.cos_sin_fixed
+        log_int_fixed = _lbmp.log_int_fixed
+    except (ImportError, AttributeError):
+        print("Warning: Sage imports in libelefun failed")
diff --git a/lib/python3.10/site-packages/mpmath/libmp/libhyper.py b/lib/python3.10/site-packages/mpmath/libmp/libhyper.py
new file mode 100644
index 0000000000000000000000000000000000000000..04f52d59710be77819066aea5c1cf4b0883f72d7
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/libmp/libhyper.py
@@ -0,0 +1,1150 @@
+"""
+This module implements computation of hypergeometric and related
+functions. In particular, it provides code for generic summation
+of hypergeometric series. Optimized versions for various special
+cases are also provided.
+"""
+
+import operator
+import math
+
+from .backend import MPZ_ZERO, MPZ_ONE, BACKEND, xrange, exec_
+
+from .libintmath import gcd
+
+from .libmpf import (\
+    ComplexResult, round_fast, round_nearest,
+    negative_rnd, bitcount, to_fixed, from_man_exp, from_int, to_int,
+    from_rational,
+    fzero, fone, fnone, ftwo, finf, fninf, fnan,
+    mpf_sign, mpf_add, mpf_abs, mpf_pos,
+    mpf_cmp, mpf_lt, mpf_le, mpf_gt, mpf_min_max,
+    mpf_perturb, mpf_neg, mpf_shift, mpf_sub, mpf_mul, mpf_div,
+    sqrt_fixed, mpf_sqrt, mpf_rdiv_int, mpf_pow_int,
+    to_rational,
+)
+
+from .libelefun import (\
+    mpf_pi, mpf_exp, mpf_log, pi_fixed, mpf_cos_sin, mpf_cos, mpf_sin,
+    mpf_sqrt, agm_fixed,
+)
+
+from .libmpc import (\
+    mpc_one, mpc_sub, mpc_mul_mpf, mpc_mul, mpc_neg, complex_int_pow,
+    mpc_div, mpc_add_mpf, mpc_sub_mpf,
+    mpc_log, mpc_add, mpc_pos, mpc_shift,
+    mpc_is_infnan, mpc_zero, mpc_sqrt, mpc_abs,
+    mpc_mpf_div, mpc_square, mpc_exp
+)
+
+from .libintmath import ifac
+from .gammazeta import mpf_gamma_int, mpf_euler, euler_fixed
+
+class NoConvergence(Exception):
+    pass
+
+
+#-----------------------------------------------------------------------#
+#                                                                       #
+#                     Generic hypergeometric series                     #
+#                                                                       #
+#-----------------------------------------------------------------------#
+
+"""
+TODO:
+
+1. proper mpq parsing
+2. imaginary z special-cased (also: rational, integer?)
+3. more clever handling of series that don't converge because of stupid
+   upwards rounding
+4. checking for cancellation
+
+"""
+
+def make_hyp_summator(key):
+    """
+    Returns a function that sums a generalized hypergeometric series,
+    for given parameter types (integer, rational, real, complex).
+
+    """
+    p, q, param_types, ztype = key
+
+    pstring = "".join(param_types)
+    fname = "hypsum_%i_%i_%s_%s_%s" % (p, q, pstring[:p], pstring[p:], ztype)
+    #print "generating hypsum", fname
+
+    have_complex_param = 'C' in param_types
+    have_complex_arg = ztype == 'C'
+    have_complex = have_complex_param or have_complex_arg
+
+    source = []
+    add = source.append
+
+    aint = []
+    arat = []
+    bint = []
+    brat = []
+    areal = []
+    breal = []
+    acomplex = []
+    bcomplex = []
+
+    #add("wp = prec + 40")
+    add("MAX = kwargs.get('maxterms', wp*100)")
+    add("HIGH = MPZ_ONE<<epsshift")
+    add("LOW = -HIGH")
+
+    # Setup code
+    add("SRE = PRE = one = (MPZ_ONE << wp)")
+    if have_complex:
+        add("SIM = PIM = MPZ_ZERO")
+
+    if have_complex_arg:
+        add("xsign, xm, xe, xbc = z[0]")
+        add("if xsign: xm = -xm")
+        add("ysign, ym, ye, ybc = z[1]")
+        add("if ysign: ym = -ym")
+    else:
+        add("xsign, xm, xe, xbc = z")
+        add("if xsign: xm = -xm")
+
+    add("offset = xe + wp")
+    add("if offset >= 0:")
+    add("    ZRE = xm << offset")
+    add("else:")
+    add("    ZRE = xm >> (-offset)")
+    if have_complex_arg:
+        add("offset = ye + wp")
+        add("if offset >= 0:")
+        add("    ZIM = ym << offset")
+        add("else:")
+        add("    ZIM = ym >> (-offset)")
+
+    for i, flag in enumerate(param_types):
+        W = ["A", "B"][i >= p]
+        if flag == 'Z':
+            ([aint,bint][i >= p]).append(i)
+            add("%sINT_%i = coeffs[%i]" % (W, i, i))
+        elif flag == 'Q':
+            ([arat,brat][i >= p]).append(i)
+            add("%sP_%i, %sQ_%i = coeffs[%i]._mpq_" % (W, i, W, i, i))
+        elif flag == 'R':
+            ([areal,breal][i >= p]).append(i)
+            add("xsign, xm, xe, xbc = coeffs[%i]._mpf_" % i)
+            add("if xsign: xm = -xm")
+            add("offset = xe + wp")
+            add("if offset >= 0:")
+            add("    %sREAL_%i = xm << offset" % (W, i))
+            add("else:")
+            add("    %sREAL_%i = xm >> (-offset)" % (W, i))
+        elif flag == 'C':
+            ([acomplex,bcomplex][i >= p]).append(i)
+            add("__re, __im = coeffs[%i]._mpc_" % i)
+            add("xsign, xm, xe, xbc = __re")
+            add("if xsign: xm = -xm")
+            add("ysign, ym, ye, ybc = __im")
+            add("if ysign: ym = -ym")
+
+            add("offset = xe + wp")
+            add("if offset >= 0:")
+            add("    %sCRE_%i = xm << offset" % (W, i))
+            add("else:")
+            add("    %sCRE_%i = xm >> (-offset)" % (W, i))
+            add("offset = ye + wp")
+            add("if offset >= 0:")
+            add("    %sCIM_%i = ym << offset" % (W, i))
+            add("else:")
+            add("    %sCIM_%i = ym >> (-offset)" % (W, i))
+        else:
+            raise ValueError
+
+    l_areal = len(areal)
+    l_breal = len(breal)
+    cancellable_real = min(l_areal, l_breal)
+    noncancellable_real_num = areal[cancellable_real:]
+    noncancellable_real_den = breal[cancellable_real:]
+
+    # LOOP
+    add("for n in xrange(1,10**8):")
+
+    add("    if n in magnitude_check:")
+    add("        p_mag = bitcount(abs(PRE))")
+    if have_complex:
+        add("        p_mag = max(p_mag, bitcount(abs(PIM)))")
+    add("        magnitude_check[n] = wp-p_mag")
+
+    # Real factors
+    multiplier = " * ".join(["AINT_#".replace("#", str(i)) for i in aint] + \
+                            ["AP_#".replace("#", str(i)) for i in arat] + \
+                            ["BQ_#".replace("#", str(i)) for i in brat])
+
+    divisor    = " * ".join(["BINT_#".replace("#", str(i)) for i in bint] + \
+                            ["BP_#".replace("#", str(i)) for i in brat] + \
+                            ["AQ_#".replace("#", str(i)) for i in arat] + ["n"])
+
+    if multiplier:
+        add("    mul = " + multiplier)
+    add("    div = " + divisor)
+
+    # Check for singular terms
+    add("    if not div:")
+    if multiplier:
+        add("        if not mul:")
+        add("            break")
+    add("        raise ZeroDivisionError")
+
+    # Update product
+    if have_complex:
+
+        # TODO: when there are several real parameters and just a few complex
+        # (maybe just the complex argument), we only need to do about
+        # half as many ops if we accumulate the real factor in a single real variable
+        for k in range(cancellable_real): add("    PRE = PRE * AREAL_%i // BREAL_%i" % (areal[k], breal[k]))
+        for i in noncancellable_real_num: add("    PRE = (PRE * AREAL_#) >> wp".replace("#", str(i)))
+        for i in noncancellable_real_den: add("    PRE = (PRE << wp) // BREAL_#".replace("#", str(i)))
+        for k in range(cancellable_real): add("    PIM = PIM * AREAL_%i // BREAL_%i" % (areal[k], breal[k]))
+        for i in noncancellable_real_num: add("    PIM = (PIM * AREAL_#) >> wp".replace("#", str(i)))
+        for i in noncancellable_real_den: add("    PIM = (PIM << wp) // BREAL_#".replace("#", str(i)))
+
+        if multiplier:
+            if have_complex_arg:
+                add("    PRE, PIM = (mul*(PRE*ZRE-PIM*ZIM))//div, (mul*(PIM*ZRE+PRE*ZIM))//div")
+                add("    PRE >>= wp")
+                add("    PIM >>= wp")
+            else:
+                add("    PRE = ((mul * PRE * ZRE) >> wp) // div")
+                add("    PIM = ((mul * PIM * ZRE) >> wp) // div")
+        else:
+            if have_complex_arg:
+                add("    PRE, PIM = (PRE*ZRE-PIM*ZIM)//div, (PIM*ZRE+PRE*ZIM)//div")
+                add("    PRE >>= wp")
+                add("    PIM >>= wp")
+            else:
+                add("    PRE = ((PRE * ZRE) >> wp) // div")
+                add("    PIM = ((PIM * ZRE) >> wp) // div")
+
+        for i in acomplex:
+            add("    PRE, PIM = PRE*ACRE_#-PIM*ACIM_#, PIM*ACRE_#+PRE*ACIM_#".replace("#", str(i)))
+            add("    PRE >>= wp")
+            add("    PIM >>= wp")
+
+        for i in bcomplex:
+            add("    mag = BCRE_#*BCRE_#+BCIM_#*BCIM_#".replace("#", str(i)))
+            add("    re = PRE*BCRE_# + PIM*BCIM_#".replace("#", str(i)))
+            add("    im = PIM*BCRE_# - PRE*BCIM_#".replace("#", str(i)))
+            add("    PRE = (re << wp) // mag".replace("#", str(i)))
+            add("    PIM = (im << wp) // mag".replace("#", str(i)))
+
+    else:
+        for k in range(cancellable_real): add("    PRE = PRE * AREAL_%i // BREAL_%i" % (areal[k], breal[k]))
+        for i in noncancellable_real_num: add("    PRE = (PRE * AREAL_#) >> wp".replace("#", str(i)))
+        for i in noncancellable_real_den: add("    PRE = (PRE << wp) // BREAL_#".replace("#", str(i)))
+        if multiplier:
+            add("    PRE = ((PRE * mul * ZRE) >> wp) // div")
+        else:
+            add("    PRE = ((PRE * ZRE) >> wp) // div")
+
+    # Add product to sum
+    if have_complex:
+        add("    SRE += PRE")
+        add("    SIM += PIM")
+        add("    if (HIGH > PRE > LOW) and (HIGH > PIM > LOW):")
+        add("        break")
+    else:
+        add("    SRE += PRE")
+        add("    if HIGH > PRE > LOW:")
+        add("        break")
+
+    #add("    from mpmath import nprint, log, ldexp")
+    #add("    nprint([n, log(abs(PRE),2), ldexp(PRE,-wp)])")
+
+    add("    if n > MAX:")
+    add("        raise NoConvergence('Hypergeometric series converges too slowly. Try increasing maxterms.')")
+
+    # +1 all parameters for next loop
+    for i in aint:     add("    AINT_# += 1".replace("#", str(i)))
+    for i in bint:     add("    BINT_# += 1".replace("#", str(i)))
+    for i in arat:     add("    AP_# += AQ_#".replace("#", str(i)))
+    for i in brat:     add("    BP_# += BQ_#".replace("#", str(i)))
+    for i in areal:    add("    AREAL_# += one".replace("#", str(i)))
+    for i in breal:    add("    BREAL_# += one".replace("#", str(i)))
+    for i in acomplex: add("    ACRE_# += one".replace("#", str(i)))
+    for i in bcomplex: add("    BCRE_# += one".replace("#", str(i)))
+
+    if have_complex:
+        add("a = from_man_exp(SRE, -wp, prec, 'n')")
+        add("b = from_man_exp(SIM, -wp, prec, 'n')")
+
+        add("if SRE:")
+        add("    if SIM:")
+        add("        magn = max(a[2]+a[3], b[2]+b[3])")
+        add("    else:")
+        add("        magn = a[2]+a[3]")
+        add("elif SIM:")
+        add("    magn = b[2]+b[3]")
+        add("else:")
+        add("    magn = -wp+1")
+
+        add("return (a, b), True, magn")
+    else:
+        add("a = from_man_exp(SRE, -wp, prec, 'n')")
+
+        add("if SRE:")
+        add("    magn = a[2]+a[3]")
+        add("else:")
+        add("    magn = -wp+1")
+
+        add("return a, False, magn")
+
+    source = "\n".join(("    " + line) for line in source)
+    source = ("def %s(coeffs, z, prec, wp, epsshift, magnitude_check, **kwargs):\n" % fname) + source
+
+    namespace = {}
+
+    exec_(source, globals(), namespace)
+
+    #print source
+    return source, namespace[fname]
+
+
+if BACKEND == 'sage':
+
+    def make_hyp_summator(key):
+        """
+        Returns a function that sums a generalized hypergeometric series,
+        for given parameter types (integer, rational, real, complex).
+        """
+        from sage.libs.mpmath.ext_main import hypsum_internal
+        p, q, param_types, ztype = key
+        def _hypsum(coeffs, z, prec, wp, epsshift, magnitude_check, **kwargs):
+            return hypsum_internal(p, q, param_types, ztype, coeffs, z,
+                prec, wp, epsshift, magnitude_check, kwargs)
+
+        return "(none)", _hypsum
+
+
+#-----------------------------------------------------------------------#
+#                                                                       #
+#                              Error functions                          #
+#                                                                       #
+#-----------------------------------------------------------------------#
+
+# TODO: mpf_erf should call mpf_erfc when appropriate (currently
+#    only the converse delegation is implemented)
+
+def mpf_erf(x, prec, rnd=round_fast):
+    sign, man, exp, bc = x
+    if not man:
+        if x == fzero: return fzero
+        if x == finf: return fone
+        if x== fninf: return fnone
+        return fnan
+    size = exp + bc
+    lg = math.log
+    # The approximation erf(x) = 1 is accurate to > x^2 * log(e,2) bits
+    if size > 3 and 2*(size-1) + 0.528766 > lg(prec,2):
+        if sign:
+            return mpf_perturb(fnone, 0, prec, rnd)
+        else:
+            return mpf_perturb(fone, 1, prec, rnd)
+    # erf(x) ~ 2*x/sqrt(pi) close to 0
+    if size < -prec:
+        # 2*x
+        x = mpf_shift(x,1)
+        c = mpf_sqrt(mpf_pi(prec+20), prec+20)
+        # TODO: interval rounding
+        return mpf_div(x, c, prec, rnd)
+    wp = prec + abs(size) + 25
+    # Taylor series for erf, fixed-point summation
+    t = abs(to_fixed(x, wp))
+    t2 = (t*t) >> wp
+    s, term, k = t, 12345, 1
+    while term:
+        t = ((t * t2) >> wp) // k
+        term = t // (2*k+1)
+        if k & 1:
+            s -= term
+        else:
+            s += term
+        k += 1
+    s = (s << (wp+1)) // sqrt_fixed(pi_fixed(wp), wp)
+    if sign:
+        s = -s
+    return from_man_exp(s, -wp, prec, rnd)
+
+# If possible, we use the asymptotic series for erfc.
+# This is an alternating divergent asymptotic series, so
+# the error is at most equal to the first omitted term.
+# Here we check if the smallest term is small enough
+# for a given x and precision
+def erfc_check_series(x, prec):
+    n = to_int(x)
+    if n**2 * 1.44 > prec:
+        return True
+    return False
+
+def mpf_erfc(x, prec, rnd=round_fast):
+    sign, man, exp, bc = x
+    if not man:
+        if x == fzero: return fone
+        if x == finf: return fzero
+        if x == fninf: return ftwo
+        return fnan
+    wp = prec + 20
+    mag = bc+exp
+    # Preserve full accuracy when exponent grows huge
+    wp += max(0, 2*mag)
+    regular_erf = sign or mag < 2
+    if regular_erf or not erfc_check_series(x, wp):
+        if regular_erf:
+            return mpf_sub(fone, mpf_erf(x, prec+10, negative_rnd[rnd]), prec, rnd)
+        # 1-erf(x) ~ exp(-x^2), increase prec to deal with cancellation
+        n = to_int(x)+1
+        return mpf_sub(fone, mpf_erf(x, prec + int(n**2*1.44) + 10), prec, rnd)
+    s = term = MPZ_ONE << wp
+    term_prev = 0
+    t = (2 * to_fixed(x, wp) ** 2) >> wp
+    k = 1
+    while 1:
+        term = ((term * (2*k - 1)) << wp) // t
+        if k > 4 and term > term_prev or not term:
+            break
+        if k & 1:
+            s -= term
+        else:
+            s += term
+        term_prev = term
+        #print k, to_str(from_man_exp(term, -wp, 50), 10)
+        k += 1
+    s = (s << wp) // sqrt_fixed(pi_fixed(wp), wp)
+    s = from_man_exp(s, -wp, wp)
+    z = mpf_exp(mpf_neg(mpf_mul(x,x,wp),wp),wp)
+    y = mpf_div(mpf_mul(z, s, wp), x, prec, rnd)
+    return y
+
+
+#-----------------------------------------------------------------------#
+#                                                                       #
+#                         Exponential integrals                         #
+#                                                                       #
+#-----------------------------------------------------------------------#
+
+def ei_taylor(x, prec):
+    s = t = x
+    k = 2
+    while t:
+        t = ((t*x) >> prec) // k
+        s += t // k
+        k += 1
+    return s
+
+def complex_ei_taylor(zre, zim, prec):
+    _abs = abs
+    sre = tre = zre
+    sim = tim = zim
+    k = 2
+    while _abs(tre) + _abs(tim) > 5:
+        tre, tim = ((tre*zre-tim*zim)//k)>>prec, ((tre*zim+tim*zre)//k)>>prec
+        sre += tre // k
+        sim += tim // k
+        k += 1
+    return sre, sim
+
+def ei_asymptotic(x, prec):
+    one = MPZ_ONE << prec
+    x = t = ((one << prec) // x)
+    s = one + x
+    k = 2
+    while t:
+        t = (k*t*x) >> prec
+        s += t
+        k += 1
+    return s
+
+def complex_ei_asymptotic(zre, zim, prec):
+    _abs = abs
+    one = MPZ_ONE << prec
+    M = (zim*zim + zre*zre) >> prec
+    # 1 / z
+    xre = tre = (zre << prec) // M
+    xim = tim = ((-zim) << prec) // M
+    sre = one + xre
+    sim = xim
+    k = 2
+    while _abs(tre) + _abs(tim) > 1000:
+        #print tre, tim
+        tre, tim = ((tre*xre-tim*xim)*k)>>prec, ((tre*xim+tim*xre)*k)>>prec
+        sre += tre
+        sim += tim
+        k += 1
+        if k > prec:
+            raise NoConvergence
+    return sre, sim
+
+def mpf_ei(x, prec, rnd=round_fast, e1=False):
+    if e1:
+        x = mpf_neg(x)
+    sign, man, exp, bc = x
+    if e1 and not sign:
+        if x == fzero:
+            return finf
+        raise ComplexResult("E1(x) for x < 0")
+    if man:
+        xabs = 0, man, exp, bc
+        xmag = exp+bc
+        wp = prec + 20
+        can_use_asymp = xmag > wp
+        if not can_use_asymp:
+            if exp >= 0:
+                xabsint = man << exp
+            else:
+                xabsint = man >> (-exp)
+            can_use_asymp = xabsint > int(wp*0.693) + 10
+        if can_use_asymp:
+            if xmag > wp:
+                v = fone
+            else:
+                v = from_man_exp(ei_asymptotic(to_fixed(x, wp), wp), -wp)
+            v = mpf_mul(v, mpf_exp(x, wp), wp)
+            v = mpf_div(v, x, prec, rnd)
+        else:
+            wp += 2*int(to_int(xabs))
+            u = to_fixed(x, wp)
+            v = ei_taylor(u, wp) + euler_fixed(wp)
+            t1 = from_man_exp(v,-wp)
+            t2 = mpf_log(xabs,wp)
+            v = mpf_add(t1, t2, prec, rnd)
+    else:
+        if x == fzero: v = fninf
+        elif x == finf: v = finf
+        elif x == fninf: v = fzero
+        else: v = fnan
+    if e1:
+        v = mpf_neg(v)
+    return v
+
+def mpc_ei(z, prec, rnd=round_fast, e1=False):
+    if e1:
+        z = mpc_neg(z)
+    a, b = z
+    asign, aman, aexp, abc = a
+    bsign, bman, bexp, bbc = b
+    if b == fzero:
+        if e1:
+            x = mpf_neg(mpf_ei(a, prec, rnd))
+            if not asign:
+                y = mpf_neg(mpf_pi(prec, rnd))
+            else:
+                y = fzero
+            return x, y
+        else:
+            return mpf_ei(a, prec, rnd), fzero
+    if a != fzero:
+        if not aman or not bman:
+            return (fnan, fnan)
+    wp = prec + 40
+    amag = aexp+abc
+    bmag = bexp+bbc
+    zmag = max(amag, bmag)
+    can_use_asymp = zmag > wp
+    if not can_use_asymp:
+        zabsint = abs(to_int(a)) + abs(to_int(b))
+        can_use_asymp = zabsint > int(wp*0.693) + 20
+    try:
+        if can_use_asymp:
+            if zmag > wp:
+                v = fone, fzero
+            else:
+                zre = to_fixed(a, wp)
+                zim = to_fixed(b, wp)
+                vre, vim = complex_ei_asymptotic(zre, zim, wp)
+                v = from_man_exp(vre, -wp), from_man_exp(vim, -wp)
+            v = mpc_mul(v, mpc_exp(z, wp), wp)
+            v = mpc_div(v, z, wp)
+            if e1:
+                v = mpc_neg(v, prec, rnd)
+            else:
+                x, y = v
+                if bsign:
+                    v = mpf_pos(x, prec, rnd), mpf_sub(y, mpf_pi(wp), prec, rnd)
+                else:
+                    v = mpf_pos(x, prec, rnd), mpf_add(y, mpf_pi(wp), prec, rnd)
+            return v
+    except NoConvergence:
+        pass
+    #wp += 2*max(0,zmag)
+    wp += 2*int(to_int(mpc_abs(z, 5)))
+    zre = to_fixed(a, wp)
+    zim = to_fixed(b, wp)
+    vre, vim = complex_ei_taylor(zre, zim, wp)
+    vre += euler_fixed(wp)
+    v = from_man_exp(vre,-wp), from_man_exp(vim,-wp)
+    if e1:
+        u = mpc_log(mpc_neg(z),wp)
+    else:
+        u = mpc_log(z,wp)
+    v = mpc_add(v, u, prec, rnd)
+    if e1:
+        v = mpc_neg(v)
+    return v
+
+def mpf_e1(x, prec, rnd=round_fast):
+    return mpf_ei(x, prec, rnd, True)
+
+def mpc_e1(x, prec, rnd=round_fast):
+    return mpc_ei(x, prec, rnd, True)
+
+def mpf_expint(n, x, prec, rnd=round_fast, gamma=False):
+    """
+    E_n(x), n an integer, x real
+
+    With gamma=True, computes Gamma(n,x)   (upper incomplete gamma function)
+
+    Returns (real, None) if real, otherwise (real, imag)
+    The imaginary part is an optional branch cut term
+
+    """
+    sign, man, exp, bc = x
+    if not man:
+        if gamma:
+            if x == fzero:
+                # Actually gamma function pole
+                if n <= 0:
+                    return finf, None
+                return mpf_gamma_int(n, prec, rnd), None
+            if x == finf:
+                return fzero, None
+            # TODO: could return finite imaginary value at -inf
+            return fnan, fnan
+        else:
+            if x == fzero:
+                if n > 1:
+                    return from_rational(1, n-1, prec, rnd), None
+                else:
+                    return finf, None
+            if x == finf:
+                return fzero, None
+            return fnan, fnan
+    n_orig = n
+    if gamma:
+        n = 1-n
+    wp = prec + 20
+    xmag = exp + bc
+    # Beware of near-poles
+    if xmag < -10:
+        raise NotImplementedError
+    nmag = bitcount(abs(n))
+    have_imag = n > 0 and sign
+    negx = mpf_neg(x)
+    # Skip series if direct convergence
+    if n == 0 or 2*nmag - xmag < -wp:
+        if gamma:
+            v = mpf_exp(negx, wp)
+            re = mpf_mul(v, mpf_pow_int(x, n_orig-1, wp), prec, rnd)
+        else:
+            v = mpf_exp(negx, wp)
+            re = mpf_div(v, x, prec, rnd)
+    else:
+        # Finite number of terms, or...
+        can_use_asymptotic_series = -3*wp < n <= 0
+        # ...large enough?
+        if not can_use_asymptotic_series:
+            xi = abs(to_int(x))
+            m = min(max(1, xi-n), 2*wp)
+            siz = -n*nmag + (m+n)*bitcount(abs(m+n)) - m*xmag - (144*m//100)
+            tol = -wp-10
+            can_use_asymptotic_series = siz < tol
+        if can_use_asymptotic_series:
+            r = ((-MPZ_ONE) << (wp+wp)) // to_fixed(x, wp)
+            m = n
+            t = r*m
+            s = MPZ_ONE << wp
+            while m and t:
+                s += t
+                m += 1
+                t = (m*r*t) >> wp
+            v = mpf_exp(negx, wp)
+            if gamma:
+                # ~ exp(-x) * x^(n-1) * (1 + ...)
+                v = mpf_mul(v, mpf_pow_int(x, n_orig-1, wp), wp)
+            else:
+                # ~ exp(-x)/x * (1 + ...)
+                v = mpf_div(v, x, wp)
+            re = mpf_mul(v, from_man_exp(s, -wp), prec, rnd)
+        elif n == 1:
+            re = mpf_neg(mpf_ei(negx, prec, rnd))
+        elif n > 0 and n < 3*wp:
+            T1 = mpf_neg(mpf_ei(negx, wp))
+            if gamma:
+                if n_orig & 1:
+                    T1 = mpf_neg(T1)
+            else:
+                T1 = mpf_mul(T1, mpf_pow_int(negx, n-1, wp), wp)
+            r = t = to_fixed(x, wp)
+            facs = [1] * (n-1)
+            for k in range(1,n-1):
+                facs[k] = facs[k-1] * k
+            facs = facs[::-1]
+            s = facs[0] << wp
+            for k in range(1, n-1):
+                if k & 1:
+                    s -= facs[k] * t
+                else:
+                    s += facs[k] * t
+                t = (t*r) >> wp
+            T2 = from_man_exp(s, -wp, wp)
+            T2 = mpf_mul(T2, mpf_exp(negx, wp))
+            if gamma:
+                T2 = mpf_mul(T2, mpf_pow_int(x, n_orig, wp), wp)
+            R = mpf_add(T1, T2)
+            re = mpf_div(R, from_int(ifac(n-1)), prec, rnd)
+        else:
+            raise NotImplementedError
+    if have_imag:
+        M = from_int(-ifac(n-1))
+        if gamma:
+            im = mpf_div(mpf_pi(wp), M, prec, rnd)
+            if n_orig & 1:
+                im = mpf_neg(im)
+        else:
+            im = mpf_div(mpf_mul(mpf_pi(wp), mpf_pow_int(negx, n_orig-1, wp), wp), M, prec, rnd)
+        return re, im
+    else:
+        return re, None
+
+def mpf_ci_si_taylor(x, wp, which=0):
+    """
+    0 - Ci(x) - (euler+log(x))
+    1 - Si(x)
+    """
+    x = to_fixed(x, wp)
+    x2 = -(x*x) >> wp
+    if which == 0:
+        s, t, k = 0, (MPZ_ONE<<wp), 2
+    else:
+        s, t, k = x, x, 3
+    while t:
+        t = (t*x2//(k*(k-1)))>>wp
+        s += t//k
+        k += 2
+    return from_man_exp(s, -wp)
+
+def mpc_ci_si_taylor(re, im, wp, which=0):
+    # The following code is only designed for small arguments,
+    # and not too small arguments (for relative accuracy)
+    if re[1]:
+        mag = re[2]+re[3]
+    elif im[1]:
+        mag = im[2]+im[3]
+    if im[1]:
+        mag = max(mag, im[2]+im[3])
+    if mag > 2 or mag < -wp:
+        raise NotImplementedError
+    wp += (2-mag)
+    zre = to_fixed(re, wp)
+    zim = to_fixed(im, wp)
+    z2re = (zim*zim-zre*zre)>>wp
+    z2im = (-2*zre*zim)>>wp
+    tre = zre
+    tim = zim
+    one = MPZ_ONE<<wp
+    if which == 0:
+        sre, sim, tre, tim, k = 0, 0, (MPZ_ONE<<wp), 0, 2
+    else:
+        sre, sim, tre, tim, k = zre, zim, zre, zim, 3
+    while max(abs(tre), abs(tim)) > 2:
+        f = k*(k-1)
+        tre, tim = ((tre*z2re-tim*z2im)//f)>>wp, ((tre*z2im+tim*z2re)//f)>>wp
+        sre += tre//k
+        sim += tim//k
+        k += 2
+    return from_man_exp(sre, -wp), from_man_exp(sim, -wp)
+
+def mpf_ci_si(x, prec, rnd=round_fast, which=2):
+    """
+    Calculation of Ci(x), Si(x) for real x.
+
+    which = 0 -- returns (Ci(x), -)
+    which = 1 -- returns (Si(x), -)
+    which = 2 -- returns (Ci(x), Si(x))
+
+    Note: if x < 0, Ci(x) needs an additional imaginary term, pi*i.
+    """
+    wp = prec + 20
+    sign, man, exp, bc = x
+    ci, si = None, None
+    if not man:
+        if x == fzero:
+            return (fninf, fzero)
+        if x == fnan:
+            return (x, x)
+        ci = fzero
+        if which != 0:
+            if x == finf:
+                si = mpf_shift(mpf_pi(prec, rnd), -1)
+            if x == fninf:
+                si = mpf_neg(mpf_shift(mpf_pi(prec, negative_rnd[rnd]), -1))
+        return (ci, si)
+    # For small x: Ci(x) ~ euler + log(x), Si(x) ~ x
+    mag = exp+bc
+    if mag < -wp:
+        if which != 0:
+            si = mpf_perturb(x, 1-sign, prec, rnd)
+        if which != 1:
+            y = mpf_euler(wp)
+            xabs = mpf_abs(x)
+            ci = mpf_add(y, mpf_log(xabs, wp), prec, rnd)
+        return ci, si
+    # For huge x: Ci(x) ~ sin(x)/x, Si(x) ~ pi/2
+    elif mag > wp:
+        if which != 0:
+            if sign:
+                si = mpf_neg(mpf_pi(prec, negative_rnd[rnd]))
+            else:
+                si = mpf_pi(prec, rnd)
+            si = mpf_shift(si, -1)
+        if which != 1:
+            ci = mpf_div(mpf_sin(x, wp), x, prec, rnd)
+        return ci, si
+    else:
+        wp += abs(mag)
+    # Use an asymptotic series? The smallest value of n!/x^n
+    # occurs for n ~ x, where the magnitude is ~ exp(-x).
+    asymptotic = mag-1 > math.log(wp, 2)
+    # Case 1: convergent series near 0
+    if not asymptotic:
+        if which != 0:
+            si = mpf_pos(mpf_ci_si_taylor(x, wp, 1), prec, rnd)
+        if which != 1:
+            ci = mpf_ci_si_taylor(x, wp, 0)
+            ci = mpf_add(ci, mpf_euler(wp), wp)
+            ci = mpf_add(ci, mpf_log(mpf_abs(x), wp), prec, rnd)
+        return ci, si
+    x = mpf_abs(x)
+    # Case 2: asymptotic series for x >> 1
+    xf = to_fixed(x, wp)
+    xr = (MPZ_ONE<<(2*wp)) // xf   # 1/x
+    s1 = (MPZ_ONE << wp)
+    s2 = xr
+    t = xr
+    k = 2
+    while t:
+        t = -t
+        t = (t*xr*k)>>wp
+        k += 1
+        s1 += t
+        t = (t*xr*k)>>wp
+        k += 1
+        s2 += t
+    s1 = from_man_exp(s1, -wp)
+    s2 = from_man_exp(s2, -wp)
+    s1 = mpf_div(s1, x, wp)
+    s2 = mpf_div(s2, x, wp)
+    cos, sin = mpf_cos_sin(x, wp)
+    # Ci(x) = sin(x)*s1-cos(x)*s2
+    # Si(x) = pi/2-cos(x)*s1-sin(x)*s2
+    if which != 0:
+        si = mpf_add(mpf_mul(cos, s1), mpf_mul(sin, s2), wp)
+        si = mpf_sub(mpf_shift(mpf_pi(wp), -1), si, wp)
+        if sign:
+            si = mpf_neg(si)
+        si = mpf_pos(si, prec, rnd)
+    if which != 1:
+        ci = mpf_sub(mpf_mul(sin, s1), mpf_mul(cos, s2), prec, rnd)
+    return ci, si
+
+def mpf_ci(x, prec, rnd=round_fast):
+    if mpf_sign(x) < 0:
+        raise ComplexResult
+    return mpf_ci_si(x, prec, rnd, 0)[0]
+
+def mpf_si(x, prec, rnd=round_fast):
+    return mpf_ci_si(x, prec, rnd, 1)[1]
+
+def mpc_ci(z, prec, rnd=round_fast):
+    re, im = z
+    if im == fzero:
+        ci = mpf_ci_si(re, prec, rnd, 0)[0]
+        if mpf_sign(re) < 0:
+            return (ci, mpf_pi(prec, rnd))
+        return (ci, fzero)
+    wp = prec + 20
+    cre, cim = mpc_ci_si_taylor(re, im, wp, 0)
+    cre = mpf_add(cre, mpf_euler(wp), wp)
+    ci = mpc_add((cre, cim), mpc_log(z, wp), prec, rnd)
+    return ci
+
+def mpc_si(z, prec, rnd=round_fast):
+    re, im = z
+    if im == fzero:
+        return (mpf_ci_si(re, prec, rnd, 1)[1], fzero)
+    wp = prec + 20
+    z = mpc_ci_si_taylor(re, im, wp, 1)
+    return mpc_pos(z, prec, rnd)
+
+
+#-----------------------------------------------------------------------#
+#                                                                       #
+#                             Bessel functions                          #
+#                                                                       #
+#-----------------------------------------------------------------------#
+
+# A Bessel function of the first kind of integer order, J_n(x), is
+# given by the power series
+
+#             oo
+#             ___         k         2 k + n
+#            \        (-1)     / x \
+#    J_n(x) = )    ----------- | - |
+#            /___  k! (k + n)! \ 2 /
+#            k = 0
+
+# Simplifying the quotient between two successive terms gives the
+# ratio x^2 / (-4*k*(k+n)). Hence, we only need one full-precision
+# multiplication and one division by a small integer per term.
+# The complex version is very similar, the only difference being
+# that the multiplication is actually 4 multiplies.
+
+# In the general case, we have
+# J_v(x) = (x/2)**v / v! * 0F1(v+1, (-1/4)*z**2)
+
+# TODO: for extremely large x, we could use an asymptotic
+# trigonometric approximation.
+
+# TODO: recompute at higher precision if the fixed-point mantissa
+# is very small
+
+def mpf_besseljn(n, x, prec, rounding=round_fast):
+    prec += 50
+    negate = n < 0 and n & 1
+    mag = x[2]+x[3]
+    n = abs(n)
+    wp = prec + 20 + n*bitcount(n)
+    if mag < 0:
+        wp -= n * mag
+    x = to_fixed(x, wp)
+    x2 = (x**2) >> wp
+    if not n:
+        s = t = MPZ_ONE << wp
+    else:
+        s = t = (x**n // ifac(n)) >> ((n-1)*wp + n)
+    k = 1
+    while t:
+        t = ((t * x2) // (-4*k*(k+n))) >> wp
+        s += t
+        k += 1
+    if negate:
+        s = -s
+    return from_man_exp(s, -wp, prec, rounding)
+
+def mpc_besseljn(n, z, prec, rounding=round_fast):
+    negate = n < 0 and n & 1
+    n = abs(n)
+    origprec = prec
+    zre, zim = z
+    mag = max(zre[2]+zre[3], zim[2]+zim[3])
+    prec += 20 + n*bitcount(n) + abs(mag)
+    if mag < 0:
+        prec -= n * mag
+    zre = to_fixed(zre, prec)
+    zim = to_fixed(zim, prec)
+    z2re = (zre**2 - zim**2) >> prec
+    z2im = (zre*zim) >> (prec-1)
+    if not n:
+        sre = tre = MPZ_ONE << prec
+        sim = tim = MPZ_ZERO
+    else:
+        re, im = complex_int_pow(zre, zim, n)
+        sre = tre = (re // ifac(n)) >> ((n-1)*prec + n)
+        sim = tim = (im // ifac(n)) >> ((n-1)*prec + n)
+    k = 1
+    while abs(tre) + abs(tim) > 3:
+        p = -4*k*(k+n)
+        tre, tim = tre*z2re - tim*z2im, tim*z2re + tre*z2im
+        tre = (tre // p) >> prec
+        tim = (tim // p) >> prec
+        sre += tre
+        sim += tim
+        k += 1
+    if negate:
+        sre = -sre
+        sim = -sim
+    re = from_man_exp(sre, -prec, origprec, rounding)
+    im = from_man_exp(sim, -prec, origprec, rounding)
+    return (re, im)
+
+def mpf_agm(a, b, prec, rnd=round_fast):
+    """
+    Computes the arithmetic-geometric mean agm(a,b) for
+    nonnegative mpf values a, b.
+    """
+    asign, aman, aexp, abc = a
+    bsign, bman, bexp, bbc = b
+    if asign or bsign:
+        raise ComplexResult("agm of a negative number")
+    # Handle inf, nan or zero in either operand
+    if not (aman and bman):
+        if a == fnan or b == fnan:
+            return fnan
+        if a == finf:
+            if b == fzero:
+                return fnan
+            return finf
+        if b == finf:
+            if a == fzero:
+                return fnan
+            return finf
+        # agm(0,x) = agm(x,0) = 0
+        return fzero
+    wp = prec + 20
+    amag = aexp+abc
+    bmag = bexp+bbc
+    mag_delta = amag - bmag
+    # Reduce to roughly the same magnitude using floating-point AGM
+    abs_mag_delta = abs(mag_delta)
+    if abs_mag_delta > 10:
+        while abs_mag_delta > 10:
+            a, b = mpf_shift(mpf_add(a,b,wp),-1), \
+                mpf_sqrt(mpf_mul(a,b,wp),wp)
+            abs_mag_delta //= 2
+        asign, aman, aexp, abc = a
+        bsign, bman, bexp, bbc = b
+        amag = aexp+abc
+        bmag = bexp+bbc
+        mag_delta = amag - bmag
+    #print to_float(a), to_float(b)
+    # Use agm(a,b) = agm(x*a,x*b)/x to obtain a, b ~= 1
+    min_mag = min(amag,bmag)
+    max_mag = max(amag,bmag)
+    n = 0
+    # If too small, we lose precision when going to fixed-point
+    if min_mag < -8:
+        n = -min_mag
+    # If too large, we waste time using fixed-point with large numbers
+    elif max_mag > 20:
+        n = -max_mag
+    if n:
+        a = mpf_shift(a, n)
+        b = mpf_shift(b, n)
+    #print to_float(a), to_float(b)
+    af = to_fixed(a, wp)
+    bf = to_fixed(b, wp)
+    g = agm_fixed(af, bf, wp)
+    return from_man_exp(g, -wp-n, prec, rnd)
+
+def mpf_agm1(a, prec, rnd=round_fast):
+    """
+    Computes the arithmetic-geometric mean agm(1,a) for a nonnegative
+    mpf value a.
+    """
+    return mpf_agm(fone, a, prec, rnd)
+
+def mpc_agm(a, b, prec, rnd=round_fast):
+    """
+    Complex AGM.
+
+    TODO:
+    * check that convergence works as intended
+    * optimize
+    * select a nonarbitrary branch
+    """
+    if mpc_is_infnan(a) or mpc_is_infnan(b):
+        return fnan, fnan
+    if mpc_zero in (a, b):
+        return fzero, fzero
+    if mpc_neg(a) == b:
+        return fzero, fzero
+    wp = prec+20
+    eps = mpf_shift(fone, -wp+10)
+    while 1:
+        a1 = mpc_shift(mpc_add(a, b, wp), -1)
+        b1 = mpc_sqrt(mpc_mul(a, b, wp), wp)
+        a, b = a1, b1
+        size = mpf_min_max([mpc_abs(a,10), mpc_abs(b,10)])[1]
+        err = mpc_abs(mpc_sub(a, b, 10), 10)
+        if size == fzero or mpf_lt(err, mpf_mul(eps, size)):
+            return a
+
+def mpc_agm1(a, prec, rnd=round_fast):
+    return mpc_agm(mpc_one, a, prec, rnd)
+
+def mpf_ellipk(x, prec, rnd=round_fast):
+    if not x[1]:
+        if x == fzero:
+            return mpf_shift(mpf_pi(prec, rnd), -1)
+        if x == fninf:
+            return fzero
+        if x == fnan:
+            return x
+    if x == fone:
+        return finf
+    # TODO: for |x| << 1/2, one could use fall back to
+    # pi/2 * hyp2f1_rat((1,2),(1,2),(1,1), x)
+    wp = prec + 15
+    # Use K(x) = pi/2/agm(1,a) where a = sqrt(1-x)
+    # The sqrt raises ComplexResult if x > 0
+    a = mpf_sqrt(mpf_sub(fone, x, wp), wp)
+    v = mpf_agm1(a, wp)
+    r = mpf_div(mpf_pi(wp), v, prec, rnd)
+    return mpf_shift(r, -1)
+
+def mpc_ellipk(z, prec, rnd=round_fast):
+    re, im = z
+    if im == fzero:
+        if re == finf:
+            return mpc_zero
+        if mpf_le(re, fone):
+            return mpf_ellipk(re, prec, rnd), fzero
+    wp = prec + 15
+    a = mpc_sqrt(mpc_sub(mpc_one, z, wp), wp)
+    v = mpc_agm1(a, wp)
+    r = mpc_mpf_div(mpf_pi(wp), v, prec, rnd)
+    return mpc_shift(r, -1)
+
+def mpf_ellipe(x, prec, rnd=round_fast):
+    # http://functions.wolfram.com/EllipticIntegrals/
+    # EllipticK/20/01/0001/
+    # E = (1-m)*(K'(m)*2*m + K(m))
+    sign, man, exp, bc = x
+    if not man:
+        if x == fzero:
+            return mpf_shift(mpf_pi(prec, rnd), -1)
+        if x == fninf:
+            return finf
+        if x == fnan:
+            return x
+        if x == finf:
+            raise ComplexResult
+    if x == fone:
+        return fone
+    wp = prec+20
+    mag = exp+bc
+    if mag < -wp:
+        return mpf_shift(mpf_pi(prec, rnd), -1)
+    # Compute a finite difference for K'
+    p = max(mag, 0) - wp
+    h = mpf_shift(fone, p)
+    K = mpf_ellipk(x, 2*wp)
+    Kh = mpf_ellipk(mpf_sub(x, h), 2*wp)
+    Kdiff = mpf_shift(mpf_sub(K, Kh), -p)
+    t = mpf_sub(fone, x)
+    b = mpf_mul(Kdiff, mpf_shift(x,1), wp)
+    return mpf_mul(t, mpf_add(K, b), prec, rnd)
+
+def mpc_ellipe(z, prec, rnd=round_fast):
+    re, im = z
+    if im == fzero:
+        if re == finf:
+            return (fzero, finf)
+        if mpf_le(re, fone):
+            return mpf_ellipe(re, prec, rnd), fzero
+    wp = prec + 15
+    mag = mpc_abs(z, 1)
+    p = max(mag[2]+mag[3], 0) - wp
+    h = mpf_shift(fone, p)
+    K = mpc_ellipk(z, 2*wp)
+    Kh = mpc_ellipk(mpc_add_mpf(z, h, 2*wp), 2*wp)
+    Kdiff = mpc_shift(mpc_sub(Kh, K, wp), -p)
+    t = mpc_sub(mpc_one, z, wp)
+    b = mpc_mul(Kdiff, mpc_shift(z,1), wp)
+    return mpc_mul(t, mpc_add(K, b, wp), prec, rnd)
diff --git a/lib/python3.10/site-packages/mpmath/libmp/libintmath.py b/lib/python3.10/site-packages/mpmath/libmp/libintmath.py
new file mode 100644
index 0000000000000000000000000000000000000000..7880546e135639208d136488408b102ad41682a2
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/libmp/libintmath.py
@@ -0,0 +1,584 @@
+"""
+Utility functions for integer math.
+
+TODO: rename, cleanup, perhaps move the gmpy wrapper code
+here from settings.py
+
+"""
+
+import math
+from bisect import bisect
+
+from .backend import xrange
+from .backend import BACKEND, gmpy, sage, sage_utils, MPZ, MPZ_ONE, MPZ_ZERO
+
+small_trailing = [0] * 256
+for j in range(1,8):
+    small_trailing[1<<j::1<<(j+1)] = [j] * (1<<(7-j))
+
+def giant_steps(start, target, n=2):
+    """
+    Return a list of integers ~=
+
+    [start, n*start, ..., target/n^2, target/n, target]
+
+    but conservatively rounded so that the quotient between two
+    successive elements is actually slightly less than n.
+
+    With n = 2, this describes suitable precision steps for a
+    quadratically convergent algorithm such as Newton's method;
+    with n = 3 steps for cubic convergence (Halley's method), etc.
+
+        >>> giant_steps(50,1000)
+        [66, 128, 253, 502, 1000]
+        >>> giant_steps(50,1000,4)
+        [65, 252, 1000]
+
+    """
+    L = [target]
+    while L[-1] > start*n:
+        L = L + [L[-1]//n + 2]
+    return L[::-1]
+
+def rshift(x, n):
+    """For an integer x, calculate x >> n with the fastest (floor)
+    rounding. Unlike the plain Python expression (x >> n), n is
+    allowed to be negative, in which case a left shift is performed."""
+    if n >= 0: return x >> n
+    else:      return x << (-n)
+
+def lshift(x, n):
+    """For an integer x, calculate x << n. Unlike the plain Python
+    expression (x << n), n is allowed to be negative, in which case a
+    right shift with default (floor) rounding is performed."""
+    if n >= 0: return x << n
+    else:      return x >> (-n)
+
+if BACKEND == 'sage':
+    import operator
+    rshift = operator.rshift
+    lshift = operator.lshift
+
+def python_trailing(n):
+    """Count the number of trailing zero bits in abs(n)."""
+    if not n:
+        return 0
+    low_byte = n & 0xff
+    if low_byte:
+        return small_trailing[low_byte]
+    t = 8
+    n >>= 8
+    while not n & 0xff:
+        n >>= 8
+        t += 8
+    return t + small_trailing[n & 0xff]
+
+if BACKEND == 'gmpy':
+    if gmpy.version() >= '2':
+        def gmpy_trailing(n):
+            """Count the number of trailing zero bits in abs(n) using gmpy."""
+            if n: return MPZ(n).bit_scan1()
+            else: return 0
+    else:
+        def gmpy_trailing(n):
+            """Count the number of trailing zero bits in abs(n) using gmpy."""
+            if n: return MPZ(n).scan1()
+            else: return 0
+
+# Small powers of 2
+powers = [1<<_ for _ in range(300)]
+
+def python_bitcount(n):
+    """Calculate bit size of the nonnegative integer n."""
+    bc = bisect(powers, n)
+    if bc != 300:
+        return bc
+    bc = int(math.log(n, 2)) - 4
+    return bc + bctable[n>>bc]
+
+def gmpy_bitcount(n):
+    """Calculate bit size of the nonnegative integer n."""
+    if n: return MPZ(n).numdigits(2)
+    else: return 0
+
+#def sage_bitcount(n):
+#    if n: return MPZ(n).nbits()
+#    else: return 0
+
+def sage_trailing(n):
+    return MPZ(n).trailing_zero_bits()
+
+if BACKEND == 'gmpy':
+    bitcount = gmpy_bitcount
+    trailing = gmpy_trailing
+elif BACKEND == 'sage':
+    sage_bitcount = sage_utils.bitcount
+    bitcount = sage_bitcount
+    trailing = sage_trailing
+else:
+    bitcount = python_bitcount
+    trailing = python_trailing
+
+if BACKEND == 'gmpy' and 'bit_length' in dir(gmpy):
+    bitcount = gmpy.bit_length
+
+# Used to avoid slow function calls as far as possible
+trailtable = [trailing(n) for n in range(256)]
+bctable = [bitcount(n) for n in range(1024)]
+
+# TODO: speed up for bases 2, 4, 8, 16, ...
+
+def bin_to_radix(x, xbits, base, bdigits):
+    """Changes radix of a fixed-point number; i.e., converts
+    x * 2**xbits to floor(x * 10**bdigits)."""
+    return x * (MPZ(base)**bdigits) >> xbits
+
+stddigits = '0123456789abcdefghijklmnopqrstuvwxyz'
+
+def small_numeral(n, base=10, digits=stddigits):
+    """Return the string numeral of a positive integer in an arbitrary
+    base. Most efficient for small input."""
+    if base == 10:
+        return str(n)
+    digs = []
+    while n:
+        n, digit = divmod(n, base)
+        digs.append(digits[digit])
+    return "".join(digs[::-1])
+
+def numeral_python(n, base=10, size=0, digits=stddigits):
+    """Represent the integer n as a string of digits in the given base.
+    Recursive division is used to make this function about 3x faster
+    than Python's str() for converting integers to decimal strings.
+
+    The 'size' parameters specifies the number of digits in n; this
+    number is only used to determine splitting points and need not be
+    exact."""
+    if n <= 0:
+        if not n:
+            return "0"
+        return "-" + numeral(-n, base, size, digits)
+    # Fast enough to do directly
+    if size < 250:
+        return small_numeral(n, base, digits)
+    # Divide in half
+    half = (size // 2) + (size & 1)
+    A, B = divmod(n, base**half)
+    ad = numeral(A, base, half, digits)
+    bd = numeral(B, base, half, digits).rjust(half, "0")
+    return ad + bd
+
+def numeral_gmpy(n, base=10, size=0, digits=stddigits):
+    """Represent the integer n as a string of digits in the given base.
+    Recursive division is used to make this function about 3x faster
+    than Python's str() for converting integers to decimal strings.
+
+    The 'size' parameters specifies the number of digits in n; this
+    number is only used to determine splitting points and need not be
+    exact."""
+    if n < 0:
+        return "-" + numeral(-n, base, size, digits)
+    # gmpy.digits() may cause a segmentation fault when trying to convert
+    # extremely large values to a string. The size limit may need to be
+    # adjusted on some platforms, but 1500000 works on Windows and Linux.
+    if size < 1500000:
+        return gmpy.digits(n, base)
+    # Divide in half
+    half = (size // 2) + (size & 1)
+    A, B = divmod(n, MPZ(base)**half)
+    ad = numeral(A, base, half, digits)
+    bd = numeral(B, base, half, digits).rjust(half, "0")
+    return ad + bd
+
+if BACKEND == "gmpy":
+    numeral = numeral_gmpy
+else:
+    numeral = numeral_python
+
+_1_800 = 1<<800
+_1_600 = 1<<600
+_1_400 = 1<<400
+_1_200 = 1<<200
+_1_100 = 1<<100
+_1_50 = 1<<50
+
+def isqrt_small_python(x):
+    """
+    Correctly (floor) rounded integer square root, using
+    division. Fast up to ~200 digits.
+    """
+    if not x:
+        return x
+    if x < _1_800:
+        # Exact with IEEE double precision arithmetic
+        if x < _1_50:
+            return int(x**0.5)
+        # Initial estimate can be any integer >= the true root; round up
+        r = int(x**0.5 * 1.00000000000001) + 1
+    else:
+        bc = bitcount(x)
+        n = bc//2
+        r = int((x>>(2*n-100))**0.5+2)<<(n-50)  # +2 is to round up
+    # The following iteration now precisely computes floor(sqrt(x))
+    # See e.g. Crandall & Pomerance, "Prime Numbers: A Computational
+    # Perspective"
+    while 1:
+        y = (r+x//r)>>1
+        if y >= r:
+            return r
+        r = y
+
+def isqrt_fast_python(x):
+    """
+    Fast approximate integer square root, computed using division-free
+    Newton iteration for large x. For random integers the result is almost
+    always correct (floor(sqrt(x))), but is 1 ulp too small with a roughly
+    0.1% probability. If x is very close to an exact square, the answer is
+    1 ulp wrong with high probability.
+
+    With 0 guard bits, the largest error over a set of 10^5 random
+    inputs of size 1-10^5 bits was 3 ulp. The use of 10 guard bits
+    almost certainly guarantees a max 1 ulp error.
+    """
+    # Use direct division-based iteration if sqrt(x) < 2^400
+    # Assume floating-point square root accurate to within 1 ulp, then:
+    # 0 Newton iterations good to 52 bits
+    # 1 Newton iterations good to 104 bits
+    # 2 Newton iterations good to 208 bits
+    # 3 Newton iterations good to 416 bits
+    if x < _1_800:
+        y = int(x**0.5)
+        if x >= _1_100:
+            y = (y + x//y) >> 1
+            if x >= _1_200:
+                y = (y + x//y) >> 1
+                if x >= _1_400:
+                    y = (y + x//y) >> 1
+        return y
+    bc = bitcount(x)
+    guard_bits = 10
+    x <<= 2*guard_bits
+    bc += 2*guard_bits
+    bc += (bc&1)
+    hbc = bc//2
+    startprec = min(50, hbc)
+    # Newton iteration for 1/sqrt(x), with floating-point starting value
+    r = int(2.0**(2*startprec) * (x >> (bc-2*startprec)) ** -0.5)
+    pp = startprec
+    for p in giant_steps(startprec, hbc):
+        # r**2, scaled from real size 2**(-bc) to 2**p
+        r2 = (r*r) >> (2*pp - p)
+        # x*r**2, scaled from real size ~1.0 to 2**p
+        xr2 = ((x >> (bc-p)) * r2) >> p
+        # New value of r, scaled from real size 2**(-bc/2) to 2**p
+        r = (r * ((3<<p) - xr2)) >> (pp+1)
+        pp = p
+    # (1/sqrt(x))*x = sqrt(x)
+    return (r*(x>>hbc)) >> (p+guard_bits)
+
+def sqrtrem_python(x):
+    """Correctly rounded integer (floor) square root with remainder."""
+    # to check cutoff:
+    # plot(lambda x: timing(isqrt, 2**int(x)), [0,2000])
+    if x < _1_600:
+        y = isqrt_small_python(x)
+        return y, x - y*y
+    y = isqrt_fast_python(x) + 1
+    rem = x - y*y
+    # Correct remainder
+    while rem < 0:
+        y -= 1
+        rem += (1+2*y)
+    else:
+        if rem:
+            while rem > 2*(1+y):
+                y += 1
+                rem -= (1+2*y)
+    return y, rem
+
+def isqrt_python(x):
+    """Integer square root with correct (floor) rounding."""
+    return sqrtrem_python(x)[0]
+
+def sqrt_fixed(x, prec):
+    return isqrt_fast(x<<prec)
+
+sqrt_fixed2 = sqrt_fixed
+
+if BACKEND == 'gmpy':
+    if gmpy.version() >= '2':
+        isqrt_small = isqrt_fast = isqrt = gmpy.isqrt
+        sqrtrem = gmpy.isqrt_rem
+    else:
+        isqrt_small = isqrt_fast = isqrt = gmpy.sqrt
+        sqrtrem = gmpy.sqrtrem
+elif BACKEND == 'sage':
+    isqrt_small = isqrt_fast = isqrt = \
+        getattr(sage_utils, "isqrt", lambda n: MPZ(n).isqrt())
+    sqrtrem = lambda n: MPZ(n).sqrtrem()
+else:
+    isqrt_small = isqrt_small_python
+    isqrt_fast = isqrt_fast_python
+    isqrt = isqrt_python
+    sqrtrem = sqrtrem_python
+
+
+def ifib(n, _cache={}):
+    """Computes the nth Fibonacci number as an integer, for
+    integer n."""
+    if n < 0:
+        return (-1)**(-n+1) * ifib(-n)
+    if n in _cache:
+        return _cache[n]
+    m = n
+    # Use Dijkstra's logarithmic algorithm
+    # The following implementation is basically equivalent to
+    # http://en.literateprograms.org/Fibonacci_numbers_(Scheme)
+    a, b, p, q = MPZ_ONE, MPZ_ZERO, MPZ_ZERO, MPZ_ONE
+    while n:
+        if n & 1:
+            aq = a*q
+            a, b = b*q+aq+a*p, b*p+aq
+            n -= 1
+        else:
+            qq = q*q
+            p, q = p*p+qq, qq+2*p*q
+            n >>= 1
+    if m < 250:
+        _cache[m] = b
+    return b
+
+MAX_FACTORIAL_CACHE = 1000
+
+def ifac(n, memo={0:1, 1:1}):
+    """Return n factorial (for integers n >= 0 only)."""
+    f = memo.get(n)
+    if f:
+        return f
+    k = len(memo)
+    p = memo[k-1]
+    MAX = MAX_FACTORIAL_CACHE
+    while k <= n:
+        p *= k
+        if k <= MAX:
+            memo[k] = p
+        k += 1
+    return p
+
+def ifac2(n, memo_pair=[{0:1}, {1:1}]):
+    """Return n!! (double factorial), integers n >= 0 only."""
+    memo = memo_pair[n&1]
+    f = memo.get(n)
+    if f:
+        return f
+    k = max(memo)
+    p = memo[k]
+    MAX = MAX_FACTORIAL_CACHE
+    while k < n:
+        k += 2
+        p *= k
+        if k <= MAX:
+            memo[k] = p
+    return p
+
+if BACKEND == 'gmpy':
+    ifac = gmpy.fac
+elif BACKEND == 'sage':
+    ifac = lambda n: int(sage.factorial(n))
+    ifib = sage.fibonacci
+
+def list_primes(n):
+    n = n + 1
+    sieve = list(xrange(n))
+    sieve[:2] = [0, 0]
+    for i in xrange(2, int(n**0.5)+1):
+        if sieve[i]:
+            for j in xrange(i**2, n, i):
+                sieve[j] = 0
+    return [p for p in sieve if p]
+
+if BACKEND == 'sage':
+    # Note: it is *VERY* important for performance that we convert
+    # the list to Python ints.
+    def list_primes(n):
+        return [int(_) for _ in sage.primes(n+1)]
+
+small_odd_primes = (3,5,7,11,13,17,19,23,29,31,37,41,43,47)
+small_odd_primes_set = set(small_odd_primes)
+
+def isprime(n):
+    """
+    Determines whether n is a prime number. A probabilistic test is
+    performed if n is very large. No special trick is used for detecting
+    perfect powers.
+
+        >>> sum(list_primes(100000))
+        454396537
+        >>> sum(n*isprime(n) for n in range(100000))
+        454396537
+
+    """
+    n = int(n)
+    if not n & 1:
+        return n == 2
+    if n < 50:
+        return n in small_odd_primes_set
+    for p in small_odd_primes:
+        if not n % p:
+            return False
+    m = n-1
+    s = trailing(m)
+    d = m >> s
+    def test(a):
+        x = pow(a,d,n)
+        if x == 1 or x == m:
+            return True
+        for r in xrange(1,s):
+            x = x**2 % n
+            if x == m:
+                return True
+        return False
+    # See http://primes.utm.edu/prove/prove2_3.html
+    if n < 1373653:
+        witnesses = [2,3]
+    elif n < 341550071728321:
+        witnesses = [2,3,5,7,11,13,17]
+    else:
+        witnesses = small_odd_primes
+    for a in witnesses:
+        if not test(a):
+            return False
+    return True
+
+def moebius(n):
+    """
+    Evaluates the Moebius function which is `mu(n) = (-1)^k` if `n`
+    is a product of `k` distinct primes and `mu(n) = 0` otherwise.
+
+    TODO: speed up using factorization
+    """
+    n = abs(int(n))
+    if n < 2:
+        return n
+    factors = []
+    for p in xrange(2, n+1):
+        if not (n % p):
+            if not (n % p**2):
+                return 0
+            if not sum(p % f for f in factors):
+                factors.append(p)
+    return (-1)**len(factors)
+
+def gcd(*args):
+    a = 0
+    for b in args:
+        if a:
+            while b:
+                a, b = b, a % b
+        else:
+            a = b
+    return a
+
+
+#  Comment by Juan Arias de Reyna:
+#
+#  I learn this method to compute EulerE[2n] from van de Lune.
+#
+#  We apply the formula   EulerE[2n] = (-1)^n 2**(-2n) sum_{j=0}^n a(2n,2j+1)
+#
+#  where the numbers a(n,j) vanish for  j > n+1 or j <= -1  and satisfies
+#
+#  a(0,-1) = a(0,0) = 0;  a(0,1)= 1; a(0,2) = a(0,3) = 0
+#
+#  a(n,j) = a(n-1,j)                              when n+j is even
+#  a(n,j) = (j-1) a(n-1,j-1) + (j+1) a(n-1,j+1)   when n+j is odd
+#
+#
+#  But we can use only one array unidimensional a(j) since to compute
+#  a(n,j) we only need to know a(n-1,k) where k and j are of different parity
+#  and we have not to conserve the used values.
+#
+#  We cached up the values of Euler numbers to sufficiently high order.
+#
+#  Important Observation: If we pretend to use the numbers
+#     EulerE[1], EulerE[2], ... , EulerE[n]
+#     it is convenient to compute first EulerE[n], since the algorithm
+#     computes first all
+#     the previous ones, and keeps them in the CACHE
+
+MAX_EULER_CACHE = 500
+
+def eulernum(m, _cache={0:MPZ_ONE}):
+    r"""
+    Computes the Euler numbers `E(n)`, which can be defined as
+    coefficients of the Taylor expansion of `1/cosh x`:
+
+    .. math ::
+
+        \frac{1}{\cosh x} = \sum_{n=0}^\infty \frac{E_n}{n!} x^n
+
+    Example::
+
+        >>> [int(eulernum(n)) for n in range(11)]
+        [1, 0, -1, 0, 5, 0, -61, 0, 1385, 0, -50521]
+        >>> [int(eulernum(n)) for n in range(11)]   # test cache
+        [1, 0, -1, 0, 5, 0, -61, 0, 1385, 0, -50521]
+
+    """
+    # for odd m > 1, the Euler numbers are zero
+    if m & 1:
+        return MPZ_ZERO
+    f = _cache.get(m)
+    if f:
+        return f
+    MAX = MAX_EULER_CACHE
+    n = m
+    a = [MPZ(_) for _ in [0,0,1,0,0,0]]
+    for  n in range(1, m+1):
+        for j in range(n+1, -1, -2):
+            a[j+1] = (j-1)*a[j] + (j+1)*a[j+2]
+        a.append(0)
+        suma = 0
+        for k in range(n+1, -1, -2):
+            suma += a[k+1]
+            if n <= MAX:
+                _cache[n] = ((-1)**(n//2))*(suma // 2**n)
+        if n == m:
+            return ((-1)**(n//2))*suma // 2**n
+
+def stirling1(n, k):
+    """
+    Stirling number of the first kind.
+    """
+    if n < 0 or k < 0:
+        raise ValueError
+    if k >= n:
+        return MPZ(n == k)
+    if k < 1:
+        return MPZ_ZERO
+    L = [MPZ_ZERO] * (k+1)
+    L[1] = MPZ_ONE
+    for m in xrange(2, n+1):
+        for j in xrange(min(k, m), 0, -1):
+            L[j] = (m-1) * L[j] + L[j-1]
+    return (-1)**(n+k) * L[k]
+
+def stirling2(n, k):
+    """
+    Stirling number of the second kind.
+    """
+    if n < 0 or k < 0:
+        raise ValueError
+    if k >= n:
+        return MPZ(n == k)
+    if k <= 1:
+        return MPZ(k == 1)
+    s = MPZ_ZERO
+    t = MPZ_ONE
+    for j in xrange(k+1):
+        if (k + j) & 1:
+            s -= t * MPZ(j)**n
+        else:
+            s += t * MPZ(j)**n
+        t = t * (k - j) // (j + 1)
+    return s // ifac(k)
diff --git a/lib/python3.10/site-packages/mpmath/libmp/libmpc.py b/lib/python3.10/site-packages/mpmath/libmp/libmpc.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc22d0e73674676c8a9249ebc2d48da7f3be8b0d
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/libmp/libmpc.py
@@ -0,0 +1,835 @@
+"""
+Low-level functions for complex arithmetic.
+"""
+
+import sys
+
+from .backend import MPZ, MPZ_ZERO, MPZ_ONE, MPZ_TWO, BACKEND
+
+from .libmpf import (\
+    round_floor, round_ceiling, round_down, round_up,
+    round_nearest, round_fast, bitcount,
+    bctable, normalize, normalize1, reciprocal_rnd, rshift, lshift, giant_steps,
+    negative_rnd,
+    to_str, to_fixed, from_man_exp, from_float, to_float, from_int, to_int,
+    fzero, fone, ftwo, fhalf, finf, fninf, fnan, fnone,
+    mpf_abs, mpf_pos, mpf_neg, mpf_add, mpf_sub, mpf_mul,
+    mpf_div, mpf_mul_int, mpf_shift, mpf_sqrt, mpf_hypot,
+    mpf_rdiv_int, mpf_floor, mpf_ceil, mpf_nint, mpf_frac,
+    mpf_sign, mpf_hash,
+    ComplexResult
+)
+
+from .libelefun import (\
+    mpf_pi, mpf_exp, mpf_log, mpf_cos_sin, mpf_cosh_sinh, mpf_tan, mpf_pow_int,
+    mpf_log_hypot,
+    mpf_cos_sin_pi, mpf_phi,
+    mpf_cos, mpf_sin, mpf_cos_pi, mpf_sin_pi,
+    mpf_atan, mpf_atan2, mpf_cosh, mpf_sinh, mpf_tanh,
+    mpf_asin, mpf_acos, mpf_acosh, mpf_nthroot, mpf_fibonacci
+)
+
+# An mpc value is a (real, imag) tuple
+mpc_one = fone, fzero
+mpc_zero = fzero, fzero
+mpc_two = ftwo, fzero
+mpc_half = (fhalf, fzero)
+
+_infs = (finf, fninf)
+_infs_nan = (finf, fninf, fnan)
+
+def mpc_is_inf(z):
+    """Check if either real or imaginary part is infinite"""
+    re, im = z
+    if re in _infs: return True
+    if im in _infs: return True
+    return False
+
+def mpc_is_infnan(z):
+    """Check if either real or imaginary part is infinite or nan"""
+    re, im = z
+    if re in _infs_nan: return True
+    if im in _infs_nan: return True
+    return False
+
+def mpc_to_str(z, dps, **kwargs):
+    re, im = z
+    rs = to_str(re, dps)
+    if im[0]:
+        return rs + " - " + to_str(mpf_neg(im), dps, **kwargs) + "j"
+    else:
+        return rs + " + " + to_str(im, dps, **kwargs) + "j"
+
+def mpc_to_complex(z, strict=False, rnd=round_fast):
+    re, im = z
+    return complex(to_float(re, strict, rnd), to_float(im, strict, rnd))
+
+def mpc_hash(z):
+    if sys.version_info >= (3, 2):
+        re, im = z
+        h = mpf_hash(re) + sys.hash_info.imag * mpf_hash(im)
+        # Need to reduce either module 2^32 or 2^64
+        h = h % (2**sys.hash_info.width)
+        return int(h)
+    else:
+        try:
+            return hash(mpc_to_complex(z, strict=True))
+        except OverflowError:
+            return hash(z)
+
+def mpc_conjugate(z, prec, rnd=round_fast):
+    re, im = z
+    return re, mpf_neg(im, prec, rnd)
+
+def mpc_is_nonzero(z):
+    return z != mpc_zero
+
+def mpc_add(z, w, prec, rnd=round_fast):
+    a, b = z
+    c, d = w
+    return mpf_add(a, c, prec, rnd), mpf_add(b, d, prec, rnd)
+
+def mpc_add_mpf(z, x, prec, rnd=round_fast):
+    a, b = z
+    return mpf_add(a, x, prec, rnd), b
+
+def mpc_sub(z, w, prec=0, rnd=round_fast):
+    a, b = z
+    c, d = w
+    return mpf_sub(a, c, prec, rnd), mpf_sub(b, d, prec, rnd)
+
+def mpc_sub_mpf(z, p, prec=0, rnd=round_fast):
+    a, b = z
+    return mpf_sub(a, p, prec, rnd), b
+
+def mpc_pos(z, prec, rnd=round_fast):
+    a, b = z
+    return mpf_pos(a, prec, rnd), mpf_pos(b, prec, rnd)
+
+def mpc_neg(z, prec=None, rnd=round_fast):
+    a, b = z
+    return mpf_neg(a, prec, rnd), mpf_neg(b, prec, rnd)
+
+def mpc_shift(z, n):
+    a, b = z
+    return mpf_shift(a, n), mpf_shift(b, n)
+
+def mpc_abs(z, prec, rnd=round_fast):
+    """Absolute value of a complex number, |a+bi|.
+    Returns an mpf value."""
+    a, b = z
+    return mpf_hypot(a, b, prec, rnd)
+
+def mpc_arg(z, prec, rnd=round_fast):
+    """Argument of a complex number. Returns an mpf value."""
+    a, b = z
+    return mpf_atan2(b, a, prec, rnd)
+
+def mpc_floor(z, prec, rnd=round_fast):
+    a, b = z
+    return mpf_floor(a, prec, rnd), mpf_floor(b, prec, rnd)
+
+def mpc_ceil(z, prec, rnd=round_fast):
+    a, b = z
+    return mpf_ceil(a, prec, rnd), mpf_ceil(b, prec, rnd)
+
+def mpc_nint(z, prec, rnd=round_fast):
+    a, b = z
+    return mpf_nint(a, prec, rnd), mpf_nint(b, prec, rnd)
+
+def mpc_frac(z, prec, rnd=round_fast):
+    a, b = z
+    return mpf_frac(a, prec, rnd), mpf_frac(b, prec, rnd)
+
+
+def mpc_mul(z, w, prec, rnd=round_fast):
+    """
+    Complex multiplication.
+
+    Returns the real and imaginary part of (a+bi)*(c+di), rounded to
+    the specified precision. The rounding mode applies to the real and
+    imaginary parts separately.
+    """
+    a, b = z
+    c, d = w
+    p = mpf_mul(a, c)
+    q = mpf_mul(b, d)
+    r = mpf_mul(a, d)
+    s = mpf_mul(b, c)
+    re = mpf_sub(p, q, prec, rnd)
+    im = mpf_add(r, s, prec, rnd)
+    return re, im
+
+def mpc_square(z, prec, rnd=round_fast):
+    # (a+b*I)**2 == a**2 - b**2 + 2*I*a*b
+    a, b = z
+    p = mpf_mul(a,a)
+    q = mpf_mul(b,b)
+    r = mpf_mul(a,b, prec, rnd)
+    re = mpf_sub(p, q, prec, rnd)
+    im = mpf_shift(r, 1)
+    return re, im
+
+def mpc_mul_mpf(z, p, prec, rnd=round_fast):
+    a, b = z
+    re = mpf_mul(a, p, prec, rnd)
+    im = mpf_mul(b, p, prec, rnd)
+    return re, im
+
+def mpc_mul_imag_mpf(z, x, prec, rnd=round_fast):
+    """
+    Multiply the mpc value z by I*x where x is an mpf value.
+    """
+    a, b = z
+    re = mpf_neg(mpf_mul(b, x, prec, rnd))
+    im = mpf_mul(a, x, prec, rnd)
+    return re, im
+
+def mpc_mul_int(z, n, prec, rnd=round_fast):
+    a, b = z
+    re = mpf_mul_int(a, n, prec, rnd)
+    im = mpf_mul_int(b, n, prec, rnd)
+    return re, im
+
+def mpc_div(z, w, prec, rnd=round_fast):
+    a, b = z
+    c, d = w
+    wp = prec + 10
+    # mag = c*c + d*d
+    mag = mpf_add(mpf_mul(c, c), mpf_mul(d, d), wp)
+    # (a*c+b*d)/mag, (b*c-a*d)/mag
+    t = mpf_add(mpf_mul(a,c), mpf_mul(b,d), wp)
+    u = mpf_sub(mpf_mul(b,c), mpf_mul(a,d), wp)
+    return mpf_div(t,mag,prec,rnd), mpf_div(u,mag,prec,rnd)
+
+def mpc_div_mpf(z, p, prec, rnd=round_fast):
+    """Calculate z/p where p is real"""
+    a, b = z
+    re = mpf_div(a, p, prec, rnd)
+    im = mpf_div(b, p, prec, rnd)
+    return re, im
+
+def mpc_reciprocal(z, prec, rnd=round_fast):
+    """Calculate 1/z efficiently"""
+    a, b = z
+    m = mpf_add(mpf_mul(a,a),mpf_mul(b,b),prec+10)
+    re = mpf_div(a, m, prec, rnd)
+    im = mpf_neg(mpf_div(b, m, prec, rnd))
+    return re, im
+
+def mpc_mpf_div(p, z, prec, rnd=round_fast):
+    """Calculate p/z where p is real efficiently"""
+    a, b = z
+    m = mpf_add(mpf_mul(a,a),mpf_mul(b,b), prec+10)
+    re = mpf_div(mpf_mul(a,p), m, prec, rnd)
+    im = mpf_div(mpf_neg(mpf_mul(b,p)), m, prec, rnd)
+    return re, im
+
+def complex_int_pow(a, b, n):
+    """Complex integer power: computes (a+b*I)**n exactly for
+    nonnegative n (a and b must be Python ints)."""
+    wre = 1
+    wim = 0
+    while n:
+        if n & 1:
+            wre, wim = wre*a - wim*b, wim*a + wre*b
+            n -= 1
+        a, b = a*a - b*b, 2*a*b
+        n //= 2
+    return wre, wim
+
+def mpc_pow(z, w, prec, rnd=round_fast):
+    if w[1] == fzero:
+        return mpc_pow_mpf(z, w[0], prec, rnd)
+    return mpc_exp(mpc_mul(mpc_log(z, prec+10), w, prec+10), prec, rnd)
+
+def mpc_pow_mpf(z, p, prec, rnd=round_fast):
+    psign, pman, pexp, pbc = p
+    if pexp >= 0:
+        return mpc_pow_int(z, (-1)**psign * (pman<<pexp), prec, rnd)
+    if pexp == -1:
+        sqrtz = mpc_sqrt(z, prec+10)
+        return mpc_pow_int(sqrtz, (-1)**psign * pman, prec, rnd)
+    return mpc_exp(mpc_mul_mpf(mpc_log(z, prec+10), p, prec+10), prec, rnd)
+
+def mpc_pow_int(z, n, prec, rnd=round_fast):
+    a, b = z
+    if b == fzero:
+        return mpf_pow_int(a, n, prec, rnd), fzero
+    if a == fzero:
+        v = mpf_pow_int(b, n, prec, rnd)
+        n %= 4
+        if n == 0:
+            return v, fzero
+        elif n == 1:
+            return fzero, v
+        elif n == 2:
+            return mpf_neg(v), fzero
+        elif n == 3:
+            return fzero, mpf_neg(v)
+    if n == 0: return mpc_one
+    if n == 1: return mpc_pos(z, prec, rnd)
+    if n == 2: return mpc_square(z, prec, rnd)
+    if n == -1: return mpc_reciprocal(z, prec, rnd)
+    if n < 0: return mpc_reciprocal(mpc_pow_int(z, -n, prec+4), prec, rnd)
+    asign, aman, aexp, abc = a
+    bsign, bman, bexp, bbc = b
+    if asign: aman = -aman
+    if bsign: bman = -bman
+    de = aexp - bexp
+    abs_de = abs(de)
+    exact_size = n*(abs_de + max(abc, bbc))
+    if exact_size < 10000:
+        if de > 0:
+            aman <<= de
+            aexp = bexp
+        else:
+            bman <<= (-de)
+            bexp = aexp
+        re, im = complex_int_pow(aman, bman, n)
+        re = from_man_exp(re, int(n*aexp), prec, rnd)
+        im = from_man_exp(im, int(n*bexp), prec, rnd)
+        return re, im
+    return mpc_exp(mpc_mul_int(mpc_log(z, prec+10), n, prec+10), prec, rnd)
+
+def mpc_sqrt(z, prec, rnd=round_fast):
+    """Complex square root (principal branch).
+
+    We have sqrt(a+bi) = sqrt((r+a)/2) + b/sqrt(2*(r+a))*i where
+    r = abs(a+bi), when a+bi is not a negative real number."""
+    a, b = z
+    if b == fzero:
+        if a == fzero:
+            return (a, b)
+        # When a+bi is a negative real number, we get a real sqrt times i
+        if a[0]:
+            im = mpf_sqrt(mpf_neg(a), prec, rnd)
+            return (fzero, im)
+        else:
+            re = mpf_sqrt(a, prec, rnd)
+            return (re, fzero)
+    wp = prec+20
+    if not a[0]:                               # case a positive
+        t  = mpf_add(mpc_abs((a, b), wp), a, wp)  # t = abs(a+bi) + a
+        u = mpf_shift(t, -1)                      # u = t/2
+        re = mpf_sqrt(u, prec, rnd)               # re = sqrt(u)
+        v = mpf_shift(t, 1)                       # v = 2*t
+        w  = mpf_sqrt(v, wp)                      # w = sqrt(v)
+        im = mpf_div(b, w, prec, rnd)             # im = b / w
+    else:                                      # case a negative
+        t = mpf_sub(mpc_abs((a, b), wp), a, wp)   # t = abs(a+bi) - a
+        u = mpf_shift(t, -1)                      # u = t/2
+        im = mpf_sqrt(u, prec, rnd)               # im = sqrt(u)
+        v = mpf_shift(t, 1)                       # v = 2*t
+        w  = mpf_sqrt(v, wp)                      # w = sqrt(v)
+        re = mpf_div(b, w, prec, rnd)             # re = b/w
+        if b[0]:
+            re = mpf_neg(re)
+            im = mpf_neg(im)
+    return re, im
+
+def mpc_nthroot_fixed(a, b, n, prec):
+    # a, b signed integers at fixed precision prec
+    start = 50
+    a1 = int(rshift(a, prec - n*start))
+    b1 = int(rshift(b, prec - n*start))
+    try:
+        r = (a1 + 1j * b1)**(1.0/n)
+        re = r.real
+        im = r.imag
+        re = MPZ(int(re))
+        im = MPZ(int(im))
+    except OverflowError:
+        a1 = from_int(a1, start)
+        b1 = from_int(b1, start)
+        fn = from_int(n)
+        nth = mpf_rdiv_int(1, fn, start)
+        re, im = mpc_pow((a1, b1), (nth, fzero), start)
+        re = to_int(re)
+        im = to_int(im)
+    extra = 10
+    prevp = start
+    extra1 = n
+    for p in giant_steps(start, prec+extra):
+        # this is slow for large n, unlike int_pow_fixed
+        re2, im2 = complex_int_pow(re, im, n-1)
+        re2 = rshift(re2, (n-1)*prevp - p - extra1)
+        im2 = rshift(im2, (n-1)*prevp - p - extra1)
+        r4 = (re2*re2 + im2*im2) >> (p + extra1)
+        ap = rshift(a, prec - p)
+        bp = rshift(b, prec - p)
+        rec = (ap * re2 + bp * im2) >> p
+        imc = (-ap * im2 + bp * re2) >> p
+        reb = (rec << p) // r4
+        imb = (imc << p) // r4
+        re = (reb + (n-1)*lshift(re, p-prevp))//n
+        im = (imb + (n-1)*lshift(im, p-prevp))//n
+        prevp = p
+    return re, im
+
+def mpc_nthroot(z, n, prec, rnd=round_fast):
+    """
+    Complex n-th root.
+
+    Use Newton method as in the real case when it is faster,
+    otherwise use z**(1/n)
+    """
+    a, b = z
+    if a[0] == 0 and b == fzero:
+        re = mpf_nthroot(a, n, prec, rnd)
+        return (re, fzero)
+    if n < 2:
+        if n == 0:
+            return mpc_one
+        if n == 1:
+            return mpc_pos((a, b), prec, rnd)
+        if n == -1:
+            return mpc_div(mpc_one, (a, b), prec, rnd)
+        inverse = mpc_nthroot((a, b), -n, prec+5, reciprocal_rnd[rnd])
+        return mpc_div(mpc_one, inverse, prec, rnd)
+    if n <= 20:
+        prec2 = int(1.2 * (prec + 10))
+        asign, aman, aexp, abc = a
+        bsign, bman, bexp, bbc = b
+        pf = mpc_abs((a,b), prec)
+        if pf[-2] + pf[-1] > -10  and pf[-2] + pf[-1] < prec:
+            af = to_fixed(a, prec2)
+            bf = to_fixed(b, prec2)
+            re, im = mpc_nthroot_fixed(af, bf, n, prec2)
+            extra = 10
+            re = from_man_exp(re, -prec2-extra, prec2, rnd)
+            im = from_man_exp(im, -prec2-extra, prec2, rnd)
+            return re, im
+    fn = from_int(n)
+    prec2 = prec+10 + 10
+    nth = mpf_rdiv_int(1, fn, prec2)
+    re, im = mpc_pow((a, b), (nth, fzero), prec2, rnd)
+    re = normalize(re[0], re[1], re[2], re[3], prec, rnd)
+    im = normalize(im[0], im[1], im[2], im[3], prec, rnd)
+    return re, im
+
+def mpc_cbrt(z, prec, rnd=round_fast):
+    """
+    Complex cubic root.
+    """
+    return mpc_nthroot(z, 3, prec, rnd)
+
+def mpc_exp(z, prec, rnd=round_fast):
+    """
+    Complex exponential function.
+
+    We use the direct formula exp(a+bi) = exp(a) * (cos(b) + sin(b)*i)
+    for the computation. This formula is very nice because it is
+    pefectly stable; since we just do real multiplications, the only
+    numerical errors that can creep in are single-ulp rounding errors.
+
+    The formula is efficient since mpmath's real exp is quite fast and
+    since we can compute cos and sin simultaneously.
+
+    It is no problem if a and b are large; if the implementations of
+    exp/cos/sin are accurate and efficient for all real numbers, then
+    so is this function for all complex numbers.
+    """
+    a, b = z
+    if a == fzero:
+        return mpf_cos_sin(b, prec, rnd)
+    if b == fzero:
+        return mpf_exp(a, prec, rnd), fzero
+    mag = mpf_exp(a, prec+4, rnd)
+    c, s = mpf_cos_sin(b, prec+4, rnd)
+    re = mpf_mul(mag, c, prec, rnd)
+    im = mpf_mul(mag, s, prec, rnd)
+    return re, im
+
+def mpc_log(z, prec, rnd=round_fast):
+    re = mpf_log_hypot(z[0], z[1], prec, rnd)
+    im = mpc_arg(z, prec, rnd)
+    return re, im
+
+def mpc_cos(z, prec, rnd=round_fast):
+    """Complex cosine. The formula used is cos(a+bi) = cos(a)*cosh(b) -
+    sin(a)*sinh(b)*i.
+
+    The same comments apply as for the complex exp: only real
+    multiplications are pewrormed, so no cancellation errors are
+    possible. The formula is also efficient since we can compute both
+    pairs (cos, sin) and (cosh, sinh) in single stwps."""
+    a, b = z
+    if b == fzero:
+        return mpf_cos(a, prec, rnd), fzero
+    if a == fzero:
+        return mpf_cosh(b, prec, rnd), fzero
+    wp = prec + 6
+    c, s = mpf_cos_sin(a, wp)
+    ch, sh = mpf_cosh_sinh(b, wp)
+    re = mpf_mul(c, ch, prec, rnd)
+    im = mpf_mul(s, sh, prec, rnd)
+    return re, mpf_neg(im)
+
+def mpc_sin(z, prec, rnd=round_fast):
+    """Complex sine. We have sin(a+bi) = sin(a)*cosh(b) +
+    cos(a)*sinh(b)*i. See the docstring for mpc_cos for additional
+    comments."""
+    a, b = z
+    if b == fzero:
+        return mpf_sin(a, prec, rnd), fzero
+    if a == fzero:
+        return fzero, mpf_sinh(b, prec, rnd)
+    wp = prec + 6
+    c, s = mpf_cos_sin(a, wp)
+    ch, sh = mpf_cosh_sinh(b, wp)
+    re = mpf_mul(s, ch, prec, rnd)
+    im = mpf_mul(c, sh, prec, rnd)
+    return re, im
+
+def mpc_tan(z, prec, rnd=round_fast):
+    """Complex tangent. Computed as tan(a+bi) = sin(2a)/M + sinh(2b)/M*i
+    where M = cos(2a) + cosh(2b)."""
+    a, b = z
+    asign, aman, aexp, abc = a
+    bsign, bman, bexp, bbc = b
+    if b == fzero: return mpf_tan(a, prec, rnd), fzero
+    if a == fzero: return fzero, mpf_tanh(b, prec, rnd)
+    wp = prec + 15
+    a = mpf_shift(a, 1)
+    b = mpf_shift(b, 1)
+    c, s = mpf_cos_sin(a, wp)
+    ch, sh = mpf_cosh_sinh(b, wp)
+    # TODO: handle cancellation when c ~=  -1 and ch ~= 1
+    mag = mpf_add(c, ch, wp)
+    re = mpf_div(s, mag, prec, rnd)
+    im = mpf_div(sh, mag, prec, rnd)
+    return re, im
+
+def mpc_cos_pi(z, prec, rnd=round_fast):
+    a, b = z
+    if b == fzero:
+        return mpf_cos_pi(a, prec, rnd), fzero
+    b = mpf_mul(b, mpf_pi(prec+5), prec+5)
+    if a == fzero:
+        return mpf_cosh(b, prec, rnd), fzero
+    wp = prec + 6
+    c, s = mpf_cos_sin_pi(a, wp)
+    ch, sh = mpf_cosh_sinh(b, wp)
+    re = mpf_mul(c, ch, prec, rnd)
+    im = mpf_mul(s, sh, prec, rnd)
+    return re, mpf_neg(im)
+
+def mpc_sin_pi(z, prec, rnd=round_fast):
+    a, b = z
+    if b == fzero:
+        return mpf_sin_pi(a, prec, rnd), fzero
+    b = mpf_mul(b, mpf_pi(prec+5), prec+5)
+    if a == fzero:
+        return fzero, mpf_sinh(b, prec, rnd)
+    wp = prec + 6
+    c, s = mpf_cos_sin_pi(a, wp)
+    ch, sh = mpf_cosh_sinh(b, wp)
+    re = mpf_mul(s, ch, prec, rnd)
+    im = mpf_mul(c, sh, prec, rnd)
+    return re, im
+
+def mpc_cos_sin(z, prec, rnd=round_fast):
+    a, b = z
+    if a == fzero:
+        ch, sh = mpf_cosh_sinh(b, prec, rnd)
+        return (ch, fzero), (fzero, sh)
+    if b == fzero:
+        c, s = mpf_cos_sin(a, prec, rnd)
+        return (c, fzero), (s, fzero)
+    wp = prec + 6
+    c, s = mpf_cos_sin(a, wp)
+    ch, sh = mpf_cosh_sinh(b, wp)
+    cre = mpf_mul(c, ch, prec, rnd)
+    cim = mpf_mul(s, sh, prec, rnd)
+    sre = mpf_mul(s, ch, prec, rnd)
+    sim = mpf_mul(c, sh, prec, rnd)
+    return (cre, mpf_neg(cim)), (sre, sim)
+
+def mpc_cos_sin_pi(z, prec, rnd=round_fast):
+    a, b = z
+    if b == fzero:
+        c, s = mpf_cos_sin_pi(a, prec, rnd)
+        return (c, fzero), (s, fzero)
+    b = mpf_mul(b, mpf_pi(prec+5), prec+5)
+    if a == fzero:
+        ch, sh = mpf_cosh_sinh(b, prec, rnd)
+        return (ch, fzero), (fzero, sh)
+    wp = prec + 6
+    c, s = mpf_cos_sin_pi(a, wp)
+    ch, sh = mpf_cosh_sinh(b, wp)
+    cre = mpf_mul(c, ch, prec, rnd)
+    cim = mpf_mul(s, sh, prec, rnd)
+    sre = mpf_mul(s, ch, prec, rnd)
+    sim = mpf_mul(c, sh, prec, rnd)
+    return (cre, mpf_neg(cim)), (sre, sim)
+
+def mpc_cosh(z, prec, rnd=round_fast):
+    """Complex hyperbolic cosine. Computed as cosh(z) = cos(z*i)."""
+    a, b = z
+    return mpc_cos((b, mpf_neg(a)), prec, rnd)
+
+def mpc_sinh(z, prec, rnd=round_fast):
+    """Complex hyperbolic sine. Computed as sinh(z) = -i*sin(z*i)."""
+    a, b = z
+    b, a = mpc_sin((b, a), prec, rnd)
+    return a, b
+
+def mpc_tanh(z, prec, rnd=round_fast):
+    """Complex hyperbolic tangent. Computed as tanh(z) = -i*tan(z*i)."""
+    a, b = z
+    b, a = mpc_tan((b, a), prec, rnd)
+    return a, b
+
+# TODO: avoid loss of accuracy
+def mpc_atan(z, prec, rnd=round_fast):
+    a, b = z
+    # atan(z) = (I/2)*(log(1-I*z) - log(1+I*z))
+    # x = 1-I*z = 1 + b - I*a
+    # y = 1+I*z = 1 - b + I*a
+    wp = prec + 15
+    x = mpf_add(fone, b, wp), mpf_neg(a)
+    y = mpf_sub(fone, b, wp), a
+    l1 = mpc_log(x, wp)
+    l2 = mpc_log(y, wp)
+    a, b = mpc_sub(l1, l2, prec, rnd)
+    # (I/2) * (a+b*I) = (-b/2 + a/2*I)
+    v = mpf_neg(mpf_shift(b,-1)), mpf_shift(a,-1)
+    # Subtraction at infinity gives correct real part but
+    # wrong imaginary part (should be zero)
+    if v[1] == fnan and mpc_is_inf(z):
+        v = (v[0], fzero)
+    return v
+
+beta_crossover = from_float(0.6417)
+alpha_crossover = from_float(1.5)
+
+def acos_asin(z, prec, rnd, n):
+    """ complex acos for n = 0, asin for n = 1
+    The algorithm is described in
+    T.E. Hull, T.F. Fairgrieve and P.T.P. Tang
+    'Implementing the Complex Arcsine and Arcosine Functions
+    using Exception Handling',
+    ACM Trans. on Math. Software Vol. 23 (1997), p299
+    The complex acos and asin can be defined as
+    acos(z) = acos(beta) - I*sign(a)* log(alpha + sqrt(alpha**2 -1))
+    asin(z) = asin(beta) + I*sign(a)* log(alpha + sqrt(alpha**2 -1))
+    where z = a + I*b
+    alpha = (1/2)*(r + s); beta = (1/2)*(r - s) = a/alpha
+    r = sqrt((a+1)**2 + y**2); s = sqrt((a-1)**2 + y**2)
+    These expressions are rewritten in different ways in different
+    regions, delimited by two crossovers alpha_crossover and beta_crossover,
+    and by abs(a) <= 1, in order to improve the numerical accuracy.
+    """
+    a, b = z
+    wp = prec + 10
+    # special cases with real argument
+    if b == fzero:
+        am = mpf_sub(fone, mpf_abs(a), wp)
+        # case abs(a) <= 1
+        if not am[0]:
+            if n == 0:
+                return mpf_acos(a, prec, rnd), fzero
+            else:
+                return mpf_asin(a, prec, rnd), fzero
+        # cases abs(a) > 1
+        else:
+            # case a < -1
+            if a[0]:
+                pi = mpf_pi(prec, rnd)
+                c = mpf_acosh(mpf_neg(a), prec, rnd)
+                if n == 0:
+                    return pi, mpf_neg(c)
+                else:
+                    return mpf_neg(mpf_shift(pi, -1)), c
+            # case a > 1
+            else:
+                c = mpf_acosh(a, prec, rnd)
+                if n == 0:
+                    return fzero, c
+                else:
+                    pi = mpf_pi(prec, rnd)
+                    return mpf_shift(pi, -1), mpf_neg(c)
+    asign = bsign = 0
+    if a[0]:
+        a = mpf_neg(a)
+        asign = 1
+    if b[0]:
+        b = mpf_neg(b)
+        bsign = 1
+    am = mpf_sub(fone, a, wp)
+    ap = mpf_add(fone, a, wp)
+    r = mpf_hypot(ap, b, wp)
+    s = mpf_hypot(am, b, wp)
+    alpha = mpf_shift(mpf_add(r, s, wp), -1)
+    beta = mpf_div(a, alpha, wp)
+    b2 = mpf_mul(b,b, wp)
+    # case beta <= beta_crossover
+    if not mpf_sub(beta_crossover, beta, wp)[0]:
+        if n == 0:
+            re = mpf_acos(beta, wp)
+        else:
+            re = mpf_asin(beta, wp)
+    else:
+        # to compute the real part in this region use the identity
+        # asin(beta) = atan(beta/sqrt(1-beta**2))
+        # beta/sqrt(1-beta**2) = (alpha + a) * (alpha - a)
+        # alpha + a is numerically accurate; alpha - a can have
+        # cancellations leading to numerical inaccuracies, so rewrite
+        # it in differente ways according to the region
+        Ax = mpf_add(alpha, a, wp)
+        # case a <= 1
+        if not am[0]:
+            # c = b*b/(r + (a+1)); d = (s + (1-a))
+            # alpha - a = (1/2)*(c + d)
+            # case n=0: re = atan(sqrt((1/2) * Ax * (c + d))/a)
+            # case n=1: re = atan(a/sqrt((1/2) * Ax * (c + d)))
+            c = mpf_div(b2, mpf_add(r, ap, wp), wp)
+            d = mpf_add(s, am, wp)
+            re = mpf_shift(mpf_mul(Ax, mpf_add(c, d, wp), wp), -1)
+            if n == 0:
+                re = mpf_atan(mpf_div(mpf_sqrt(re, wp), a, wp), wp)
+            else:
+                re = mpf_atan(mpf_div(a, mpf_sqrt(re, wp), wp), wp)
+        else:
+            # c = Ax/(r + (a+1)); d = Ax/(s - (1-a))
+            # alpha - a = (1/2)*(c + d)
+            # case n = 0: re = atan(b*sqrt(c + d)/2/a)
+            # case n = 1: re = atan(a/(b*sqrt(c + d)/2)
+            c = mpf_div(Ax, mpf_add(r, ap, wp), wp)
+            d = mpf_div(Ax, mpf_sub(s, am, wp), wp)
+            re = mpf_shift(mpf_add(c, d, wp), -1)
+            re = mpf_mul(b, mpf_sqrt(re, wp), wp)
+            if n == 0:
+                re = mpf_atan(mpf_div(re, a, wp), wp)
+            else:
+                re = mpf_atan(mpf_div(a, re, wp), wp)
+    # to compute alpha + sqrt(alpha**2 - 1), if alpha <= alpha_crossover
+    # replace it with 1 + Am1 + sqrt(Am1*(alpha+1)))
+    # where Am1 = alpha -1
+    # if alpha <= alpha_crossover:
+    if not mpf_sub(alpha_crossover, alpha, wp)[0]:
+        c1 = mpf_div(b2, mpf_add(r, ap, wp), wp)
+        # case a < 1
+        if mpf_neg(am)[0]:
+            # Am1 = (1/2) * (b*b/(r + (a+1)) + b*b/(s + (1-a))
+            c2 = mpf_add(s, am, wp)
+            c2 = mpf_div(b2, c2, wp)
+            Am1 = mpf_shift(mpf_add(c1, c2, wp), -1)
+        else:
+            # Am1 = (1/2) * (b*b/(r + (a+1)) + (s - (1-a)))
+            c2 = mpf_sub(s, am, wp)
+            Am1 = mpf_shift(mpf_add(c1, c2, wp), -1)
+        # im = log(1 + Am1 + sqrt(Am1*(alpha+1)))
+        im = mpf_mul(Am1, mpf_add(alpha, fone, wp), wp)
+        im = mpf_log(mpf_add(fone, mpf_add(Am1, mpf_sqrt(im, wp), wp), wp), wp)
+    else:
+        # im = log(alpha + sqrt(alpha*alpha - 1))
+        im = mpf_sqrt(mpf_sub(mpf_mul(alpha, alpha, wp), fone, wp), wp)
+        im = mpf_log(mpf_add(alpha, im, wp), wp)
+    if asign:
+        if n == 0:
+            re = mpf_sub(mpf_pi(wp), re, wp)
+        else:
+            re = mpf_neg(re)
+    if not bsign and n == 0:
+        im = mpf_neg(im)
+    if bsign and n == 1:
+        im = mpf_neg(im)
+    re = normalize(re[0], re[1], re[2], re[3], prec, rnd)
+    im = normalize(im[0], im[1], im[2], im[3], prec, rnd)
+    return re, im
+
+def mpc_acos(z, prec, rnd=round_fast):
+    return acos_asin(z, prec, rnd, 0)
+
+def mpc_asin(z, prec, rnd=round_fast):
+    return acos_asin(z, prec, rnd, 1)
+
+def mpc_asinh(z, prec, rnd=round_fast):
+    # asinh(z) = I * asin(-I z)
+    a, b = z
+    a, b =  mpc_asin((b, mpf_neg(a)), prec, rnd)
+    return mpf_neg(b), a
+
+def mpc_acosh(z, prec, rnd=round_fast):
+    # acosh(z) = -I * acos(z)   for Im(acos(z)) <= 0
+    #            +I * acos(z)   otherwise
+    a, b = mpc_acos(z, prec, rnd)
+    if b[0] or b == fzero:
+        return mpf_neg(b), a
+    else:
+        return b, mpf_neg(a)
+
+def mpc_atanh(z, prec, rnd=round_fast):
+    # atanh(z) = (log(1+z)-log(1-z))/2
+    wp = prec + 15
+    a = mpc_add(z, mpc_one, wp)
+    b = mpc_sub(mpc_one, z, wp)
+    a = mpc_log(a, wp)
+    b = mpc_log(b, wp)
+    v = mpc_shift(mpc_sub(a, b, wp), -1)
+    # Subtraction at infinity gives correct imaginary part but
+    # wrong real part (should be zero)
+    if v[0] == fnan and mpc_is_inf(z):
+        v = (fzero, v[1])
+    return v
+
+def mpc_fibonacci(z, prec, rnd=round_fast):
+    re, im = z
+    if im == fzero:
+        return (mpf_fibonacci(re, prec, rnd), fzero)
+    size = max(abs(re[2]+re[3]), abs(re[2]+re[3]))
+    wp = prec + size + 20
+    a = mpf_phi(wp)
+    b = mpf_add(mpf_shift(a, 1), fnone, wp)
+    u = mpc_pow((a, fzero), z, wp)
+    v = mpc_cos_pi(z, wp)
+    v = mpc_div(v, u, wp)
+    u = mpc_sub(u, v, wp)
+    u = mpc_div_mpf(u, b, prec, rnd)
+    return u
+
+def mpf_expj(x, prec, rnd='f'):
+    raise ComplexResult
+
+def mpc_expj(z, prec, rnd='f'):
+    re, im = z
+    if im == fzero:
+        return mpf_cos_sin(re, prec, rnd)
+    if re == fzero:
+        return mpf_exp(mpf_neg(im), prec, rnd), fzero
+    ey = mpf_exp(mpf_neg(im), prec+10)
+    c, s = mpf_cos_sin(re, prec+10)
+    re = mpf_mul(ey, c, prec, rnd)
+    im = mpf_mul(ey, s, prec, rnd)
+    return re, im
+
+def mpf_expjpi(x, prec, rnd='f'):
+    raise ComplexResult
+
+def mpc_expjpi(z, prec, rnd='f'):
+    re, im = z
+    if im == fzero:
+        return mpf_cos_sin_pi(re, prec, rnd)
+    sign, man, exp, bc = im
+    wp = prec+10
+    if man:
+        wp += max(0, exp+bc)
+    im = mpf_neg(mpf_mul(mpf_pi(wp), im, wp))
+    if re == fzero:
+        return mpf_exp(im, prec, rnd), fzero
+    ey = mpf_exp(im, prec+10)
+    c, s = mpf_cos_sin_pi(re, prec+10)
+    re = mpf_mul(ey, c, prec, rnd)
+    im = mpf_mul(ey, s, prec, rnd)
+    return re, im
+
+
+if BACKEND == 'sage':
+    try:
+        import sage.libs.mpmath.ext_libmp as _lbmp
+        mpc_exp = _lbmp.mpc_exp
+        mpc_sqrt = _lbmp.mpc_sqrt
+    except (ImportError, AttributeError):
+        print("Warning: Sage imports in libmpc failed")
diff --git a/lib/python3.10/site-packages/mpmath/libmp/libmpf.py b/lib/python3.10/site-packages/mpmath/libmp/libmpf.py
new file mode 100644
index 0000000000000000000000000000000000000000..5c162e17d4f688c71dc3476b944e2d31c65faab7
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/libmp/libmpf.py
@@ -0,0 +1,1414 @@
+"""
+Low-level functions for arbitrary-precision floating-point arithmetic.
+"""
+
+__docformat__ = 'plaintext'
+
+import math
+
+from bisect import bisect
+
+import sys
+
+# Importing random is slow
+#from random import getrandbits
+getrandbits = None
+
+from .backend import (MPZ, MPZ_TYPE, MPZ_ZERO, MPZ_ONE, MPZ_TWO, MPZ_FIVE,
+    BACKEND, STRICT, HASH_MODULUS, HASH_BITS, gmpy, sage, sage_utils)
+
+from .libintmath import (giant_steps,
+    trailtable, bctable, lshift, rshift, bitcount, trailing,
+    sqrt_fixed, numeral, isqrt, isqrt_fast, sqrtrem,
+    bin_to_radix)
+
+# We don't pickle tuples directly for the following reasons:
+#   1: pickle uses str() for ints, which is inefficient when they are large
+#   2: pickle doesn't work for gmpy mpzs
+# Both problems are solved by using hex()
+
+if BACKEND == 'sage':
+    def to_pickable(x):
+        sign, man, exp, bc = x
+        return sign, hex(man), exp, bc
+else:
+    def to_pickable(x):
+        sign, man, exp, bc = x
+        return sign, hex(man)[2:], exp, bc
+
+def from_pickable(x):
+    sign, man, exp, bc = x
+    return (sign, MPZ(man, 16), exp, bc)
+
+class ComplexResult(ValueError):
+    pass
+
+try:
+    intern
+except NameError:
+    intern = lambda x: x
+
+# All supported rounding modes
+round_nearest = intern('n')
+round_floor = intern('f')
+round_ceiling = intern('c')
+round_up = intern('u')
+round_down = intern('d')
+round_fast = round_down
+
+def prec_to_dps(n):
+    """Return number of accurate decimals that can be represented
+    with a precision of n bits."""
+    return max(1, int(round(int(n)/3.3219280948873626)-1))
+
+def dps_to_prec(n):
+    """Return the number of bits required to represent n decimals
+    accurately."""
+    return max(1, int(round((int(n)+1)*3.3219280948873626)))
+
+def repr_dps(n):
+    """Return the number of decimal digits required to represent
+    a number with n-bit precision so that it can be uniquely
+    reconstructed from the representation."""
+    dps = prec_to_dps(n)
+    if dps == 15:
+        return 17
+    return dps + 3
+
+#----------------------------------------------------------------------------#
+#                    Some commonly needed float values                       #
+#----------------------------------------------------------------------------#
+
+# Regular number format:
+# (-1)**sign * mantissa * 2**exponent, plus bitcount of mantissa
+fzero = (0, MPZ_ZERO, 0, 0)
+fnzero = (1, MPZ_ZERO, 0, 0)
+fone = (0, MPZ_ONE, 0, 1)
+fnone = (1, MPZ_ONE, 0, 1)
+ftwo = (0, MPZ_ONE, 1, 1)
+ften = (0, MPZ_FIVE, 1, 3)
+fhalf = (0, MPZ_ONE, -1, 1)
+
+# Arbitrary encoding for special numbers: zero mantissa, nonzero exponent
+fnan = (0, MPZ_ZERO, -123, -1)
+finf = (0, MPZ_ZERO, -456, -2)
+fninf = (1, MPZ_ZERO, -789, -3)
+
+# Was 1e1000; this is broken in Python 2.4
+math_float_inf = 1e300 * 1e300
+
+
+#----------------------------------------------------------------------------#
+#                                  Rounding                                  #
+#----------------------------------------------------------------------------#
+
+# This function can be used to round a mantissa generally. However,
+# we will try to do most rounding inline for efficiency.
+def round_int(x, n, rnd):
+    if rnd == round_nearest:
+        if x >= 0:
+            t = x >> (n-1)
+            if t & 1 and ((t & 2) or (x & h_mask[n<300][n])):
+                return (t>>1)+1
+            else:
+                return t>>1
+        else:
+            return -round_int(-x, n, rnd)
+    if rnd == round_floor:
+        return x >> n
+    if rnd == round_ceiling:
+        return -((-x) >> n)
+    if rnd == round_down:
+        if x >= 0:
+            return x >> n
+        return -((-x) >> n)
+    if rnd == round_up:
+        if x >= 0:
+            return -((-x) >> n)
+        return x >> n
+
+# These masks are used to pick out segments of numbers to determine
+# which direction to round when rounding to nearest.
+class h_mask_big:
+    def __getitem__(self, n):
+        return (MPZ_ONE<<(n-1))-1
+
+h_mask_small = [0]+[((MPZ_ONE<<(_-1))-1) for _ in range(1, 300)]
+h_mask = [h_mask_big(), h_mask_small]
+
+# The >> operator rounds to floor. shifts_down[rnd][sign]
+# tells whether this is the right direction to use, or if the
+# number should be negated before shifting
+shifts_down = {round_floor:(1,0), round_ceiling:(0,1),
+    round_down:(1,1), round_up:(0,0)}
+
+
+#----------------------------------------------------------------------------#
+#                          Normalization of raw mpfs                         #
+#----------------------------------------------------------------------------#
+
+# This function is called almost every time an mpf is created.
+# It has been optimized accordingly.
+
+def _normalize(sign, man, exp, bc, prec, rnd):
+    """
+    Create a raw mpf tuple with value (-1)**sign * man * 2**exp and
+    normalized mantissa. The mantissa is rounded in the specified
+    direction if its size exceeds the precision. Trailing zero bits
+    are also stripped from the mantissa to ensure that the
+    representation is canonical.
+
+    Conditions on the input:
+    * The input must represent a regular (finite) number
+    * The sign bit must be 0 or 1
+    * The mantissa must be positive
+    * The exponent must be an integer
+    * The bitcount must be exact
+
+    If these conditions are not met, use from_man_exp, mpf_pos, or any
+    of the conversion functions to create normalized raw mpf tuples.
+    """
+    if not man:
+        return fzero
+    # Cut mantissa down to size if larger than target precision
+    n = bc - prec
+    if n > 0:
+        if rnd == round_nearest:
+            t = man >> (n-1)
+            if t & 1 and ((t & 2) or (man & h_mask[n<300][n])):
+                man = (t>>1)+1
+            else:
+                man = t>>1
+        elif shifts_down[rnd][sign]:
+            man >>= n
+        else:
+            man = -((-man)>>n)
+        exp += n
+        bc = prec
+    # Strip trailing bits
+    if not man & 1:
+        t = trailtable[int(man & 255)]
+        if not t:
+            while not man & 255:
+                man >>= 8
+                exp += 8
+                bc -= 8
+            t = trailtable[int(man & 255)]
+        man >>= t
+        exp += t
+        bc -= t
+    # Bit count can be wrong if the input mantissa was 1 less than
+    # a power of 2 and got rounded up, thereby adding an extra bit.
+    # With trailing bits removed, all powers of two have mantissa 1,
+    # so this is easy to check for.
+    if man == 1:
+        bc = 1
+    return sign, man, exp, bc
+
+def _normalize1(sign, man, exp, bc, prec, rnd):
+    """same as normalize, but with the added condition that
+       man is odd or zero
+    """
+    if not man:
+        return fzero
+    if bc <= prec:
+        return sign, man, exp, bc
+    n = bc - prec
+    if rnd == round_nearest:
+        t = man >> (n-1)
+        if t & 1 and ((t & 2) or (man & h_mask[n<300][n])):
+            man = (t>>1)+1
+        else:
+            man = t>>1
+    elif shifts_down[rnd][sign]:
+        man >>= n
+    else:
+        man = -((-man)>>n)
+    exp += n
+    bc = prec
+    # Strip trailing bits
+    if not man & 1:
+        t = trailtable[int(man & 255)]
+        if not t:
+            while not man & 255:
+                man >>= 8
+                exp += 8
+                bc -= 8
+            t = trailtable[int(man & 255)]
+        man >>= t
+        exp += t
+        bc -= t
+    # Bit count can be wrong if the input mantissa was 1 less than
+    # a power of 2 and got rounded up, thereby adding an extra bit.
+    # With trailing bits removed, all powers of two have mantissa 1,
+    # so this is easy to check for.
+    if man == 1:
+        bc = 1
+    return sign, man, exp, bc
+
+try:
+    _exp_types = (int, long)
+except NameError:
+    _exp_types = (int,)
+
+def strict_normalize(sign, man, exp, bc, prec, rnd):
+    """Additional checks on the components of an mpf. Enable tests by setting
+       the environment variable MPMATH_STRICT to Y."""
+    assert type(man) == MPZ_TYPE
+    assert type(bc) in _exp_types
+    assert type(exp) in _exp_types
+    assert bc == bitcount(man)
+    return _normalize(sign, man, exp, bc, prec, rnd)
+
+def strict_normalize1(sign, man, exp, bc, prec, rnd):
+    """Additional checks on the components of an mpf. Enable tests by setting
+       the environment variable MPMATH_STRICT to Y."""
+    assert type(man) == MPZ_TYPE
+    assert type(bc) in _exp_types
+    assert type(exp) in _exp_types
+    assert bc == bitcount(man)
+    assert (not man) or (man & 1)
+    return _normalize1(sign, man, exp, bc, prec, rnd)
+
+if BACKEND == 'gmpy' and '_mpmath_normalize' in dir(gmpy):
+    _normalize = gmpy._mpmath_normalize
+    _normalize1 = gmpy._mpmath_normalize
+
+if BACKEND == 'sage':
+    _normalize = _normalize1 = sage_utils.normalize
+
+if STRICT:
+    normalize = strict_normalize
+    normalize1 = strict_normalize1
+else:
+    normalize = _normalize
+    normalize1 = _normalize1
+
+#----------------------------------------------------------------------------#
+#                            Conversion functions                            #
+#----------------------------------------------------------------------------#
+
+def from_man_exp(man, exp, prec=None, rnd=round_fast):
+    """Create raw mpf from (man, exp) pair. The mantissa may be signed.
+    If no precision is specified, the mantissa is stored exactly."""
+    man = MPZ(man)
+    sign = 0
+    if man < 0:
+        sign = 1
+        man = -man
+    if man < 1024:
+        bc = bctable[int(man)]
+    else:
+        bc = bitcount(man)
+    if not prec:
+        if not man:
+            return fzero
+        if not man & 1:
+            if man & 2:
+                return (sign, man >> 1, exp + 1, bc - 1)
+            t = trailtable[int(man & 255)]
+            if not t:
+                while not man & 255:
+                    man >>= 8
+                    exp += 8
+                    bc -= 8
+                t = trailtable[int(man & 255)]
+            man >>= t
+            exp += t
+            bc -= t
+        return (sign, man, exp, bc)
+    return normalize(sign, man, exp, bc, prec, rnd)
+
+int_cache = dict((n, from_man_exp(n, 0)) for n in range(-10, 257))
+
+if BACKEND == 'gmpy' and '_mpmath_create' in dir(gmpy):
+    from_man_exp = gmpy._mpmath_create
+
+if BACKEND == 'sage':
+    from_man_exp = sage_utils.from_man_exp
+
+def from_int(n, prec=0, rnd=round_fast):
+    """Create a raw mpf from an integer. If no precision is specified,
+    the mantissa is stored exactly."""
+    if not prec:
+        if n in int_cache:
+            return int_cache[n]
+    return from_man_exp(n, 0, prec, rnd)
+
+def to_man_exp(s):
+    """Return (man, exp) of a raw mpf. Raise an error if inf/nan."""
+    sign, man, exp, bc = s
+    if (not man) and exp:
+        raise ValueError("mantissa and exponent are undefined for %s" % man)
+    return man, exp
+
+def to_int(s, rnd=None):
+    """Convert a raw mpf to the nearest int. Rounding is done down by
+    default (same as int(float) in Python), but can be changed. If the
+    input is inf/nan, an exception is raised."""
+    sign, man, exp, bc = s
+    if (not man) and exp:
+        raise ValueError("cannot convert inf or nan to int")
+    if exp >= 0:
+        if sign:
+            return (-man) << exp
+        return man << exp
+    # Make default rounding fast
+    if not rnd:
+        if sign:
+            return -(man >> (-exp))
+        else:
+            return man >> (-exp)
+    if sign:
+        return round_int(-man, -exp, rnd)
+    else:
+        return round_int(man, -exp, rnd)
+
+def mpf_round_int(s, rnd):
+    sign, man, exp, bc = s
+    if (not man) and exp:
+        return s
+    if exp >= 0:
+        return s
+    mag = exp+bc
+    if mag < 1:
+        if rnd == round_ceiling:
+            if sign: return fzero
+            else:    return fone
+        elif rnd == round_floor:
+            if sign: return fnone
+            else:    return fzero
+        elif rnd == round_nearest:
+            if mag < 0 or man == MPZ_ONE: return fzero
+            elif sign: return fnone
+            else:      return fone
+        else:
+            raise NotImplementedError
+    return mpf_pos(s, min(bc, mag), rnd)
+
+def mpf_floor(s, prec=0, rnd=round_fast):
+    v = mpf_round_int(s, round_floor)
+    if prec:
+        v = mpf_pos(v, prec, rnd)
+    return v
+
+def mpf_ceil(s, prec=0, rnd=round_fast):
+    v = mpf_round_int(s, round_ceiling)
+    if prec:
+        v = mpf_pos(v, prec, rnd)
+    return v
+
+def mpf_nint(s, prec=0, rnd=round_fast):
+    v = mpf_round_int(s, round_nearest)
+    if prec:
+        v = mpf_pos(v, prec, rnd)
+    return v
+
+def mpf_frac(s, prec=0, rnd=round_fast):
+    return mpf_sub(s, mpf_floor(s), prec, rnd)
+
+def from_float(x, prec=53, rnd=round_fast):
+    """Create a raw mpf from a Python float, rounding if necessary.
+    If prec >= 53, the result is guaranteed to represent exactly the
+    same number as the input. If prec is not specified, use prec=53."""
+    # frexp only raises an exception for nan on some platforms
+    if x != x:
+        return fnan
+    # in Python2.5 math.frexp gives an exception for float infinity
+    # in Python2.6 it returns (float infinity, 0)
+    try:
+        m, e = math.frexp(x)
+    except:
+        if x == math_float_inf: return finf
+        if x == -math_float_inf: return fninf
+        return fnan
+    if x == math_float_inf: return finf
+    if x == -math_float_inf: return fninf
+    return from_man_exp(int(m*(1<<53)), e-53, prec, rnd)
+
+def from_npfloat(x, prec=113, rnd=round_fast):
+    """Create a raw mpf from a numpy float, rounding if necessary.
+    If prec >= 113, the result is guaranteed to represent exactly the
+    same number as the input. If prec is not specified, use prec=113."""
+    y = float(x)
+    if x == y: # ldexp overflows for float16
+        return from_float(y, prec, rnd)
+    import numpy as np
+    if np.isfinite(x):
+        m, e = np.frexp(x)
+        return from_man_exp(int(np.ldexp(m, 113)), int(e-113), prec, rnd)
+    if np.isposinf(x): return finf
+    if np.isneginf(x): return fninf
+    return fnan
+
+def from_Decimal(x, prec=None, rnd=round_fast):
+    """Create a raw mpf from a Decimal, rounding if necessary.
+    If prec is not specified, use the equivalent bit precision
+    of the number of significant digits in x."""
+    if x.is_nan(): return fnan
+    if x.is_infinite(): return fninf if x.is_signed() else finf
+    if prec is None:
+        prec = int(len(x.as_tuple()[1])*3.3219280948873626)
+    return from_str(str(x), prec, rnd)
+
+def to_float(s, strict=False, rnd=round_fast):
+    """
+    Convert a raw mpf to a Python float. The result is exact if the
+    bitcount of s is <= 53 and no underflow/overflow occurs.
+
+    If the number is too large or too small to represent as a regular
+    float, it will be converted to inf or 0.0. Setting strict=True
+    forces an OverflowError to be raised instead.
+
+    Warning: with a directed rounding mode, the correct nearest representable
+    floating-point number in the specified direction might not be computed
+    in case of overflow or (gradual) underflow.
+    """
+    sign, man, exp, bc = s
+    if not man:
+        if s == fzero: return 0.0
+        if s == finf: return math_float_inf
+        if s == fninf: return -math_float_inf
+        return math_float_inf/math_float_inf
+    if bc > 53:
+        sign, man, exp, bc = normalize1(sign, man, exp, bc, 53, rnd)
+    if sign:
+        man = -man
+    try:
+        return math.ldexp(man, exp)
+    except OverflowError:
+        if strict:
+            raise
+        # Overflow to infinity
+        if exp + bc > 0:
+            if sign:
+                return -math_float_inf
+            else:
+                return math_float_inf
+        # Underflow to zero
+        return 0.0
+
+def from_rational(p, q, prec, rnd=round_fast):
+    """Create a raw mpf from a rational number p/q, round if
+    necessary."""
+    return mpf_div(from_int(p), from_int(q), prec, rnd)
+
+def to_rational(s):
+    """Convert a raw mpf to a rational number. Return integers (p, q)
+    such that s = p/q exactly."""
+    sign, man, exp, bc = s
+    if sign:
+        man = -man
+    if bc == -1:
+        raise ValueError("cannot convert %s to a rational number" % man)
+    if exp >= 0:
+        return man * (1<<exp), 1
+    else:
+        return man, 1<<(-exp)
+
+def to_fixed(s, prec):
+    """Convert a raw mpf to a fixed-point big integer"""
+    sign, man, exp, bc = s
+    offset = exp + prec
+    if sign:
+        if offset >= 0: return (-man) << offset
+        else:           return (-man) >> (-offset)
+    else:
+        if offset >= 0: return man << offset
+        else:           return man >> (-offset)
+
+
+##############################################################################
+##############################################################################
+
+#----------------------------------------------------------------------------#
+#                       Arithmetic operations, etc.                          #
+#----------------------------------------------------------------------------#
+
+def mpf_rand(prec):
+    """Return a raw mpf chosen randomly from [0, 1), with prec bits
+    in the mantissa."""
+    global getrandbits
+    if not getrandbits:
+        import random
+        getrandbits = random.getrandbits
+    return from_man_exp(getrandbits(prec), -prec, prec, round_floor)
+
+def mpf_eq(s, t):
+    """Test equality of two raw mpfs. This is simply tuple comparison
+    unless either number is nan, in which case the result is False."""
+    if not s[1] or not t[1]:
+        if s == fnan or t == fnan:
+            return False
+    return s == t
+
+def mpf_hash(s):
+    # Duplicate the new hash algorithm introduces in Python 3.2.
+    if sys.version_info >= (3, 2):
+        ssign, sman, sexp, sbc = s
+
+        # Handle special numbers
+        if not sman:
+            if s == fnan: return sys.hash_info.nan
+            if s == finf: return sys.hash_info.inf
+            if s == fninf: return -sys.hash_info.inf
+        h = sman % HASH_MODULUS
+        if sexp >= 0:
+            sexp = sexp % HASH_BITS
+        else:
+            sexp = HASH_BITS - 1 - ((-1 - sexp) % HASH_BITS)
+        h = (h << sexp) % HASH_MODULUS
+        if ssign: h = -h
+        if h == -1: h = -2
+        return int(h)
+    else:
+        try:
+            # Try to be compatible with hash values for floats and ints
+            return hash(to_float(s, strict=1))
+        except OverflowError:
+            # We must unfortunately sacrifice compatibility with ints here.
+            # We could do hash(man << exp) when the exponent is positive, but
+            # this would cause unreasonable inefficiency for large numbers.
+            return hash(s)
+
+def mpf_cmp(s, t):
+    """Compare the raw mpfs s and t. Return -1 if s < t, 0 if s == t,
+    and 1 if s > t. (Same convention as Python's cmp() function.)"""
+
+    # In principle, a comparison amounts to determining the sign of s-t.
+    # A full subtraction is relatively slow, however, so we first try to
+    # look at the components.
+    ssign, sman, sexp, sbc = s
+    tsign, tman, texp, tbc = t
+
+    # Handle zeros and special numbers
+    if not sman or not tman:
+        if s == fzero: return -mpf_sign(t)
+        if t == fzero: return mpf_sign(s)
+        if s == t: return 0
+        # Follow same convention as Python's cmp for float nan
+        if t == fnan: return 1
+        if s == finf: return 1
+        if t == fninf: return 1
+        return -1
+    # Different sides of zero
+    if ssign != tsign:
+        if not ssign: return 1
+        return -1
+    # This reduces to direct integer comparison
+    if sexp == texp:
+        if sman == tman:
+            return 0
+        if sman > tman:
+            if ssign: return -1
+            else:     return 1
+        else:
+            if ssign: return 1
+            else:     return -1
+    # Check position of the highest set bit in each number. If
+    # different, there is certainly an inequality.
+    a = sbc + sexp
+    b = tbc + texp
+    if ssign:
+        if a < b: return 1
+        if a > b: return -1
+    else:
+        if a < b: return -1
+        if a > b: return 1
+
+    # Both numbers have the same highest bit. Subtract to find
+    # how the lower bits compare.
+    delta = mpf_sub(s, t, 5, round_floor)
+    if delta[0]:
+        return -1
+    return 1
+
+def mpf_lt(s, t):
+    if s == fnan or t == fnan:
+        return False
+    return mpf_cmp(s, t) < 0
+
+def mpf_le(s, t):
+    if s == fnan or t == fnan:
+        return False
+    return mpf_cmp(s, t) <= 0
+
+def mpf_gt(s, t):
+    if s == fnan or t == fnan:
+        return False
+    return mpf_cmp(s, t) > 0
+
+def mpf_ge(s, t):
+    if s == fnan or t == fnan:
+        return False
+    return mpf_cmp(s, t) >= 0
+
+def mpf_min_max(seq):
+    min = max = seq[0]
+    for x in seq[1:]:
+        if mpf_lt(x, min): min = x
+        if mpf_gt(x, max): max = x
+    return min, max
+
+def mpf_pos(s, prec=0, rnd=round_fast):
+    """Calculate 0+s for a raw mpf (i.e., just round s to the specified
+    precision)."""
+    if prec:
+        sign, man, exp, bc = s
+        if (not man) and exp:
+            return s
+        return normalize1(sign, man, exp, bc, prec, rnd)
+    return s
+
+def mpf_neg(s, prec=None, rnd=round_fast):
+    """Negate a raw mpf (return -s), rounding the result to the
+    specified precision. The prec argument can be omitted to do the
+    operation exactly."""
+    sign, man, exp, bc = s
+    if not man:
+        if exp:
+            if s == finf: return fninf
+            if s == fninf: return finf
+        return s
+    if not prec:
+        return (1-sign, man, exp, bc)
+    return normalize1(1-sign, man, exp, bc, prec, rnd)
+
+def mpf_abs(s, prec=None, rnd=round_fast):
+    """Return abs(s) of the raw mpf s, rounded to the specified
+    precision. The prec argument can be omitted to generate an
+    exact result."""
+    sign, man, exp, bc = s
+    if (not man) and exp:
+        if s == fninf:
+            return finf
+        return s
+    if not prec:
+        if sign:
+            return (0, man, exp, bc)
+        return s
+    return normalize1(0, man, exp, bc, prec, rnd)
+
+def mpf_sign(s):
+    """Return -1, 0, or 1 (as a Python int, not a raw mpf) depending on
+    whether s is negative, zero, or positive. (Nan is taken to give 0.)"""
+    sign, man, exp, bc = s
+    if not man:
+        if s == finf: return 1
+        if s == fninf: return -1
+        return 0
+    return (-1) ** sign
+
+def mpf_add(s, t, prec=0, rnd=round_fast, _sub=0):
+    """
+    Add the two raw mpf values s and t.
+
+    With prec=0, no rounding is performed. Note that this can
+    produce a very large mantissa (potentially too large to fit
+    in memory) if exponents are far apart.
+    """
+    ssign, sman, sexp, sbc = s
+    tsign, tman, texp, tbc = t
+    tsign ^= _sub
+    # Standard case: two nonzero, regular numbers
+    if sman and tman:
+        offset = sexp - texp
+        if offset:
+            if offset > 0:
+                # Outside precision range; only need to perturb
+                if offset > 100 and prec:
+                    delta = sbc + sexp - tbc - texp
+                    if delta > prec + 4:
+                        offset = prec + 4
+                        sman <<= offset
+                        if tsign == ssign: sman += 1
+                        else:              sman -= 1
+                        return normalize1(ssign, sman, sexp-offset,
+                            bitcount(sman), prec, rnd)
+                # Add
+                if ssign == tsign:
+                    man = tman + (sman << offset)
+                # Subtract
+                else:
+                    if ssign: man = tman - (sman << offset)
+                    else:     man = (sman << offset) - tman
+                    if man >= 0:
+                        ssign = 0
+                    else:
+                        man = -man
+                        ssign = 1
+                bc = bitcount(man)
+                return normalize1(ssign, man, texp, bc, prec or bc, rnd)
+            elif offset < 0:
+                # Outside precision range; only need to perturb
+                if offset < -100 and prec:
+                    delta = tbc + texp - sbc - sexp
+                    if delta > prec + 4:
+                        offset = prec + 4
+                        tman <<= offset
+                        if ssign == tsign: tman += 1
+                        else:              tman -= 1
+                        return normalize1(tsign, tman, texp-offset,
+                            bitcount(tman), prec, rnd)
+                # Add
+                if ssign == tsign:
+                    man = sman + (tman << -offset)
+                # Subtract
+                else:
+                    if tsign: man = sman - (tman << -offset)
+                    else:     man = (tman << -offset) - sman
+                    if man >= 0:
+                        ssign = 0
+                    else:
+                        man = -man
+                        ssign = 1
+                bc = bitcount(man)
+                return normalize1(ssign, man, sexp, bc, prec or bc, rnd)
+        # Equal exponents; no shifting necessary
+        if ssign == tsign:
+            man = tman + sman
+        else:
+            if ssign: man = tman - sman
+            else:     man = sman - tman
+            if man >= 0:
+                ssign = 0
+            else:
+                man = -man
+                ssign = 1
+        bc = bitcount(man)
+        return normalize(ssign, man, texp, bc, prec or bc, rnd)
+    # Handle zeros and special numbers
+    if _sub:
+        t = mpf_neg(t)
+    if not sman:
+        if sexp:
+            if s == t or tman or not texp:
+                return s
+            return fnan
+        if tman:
+            return normalize1(tsign, tman, texp, tbc, prec or tbc, rnd)
+        return t
+    if texp:
+        return t
+    if sman:
+        return normalize1(ssign, sman, sexp, sbc, prec or sbc, rnd)
+    return s
+
+def mpf_sub(s, t, prec=0, rnd=round_fast):
+    """Return the difference of two raw mpfs, s-t. This function is
+    simply a wrapper of mpf_add that changes the sign of t."""
+    return mpf_add(s, t, prec, rnd, 1)
+
+def mpf_sum(xs, prec=0, rnd=round_fast, absolute=False):
+    """
+    Sum a list of mpf values efficiently and accurately
+    (typically no temporary roundoff occurs). If prec=0,
+    the final result will not be rounded either.
+
+    There may be roundoff error or cancellation if extremely
+    large exponent differences occur.
+
+    With absolute=True, sums the absolute values.
+    """
+    man = 0
+    exp = 0
+    max_extra_prec = prec*2 or 1000000  # XXX
+    special = None
+    for x in xs:
+        xsign, xman, xexp, xbc = x
+        if xman:
+            if xsign and not absolute:
+                xman = -xman
+            delta = xexp - exp
+            if xexp >= exp:
+                # x much larger than existing sum?
+                # first: quick test
+                if (delta > max_extra_prec) and \
+                    ((not man) or delta-bitcount(abs(man)) > max_extra_prec):
+                    man = xman
+                    exp = xexp
+                else:
+                    man += (xman << delta)
+            else:
+                delta = -delta
+                # x much smaller than existing sum?
+                if delta-xbc > max_extra_prec:
+                    if not man:
+                        man, exp = xman, xexp
+                else:
+                    man = (man << delta) + xman
+                    exp = xexp
+        elif xexp:
+            if absolute:
+                x = mpf_abs(x)
+            special = mpf_add(special or fzero, x, 1)
+    # Will be inf or nan
+    if special:
+        return special
+    return from_man_exp(man, exp, prec, rnd)
+
+def gmpy_mpf_mul(s, t, prec=0, rnd=round_fast):
+    """Multiply two raw mpfs"""
+    ssign, sman, sexp, sbc = s
+    tsign, tman, texp, tbc = t
+    sign = ssign ^ tsign
+    man = sman*tman
+    if man:
+        bc = bitcount(man)
+        if prec:
+            return normalize1(sign, man, sexp+texp, bc, prec, rnd)
+        else:
+            return (sign, man, sexp+texp, bc)
+    s_special = (not sman) and sexp
+    t_special = (not tman) and texp
+    if not s_special and not t_special:
+        return fzero
+    if fnan in (s, t): return fnan
+    if (not tman) and texp: s, t = t, s
+    if t == fzero: return fnan
+    return {1:finf, -1:fninf}[mpf_sign(s) * mpf_sign(t)]
+
+def gmpy_mpf_mul_int(s, n, prec, rnd=round_fast):
+    """Multiply by a Python integer."""
+    sign, man, exp, bc = s
+    if not man:
+        return mpf_mul(s, from_int(n), prec, rnd)
+    if not n:
+        return fzero
+    if n < 0:
+        sign ^= 1
+        n = -n
+    man *= n
+    return normalize(sign, man, exp, bitcount(man), prec, rnd)
+
+def python_mpf_mul(s, t, prec=0, rnd=round_fast):
+    """Multiply two raw mpfs"""
+    ssign, sman, sexp, sbc = s
+    tsign, tman, texp, tbc = t
+    sign = ssign ^ tsign
+    man = sman*tman
+    if man:
+        bc = sbc + tbc - 1
+        bc += int(man>>bc)
+        if prec:
+            return normalize1(sign, man, sexp+texp, bc, prec, rnd)
+        else:
+            return (sign, man, sexp+texp, bc)
+    s_special = (not sman) and sexp
+    t_special = (not tman) and texp
+    if not s_special and not t_special:
+        return fzero
+    if fnan in (s, t): return fnan
+    if (not tman) and texp: s, t = t, s
+    if t == fzero: return fnan
+    return {1:finf, -1:fninf}[mpf_sign(s) * mpf_sign(t)]
+
+def python_mpf_mul_int(s, n, prec, rnd=round_fast):
+    """Multiply by a Python integer."""
+    sign, man, exp, bc = s
+    if not man:
+        return mpf_mul(s, from_int(n), prec, rnd)
+    if not n:
+        return fzero
+    if n < 0:
+        sign ^= 1
+        n = -n
+    man *= n
+    # Generally n will be small
+    if n < 1024:
+        bc += bctable[int(n)] - 1
+    else:
+        bc += bitcount(n) - 1
+    bc += int(man>>bc)
+    return normalize(sign, man, exp, bc, prec, rnd)
+
+
+if BACKEND == 'gmpy':
+    mpf_mul = gmpy_mpf_mul
+    mpf_mul_int = gmpy_mpf_mul_int
+else:
+    mpf_mul = python_mpf_mul
+    mpf_mul_int = python_mpf_mul_int
+
+def mpf_shift(s, n):
+    """Quickly multiply the raw mpf s by 2**n without rounding."""
+    sign, man, exp, bc = s
+    if not man:
+        return s
+    return sign, man, exp+n, bc
+
+def mpf_frexp(x):
+    """Convert x = y*2**n to (y, n) with abs(y) in [0.5, 1) if nonzero"""
+    sign, man, exp, bc = x
+    if not man:
+        if x == fzero:
+            return (fzero, 0)
+        else:
+            raise ValueError
+    return mpf_shift(x, -bc-exp), bc+exp
+
+def mpf_div(s, t, prec, rnd=round_fast):
+    """Floating-point division"""
+    ssign, sman, sexp, sbc = s
+    tsign, tman, texp, tbc = t
+    if not sman or not tman:
+        if s == fzero:
+            if t == fzero: raise ZeroDivisionError
+            if t == fnan: return fnan
+            return fzero
+        if t == fzero:
+            raise ZeroDivisionError
+        s_special = (not sman) and sexp
+        t_special = (not tman) and texp
+        if s_special and t_special:
+            return fnan
+        if s == fnan or t == fnan:
+            return fnan
+        if not t_special:
+            if t == fzero:
+                return fnan
+            return {1:finf, -1:fninf}[mpf_sign(s) * mpf_sign(t)]
+        return fzero
+    sign = ssign ^ tsign
+    if tman == 1:
+        return normalize1(sign, sman, sexp-texp, sbc, prec, rnd)
+    # Same strategy as for addition: if there is a remainder, perturb
+    # the result a few bits outside the precision range before rounding
+    extra = prec - sbc + tbc + 5
+    if extra < 5:
+        extra = 5
+    quot, rem = divmod(sman<<extra, tman)
+    if rem:
+        quot = (quot<<1) + 1
+        extra += 1
+        return normalize1(sign, quot, sexp-texp-extra, bitcount(quot), prec, rnd)
+    return normalize(sign, quot, sexp-texp-extra, bitcount(quot), prec, rnd)
+
+def mpf_rdiv_int(n, t, prec, rnd=round_fast):
+    """Floating-point division n/t with a Python integer as numerator"""
+    sign, man, exp, bc = t
+    if not n or not man:
+        return mpf_div(from_int(n), t, prec, rnd)
+    if n < 0:
+        sign ^= 1
+        n = -n
+    extra = prec + bc + 5
+    quot, rem = divmod(n<<extra, man)
+    if rem:
+        quot = (quot<<1) + 1
+        extra += 1
+        return normalize1(sign, quot, -exp-extra, bitcount(quot), prec, rnd)
+    return normalize(sign, quot, -exp-extra, bitcount(quot), prec, rnd)
+
+def mpf_mod(s, t, prec, rnd=round_fast):
+    ssign, sman, sexp, sbc = s
+    tsign, tman, texp, tbc = t
+    if ((not sman) and sexp) or ((not tman) and texp):
+        return fnan
+    # Important special case: do nothing if t is larger
+    if ssign == tsign and texp > sexp+sbc:
+        return s
+    # Another important special case: this allows us to do e.g. x % 1.0
+    # to find the fractional part of x, and it will work when x is huge.
+    if tman == 1 and sexp > texp+tbc:
+        return fzero
+    base = min(sexp, texp)
+    sman = (-1)**ssign * sman
+    tman = (-1)**tsign * tman
+    man = (sman << (sexp-base)) % (tman << (texp-base))
+    if man >= 0:
+        sign = 0
+    else:
+        man = -man
+        sign = 1
+    return normalize(sign, man, base, bitcount(man), prec, rnd)
+
+reciprocal_rnd = {
+  round_down : round_up,
+  round_up : round_down,
+  round_floor : round_ceiling,
+  round_ceiling : round_floor,
+  round_nearest : round_nearest
+}
+
+negative_rnd = {
+  round_down : round_down,
+  round_up : round_up,
+  round_floor : round_ceiling,
+  round_ceiling : round_floor,
+  round_nearest : round_nearest
+}
+
+def mpf_pow_int(s, n, prec, rnd=round_fast):
+    """Compute s**n, where s is a raw mpf and n is a Python integer."""
+    sign, man, exp, bc = s
+
+    if (not man) and exp:
+        if s == finf:
+            if n > 0: return s
+            if n == 0: return fnan
+            return fzero
+        if s == fninf:
+            if n > 0: return [finf, fninf][n & 1]
+            if n == 0: return fnan
+            return fzero
+        return fnan
+
+    n = int(n)
+    if n == 0: return fone
+    if n == 1: return mpf_pos(s, prec, rnd)
+    if n == 2:
+        _, man, exp, bc = s
+        if not man:
+            return fzero
+        man = man*man
+        if man == 1:
+            return (0, MPZ_ONE, exp+exp, 1)
+        bc = bc + bc - 2
+        bc += bctable[int(man>>bc)]
+        return normalize1(0, man, exp+exp, bc, prec, rnd)
+    if n == -1: return mpf_div(fone, s, prec, rnd)
+    if n < 0:
+        inverse = mpf_pow_int(s, -n, prec+5, reciprocal_rnd[rnd])
+        return mpf_div(fone, inverse, prec, rnd)
+
+    result_sign = sign & n
+
+    # Use exact integer power when the exact mantissa is small
+    if man == 1:
+        return (result_sign, MPZ_ONE, exp*n, 1)
+    if bc*n < 1000:
+        man **= n
+        return normalize1(result_sign, man, exp*n, bitcount(man), prec, rnd)
+
+    # Use directed rounding all the way through to maintain rigorous
+    # bounds for interval arithmetic
+    rounds_down = (rnd == round_nearest) or \
+        shifts_down[rnd][result_sign]
+
+    # Now we perform binary exponentiation. Need to estimate precision
+    # to avoid rounding errors from temporary operations. Roughly log_2(n)
+    # operations are performed.
+    workprec = prec + 4*bitcount(n) + 4
+    _, pm, pe, pbc = fone
+    while 1:
+        if n & 1:
+            pm = pm*man
+            pe = pe+exp
+            pbc += bc - 2
+            pbc = pbc + bctable[int(pm >> pbc)]
+            if pbc > workprec:
+                if rounds_down:
+                    pm = pm >> (pbc-workprec)
+                else:
+                    pm = -((-pm) >> (pbc-workprec))
+                pe += pbc - workprec
+                pbc = workprec
+            n -= 1
+            if not n:
+                break
+        man = man*man
+        exp = exp+exp
+        bc = bc + bc - 2
+        bc = bc + bctable[int(man >> bc)]
+        if bc > workprec:
+            if rounds_down:
+                man = man >> (bc-workprec)
+            else:
+                man = -((-man) >> (bc-workprec))
+            exp += bc - workprec
+            bc = workprec
+        n = n // 2
+
+    return normalize(result_sign, pm, pe, pbc, prec, rnd)
+
+
+def mpf_perturb(x, eps_sign, prec, rnd):
+    """
+    For nonzero x, calculate x + eps with directed rounding, where
+    eps < prec relatively and eps has the given sign (0 for
+    positive, 1 for negative).
+
+    With rounding to nearest, this is taken to simply normalize
+    x to the given precision.
+    """
+    if rnd == round_nearest:
+        return mpf_pos(x, prec, rnd)
+    sign, man, exp, bc = x
+    eps = (eps_sign, MPZ_ONE, exp+bc-prec-1, 1)
+    if sign:
+        away = (rnd in (round_down, round_ceiling)) ^ eps_sign
+    else:
+        away = (rnd in (round_up, round_ceiling)) ^ eps_sign
+    if away:
+        return mpf_add(x, eps, prec, rnd)
+    else:
+        return mpf_pos(x, prec, rnd)
+
+
+#----------------------------------------------------------------------------#
+#                              Radix conversion                              #
+#----------------------------------------------------------------------------#
+
+def to_digits_exp(s, dps):
+    """Helper function for representing the floating-point number s as
+    a decimal with dps digits. Returns (sign, string, exponent) where
+    sign is '' or '-', string is the digit string, and exponent is
+    the decimal exponent as an int.
+
+    If inexact, the decimal representation is rounded toward zero."""
+
+    # Extract sign first so it doesn't mess up the string digit count
+    if s[0]:
+        sign = '-'
+        s = mpf_neg(s)
+    else:
+        sign = ''
+    _sign, man, exp, bc = s
+
+    if not man:
+        return '', '0', 0
+
+    bitprec = int(dps * math.log(10,2)) + 10
+
+    # Cut down to size
+    # TODO: account for precision when doing this
+    exp_from_1 = exp + bc
+    if abs(exp_from_1) > 3500:
+        from .libelefun import mpf_ln2, mpf_ln10
+        # Set b = int(exp * log(2)/log(10))
+        # If exp is huge, we must use high-precision arithmetic to
+        # find the nearest power of ten
+        expprec = bitcount(abs(exp)) + 5
+        tmp = from_int(exp)
+        tmp = mpf_mul(tmp, mpf_ln2(expprec))
+        tmp = mpf_div(tmp, mpf_ln10(expprec), expprec)
+        b = to_int(tmp)
+        s = mpf_div(s, mpf_pow_int(ften, b, bitprec), bitprec)
+        _sign, man, exp, bc = s
+        exponent = b
+    else:
+        exponent = 0
+
+    # First, calculate mantissa digits by converting to a binary
+    # fixed-point number and then converting that number to
+    # a decimal fixed-point number.
+    fixprec = max(bitprec - exp - bc, 0)
+    fixdps = int(fixprec / math.log(10,2) + 0.5)
+    sf = to_fixed(s, fixprec)
+    sd = bin_to_radix(sf, fixprec, 10, fixdps)
+    digits = numeral(sd, base=10, size=dps)
+
+    exponent += len(digits) - fixdps - 1
+    return sign, digits, exponent
+
+def to_str(s, dps, strip_zeros=True, min_fixed=None, max_fixed=None,
+    show_zero_exponent=False):
+    """
+    Convert a raw mpf to a decimal floating-point literal with at
+    most `dps` decimal digits in the mantissa (not counting extra zeros
+    that may be inserted for visual purposes).
+
+    The number will be printed in fixed-point format if the position
+    of the leading digit is strictly between min_fixed
+    (default = min(-dps/3,-5)) and max_fixed (default = dps).
+
+    To force fixed-point format always, set min_fixed = -inf,
+    max_fixed = +inf. To force floating-point format, set
+    min_fixed >= max_fixed.
+
+    The literal is formatted so that it can be parsed back to a number
+    by to_str, float() or Decimal().
+    """
+
+    # Special numbers
+    if not s[1]:
+        if s == fzero:
+            if dps: t = '0.0'
+            else:   t = '.0'
+            if show_zero_exponent:
+                t += 'e+0'
+            return t
+        if s == finf: return '+inf'
+        if s == fninf: return '-inf'
+        if s == fnan: return 'nan'
+        raise ValueError
+
+    if min_fixed is None: min_fixed = min(-(dps//3), -5)
+    if max_fixed is None: max_fixed = dps
+
+    # to_digits_exp rounds to floor.
+    # This sometimes kills some instances of "...00001"
+    sign, digits, exponent = to_digits_exp(s, dps+3)
+
+    # No digits: show only .0; round exponent to nearest
+    if not dps:
+        if digits[0] in '56789':
+            exponent += 1
+        digits = ".0"
+
+    else:
+        # Rounding up kills some instances of "...99999"
+        if len(digits) > dps and digits[dps] in '56789':
+            digits = digits[:dps]
+            i = dps - 1
+            while i >= 0 and digits[i] == '9':
+                i -= 1
+            if i >= 0:
+                digits = digits[:i] + str(int(digits[i]) + 1) + '0' * (dps - i - 1)
+            else:
+                digits = '1' + '0' * (dps - 1)
+                exponent += 1
+        else:
+            digits = digits[:dps]
+
+        # Prettify numbers close to unit magnitude
+        if min_fixed < exponent < max_fixed:
+            if exponent < 0:
+                digits = ("0"*int(-exponent)) + digits
+                split = 1
+            else:
+                split = exponent + 1
+                if split > dps:
+                    digits += "0"*(split-dps)
+            exponent = 0
+        else:
+            split = 1
+
+        digits = (digits[:split] + "." + digits[split:])
+
+        if strip_zeros:
+            # Clean up trailing zeros
+            digits = digits.rstrip('0')
+            if digits[-1] == ".":
+                digits += "0"
+
+    if exponent == 0 and dps and not show_zero_exponent: return sign + digits
+    if exponent >= 0: return sign + digits + "e+" + str(exponent)
+    if exponent < 0: return sign + digits + "e" + str(exponent)
+
+def str_to_man_exp(x, base=10):
+    """Helper function for from_str."""
+    x = x.lower().rstrip('l')
+    # Verify that the input is a valid float literal
+    float(x)
+    # Split into mantissa, exponent
+    parts = x.split('e')
+    if len(parts) == 1:
+        exp = 0
+    else: # == 2
+        x = parts[0]
+        exp = int(parts[1])
+    # Look for radix point in mantissa
+    parts = x.split('.')
+    if len(parts) == 2:
+        a, b = parts[0], parts[1].rstrip('0')
+        exp -= len(b)
+        x = a + b
+    x = MPZ(int(x, base))
+    return x, exp
+
+special_str = {'inf':finf, '+inf':finf, '-inf':fninf, 'nan':fnan}
+
+def from_str(x, prec, rnd=round_fast):
+    """Create a raw mpf from a decimal literal, rounding in the
+    specified direction if the input number cannot be represented
+    exactly as a binary floating-point number with the given number of
+    bits. The literal syntax accepted is the same as for Python
+    floats.
+
+    TODO: the rounding does not work properly for large exponents.
+    """
+    x = x.lower().strip()
+    if x in special_str:
+        return special_str[x]
+
+    if '/' in x:
+        p, q = x.split('/')
+        p, q = p.rstrip('l'), q.rstrip('l')
+        return from_rational(int(p), int(q), prec, rnd)
+
+    man, exp = str_to_man_exp(x, base=10)
+
+    # XXX: appropriate cutoffs & track direction
+    # note no factors of 5
+    if abs(exp) > 400:
+        s = from_int(man, prec+10)
+        s = mpf_mul(s, mpf_pow_int(ften, exp, prec+10), prec, rnd)
+    else:
+        if exp >= 0:
+            s = from_int(man * 10**exp, prec, rnd)
+        else:
+            s = from_rational(man, 10**-exp, prec, rnd)
+    return s
+
+# Binary string conversion. These are currently mainly used for debugging
+# and could use some improvement in the future
+
+def from_bstr(x):
+    man, exp = str_to_man_exp(x, base=2)
+    man = MPZ(man)
+    sign = 0
+    if man < 0:
+        man = -man
+        sign = 1
+    bc = bitcount(man)
+    return normalize(sign, man, exp, bc, bc, round_floor)
+
+def to_bstr(x):
+    sign, man, exp, bc = x
+    return ['','-'][sign] + numeral(man, size=bitcount(man), base=2) + ("e%i" % exp)
+
+
+#----------------------------------------------------------------------------#
+#                                Square roots                                #
+#----------------------------------------------------------------------------#
+
+
+def mpf_sqrt(s, prec, rnd=round_fast):
+    """
+    Compute the square root of a nonnegative mpf value. The
+    result is correctly rounded.
+    """
+    sign, man, exp, bc = s
+    if sign:
+        raise ComplexResult("square root of a negative number")
+    if not man:
+        return s
+    if exp & 1:
+        exp -= 1
+        man <<= 1
+        bc += 1
+    elif man == 1:
+        return normalize1(sign, man, exp//2, bc, prec, rnd)
+    shift = max(4, 2*prec-bc+4)
+    shift += shift & 1
+    if rnd in 'fd':
+        man = isqrt(man<<shift)
+    else:
+        man, rem = sqrtrem(man<<shift)
+        # Perturb up
+        if rem:
+            man = (man<<1)+1
+            shift += 2
+    return from_man_exp(man, (exp-shift)//2, prec, rnd)
+
+def mpf_hypot(x, y, prec, rnd=round_fast):
+    """Compute the Euclidean norm sqrt(x**2 + y**2) of two raw mpfs
+    x and y."""
+    if y == fzero: return mpf_abs(x, prec, rnd)
+    if x == fzero: return mpf_abs(y, prec, rnd)
+    hypot2 = mpf_add(mpf_mul(x,x), mpf_mul(y,y), prec+4)
+    return mpf_sqrt(hypot2, prec, rnd)
+
+
+if BACKEND == 'sage':
+    try:
+        import sage.libs.mpmath.ext_libmp as ext_lib
+        mpf_add = ext_lib.mpf_add
+        mpf_sub = ext_lib.mpf_sub
+        mpf_mul = ext_lib.mpf_mul
+        mpf_div = ext_lib.mpf_div
+        mpf_sqrt = ext_lib.mpf_sqrt
+    except ImportError:
+        pass
diff --git a/lib/python3.10/site-packages/mpmath/libmp/libmpi.py b/lib/python3.10/site-packages/mpmath/libmp/libmpi.py
new file mode 100644
index 0000000000000000000000000000000000000000..31377642b50b7e7a1e430e0cad5c84eeb00ec19c
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/libmp/libmpi.py
@@ -0,0 +1,935 @@
+"""
+Computational functions for interval arithmetic.
+
+"""
+
+from .backend import xrange
+
+from .libmpf import (
+    ComplexResult,
+    round_down, round_up, round_floor, round_ceiling, round_nearest,
+    prec_to_dps, repr_dps, dps_to_prec,
+    bitcount,
+    from_float,
+    fnan, finf, fninf, fzero, fhalf, fone, fnone,
+    mpf_sign, mpf_lt, mpf_le, mpf_gt, mpf_ge, mpf_eq, mpf_cmp,
+    mpf_min_max,
+    mpf_floor, from_int, to_int, to_str, from_str,
+    mpf_abs, mpf_neg, mpf_pos, mpf_add, mpf_sub, mpf_mul, mpf_mul_int,
+    mpf_div, mpf_shift, mpf_pow_int,
+    from_man_exp, MPZ_ONE)
+
+from .libelefun import (
+    mpf_log, mpf_exp, mpf_sqrt, mpf_atan, mpf_atan2,
+    mpf_pi, mod_pi2, mpf_cos_sin
+)
+
+from .gammazeta import mpf_gamma, mpf_rgamma, mpf_loggamma, mpc_loggamma
+
+def mpi_str(s, prec):
+    sa, sb = s
+    dps = prec_to_dps(prec) + 5
+    return "[%s, %s]" % (to_str(sa, dps), to_str(sb, dps))
+    #dps = prec_to_dps(prec)
+    #m = mpi_mid(s, prec)
+    #d = mpf_shift(mpi_delta(s, 20), -1)
+    #return "%s +/- %s" % (to_str(m, dps), to_str(d, 3))
+
+mpi_zero = (fzero, fzero)
+mpi_one = (fone, fone)
+
+def mpi_eq(s, t):
+    return s == t
+
+def mpi_ne(s, t):
+    return s != t
+
+def mpi_lt(s, t):
+    sa, sb = s
+    ta, tb = t
+    if mpf_lt(sb, ta): return True
+    if mpf_ge(sa, tb): return False
+    return None
+
+def mpi_le(s, t):
+    sa, sb = s
+    ta, tb = t
+    if mpf_le(sb, ta): return True
+    if mpf_gt(sa, tb): return False
+    return None
+
+def mpi_gt(s, t): return mpi_lt(t, s)
+def mpi_ge(s, t): return mpi_le(t, s)
+
+def mpi_add(s, t, prec=0):
+    sa, sb = s
+    ta, tb = t
+    a = mpf_add(sa, ta, prec, round_floor)
+    b = mpf_add(sb, tb, prec, round_ceiling)
+    if a == fnan: a = fninf
+    if b == fnan: b = finf
+    return a, b
+
+def mpi_sub(s, t, prec=0):
+    sa, sb = s
+    ta, tb = t
+    a = mpf_sub(sa, tb, prec, round_floor)
+    b = mpf_sub(sb, ta, prec, round_ceiling)
+    if a == fnan: a = fninf
+    if b == fnan: b = finf
+    return a, b
+
+def mpi_delta(s, prec):
+    sa, sb = s
+    return mpf_sub(sb, sa, prec, round_up)
+
+def mpi_mid(s, prec):
+    sa, sb = s
+    return mpf_shift(mpf_add(sa, sb, prec, round_nearest), -1)
+
+def mpi_pos(s, prec):
+    sa, sb = s
+    a = mpf_pos(sa, prec, round_floor)
+    b = mpf_pos(sb, prec, round_ceiling)
+    return a, b
+
+def mpi_neg(s, prec=0):
+    sa, sb = s
+    a = mpf_neg(sb, prec, round_floor)
+    b = mpf_neg(sa, prec, round_ceiling)
+    return a, b
+
+def mpi_abs(s, prec=0):
+    sa, sb = s
+    sas = mpf_sign(sa)
+    sbs = mpf_sign(sb)
+    # Both points nonnegative?
+    if sas >= 0:
+        a = mpf_pos(sa, prec, round_floor)
+        b = mpf_pos(sb, prec, round_ceiling)
+    # Upper point nonnegative?
+    elif sbs >= 0:
+        a = fzero
+        negsa = mpf_neg(sa)
+        if mpf_lt(negsa, sb):
+            b = mpf_pos(sb, prec, round_ceiling)
+        else:
+            b = mpf_pos(negsa, prec, round_ceiling)
+    # Both negative?
+    else:
+        a = mpf_neg(sb, prec, round_floor)
+        b = mpf_neg(sa, prec, round_ceiling)
+    return a, b
+
+# TODO: optimize
+def mpi_mul_mpf(s, t, prec):
+    return mpi_mul(s, (t, t), prec)
+
+def mpi_div_mpf(s, t, prec):
+    return mpi_div(s, (t, t), prec)
+
+def mpi_mul(s, t, prec=0):
+    sa, sb = s
+    ta, tb = t
+    sas = mpf_sign(sa)
+    sbs = mpf_sign(sb)
+    tas = mpf_sign(ta)
+    tbs = mpf_sign(tb)
+    if sas == sbs == 0:
+        # Should maybe be undefined
+        if ta == fninf or tb == finf:
+            return fninf, finf
+        return fzero, fzero
+    if tas == tbs == 0:
+        # Should maybe be undefined
+        if sa == fninf or sb == finf:
+            return fninf, finf
+        return fzero, fzero
+    if sas >= 0:
+        # positive * positive
+        if tas >= 0:
+            a = mpf_mul(sa, ta, prec, round_floor)
+            b = mpf_mul(sb, tb, prec, round_ceiling)
+            if a == fnan: a = fzero
+            if b == fnan: b = finf
+        # positive * negative
+        elif tbs <= 0:
+            a = mpf_mul(sb, ta, prec, round_floor)
+            b = mpf_mul(sa, tb, prec, round_ceiling)
+            if a == fnan: a = fninf
+            if b == fnan: b = fzero
+        # positive * both signs
+        else:
+            a = mpf_mul(sb, ta, prec, round_floor)
+            b = mpf_mul(sb, tb, prec, round_ceiling)
+            if a == fnan: a = fninf
+            if b == fnan: b = finf
+    elif sbs <= 0:
+        # negative * positive
+        if tas >= 0:
+            a = mpf_mul(sa, tb, prec, round_floor)
+            b = mpf_mul(sb, ta, prec, round_ceiling)
+            if a == fnan: a = fninf
+            if b == fnan: b = fzero
+        # negative * negative
+        elif tbs <= 0:
+            a = mpf_mul(sb, tb, prec, round_floor)
+            b = mpf_mul(sa, ta, prec, round_ceiling)
+            if a == fnan: a = fzero
+            if b == fnan: b = finf
+        # negative * both signs
+        else:
+            a = mpf_mul(sa, tb, prec, round_floor)
+            b = mpf_mul(sa, ta, prec, round_ceiling)
+            if a == fnan: a = fninf
+            if b == fnan: b = finf
+    else:
+        # General case: perform all cross-multiplications and compare
+        # Since the multiplications can be done exactly, we need only
+        # do 4 (instead of 8: two for each rounding mode)
+        cases = [mpf_mul(sa, ta), mpf_mul(sa, tb), mpf_mul(sb, ta), mpf_mul(sb, tb)]
+        if fnan in cases:
+            a, b = (fninf, finf)
+        else:
+            a, b = mpf_min_max(cases)
+            a = mpf_pos(a, prec, round_floor)
+            b = mpf_pos(b, prec, round_ceiling)
+    return a, b
+
+def mpi_square(s, prec=0):
+    sa, sb = s
+    if mpf_ge(sa, fzero):
+        a = mpf_mul(sa, sa, prec, round_floor)
+        b = mpf_mul(sb, sb, prec, round_ceiling)
+    elif mpf_le(sb, fzero):
+        a = mpf_mul(sb, sb, prec, round_floor)
+        b = mpf_mul(sa, sa, prec, round_ceiling)
+    else:
+        sa = mpf_neg(sa)
+        sa, sb = mpf_min_max([sa, sb])
+        a = fzero
+        b = mpf_mul(sb, sb, prec, round_ceiling)
+    return a, b
+
+def mpi_div(s, t, prec):
+    sa, sb = s
+    ta, tb = t
+    sas = mpf_sign(sa)
+    sbs = mpf_sign(sb)
+    tas = mpf_sign(ta)
+    tbs = mpf_sign(tb)
+    # 0 / X
+    if sas == sbs == 0:
+        # 0 / <interval containing 0>
+        if (tas < 0 and tbs > 0) or (tas == 0 or tbs == 0):
+            return fninf, finf
+        return fzero, fzero
+    # Denominator contains both negative and positive numbers;
+    # this should properly be a multi-interval, but the closest
+    # match is the entire (extended) real line
+    if tas < 0 and tbs > 0:
+        return fninf, finf
+    # Assume denominator to be nonnegative
+    if tas < 0:
+        return mpi_div(mpi_neg(s), mpi_neg(t), prec)
+    # Division by zero
+    # XXX: make sure all results make sense
+    if tas == 0:
+        # Numerator contains both signs?
+        if sas < 0 and sbs > 0:
+            return fninf, finf
+        if tas == tbs:
+            return fninf, finf
+        # Numerator positive?
+        if sas >= 0:
+            a = mpf_div(sa, tb, prec, round_floor)
+            b = finf
+        if sbs <= 0:
+            a = fninf
+            b = mpf_div(sb, tb, prec, round_ceiling)
+    # Division with positive denominator
+    # We still have to handle nans resulting from inf/0 or inf/inf
+    else:
+        # Nonnegative numerator
+        if sas >= 0:
+            a = mpf_div(sa, tb, prec, round_floor)
+            b = mpf_div(sb, ta, prec, round_ceiling)
+            if a == fnan: a = fzero
+            if b == fnan: b = finf
+        # Nonpositive numerator
+        elif sbs <= 0:
+            a = mpf_div(sa, ta, prec, round_floor)
+            b = mpf_div(sb, tb, prec, round_ceiling)
+            if a == fnan: a = fninf
+            if b == fnan: b = fzero
+        # Numerator contains both signs?
+        else:
+            a = mpf_div(sa, ta, prec, round_floor)
+            b = mpf_div(sb, ta, prec, round_ceiling)
+            if a == fnan: a = fninf
+            if b == fnan: b = finf
+    return a, b
+
+def mpi_pi(prec):
+    a = mpf_pi(prec, round_floor)
+    b = mpf_pi(prec, round_ceiling)
+    return a, b
+
+def mpi_exp(s, prec):
+    sa, sb = s
+    # exp is monotonic
+    a = mpf_exp(sa, prec, round_floor)
+    b = mpf_exp(sb, prec, round_ceiling)
+    return a, b
+
+def mpi_log(s, prec):
+    sa, sb = s
+    # log is monotonic
+    a = mpf_log(sa, prec, round_floor)
+    b = mpf_log(sb, prec, round_ceiling)
+    return a, b
+
+def mpi_sqrt(s, prec):
+    sa, sb = s
+    # sqrt is monotonic
+    a = mpf_sqrt(sa, prec, round_floor)
+    b = mpf_sqrt(sb, prec, round_ceiling)
+    return a, b
+
+def mpi_atan(s, prec):
+    sa, sb = s
+    a = mpf_atan(sa, prec, round_floor)
+    b = mpf_atan(sb, prec, round_ceiling)
+    return a, b
+
+def mpi_pow_int(s, n, prec):
+    sa, sb = s
+    if n < 0:
+        return mpi_div((fone, fone), mpi_pow_int(s, -n, prec+20), prec)
+    if n == 0:
+        return (fone, fone)
+    if n == 1:
+        return s
+    if n == 2:
+        return mpi_square(s, prec)
+    # Odd -- signs are preserved
+    if n & 1:
+        a = mpf_pow_int(sa, n, prec, round_floor)
+        b = mpf_pow_int(sb, n, prec, round_ceiling)
+    # Even -- important to ensure positivity
+    else:
+        sas = mpf_sign(sa)
+        sbs = mpf_sign(sb)
+        # Nonnegative?
+        if sas >= 0:
+            a = mpf_pow_int(sa, n, prec, round_floor)
+            b = mpf_pow_int(sb, n, prec, round_ceiling)
+        # Nonpositive?
+        elif sbs <= 0:
+            a = mpf_pow_int(sb, n, prec, round_floor)
+            b = mpf_pow_int(sa, n, prec, round_ceiling)
+        # Mixed signs?
+        else:
+            a = fzero
+            # max(-a,b)**n
+            sa = mpf_neg(sa)
+            if mpf_ge(sa, sb):
+                b = mpf_pow_int(sa, n, prec, round_ceiling)
+            else:
+                b = mpf_pow_int(sb, n, prec, round_ceiling)
+    return a, b
+
+def mpi_pow(s, t, prec):
+    ta, tb = t
+    if ta == tb and ta not in (finf, fninf):
+        if ta == from_int(to_int(ta)):
+            return mpi_pow_int(s, to_int(ta), prec)
+        if ta == fhalf:
+            return mpi_sqrt(s, prec)
+    u = mpi_log(s, prec + 20)
+    v = mpi_mul(u, t, prec + 20)
+    return mpi_exp(v, prec)
+
+def MIN(x, y):
+    if mpf_le(x, y):
+        return x
+    return y
+
+def MAX(x, y):
+    if mpf_ge(x, y):
+        return x
+    return y
+
+def cos_sin_quadrant(x, wp):
+    sign, man, exp, bc = x
+    if x == fzero:
+        return fone, fzero, 0
+    # TODO: combine evaluation code to avoid duplicate modulo
+    c, s = mpf_cos_sin(x, wp)
+    t, n, wp_ = mod_pi2(man, exp, exp+bc, 15)
+    if sign:
+        n = -1-n
+    return c, s, n
+
+def mpi_cos_sin(x, prec):
+    a, b = x
+    if a == b == fzero:
+        return (fone, fone), (fzero, fzero)
+    # Guaranteed to contain both -1 and 1
+    if (finf in x) or (fninf in x):
+        return (fnone, fone), (fnone, fone)
+    wp = prec + 20
+    ca, sa, na = cos_sin_quadrant(a, wp)
+    cb, sb, nb = cos_sin_quadrant(b, wp)
+    ca, cb = mpf_min_max([ca, cb])
+    sa, sb = mpf_min_max([sa, sb])
+    # Both functions are monotonic within one quadrant
+    if na == nb:
+        pass
+    # Guaranteed to contain both -1 and 1
+    elif nb - na >= 4:
+        return (fnone, fone), (fnone, fone)
+    else:
+        # cos has maximum between a and b
+        if na//4 != nb//4:
+            cb = fone
+        # cos has minimum
+        if (na-2)//4 != (nb-2)//4:
+            ca = fnone
+        # sin has maximum
+        if (na-1)//4 != (nb-1)//4:
+            sb = fone
+        # sin has minimum
+        if (na-3)//4 != (nb-3)//4:
+            sa = fnone
+    # Perturb to force interval rounding
+    more = from_man_exp((MPZ_ONE<<wp) + (MPZ_ONE<<10), -wp)
+    less = from_man_exp((MPZ_ONE<<wp) - (MPZ_ONE<<10), -wp)
+    def finalize(v, rounding):
+        if bool(v[0]) == (rounding == round_floor):
+            p = more
+        else:
+            p = less
+        v = mpf_mul(v, p, prec, rounding)
+        sign, man, exp, bc = v
+        if exp+bc >= 1:
+            if sign:
+                return fnone
+            return fone
+        return v
+    ca = finalize(ca, round_floor)
+    cb = finalize(cb, round_ceiling)
+    sa = finalize(sa, round_floor)
+    sb = finalize(sb, round_ceiling)
+    return (ca,cb), (sa,sb)
+
+def mpi_cos(x, prec):
+    return mpi_cos_sin(x, prec)[0]
+
+def mpi_sin(x, prec):
+    return mpi_cos_sin(x, prec)[1]
+
+def mpi_tan(x, prec):
+    cos, sin = mpi_cos_sin(x, prec+20)
+    return mpi_div(sin, cos, prec)
+
+def mpi_cot(x, prec):
+    cos, sin = mpi_cos_sin(x, prec+20)
+    return mpi_div(cos, sin, prec)
+
+def mpi_from_str_a_b(x, y, percent, prec):
+    wp = prec + 20
+    xa = from_str(x, wp, round_floor)
+    xb = from_str(x, wp, round_ceiling)
+    #ya = from_str(y, wp, round_floor)
+    y = from_str(y, wp, round_ceiling)
+    assert mpf_ge(y, fzero)
+    if percent:
+        y = mpf_mul(MAX(mpf_abs(xa), mpf_abs(xb)), y, wp, round_ceiling)
+        y = mpf_div(y, from_int(100), wp, round_ceiling)
+    a = mpf_sub(xa, y, prec, round_floor)
+    b = mpf_add(xb, y, prec, round_ceiling)
+    return a, b
+
+def mpi_from_str(s, prec):
+    """
+    Parse an interval number given as a string.
+
+    Allowed forms are
+
+    "-1.23e-27"
+        Any single decimal floating-point literal.
+    "a +- b"  or  "a (b)"
+        a is the midpoint of the interval and b is the half-width
+    "a +- b%"  or  "a (b%)"
+        a is the midpoint of the interval and the half-width
+        is b percent of a (`a \times b / 100`).
+    "[a, b]"
+        The interval indicated directly.
+    "x[y,z]e"
+        x are shared digits, y and z are unequal digits, e is the exponent.
+
+    """
+    e = ValueError("Improperly formed interval number '%s'" % s)
+    s = s.replace(" ", "")
+    wp = prec + 20
+    if "+-" in s:
+        x, y = s.split("+-")
+        return mpi_from_str_a_b(x, y, False, prec)
+    # case 2
+    elif "(" in s:
+        # Don't confuse with a complex number (x,y)
+        if s[0] == "(" or ")" not in s:
+            raise e
+        s = s.replace(")", "")
+        percent = False
+        if "%" in s:
+            if s[-1] != "%":
+                raise e
+            percent = True
+            s = s.replace("%", "")
+        x, y = s.split("(")
+        return mpi_from_str_a_b(x, y, percent, prec)
+    elif "," in s:
+        if ('[' not in s) or (']' not in s):
+            raise e
+        if s[0] == '[':
+            # case 3
+            s = s.replace("[", "")
+            s = s.replace("]", "")
+            a, b = s.split(",")
+            a = from_str(a, prec, round_floor)
+            b = from_str(b, prec, round_ceiling)
+            return a, b
+        else:
+            # case 4
+            x, y = s.split('[')
+            y, z = y.split(',')
+            if 'e' in s:
+                z, e = z.split(']')
+            else:
+                z, e = z.rstrip(']'), ''
+            a = from_str(x+y+e, prec, round_floor)
+            b = from_str(x+z+e, prec, round_ceiling)
+            return a, b
+    else:
+        a = from_str(s, prec, round_floor)
+        b = from_str(s, prec, round_ceiling)
+        return a, b
+
+def mpi_to_str(x, dps, use_spaces=True, brackets='[]', mode='brackets', error_dps=4, **kwargs):
+    """
+    Convert a mpi interval to a string.
+
+    **Arguments**
+
+    *dps*
+        decimal places to use for printing
+    *use_spaces*
+        use spaces for more readable output, defaults to true
+    *brackets*
+        pair of strings (or two-character string) giving left and right brackets
+    *mode*
+        mode of display: 'plusminus', 'percent', 'brackets' (default) or 'diff'
+    *error_dps*
+        limit the error to *error_dps* digits (mode 'plusminus and 'percent')
+
+    Additional keyword arguments are forwarded to the mpf-to-string conversion
+    for the components of the output.
+
+    **Examples**
+
+        >>> from mpmath import mpi, mp
+        >>> mp.dps = 30
+        >>> x = mpi(1, 2)._mpi_
+        >>> mpi_to_str(x, 2, mode='plusminus')
+        '1.5 +- 0.5'
+        >>> mpi_to_str(x, 2, mode='percent')
+        '1.5 (33.33%)'
+        >>> mpi_to_str(x, 2, mode='brackets')
+        '[1.0, 2.0]'
+        >>> mpi_to_str(x, 2, mode='brackets' , brackets=('<', '>'))
+        '<1.0, 2.0>'
+        >>> x = mpi('5.2582327113062393041', '5.2582327113062749951')._mpi_
+        >>> mpi_to_str(x, 15, mode='diff')
+        '5.2582327113062[4, 7]'
+        >>> mpi_to_str(mpi(0)._mpi_, 2, mode='percent')
+        '0.0 (0.0%)'
+
+    """
+    prec = dps_to_prec(dps)
+    wp = prec + 20
+    a, b = x
+    mid = mpi_mid(x, prec)
+    delta = mpi_delta(x, prec)
+    a_str = to_str(a, dps, **kwargs)
+    b_str = to_str(b, dps, **kwargs)
+    mid_str = to_str(mid, dps, **kwargs)
+    sp = ""
+    if use_spaces:
+        sp = " "
+    br1, br2 = brackets
+    if mode == 'plusminus':
+        delta_str = to_str(mpf_shift(delta,-1), dps, **kwargs)
+        s = mid_str + sp + "+-" + sp + delta_str
+    elif mode == 'percent':
+        if mid == fzero:
+            p = fzero
+        else:
+            # p = 100 * delta(x) / (2*mid(x))
+            p = mpf_mul(delta, from_int(100))
+            p = mpf_div(p, mpf_mul(mid, from_int(2)), wp)
+        s = mid_str + sp + "(" + to_str(p, error_dps) + "%)"
+    elif mode == 'brackets':
+        s = br1 + a_str + "," + sp + b_str + br2
+    elif mode == 'diff':
+        # use more digits if str(x.a) and str(x.b) are equal
+        if a_str == b_str:
+            a_str = to_str(a, dps+3, **kwargs)
+            b_str = to_str(b, dps+3, **kwargs)
+        # separate mantissa and exponent
+        a = a_str.split('e')
+        if len(a) == 1:
+            a.append('')
+        b = b_str.split('e')
+        if len(b) == 1:
+            b.append('')
+        if a[1] == b[1]:
+            if a[0] != b[0]:
+                for i in xrange(len(a[0]) + 1):
+                    if a[0][i] != b[0][i]:
+                        break
+                s = (a[0][:i] + br1 + a[0][i:] + ',' + sp + b[0][i:] + br2
+                     + 'e'*min(len(a[1]), 1) + a[1])
+            else: # no difference
+                s = a[0] + br1 + br2 + 'e'*min(len(a[1]), 1) + a[1]
+        else:
+            s = br1 + 'e'.join(a) + ',' + sp + 'e'.join(b) + br2
+    else:
+        raise ValueError("'%s' is unknown mode for printing mpi" % mode)
+    return s
+
+def mpci_add(x, y, prec):
+    a, b = x
+    c, d = y
+    return mpi_add(a, c, prec), mpi_add(b, d, prec)
+
+def mpci_sub(x, y, prec):
+    a, b = x
+    c, d = y
+    return mpi_sub(a, c, prec), mpi_sub(b, d, prec)
+
+def mpci_neg(x, prec=0):
+    a, b = x
+    return mpi_neg(a, prec), mpi_neg(b, prec)
+
+def mpci_pos(x, prec):
+    a, b = x
+    return mpi_pos(a, prec), mpi_pos(b, prec)
+
+def mpci_mul(x, y, prec):
+    # TODO: optimize for real/imag cases
+    a, b = x
+    c, d = y
+    r1 = mpi_mul(a,c)
+    r2 = mpi_mul(b,d)
+    re = mpi_sub(r1,r2,prec)
+    i1 = mpi_mul(a,d)
+    i2 = mpi_mul(b,c)
+    im = mpi_add(i1,i2,prec)
+    return re, im
+
+def mpci_div(x, y, prec):
+    # TODO: optimize for real/imag cases
+    a, b = x
+    c, d = y
+    wp = prec+20
+    m1 = mpi_square(c)
+    m2 = mpi_square(d)
+    m = mpi_add(m1,m2,wp)
+    re = mpi_add(mpi_mul(a,c), mpi_mul(b,d), wp)
+    im = mpi_sub(mpi_mul(b,c), mpi_mul(a,d), wp)
+    re = mpi_div(re, m, prec)
+    im = mpi_div(im, m, prec)
+    return re, im
+
+def mpci_exp(x, prec):
+    a, b = x
+    wp = prec+20
+    r = mpi_exp(a, wp)
+    c, s = mpi_cos_sin(b, wp)
+    a = mpi_mul(r, c, prec)
+    b = mpi_mul(r, s, prec)
+    return a, b
+
+def mpi_shift(x, n):
+    a, b = x
+    return mpf_shift(a,n), mpf_shift(b,n)
+
+def mpi_cosh_sinh(x, prec):
+    # TODO: accuracy for small x
+    wp = prec+20
+    e1 = mpi_exp(x, wp)
+    e2 = mpi_div(mpi_one, e1, wp)
+    c = mpi_add(e1, e2, prec)
+    s = mpi_sub(e1, e2, prec)
+    c = mpi_shift(c, -1)
+    s = mpi_shift(s, -1)
+    return c, s
+
+def mpci_cos(x, prec):
+    a, b = x
+    wp = prec+10
+    c, s = mpi_cos_sin(a, wp)
+    ch, sh = mpi_cosh_sinh(b, wp)
+    re = mpi_mul(c, ch, prec)
+    im = mpi_mul(s, sh, prec)
+    return re, mpi_neg(im)
+
+def mpci_sin(x, prec):
+    a, b = x
+    wp = prec+10
+    c, s = mpi_cos_sin(a, wp)
+    ch, sh = mpi_cosh_sinh(b, wp)
+    re = mpi_mul(s, ch, prec)
+    im = mpi_mul(c, sh, prec)
+    return re, im
+
+def mpci_abs(x, prec):
+    a, b = x
+    if a == mpi_zero:
+        return mpi_abs(b)
+    if b == mpi_zero:
+        return mpi_abs(a)
+    # Important: nonnegative
+    a = mpi_square(a)
+    b = mpi_square(b)
+    t = mpi_add(a, b, prec+20)
+    return mpi_sqrt(t, prec)
+
+def mpi_atan2(y, x, prec):
+    ya, yb = y
+    xa, xb = x
+    # Constrained to the real line
+    if ya == yb == fzero:
+        if mpf_ge(xa, fzero):
+            return mpi_zero
+        return mpi_pi(prec)
+    # Right half-plane
+    if mpf_ge(xa, fzero):
+        if mpf_ge(ya, fzero):
+            a = mpf_atan2(ya, xb, prec, round_floor)
+        else:
+            a = mpf_atan2(ya, xa, prec, round_floor)
+        if mpf_ge(yb, fzero):
+            b = mpf_atan2(yb, xa, prec, round_ceiling)
+        else:
+            b = mpf_atan2(yb, xb, prec, round_ceiling)
+    # Upper half-plane
+    elif mpf_ge(ya, fzero):
+        b = mpf_atan2(ya, xa, prec, round_ceiling)
+        if mpf_le(xb, fzero):
+            a = mpf_atan2(yb, xb, prec, round_floor)
+        else:
+            a = mpf_atan2(ya, xb, prec, round_floor)
+    # Lower half-plane
+    elif mpf_le(yb, fzero):
+        a = mpf_atan2(yb, xa, prec, round_floor)
+        if mpf_le(xb, fzero):
+            b = mpf_atan2(ya, xb, prec, round_ceiling)
+        else:
+            b = mpf_atan2(yb, xb, prec, round_ceiling)
+    # Covering the origin
+    else:
+        b = mpf_pi(prec, round_ceiling)
+        a = mpf_neg(b)
+    return a, b
+
+def mpci_arg(z, prec):
+    x, y = z
+    return mpi_atan2(y, x, prec)
+
+def mpci_log(z, prec):
+    x, y = z
+    re = mpi_log(mpci_abs(z, prec+20), prec)
+    im = mpci_arg(z, prec)
+    return re, im
+
+def mpci_pow(x, y, prec):
+    # TODO: recognize/speed up real cases, integer y
+    yre, yim = y
+    if yim == mpi_zero:
+        ya, yb = yre
+        if ya == yb:
+            sign, man, exp, bc = yb
+            if man and exp >= 0:
+                return mpci_pow_int(x, (-1)**sign * int(man<<exp), prec)
+            # x^0
+            if yb == fzero:
+                return mpci_pow_int(x, 0, prec)
+    wp = prec+20
+    return mpci_exp(mpci_mul(y, mpci_log(x, wp), wp), prec)
+
+def mpci_square(x, prec):
+    a, b = x
+    # (a+bi)^2 = (a^2-b^2) + 2abi
+    re = mpi_sub(mpi_square(a), mpi_square(b), prec)
+    im = mpi_mul(a, b, prec)
+    im = mpi_shift(im, 1)
+    return re, im
+
+def mpci_pow_int(x, n, prec):
+    if n < 0:
+        return mpci_div((mpi_one,mpi_zero), mpci_pow_int(x, -n, prec+20), prec)
+    if n == 0:
+        return mpi_one, mpi_zero
+    if n == 1:
+        return mpci_pos(x, prec)
+    if n == 2:
+        return mpci_square(x, prec)
+    wp = prec + 20
+    result = (mpi_one, mpi_zero)
+    while n:
+        if n & 1:
+            result = mpci_mul(result, x, wp)
+            n -= 1
+        x = mpci_square(x, wp)
+        n >>= 1
+    return mpci_pos(result, prec)
+
+gamma_min_a = from_float(1.46163214496)
+gamma_min_b = from_float(1.46163214497)
+gamma_min = (gamma_min_a, gamma_min_b)
+gamma_mono_imag_a = from_float(-1.1)
+gamma_mono_imag_b = from_float(1.1)
+
+def mpi_overlap(x, y):
+    a, b = x
+    c, d = y
+    if mpf_lt(d, a): return False
+    if mpf_gt(c, b): return False
+    return True
+
+# type = 0 -- gamma
+# type = 1 -- factorial
+# type = 2 -- 1/gamma
+# type = 3 -- log-gamma
+
+def mpi_gamma(z, prec, type=0):
+    a, b = z
+    wp = prec+20
+
+    if type == 1:
+        return mpi_gamma(mpi_add(z, mpi_one, wp), prec, 0)
+
+    # increasing
+    if mpf_gt(a, gamma_min_b):
+        if type == 0:
+            c = mpf_gamma(a, prec, round_floor)
+            d = mpf_gamma(b, prec, round_ceiling)
+        elif type == 2:
+            c = mpf_rgamma(b, prec, round_floor)
+            d = mpf_rgamma(a, prec, round_ceiling)
+        elif type == 3:
+            c = mpf_loggamma(a, prec, round_floor)
+            d = mpf_loggamma(b, prec, round_ceiling)
+    # decreasing
+    elif mpf_gt(a, fzero) and mpf_lt(b, gamma_min_a):
+        if type == 0:
+            c = mpf_gamma(b, prec, round_floor)
+            d = mpf_gamma(a, prec, round_ceiling)
+        elif type == 2:
+            c = mpf_rgamma(a, prec, round_floor)
+            d = mpf_rgamma(b, prec, round_ceiling)
+        elif type == 3:
+            c = mpf_loggamma(b, prec, round_floor)
+            d = mpf_loggamma(a, prec, round_ceiling)
+    else:
+        # TODO: reflection formula
+        znew = mpi_add(z, mpi_one, wp)
+        if type == 0: return mpi_div(mpi_gamma(znew, prec+2, 0), z, prec)
+        if type == 2: return mpi_mul(mpi_gamma(znew, prec+2, 2), z, prec)
+        if type == 3: return mpi_sub(mpi_gamma(znew, prec+2, 3), mpi_log(z, prec+2), prec)
+    return c, d
+
+def mpci_gamma(z, prec, type=0):
+    (a1,a2), (b1,b2) = z
+
+    # Real case
+    if b1 == b2 == fzero and (type != 3 or mpf_gt(a1,fzero)):
+        return mpi_gamma(z, prec, type), mpi_zero
+
+    # Estimate precision
+    wp = prec+20
+    if type != 3:
+        amag = a2[2]+a2[3]
+        bmag = b2[2]+b2[3]
+        if a2 != fzero:
+            mag = max(amag, bmag)
+        else:
+            mag = bmag
+        an = abs(to_int(a2))
+        bn = abs(to_int(b2))
+        absn = max(an, bn)
+        gamma_size = max(0,absn*mag)
+        wp += bitcount(gamma_size)
+
+    # Assume type != 1
+    if type == 1:
+        (a1,a2) = mpi_add((a1,a2), mpi_one, wp); z = (a1,a2), (b1,b2)
+        type = 0
+
+    # Avoid non-monotonic region near the negative real axis
+    if mpf_lt(a1, gamma_min_b):
+        if mpi_overlap((b1,b2), (gamma_mono_imag_a, gamma_mono_imag_b)):
+            # TODO: reflection formula
+            #if mpf_lt(a2, mpf_shift(fone,-1)):
+            #    znew = mpci_sub((mpi_one,mpi_zero),z,wp)
+            #    ...
+            # Recurrence:
+            # gamma(z) = gamma(z+1)/z
+            znew = mpi_add((a1,a2), mpi_one, wp), (b1,b2)
+            if type == 0: return mpci_div(mpci_gamma(znew, prec+2, 0), z, prec)
+            if type == 2: return mpci_mul(mpci_gamma(znew, prec+2, 2), z, prec)
+            if type == 3: return mpci_sub(mpci_gamma(znew, prec+2, 3), mpci_log(z,prec+2), prec)
+
+    # Use monotonicity (except for a small region close to the
+    # origin and near poles)
+    # upper half-plane
+    if mpf_ge(b1, fzero):
+        minre = mpc_loggamma((a1,b2), wp, round_floor)
+        maxre = mpc_loggamma((a2,b1), wp, round_ceiling)
+        minim = mpc_loggamma((a1,b1), wp, round_floor)
+        maxim = mpc_loggamma((a2,b2), wp, round_ceiling)
+    # lower half-plane
+    elif mpf_le(b2, fzero):
+        minre = mpc_loggamma((a1,b1), wp, round_floor)
+        maxre = mpc_loggamma((a2,b2), wp, round_ceiling)
+        minim = mpc_loggamma((a2,b1), wp, round_floor)
+        maxim = mpc_loggamma((a1,b2), wp, round_ceiling)
+    # crosses real axis
+    else:
+        maxre = mpc_loggamma((a2,fzero), wp, round_ceiling)
+        # stretches more into the lower half-plane
+        if mpf_gt(mpf_neg(b1), b2):
+            minre = mpc_loggamma((a1,b1), wp, round_ceiling)
+        else:
+            minre = mpc_loggamma((a1,b2), wp, round_ceiling)
+        minim = mpc_loggamma((a2,b1), wp, round_floor)
+        maxim = mpc_loggamma((a2,b2), wp, round_floor)
+
+    w = (minre[0], maxre[0]), (minim[1], maxim[1])
+    if type == 3:
+        return mpi_pos(w[0], prec), mpi_pos(w[1], prec)
+    if type == 2:
+        w = mpci_neg(w)
+    return mpci_exp(w, prec)
+
+def mpi_loggamma(z, prec): return mpi_gamma(z, prec, type=3)
+def mpci_loggamma(z, prec): return mpci_gamma(z, prec, type=3)
+
+def mpi_rgamma(z, prec): return mpi_gamma(z, prec, type=2)
+def mpci_rgamma(z, prec): return mpci_gamma(z, prec, type=2)
+
+def mpi_factorial(z, prec): return mpi_gamma(z, prec, type=1)
+def mpci_factorial(z, prec): return mpci_gamma(z, prec, type=1)
diff --git a/lib/python3.10/site-packages/mpmath/matrices/__init__.py b/lib/python3.10/site-packages/mpmath/matrices/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..293697b9fcf8bd82d58ac4ff45acd73fadac82f9
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/matrices/__init__.py
@@ -0,0 +1,2 @@
+from . import eigen           # to set methods
+from . import eigen_symmetric # to set methods
diff --git a/lib/python3.10/site-packages/mpmath/matrices/__pycache__/calculus.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/matrices/__pycache__/calculus.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1522645dd3589806b77f7a7d67174af175b66c01
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/matrices/__pycache__/calculus.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/matrices/calculus.py b/lib/python3.10/site-packages/mpmath/matrices/calculus.py
new file mode 100644
index 0000000000000000000000000000000000000000..7fae2a7a9a29898241ed41810331b480ff70798f
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/matrices/calculus.py
@@ -0,0 +1,531 @@
+from ..libmp.backend import xrange
+
+# TODO: should use diagonalization-based algorithms
+
+class MatrixCalculusMethods(object):
+
+    def _exp_pade(ctx, a):
+        """
+        Exponential of a matrix using Pade approximants.
+
+        See G. H. Golub, C. F. van Loan 'Matrix Computations',
+        third Ed., page 572
+
+        TODO:
+         - find a good estimate for q
+         - reduce the number of matrix multiplications to improve
+           performance
+        """
+        def eps_pade(p):
+            return ctx.mpf(2)**(3-2*p) * \
+                ctx.factorial(p)**2/(ctx.factorial(2*p)**2 * (2*p + 1))
+        q = 4
+        extraq = 8
+        while 1:
+            if eps_pade(q) < ctx.eps:
+                break
+            q += 1
+        q += extraq
+        j = int(max(1, ctx.mag(ctx.mnorm(a,'inf'))))
+        extra = q
+        prec = ctx.prec
+        ctx.dps += extra + 3
+        try:
+            a = a/2**j
+            na = a.rows
+            den = ctx.eye(na)
+            num = ctx.eye(na)
+            x = ctx.eye(na)
+            c = ctx.mpf(1)
+            for k in range(1, q+1):
+                c *= ctx.mpf(q - k + 1)/((2*q - k + 1) * k)
+                x = a*x
+                cx = c*x
+                num += cx
+                den += (-1)**k * cx
+            f = ctx.lu_solve_mat(den, num)
+            for k in range(j):
+                f = f*f
+        finally:
+            ctx.prec = prec
+        return f*1
+
+    def expm(ctx, A, method='taylor'):
+        r"""
+        Computes the matrix exponential of a square matrix `A`, which is defined
+        by the power series
+
+        .. math ::
+
+            \exp(A) = I + A + \frac{A^2}{2!} + \frac{A^3}{3!} + \ldots
+
+        With method='taylor', the matrix exponential is computed
+        using the Taylor series. With method='pade', Pade approximants
+        are used instead.
+
+        **Examples**
+
+        Basic examples::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = True
+            >>> expm(zeros(3))
+            [1.0  0.0  0.0]
+            [0.0  1.0  0.0]
+            [0.0  0.0  1.0]
+            >>> expm(eye(3))
+            [2.71828182845905               0.0               0.0]
+            [             0.0  2.71828182845905               0.0]
+            [             0.0               0.0  2.71828182845905]
+            >>> expm([[1,1,0],[1,0,1],[0,1,0]])
+            [ 3.86814500615414  2.26812870852145  0.841130841230196]
+            [ 2.26812870852145  2.44114713886289   1.42699786729125]
+            [0.841130841230196  1.42699786729125    1.6000162976327]
+            >>> expm([[1,1,0],[1,0,1],[0,1,0]], method='pade')
+            [ 3.86814500615414  2.26812870852145  0.841130841230196]
+            [ 2.26812870852145  2.44114713886289   1.42699786729125]
+            [0.841130841230196  1.42699786729125    1.6000162976327]
+            >>> expm([[1+j, 0], [1+j,1]])
+            [(1.46869393991589 + 2.28735528717884j)                        0.0]
+            [  (1.03776739863568 + 3.536943175722j)  (2.71828182845905 + 0.0j)]
+
+        Matrices with large entries are allowed::
+
+            >>> expm(matrix([[1,2],[2,3]])**25)
+            [5.65024064048415e+2050488462815550  9.14228140091932e+2050488462815550]
+            [9.14228140091932e+2050488462815550  1.47925220414035e+2050488462815551]
+
+        The identity `\exp(A+B) = \exp(A) \exp(B)` does not hold for
+        noncommuting matrices::
+
+            >>> A = hilbert(3)
+            >>> B = A + eye(3)
+            >>> chop(mnorm(A*B - B*A))
+            0.0
+            >>> chop(mnorm(expm(A+B) - expm(A)*expm(B)))
+            0.0
+            >>> B = A + ones(3)
+            >>> mnorm(A*B - B*A)
+            1.8
+            >>> mnorm(expm(A+B) - expm(A)*expm(B))
+            42.0927851137247
+
+        """
+        if method == 'pade':
+            prec = ctx.prec
+            try:
+                A = ctx.matrix(A)
+                ctx.prec += 2*A.rows
+                res = ctx._exp_pade(A)
+            finally:
+                ctx.prec = prec
+            return res
+        A = ctx.matrix(A)
+        prec = ctx.prec
+        j = int(max(1, ctx.mag(ctx.mnorm(A,'inf'))))
+        j += int(0.5*prec**0.5)
+        try:
+            ctx.prec += 10 + 2*j
+            tol = +ctx.eps
+            A = A/2**j
+            T = A
+            Y = A**0 + A
+            k = 2
+            while 1:
+                T *= A * (1/ctx.mpf(k))
+                if ctx.mnorm(T, 'inf') < tol:
+                    break
+                Y += T
+                k += 1
+            for k in xrange(j):
+                Y = Y*Y
+        finally:
+            ctx.prec = prec
+        Y *= 1
+        return Y
+
+    def cosm(ctx, A):
+        r"""
+        Gives the cosine of a square matrix `A`, defined in analogy
+        with the matrix exponential.
+
+        Examples::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = True
+            >>> X = eye(3)
+            >>> cosm(X)
+            [0.54030230586814               0.0               0.0]
+            [             0.0  0.54030230586814               0.0]
+            [             0.0               0.0  0.54030230586814]
+            >>> X = hilbert(3)
+            >>> cosm(X)
+            [ 0.424403834569555  -0.316643413047167  -0.221474945949293]
+            [-0.316643413047167   0.820646708837824  -0.127183694770039]
+            [-0.221474945949293  -0.127183694770039   0.909236687217541]
+            >>> X = matrix([[1+j,-2],[0,-j]])
+            >>> cosm(X)
+            [(0.833730025131149 - 0.988897705762865j)  (1.07485840848393 - 0.17192140544213j)]
+            [                                     0.0               (1.54308063481524 + 0.0j)]
+        """
+        B = 0.5 * (ctx.expm(A*ctx.j) + ctx.expm(A*(-ctx.j)))
+        if not sum(A.apply(ctx.im).apply(abs)):
+            B = B.apply(ctx.re)
+        return B
+
+    def sinm(ctx, A):
+        r"""
+        Gives the sine of a square matrix `A`, defined in analogy
+        with the matrix exponential.
+
+        Examples::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = True
+            >>> X = eye(3)
+            >>> sinm(X)
+            [0.841470984807897                0.0                0.0]
+            [              0.0  0.841470984807897                0.0]
+            [              0.0                0.0  0.841470984807897]
+            >>> X = hilbert(3)
+            >>> sinm(X)
+            [0.711608512150994  0.339783913247439  0.220742837314741]
+            [0.339783913247439  0.244113865695532  0.187231271174372]
+            [0.220742837314741  0.187231271174372  0.155816730769635]
+            >>> X = matrix([[1+j,-2],[0,-j]])
+            >>> sinm(X)
+            [(1.29845758141598 + 0.634963914784736j)  (-1.96751511930922 + 0.314700021761367j)]
+            [                                    0.0                  (0.0 - 1.1752011936438j)]
+        """
+        B = (-0.5j) * (ctx.expm(A*ctx.j) - ctx.expm(A*(-ctx.j)))
+        if not sum(A.apply(ctx.im).apply(abs)):
+            B = B.apply(ctx.re)
+        return B
+
+    def _sqrtm_rot(ctx, A, _may_rotate):
+        # If the iteration fails to converge, cheat by performing
+        # a rotation by a complex number
+        u = ctx.j**0.3
+        return ctx.sqrtm(u*A, _may_rotate) / ctx.sqrt(u)
+
+    def sqrtm(ctx, A, _may_rotate=2):
+        r"""
+        Computes a square root of the square matrix `A`, i.e. returns
+        a matrix `B = A^{1/2}` such that `B^2 = A`. The square root
+        of a matrix, if it exists, is not unique.
+
+        **Examples**
+
+        Square roots of some simple matrices::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = True
+            >>> sqrtm([[1,0], [0,1]])
+            [1.0  0.0]
+            [0.0  1.0]
+            >>> sqrtm([[0,0], [0,0]])
+            [0.0  0.0]
+            [0.0  0.0]
+            >>> sqrtm([[2,0],[0,1]])
+            [1.4142135623731  0.0]
+            [            0.0  1.0]
+            >>> sqrtm([[1,1],[1,0]])
+            [ (0.920442065259926 - 0.21728689675164j)  (0.568864481005783 + 0.351577584254143j)]
+            [(0.568864481005783 + 0.351577584254143j)  (0.351577584254143 - 0.568864481005783j)]
+            >>> sqrtm([[1,0],[0,1]])
+            [1.0  0.0]
+            [0.0  1.0]
+            >>> sqrtm([[-1,0],[0,1]])
+            [(0.0 - 1.0j)           0.0]
+            [         0.0  (1.0 + 0.0j)]
+            >>> sqrtm([[j,0],[0,j]])
+            [(0.707106781186547 + 0.707106781186547j)                                       0.0]
+            [                                     0.0  (0.707106781186547 + 0.707106781186547j)]
+
+        A square root of a rotation matrix, giving the corresponding
+        half-angle rotation matrix::
+
+            >>> t1 = 0.75
+            >>> t2 = t1 * 0.5
+            >>> A1 = matrix([[cos(t1), -sin(t1)], [sin(t1), cos(t1)]])
+            >>> A2 = matrix([[cos(t2), -sin(t2)], [sin(t2), cos(t2)]])
+            >>> sqrtm(A1)
+            [0.930507621912314  -0.366272529086048]
+            [0.366272529086048   0.930507621912314]
+            >>> A2
+            [0.930507621912314  -0.366272529086048]
+            [0.366272529086048   0.930507621912314]
+
+        The identity `(A^2)^{1/2} = A` does not necessarily hold::
+
+            >>> A = matrix([[4,1,4],[7,8,9],[10,2,11]])
+            >>> sqrtm(A**2)
+            [ 4.0  1.0   4.0]
+            [ 7.0  8.0   9.0]
+            [10.0  2.0  11.0]
+            >>> sqrtm(A)**2
+            [ 4.0  1.0   4.0]
+            [ 7.0  8.0   9.0]
+            [10.0  2.0  11.0]
+            >>> A = matrix([[-4,1,4],[7,-8,9],[10,2,11]])
+            >>> sqrtm(A**2)
+            [  7.43715112194995  -0.324127569985474   1.8481718827526]
+            [-0.251549715716942    9.32699765900402  2.48221180985147]
+            [  4.11609388833616   0.775751877098258   13.017955697342]
+            >>> chop(sqrtm(A)**2)
+            [-4.0   1.0   4.0]
+            [ 7.0  -8.0   9.0]
+            [10.0   2.0  11.0]
+
+        For some matrices, a square root does not exist::
+
+            >>> sqrtm([[0,1], [0,0]])
+            Traceback (most recent call last):
+              ...
+            ZeroDivisionError: matrix is numerically singular
+
+        Two examples from the documentation for Matlab's ``sqrtm``::
+
+            >>> mp.dps = 15; mp.pretty = True
+            >>> sqrtm([[7,10],[15,22]])
+            [1.56669890360128  1.74077655955698]
+            [2.61116483933547  4.17786374293675]
+            >>>
+            >>> X = matrix(\
+            ...   [[5,-4,1,0,0],
+            ...   [-4,6,-4,1,0],
+            ...   [1,-4,6,-4,1],
+            ...   [0,1,-4,6,-4],
+            ...   [0,0,1,-4,5]])
+            >>> Y = matrix(\
+            ...   [[2,-1,-0,-0,-0],
+            ...   [-1,2,-1,0,-0],
+            ...   [0,-1,2,-1,0],
+            ...   [-0,0,-1,2,-1],
+            ...   [-0,-0,-0,-1,2]])
+            >>> mnorm(sqrtm(X) - Y)
+            4.53155328326114e-19
+
+        """
+        A = ctx.matrix(A)
+        # Trivial
+        if A*0 == A:
+            return A
+        prec = ctx.prec
+        if _may_rotate:
+            d = ctx.det(A)
+            if abs(ctx.im(d)) < 16*ctx.eps and ctx.re(d) < 0:
+                return ctx._sqrtm_rot(A, _may_rotate-1)
+        try:
+            ctx.prec += 10
+            tol = ctx.eps * 128
+            Y = A
+            Z = I = A**0
+            k = 0
+            # Denman-Beavers iteration
+            while 1:
+                Yprev = Y
+                try:
+                    Y, Z = 0.5*(Y+ctx.inverse(Z)), 0.5*(Z+ctx.inverse(Y))
+                except ZeroDivisionError:
+                    if _may_rotate:
+                        Y = ctx._sqrtm_rot(A, _may_rotate-1)
+                        break
+                    else:
+                        raise
+                mag1 = ctx.mnorm(Y-Yprev, 'inf')
+                mag2 = ctx.mnorm(Y, 'inf')
+                if mag1 <= mag2*tol:
+                    break
+                if _may_rotate and k > 6 and not mag1 < mag2 * 0.001:
+                    return ctx._sqrtm_rot(A, _may_rotate-1)
+                k += 1
+                if k > ctx.prec:
+                    raise ctx.NoConvergence
+        finally:
+            ctx.prec = prec
+        Y *= 1
+        return Y
+
+    def logm(ctx, A):
+        r"""
+        Computes a logarithm of the square matrix `A`, i.e. returns
+        a matrix `B = \log(A)` such that `\exp(B) = A`. The logarithm
+        of a matrix, if it exists, is not unique.
+
+        **Examples**
+
+        Logarithms of some simple matrices::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = True
+            >>> X = eye(3)
+            >>> logm(X)
+            [0.0  0.0  0.0]
+            [0.0  0.0  0.0]
+            [0.0  0.0  0.0]
+            >>> logm(2*X)
+            [0.693147180559945                0.0                0.0]
+            [              0.0  0.693147180559945                0.0]
+            [              0.0                0.0  0.693147180559945]
+            >>> logm(expm(X))
+            [1.0  0.0  0.0]
+            [0.0  1.0  0.0]
+            [0.0  0.0  1.0]
+
+        A logarithm of a complex matrix::
+
+            >>> X = matrix([[2+j, 1, 3], [1-j, 1-2*j, 1], [-4, -5, j]])
+            >>> B = logm(X)
+            >>> nprint(B)
+            [ (0.808757 + 0.107759j)    (2.20752 + 0.202762j)   (1.07376 - 0.773874j)]
+            [ (0.905709 - 0.107795j)  (0.0287395 - 0.824993j)  (0.111619 + 0.514272j)]
+            [(-0.930151 + 0.399512j)   (-2.06266 - 0.674397j)  (0.791552 + 0.519839j)]
+            >>> chop(expm(B))
+            [(2.0 + 1.0j)           1.0           3.0]
+            [(1.0 - 1.0j)  (1.0 - 2.0j)           1.0]
+            [        -4.0          -5.0  (0.0 + 1.0j)]
+
+        A matrix `X` close to the identity matrix, for which
+        `\log(\exp(X)) = \exp(\log(X)) = X` holds::
+
+            >>> X = eye(3) + hilbert(3)/4
+            >>> X
+            [              1.25             0.125  0.0833333333333333]
+            [             0.125  1.08333333333333              0.0625]
+            [0.0833333333333333            0.0625                1.05]
+            >>> logm(expm(X))
+            [              1.25             0.125  0.0833333333333333]
+            [             0.125  1.08333333333333              0.0625]
+            [0.0833333333333333            0.0625                1.05]
+            >>> expm(logm(X))
+            [              1.25             0.125  0.0833333333333333]
+            [             0.125  1.08333333333333              0.0625]
+            [0.0833333333333333            0.0625                1.05]
+
+        A logarithm of a rotation matrix, giving back the angle of
+        the rotation::
+
+            >>> t = 3.7
+            >>> A = matrix([[cos(t),sin(t)],[-sin(t),cos(t)]])
+            >>> chop(logm(A))
+            [             0.0  -2.58318530717959]
+            [2.58318530717959                0.0]
+            >>> (2*pi-t)
+            2.58318530717959
+
+        For some matrices, a logarithm does not exist::
+
+            >>> logm([[1,0], [0,0]])
+            Traceback (most recent call last):
+              ...
+            ZeroDivisionError: matrix is numerically singular
+
+        Logarithm of a matrix with large entries::
+
+            >>> logm(hilbert(3) * 10**20).apply(re)
+            [ 45.5597513593433  1.27721006042799  0.317662687717978]
+            [ 1.27721006042799  42.5222778973542   2.24003708791604]
+            [0.317662687717978  2.24003708791604    42.395212822267]
+
+        """
+        A = ctx.matrix(A)
+        prec = ctx.prec
+        try:
+            ctx.prec += 10
+            tol = ctx.eps * 128
+            I = A**0
+            B = A
+            n = 0
+            while 1:
+                B = ctx.sqrtm(B)
+                n += 1
+                if ctx.mnorm(B-I, 'inf') < 0.125:
+                    break
+            T = X = B-I
+            L = X*0
+            k = 1
+            while 1:
+                if k & 1:
+                    L += T / k
+                else:
+                    L -= T / k
+                T *= X
+                if ctx.mnorm(T, 'inf') < tol:
+                    break
+                k += 1
+                if k > ctx.prec:
+                    raise ctx.NoConvergence
+        finally:
+            ctx.prec = prec
+        L *= 2**n
+        return L
+
+    def powm(ctx, A, r):
+        r"""
+        Computes `A^r = \exp(A \log r)` for a matrix `A` and complex
+        number `r`.
+
+        **Examples**
+
+        Powers and inverse powers of a matrix::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = True
+            >>> A = matrix([[4,1,4],[7,8,9],[10,2,11]])
+            >>> powm(A, 2)
+            [ 63.0  20.0   69.0]
+            [174.0  89.0  199.0]
+            [164.0  48.0  179.0]
+            >>> chop(powm(powm(A, 4), 1/4.))
+            [ 4.0  1.0   4.0]
+            [ 7.0  8.0   9.0]
+            [10.0  2.0  11.0]
+            >>> powm(extraprec(20)(powm)(A, -4), -1/4.)
+            [ 4.0  1.0   4.0]
+            [ 7.0  8.0   9.0]
+            [10.0  2.0  11.0]
+            >>> chop(powm(powm(A, 1+0.5j), 1/(1+0.5j)))
+            [ 4.0  1.0   4.0]
+            [ 7.0  8.0   9.0]
+            [10.0  2.0  11.0]
+            >>> powm(extraprec(5)(powm)(A, -1.5), -1/(1.5))
+            [ 4.0  1.0   4.0]
+            [ 7.0  8.0   9.0]
+            [10.0  2.0  11.0]
+
+        A Fibonacci-generating matrix::
+
+            >>> powm([[1,1],[1,0]], 10)
+            [89.0  55.0]
+            [55.0  34.0]
+            >>> fib(10)
+            55.0
+            >>> powm([[1,1],[1,0]], 6.5)
+            [(16.5166626964253 - 0.0121089837381789j)  (10.2078589271083 + 0.0195927472575932j)]
+            [(10.2078589271083 + 0.0195927472575932j)  (6.30880376931698 - 0.0317017309957721j)]
+            >>> (phi**6.5 - (1-phi)**6.5)/sqrt(5)
+            (10.2078589271083 - 0.0195927472575932j)
+            >>> powm([[1,1],[1,0]], 6.2)
+            [ (14.3076953002666 - 0.008222855781077j)  (8.81733464837593 + 0.0133048601383712j)]
+            [(8.81733464837593 + 0.0133048601383712j)  (5.49036065189071 - 0.0215277159194482j)]
+            >>> (phi**6.2 - (1-phi)**6.2)/sqrt(5)
+            (8.81733464837593 - 0.0133048601383712j)
+
+        """
+        A = ctx.matrix(A)
+        r = ctx.convert(r)
+        prec = ctx.prec
+        try:
+            ctx.prec += 10
+            if ctx.isint(r):
+                v = A ** int(r)
+            elif ctx.isint(r*2):
+                y = int(r*2)
+                v = ctx.sqrtm(A) ** y
+            else:
+                v = ctx.expm(r*ctx.logm(A))
+        finally:
+            ctx.prec = prec
+        v *= 1
+        return v
diff --git a/lib/python3.10/site-packages/mpmath/matrices/eigen.py b/lib/python3.10/site-packages/mpmath/matrices/eigen.py
new file mode 100644
index 0000000000000000000000000000000000000000..885d604203195b695183329acc637de91aeaf5ea
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/matrices/eigen.py
@@ -0,0 +1,877 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+##################################################################################################
+#     module for the eigenvalue problem
+#       Copyright 2013 Timo Hartmann (thartmann15 at gmail.com)
+#
+# todo:
+#  - implement balancing
+#  - agressive early deflation
+#
+##################################################################################################
+
+"""
+The eigenvalue problem
+----------------------
+
+This file contains routines for the eigenvalue problem.
+
+high level routines:
+
+  hessenberg : reduction of a real or complex square matrix to upper Hessenberg form
+  schur : reduction of a real or complex square matrix to upper Schur form
+  eig : eigenvalues and eigenvectors of a real or complex square matrix
+
+low level routines:
+
+  hessenberg_reduce_0 : reduction of a real or complex square matrix to upper Hessenberg form
+  hessenberg_reduce_1 : auxiliary routine to hessenberg_reduce_0
+  qr_step : a single implicitly shifted QR step for an upper Hessenberg matrix
+  hessenberg_qr : Schur decomposition of an upper Hessenberg matrix
+  eig_tr_r : right eigenvectors of an upper triangular matrix
+  eig_tr_l : left  eigenvectors of an upper triangular matrix
+"""
+
+from ..libmp.backend import xrange
+
+class Eigen(object):
+    pass
+
+def defun(f):
+    setattr(Eigen, f.__name__, f)
+    return f
+
+def hessenberg_reduce_0(ctx, A, T):
+    """
+    This routine computes the (upper) Hessenberg decomposition of a square matrix A.
+    Given A, an unitary matrix Q is calculated such that
+
+               Q' A Q = H              and             Q' Q = Q Q' = 1
+
+    where H is an upper Hessenberg matrix, meaning that it only contains zeros
+    below the first subdiagonal. Here ' denotes the hermitian transpose (i.e.
+    transposition and conjugation).
+
+    parameters:
+      A         (input/output) On input, A contains the square matrix A of
+                dimension (n,n). On output, A contains a compressed representation
+                of Q and H.
+      T         (output) An array of length n containing the first elements of
+                the Householder reflectors.
+    """
+
+    # internally we work with householder reflections from the right.
+    # let u be a row vector (i.e. u[i]=A[i,:i]). then
+    # Q is build up by reflectors of the type (1-v'v) where v is a suitable
+    # modification of u. these reflectors are applyed to A from the right.
+    # because we work with reflectors from the right we have to start with
+    # the bottom row of A and work then upwards (this corresponds to
+    # some kind of RQ decomposition).
+    # the first part of the vectors v (i.e. A[i,:(i-1)]) are stored as row vectors
+    # in the lower left part of A (excluding the diagonal and subdiagonal).
+    # the last entry of v is stored in T.
+    # the upper right part of A (including diagonal and subdiagonal) becomes H.
+
+
+    n = A.rows
+    if n <= 2: return
+
+    for i in xrange(n-1, 1, -1):
+
+        # scale the vector
+
+        scale = 0
+        for k in xrange(0, i):
+            scale += abs(ctx.re(A[i,k])) + abs(ctx.im(A[i,k]))
+
+        scale_inv = 0
+        if scale != 0:
+            scale_inv = 1 / scale
+
+        if scale == 0 or ctx.isinf(scale_inv):
+            # sadly there are floating point numbers not equal to zero whose reciprocal is infinity
+            T[i] = 0
+            A[i,i-1] = 0
+            continue
+
+        # calculate parameters for housholder transformation
+
+        H = 0
+        for k in xrange(0, i):
+            A[i,k] *= scale_inv
+            rr = ctx.re(A[i,k])
+            ii = ctx.im(A[i,k])
+            H += rr * rr + ii * ii
+
+        F = A[i,i-1]
+        f = abs(F)
+        G = ctx.sqrt(H)
+        A[i,i-1] = - G * scale
+
+        if f == 0:
+            T[i] = G
+        else:
+            ff = F / f
+            T[i] = F + G * ff
+            A[i,i-1] *= ff
+
+        H += G * f
+        H = 1 / ctx.sqrt(H)
+
+        T[i] *= H
+        for k in xrange(0, i - 1):
+            A[i,k] *= H
+
+        for j in xrange(0, i):
+            # apply housholder transformation (from right)
+
+            G = ctx.conj(T[i]) * A[j,i-1]
+            for k in xrange(0, i-1):
+                G += ctx.conj(A[i,k]) * A[j,k]
+
+            A[j,i-1] -= G * T[i]
+            for k in xrange(0, i-1):
+                A[j,k] -= G * A[i,k]
+
+        for j in xrange(0, n):
+            # apply housholder transformation (from left)
+
+            G = T[i] * A[i-1,j]
+            for k in xrange(0, i-1):
+                G += A[i,k] * A[k,j]
+
+            A[i-1,j] -= G * ctx.conj(T[i])
+            for k in xrange(0, i-1):
+                A[k,j] -= G * ctx.conj(A[i,k])
+
+
+
+def hessenberg_reduce_1(ctx, A, T):
+    """
+    This routine forms the unitary matrix Q described in hessenberg_reduce_0.
+
+    parameters:
+      A    (input/output) On input, A is the same matrix as delivered by
+           hessenberg_reduce_0. On output, A is set to Q.
+
+      T    (input) On input, T is the same array as delivered by hessenberg_reduce_0.
+    """
+
+    n = A.rows
+
+    if n == 1:
+        A[0,0] = 1
+        return
+
+    A[0,0] = A[1,1] = 1
+    A[0,1] = A[1,0] = 0
+
+    for i in xrange(2, n):
+        if T[i] != 0:
+
+            for j in xrange(0, i):
+                G = T[i] * A[i-1,j]
+                for k in xrange(0, i-1):
+                    G += A[i,k] * A[k,j]
+
+                A[i-1,j] -= G * ctx.conj(T[i])
+                for k in xrange(0, i-1):
+                    A[k,j] -= G * ctx.conj(A[i,k])
+
+        A[i,i] = 1
+        for j in xrange(0, i):
+            A[j,i] = A[i,j] = 0
+
+
+
+@defun
+def hessenberg(ctx, A, overwrite_a = False):
+    """
+    This routine computes the Hessenberg decomposition of a square matrix A.
+    Given A, an unitary matrix Q is determined such that
+
+          Q' A Q = H                and               Q' Q = Q Q' = 1
+
+    where H is an upper right Hessenberg matrix. Here ' denotes the hermitian
+    transpose (i.e. transposition and conjugation).
+
+    input:
+      A            : a real or complex square matrix
+      overwrite_a  : if true, allows modification of A which may improve
+                     performance. if false, A is not modified.
+
+    output:
+      Q : an unitary matrix
+      H : an upper right Hessenberg matrix
+
+    example:
+      >>> from mpmath import mp
+      >>> A = mp.matrix([[3, -1, 2], [2, 5, -5], [-2, -3, 7]])
+      >>> Q, H = mp.hessenberg(A)
+      >>> mp.nprint(H, 3) # doctest:+SKIP
+      [  3.15  2.23  4.44]
+      [-0.769  4.85  3.05]
+      [   0.0  3.61   7.0]
+      >>> print(mp.chop(A - Q * H * Q.transpose_conj()))
+      [0.0  0.0  0.0]
+      [0.0  0.0  0.0]
+      [0.0  0.0  0.0]
+
+    return value:   (Q, H)
+    """
+
+    n = A.rows
+
+    if n == 1:
+        return (ctx.matrix([[1]]), A)
+
+    if not overwrite_a:
+        A = A.copy()
+
+    T = ctx.matrix(n, 1)
+
+    hessenberg_reduce_0(ctx, A, T)
+    Q = A.copy()
+    hessenberg_reduce_1(ctx, Q, T)
+
+    for x in xrange(n):
+        for y in xrange(x+2, n):
+            A[y,x] = 0
+
+    return Q, A
+
+
+###########################################################################
+
+
+def qr_step(ctx, n0, n1, A, Q, shift):
+    """
+    This subroutine executes a single implicitly shifted QR step applied to an
+    upper Hessenberg matrix A. Given A and shift as input, first an QR
+    decomposition is calculated:
+
+      Q R = A - shift * 1 .
+
+    The output is then following matrix:
+
+      R Q + shift * 1
+
+    parameters:
+      n0, n1    (input) Two integers which specify the submatrix A[n0:n1,n0:n1]
+                on which this subroutine operators. The subdiagonal elements
+                to the left and below this submatrix must be deflated (i.e. zero).
+                following restriction is imposed: n1>=n0+2
+      A         (input/output) On input, A is an upper Hessenberg matrix.
+                On output, A is replaced by "R Q + shift * 1"
+      Q         (input/output) The parameter Q is multiplied by the unitary matrix
+                Q arising from the QR decomposition. Q can also be false, in which
+                case the unitary matrix Q is not computated.
+      shift     (input) a complex number specifying the shift. idealy close to an
+                eigenvalue of the bottemmost part of the submatrix A[n0:n1,n0:n1].
+
+    references:
+      Stoer, Bulirsch - Introduction to Numerical Analysis.
+      Kresser : Numerical Methods for General and Structured Eigenvalue Problems
+    """
+
+    # implicitly shifted and bulge chasing is explained at p.398/399 in "Stoer, Bulirsch - Introduction to Numerical Analysis"
+    # for bulge chasing see also "Watkins - The Matrix Eigenvalue Problem" sec.4.5,p.173
+
+    # the Givens rotation we used is determined as follows: let c,s be two complex
+    # numbers. then we have following relation:
+    #
+    #     v = sqrt(|c|^2 + |s|^2)
+    #
+    #     1/v [ c~  s~]  [c] = [v]
+    #         [-s   c ]  [s]   [0]
+    #
+    # the matrix on the left is our Givens rotation.
+
+    n = A.rows
+
+    # first step
+
+    # calculate givens rotation
+    c = A[n0  ,n0] - shift
+    s = A[n0+1,n0]
+
+    v = ctx.hypot(ctx.hypot(ctx.re(c), ctx.im(c)), ctx.hypot(ctx.re(s), ctx.im(s)))
+
+    if v == 0:
+        v = 1
+        c = 1
+        s = 0
+    else:
+        c /= v
+        s /= v
+
+    cc = ctx.conj(c)
+    cs = ctx.conj(s)
+
+    for k in xrange(n0, n):
+        # apply givens rotation from the left
+        x = A[n0  ,k]
+        y = A[n0+1,k]
+        A[n0  ,k] = cc * x + cs * y
+        A[n0+1,k] = c * y - s * x
+
+    for k in xrange(min(n1, n0+3)):
+        # apply givens rotation from the right
+        x = A[k,n0  ]
+        y = A[k,n0+1]
+        A[k,n0  ] = c * x + s * y
+        A[k,n0+1] = cc * y - cs * x
+
+    if not isinstance(Q, bool):
+        for k in xrange(n):
+            # eigenvectors
+            x = Q[k,n0  ]
+            y = Q[k,n0+1]
+            Q[k,n0  ] = c * x + s * y
+            Q[k,n0+1] = cc * y - cs * x
+
+    # chase the bulge
+
+    for j in xrange(n0, n1 - 2):
+        # calculate givens rotation
+
+        c = A[j+1,j]
+        s = A[j+2,j]
+
+        v = ctx.hypot(ctx.hypot(ctx.re(c), ctx.im(c)), ctx.hypot(ctx.re(s), ctx.im(s)))
+
+        if v == 0:
+            A[j+1,j] = 0
+            v = 1
+            c = 1
+            s = 0
+        else:
+            A[j+1,j] = v
+            c /= v
+            s /= v
+
+        A[j+2,j] = 0
+
+        cc = ctx.conj(c)
+        cs = ctx.conj(s)
+
+        for k in xrange(j+1, n):
+            # apply givens rotation from the left
+            x = A[j+1,k]
+            y = A[j+2,k]
+            A[j+1,k] = cc * x + cs * y
+            A[j+2,k] = c * y - s * x
+
+        for k in xrange(0, min(n1, j+4)):
+            # apply givens rotation from the right
+            x = A[k,j+1]
+            y = A[k,j+2]
+            A[k,j+1] = c * x + s * y
+            A[k,j+2] = cc * y - cs * x
+
+        if not isinstance(Q, bool):
+            for k in xrange(0, n):
+                # eigenvectors
+                x = Q[k,j+1]
+                y = Q[k,j+2]
+                Q[k,j+1] = c * x + s * y
+                Q[k,j+2] = cc * y - cs * x
+
+
+
+def hessenberg_qr(ctx, A, Q):
+    """
+    This routine computes the Schur decomposition of an upper Hessenberg matrix A.
+    Given A, an unitary matrix Q is determined such that
+
+          Q' A Q = R                   and                  Q' Q = Q Q' = 1
+
+    where R is an upper right triangular matrix. Here ' denotes the hermitian
+    transpose (i.e. transposition and conjugation).
+
+    parameters:
+      A         (input/output) On input, A contains an upper Hessenberg matrix.
+                On output, A is replace by the upper right triangluar matrix R.
+
+      Q         (input/output) The parameter Q is multiplied by the unitary
+                matrix Q arising from the Schur decomposition. Q can also be
+                false, in which case the unitary matrix Q is not computated.
+    """
+
+    n = A.rows
+
+    norm = 0
+    for x in xrange(n):
+        for y in xrange(min(x+2, n)):
+            norm += ctx.re(A[y,x]) ** 2 + ctx.im(A[y,x]) ** 2
+    norm = ctx.sqrt(norm) / n
+
+    if norm == 0:
+        return
+
+    n0 = 0
+    n1 = n
+
+    eps = ctx.eps / (100 * n)
+    maxits = ctx.dps * 4
+
+    its = totalits = 0
+
+    while 1:
+        # kressner p.32 algo 3
+        # the active submatrix is A[n0:n1,n0:n1]
+
+        k = n0
+
+        while k + 1 < n1:
+            s = abs(ctx.re(A[k,k])) + abs(ctx.im(A[k,k])) + abs(ctx.re(A[k+1,k+1])) + abs(ctx.im(A[k+1,k+1]))
+            if s < eps * norm:
+                s = norm
+            if abs(A[k+1,k]) < eps * s:
+                break
+            k += 1
+
+        if k + 1 < n1:
+            # deflation found at position (k+1, k)
+
+            A[k+1,k] = 0
+            n0 = k + 1
+
+            its = 0
+
+            if n0 + 1 >= n1:
+                # block of size at most two has converged
+                n0 = 0
+                n1 = k + 1
+                if n1 < 2:
+                    # QR algorithm has converged
+                    return
+        else:
+            if (its % 30) == 10:
+                # exceptional shift
+                shift = A[n1-1,n1-2]
+            elif (its % 30) == 20:
+                # exceptional shift
+                shift = abs(A[n1-1,n1-2])
+            elif (its % 30) == 29:
+                # exceptional shift
+                shift = norm
+            else:
+                #    A = [ a b ]       det(x-A)=x*x-x*tr(A)+det(A)
+                #        [ c d ]
+                #
+                # eigenvalues bad:   (tr(A)+sqrt((tr(A))**2-4*det(A)))/2
+                #     bad because of cancellation if |c| is small and |a-d| is small, too.
+                #
+                # eigenvalues good:     (a+d+sqrt((a-d)**2+4*b*c))/2
+
+                t =  A[n1-2,n1-2] + A[n1-1,n1-1]
+                s = (A[n1-1,n1-1] - A[n1-2,n1-2]) ** 2 + 4 * A[n1-1,n1-2] * A[n1-2,n1-1]
+                if ctx.re(s) > 0:
+                    s = ctx.sqrt(s)
+                else:
+                    s = ctx.sqrt(-s) * 1j
+                a = (t + s) / 2
+                b = (t - s) / 2
+                if abs(A[n1-1,n1-1] - a) > abs(A[n1-1,n1-1] - b):
+                    shift = b
+                else:
+                    shift = a
+
+            its += 1
+            totalits += 1
+
+            qr_step(ctx, n0, n1, A, Q, shift)
+
+            if its > maxits:
+                raise RuntimeError("qr: failed to converge after %d steps" % its)
+
+
+@defun
+def schur(ctx, A, overwrite_a = False):
+    """
+    This routine computes the Schur decomposition of a square matrix A.
+    Given A, an unitary matrix Q is determined such that
+
+          Q' A Q = R                and               Q' Q = Q Q' = 1
+
+    where R is an upper right triangular matrix. Here ' denotes the
+    hermitian transpose (i.e. transposition and conjugation).
+
+    input:
+      A            : a real or complex square matrix
+      overwrite_a  : if true, allows modification of A which may improve
+                     performance. if false, A is not modified.
+
+    output:
+      Q : an unitary matrix
+      R : an upper right triangular matrix
+
+    return value:   (Q, R)
+
+    example:
+      >>> from mpmath import mp
+      >>> A = mp.matrix([[3, -1, 2], [2, 5, -5], [-2, -3, 7]])
+      >>> Q, R = mp.schur(A)
+      >>> mp.nprint(R, 3) # doctest:+SKIP
+      [2.0  0.417  -2.53]
+      [0.0    4.0  -4.74]
+      [0.0    0.0    9.0]
+      >>> print(mp.chop(A - Q * R * Q.transpose_conj()))
+      [0.0  0.0  0.0]
+      [0.0  0.0  0.0]
+      [0.0  0.0  0.0]
+
+    warning: The Schur decomposition is not unique.
+    """
+
+    n = A.rows
+
+    if n == 1:
+        return (ctx.matrix([[1]]), A)
+
+    if not overwrite_a:
+        A = A.copy()
+
+    T = ctx.matrix(n, 1)
+
+    hessenberg_reduce_0(ctx, A, T)
+    Q = A.copy()
+    hessenberg_reduce_1(ctx, Q, T)
+
+    for x in xrange(n):
+        for y in xrange(x + 2, n):
+            A[y,x] = 0
+
+    hessenberg_qr(ctx, A, Q)
+
+    return Q, A
+
+
+def eig_tr_r(ctx, A):
+    """
+    This routine calculates the right eigenvectors of an upper right triangular matrix.
+
+    input:
+      A      an upper right triangular matrix
+
+    output:
+      ER     a matrix whose columns form the right eigenvectors of A
+
+    return value: ER
+    """
+
+    # this subroutine is inspired by the lapack routines ctrevc.f,clatrs.f
+
+    n = A.rows
+
+    ER = ctx.eye(n)
+
+    eps = ctx.eps
+
+    unfl = ctx.ldexp(ctx.one, -ctx.prec * 30)
+    # since mpmath effectively has no limits on the exponent, we simply scale doubles up
+    # original double has prec*20
+
+    smlnum = unfl * (n / eps)
+    simin = 1 / ctx.sqrt(eps)
+
+    rmax = 1
+
+    for i in xrange(1, n):
+        s = A[i,i]
+
+        smin = max(eps * abs(s), smlnum)
+
+        for j in xrange(i - 1, -1, -1):
+
+            r = 0
+            for k in xrange(j + 1, i + 1):
+                r += A[j,k] * ER[k,i]
+
+            t = A[j,j] - s
+            if abs(t) < smin:
+                t = smin
+
+            r = -r / t
+            ER[j,i] = r
+
+            rmax = max(rmax, abs(r))
+            if rmax > simin:
+                for k in xrange(j, i+1):
+                    ER[k,i] /= rmax
+                rmax = 1
+
+        if rmax != 1:
+            for k in xrange(0, i + 1):
+                ER[k,i] /= rmax
+
+    return ER
+
+def eig_tr_l(ctx, A):
+    """
+    This routine calculates the left eigenvectors of an upper right triangular matrix.
+
+    input:
+      A      an upper right triangular matrix
+
+    output:
+      EL     a matrix whose rows form the left eigenvectors of A
+
+    return value:  EL
+    """
+
+    n = A.rows
+
+    EL = ctx.eye(n)
+
+    eps = ctx.eps
+
+    unfl = ctx.ldexp(ctx.one, -ctx.prec * 30)
+    # since mpmath effectively has no limits on the exponent, we simply scale doubles up
+    # original double has prec*20
+
+    smlnum = unfl * (n / eps)
+    simin = 1 / ctx.sqrt(eps)
+
+    rmax = 1
+
+    for i in xrange(0, n - 1):
+        s = A[i,i]
+
+        smin = max(eps * abs(s), smlnum)
+
+        for j in xrange(i + 1, n):
+
+            r = 0
+            for k in xrange(i, j):
+                r += EL[i,k] * A[k,j]
+
+            t = A[j,j] - s
+            if abs(t) < smin:
+                t = smin
+
+            r = -r / t
+            EL[i,j] = r
+
+            rmax = max(rmax, abs(r))
+            if rmax > simin:
+                for k in xrange(i, j + 1):
+                    EL[i,k] /= rmax
+                rmax = 1
+
+        if rmax != 1:
+            for k in xrange(i, n):
+                EL[i,k] /= rmax
+
+    return EL
+
+@defun
+def eig(ctx, A, left = False, right = True, overwrite_a = False):
+    """
+    This routine computes the eigenvalues and optionally the left and right
+    eigenvectors of a square matrix A. Given A, a vector E and matrices ER
+    and EL are calculated such that
+
+                        A ER[:,i] =         E[i] ER[:,i]
+                EL[i,:] A         = EL[i,:] E[i]
+
+    E contains the eigenvalues of A. The columns of ER contain the right eigenvectors
+    of A whereas the rows of EL contain the left eigenvectors.
+
+
+    input:
+      A           : a real or complex square matrix of shape (n, n)
+      left        : if true, the left eigenvectors are calculated.
+      right       : if true, the right eigenvectors are calculated.
+      overwrite_a : if true, allows modification of A which may improve
+                    performance. if false, A is not modified.
+
+    output:
+      E    : a list of length n containing the eigenvalues of A.
+      ER   : a matrix whose columns contain the right eigenvectors of A.
+      EL   : a matrix whose rows contain the left eigenvectors of A.
+
+    return values:
+       E            if left and right are both false.
+      (E, ER)       if right is true and left is false.
+      (E, EL)       if left is true and right is false.
+      (E, EL, ER)   if left and right are true.
+
+
+    examples:
+      >>> from mpmath import mp
+      >>> A = mp.matrix([[3, -1, 2], [2, 5, -5], [-2, -3, 7]])
+      >>> E, ER = mp.eig(A)
+      >>> print(mp.chop(A * ER[:,0] - E[0] * ER[:,0]))
+      [0.0]
+      [0.0]
+      [0.0]
+
+      >>> E, EL, ER = mp.eig(A,left = True, right = True)
+      >>> E, EL, ER = mp.eig_sort(E, EL, ER)
+      >>> mp.nprint(E)
+      [2.0, 4.0, 9.0]
+      >>> print(mp.chop(A * ER[:,0] - E[0] * ER[:,0]))
+      [0.0]
+      [0.0]
+      [0.0]
+      >>> print(mp.chop( EL[0,:] * A - EL[0,:] * E[0]))
+      [0.0  0.0  0.0]
+
+    warning:
+     - If there are multiple eigenvalues, the eigenvectors do not necessarily
+       span the whole vectorspace, i.e. ER and EL may have not full rank.
+       Furthermore in that case the eigenvectors are numerical ill-conditioned.
+     - In the general case the eigenvalues have no natural order.
+
+    see also:
+      - eigh (or eigsy, eighe) for the symmetric eigenvalue problem.
+      - eig_sort for sorting of eigenvalues and eigenvectors
+    """
+
+    n = A.rows
+
+    if n == 1:
+        if left and (not right):
+            return ([A[0]], ctx.matrix([[1]]))
+
+        if right and (not left):
+            return ([A[0]], ctx.matrix([[1]]))
+
+        return ([A[0]], ctx.matrix([[1]]), ctx.matrix([[1]]))
+
+    if not overwrite_a:
+        A = A.copy()
+
+    T = ctx.zeros(n, 1)
+
+    hessenberg_reduce_0(ctx, A, T)
+
+    if left or right:
+        Q = A.copy()
+        hessenberg_reduce_1(ctx, Q, T)
+    else:
+        Q = False
+
+    for x in xrange(n):
+        for y in xrange(x + 2, n):
+            A[y,x] = 0
+
+    hessenberg_qr(ctx, A, Q)
+
+    E = [0 for i in xrange(n)]
+    for i in xrange(n):
+        E[i] = A[i,i]
+
+    if not (left or right):
+        return E
+
+    if left:
+        EL = eig_tr_l(ctx, A)
+        EL = EL * Q.transpose_conj()
+
+    if right:
+        ER = eig_tr_r(ctx, A)
+        ER = Q * ER
+
+    if left and (not right):
+        return (E, EL)
+
+    if right and (not left):
+        return (E, ER)
+
+    return (E, EL, ER)
+
+@defun
+def eig_sort(ctx, E, EL = False, ER = False, f = "real"):
+    """
+    This routine sorts the eigenvalues and eigenvectors delivered by ``eig``.
+
+    parameters:
+      E  : the eigenvalues as delivered by eig
+      EL : the left  eigenvectors as delivered by eig, or false
+      ER : the right eigenvectors as delivered by eig, or false
+      f  : either a string ("real" sort by increasing real part, "imag" sort by
+           increasing imag part, "abs" sort by absolute value) or a function
+           mapping complexs to the reals, i.e. ``f = lambda x: -mp.re(x) ``
+           would sort the eigenvalues by decreasing real part.
+
+    return values:
+       E            if EL and ER are both false.
+      (E, ER)       if ER is not false and left is false.
+      (E, EL)       if EL is not false and right is false.
+      (E, EL, ER)   if EL and ER are not false.
+
+    example:
+      >>> from mpmath import mp
+      >>> A = mp.matrix([[3, -1, 2], [2, 5, -5], [-2, -3, 7]])
+      >>> E, EL, ER = mp.eig(A,left = True, right = True)
+      >>> E, EL, ER = mp.eig_sort(E, EL, ER)
+      >>> mp.nprint(E)
+      [2.0, 4.0, 9.0]
+      >>> E, EL, ER = mp.eig_sort(E, EL, ER,f = lambda x: -mp.re(x))
+      >>> mp.nprint(E)
+      [9.0, 4.0, 2.0]
+      >>> print(mp.chop(A * ER[:,0] - E[0] * ER[:,0]))
+      [0.0]
+      [0.0]
+      [0.0]
+      >>> print(mp.chop( EL[0,:] * A - EL[0,:] * E[0]))
+      [0.0  0.0  0.0]
+    """
+
+    if isinstance(f, str):
+        if f == "real":
+            f = ctx.re
+        elif f == "imag":
+            f = ctx.im
+        elif f == "abs":
+            f = abs
+        else:
+            raise RuntimeError("unknown function %s" % f)
+
+    n = len(E)
+
+    # Sort eigenvalues (bubble-sort)
+
+    for i in xrange(n):
+        imax = i
+        s = f(E[i])         # s is the current maximal element
+
+        for j in xrange(i + 1, n):
+            c = f(E[j])
+            if c < s:
+                s = c
+                imax = j
+
+        if imax != i:
+            # swap eigenvalues
+
+            z = E[i]
+            E[i] = E[imax]
+            E[imax] = z
+
+            if not isinstance(EL, bool):
+                for j in xrange(n):
+                    z = EL[i,j]
+                    EL[i,j] = EL[imax,j]
+                    EL[imax,j] = z
+
+            if not isinstance(ER, bool):
+                for j in xrange(n):
+                    z = ER[j,i]
+                    ER[j,i] = ER[j,imax]
+                    ER[j,imax] = z
+
+    if isinstance(EL, bool) and isinstance(ER, bool):
+        return E
+
+    if isinstance(EL, bool) and not(isinstance(ER, bool)):
+        return (E, ER)
+
+    if isinstance(ER, bool) and not(isinstance(EL, bool)):
+        return (E, EL)
+
+    return (E, EL, ER)
diff --git a/lib/python3.10/site-packages/mpmath/matrices/eigen_symmetric.py b/lib/python3.10/site-packages/mpmath/matrices/eigen_symmetric.py
new file mode 100644
index 0000000000000000000000000000000000000000..c82c0bb061d22c37a89f82a0b9bdab3e9ba7ddde
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/matrices/eigen_symmetric.py
@@ -0,0 +1,1807 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+##################################################################################################
+#     module for the symmetric eigenvalue problem
+#       Copyright 2013 Timo Hartmann (thartmann15 at gmail.com)
+#
+# todo:
+#  - implement balancing
+#
+##################################################################################################
+
+"""
+The symmetric eigenvalue problem.
+---------------------------------
+
+This file contains routines for the symmetric eigenvalue problem.
+
+high level routines:
+
+  eigsy : real symmetric (ordinary) eigenvalue problem
+  eighe : complex hermitian (ordinary) eigenvalue problem
+  eigh  : unified interface for eigsy and eighe
+  svd_r : singular value decomposition for real matrices
+  svd_c : singular value decomposition for complex matrices
+  svd   : unified interface for svd_r and svd_c
+
+
+low level routines:
+
+  r_sy_tridiag : reduction of real symmetric matrix to real symmetric tridiagonal matrix
+  c_he_tridiag_0 : reduction of complex hermitian matrix to real symmetric tridiagonal matrix
+  c_he_tridiag_1 : auxiliary routine to c_he_tridiag_0
+  c_he_tridiag_2 : auxiliary routine to c_he_tridiag_0
+  tridiag_eigen : solves the real symmetric tridiagonal matrix eigenvalue problem
+  svd_r_raw : raw singular value decomposition for real matrices
+  svd_c_raw : raw singular value decomposition for complex matrices
+"""
+
+from ..libmp.backend import xrange
+from .eigen import defun
+
+
+def r_sy_tridiag(ctx, A, D, E, calc_ev = True):
+    """
+    This routine transforms a real symmetric matrix A to a real symmetric
+    tridiagonal matrix T using an orthogonal similarity transformation:
+          Q' * A * Q = T     (here ' denotes the matrix transpose).
+    The orthogonal matrix Q is build up from Householder reflectors.
+
+    parameters:
+      A         (input/output) On input, A contains the real symmetric matrix of
+                dimension (n,n). On output, if calc_ev is true, A contains the
+                orthogonal matrix Q, otherwise A is destroyed.
+
+      D         (output) real array of length n, contains the diagonal elements
+                of the tridiagonal matrix
+
+      E         (output) real array of length n, contains the offdiagonal elements
+                of the tridiagonal matrix in E[0:(n-1)] where is the dimension of
+                the matrix A. E[n-1] is undefined.
+
+      calc_ev   (input) If calc_ev is true, this routine explicitly calculates the
+                orthogonal matrix Q which is then returned in A. If calc_ev is
+                false, Q is not explicitly calculated resulting in a shorter run time.
+
+    This routine is a python translation of the fortran routine tred2.f in the
+    software library EISPACK (see netlib.org) which itself is based on the algol
+    procedure tred2 described in:
+      - Num. Math. 11, p.181-195 (1968) by Martin, Reinsch and Wilkonson
+      - Handbook for auto. comp., Vol II, Linear Algebra, p.212-226 (1971)
+
+    For a good introduction to Householder reflections, see also
+      Stoer, Bulirsch - Introduction to Numerical Analysis.
+    """
+
+    # note : the vector v of the i-th houshoulder reflector is stored in a[(i+1):,i]
+    #        whereas v/<v,v> is stored in a[i,(i+1):]
+
+    n = A.rows
+    for i in xrange(n - 1, 0, -1):
+        # scale the vector
+
+        scale = 0
+        for k in xrange(0, i):
+            scale += abs(A[k,i])
+
+        scale_inv = 0
+        if scale != 0:
+            scale_inv = 1/scale
+
+        # sadly there are floating point numbers not equal to zero whose reciprocal is infinity
+
+        if i == 1 or scale == 0 or ctx.isinf(scale_inv):
+            E[i] = A[i-1,i]        # nothing to do
+            D[i] = 0
+            continue
+
+        # calculate parameters for housholder transformation
+
+        H = 0
+        for k in xrange(0, i):
+            A[k,i] *= scale_inv
+            H += A[k,i] * A[k,i]
+
+        F = A[i-1,i]
+        G = ctx.sqrt(H)
+        if F > 0:
+            G = -G
+        E[i] = scale * G
+        H -= F * G
+        A[i-1,i] = F - G
+        F = 0
+
+        # apply housholder transformation
+
+        for j in xrange(0, i):
+            if calc_ev:
+                A[i,j] = A[j,i] / H
+
+            G = 0                  # calculate A*U
+            for k in xrange(0, j + 1):
+                G += A[k,j] * A[k,i]
+            for k in xrange(j + 1, i):
+                G += A[j,k] * A[k,i]
+
+            E[j] = G / H           # calculate P
+            F += E[j] * A[j,i]
+
+        HH = F / (2 * H)
+
+        for j in xrange(0, i):     # calculate reduced A
+            F = A[j,i]
+            G = E[j] - HH * F      # calculate Q
+            E[j] = G
+
+            for k in xrange(0, j + 1):
+                A[k,j] -= F * E[k] + G * A[k,i]
+
+        D[i] = H
+
+    for i in xrange(1, n):         # better for compatibility
+        E[i-1] = E[i]
+    E[n-1] = 0
+
+    if calc_ev:
+        D[0] = 0
+        for i in xrange(0, n):
+            if D[i] != 0:
+                for j in xrange(0, i):     # accumulate transformation matrices
+                    G = 0
+                    for k in xrange(0, i):
+                        G += A[i,k] * A[k,j]
+                    for k in xrange(0, i):
+                        A[k,j] -= G * A[k,i]
+
+            D[i] = A[i,i]
+            A[i,i] = 1
+
+            for j in xrange(0, i):
+                A[j,i] = A[i,j] = 0
+    else:
+        for i in xrange(0, n):
+            D[i] = A[i,i]
+
+
+
+
+
+def c_he_tridiag_0(ctx, A, D, E, T):
+    """
+    This routine transforms a complex hermitian matrix A to a real symmetric
+    tridiagonal matrix T using an unitary similarity transformation:
+          Q' * A * Q = T     (here ' denotes the hermitian matrix transpose,
+                              i.e. transposition und conjugation).
+    The unitary matrix Q is build up from Householder reflectors and
+    an unitary diagonal matrix.
+
+    parameters:
+      A         (input/output) On input, A contains the complex hermitian matrix
+                of dimension (n,n). On output, A contains the unitary matrix Q
+                in compressed form.
+
+      D         (output) real array of length n, contains the diagonal elements
+                of the tridiagonal matrix.
+
+      E         (output) real array of length n, contains the offdiagonal elements
+                of the tridiagonal matrix in E[0:(n-1)] where is the dimension of
+                the matrix A. E[n-1] is undefined.
+
+      T         (output) complex array of length n, contains a unitary diagonal
+                matrix.
+
+    This routine is a python translation (in slightly modified form) of the fortran
+    routine htridi.f in the software library EISPACK (see netlib.org) which itself
+    is a complex version of the algol procedure tred1 described in:
+      - Num. Math. 11, p.181-195 (1968) by Martin, Reinsch and Wilkonson
+      - Handbook for auto. comp., Vol II, Linear Algebra, p.212-226 (1971)
+
+    For a good introduction to Householder reflections, see also
+      Stoer, Bulirsch - Introduction to Numerical Analysis.
+    """
+
+    n = A.rows
+    T[n-1] = 1
+    for i in xrange(n - 1, 0, -1):
+
+        # scale the vector
+
+        scale = 0
+        for k in xrange(0, i):
+            scale += abs(ctx.re(A[k,i])) + abs(ctx.im(A[k,i]))
+
+        scale_inv = 0
+        if scale != 0:
+            scale_inv = 1 / scale
+
+        # sadly there are floating point numbers not equal to zero whose reciprocal is infinity
+
+        if scale == 0 or ctx.isinf(scale_inv):
+            E[i] = 0
+            D[i] = 0
+            T[i-1] = 1
+            continue
+
+        if i == 1:
+            F = A[i-1,i]
+            f = abs(F)
+            E[i] = f
+            D[i] = 0
+            if f != 0:
+                T[i-1] = T[i] * F / f
+            else:
+                T[i-1] = T[i]
+            continue
+
+        # calculate parameters for housholder transformation
+
+        H = 0
+        for k in xrange(0, i):
+            A[k,i] *= scale_inv
+            rr = ctx.re(A[k,i])
+            ii = ctx.im(A[k,i])
+            H += rr * rr + ii * ii
+
+        F = A[i-1,i]
+        f = abs(F)
+        G = ctx.sqrt(H)
+        H += G * f
+        E[i] = scale * G
+        if f != 0:
+            F = F / f
+            TZ = - T[i] * F              # T[i-1]=-T[i]*F, but we need T[i-1] as temporary storage
+            G *= F
+        else:
+            TZ = -T[i]                   # T[i-1]=-T[i]
+        A[i-1,i] += G
+        F = 0
+
+        # apply housholder transformation
+
+        for j in xrange(0, i):
+            A[i,j] = A[j,i] / H
+
+            G = 0                        # calculate A*U
+            for k in xrange(0, j + 1):
+                G += ctx.conj(A[k,j]) * A[k,i]
+            for k in xrange(j + 1, i):
+                G += A[j,k] * A[k,i]
+
+            T[j] = G / H                 # calculate P
+            F += ctx.conj(T[j]) * A[j,i]
+
+        HH = F / (2 * H)
+
+        for j in xrange(0, i):           # calculate reduced A
+            F = A[j,i]
+            G = T[j] - HH * F            # calculate Q
+            T[j] = G
+
+            for k in xrange(0, j + 1):
+                A[k,j] -= ctx.conj(F) * T[k] + ctx.conj(G) * A[k,i]
+                # as we use the lower left part for storage
+                # we have to use the transpose of the normal formula
+
+        T[i-1] = TZ
+        D[i] = H
+
+    for i in xrange(1, n):                # better for compatibility
+        E[i-1] = E[i]
+    E[n-1] = 0
+
+    D[0] = 0
+    for i in xrange(0, n):
+        zw = D[i]
+        D[i] = ctx.re(A[i,i])
+        A[i,i] = zw
+
+
+
+
+
+
+
+def c_he_tridiag_1(ctx, A, T):
+    """
+    This routine forms the unitary matrix Q described in c_he_tridiag_0.
+
+    parameters:
+      A    (input/output) On input, A is the same matrix as delivered by
+           c_he_tridiag_0. On output, A is set to Q.
+
+      T    (input) On input, T is the same array as delivered by c_he_tridiag_0.
+
+    """
+
+    n = A.rows
+
+    for i in xrange(0, n):
+        if A[i,i] != 0:
+            for j in xrange(0, i):
+                G = 0
+                for k in xrange(0, i):
+                    G += ctx.conj(A[i,k]) * A[k,j]
+                for k in xrange(0, i):
+                    A[k,j] -= G * A[k,i]
+
+        A[i,i] = 1
+
+        for j in xrange(0, i):
+            A[j,i] = A[i,j] = 0
+
+    for i in xrange(0, n):
+        for k in xrange(0, n):
+            A[i,k] *= T[k]
+
+
+
+
+def c_he_tridiag_2(ctx, A, T, B):
+    """
+    This routine applied the unitary matrix Q described in c_he_tridiag_0
+    onto the the matrix B, i.e. it forms Q*B.
+
+    parameters:
+      A    (input) On input, A is the same matrix as delivered by c_he_tridiag_0.
+
+      T    (input) On input, T is the same array as delivered by c_he_tridiag_0.
+
+      B    (input/output) On input, B is a complex matrix. On output B is replaced
+           by Q*B.
+
+    This routine is a python translation of the fortran routine htribk.f in the
+    software library EISPACK (see netlib.org). See c_he_tridiag_0 for more
+    references.
+    """
+
+    n = A.rows
+
+    for i in xrange(0, n):
+        for k in xrange(0, n):
+            B[k,i] *= T[k]
+
+    for i in xrange(0, n):
+        if A[i,i] != 0:
+            for j in xrange(0, n):
+                G = 0
+                for k in xrange(0, i):
+                    G += ctx.conj(A[i,k]) * B[k,j]
+                for k in xrange(0, i):
+                    B[k,j] -= G * A[k,i]
+
+
+
+
+
+def tridiag_eigen(ctx, d, e, z = False):
+    """
+    This subroutine find the eigenvalues and the first components of the
+    eigenvectors of a real symmetric tridiagonal matrix using the implicit
+    QL method.
+
+    parameters:
+
+      d (input/output) real array of length n. on input, d contains the diagonal
+        elements of the input matrix. on output, d contains the eigenvalues in
+        ascending order.
+
+      e (input) real array of length n. on input, e contains the offdiagonal
+        elements of the input matrix in e[0:(n-1)]. On output, e has been
+        destroyed.
+
+      z (input/output) If z is equal to False, no eigenvectors will be computed.
+        Otherwise on input z should have the format z[0:m,0:n] (i.e. a real or
+        complex matrix of dimension (m,n) ). On output this matrix will be
+        multiplied by the matrix of the eigenvectors (i.e. the columns of this
+        matrix are the eigenvectors): z --> z*EV
+        That means if z[i,j]={1 if j==j; 0 otherwise} on input, then on output
+        z will contain the first m components of the eigenvectors. That means
+        if m is equal to n, the i-th eigenvector will be z[:,i].
+
+    This routine is a python translation (in slightly modified form) of the
+    fortran routine imtql2.f in the software library EISPACK (see netlib.org)
+    which itself is based on the algol procudure imtql2 desribed in:
+     - num. math. 12, p. 377-383(1968) by matrin and wilkinson
+     - modified in num. math. 15, p. 450(1970) by dubrulle
+     - handbook for auto. comp., vol. II-linear algebra, p. 241-248 (1971)
+    See also the routine gaussq.f in netlog.org or acm algorithm 726.
+    """
+
+    n = len(d)
+    e[n-1] = 0
+    iterlim = 2 * ctx.dps
+
+    for l in xrange(n):
+        j = 0
+        while 1:
+            m = l
+            while 1:
+                # look for a small subdiagonal element
+                if m + 1 == n:
+                    break
+                if abs(e[m]) <= ctx.eps * (abs(d[m]) + abs(d[m + 1])):
+                    break
+                m = m + 1
+            if m == l:
+                break
+
+            if j >= iterlim:
+                raise RuntimeError("tridiag_eigen: no convergence to an eigenvalue after %d iterations" % iterlim)
+
+            j += 1
+
+            # form shift
+
+            p = d[l]
+            g = (d[l + 1] - p) / (2 * e[l])
+            r = ctx.hypot(g, 1)
+
+            if g < 0:
+                s = g - r
+            else:
+                s = g + r
+
+            g = d[m] - p + e[l] / s
+
+            s, c, p = 1, 1, 0
+
+            for i in xrange(m - 1, l - 1, -1):
+                f = s * e[i]
+                b = c * e[i]
+                if abs(f) > abs(g):             # this here is a slight improvement also used in gaussq.f or acm algorithm 726.
+                    c = g / f
+                    r = ctx.hypot(c, 1)
+                    e[i + 1] = f * r
+                    s = 1 / r
+                    c = c * s
+                else:
+                    s = f / g
+                    r = ctx.hypot(s, 1)
+                    e[i + 1] = g * r
+                    c = 1 / r
+                    s = s * c
+                g = d[i + 1] - p
+                r = (d[i] - g) * s + 2 * c * b
+                p = s * r
+                d[i + 1] = g + p
+                g = c * r - b
+
+                if not isinstance(z, bool):
+                    # calculate eigenvectors
+                    for w in xrange(z.rows):
+                        f = z[w,i+1]
+                        z[w,i+1] = s * z[w,i] + c * f
+                        z[w,i  ] = c * z[w,i] - s * f
+
+            d[l] = d[l] - p
+            e[l] = g
+            e[m] = 0
+
+    for ii in xrange(1, n):
+        # sort eigenvalues and eigenvectors (bubble-sort)
+        i = ii - 1
+        k = i
+        p = d[i]
+        for j in xrange(ii, n):
+            if d[j] >= p:
+                continue
+            k = j
+            p = d[k]
+        if k == i:
+            continue
+        d[k] = d[i]
+        d[i] = p
+
+        if not isinstance(z, bool):
+            for w in xrange(z.rows):
+                p = z[w,i]
+                z[w,i] = z[w,k]
+                z[w,k] = p
+
+########################################################################################
+
+@defun
+def eigsy(ctx, A, eigvals_only = False, overwrite_a = False):
+    """
+    This routine solves the (ordinary) eigenvalue problem for a real symmetric
+    square matrix A. Given A, an orthogonal matrix Q is calculated which
+    diagonalizes A:
+
+          Q' A Q = diag(E)               and                Q Q' = Q' Q = 1
+
+    Here diag(E) is a diagonal matrix whose diagonal is E.
+    ' denotes the transpose.
+
+    The columns of Q are the eigenvectors of A and E contains the eigenvalues:
+
+          A Q[:,i] = E[i] Q[:,i]
+
+
+    input:
+
+      A: real matrix of format (n,n) which is symmetric
+         (i.e. A=A' or A[i,j]=A[j,i])
+
+      eigvals_only: if true, calculates only the eigenvalues E.
+                    if false, calculates both eigenvectors and eigenvalues.
+
+      overwrite_a: if true, allows modification of A which may improve
+                   performance. if false, A is not modified.
+
+    output:
+
+      E: vector of format (n). contains the eigenvalues of A in ascending order.
+
+      Q: orthogonal matrix of format (n,n). contains the eigenvectors
+         of A as columns.
+
+    return value:
+
+          E          if eigvals_only is true
+         (E, Q)      if eigvals_only is false
+
+    example:
+      >>> from mpmath import mp
+      >>> A = mp.matrix([[3, 2], [2, 0]])
+      >>> E = mp.eigsy(A, eigvals_only = True)
+      >>> print(E)
+      [-1.0]
+      [ 4.0]
+
+      >>> A = mp.matrix([[1, 2], [2, 3]])
+      >>> E, Q = mp.eigsy(A)
+      >>> print(mp.chop(A * Q[:,0] - E[0] * Q[:,0]))
+      [0.0]
+      [0.0]
+
+    see also: eighe, eigh, eig
+    """
+
+    if not overwrite_a:
+        A = A.copy()
+
+    d = ctx.zeros(A.rows, 1)
+    e = ctx.zeros(A.rows, 1)
+
+    if eigvals_only:
+        r_sy_tridiag(ctx, A, d, e, calc_ev = False)
+        tridiag_eigen(ctx, d, e, False)
+        return d
+    else:
+        r_sy_tridiag(ctx, A, d, e, calc_ev = True)
+        tridiag_eigen(ctx, d, e, A)
+        return (d, A)
+
+
+@defun
+def eighe(ctx, A, eigvals_only = False, overwrite_a = False):
+    """
+    This routine solves the (ordinary) eigenvalue problem for a complex
+    hermitian square matrix A. Given A, an unitary matrix Q is calculated which
+    diagonalizes A:
+
+        Q' A Q = diag(E)               and                Q Q' = Q' Q = 1
+
+    Here diag(E) a is diagonal matrix whose diagonal is E.
+    ' denotes the hermitian transpose (i.e. ordinary transposition and
+    complex conjugation).
+
+    The columns of Q are the eigenvectors of A and E contains the eigenvalues:
+
+        A Q[:,i] = E[i] Q[:,i]
+
+
+    input:
+
+      A: complex matrix of format (n,n) which is hermitian
+         (i.e. A=A' or A[i,j]=conj(A[j,i]))
+
+      eigvals_only: if true, calculates only the eigenvalues E.
+                    if false, calculates both eigenvectors and eigenvalues.
+
+      overwrite_a: if true, allows modification of A which may improve
+                   performance. if false, A is not modified.
+
+    output:
+
+      E: vector of format (n). contains the eigenvalues of A in ascending order.
+
+      Q: unitary matrix of format (n,n). contains the eigenvectors
+         of A as columns.
+
+    return value:
+
+           E         if eigvals_only is true
+          (E, Q)     if eigvals_only is false
+
+    example:
+      >>> from mpmath import mp
+      >>> A = mp.matrix([[1, -3 - 1j], [-3 + 1j, -2]])
+      >>> E = mp.eighe(A, eigvals_only = True)
+      >>> print(E)
+      [-4.0]
+      [ 3.0]
+
+      >>> A = mp.matrix([[1, 2 + 5j], [2 - 5j, 3]])
+      >>> E, Q = mp.eighe(A)
+      >>> print(mp.chop(A * Q[:,0] - E[0] * Q[:,0]))
+      [0.0]
+      [0.0]
+
+    see also: eigsy, eigh, eig
+    """
+
+    if not overwrite_a:
+        A = A.copy()
+
+    d = ctx.zeros(A.rows, 1)
+    e = ctx.zeros(A.rows, 1)
+    t = ctx.zeros(A.rows, 1)
+
+    if eigvals_only:
+        c_he_tridiag_0(ctx, A, d, e, t)
+        tridiag_eigen(ctx, d, e, False)
+        return d
+    else:
+        c_he_tridiag_0(ctx, A, d, e, t)
+        B = ctx.eye(A.rows)
+        tridiag_eigen(ctx, d, e, B)
+        c_he_tridiag_2(ctx, A, t, B)
+        return (d, B)
+
+@defun
+def eigh(ctx, A, eigvals_only = False, overwrite_a = False):
+    """
+    "eigh" is a unified interface for "eigsy" and "eighe". Depending on
+    whether A is real or complex the appropriate function is called.
+
+    This routine solves the (ordinary) eigenvalue problem for a real symmetric
+    or complex hermitian square matrix A. Given A, an orthogonal (A real) or
+    unitary (A complex) matrix Q is calculated which diagonalizes A:
+
+        Q' A Q = diag(E)               and                Q Q' = Q' Q = 1
+
+    Here diag(E) a is diagonal matrix whose diagonal is E.
+    ' denotes the hermitian transpose (i.e. ordinary transposition and
+    complex conjugation).
+
+    The columns of Q are the eigenvectors of A and E contains the eigenvalues:
+
+        A Q[:,i] = E[i] Q[:,i]
+
+    input:
+
+      A: a real or complex square matrix of format (n,n) which is symmetric
+         (i.e. A[i,j]=A[j,i]) or hermitian (i.e. A[i,j]=conj(A[j,i])).
+
+      eigvals_only: if true, calculates only the eigenvalues E.
+                    if false, calculates both eigenvectors and eigenvalues.
+
+      overwrite_a: if true, allows modification of A which may improve
+                   performance. if false, A is not modified.
+
+    output:
+
+      E: vector of format (n). contains the eigenvalues of A in ascending order.
+
+      Q: an orthogonal or unitary matrix of format (n,n). contains the
+         eigenvectors of A as columns.
+
+    return value:
+
+          E         if eigvals_only is true
+         (E, Q)     if eigvals_only is false
+
+    example:
+      >>> from mpmath import mp
+      >>> A = mp.matrix([[3, 2], [2, 0]])
+      >>> E = mp.eigh(A, eigvals_only = True)
+      >>> print(E)
+      [-1.0]
+      [ 4.0]
+
+      >>> A = mp.matrix([[1, 2], [2, 3]])
+      >>> E, Q = mp.eigh(A)
+      >>> print(mp.chop(A * Q[:,0] - E[0] * Q[:,0]))
+      [0.0]
+      [0.0]
+
+      >>> A = mp.matrix([[1, 2 + 5j], [2 - 5j, 3]])
+      >>> E, Q = mp.eigh(A)
+      >>> print(mp.chop(A * Q[:,0] - E[0] * Q[:,0]))
+      [0.0]
+      [0.0]
+
+    see also: eigsy, eighe, eig
+    """
+
+    iscomplex = any(type(x) is ctx.mpc for x in A)
+
+    if iscomplex:
+        return ctx.eighe(A, eigvals_only = eigvals_only, overwrite_a = overwrite_a)
+    else:
+        return ctx.eigsy(A, eigvals_only = eigvals_only, overwrite_a = overwrite_a)
+
+
+@defun
+def gauss_quadrature(ctx, n, qtype = "legendre", alpha = 0, beta = 0):
+    """
+    This routine calulates gaussian quadrature rules for different
+    families of orthogonal polynomials. Let (a, b) be an interval,
+    W(x) a positive weight function and n a positive integer.
+    Then the purpose of this routine is to calculate pairs (x_k, w_k)
+    for k=0, 1, 2, ... (n-1) which give
+
+      int(W(x) * F(x), x = a..b) = sum(w_k * F(x_k),k = 0..(n-1))
+
+    exact for all polynomials F(x) of degree (strictly) less than 2*n. For all
+    integrable functions F(x) the sum is a (more or less) good approximation to
+    the integral. The x_k are called nodes (which are the zeros of the
+    related orthogonal polynomials) and the w_k are called the weights.
+
+    parameters
+       n        (input) The degree of the quadrature rule, i.e. its number of
+                nodes.
+
+       qtype    (input) The family of orthogonal polynmomials for which to
+                compute the quadrature rule. See the list below.
+
+       alpha    (input) real number, used as parameter for some orthogonal
+                polynomials
+
+       beta     (input) real number, used as parameter for some orthogonal
+                polynomials.
+
+    return value
+
+      (X, W)    a pair of two real arrays where x_k = X[k] and w_k = W[k].
+
+
+    orthogonal polynomials:
+
+      qtype           polynomial
+      -----           ----------
+
+      "legendre"      Legendre polynomials, W(x)=1 on the interval (-1, +1)
+      "legendre01"    shifted Legendre polynomials, W(x)=1 on the interval (0, +1)
+      "hermite"       Hermite polynomials, W(x)=exp(-x*x) on (-infinity,+infinity)
+      "laguerre"      Laguerre polynomials, W(x)=exp(-x) on (0,+infinity)
+      "glaguerre"     generalized Laguerre polynomials, W(x)=exp(-x)*x**alpha
+                      on (0, +infinity)
+      "chebyshev1"    Chebyshev polynomials of the first kind, W(x)=1/sqrt(1-x*x)
+                      on (-1, +1)
+      "chebyshev2"    Chebyshev polynomials of the second kind, W(x)=sqrt(1-x*x)
+                      on (-1, +1)
+      "jacobi"        Jacobi polynomials, W(x)=(1-x)**alpha * (1+x)**beta on (-1, +1)
+                      with alpha>-1 and beta>-1
+
+    examples:
+      >>> from mpmath import mp
+      >>> f = lambda x: x**8 + 2 * x**6 - 3 * x**4 + 5 * x**2 - 7
+      >>> X, W = mp.gauss_quadrature(5, "hermite")
+      >>> A = mp.fdot([(f(x), w) for x, w in zip(X, W)])
+      >>> B = mp.sqrt(mp.pi) * 57 / 16
+      >>> C = mp.quad(lambda x: mp.exp(- x * x) * f(x), [-mp.inf, +mp.inf])
+      >>> mp.nprint((mp.chop(A-B, tol = 1e-10), mp.chop(A-C, tol = 1e-10)))
+      (0.0, 0.0)
+
+      >>> f = lambda x: x**5 - 2 * x**4 + 3 * x**3 - 5 * x**2 + 7 * x - 11
+      >>> X, W = mp.gauss_quadrature(3, "laguerre")
+      >>> A = mp.fdot([(f(x), w) for x, w in zip(X, W)])
+      >>> B = 76
+      >>> C = mp.quad(lambda x: mp.exp(-x) * f(x), [0, +mp.inf])
+      >>> mp.nprint(mp.chop(A-B, tol = 1e-10), mp.chop(A-C, tol = 1e-10))
+      .0
+
+      # orthogonality of the chebyshev polynomials:
+      >>> f = lambda x: mp.chebyt(3, x) * mp.chebyt(2, x)
+      >>> X, W = mp.gauss_quadrature(3, "chebyshev1")
+      >>> A = mp.fdot([(f(x), w) for x, w in zip(X, W)])
+      >>> print(mp.chop(A, tol = 1e-10))
+      0.0
+
+    references:
+      - golub and welsch, "calculations of gaussian quadrature rules", mathematics of
+        computation 23, p. 221-230 (1969)
+      - golub, "some modified matrix eigenvalue problems", siam review 15, p. 318-334 (1973)
+      - stroud and secrest, "gaussian quadrature formulas", prentice-hall (1966)
+
+    See also the routine gaussq.f in netlog.org or ACM Transactions on
+    Mathematical Software algorithm 726.
+    """
+
+    d = ctx.zeros(n, 1)
+    e = ctx.zeros(n, 1)
+    z = ctx.zeros(1, n)
+
+    z[0,0] = 1
+
+    if qtype == "legendre":
+        # legendre on the range -1 +1 , abramowitz, table 25.4, p.916
+        w = 2
+        for i in xrange(n):
+            j = i + 1
+            e[i] = ctx.sqrt(j * j / (4 * j * j - ctx.mpf(1)))
+    elif qtype == "legendre01":
+        # legendre shifted to 0 1        , abramowitz, table 25.8, p.921
+        w = 1
+        for i in xrange(n):
+            d[i] = 1 / ctx.mpf(2)
+            j = i + 1
+            e[i] = ctx.sqrt(j * j / (16 * j * j - ctx.mpf(4)))
+    elif qtype == "hermite":
+        # hermite on the range -inf +inf , abramowitz, table 25.10,p.924
+        w = ctx.sqrt(ctx.pi)
+        for i in xrange(n):
+            j = i + 1
+            e[i] = ctx.sqrt(j / ctx.mpf(2))
+    elif qtype == "laguerre":
+        # laguerre on the range 0 +inf , abramowitz, table 25.9, p. 923
+        w = 1
+        for i in xrange(n):
+            j = i + 1
+            d[i] = 2 * j - 1
+            e[i] = j
+    elif qtype=="chebyshev1":
+        # chebyshev polynimials of the first kind
+        w = ctx.pi
+        for i in xrange(n):
+            e[i] = 1 / ctx.mpf(2)
+        e[0] = ctx.sqrt(1 / ctx.mpf(2))
+    elif qtype == "chebyshev2":
+        # chebyshev polynimials of the second kind
+        w = ctx.pi / 2
+        for i in xrange(n):
+            e[i] = 1 / ctx.mpf(2)
+    elif qtype == "glaguerre":
+        # generalized laguerre on the range 0 +inf
+        w = ctx.gamma(1 + alpha)
+        for i in xrange(n):
+            j = i + 1
+            d[i] = 2 * j - 1 + alpha
+            e[i] = ctx.sqrt(j * (j + alpha))
+    elif qtype == "jacobi":
+        # jacobi polynomials
+        alpha = ctx.mpf(alpha)
+        beta = ctx.mpf(beta)
+        ab = alpha + beta
+        abi = ab + 2
+        w = (2**(ab+1)) * ctx.gamma(alpha + 1) * ctx.gamma(beta + 1) / ctx.gamma(abi)
+        d[0] = (beta - alpha) / abi
+        e[0] = ctx.sqrt(4 * (1 + alpha) * (1 + beta) / ((abi + 1) * (abi * abi)))
+        a2b2 = beta * beta - alpha * alpha
+        for i in xrange(1, n):
+            j = i + 1
+            abi = 2 * j + ab
+            d[i] = a2b2 / ((abi - 2) * abi)
+            e[i] = ctx.sqrt(4 * j * (j + alpha) * (j + beta) * (j + ab) / ((abi * abi - 1) * abi * abi))
+    elif isinstance(qtype, str):
+        raise ValueError("unknown quadrature rule \"%s\"" % qtype)
+    elif not isinstance(qtype, str):
+        w = qtype(d, e)
+    else:
+        assert 0
+
+    tridiag_eigen(ctx, d, e, z)
+
+    for i in xrange(len(z)):
+        z[i] *= z[i]
+
+    z = z.transpose()
+    return (d, w * z)
+
+##################################################################################################
+##################################################################################################
+##################################################################################################
+
+def svd_r_raw(ctx, A, V = False, calc_u = False):
+    """
+    This routine computes the singular value decomposition of a matrix A.
+    Given A, two orthogonal matrices U and V are calculated such that
+
+                    A = U S V
+
+    where S is a suitable shaped matrix whose off-diagonal elements are zero.
+    The diagonal elements of S are the singular values of A, i.e. the
+    squareroots of the eigenvalues of A' A or A A'. Here ' denotes the transpose.
+    Householder bidiagonalization and a variant of the QR algorithm is used.
+
+    overview of the matrices :
+
+      A : m*n       A gets replaced by U
+      U : m*n       U replaces A. If n>m then only the first m*m block of U is
+                    non-zero. column-orthogonal: U' U = B
+                    here B is a n*n matrix whose first min(m,n) diagonal
+                    elements are 1 and all other elements are zero.
+      S : n*n       diagonal matrix, only the diagonal elements are stored in
+                    the array S. only the first min(m,n) diagonal elements are non-zero.
+      V : n*n       orthogonal: V V' = V' V = 1
+
+    parameters:
+      A        (input/output) On input, A contains a real matrix of shape m*n.
+               On output, if calc_u is true A contains the column-orthogonal
+               matrix U; otherwise A is simply used as workspace and thus destroyed.
+
+      V        (input/output) if false, the matrix V is not calculated. otherwise
+               V must be a matrix of shape n*n.
+
+      calc_u   (input) If true, the matrix U is calculated and replaces A.
+               if false, U is not calculated and A is simply destroyed
+
+    return value:
+      S        an array of length n containing the singular values of A sorted by
+               decreasing magnitude. only the first min(m,n) elements are non-zero.
+
+    This routine is a python translation of the fortran routine svd.f in the
+    software library EISPACK (see netlib.org) which itself is based on the
+    algol procedure svd described in:
+      - num. math. 14, 403-420(1970) by golub and reinsch.
+      - wilkinson/reinsch: handbook for auto. comp., vol ii-linear algebra, 134-151(1971).
+
+    """
+
+    m, n = A.rows, A.cols
+
+    S = ctx.zeros(n, 1)
+
+    # work is a temporary array of size n
+    work = ctx.zeros(n, 1)
+
+    g = scale = anorm = 0
+    maxits = 3 * ctx.dps
+
+    for i in xrange(n):     # householder reduction to bidiagonal form
+        work[i] = scale*g
+        g = s = scale = 0
+        if i < m:
+            for k in xrange(i, m):
+                scale += ctx.fabs(A[k,i])
+            if scale != 0:
+                for k in xrange(i, m):
+                    A[k,i] /= scale
+                    s += A[k,i] * A[k,i]
+                f = A[i,i]
+                g = -ctx.sqrt(s)
+                if f < 0:
+                    g = -g
+                h = f * g - s
+                A[i,i] = f - g
+                for j in xrange(i+1, n):
+                    s = 0
+                    for k in xrange(i, m):
+                        s += A[k,i] * A[k,j]
+                    f = s / h
+                    for k in xrange(i, m):
+                        A[k,j] += f * A[k,i]
+                for k in xrange(i,m):
+                    A[k,i] *= scale
+
+        S[i] = scale * g
+        g = s = scale = 0
+
+        if i < m and i != n - 1:
+            for k in xrange(i+1, n):
+                scale += ctx.fabs(A[i,k])
+            if scale:
+                for k in xrange(i+1, n):
+                    A[i,k] /= scale
+                    s += A[i,k] * A[i,k]
+                f = A[i,i+1]
+                g = -ctx.sqrt(s)
+                if f < 0:
+                    g = -g
+                h = f * g - s
+                A[i,i+1] = f - g
+
+                for k in xrange(i+1, n):
+                    work[k] = A[i,k] / h
+
+                for j in xrange(i+1, m):
+                    s = 0
+                    for k in xrange(i+1, n):
+                        s += A[j,k] * A[i,k]
+                    for k in xrange(i+1, n):
+                        A[j,k] += s * work[k]
+
+                for k in xrange(i+1, n):
+                    A[i,k] *= scale
+
+        anorm = max(anorm, ctx.fabs(S[i]) + ctx.fabs(work[i]))
+
+    if not isinstance(V, bool):
+        for i in xrange(n-2, -1, -1):     # accumulation of right hand transformations
+            V[i+1,i+1] = 1
+
+            if work[i+1] != 0:
+                for j in xrange(i+1, n):
+                    V[i,j] = (A[i,j] / A[i,i+1]) / work[i+1]
+                for j in xrange(i+1, n):
+                    s = 0
+                    for k in xrange(i+1, n):
+                        s += A[i,k] * V[j,k]
+                    for k in xrange(i+1, n):
+                        V[j,k] += s * V[i,k]
+
+            for j in xrange(i+1, n):
+                V[j,i] = V[i,j] = 0
+
+        V[0,0] = 1
+
+    if m<n : minnm = m
+    else   : minnm = n
+
+    if calc_u:
+        for i in xrange(minnm-1, -1, -1): # accumulation of left hand transformations
+            g = S[i]
+            for j in xrange(i+1, n):
+                A[i,j] = 0
+            if g != 0:
+                g = 1 / g
+                for j in xrange(i+1, n):
+                    s = 0
+                    for k in xrange(i+1, m):
+                        s += A[k,i] * A[k,j]
+                    f = (s / A[i,i]) * g
+                    for k in xrange(i, m):
+                        A[k,j] += f * A[k,i]
+                for j in xrange(i, m):
+                    A[j,i] *= g
+            else:
+                for j in xrange(i, m):
+                    A[j,i] = 0
+            A[i,i] += 1
+
+    for k in xrange(n - 1, -1, -1):
+        # diagonalization of the bidiagonal form:
+        #   loop over singular values, and over allowed itations
+
+        its = 0
+        while 1:
+            its += 1
+            flag = True
+
+            for l in xrange(k, -1, -1):
+                nm = l-1
+
+                if ctx.fabs(work[l]) + anorm == anorm:
+                    flag = False
+                    break
+
+                if ctx.fabs(S[nm]) + anorm == anorm:
+                    break
+
+            if flag:
+                c = 0
+                s = 1
+                for i in xrange(l, k + 1):
+                    f = s * work[i]
+                    work[i] *= c
+                    if ctx.fabs(f) + anorm == anorm:
+                        break
+                    g = S[i]
+                    h = ctx.hypot(f, g)
+                    S[i] = h
+                    h = 1 / h
+                    c = g * h
+                    s = - f * h
+
+                    if calc_u:
+                        for j in xrange(m):
+                            y = A[j,nm]
+                            z = A[j,i]
+                            A[j,nm] = y * c + z * s
+                            A[j,i]  = z * c - y * s
+
+            z = S[k]
+
+            if l == k:               # convergence
+                if z < 0:            # singular value is made nonnegative
+                    S[k] = -z
+                    if not isinstance(V, bool):
+                        for j in xrange(n):
+                            V[k,j] = -V[k,j]
+                break
+
+            if its >= maxits:
+                raise RuntimeError("svd: no convergence to an eigenvalue after %d iterations" % its)
+
+            x = S[l]         # shift from bottom 2 by 2 minor
+            nm = k-1
+            y = S[nm]
+            g = work[nm]
+            h = work[k]
+            f = ((y - z) * (y + z) + (g - h) * (g + h))/(2 * h * y)
+            g = ctx.hypot(f, 1)
+            if f >= 0: f = ((x - z) * (x + z) + h * ((y / (f + g)) - h)) / x
+            else:      f = ((x - z) * (x + z) + h * ((y / (f - g)) - h)) / x
+
+            c = s = 1         # next qt transformation
+
+            for j in xrange(l, nm + 1):
+                g = work[j+1]
+                y = S[j+1]
+                h = s * g
+                g = c * g
+                z = ctx.hypot(f, h)
+                work[j] = z
+                c = f / z
+                s = h / z
+                f = x * c + g * s
+                g = g * c - x * s
+                h = y * s
+                y *= c
+                if not isinstance(V, bool):
+                    for jj in xrange(n):
+                        x = V[j  ,jj]
+                        z = V[j+1,jj]
+                        V[j    ,jj]= x * c + z * s
+                        V[j+1  ,jj]= z * c - x * s
+                z = ctx.hypot(f, h)
+                S[j] = z
+                if z != 0:            # rotation can be arbitray if z=0
+                    z = 1 / z
+                    c = f * z
+                    s = h * z
+                f = c * g + s * y
+                x = c * y - s * g
+
+                if calc_u:
+                    for jj in xrange(m):
+                        y = A[jj,j  ]
+                        z = A[jj,j+1]
+                        A[jj,j    ] = y * c + z * s
+                        A[jj,j+1  ] = z * c - y * s
+
+            work[l] = 0
+            work[k] = f
+            S[k] = x
+
+    ##########################
+
+    # Sort singular values into decreasing order (bubble-sort)
+
+    for i in xrange(n):
+        imax = i
+        s = ctx.fabs(S[i])         # s is the current maximal element
+
+        for j in xrange(i + 1, n):
+            c = ctx.fabs(S[j])
+            if c > s:
+                s = c
+                imax = j
+
+        if imax != i:
+            # swap singular values
+
+            z = S[i]
+            S[i] = S[imax]
+            S[imax] = z
+
+            if calc_u:
+                for j in xrange(m):
+                    z = A[j,i]
+                    A[j,i] = A[j,imax]
+                    A[j,imax] = z
+
+            if not isinstance(V, bool):
+                for j in xrange(n):
+                    z = V[i,j]
+                    V[i,j] = V[imax,j]
+                    V[imax,j] = z
+
+    return S
+
+#######################
+
+def svd_c_raw(ctx, A, V = False, calc_u = False):
+    """
+    This routine computes the singular value decomposition of a matrix A.
+    Given A, two unitary matrices U and V are calculated such that
+
+                    A = U S V
+
+    where S is a suitable shaped matrix whose off-diagonal elements are zero.
+    The diagonal elements of S are the singular values of A, i.e. the
+    squareroots of the eigenvalues of A' A or A A'. Here ' denotes the hermitian
+    transpose (i.e. transposition and conjugation). Householder bidiagonalization
+    and a variant of the QR algorithm is used.
+
+    overview of the matrices :
+
+      A : m*n       A gets replaced by U
+      U : m*n       U replaces A. If n>m then only the first m*m block of U is
+                    non-zero. column-unitary: U' U = B
+                    here B is a n*n matrix whose first min(m,n) diagonal
+                    elements are 1 and all other elements are zero.
+      S : n*n       diagonal matrix, only the diagonal elements are stored in
+                    the array S. only the first min(m,n) diagonal elements are non-zero.
+      V : n*n       unitary: V V' = V' V = 1
+
+    parameters:
+      A        (input/output) On input, A contains a complex matrix of shape m*n.
+               On output, if calc_u is true A contains the column-unitary
+               matrix U; otherwise A is simply used as workspace and thus destroyed.
+
+      V        (input/output) if false, the matrix V is not calculated. otherwise
+               V must be a matrix of shape n*n.
+
+      calc_u   (input) If true, the matrix U is calculated and replaces A.
+               if false, U is not calculated and A is simply destroyed
+
+    return value:
+      S        an array of length n containing the singular values of A sorted by
+               decreasing magnitude. only the first min(m,n) elements are non-zero.
+
+    This routine is a python translation of the fortran routine svd.f in the
+    software library EISPACK (see netlib.org) which itself is based on the
+    algol procedure svd described in:
+      - num. math. 14, 403-420(1970) by golub and reinsch.
+      - wilkinson/reinsch: handbook for auto. comp., vol ii-linear algebra, 134-151(1971).
+
+    """
+
+    m, n = A.rows, A.cols
+
+    S = ctx.zeros(n, 1)
+
+    # work is a temporary array of size n
+    work  = ctx.zeros(n, 1)
+    lbeta = ctx.zeros(n, 1)
+    rbeta = ctx.zeros(n, 1)
+    dwork = ctx.zeros(n, 1)
+
+    g = scale = anorm = 0
+    maxits = 3 * ctx.dps
+
+    for i in xrange(n):         # householder reduction to bidiagonal form
+        dwork[i] = scale * g    # dwork are the side-diagonal elements
+        g = s = scale = 0
+        if i < m:
+            for k in xrange(i, m):
+                scale += ctx.fabs(ctx.re(A[k,i])) + ctx.fabs(ctx.im(A[k,i]))
+            if scale != 0:
+                for k in xrange(i, m):
+                    A[k,i] /= scale
+                    ar = ctx.re(A[k,i])
+                    ai = ctx.im(A[k,i])
+                    s += ar * ar + ai * ai
+                f = A[i,i]
+                g = -ctx.sqrt(s)
+                if ctx.re(f) < 0:
+                    beta = -g - ctx.conj(f)
+                    g = -g
+                else:
+                    beta = -g + ctx.conj(f)
+                beta /= ctx.conj(beta)
+                beta += 1
+                h = 2 * (ctx.re(f) * g - s)
+                A[i,i] = f - g
+                beta /= h
+                lbeta[i] = (beta / scale) / scale
+                for j in xrange(i+1, n):
+                    s = 0
+                    for k in xrange(i, m):
+                        s += ctx.conj(A[k,i]) * A[k,j]
+                    f = beta * s
+                    for k in xrange(i, m):
+                        A[k,j] += f * A[k,i]
+                for k in xrange(i, m):
+                    A[k,i] *= scale
+
+        S[i] = scale * g     # S are the diagonal elements
+        g = s = scale = 0
+
+        if i < m and i != n - 1:
+            for k in xrange(i+1, n):
+                scale += ctx.fabs(ctx.re(A[i,k])) + ctx.fabs(ctx.im(A[i,k]))
+            if scale:
+                for k in xrange(i+1, n):
+                    A[i,k] /= scale
+                    ar = ctx.re(A[i,k])
+                    ai = ctx.im(A[i,k])
+                    s += ar * ar + ai * ai
+                f = A[i,i+1]
+                g = -ctx.sqrt(s)
+                if ctx.re(f) < 0:
+                    beta = -g - ctx.conj(f)
+                    g = -g
+                else:
+                    beta = -g + ctx.conj(f)
+
+                beta /= ctx.conj(beta)
+                beta += 1
+
+                h = 2 * (ctx.re(f) * g - s)
+                A[i,i+1] = f - g
+
+                beta /= h
+                rbeta[i] = (beta / scale) / scale
+
+                for k in xrange(i+1, n):
+                    work[k] = A[i, k]
+
+                for j in xrange(i+1, m):
+                    s = 0
+                    for k in xrange(i+1, n):
+                        s += ctx.conj(A[i,k]) * A[j,k]
+                    f = s * beta
+                    for k in xrange(i+1,n):
+                        A[j,k] += f * work[k]
+
+                for k in xrange(i+1, n):
+                    A[i,k] *= scale
+
+        anorm = max(anorm,ctx.fabs(S[i]) + ctx.fabs(dwork[i]))
+
+    if not isinstance(V, bool):
+        for i in xrange(n-2, -1, -1):     # accumulation of right hand transformations
+            V[i+1,i+1] = 1
+
+            if dwork[i+1] != 0:
+                f = ctx.conj(rbeta[i])
+                for j in xrange(i+1, n):
+                    V[i,j] = A[i,j] * f
+                for j in xrange(i+1, n):
+                    s = 0
+                    for k in xrange(i+1, n):
+                        s += ctx.conj(A[i,k]) * V[j,k]
+                    for k in xrange(i+1, n):
+                        V[j,k] += s * V[i,k]
+
+            for j in xrange(i+1,n):
+                V[j,i] = V[i,j] = 0
+
+        V[0,0] = 1
+
+    if m < n : minnm = m
+    else     : minnm = n
+
+    if calc_u:
+        for i in xrange(minnm-1, -1, -1): # accumulation of left hand transformations
+            g = S[i]
+            for j in xrange(i+1, n):
+                A[i,j] = 0
+            if g != 0:
+                g = 1 / g
+                for j in xrange(i+1, n):
+                    s = 0
+                    for k in xrange(i+1, m):
+                        s += ctx.conj(A[k,i]) * A[k,j]
+                    f = s * ctx.conj(lbeta[i])
+                    for k in xrange(i, m):
+                        A[k,j] += f * A[k,i]
+                for j in xrange(i, m):
+                    A[j,i] *= g
+            else:
+                for j in xrange(i, m):
+                    A[j,i] = 0
+            A[i,i] += 1
+
+    for k in xrange(n-1, -1, -1):
+        # diagonalization of the bidiagonal form:
+        #   loop over singular values, and over allowed itations
+
+        its = 0
+        while 1:
+            its += 1
+            flag = True
+
+            for l in xrange(k, -1, -1):
+                nm = l - 1
+
+                if ctx.fabs(dwork[l]) + anorm == anorm:
+                    flag = False
+                    break
+
+                if ctx.fabs(S[nm]) + anorm == anorm:
+                    break
+
+            if flag:
+                c = 0
+                s = 1
+                for i in xrange(l, k+1):
+                    f = s * dwork[i]
+                    dwork[i] *= c
+                    if ctx.fabs(f) + anorm == anorm:
+                        break
+                    g = S[i]
+                    h = ctx.hypot(f, g)
+                    S[i] = h
+                    h = 1 / h
+                    c = g * h
+                    s = -f * h
+
+                    if calc_u:
+                        for j in xrange(m):
+                            y = A[j,nm]
+                            z = A[j,i]
+                            A[j,nm]= y * c + z * s
+                            A[j,i] = z * c - y * s
+
+            z = S[k]
+
+            if l == k:         # convergence
+                if z < 0:    # singular value is made nonnegative
+                    S[k] = -z
+                    if not isinstance(V, bool):
+                        for j in xrange(n):
+                            V[k,j] = -V[k,j]
+                break
+
+            if its >= maxits:
+                raise RuntimeError("svd: no convergence to an eigenvalue after %d iterations" % its)
+
+            x = S[l]         # shift from bottom 2 by 2 minor
+            nm = k-1
+            y = S[nm]
+            g = dwork[nm]
+            h = dwork[k]
+            f = ((y - z) * (y + z) + (g - h) * (g + h)) / (2 * h * y)
+            g = ctx.hypot(f, 1)
+            if f >=0: f = (( x - z) *( x + z) + h *((y / (f + g)) - h)) / x
+            else:     f = (( x - z) *( x + z) + h *((y / (f - g)) - h)) / x
+
+            c = s = 1         # next qt transformation
+
+            for j in xrange(l, nm + 1):
+                g = dwork[j+1]
+                y = S[j+1]
+                h = s * g
+                g = c * g
+                z = ctx.hypot(f, h)
+                dwork[j] = z
+                c = f / z
+                s = h / z
+                f = x * c + g * s
+                g = g * c - x * s
+                h = y * s
+                y *= c
+                if not isinstance(V, bool):
+                    for jj in xrange(n):
+                        x = V[j  ,jj]
+                        z = V[j+1,jj]
+                        V[j    ,jj]= x * c + z * s
+                        V[j+1,jj  ]= z * c - x * s
+                z = ctx.hypot(f, h)
+                S[j] = z
+                if z != 0:            # rotation can be arbitray if z=0
+                    z = 1 / z
+                    c = f * z
+                    s = h * z
+                f = c * g + s * y
+                x = c * y - s * g
+                if calc_u:
+                    for jj in xrange(m):
+                        y = A[jj,j  ]
+                        z = A[jj,j+1]
+                        A[jj,j    ]= y * c + z * s
+                        A[jj,j+1  ]= z * c - y * s
+
+            dwork[l] = 0
+            dwork[k] = f
+            S[k] = x
+
+    ##########################
+
+    # Sort singular values into decreasing order (bubble-sort)
+
+    for i in xrange(n):
+        imax = i
+        s = ctx.fabs(S[i])         # s is the current maximal element
+
+        for j in xrange(i + 1, n):
+            c = ctx.fabs(S[j])
+            if c > s:
+                s = c
+                imax = j
+
+        if imax != i:
+            # swap singular values
+
+            z = S[i]
+            S[i] = S[imax]
+            S[imax] = z
+
+            if calc_u:
+                for j in xrange(m):
+                    z = A[j,i]
+                    A[j,i] = A[j,imax]
+                    A[j,imax] = z
+
+            if not isinstance(V, bool):
+                for j in xrange(n):
+                    z = V[i,j]
+                    V[i,j] = V[imax,j]
+                    V[imax,j] = z
+
+    return S
+
+##################################################################################################
+
+@defun
+def svd_r(ctx, A, full_matrices = False, compute_uv = True, overwrite_a = False):
+    """
+    This routine computes the singular value decomposition of a matrix A.
+    Given A, two orthogonal matrices U and V are calculated such that
+
+           A = U S V        and        U' U = 1         and         V V' = 1
+
+    where S is a suitable shaped matrix whose off-diagonal elements are zero.
+    Here ' denotes the transpose. The diagonal elements of S are the singular
+    values of A, i.e. the squareroots of the eigenvalues of A' A or A A'.
+
+    input:
+      A             : a real matrix of shape (m, n)
+      full_matrices : if true, U and V are of shape (m, m) and (n, n).
+                      if false, U and V are of shape (m, min(m, n)) and (min(m, n), n).
+      compute_uv    : if true, U and V are calculated. if false, only S is calculated.
+      overwrite_a   : if true, allows modification of A which may improve
+                      performance. if false, A is not modified.
+
+    output:
+      U : an orthogonal matrix: U' U = 1. if full_matrices is true, U is of
+          shape (m, m). ortherwise it is of shape (m, min(m, n)).
+
+      S : an array of length min(m, n) containing the singular values of A sorted by
+          decreasing magnitude.
+
+      V : an orthogonal matrix: V V' = 1. if full_matrices is true, V is of
+          shape (n, n). ortherwise it is of shape (min(m, n), n).
+
+    return value:
+
+           S          if compute_uv is false
+       (U, S, V)      if compute_uv is true
+
+    overview of the matrices:
+
+      full_matrices true:
+        A           : m*n
+        U           : m*m     U' U  = 1
+        S as matrix : m*n
+        V           : n*n     V  V' = 1
+
+     full_matrices false:
+        A           : m*n
+        U           : m*min(n,m)             U' U  = 1
+        S as matrix : min(m,n)*min(m,n)
+        V           : min(m,n)*n             V  V' = 1
+
+    examples:
+
+       >>> from mpmath import mp
+       >>> A = mp.matrix([[2, -2, -1], [3, 4, -2], [-2, -2, 0]])
+       >>> S = mp.svd_r(A, compute_uv = False)
+       >>> print(S)
+       [6.0]
+       [3.0]
+       [1.0]
+
+       >>> U, S, V = mp.svd_r(A)
+       >>> print(mp.chop(A - U * mp.diag(S) * V))
+       [0.0  0.0  0.0]
+       [0.0  0.0  0.0]
+       [0.0  0.0  0.0]
+
+
+    see also: svd, svd_c
+    """
+
+    m, n = A.rows, A.cols
+
+    if not compute_uv:
+        if not overwrite_a:
+            A = A.copy()
+        S = svd_r_raw(ctx, A, V = False, calc_u = False)
+        S = S[:min(m,n)]
+        return S
+
+    if full_matrices and n < m:
+        V = ctx.zeros(m, m)
+        A0 = ctx.zeros(m, m)
+        A0[:,:n] = A
+        S = svd_r_raw(ctx, A0, V, calc_u = True)
+
+        S = S[:n]
+        V = V[:n,:n]
+
+        return (A0, S, V)
+    else:
+        if not overwrite_a:
+            A = A.copy()
+        V = ctx.zeros(n, n)
+        S = svd_r_raw(ctx, A, V, calc_u = True)
+
+        if n > m:
+            if full_matrices == False:
+                V = V[:m,:]
+
+            S = S[:m]
+            A = A[:,:m]
+
+        return (A, S, V)
+
+##############################
+
+@defun
+def svd_c(ctx, A, full_matrices = False, compute_uv = True, overwrite_a = False):
+    """
+    This routine computes the singular value decomposition of a matrix A.
+    Given A, two unitary matrices U and V are calculated such that
+
+           A = U S V        and        U' U = 1         and         V V' = 1
+
+    where S is a suitable shaped matrix whose off-diagonal elements are zero.
+    Here ' denotes the hermitian transpose (i.e. transposition and complex
+    conjugation). The diagonal elements of S are the singular values of A,
+    i.e. the squareroots of the eigenvalues of A' A or A A'.
+
+    input:
+      A             : a complex matrix of shape (m, n)
+      full_matrices : if true, U and V are of shape (m, m) and (n, n).
+                      if false, U and V are of shape (m, min(m, n)) and (min(m, n), n).
+      compute_uv    : if true, U and V are calculated. if false, only S is calculated.
+      overwrite_a   : if true, allows modification of A which may improve
+                      performance. if false, A is not modified.
+
+    output:
+      U : an unitary matrix: U' U = 1. if full_matrices is true, U is of
+          shape (m, m). ortherwise it is of shape (m, min(m, n)).
+
+      S : an array of length min(m, n) containing the singular values of A sorted by
+          decreasing magnitude.
+
+      V : an unitary matrix: V V' = 1. if full_matrices is true, V is of
+          shape (n, n). ortherwise it is of shape (min(m, n), n).
+
+    return value:
+
+           S          if compute_uv is false
+       (U, S, V)      if compute_uv is true
+
+    overview of the matrices:
+
+      full_matrices true:
+        A           : m*n
+        U           : m*m     U' U  = 1
+        S as matrix : m*n
+        V           : n*n     V  V' = 1
+
+     full_matrices false:
+        A           : m*n
+        U           : m*min(n,m)             U' U  = 1
+        S as matrix : min(m,n)*min(m,n)
+        V           : min(m,n)*n             V  V' = 1
+
+    example:
+      >>> from mpmath import mp
+      >>> A = mp.matrix([[-2j, -1-3j, -2+2j], [2-2j, -1-3j, 1], [-3+1j,-2j,0]])
+      >>> S = mp.svd_c(A, compute_uv = False)
+      >>> print(mp.chop(S - mp.matrix([mp.sqrt(34), mp.sqrt(15), mp.sqrt(6)])))
+      [0.0]
+      [0.0]
+      [0.0]
+
+      >>> U, S, V = mp.svd_c(A)
+      >>> print(mp.chop(A - U * mp.diag(S) * V))
+      [0.0  0.0  0.0]
+      [0.0  0.0  0.0]
+      [0.0  0.0  0.0]
+
+    see also: svd, svd_r
+    """
+
+    m, n = A.rows, A.cols
+
+    if not compute_uv:
+        if not overwrite_a:
+            A = A.copy()
+        S = svd_c_raw(ctx, A, V = False, calc_u = False)
+        S = S[:min(m,n)]
+        return S
+
+    if full_matrices and n < m:
+        V = ctx.zeros(m, m)
+        A0 = ctx.zeros(m, m)
+        A0[:,:n] = A
+        S = svd_c_raw(ctx, A0, V, calc_u = True)
+
+        S = S[:n]
+        V = V[:n,:n]
+
+        return (A0, S, V)
+    else:
+        if not overwrite_a:
+            A = A.copy()
+        V = ctx.zeros(n, n)
+        S = svd_c_raw(ctx, A, V, calc_u = True)
+
+        if n > m:
+            if full_matrices == False:
+                V = V[:m,:]
+
+            S = S[:m]
+            A = A[:,:m]
+
+        return (A, S, V)
+
+@defun
+def svd(ctx, A, full_matrices = False, compute_uv = True, overwrite_a = False):
+    """
+    "svd" is a unified interface for "svd_r" and "svd_c". Depending on
+    whether A is real or complex the appropriate function is called.
+
+    This routine computes the singular value decomposition of a matrix A.
+    Given A, two orthogonal (A real) or unitary (A complex) matrices U and V
+    are calculated such that
+
+           A = U S V        and        U' U = 1         and         V V' = 1
+
+    where S is a suitable shaped matrix whose off-diagonal elements are zero.
+    Here ' denotes the hermitian transpose (i.e. transposition and complex
+    conjugation). The diagonal elements of S are the singular values of A,
+    i.e. the squareroots of the eigenvalues of A' A or A A'.
+
+    input:
+      A             : a real or complex matrix of shape (m, n)
+      full_matrices : if true, U and V are of shape (m, m) and (n, n).
+                      if false, U and V are of shape (m, min(m, n)) and (min(m, n), n).
+      compute_uv    : if true, U and V are calculated. if false, only S is calculated.
+      overwrite_a   : if true, allows modification of A which may improve
+                      performance. if false, A is not modified.
+
+    output:
+      U : an orthogonal or unitary matrix: U' U = 1. if full_matrices is true, U is of
+          shape (m, m). ortherwise it is of shape (m, min(m, n)).
+
+      S : an array of length min(m, n) containing the singular values of A sorted by
+          decreasing magnitude.
+
+      V : an orthogonal or unitary matrix: V V' = 1. if full_matrices is true, V is of
+          shape (n, n). ortherwise it is of shape (min(m, n), n).
+
+    return value:
+
+           S          if compute_uv is false
+       (U, S, V)      if compute_uv is true
+
+    overview of the matrices:
+
+      full_matrices true:
+        A           : m*n
+        U           : m*m     U' U  = 1
+        S as matrix : m*n
+        V           : n*n     V  V' = 1
+
+     full_matrices false:
+        A           : m*n
+        U           : m*min(n,m)             U' U  = 1
+        S as matrix : min(m,n)*min(m,n)
+        V           : min(m,n)*n             V  V' = 1
+
+    examples:
+
+       >>> from mpmath import mp
+       >>> A = mp.matrix([[2, -2, -1], [3, 4, -2], [-2, -2, 0]])
+       >>> S = mp.svd(A, compute_uv = False)
+       >>> print(S)
+       [6.0]
+       [3.0]
+       [1.0]
+
+       >>> U, S, V = mp.svd(A)
+       >>> print(mp.chop(A - U * mp.diag(S) * V))
+       [0.0  0.0  0.0]
+       [0.0  0.0  0.0]
+       [0.0  0.0  0.0]
+
+    see also: svd_r, svd_c
+    """
+
+    iscomplex = any(type(x) is ctx.mpc for x in A)
+
+    if iscomplex:
+        return ctx.svd_c(A, full_matrices = full_matrices, compute_uv = compute_uv, overwrite_a = overwrite_a)
+    else:
+        return ctx.svd_r(A, full_matrices = full_matrices, compute_uv = compute_uv, overwrite_a = overwrite_a)
diff --git a/lib/python3.10/site-packages/mpmath/matrices/linalg.py b/lib/python3.10/site-packages/mpmath/matrices/linalg.py
new file mode 100644
index 0000000000000000000000000000000000000000..e2fe643e809822e3d05a52b73c965edb622f9af9
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/matrices/linalg.py
@@ -0,0 +1,790 @@
+"""
+Linear algebra
+--------------
+
+Linear equations
+................
+
+Basic linear algebra is implemented; you can for example solve the linear
+equation system::
+
+      x + 2*y = -10
+    3*x + 4*y =  10
+
+using ``lu_solve``::
+
+    >>> from mpmath import *
+    >>> mp.pretty = False
+    >>> A = matrix([[1, 2], [3, 4]])
+    >>> b = matrix([-10, 10])
+    >>> x = lu_solve(A, b)
+    >>> x
+    matrix(
+    [['30.0'],
+     ['-20.0']])
+
+If you don't trust the result, use ``residual`` to calculate the residual ||A*x-b||::
+
+    >>> residual(A, x, b)
+    matrix(
+    [['3.46944695195361e-18'],
+     ['3.46944695195361e-18']])
+    >>> str(eps)
+    '2.22044604925031e-16'
+
+As you can see, the solution is quite accurate. The error is caused by the
+inaccuracy of the internal floating point arithmetic. Though, it's even smaller
+than the current machine epsilon, which basically means you can trust the
+result.
+
+If you need more speed, use NumPy, or ``fp.lu_solve`` for a floating-point computation.
+
+    >>> fp.lu_solve(A, b)   # doctest: +ELLIPSIS
+    matrix(...)
+
+``lu_solve`` accepts overdetermined systems. It is usually not possible to solve
+such systems, so the residual is minimized instead. Internally this is done
+using Cholesky decomposition to compute a least squares approximation. This means
+that that ``lu_solve`` will square the errors. If you can't afford this, use
+``qr_solve`` instead. It is twice as slow but more accurate, and it calculates
+the residual automatically.
+
+
+Matrix factorization
+....................
+
+The function ``lu`` computes an explicit LU factorization of a matrix::
+
+    >>> P, L, U = lu(matrix([[0,2,3],[4,5,6],[7,8,9]]))
+    >>> print(P)
+    [0.0  0.0  1.0]
+    [1.0  0.0  0.0]
+    [0.0  1.0  0.0]
+    >>> print(L)
+    [              1.0                0.0  0.0]
+    [              0.0                1.0  0.0]
+    [0.571428571428571  0.214285714285714  1.0]
+    >>> print(U)
+    [7.0  8.0                9.0]
+    [0.0  2.0                3.0]
+    [0.0  0.0  0.214285714285714]
+    >>> print(P.T*L*U)
+    [0.0  2.0  3.0]
+    [4.0  5.0  6.0]
+    [7.0  8.0  9.0]
+
+Interval matrices
+-----------------
+
+Matrices may contain interval elements. This allows one to perform
+basic linear algebra operations such as matrix multiplication
+and equation solving with rigorous error bounds::
+
+    >>> a = iv.matrix([['0.1','0.3','1.0'],
+    ...             ['7.1','5.5','4.8'],
+    ...             ['3.2','4.4','5.6']])
+    >>>
+    >>> b = iv.matrix(['4','0.6','0.5'])
+    >>> c = iv.lu_solve(a, b)
+    >>> print(c)
+    [   [5.2582327113062568605927528666, 5.25823271130625686059275702219]]
+    [[-13.1550493962678375411635581388, -13.1550493962678375411635540152]]
+    [  [7.42069154774972557628979076189, 7.42069154774972557628979190734]]
+    >>> print(a*c)
+    [  [3.99999999999999999999999844904, 4.00000000000000000000000155096]]
+    [[0.599999999999999999999968898009, 0.600000000000000000000031763736]]
+    [[0.499999999999999999999979320485, 0.500000000000000000000020679515]]
+"""
+
+# TODO:
+# *implement high-level qr()
+# *test unitvector
+# *iterative solving
+
+from copy import copy
+
+from ..libmp.backend import xrange
+
+class LinearAlgebraMethods(object):
+
+    def LU_decomp(ctx, A, overwrite=False, use_cache=True):
+        """
+        LU-factorization of a n*n matrix using the Gauss algorithm.
+        Returns L and U in one matrix and the pivot indices.
+
+        Use overwrite to specify whether A will be overwritten with L and U.
+        """
+        if not A.rows == A.cols:
+            raise ValueError('need n*n matrix')
+        # get from cache if possible
+        if use_cache and isinstance(A, ctx.matrix) and A._LU:
+            return A._LU
+        if not overwrite:
+            orig = A
+            A = A.copy()
+        tol = ctx.absmin(ctx.mnorm(A,1) * ctx.eps) # each pivot element has to be bigger
+        n = A.rows
+        p = [None]*(n - 1)
+        for j in xrange(n - 1):
+            # pivoting, choose max(abs(reciprocal row sum)*abs(pivot element))
+            biggest = 0
+            for k in xrange(j, n):
+                s = ctx.fsum([ctx.absmin(A[k,l]) for l in xrange(j, n)])
+                if ctx.absmin(s) <= tol:
+                    raise ZeroDivisionError('matrix is numerically singular')
+                current = 1/s * ctx.absmin(A[k,j])
+                if current > biggest: # TODO: what if equal?
+                    biggest = current
+                    p[j] = k
+            # swap rows according to p
+            ctx.swap_row(A, j, p[j])
+            if ctx.absmin(A[j,j]) <= tol:
+                raise ZeroDivisionError('matrix is numerically singular')
+            # calculate elimination factors and add rows
+            for i in xrange(j + 1, n):
+                A[i,j] /= A[j,j]
+                for k in xrange(j + 1, n):
+                    A[i,k] -= A[i,j]*A[j,k]
+        if ctx.absmin(A[n - 1,n - 1]) <= tol:
+            raise ZeroDivisionError('matrix is numerically singular')
+        # cache decomposition
+        if not overwrite and isinstance(orig, ctx.matrix):
+            orig._LU = (A, p)
+        return A, p
+
+    def L_solve(ctx, L, b, p=None):
+        """
+        Solve the lower part of a LU factorized matrix for y.
+        """
+        if L.rows != L.cols:
+            raise RuntimeError("need n*n matrix")
+        n = L.rows
+        if len(b) != n:
+            raise ValueError("Value should be equal to n")
+        b = copy(b)
+        if p: # swap b according to p
+            for k in xrange(0, len(p)):
+                ctx.swap_row(b, k, p[k])
+        # solve
+        for i in xrange(1, n):
+            for j in xrange(i):
+                b[i] -= L[i,j] * b[j]
+        return b
+
+    def U_solve(ctx, U, y):
+        """
+        Solve the upper part of a LU factorized matrix for x.
+        """
+        if U.rows != U.cols:
+            raise RuntimeError("need n*n matrix")
+        n = U.rows
+        if len(y) != n:
+            raise ValueError("Value should be equal to n")
+        x = copy(y)
+        for i in xrange(n - 1, -1, -1):
+            for j in xrange(i + 1, n):
+                x[i] -= U[i,j] * x[j]
+            x[i] /= U[i,i]
+        return x
+
+    def lu_solve(ctx, A, b, **kwargs):
+        """
+        Ax = b => x
+
+        Solve a determined or overdetermined linear equations system.
+        Fast LU decomposition is used, which is less accurate than QR decomposition
+        (especially for overdetermined systems), but it's twice as efficient.
+        Use qr_solve if you want more precision or have to solve a very ill-
+        conditioned system.
+
+        If you specify real=True, it does not check for overdeterminded complex
+        systems.
+        """
+        prec = ctx.prec
+        try:
+            ctx.prec += 10
+            # do not overwrite A nor b
+            A, b = ctx.matrix(A, **kwargs).copy(), ctx.matrix(b, **kwargs).copy()
+            if A.rows < A.cols:
+                raise ValueError('cannot solve underdetermined system')
+            if A.rows > A.cols:
+                # use least-squares method if overdetermined
+                # (this increases errors)
+                AH = A.H
+                A = AH * A
+                b = AH * b
+                if (kwargs.get('real', False) or
+                    not sum(type(i) is ctx.mpc for i in A)):
+                    # TODO: necessary to check also b?
+                    x = ctx.cholesky_solve(A, b)
+                else:
+                    x = ctx.lu_solve(A, b)
+            else:
+                # LU factorization
+                A, p = ctx.LU_decomp(A)
+                b = ctx.L_solve(A, b, p)
+                x = ctx.U_solve(A, b)
+        finally:
+            ctx.prec = prec
+        return x
+
+    def improve_solution(ctx, A, x, b, maxsteps=1):
+        """
+        Improve a solution to a linear equation system iteratively.
+
+        This re-uses the LU decomposition and is thus cheap.
+        Usually 3 up to 4 iterations are giving the maximal improvement.
+        """
+        if A.rows != A.cols:
+            raise RuntimeError("need n*n matrix") # TODO: really?
+        for _ in xrange(maxsteps):
+            r = ctx.residual(A, x, b)
+            if ctx.norm(r, 2) < 10*ctx.eps:
+                break
+            # this uses cached LU decomposition and is thus cheap
+            dx = ctx.lu_solve(A, -r)
+            x += dx
+        return x
+
+    def lu(ctx, A):
+        """
+        A -> P, L, U
+
+        LU factorisation of a square matrix A. L is the lower, U the upper part.
+        P is the permutation matrix indicating the row swaps.
+
+        P*A = L*U
+
+        If you need efficiency, use the low-level method LU_decomp instead, it's
+        much more memory efficient.
+        """
+        # get factorization
+        A, p = ctx.LU_decomp(A)
+        n = A.rows
+        L = ctx.matrix(n)
+        U = ctx.matrix(n)
+        for i in xrange(n):
+            for j in xrange(n):
+                if i > j:
+                    L[i,j] = A[i,j]
+                elif i == j:
+                    L[i,j] = 1
+                    U[i,j] = A[i,j]
+                else:
+                    U[i,j] = A[i,j]
+        # calculate permutation matrix
+        P = ctx.eye(n)
+        for k in xrange(len(p)):
+            ctx.swap_row(P, k, p[k])
+        return P, L, U
+
+    def unitvector(ctx, n, i):
+        """
+        Return the i-th n-dimensional unit vector.
+        """
+        assert 0 < i <= n, 'this unit vector does not exist'
+        return [ctx.zero]*(i-1) + [ctx.one] + [ctx.zero]*(n-i)
+
+    def inverse(ctx, A, **kwargs):
+        """
+        Calculate the inverse of a matrix.
+
+        If you want to solve an equation system Ax = b, it's recommended to use
+        solve(A, b) instead, it's about 3 times more efficient.
+        """
+        prec = ctx.prec
+        try:
+            ctx.prec += 10
+            # do not overwrite A
+            A = ctx.matrix(A, **kwargs).copy()
+            n = A.rows
+            # get LU factorisation
+            A, p = ctx.LU_decomp(A)
+            cols = []
+            # calculate unit vectors and solve corresponding system to get columns
+            for i in xrange(1, n + 1):
+                e = ctx.unitvector(n, i)
+                y = ctx.L_solve(A, e, p)
+                cols.append(ctx.U_solve(A, y))
+            # convert columns to matrix
+            inv = []
+            for i in xrange(n):
+                row = []
+                for j in xrange(n):
+                    row.append(cols[j][i])
+                inv.append(row)
+            result = ctx.matrix(inv, **kwargs)
+        finally:
+            ctx.prec = prec
+        return result
+
+    def householder(ctx, A):
+        """
+        (A|b) -> H, p, x, res
+
+        (A|b) is the coefficient matrix with left hand side of an optionally
+        overdetermined linear equation system.
+        H and p contain all information about the transformation matrices.
+        x is the solution, res the residual.
+        """
+        if not isinstance(A, ctx.matrix):
+            raise TypeError("A should be a type of ctx.matrix")
+        m = A.rows
+        n = A.cols
+        if m < n - 1:
+            raise RuntimeError("Columns should not be less than rows")
+        # calculate Householder matrix
+        p = []
+        for j in xrange(0, n - 1):
+            s = ctx.fsum(abs(A[i,j])**2 for i in xrange(j, m))
+            if not abs(s) > ctx.eps:
+                raise ValueError('matrix is numerically singular')
+            p.append(-ctx.sign(ctx.re(A[j,j])) * ctx.sqrt(s))
+            kappa = ctx.one / (s - p[j] * A[j,j])
+            A[j,j] -= p[j]
+            for k in xrange(j+1, n):
+                y = ctx.fsum(ctx.conj(A[i,j]) * A[i,k] for i in xrange(j, m)) * kappa
+                for i in xrange(j, m):
+                    A[i,k] -= A[i,j] * y
+        # solve Rx = c1
+        x = [A[i,n - 1] for i in xrange(n - 1)]
+        for i in xrange(n - 2, -1, -1):
+            x[i] -= ctx.fsum(A[i,j] * x[j] for j in xrange(i + 1, n - 1))
+            x[i] /= p[i]
+        # calculate residual
+        if not m == n - 1:
+            r = [A[m-1-i, n-1] for i in xrange(m - n + 1)]
+        else:
+            # determined system, residual should be 0
+            r = [0]*m # maybe a bad idea, changing r[i] will change all elements
+        return A, p, x, r
+
+    #def qr(ctx, A):
+    #    """
+    #    A -> Q, R
+    #
+    #    QR factorisation of a square matrix A using Householder decomposition.
+    #    Q is orthogonal, this leads to very few numerical errors.
+    #
+    #    A = Q*R
+    #    """
+    #    H, p, x, res = householder(A)
+    # TODO: implement this
+
+    def residual(ctx, A, x, b, **kwargs):
+        """
+        Calculate the residual of a solution to a linear equation system.
+
+        r = A*x - b for A*x = b
+        """
+        oldprec = ctx.prec
+        try:
+            ctx.prec *= 2
+            A, x, b = ctx.matrix(A, **kwargs), ctx.matrix(x, **kwargs), ctx.matrix(b, **kwargs)
+            return A*x - b
+        finally:
+            ctx.prec = oldprec
+
+    def qr_solve(ctx, A, b, norm=None, **kwargs):
+        """
+        Ax = b => x, ||Ax - b||
+
+        Solve a determined or overdetermined linear equations system and
+        calculate the norm of the residual (error).
+        QR decomposition using Householder factorization is applied, which gives very
+        accurate results even for ill-conditioned matrices. qr_solve is twice as
+        efficient.
+        """
+        if norm is None:
+            norm = ctx.norm
+        prec = ctx.prec
+        try:
+            ctx.prec += 10
+            # do not overwrite A nor b
+            A, b = ctx.matrix(A, **kwargs).copy(), ctx.matrix(b, **kwargs).copy()
+            if A.rows < A.cols:
+                raise ValueError('cannot solve underdetermined system')
+            H, p, x, r = ctx.householder(ctx.extend(A, b))
+            res = ctx.norm(r)
+            # calculate residual "manually" for determined systems
+            if res == 0:
+                res = ctx.norm(ctx.residual(A, x, b))
+            return ctx.matrix(x, **kwargs), res
+        finally:
+            ctx.prec = prec
+
+    def cholesky(ctx, A, tol=None):
+        r"""
+        Cholesky decomposition of a symmetric positive-definite matrix `A`.
+        Returns a lower triangular matrix `L` such that `A = L \times L^T`.
+        More generally, for a complex Hermitian positive-definite matrix,
+        a Cholesky decomposition satisfying `A = L \times L^H` is returned.
+
+        The Cholesky decomposition can be used to solve linear equation
+        systems twice as efficiently as LU decomposition, or to
+        test whether `A` is positive-definite.
+
+        The optional parameter ``tol`` determines the tolerance for
+        verifying positive-definiteness.
+
+        **Examples**
+
+        Cholesky decomposition of a positive-definite symmetric matrix::
+
+            >>> from mpmath import *
+            >>> mp.dps = 25; mp.pretty = True
+            >>> A = eye(3) + hilbert(3)
+            >>> nprint(A)
+            [     2.0      0.5  0.333333]
+            [     0.5  1.33333      0.25]
+            [0.333333     0.25       1.2]
+            >>> L = cholesky(A)
+            >>> nprint(L)
+            [ 1.41421      0.0      0.0]
+            [0.353553  1.09924      0.0]
+            [0.235702  0.15162  1.05899]
+            >>> chop(A - L*L.T)
+            [0.0  0.0  0.0]
+            [0.0  0.0  0.0]
+            [0.0  0.0  0.0]
+
+        Cholesky decomposition of a Hermitian matrix::
+
+            >>> A = eye(3) + matrix([[0,0.25j,-0.5j],[-0.25j,0,0],[0.5j,0,0]])
+            >>> L = cholesky(A)
+            >>> nprint(L)
+            [          1.0                0.0                0.0]
+            [(0.0 - 0.25j)  (0.968246 + 0.0j)                0.0]
+            [ (0.0 + 0.5j)  (0.129099 + 0.0j)  (0.856349 + 0.0j)]
+            >>> chop(A - L*L.H)
+            [0.0  0.0  0.0]
+            [0.0  0.0  0.0]
+            [0.0  0.0  0.0]
+
+        Attempted Cholesky decomposition of a matrix that is not positive
+        definite::
+
+            >>> A = -eye(3) + hilbert(3)
+            >>> L = cholesky(A)
+            Traceback (most recent call last):
+              ...
+            ValueError: matrix is not positive-definite
+
+        **References**
+
+        1. [Wikipedia]_ http://en.wikipedia.org/wiki/Cholesky_decomposition
+
+        """
+        if not isinstance(A, ctx.matrix):
+            raise RuntimeError("A should be a type of ctx.matrix")
+        if not A.rows == A.cols:
+            raise ValueError('need n*n matrix')
+        if tol is None:
+            tol = +ctx.eps
+        n = A.rows
+        L = ctx.matrix(n)
+        for j in xrange(n):
+            c = ctx.re(A[j,j])
+            if abs(c-A[j,j]) > tol:
+                raise ValueError('matrix is not Hermitian')
+            s = c - ctx.fsum((L[j,k] for k in xrange(j)),
+                absolute=True, squared=True)
+            if s < tol:
+                raise ValueError('matrix is not positive-definite')
+            L[j,j] = ctx.sqrt(s)
+            for i in xrange(j, n):
+                it1 = (L[i,k] for k in xrange(j))
+                it2 = (L[j,k] for k in xrange(j))
+                t = ctx.fdot(it1, it2, conjugate=True)
+                L[i,j] = (A[i,j] - t) / L[j,j]
+        return L
+
+    def cholesky_solve(ctx, A, b, **kwargs):
+        """
+        Ax = b => x
+
+        Solve a symmetric positive-definite linear equation system.
+        This is twice as efficient as lu_solve.
+
+        Typical use cases:
+        * A.T*A
+        * Hessian matrix
+        * differential equations
+        """
+        prec = ctx.prec
+        try:
+            ctx.prec += 10
+            # do not overwrite A nor b
+            A, b = ctx.matrix(A, **kwargs).copy(), ctx.matrix(b, **kwargs).copy()
+            if A.rows !=  A.cols:
+                raise ValueError('can only solve determined system')
+            # Cholesky factorization
+            L = ctx.cholesky(A)
+            # solve
+            n = L.rows
+            if len(b) != n:
+                raise ValueError("Value should be equal to n")
+            for i in xrange(n):
+                b[i] -= ctx.fsum(L[i,j] * b[j] for j in xrange(i))
+                b[i] /= L[i,i]
+            x = ctx.U_solve(L.T, b)
+            return x
+        finally:
+            ctx.prec = prec
+
+    def det(ctx, A):
+        """
+        Calculate the determinant of a matrix.
+        """
+        prec = ctx.prec
+        try:
+            # do not overwrite A
+            A = ctx.matrix(A).copy()
+            # use LU factorization to calculate determinant
+            try:
+                R, p = ctx.LU_decomp(A)
+            except ZeroDivisionError:
+                return 0
+            z = 1
+            for i, e in enumerate(p):
+                if i != e:
+                    z *= -1
+            for i in xrange(A.rows):
+                z *= R[i,i]
+            return z
+        finally:
+            ctx.prec = prec
+
+    def cond(ctx, A, norm=None):
+        """
+        Calculate the condition number of a matrix using a specified matrix norm.
+
+        The condition number estimates the sensitivity of a matrix to errors.
+        Example: small input errors for ill-conditioned coefficient matrices
+        alter the solution of the system dramatically.
+
+        For ill-conditioned matrices it's recommended to use qr_solve() instead
+        of lu_solve(). This does not help with input errors however, it just avoids
+        to add additional errors.
+
+        Definition:    cond(A) = ||A|| * ||A**-1||
+        """
+        if norm is None:
+            norm = lambda x: ctx.mnorm(x,1)
+        return norm(A) * norm(ctx.inverse(A))
+
+    def lu_solve_mat(ctx, a, b):
+        """Solve a * x = b  where a and b are matrices."""
+        r = ctx.matrix(a.rows, b.cols)
+        for i in range(b.cols):
+            c = ctx.lu_solve(a, b.column(i))
+            for j in range(len(c)):
+                r[j, i] = c[j]
+        return r
+
+    def qr(ctx, A, mode = 'full', edps = 10):
+        """
+        Compute a QR factorization $A = QR$ where
+        A is an m x n matrix of real or complex numbers where m >= n
+
+        mode has following meanings:
+        (1) mode = 'raw' returns two matrixes (A, tau) in the
+            internal format used by LAPACK
+        (2) mode = 'skinny' returns the leading n columns of Q
+            and n rows of R
+        (3) Any other value returns the leading m columns of Q
+            and m rows of R
+
+        edps is the increase in mp precision used for calculations
+
+        **Examples**
+
+            >>> from mpmath import *
+            >>> mp.dps = 15
+            >>> mp.pretty = True
+            >>> A = matrix([[1, 2], [3, 4], [1, 1]])
+            >>> Q, R = qr(A)
+            >>> Q
+            [-0.301511344577764   0.861640436855329   0.408248290463863]
+            [-0.904534033733291  -0.123091490979333  -0.408248290463863]
+            [-0.301511344577764  -0.492365963917331   0.816496580927726]
+            >>> R
+            [-3.3166247903554  -4.52267016866645]
+            [             0.0  0.738548945875996]
+            [             0.0                0.0]
+            >>> Q * R
+            [1.0  2.0]
+            [3.0  4.0]
+            [1.0  1.0]
+            >>> chop(Q.T * Q)
+            [1.0  0.0  0.0]
+            [0.0  1.0  0.0]
+            [0.0  0.0  1.0]
+            >>> B = matrix([[1+0j, 2-3j], [3+j, 4+5j]])
+            >>> Q, R = qr(B)
+            >>> nprint(Q)
+            [     (-0.301511 + 0.0j)   (0.0695795 - 0.95092j)]
+            [(-0.904534 - 0.301511j)  (-0.115966 + 0.278318j)]
+            >>> nprint(R)
+            [(-3.31662 + 0.0j)  (-5.72872 - 2.41209j)]
+            [              0.0       (3.91965 + 0.0j)]
+            >>> Q * R
+            [(1.0 + 0.0j)  (2.0 - 3.0j)]
+            [(3.0 + 1.0j)  (4.0 + 5.0j)]
+            >>> chop(Q.T * Q.conjugate())
+            [1.0  0.0]
+            [0.0  1.0]
+
+        """
+
+        # check values before continuing
+        assert isinstance(A, ctx.matrix)
+        m = A.rows
+        n = A.cols
+        assert n >= 0
+        assert m >= n
+        assert edps >= 0
+
+        # check for complex data type
+        cmplx = any(type(x) is ctx.mpc for x in A)
+
+        # temporarily increase the precision and initialize
+        with ctx.extradps(edps):
+            tau = ctx.matrix(n,1)
+            A = A.copy()
+
+            # ---------------
+            # FACTOR MATRIX A
+            # ---------------
+            if cmplx:
+                one = ctx.mpc('1.0', '0.0')
+                zero = ctx.mpc('0.0', '0.0')
+                rzero = ctx.mpf('0.0')
+
+                # main loop to factor A (complex)
+                for j in xrange(0, n):
+                    alpha = A[j,j]
+                    alphr = ctx.re(alpha)
+                    alphi = ctx.im(alpha)
+
+                    if (m-j) >= 2:
+                        xnorm = ctx.fsum( A[i,j]*ctx.conj(A[i,j]) for i in xrange(j+1, m) )
+                        xnorm = ctx.re( ctx.sqrt(xnorm) )
+                    else:
+                        xnorm = rzero
+
+                    if (xnorm == rzero) and (alphi == rzero):
+                        tau[j] = zero
+                        continue
+
+                    if alphr < rzero:
+                        beta = ctx.sqrt(alphr**2 + alphi**2 + xnorm**2)
+                    else:
+                        beta = -ctx.sqrt(alphr**2 + alphi**2 + xnorm**2)
+
+                    tau[j] = ctx.mpc( (beta - alphr) / beta, -alphi / beta )
+                    t = -ctx.conj(tau[j])
+                    za = one / (alpha - beta)
+
+                    for i in xrange(j+1, m):
+                        A[i,j] *= za
+
+                    A[j,j] = one
+                    for k in xrange(j+1, n):
+                        y = ctx.fsum(A[i,j] * ctx.conj(A[i,k]) for i in xrange(j, m))
+                        temp = t * ctx.conj(y)
+                        for i in xrange(j, m):
+                            A[i,k] += A[i,j] * temp
+
+                    A[j,j] = ctx.mpc(beta, '0.0')
+            else:
+                one = ctx.mpf('1.0')
+                zero = ctx.mpf('0.0')
+
+                # main loop to factor A (real)
+                for j in xrange(0, n):
+                    alpha = A[j,j]
+
+                    if (m-j) > 2:
+                        xnorm = ctx.fsum( (A[i,j])**2 for i in xrange(j+1, m) )
+                        xnorm = ctx.sqrt(xnorm)
+                    elif (m-j) == 2:
+                        xnorm = abs( A[m-1,j] )
+                    else:
+                        xnorm = zero
+
+                    if xnorm == zero:
+                        tau[j] = zero
+                        continue
+
+                    if alpha < zero:
+                        beta = ctx.sqrt(alpha**2 + xnorm**2)
+                    else:
+                        beta = -ctx.sqrt(alpha**2 + xnorm**2)
+
+                    tau[j] = (beta - alpha) / beta
+                    t = -tau[j]
+                    da = one / (alpha - beta)
+
+                    for i in xrange(j+1, m):
+                        A[i,j] *= da
+
+                    A[j,j] = one
+                    for k in xrange(j+1, n):
+                        y = ctx.fsum( A[i,j] * A[i,k] for i in xrange(j, m) )
+                        temp = t * y
+                        for i in xrange(j,m):
+                            A[i,k] += A[i,j] * temp
+
+                    A[j,j] = beta
+
+            # return factorization in same internal format as LAPACK
+            if (mode == 'raw') or (mode == 'RAW'):
+                return A, tau
+
+            # ----------------------------------
+            # FORM Q USING BACKWARD ACCUMULATION
+            # ----------------------------------
+
+            # form R before the values are overwritten
+            R = A.copy()
+            for j in xrange(0, n):
+                for i in xrange(j+1, m):
+                    R[i,j] = zero
+
+            # set the value of p (number of columns of Q to return)
+            p = m
+            if (mode == 'skinny') or (mode == 'SKINNY'):
+                p = n
+
+            # add columns to A if needed and initialize
+            A.cols += (p-n)
+            for j in xrange(0, p):
+                A[j,j] = one
+                for i in xrange(0, j):
+                    A[i,j] = zero
+
+            # main loop to form Q
+            for j in xrange(n-1, -1, -1):
+                t = -tau[j]
+                A[j,j] += t
+
+                for k in xrange(j+1, p):
+                    if cmplx:
+                        y = ctx.fsum(A[i,j] * ctx.conj(A[i,k]) for i in xrange(j+1, m))
+                        temp = t * ctx.conj(y)
+                    else:
+                        y = ctx.fsum(A[i,j] * A[i,k] for i in xrange(j+1, m))
+                        temp = t * y
+                    A[j,k] = temp
+                    for i in xrange(j+1, m):
+                        A[i,k] += A[i,j] * temp
+
+                for i in xrange(j+1, m):
+                    A[i, j] *= t
+
+            return A, R[0:p,0:n]
+
+        # ------------------
+        # END OF FUNCTION QR
+        # ------------------
diff --git a/lib/python3.10/site-packages/mpmath/matrices/matrices.py b/lib/python3.10/site-packages/mpmath/matrices/matrices.py
new file mode 100644
index 0000000000000000000000000000000000000000..a97d5a9ca7e173195386dc7cb60860a826ab6a97
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/matrices/matrices.py
@@ -0,0 +1,1005 @@
+from ..libmp.backend import xrange
+import warnings
+
+# TODO: interpret list as vectors (for multiplication)
+
+rowsep = '\n'
+colsep = '  '
+
+class _matrix(object):
+    """
+    Numerical matrix.
+
+    Specify the dimensions or the data as a nested list.
+    Elements default to zero.
+    Use a flat list to create a column vector easily.
+
+    The datatype of the context (mpf for mp, mpi for iv, and float for fp) is used to store the data.
+
+    Creating matrices
+    -----------------
+
+    Matrices in mpmath are implemented using dictionaries. Only non-zero values
+    are stored, so it is cheap to represent sparse matrices.
+
+    The most basic way to create one is to use the ``matrix`` class directly.
+    You can create an empty matrix specifying the dimensions:
+
+        >>> from mpmath import *
+        >>> mp.dps = 15
+        >>> matrix(2)
+        matrix(
+        [['0.0', '0.0'],
+         ['0.0', '0.0']])
+        >>> matrix(2, 3)
+        matrix(
+        [['0.0', '0.0', '0.0'],
+         ['0.0', '0.0', '0.0']])
+
+    Calling ``matrix`` with one dimension will create a square matrix.
+
+    To access the dimensions of a matrix, use the ``rows`` or ``cols`` keyword:
+
+        >>> A = matrix(3, 2)
+        >>> A
+        matrix(
+        [['0.0', '0.0'],
+         ['0.0', '0.0'],
+         ['0.0', '0.0']])
+        >>> A.rows
+        3
+        >>> A.cols
+        2
+
+    You can also change the dimension of an existing matrix. This will set the
+    new elements to 0. If the new dimension is smaller than before, the
+    concerning elements are discarded:
+
+        >>> A.rows = 2
+        >>> A
+        matrix(
+        [['0.0', '0.0'],
+         ['0.0', '0.0']])
+
+    Internally ``mpmathify`` is used every time an element is set. This
+    is done using the syntax A[row,column], counting from 0:
+
+        >>> A = matrix(2)
+        >>> A[1,1] = 1 + 1j
+        >>> A
+        matrix(
+        [['0.0', '0.0'],
+         ['0.0', mpc(real='1.0', imag='1.0')]])
+
+    A more comfortable way to create a matrix lets you use nested lists:
+
+        >>> matrix([[1, 2], [3, 4]])
+        matrix(
+        [['1.0', '2.0'],
+         ['3.0', '4.0']])
+
+    Convenient advanced functions are available for creating various standard
+    matrices, see ``zeros``, ``ones``, ``diag``, ``eye``, ``randmatrix`` and
+    ``hilbert``.
+
+    Vectors
+    .......
+
+    Vectors may also be represented by the ``matrix`` class (with rows = 1 or cols = 1).
+    For vectors there are some things which make life easier. A column vector can
+    be created using a flat list, a row vectors using an almost flat nested list::
+
+        >>> matrix([1, 2, 3])
+        matrix(
+        [['1.0'],
+         ['2.0'],
+         ['3.0']])
+        >>> matrix([[1, 2, 3]])
+        matrix(
+        [['1.0', '2.0', '3.0']])
+
+    Optionally vectors can be accessed like lists, using only a single index::
+
+        >>> x = matrix([1, 2, 3])
+        >>> x[1]
+        mpf('2.0')
+        >>> x[1,0]
+        mpf('2.0')
+
+    Other
+    .....
+
+    Like you probably expected, matrices can be printed::
+
+        >>> print randmatrix(3) # doctest:+SKIP
+        [ 0.782963853573023  0.802057689719883  0.427895717335467]
+        [0.0541876859348597  0.708243266653103  0.615134039977379]
+        [ 0.856151514955773  0.544759264818486  0.686210904770947]
+
+    Use ``nstr`` or ``nprint`` to specify the number of digits to print::
+
+        >>> nprint(randmatrix(5), 3) # doctest:+SKIP
+        [2.07e-1  1.66e-1  5.06e-1  1.89e-1  8.29e-1]
+        [6.62e-1  6.55e-1  4.47e-1  4.82e-1  2.06e-2]
+        [4.33e-1  7.75e-1  6.93e-2  2.86e-1  5.71e-1]
+        [1.01e-1  2.53e-1  6.13e-1  3.32e-1  2.59e-1]
+        [1.56e-1  7.27e-2  6.05e-1  6.67e-2  2.79e-1]
+
+    As matrices are mutable, you will need to copy them sometimes::
+
+        >>> A = matrix(2)
+        >>> A
+        matrix(
+        [['0.0', '0.0'],
+         ['0.0', '0.0']])
+        >>> B = A.copy()
+        >>> B[0,0] = 1
+        >>> B
+        matrix(
+        [['1.0', '0.0'],
+         ['0.0', '0.0']])
+        >>> A
+        matrix(
+        [['0.0', '0.0'],
+         ['0.0', '0.0']])
+
+    Finally, it is possible to convert a matrix to a nested list. This is very useful,
+    as most Python libraries involving matrices or arrays (namely NumPy or SymPy)
+    support this format::
+
+        >>> B.tolist()
+        [[mpf('1.0'), mpf('0.0')], [mpf('0.0'), mpf('0.0')]]
+
+
+    Matrix operations
+    -----------------
+
+    You can add and subtract matrices of compatible dimensions::
+
+        >>> A = matrix([[1, 2], [3, 4]])
+        >>> B = matrix([[-2, 4], [5, 9]])
+        >>> A + B
+        matrix(
+        [['-1.0', '6.0'],
+         ['8.0', '13.0']])
+        >>> A - B
+        matrix(
+        [['3.0', '-2.0'],
+         ['-2.0', '-5.0']])
+        >>> A + ones(3) # doctest:+ELLIPSIS
+        Traceback (most recent call last):
+          ...
+        ValueError: incompatible dimensions for addition
+
+    It is possible to multiply or add matrices and scalars. In the latter case the
+    operation will be done element-wise::
+
+        >>> A * 2
+        matrix(
+        [['2.0', '4.0'],
+         ['6.0', '8.0']])
+        >>> A / 4
+        matrix(
+        [['0.25', '0.5'],
+         ['0.75', '1.0']])
+        >>> A - 1
+        matrix(
+        [['0.0', '1.0'],
+         ['2.0', '3.0']])
+
+    Of course you can perform matrix multiplication, if the dimensions are
+    compatible, using ``@`` (for Python >= 3.5) or ``*``. For clarity, ``@`` is
+    recommended (`PEP 465 <https://www.python.org/dev/peps/pep-0465/>`), because
+    the meaning of ``*`` is different in many other Python libraries such as NumPy.
+
+        >>> A @ B # doctest:+SKIP
+        matrix(
+        [['8.0', '22.0'],
+         ['14.0', '48.0']])
+        >>> A * B # same as A @ B
+        matrix(
+        [['8.0', '22.0'],
+         ['14.0', '48.0']])
+        >>> matrix([[1, 2, 3]]) * matrix([[-6], [7], [-2]])
+        matrix(
+        [['2.0']])
+
+    ..
+        COMMENT: TODO: the above "doctest:+SKIP" may be removed as soon as we
+        have dropped support for Python 3.5 and below.
+
+    You can raise powers of square matrices::
+
+        >>> A**2
+        matrix(
+        [['7.0', '10.0'],
+         ['15.0', '22.0']])
+
+    Negative powers will calculate the inverse::
+
+        >>> A**-1
+        matrix(
+        [['-2.0', '1.0'],
+         ['1.5', '-0.5']])
+        >>> A * A**-1
+        matrix(
+        [['1.0', '1.0842021724855e-19'],
+         ['-2.16840434497101e-19', '1.0']])
+
+
+
+    Matrix transposition is straightforward::
+
+        >>> A = ones(2, 3)
+        >>> A
+        matrix(
+        [['1.0', '1.0', '1.0'],
+         ['1.0', '1.0', '1.0']])
+        >>> A.T
+        matrix(
+        [['1.0', '1.0'],
+         ['1.0', '1.0'],
+         ['1.0', '1.0']])
+
+    Norms
+    .....
+
+    Sometimes you need to know how "large" a matrix or vector is. Due to their
+    multidimensional nature it's not possible to compare them, but there are
+    several functions to map a matrix or a vector to a positive real number, the
+    so called norms.
+
+    For vectors the p-norm is intended, usually the 1-, the 2- and the oo-norm are
+    used.
+
+        >>> x = matrix([-10, 2, 100])
+        >>> norm(x, 1)
+        mpf('112.0')
+        >>> norm(x, 2)
+        mpf('100.5186549850325')
+        >>> norm(x, inf)
+        mpf('100.0')
+
+    Please note that the 2-norm is the most used one, though it is more expensive
+    to calculate than the 1- or oo-norm.
+
+    It is possible to generalize some vector norms to matrix norm::
+
+        >>> A = matrix([[1, -1000], [100, 50]])
+        >>> mnorm(A, 1)
+        mpf('1050.0')
+        >>> mnorm(A, inf)
+        mpf('1001.0')
+        >>> mnorm(A, 'F')
+        mpf('1006.2310867787777')
+
+    The last norm (the "Frobenius-norm") is an approximation for the 2-norm, which
+    is hard to calculate and not available. The Frobenius-norm lacks some
+    mathematical properties you might expect from a norm.
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.__data = {}
+        # LU decompostion cache, this is useful when solving the same system
+        # multiple times, when calculating the inverse and when calculating the
+        # determinant
+        self._LU = None
+        if "force_type" in kwargs:
+            warnings.warn("The force_type argument was removed, it did not work"
+                " properly anyway. If you want to force floating-point or"
+                " interval computations, use the respective methods from `fp`"
+                " or `mp` instead, e.g., `fp.matrix()` or `iv.matrix()`."
+                " If you want to truncate values to integer, use .apply(int) instead.")
+        if isinstance(args[0], (list, tuple)):
+            if isinstance(args[0][0], (list, tuple)):
+                # interpret nested list as matrix
+                A = args[0]
+                self.__rows = len(A)
+                self.__cols = len(A[0])
+                for i, row in enumerate(A):
+                    for j, a in enumerate(row):
+                        # note: this will call __setitem__ which will call self.ctx.convert() to convert the datatype.
+                        self[i, j] = a
+            else:
+                # interpret list as row vector
+                v = args[0]
+                self.__rows = len(v)
+                self.__cols = 1
+                for i, e in enumerate(v):
+                    self[i, 0] = e
+        elif isinstance(args[0], int):
+            # create empty matrix of given dimensions
+            if len(args) == 1:
+                self.__rows = self.__cols = args[0]
+            else:
+                if not isinstance(args[1], int):
+                    raise TypeError("expected int")
+                self.__rows = args[0]
+                self.__cols = args[1]
+        elif isinstance(args[0], _matrix):
+            A = args[0]
+            self.__rows = A._matrix__rows
+            self.__cols = A._matrix__cols
+            for i in xrange(A.__rows):
+                for j in xrange(A.__cols):
+                    self[i, j] = A[i, j]
+        elif hasattr(args[0], 'tolist'):
+            A = self.ctx.matrix(args[0].tolist())
+            self.__data = A._matrix__data
+            self.__rows = A._matrix__rows
+            self.__cols = A._matrix__cols
+        else:
+            raise TypeError('could not interpret given arguments')
+
+    def apply(self, f):
+        """
+        Return a copy of self with the function `f` applied elementwise.
+        """
+        new = self.ctx.matrix(self.__rows, self.__cols)
+        for i in xrange(self.__rows):
+            for j in xrange(self.__cols):
+                new[i,j] = f(self[i,j])
+        return new
+
+    def __nstr__(self, n=None, **kwargs):
+        # Build table of string representations of the elements
+        res = []
+        # Track per-column max lengths for pretty alignment
+        maxlen = [0] * self.cols
+        for i in range(self.rows):
+            res.append([])
+            for j in range(self.cols):
+                if n:
+                    string = self.ctx.nstr(self[i,j], n, **kwargs)
+                else:
+                    string = str(self[i,j])
+                res[-1].append(string)
+                maxlen[j] = max(len(string), maxlen[j])
+        # Patch strings together
+        for i, row in enumerate(res):
+            for j, elem in enumerate(row):
+                # Pad each element up to maxlen so the columns line up
+                row[j] = elem.rjust(maxlen[j])
+            res[i] = "[" + colsep.join(row) + "]"
+        return rowsep.join(res)
+
+    def __str__(self):
+        return self.__nstr__()
+
+    def _toliststr(self, avoid_type=False):
+        """
+        Create a list string from a matrix.
+
+        If avoid_type: avoid multiple 'mpf's.
+        """
+        # XXX: should be something like self.ctx._types
+        typ = self.ctx.mpf
+        s = '['
+        for i in xrange(self.__rows):
+            s += '['
+            for j in xrange(self.__cols):
+                if not avoid_type or not isinstance(self[i,j], typ):
+                    a = repr(self[i,j])
+                else:
+                    a = "'" + str(self[i,j]) + "'"
+                s += a + ', '
+            s = s[:-2]
+            s += '],\n '
+        s = s[:-3]
+        s += ']'
+        return s
+
+    def tolist(self):
+        """
+        Convert the matrix to a nested list.
+        """
+        return [[self[i,j] for j in range(self.__cols)] for i in range(self.__rows)]
+
+    def __repr__(self):
+        if self.ctx.pretty:
+            return self.__str__()
+        s = 'matrix(\n'
+        s += self._toliststr(avoid_type=True) + ')'
+        return s
+
+    def __get_element(self, key):
+        '''
+        Fast extraction of the i,j element from the matrix
+            This function is for private use only because is unsafe:
+                1. Does not check on the value of key it expects key to be a integer tuple (i,j)
+                2. Does not check bounds
+        '''
+        if key in self.__data:
+            return self.__data[key]
+        else:
+            return self.ctx.zero
+
+    def __set_element(self, key, value):
+        '''
+        Fast assignment of the i,j element in the matrix
+            This function is unsafe:
+                1. Does not check on the value of key it expects key to be a integer tuple (i,j)
+                2. Does not check bounds
+                3. Does not check the value type
+                4. Does not reset the LU cache
+        '''
+        if value: # only store non-zeros
+            self.__data[key] = value
+        elif key in self.__data:
+            del self.__data[key]
+
+
+    def __getitem__(self, key):
+        '''
+            Getitem function for mp matrix class with slice index enabled
+            it allows the following assingments
+            scalar to a slice of the matrix
+         B = A[:,2:6]
+        '''
+        # Convert vector to matrix indexing
+        if isinstance(key, int) or isinstance(key,slice):
+            # only sufficent for vectors
+            if self.__rows == 1:
+                key = (0, key)
+            elif self.__cols == 1:
+                key = (key, 0)
+            else:
+                raise IndexError('insufficient indices for matrix')
+
+        if isinstance(key[0],slice) or isinstance(key[1],slice):
+
+            #Rows
+            if isinstance(key[0],slice):
+                #Check bounds
+                if (key[0].start is None or key[0].start >= 0) and \
+                    (key[0].stop is None or key[0].stop <= self.__rows+1):
+                    # Generate indices
+                    rows = xrange(*key[0].indices(self.__rows))
+                else:
+                    raise IndexError('Row index out of bounds')
+            else:
+                # Single row
+                rows = [key[0]]
+
+            # Columns
+            if isinstance(key[1],slice):
+                # Check bounds
+                if (key[1].start is None or key[1].start >= 0) and \
+                    (key[1].stop is None or key[1].stop <= self.__cols+1):
+                    # Generate indices
+                    columns = xrange(*key[1].indices(self.__cols))
+                else:
+                    raise IndexError('Column index out of bounds')
+
+            else:
+                # Single column
+                columns = [key[1]]
+
+            # Create matrix slice
+            m = self.ctx.matrix(len(rows),len(columns))
+
+            # Assign elements to the output matrix
+            for i,x in enumerate(rows):
+                for j,y in enumerate(columns):
+                    m.__set_element((i,j),self.__get_element((x,y)))
+
+            return m
+
+        else:
+            # single element extraction
+            if key[0] >= self.__rows or key[1] >= self.__cols:
+                raise IndexError('matrix index out of range')
+            if key in self.__data:
+                return self.__data[key]
+            else:
+                return self.ctx.zero
+
+    def __setitem__(self, key, value):
+        # setitem function for mp matrix class with slice index enabled
+        # it allows the following assingments
+        #  scalar to a slice of the matrix
+        # A[:,2:6] = 2.5
+        #  submatrix to matrix (the value matrix should be the same size as the slice size)
+        # A[3,:] = B   where A is n x m  and B is n x 1
+        # Convert vector to matrix indexing
+        if isinstance(key, int) or isinstance(key,slice):
+            # only sufficent for vectors
+            if self.__rows == 1:
+                key = (0, key)
+            elif self.__cols == 1:
+                key = (key, 0)
+            else:
+                raise IndexError('insufficient indices for matrix')
+        # Slice indexing
+        if isinstance(key[0],slice) or isinstance(key[1],slice):
+            # Rows
+            if isinstance(key[0],slice):
+                # Check bounds
+                if (key[0].start is None or key[0].start >= 0) and \
+                    (key[0].stop is None or key[0].stop <= self.__rows+1):
+                    # generate row indices
+                    rows = xrange(*key[0].indices(self.__rows))
+                else:
+                    raise IndexError('Row index out of bounds')
+            else:
+                # Single row
+                rows = [key[0]]
+            # Columns
+            if isinstance(key[1],slice):
+                # Check bounds
+                if (key[1].start is None or key[1].start >= 0) and \
+                    (key[1].stop is None or key[1].stop <= self.__cols+1):
+                    # Generate column indices
+                    columns = xrange(*key[1].indices(self.__cols))
+                else:
+                    raise IndexError('Column index out of bounds')
+            else:
+                # Single column
+                columns = [key[1]]
+            # Assign slice with a scalar
+            if isinstance(value,self.ctx.matrix):
+                # Assign elements to matrix if input and output dimensions match
+                if len(rows) == value.rows and len(columns) == value.cols:
+                    for i,x in enumerate(rows):
+                        for j,y in enumerate(columns):
+                            self.__set_element((x,y), value.__get_element((i,j)))
+                else:
+                    raise ValueError('Dimensions do not match')
+            else:
+                # Assign slice with scalars
+                value = self.ctx.convert(value)
+                for i in rows:
+                    for j in columns:
+                        self.__set_element((i,j), value)
+        else:
+            # Single element assingment
+            # Check bounds
+            if key[0] >= self.__rows or key[1] >= self.__cols:
+                raise IndexError('matrix index out of range')
+            # Convert and store value
+            value = self.ctx.convert(value)
+            if value: # only store non-zeros
+                self.__data[key] = value
+            elif key in self.__data:
+                del self.__data[key]
+
+        if self._LU:
+            self._LU = None
+        return
+
+    def __iter__(self):
+        for i in xrange(self.__rows):
+            for j in xrange(self.__cols):
+                yield self[i,j]
+
+    def __mul__(self, other):
+        if isinstance(other, self.ctx.matrix):
+            # dot multiplication
+            if self.__cols != other.__rows:
+                raise ValueError('dimensions not compatible for multiplication')
+            new = self.ctx.matrix(self.__rows, other.__cols)
+            self_zero = self.ctx.zero
+            self_get = self.__data.get
+            other_zero = other.ctx.zero
+            other_get = other.__data.get
+            for i in xrange(self.__rows):
+                for j in xrange(other.__cols):
+                    new[i, j] = self.ctx.fdot((self_get((i,k), self_zero), other_get((k,j), other_zero))
+                                     for k in xrange(other.__rows))
+            return new
+        else:
+            # try scalar multiplication
+            new = self.ctx.matrix(self.__rows, self.__cols)
+            for i in xrange(self.__rows):
+                for j in xrange(self.__cols):
+                    new[i, j] = other * self[i, j]
+            return new
+
+    def __matmul__(self, other):
+        return self.__mul__(other)
+
+    def __rmul__(self, other):
+        # assume other is scalar and thus commutative
+        if isinstance(other, self.ctx.matrix):
+            raise TypeError("other should not be type of ctx.matrix")
+        return self.__mul__(other)
+
+    def __pow__(self, other):
+        # avoid cyclic import problems
+        #from linalg import inverse
+        if not isinstance(other, int):
+            raise ValueError('only integer exponents are supported')
+        if not self.__rows == self.__cols:
+            raise ValueError('only powers of square matrices are defined')
+        n = other
+        if n == 0:
+            return self.ctx.eye(self.__rows)
+        if n < 0:
+            n = -n
+            neg = True
+        else:
+            neg = False
+        i = n
+        y = 1
+        z = self.copy()
+        while i != 0:
+            if i % 2 == 1:
+                y = y * z
+            z = z*z
+            i = i // 2
+        if neg:
+            y = self.ctx.inverse(y)
+        return y
+
+    def __div__(self, other):
+        # assume other is scalar and do element-wise divison
+        assert not isinstance(other, self.ctx.matrix)
+        new = self.ctx.matrix(self.__rows, self.__cols)
+        for i in xrange(self.__rows):
+            for j in xrange(self.__cols):
+                new[i,j] = self[i,j] / other
+        return new
+
+    __truediv__ = __div__
+
+    def __add__(self, other):
+        if isinstance(other, self.ctx.matrix):
+            if not (self.__rows == other.__rows and self.__cols == other.__cols):
+                raise ValueError('incompatible dimensions for addition')
+            new = self.ctx.matrix(self.__rows, self.__cols)
+            for i in xrange(self.__rows):
+                for j in xrange(self.__cols):
+                    new[i,j] = self[i,j] + other[i,j]
+            return new
+        else:
+            # assume other is scalar and add element-wise
+            new = self.ctx.matrix(self.__rows, self.__cols)
+            for i in xrange(self.__rows):
+                for j in xrange(self.__cols):
+                    new[i,j] += self[i,j] + other
+            return new
+
+    def __radd__(self, other):
+        return self.__add__(other)
+
+    def __sub__(self, other):
+        if isinstance(other, self.ctx.matrix) and not (self.__rows == other.__rows
+                                              and self.__cols == other.__cols):
+            raise ValueError('incompatible dimensions for subtraction')
+        return self.__add__(other * (-1))
+
+    def __pos__(self):
+        """
+        +M returns a copy of M, rounded to current working precision.
+        """
+        return (+1) * self
+
+    def __neg__(self):
+        return (-1) * self
+
+    def __rsub__(self, other):
+        return -self + other
+
+    def __eq__(self, other):
+        return self.__rows == other.__rows and self.__cols == other.__cols \
+               and self.__data == other.__data
+
+    def __len__(self):
+        if self.rows == 1:
+            return self.cols
+        elif self.cols == 1:
+            return self.rows
+        else:
+            return self.rows # do it like numpy
+
+    def __getrows(self):
+        return self.__rows
+
+    def __setrows(self, value):
+        for key in self.__data.copy():
+            if key[0] >= value:
+                del self.__data[key]
+        self.__rows = value
+
+    rows = property(__getrows, __setrows, doc='number of rows')
+
+    def __getcols(self):
+        return self.__cols
+
+    def __setcols(self, value):
+        for key in self.__data.copy():
+            if key[1] >= value:
+                del self.__data[key]
+        self.__cols = value
+
+    cols = property(__getcols, __setcols, doc='number of columns')
+
+    def transpose(self):
+        new = self.ctx.matrix(self.__cols, self.__rows)
+        for i in xrange(self.__rows):
+            for j in xrange(self.__cols):
+                new[j,i] = self[i,j]
+        return new
+
+    T = property(transpose)
+
+    def conjugate(self):
+        return self.apply(self.ctx.conj)
+
+    def transpose_conj(self):
+        return self.conjugate().transpose()
+
+    H = property(transpose_conj)
+
+    def copy(self):
+        new = self.ctx.matrix(self.__rows, self.__cols)
+        new.__data = self.__data.copy()
+        return new
+
+    __copy__ = copy
+
+    def column(self, n):
+        m = self.ctx.matrix(self.rows, 1)
+        for i in range(self.rows):
+            m[i] = self[i,n]
+        return m
+
+class MatrixMethods(object):
+
+    def __init__(ctx):
+        # XXX: subclass
+        ctx.matrix = type('matrix', (_matrix,), {})
+        ctx.matrix.ctx = ctx
+        ctx.matrix.convert = ctx.convert
+
+    def eye(ctx, n, **kwargs):
+        """
+        Create square identity matrix n x n.
+        """
+        A = ctx.matrix(n, **kwargs)
+        for i in xrange(n):
+            A[i,i] = 1
+        return A
+
+    def diag(ctx, diagonal, **kwargs):
+        """
+        Create square diagonal matrix using given list.
+
+        Example:
+        >>> from mpmath import diag, mp
+        >>> mp.pretty = False
+        >>> diag([1, 2, 3])
+        matrix(
+        [['1.0', '0.0', '0.0'],
+         ['0.0', '2.0', '0.0'],
+         ['0.0', '0.0', '3.0']])
+        """
+        A = ctx.matrix(len(diagonal), **kwargs)
+        for i in xrange(len(diagonal)):
+            A[i,i] = diagonal[i]
+        return A
+
+    def zeros(ctx, *args, **kwargs):
+        """
+        Create matrix m x n filled with zeros.
+        One given dimension will create square matrix n x n.
+
+        Example:
+        >>> from mpmath import zeros, mp
+        >>> mp.pretty = False
+        >>> zeros(2)
+        matrix(
+        [['0.0', '0.0'],
+         ['0.0', '0.0']])
+        """
+        if len(args) == 1:
+            m = n = args[0]
+        elif len(args) == 2:
+            m = args[0]
+            n = args[1]
+        else:
+            raise TypeError('zeros expected at most 2 arguments, got %i' % len(args))
+        A = ctx.matrix(m, n, **kwargs)
+        for i in xrange(m):
+            for j in xrange(n):
+                A[i,j] = 0
+        return A
+
+    def ones(ctx, *args, **kwargs):
+        """
+        Create matrix m x n filled with ones.
+        One given dimension will create square matrix n x n.
+
+        Example:
+        >>> from mpmath import ones, mp
+        >>> mp.pretty = False
+        >>> ones(2)
+        matrix(
+        [['1.0', '1.0'],
+         ['1.0', '1.0']])
+        """
+        if len(args) == 1:
+            m = n = args[0]
+        elif len(args) == 2:
+            m = args[0]
+            n = args[1]
+        else:
+            raise TypeError('ones expected at most 2 arguments, got %i' % len(args))
+        A = ctx.matrix(m, n, **kwargs)
+        for i in xrange(m):
+            for j in xrange(n):
+                A[i,j] = 1
+        return A
+
+    def hilbert(ctx, m, n=None):
+        """
+        Create (pseudo) hilbert matrix m x n.
+        One given dimension will create hilbert matrix n x n.
+
+        The matrix is very ill-conditioned and symmetric, positive definite if
+        square.
+        """
+        if n is None:
+            n = m
+        A = ctx.matrix(m, n)
+        for i in xrange(m):
+            for j in xrange(n):
+                A[i,j] = ctx.one / (i + j + 1)
+        return A
+
+    def randmatrix(ctx, m, n=None, min=0, max=1, **kwargs):
+        """
+        Create a random m x n matrix.
+
+        All values are >= min and <max.
+        n defaults to m.
+
+        Example:
+        >>> from mpmath import randmatrix
+        >>> randmatrix(2) # doctest:+SKIP
+        matrix(
+        [['0.53491598236191806', '0.57195669543302752'],
+         ['0.85589992269513615', '0.82444367501382143']])
+        """
+        if not n:
+            n = m
+        A = ctx.matrix(m, n, **kwargs)
+        for i in xrange(m):
+            for j in xrange(n):
+                A[i,j] = ctx.rand() * (max - min) + min
+        return A
+
+    def swap_row(ctx, A, i, j):
+        """
+        Swap row i with row j.
+        """
+        if i == j:
+            return
+        if isinstance(A, ctx.matrix):
+            for k in xrange(A.cols):
+                A[i,k], A[j,k] = A[j,k], A[i,k]
+        elif isinstance(A, list):
+            A[i], A[j] = A[j], A[i]
+        else:
+            raise TypeError('could not interpret type')
+
+    def extend(ctx, A, b):
+        """
+        Extend matrix A with column b and return result.
+        """
+        if not isinstance(A, ctx.matrix):
+            raise TypeError("A should be a type of ctx.matrix")
+        if A.rows != len(b):
+            raise ValueError("Value should be equal to len(b)")
+        A = A.copy()
+        A.cols += 1
+        for i in xrange(A.rows):
+            A[i, A.cols-1] = b[i]
+        return A
+
+    def norm(ctx, x, p=2):
+        r"""
+        Gives the entrywise `p`-norm of an iterable *x*, i.e. the vector norm
+        `\left(\sum_k |x_k|^p\right)^{1/p}`, for any given `1 \le p \le \infty`.
+
+        Special cases:
+
+        If *x* is not iterable, this just returns ``absmax(x)``.
+
+        ``p=1`` gives the sum of absolute values.
+
+        ``p=2`` is the standard Euclidean vector norm.
+
+        ``p=inf`` gives the magnitude of the largest element.
+
+        For *x* a matrix, ``p=2`` is the Frobenius norm.
+        For operator matrix norms, use :func:`~mpmath.mnorm` instead.
+
+        You can use the string 'inf' as well as float('inf') or mpf('inf')
+        to specify the infinity norm.
+
+        **Examples**
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> x = matrix([-10, 2, 100])
+            >>> norm(x, 1)
+            mpf('112.0')
+            >>> norm(x, 2)
+            mpf('100.5186549850325')
+            >>> norm(x, inf)
+            mpf('100.0')
+
+        """
+        try:
+            iter(x)
+        except TypeError:
+            return ctx.absmax(x)
+        if type(p) is not int:
+            p = ctx.convert(p)
+        if p == ctx.inf:
+            return max(ctx.absmax(i) for i in x)
+        elif p == 1:
+            return ctx.fsum(x, absolute=1)
+        elif p == 2:
+            return ctx.sqrt(ctx.fsum(x, absolute=1, squared=1))
+        elif p > 1:
+            return ctx.nthroot(ctx.fsum(abs(i)**p for i in x), p)
+        else:
+            raise ValueError('p has to be >= 1')
+
+    def mnorm(ctx, A, p=1):
+        r"""
+        Gives the matrix (operator) `p`-norm of A. Currently ``p=1`` and ``p=inf``
+        are supported:
+
+        ``p=1`` gives the 1-norm (maximal column sum)
+
+        ``p=inf`` gives the `\infty`-norm (maximal row sum).
+        You can use the string 'inf' as well as float('inf') or mpf('inf')
+
+        ``p=2`` (not implemented) for a square matrix is the usual spectral
+        matrix norm, i.e. the largest singular value.
+
+        ``p='f'`` (or 'F', 'fro', 'Frobenius, 'frobenius') gives the
+        Frobenius norm, which is the elementwise 2-norm. The Frobenius norm is an
+        approximation of the spectral norm and satisfies
+
+        .. math ::
+
+            \frac{1}{\sqrt{\mathrm{rank}(A)}} \|A\|_F \le \|A\|_2 \le \|A\|_F
+
+        The Frobenius norm lacks some mathematical properties that might
+        be expected of a norm.
+
+        For general elementwise `p`-norms, use :func:`~mpmath.norm` instead.
+
+        **Examples**
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> A = matrix([[1, -1000], [100, 50]])
+            >>> mnorm(A, 1)
+            mpf('1050.0')
+            >>> mnorm(A, inf)
+            mpf('1001.0')
+            >>> mnorm(A, 'F')
+            mpf('1006.2310867787777')
+
+        """
+        A = ctx.matrix(A)
+        if type(p) is not int:
+            if type(p) is str and 'frobenius'.startswith(p.lower()):
+                return ctx.norm(A, 2)
+            p = ctx.convert(p)
+        m, n = A.rows, A.cols
+        if p == 1:
+            return max(ctx.fsum((A[i,j] for i in xrange(m)), absolute=1) for j in xrange(n))
+        elif p == ctx.inf:
+            return max(ctx.fsum((A[i,j] for j in xrange(n)), absolute=1) for i in xrange(m))
+        else:
+            raise NotImplementedError("matrix p-norm for arbitrary p")
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
diff --git a/lib/python3.10/site-packages/mpmath/tests/__init__.py b/lib/python3.10/site-packages/mpmath/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/__init__.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..77ba1fdb513963c92a7a49948cd754bc523669f9
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/__init__.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/extratest_gamma.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/extratest_gamma.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8923a47b9b875d65f275c5b7058ce66ddb27d514
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/extratest_gamma.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/extratest_zeta.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/extratest_zeta.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5fa5953c3821eaacf7b0d25e85df97d06526e994
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/extratest_zeta.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/runtests.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/runtests.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..551fedca5c1583545630677d15372f8944dcfc3e
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/runtests.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_basic_ops.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_basic_ops.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..78213513b751252df59bded322d6b02f73d18ae7
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_basic_ops.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_bitwise.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_bitwise.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..78df1cf82be81e130b368a707eab3c52137b20fe
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_bitwise.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_calculus.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_calculus.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..73a5a421a32e7c95fac0be2816d8a8cdc0ddf436
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_calculus.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_compatibility.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_compatibility.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..07025a0406896eef91b669d23b502d04cf51d98f
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_compatibility.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_convert.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_convert.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1f85ff33c3a6b6ddc66f0fa7ed32e107da6a627e
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_convert.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_diff.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_diff.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..595f10f32f5cdb8550ced60457c9412dcf7d5d30
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_diff.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_division.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_division.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a900bd2f45a14f09b48a1d2828dcb4bde34ccbb5
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_division.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_eigen.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_eigen.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e00b7e8750799694f6048d34f22d8f2f16bb9972
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_eigen.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_eigen_symmetric.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_eigen_symmetric.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..06ed54fca6d998a666d527d2702188247757da68
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_eigen_symmetric.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_elliptic.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_elliptic.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..326a8d160137d2428723e777f499f9611f86c164
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_elliptic.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_fp.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_fp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..985da435c4f5915ae9dfba4392ef916b7b559a87
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_fp.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_functions.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_functions.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cbd7a0a5d7eb3e896c272757b9065185d9dd1031
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_functions.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_functions2.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_functions2.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..99c5400c186f927ff158839d65428deec9da4259
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_functions2.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_gammazeta.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_gammazeta.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..48c7940fb2664f870678b51c6c5303b73a5ebfa2
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_gammazeta.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_hp.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_hp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ac793a562882868263396c4519b166db4b6c583a
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_hp.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_identify.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_identify.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3178c10ddd68fa96784d849a9cf094da81ca8105
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_identify.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_interval.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_interval.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8fb7e51847fd7335f177dea19b13ddb4407025ee
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_interval.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_levin.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_levin.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cf27fde6b7a8130fd342cbb6a3a5b418f2fab891
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_levin.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_linalg.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_linalg.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..85b69c88c83a82f64fedb8dc2878fd349976d414
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_linalg.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_matrices.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_matrices.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..92747c7c2e54ff32301434b3facdf2ef0256cb64
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_matrices.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_mpmath.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_mpmath.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f1a19f3707a95c14a43c1e3bde338af3f7addfb6
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_mpmath.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_ode.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_ode.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a6a7b10e9c19a2eb11f952389ff6cfb3b21acbe1
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_ode.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_pickle.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_pickle.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2b28c1887b3348a6b0c9131318c6976b2567d352
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_pickle.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_power.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_power.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c348c3008a56cad31f1d3ae36536f6a524e05e11
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_power.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_quad.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_quad.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..90019ba580293cb120f9b6862946f52a182701fb
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_quad.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_rootfinding.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_rootfinding.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0c6233b7932678b4e9097c3e93f31cd884ef966d
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_rootfinding.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_special.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_special.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..217a28758b2b47d209a38007048900c9baa852d5
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_special.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_str.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_str.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..57fc366448117b8cef6184f1c372706e37ceded9
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_str.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_summation.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_summation.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..065bbde41fcead36f465c82502d037d6499516ac
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_summation.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_trig.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_trig.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..87bd15cba45f26c879688b28b93e69b5f873b1ee
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_trig.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_visualization.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_visualization.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f0c931fbde157b242f961450439fd89d9365cdc3
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/test_visualization.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/__pycache__/torture.cpython-310.pyc b/lib/python3.10/site-packages/mpmath/tests/__pycache__/torture.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5970355e75aaa565a299d3c8576b497ba4a4d3f6
Binary files /dev/null and b/lib/python3.10/site-packages/mpmath/tests/__pycache__/torture.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/mpmath/tests/extratest_gamma.py b/lib/python3.10/site-packages/mpmath/tests/extratest_gamma.py
new file mode 100644
index 0000000000000000000000000000000000000000..5a27b61b19aba0abf6bdb8adc16fc1ec7689b67a
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/extratest_gamma.py
@@ -0,0 +1,215 @@
+from mpmath import *
+from mpmath.libmp import ifac
+
+import sys
+if "-dps" in sys.argv:
+    maxdps = int(sys.argv[sys.argv.index("-dps")+1])
+else:
+    maxdps = 1000
+
+raise_ = "-raise" in sys.argv
+
+errcount = 0
+
+def check(name, func, z, y):
+    global errcount
+    try:
+        x = func(z)
+    except:
+        errcount += 1
+        if raise_:
+            raise
+        print()
+        print(name)
+        print("EXCEPTION")
+        import traceback
+        traceback.print_tb(sys.exc_info()[2])
+        print()
+        return
+    xre = x.real
+    xim = x.imag
+    yre = y.real
+    yim = y.imag
+    tol = eps*8
+    err = 0
+    if abs(xre-yre) > abs(yre)*tol:
+        err = 1
+        print()
+        print("Error! %s (re = %s, wanted %s, err=%s)" % (name, nstr(xre,10), nstr(yre,10), nstr(abs(xre-yre))))
+        errcount += 1
+        if raise_:
+            raise SystemExit
+    if abs(xim-yim) > abs(yim)*tol:
+        err = 1
+        print()
+        print("Error! %s (im = %s, wanted %s, err=%s)" % (name, nstr(xim,10), nstr(yim,10), nstr(abs(xim-yim))))
+        errcount += 1
+        if raise_:
+            raise SystemExit
+    if not err:
+        sys.stdout.write("%s ok; " % name)
+
+def testcase(case):
+    z, result = case
+    print("Testing z =", z)
+    mp.dps = 1010
+    z = eval(z)
+    mp.dps = maxdps + 50
+    if result is None:
+        gamma_val = gamma(z)
+        loggamma_val = loggamma(z)
+        factorial_val = factorial(z)
+        rgamma_val = rgamma(z)
+    else:
+        loggamma_val = eval(result)
+        gamma_val = exp(loggamma_val)
+        factorial_val = z * gamma_val
+        rgamma_val = 1/gamma_val
+    for dps in [5, 10, 15, 25, 40, 60, 90, 120, 250, 600, 1000, 1800, 3600]:
+        if dps > maxdps:
+            break
+        mp.dps = dps
+        print("dps = %s" % dps)
+        check("gamma", gamma, z, gamma_val)
+        check("rgamma", rgamma, z, rgamma_val)
+        check("loggamma", loggamma, z, loggamma_val)
+        check("factorial", factorial, z, factorial_val)
+        print()
+        mp.dps = 15
+
+testcases = []
+
+# Basic values
+for n in list(range(1,200)) + list(range(201,2000,17)):
+    testcases.append(["%s" % n, None])
+for n in range(-200,200):
+    testcases.append(["%s+0.5" % n, None])
+    testcases.append(["%s+0.37" % n, None])
+
+testcases += [\
+["(0.1+1j)", None],
+["(-0.1+1j)", None],
+["(0.1-1j)", None],
+["(-0.1-1j)", None],
+["10j", None],
+["-10j", None],
+["100j", None],
+["10000j", None],
+["-10000000j", None],
+["(10**100)*j", None],
+["125+(10**100)*j", None],
+["-125+(10**100)*j", None],
+["(10**10)*(1+j)", None],
+["(10**10)*(-1+j)", None],
+["(10**100)*(1+j)", None],
+["(10**100)*(-1+j)", None],
+["(1.5-1j)", None],
+["(6+4j)", None],
+["(4+1j)", None],
+["(3.5+2j)", None],
+["(1.5-1j)", None],
+["(-6-4j)", None],
+["(-2-3j)", None],
+["(-2.5-2j)", None],
+["(4+1j)", None],
+["(3+3j)", None],
+["(2-2j)", None],
+["1", "0"],
+["2", "0"],
+["3", "log(2)"],
+["4", "log(6)"],
+["5", "log(24)"],
+["0.5", "log(pi)/2"],
+["1.5", "log(sqrt(pi)/2)"],
+["2.5", "log(3*sqrt(pi)/4)"],
+["mpf('0.37')", None],
+["0.25", "log(sqrt(2*sqrt(2*pi**3)/agm(1,sqrt(2))))"],
+["-0.4", None],
+["mpf('-1.9')", None],
+["mpf('12.8')", None],
+["mpf('33.7')", None],
+["mpf('95.2')", None],
+["mpf('160.3')", None],
+["mpf('2057.8')", None],
+["25", "log(ifac(24))"],
+["80", "log(ifac(79))"],
+["500", "log(ifac(500-1))"],
+["8000", "log(ifac(8000-1))"],
+["8000.5", None],
+["mpf('8000.1')", None],
+["mpf('1.37e10')", None],
+["mpf('1.37e10')*(1+j)", None],
+["mpf('1.37e10')*(-1+j)", None],
+["mpf('1.37e10')*(-1-j)", None],
+["mpf('1.37e10')*(-1+j)", None],
+["mpf('1.37e100')", None],
+["mpf('1.37e100')*(1+j)", None],
+["mpf('1.37e100')*(-1+j)", None],
+["mpf('1.37e100')*(-1-j)", None],
+["mpf('1.37e100')*(-1+j)", None],
+["3+4j",
+"mpc('"
+"-1.7566267846037841105306041816232757851567066070613445016197619371316057169"
+"4723618263960834804618463052988607348289672535780644470689771115236512106002"
+"5970873471563240537307638968509556191696167970488390423963867031934333890838"
+"8009531786948197210025029725361069435208930363494971027388382086721660805397"
+"9163230643216054580167976201709951509519218635460317367338612500626714783631"
+"7498317478048447525674016344322545858832610325861086336204591943822302971823"
+"5161814175530618223688296232894588415495615809337292518431903058265147109853"
+"1710568942184987827643886816200452860853873815413367529829631430146227470517"
+"6579967222200868632179482214312673161276976117132204633283806161971389519137"
+"1243359764435612951384238091232760634271570950240717650166551484551654327989"
+"9360285030081716934130446150245110557038117075172576825490035434069388648124"
+"6678152254554001586736120762641422590778766100376515737713938521275749049949"
+"1284143906816424244705094759339932733567910991920631339597278805393743140853"
+"391550313363278558195609260225928','"
+"4.74266443803465792819488940755002274088830335171164611359052405215840070271"
+"5906813009373171139767051863542508136875688550817670379002790304870822775498"
+"2809996675877564504192565392367259119610438951593128982646945990372179860613"
+"4294436498090428077839141927485901735557543641049637962003652638924845391650"
+"9546290137755550107224907606529385248390667634297183361902055842228798984200"
+"9591180450211798341715874477629099687609819466457990642030707080894518168924"
+"6805549314043258530272479246115112769957368212585759640878745385160943755234"
+"9398036774908108204370323896757543121853650025529763655312360354244898913463"
+"7115955702828838923393113618205074162812089732064414530813087483533203244056"
+"0546577484241423134079056537777170351934430586103623577814746004431994179990"
+"5318522939077992613855205801498201930221975721246498720895122345420698451980"
+"0051215797310305885845964334761831751370672996984756815410977750799748813563"
+"8784405288158432214886648743541773208808731479748217023665577802702269468013"
+"673719173759245720489020315779001')"],
+]
+
+for z in [4, 14, 34, 64]:
+    testcases.append(["(2+j)*%s/3" % z, None])
+    testcases.append(["(-2+j)*%s/3" % z, None])
+    testcases.append(["(1+2*j)*%s/3" % z, None])
+    testcases.append(["(2-j)*%s/3" % z, None])
+    testcases.append(["(20+j)*%s/3" % z, None])
+    testcases.append(["(-20+j)*%s/3" % z, None])
+    testcases.append(["(1+20*j)*%s/3" % z, None])
+    testcases.append(["(20-j)*%s/3" % z, None])
+    testcases.append(["(200+j)*%s/3" % z, None])
+    testcases.append(["(-200+j)*%s/3" % z, None])
+    testcases.append(["(1+200*j)*%s/3" % z, None])
+    testcases.append(["(200-j)*%s/3" % z, None])
+
+# Poles
+for n in [0,1,2,3,4,25,-1,-2,-3,-4,-20,-21,-50,-51,-200,-201,-20000,-20001]:
+    for t in ['1e-5', '1e-20', '1e-100', '1e-10000']:
+        testcases.append(["fadd(%s,'%s',exact=True)" % (n, t), None])
+        testcases.append(["fsub(%s,'%s',exact=True)" % (n, t), None])
+        testcases.append(["fadd(%s,'%sj',exact=True)" % (n, t), None])
+        testcases.append(["fsub(%s,'%sj',exact=True)" % (n, t), None])
+
+if __name__ == "__main__":
+    from timeit import default_timer as clock
+    tot_time = 0.0
+    for case in testcases:
+        t1 = clock()
+        testcase(case)
+        t2 = clock()
+        print("Test time:", t2-t1)
+        print()
+        tot_time += (t2-t1)
+    print("Total time:", tot_time)
+    print("Errors:", errcount)
diff --git a/lib/python3.10/site-packages/mpmath/tests/extratest_zeta.py b/lib/python3.10/site-packages/mpmath/tests/extratest_zeta.py
new file mode 100644
index 0000000000000000000000000000000000000000..582b3d9cbd956b9cdf94309e0e718371fe716101
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/extratest_zeta.py
@@ -0,0 +1,30 @@
+from mpmath import zetazero
+from timeit import default_timer as clock
+
+def test_zetazero():
+    cases = [\
+    (399999999, 156762524.6750591511),
+    (241389216, 97490234.2276711795),
+    (526196239, 202950727.691229534),
+    (542964976, 209039046.578535272),
+    (1048449112, 388858885.231056486),
+    (1048449113, 388858885.384337406),
+    (1048449114, 388858886.002285122),
+    (1048449115, 388858886.00239369),
+    (1048449116, 388858886.690745053)
+    ]
+    for n, v in cases:
+        print(n, v)
+        t1 = clock()
+        ok = zetazero(n).ae(complex(0.5,v))
+        t2 = clock()
+        print("ok =", ok, ("(time = %s)" % round(t2-t1,3)))
+    print("Now computing two huge zeros (this may take hours)")
+    print("Computing zetazero(8637740722917)")
+    ok = zetazero(8637740722917).ae(complex(0.5,2124447368584.39296466152))
+    print("ok =", ok)
+    ok = zetazero(8637740722918).ae(complex(0.5,2124447368584.39298170604))
+    print("ok =", ok)
+
+if __name__ == "__main__":
+    test_zetazero()
diff --git a/lib/python3.10/site-packages/mpmath/tests/runtests.py b/lib/python3.10/site-packages/mpmath/tests/runtests.py
new file mode 100644
index 0000000000000000000000000000000000000000..70fde272fdc0e05e3d8951edddca380bd36139ab
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/runtests.py
@@ -0,0 +1,161 @@
+#!/usr/bin/env python
+
+"""
+python runtests.py -py
+  Use py.test to run tests (more useful for debugging)
+
+python runtests.py -coverage
+  Generate test coverage report. Statistics are written to /tmp
+
+python runtests.py -profile
+  Generate profile stats (this is much slower)
+
+python runtests.py -nogmpy
+  Run tests without using GMPY even if it exists
+
+python runtests.py -strict
+  Enforce extra tests in normalize()
+
+python runtests.py -local
+  Insert '../..' at the beginning of sys.path to use local mpmath
+
+python runtests.py -skip ...
+  Skip tests from the listed modules
+
+Additional arguments are used to filter the tests to run. Only files that have
+one of the arguments in their name are executed.
+
+"""
+
+import sys, os, traceback
+
+profile = False
+if "-profile" in sys.argv:
+    sys.argv.remove('-profile')
+    profile = True
+
+coverage = False
+if "-coverage" in sys.argv:
+    sys.argv.remove('-coverage')
+    coverage = True
+
+if "-nogmpy" in sys.argv:
+    sys.argv.remove('-nogmpy')
+    os.environ['MPMATH_NOGMPY'] = 'Y'
+
+if "-strict" in sys.argv:
+    sys.argv.remove('-strict')
+    os.environ['MPMATH_STRICT'] = 'Y'
+
+if "-local" in sys.argv:
+    sys.argv.remove('-local')
+    importdir = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]),
+                                             '../..'))
+else:
+    importdir = ''
+
+# TODO: add a flag for this
+testdir = ''
+
+def testit(importdir='', testdir='', exit_on_fail=False):
+    """Run all tests in testdir while importing from importdir."""
+    if importdir:
+        sys.path.insert(1, importdir)
+    if testdir:
+        sys.path.insert(1, testdir)
+    import os.path
+    import mpmath
+    print("mpmath imported from %s" % os.path.dirname(mpmath.__file__))
+    print("mpmath backend: %s" % mpmath.libmp.backend.BACKEND)
+    print("mpmath mp class: %s" % repr(mpmath.mp))
+    print("mpmath version: %s" % mpmath.__version__)
+    print("Python version: %s" % sys.version)
+    print("")
+    if "-py" in sys.argv:
+        sys.argv.remove('-py')
+        import py
+        py.test.cmdline.main()
+    else:
+        import glob
+        from timeit import default_timer as clock
+        modules = []
+        args = sys.argv[1:]
+        excluded = []
+        if '-skip' in args:
+            excluded = args[args.index('-skip')+1:]
+            args = args[:args.index('-skip')]
+        # search for tests in directory of this file if not otherwise specified
+        if not testdir:
+            pattern = os.path.dirname(sys.argv[0])
+        else:
+            pattern = testdir
+        if pattern:
+            pattern += '/'
+        pattern += 'test*.py'
+        # look for tests (respecting specified filter)
+        for f in glob.glob(pattern):
+            name = os.path.splitext(os.path.basename(f))[0]
+            # If run as a script, only run tests given as args, if any are given
+            if args and __name__ == "__main__":
+                ok = False
+                for arg in args:
+                    if arg in name:
+                        ok = True
+                        break
+                if not ok:
+                    continue
+            elif name in excluded:
+                continue
+            module = __import__(name)
+            priority = module.__dict__.get('priority', 100)
+            if priority == 666:
+                modules = [[priority, name, module]]
+                break
+            modules.append([priority, name, module])
+        # execute tests
+        modules.sort()
+        tstart = clock()
+        for priority, name, module in modules:
+            print(name)
+            for f in sorted(module.__dict__.keys()):
+                if f.startswith('test_'):
+                    if coverage and ('numpy' in f):
+                        continue
+                    sys.stdout.write("    " + f[5:].ljust(25) + " ")
+                    t1 = clock()
+                    try:
+                        module.__dict__[f]()
+                    except:
+                        etype, evalue, trb = sys.exc_info()
+                        if etype in (KeyboardInterrupt, SystemExit):
+                            raise
+                        print("")
+                        print("TEST FAILED!")
+                        print("")
+                        traceback.print_exc()
+                        if exit_on_fail:
+                            return
+                    t2 = clock()
+                    print("ok " + "       " + ("%.7f" % (t2-t1)) + " s")
+        tend = clock()
+        print("")
+        print("finished tests in " + ("%.2f" % (tend-tstart)) + " seconds")
+        # clean sys.path
+        if importdir:
+            sys.path.remove(importdir)
+        if testdir:
+            sys.path.remove(testdir)
+
+if __name__ == '__main__':
+    if profile:
+        import cProfile
+        cProfile.run("testit('%s', '%s')" % (importdir, testdir), sort=1)
+    elif coverage:
+        import trace
+        tracer = trace.Trace(ignoredirs=[sys.prefix, sys.exec_prefix],
+            trace=0, count=1)
+        tracer.run('testit(importdir, testdir)')
+        r = tracer.results()
+        r.write_results(show_missing=True, summary=True, coverdir="/tmp")
+    else:
+        testit(importdir, testdir)
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_basic_ops.py b/lib/python3.10/site-packages/mpmath/tests/test_basic_ops.py
new file mode 100644
index 0000000000000000000000000000000000000000..f577c7fa9f9734876b6767f6cc21144df305d82f
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_basic_ops.py
@@ -0,0 +1,451 @@
+import mpmath
+from mpmath import *
+from mpmath.libmp import *
+import random
+import sys
+
+try:
+    long = long
+except NameError:
+    long = int
+
+def test_type_compare():
+    assert mpf(2) == mpc(2,0)
+    assert mpf(0) == mpc(0)
+    assert mpf(2) != mpc(2, 0.00001)
+    assert mpf(2) == 2.0
+    assert mpf(2) != 3.0
+    assert mpf(2) == 2
+    assert mpf(2) != '2.0'
+    assert mpc(2) != '2.0'
+
+def test_add():
+    assert mpf(2.5) + mpf(3) == 5.5
+    assert mpf(2.5) + 3 == 5.5
+    assert mpf(2.5) + 3.0 == 5.5
+    assert 3 + mpf(2.5) == 5.5
+    assert 3.0 + mpf(2.5) == 5.5
+    assert (3+0j) + mpf(2.5) == 5.5
+    assert mpc(2.5) + mpf(3) == 5.5
+    assert mpc(2.5) + 3 == 5.5
+    assert mpc(2.5) + 3.0 == 5.5
+    assert mpc(2.5) + (3+0j) == 5.5
+    assert 3 + mpc(2.5) == 5.5
+    assert 3.0 + mpc(2.5) == 5.5
+    assert (3+0j) + mpc(2.5) == 5.5
+
+def test_sub():
+    assert mpf(2.5) - mpf(3) == -0.5
+    assert mpf(2.5) - 3 == -0.5
+    assert mpf(2.5) - 3.0 == -0.5
+    assert 3 - mpf(2.5) == 0.5
+    assert 3.0 - mpf(2.5) == 0.5
+    assert (3+0j) - mpf(2.5) == 0.5
+    assert mpc(2.5) - mpf(3) == -0.5
+    assert mpc(2.5) - 3 == -0.5
+    assert mpc(2.5) - 3.0 == -0.5
+    assert mpc(2.5) - (3+0j) == -0.5
+    assert 3 - mpc(2.5) == 0.5
+    assert 3.0 - mpc(2.5) == 0.5
+    assert (3+0j) - mpc(2.5) == 0.5
+
+def test_mul():
+    assert mpf(2.5) * mpf(3) == 7.5
+    assert mpf(2.5) * 3 == 7.5
+    assert mpf(2.5) * 3.0 == 7.5
+    assert 3 * mpf(2.5) == 7.5
+    assert 3.0 * mpf(2.5) == 7.5
+    assert (3+0j) * mpf(2.5) == 7.5
+    assert mpc(2.5) * mpf(3) == 7.5
+    assert mpc(2.5) * 3 == 7.5
+    assert mpc(2.5) * 3.0 == 7.5
+    assert mpc(2.5) * (3+0j) == 7.5
+    assert 3 * mpc(2.5) == 7.5
+    assert 3.0 * mpc(2.5) == 7.5
+    assert (3+0j) * mpc(2.5) == 7.5
+
+def test_div():
+    assert mpf(6) / mpf(3) == 2.0
+    assert mpf(6) / 3 == 2.0
+    assert mpf(6) / 3.0 == 2.0
+    assert 6 / mpf(3) == 2.0
+    assert 6.0 / mpf(3) == 2.0
+    assert (6+0j) / mpf(3.0) == 2.0
+    assert mpc(6) / mpf(3) == 2.0
+    assert mpc(6) / 3 == 2.0
+    assert mpc(6) / 3.0 == 2.0
+    assert mpc(6) / (3+0j) == 2.0
+    assert 6 / mpc(3) == 2.0
+    assert 6.0 / mpc(3) == 2.0
+    assert (6+0j) / mpc(3) == 2.0
+
+def test_pow():
+    assert mpf(6) ** mpf(3) == 216.0
+    assert mpf(6) ** 3 == 216.0
+    assert mpf(6) ** 3.0 == 216.0
+    assert 6 ** mpf(3) == 216.0
+    assert 6.0 ** mpf(3) == 216.0
+    assert (6+0j) ** mpf(3.0) == 216.0
+    assert mpc(6) ** mpf(3) == 216.0
+    assert mpc(6) ** 3 == 216.0
+    assert mpc(6) ** 3.0 == 216.0
+    assert mpc(6) ** (3+0j) == 216.0
+    assert 6 ** mpc(3) == 216.0
+    assert 6.0 ** mpc(3) == 216.0
+    assert (6+0j) ** mpc(3) == 216.0
+
+def test_mixed_misc():
+    assert 1 + mpf(3) == mpf(3) + 1 == 4
+    assert 1 - mpf(3) == -(mpf(3) - 1) == -2
+    assert 3 * mpf(2) == mpf(2) * 3 == 6
+    assert 6 / mpf(2) == mpf(6) / 2 == 3
+    assert 1.0 + mpf(3) == mpf(3) + 1.0 == 4
+    assert 1.0 - mpf(3) == -(mpf(3) - 1.0) == -2
+    assert 3.0 * mpf(2) == mpf(2) * 3.0 == 6
+    assert 6.0 / mpf(2) == mpf(6) / 2.0 == 3
+
+def test_add_misc():
+    mp.dps = 15
+    assert mpf(4) + mpf(-70) == -66
+    assert mpf(1) + mpf(1.1)/80 == 1 + 1.1/80
+    assert mpf((1, 10000000000)) + mpf(3) == mpf((1, 10000000000))
+    assert mpf(3) + mpf((1, 10000000000)) == mpf((1, 10000000000))
+    assert mpf((1, -10000000000)) + mpf(3) == mpf(3)
+    assert mpf(3) + mpf((1, -10000000000)) == mpf(3)
+    assert mpf(1) + 1e-15 != 1
+    assert mpf(1) + 1e-20 == 1
+    assert mpf(1.07e-22) + 0 == mpf(1.07e-22)
+    assert mpf(0) + mpf(1.07e-22) == mpf(1.07e-22)
+
+def test_complex_misc():
+    # many more tests needed
+    assert 1 + mpc(2) == 3
+    assert not mpc(2).ae(2 + 1e-13)
+    assert mpc(2+1e-15j).ae(2)
+
+def test_complex_zeros():
+    for a in [0,2]:
+        for b in [0,3]:
+            for c in [0,4]:
+                for d in [0,5]:
+                    assert mpc(a,b)*mpc(c,d) == complex(a,b)*complex(c,d)
+
+def test_hash():
+    for i in range(-256, 256):
+        assert hash(mpf(i)) == hash(i)
+    assert hash(mpf(0.5)) == hash(0.5)
+    assert hash(mpc(2,3)) == hash(2+3j)
+    # Check that this doesn't fail
+    assert hash(inf)
+    # Check that overflow doesn't assign equal hashes to large numbers
+    assert hash(mpf('1e1000')) != hash('1e10000')
+    assert hash(mpc(100,'1e1000')) != hash(mpc(200,'1e1000'))
+    from mpmath.rational import mpq
+    assert hash(mp.mpq(1,3))
+    assert hash(mp.mpq(0,1)) == 0
+    assert hash(mp.mpq(-1,1)) == hash(-1)
+    assert hash(mp.mpq(1,1)) == hash(1)
+    assert hash(mp.mpq(5,1)) == hash(5)
+    assert hash(mp.mpq(1,2)) == hash(0.5)
+    if sys.version_info >= (3, 2):
+        assert hash(mpf(1)*2**2000) == hash(2**2000)
+        assert hash(mpf(1)/2**2000) == hash(mpq(1,2**2000))
+
+# Advanced rounding test
+def test_add_rounding():
+    mp.dps = 15
+    a = from_float(1e-50)
+    assert mpf_sub(mpf_add(fone, a, 53, round_up), fone, 53, round_up) == from_float(2.2204460492503131e-16)
+    assert mpf_sub(fone, a, 53, round_up) == fone
+    assert mpf_sub(fone, mpf_sub(fone, a, 53, round_down), 53, round_down) == from_float(1.1102230246251565e-16)
+    assert mpf_add(fone, a, 53, round_down) == fone
+
+def test_almost_equal():
+    assert mpf(1.2).ae(mpf(1.20000001), 1e-7)
+    assert not mpf(1.2).ae(mpf(1.20000001), 1e-9)
+    assert not mpf(-0.7818314824680298).ae(mpf(-0.774695868667929))
+
+def test_arithmetic_functions():
+    import operator
+    ops = [(operator.add, fadd), (operator.sub, fsub), (operator.mul, fmul),
+        (operator.truediv, fdiv)]
+    a = mpf(0.27)
+    b = mpf(1.13)
+    c = mpc(0.51+2.16j)
+    d = mpc(1.08-0.99j)
+    for x in [a,b,c,d]:
+        for y in [a,b,c,d]:
+            for op, fop in ops:
+                if fop is not fdiv:
+                    mp.prec = 200
+                    z0 = op(x,y)
+                mp.prec = 60
+                z1 = op(x,y)
+                mp.prec = 53
+                z2 = op(x,y)
+                assert fop(x, y, prec=60) == z1
+                assert fop(x, y) == z2
+                if fop is not fdiv:
+                    assert fop(x, y, prec=inf) == z0
+                    assert fop(x, y, dps=inf) == z0
+                    assert fop(x, y, exact=True) == z0
+                assert fneg(fneg(z1, exact=True), prec=inf) == z1
+                assert fneg(z1) == -(+z1)
+    mp.dps = 15
+
+def test_exact_integer_arithmetic():
+    # XXX: re-fix this so that all operations are tested with all rounding modes
+    random.seed(0)
+    for prec in [6, 10, 25, 40, 100, 250, 725]:
+        for rounding in ['d', 'u', 'f', 'c', 'n']:
+            mp.dps = prec
+            M = 10**(prec-2)
+            M2 = 10**(prec//2-2)
+            for i in range(10):
+                a = random.randint(-M, M)
+                b = random.randint(-M, M)
+                assert mpf(a, rounding=rounding) == a
+                assert int(mpf(a, rounding=rounding)) == a
+                assert int(mpf(str(a), rounding=rounding)) == a
+                assert mpf(a) + mpf(b) == a + b
+                assert mpf(a) - mpf(b) == a - b
+                assert -mpf(a) == -a
+                a = random.randint(-M2, M2)
+                b = random.randint(-M2, M2)
+                assert mpf(a) * mpf(b) == a*b
+                assert mpf_mul(from_int(a), from_int(b), mp.prec, rounding) == from_int(a*b)
+    mp.dps = 15
+
+def test_odd_int_bug():
+    assert to_int(from_int(3), round_nearest) == 3
+
+def test_str_1000_digits():
+    mp.dps = 1001
+    # last digit may be wrong
+    assert str(mpf(2)**0.5)[-10:-1] == '9518488472'[:9]
+    assert str(pi)[-10:-1] == '2164201989'[:9]
+    mp.dps = 15
+
+def test_str_10000_digits():
+    mp.dps = 10001
+    # last digit may be wrong
+    assert str(mpf(2)**0.5)[-10:-1] == '5873258351'[:9]
+    assert str(pi)[-10:-1] == '5256375678'[:9]
+    mp.dps = 15
+
+def test_monitor():
+    f = lambda x: x**2
+    a = []
+    b = []
+    g = monitor(f, a.append, b.append)
+    assert g(3) == 9
+    assert g(4) == 16
+    assert a[0] == ((3,), {})
+    assert b[0] == 9
+
+def test_nint_distance():
+    assert nint_distance(mpf(-3)) == (-3, -inf)
+    assert nint_distance(mpc(-3)) == (-3, -inf)
+    assert nint_distance(mpf(-3.1)) == (-3, -3)
+    assert nint_distance(mpf(-3.01)) == (-3, -6)
+    assert nint_distance(mpf(-3.001)) == (-3, -9)
+    assert nint_distance(mpf(-3.0001)) == (-3, -13)
+    assert nint_distance(mpf(-2.9)) == (-3, -3)
+    assert nint_distance(mpf(-2.99)) == (-3, -6)
+    assert nint_distance(mpf(-2.999)) == (-3, -9)
+    assert nint_distance(mpf(-2.9999)) == (-3, -13)
+    assert nint_distance(mpc(-3+0.1j)) == (-3, -3)
+    assert nint_distance(mpc(-3+0.01j)) == (-3, -6)
+    assert nint_distance(mpc(-3.1+0.1j)) == (-3, -3)
+    assert nint_distance(mpc(-3.01+0.01j)) == (-3, -6)
+    assert nint_distance(mpc(-3.001+0.001j)) == (-3, -9)
+    assert nint_distance(mpf(0)) == (0, -inf)
+    assert nint_distance(mpf(0.01)) == (0, -6)
+    assert nint_distance(mpf('1e-100')) == (0, -332)
+
+def test_floor_ceil_nint_frac():
+    mp.dps = 15
+    for n in range(-10,10):
+        assert floor(n) == n
+        assert floor(n+0.5) == n
+        assert ceil(n) == n
+        assert ceil(n+0.5) == n+1
+        assert nint(n) == n
+        # nint rounds to even
+        if n % 2 == 1:
+            assert nint(n+0.5) == n+1
+        else:
+            assert nint(n+0.5) == n
+    assert floor(inf) == inf
+    assert floor(ninf) == ninf
+    assert isnan(floor(nan))
+    assert ceil(inf) == inf
+    assert ceil(ninf) == ninf
+    assert isnan(ceil(nan))
+    assert nint(inf) == inf
+    assert nint(ninf) == ninf
+    assert isnan(nint(nan))
+    assert floor(0.1) == 0
+    assert floor(0.9) == 0
+    assert floor(-0.1) == -1
+    assert floor(-0.9) == -1
+    assert floor(10000000000.1) == 10000000000
+    assert floor(10000000000.9) == 10000000000
+    assert floor(-10000000000.1) == -10000000000-1
+    assert floor(-10000000000.9) == -10000000000-1
+    assert floor(1e-100) == 0
+    assert floor(-1e-100) == -1
+    assert floor(1e100) == 1e100
+    assert floor(-1e100) == -1e100
+    assert ceil(0.1) == 1
+    assert ceil(0.9) == 1
+    assert ceil(-0.1) == 0
+    assert ceil(-0.9) == 0
+    assert ceil(10000000000.1) == 10000000000+1
+    assert ceil(10000000000.9) == 10000000000+1
+    assert ceil(-10000000000.1) == -10000000000
+    assert ceil(-10000000000.9) == -10000000000
+    assert ceil(1e-100) == 1
+    assert ceil(-1e-100) == 0
+    assert ceil(1e100) == 1e100
+    assert ceil(-1e100) == -1e100
+    assert nint(0.1) == 0
+    assert nint(0.9) == 1
+    assert nint(-0.1) == 0
+    assert nint(-0.9) == -1
+    assert nint(10000000000.1) == 10000000000
+    assert nint(10000000000.9) == 10000000000+1
+    assert nint(-10000000000.1) == -10000000000
+    assert nint(-10000000000.9) == -10000000000-1
+    assert nint(1e-100) == 0
+    assert nint(-1e-100) == 0
+    assert nint(1e100) == 1e100
+    assert nint(-1e100) == -1e100
+    assert floor(3.2+4.6j) == 3+4j
+    assert ceil(3.2+4.6j) == 4+5j
+    assert nint(3.2+4.6j) == 3+5j
+    for n in range(-10,10):
+        assert frac(n) == 0
+    assert frac(0.25) == 0.25
+    assert frac(1.25) == 0.25
+    assert frac(2.25) == 0.25
+    assert frac(-0.25) == 0.75
+    assert frac(-1.25) == 0.75
+    assert frac(-2.25) == 0.75
+    assert frac('1e100000000000000') == 0
+    u = mpf('1e-100000000000000')
+    assert frac(u) == u
+    assert frac(-u) == 1  # rounding!
+    u = mpf('1e-400')
+    assert frac(-u, prec=0) == fsub(1, u, exact=True)
+    assert frac(3.25+4.75j) == 0.25+0.75j
+
+def test_isnan_etc():
+    from mpmath.rational import mpq
+    assert isnan(nan) == True
+    assert isnan(3) == False
+    assert isnan(mpf(3)) == False
+    assert isnan(inf) == False
+    assert isnan(mpc(2,nan)) == True
+    assert isnan(mpc(2,nan)) == True
+    assert isnan(mpc(nan,nan)) == True
+    assert isnan(mpc(2,2)) == False
+    assert isnan(mpc(nan,inf)) == True
+    assert isnan(mpc(inf,inf)) == False
+    assert isnan(mpq((3,2))) == False
+    assert isnan(mpq((0,1))) == False
+    assert isinf(inf) == True
+    assert isinf(-inf) == True
+    assert isinf(3) == False
+    assert isinf(nan) == False
+    assert isinf(3+4j) == False
+    assert isinf(mpc(inf)) == True
+    assert isinf(mpc(3,inf)) == True
+    assert isinf(mpc(inf,3)) == True
+    assert isinf(mpc(inf,inf)) == True
+    assert isinf(mpc(nan,inf)) == True
+    assert isinf(mpc(inf,nan)) == True
+    assert isinf(mpc(nan,nan)) == False
+    assert isinf(mpq((3,2))) == False
+    assert isinf(mpq((0,1))) == False
+    assert isnormal(3) == True
+    assert isnormal(3.5) == True
+    assert isnormal(mpf(3.5)) == True
+    assert isnormal(0) == False
+    assert isnormal(mpf(0)) == False
+    assert isnormal(0.0) == False
+    assert isnormal(inf) == False
+    assert isnormal(-inf) == False
+    assert isnormal(nan) == False
+    assert isnormal(float(inf)) == False
+    assert isnormal(mpc(0,0)) == False
+    assert isnormal(mpc(3,0)) == True
+    assert isnormal(mpc(0,3)) == True
+    assert isnormal(mpc(3,3)) == True
+    assert isnormal(mpc(0,nan)) == False
+    assert isnormal(mpc(0,inf)) == False
+    assert isnormal(mpc(3,nan)) == False
+    assert isnormal(mpc(3,inf)) == False
+    assert isnormal(mpc(3,-inf)) == False
+    assert isnormal(mpc(nan,0)) == False
+    assert isnormal(mpc(inf,0)) == False
+    assert isnormal(mpc(nan,3)) == False
+    assert isnormal(mpc(inf,3)) == False
+    assert isnormal(mpc(inf,nan)) == False
+    assert isnormal(mpc(nan,inf)) == False
+    assert isnormal(mpc(nan,nan)) == False
+    assert isnormal(mpc(inf,inf)) == False
+    assert isnormal(mpq((3,2))) == True
+    assert isnormal(mpq((0,1))) == False
+    assert isint(3) == True
+    assert isint(0) == True
+    assert isint(long(3)) == True
+    assert isint(long(0)) == True
+    assert isint(mpf(3)) == True
+    assert isint(mpf(0)) == True
+    assert isint(mpf(-3)) == True
+    assert isint(mpf(3.2)) == False
+    assert isint(3.2) == False
+    assert isint(nan) == False
+    assert isint(inf) == False
+    assert isint(-inf) == False
+    assert isint(mpc(0)) == True
+    assert isint(mpc(3)) == True
+    assert isint(mpc(3.2)) == False
+    assert isint(mpc(3,inf)) == False
+    assert isint(mpc(inf)) == False
+    assert isint(mpc(3,2)) == False
+    assert isint(mpc(0,2)) == False
+    assert isint(mpc(3,2),gaussian=True) == True
+    assert isint(mpc(3,0),gaussian=True) == True
+    assert isint(mpc(0,3),gaussian=True) == True
+    assert isint(3+4j) == False
+    assert isint(3+4j, gaussian=True) == True
+    assert isint(3+0j) == True
+    assert isint(mpq((3,2))) == False
+    assert isint(mpq((3,9))) == False
+    assert isint(mpq((9,3))) == True
+    assert isint(mpq((0,4))) == True
+    assert isint(mpq((1,1))) == True
+    assert isint(mpq((-1,1))) == True
+    assert mp.isnpint(0) == True
+    assert mp.isnpint(1) == False
+    assert mp.isnpint(-1) == True
+    assert mp.isnpint(-1.1) == False
+    assert mp.isnpint(-1.0) == True
+    assert mp.isnpint(mp.mpq(1,2)) == False
+    assert mp.isnpint(mp.mpq(-1,2)) == False
+    assert mp.isnpint(mp.mpq(-3,1)) == True
+    assert mp.isnpint(mp.mpq(0,1)) == True
+    assert mp.isnpint(mp.mpq(1,1)) == False
+    assert mp.isnpint(0+0j) == True
+    assert mp.isnpint(-1+0j) == True
+    assert mp.isnpint(-1.1+0j) == False
+    assert mp.isnpint(-1+0.1j) == False
+    assert mp.isnpint(0+0.1j) == False
+
+
+def test_issue_438():
+    assert mpf(finf) == mpf('inf')
+    assert mpf(fninf) == mpf('-inf')
+    assert mpf(fnan)._mpf_ == mpf('nan')._mpf_
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_bitwise.py b/lib/python3.10/site-packages/mpmath/tests/test_bitwise.py
new file mode 100644
index 0000000000000000000000000000000000000000..4f61b69fc8819cf275abaedd98847c58c3b5924a
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_bitwise.py
@@ -0,0 +1,188 @@
+"""
+Test bit-level integer and mpf operations
+"""
+
+from mpmath import *
+from mpmath.libmp import *
+
+def test_bitcount():
+    assert bitcount(0) == 0
+    assert bitcount(1) == 1
+    assert bitcount(7) == 3
+    assert bitcount(8) == 4
+    assert bitcount(2**100) == 101
+    assert bitcount(2**100-1) == 100
+
+def test_trailing():
+    assert trailing(0) == 0
+    assert trailing(1) == 0
+    assert trailing(2) == 1
+    assert trailing(7) == 0
+    assert trailing(8) == 3
+    assert trailing(2**100) == 100
+    assert trailing(2**100-1) == 0
+
+def test_round_down():
+    assert from_man_exp(0, -4, 4, round_down)[:3] == (0, 0, 0)
+    assert from_man_exp(0xf0, -4, 4, round_down)[:3] == (0, 15, 0)
+    assert from_man_exp(0xf1, -4, 4, round_down)[:3] == (0, 15, 0)
+    assert from_man_exp(0xff, -4, 4, round_down)[:3] == (0, 15, 0)
+    assert from_man_exp(-0xf0, -4, 4, round_down)[:3] == (1, 15, 0)
+    assert from_man_exp(-0xf1, -4, 4, round_down)[:3] == (1, 15, 0)
+    assert from_man_exp(-0xff, -4, 4, round_down)[:3] == (1, 15, 0)
+
+def test_round_up():
+    assert from_man_exp(0, -4, 4, round_up)[:3] == (0, 0, 0)
+    assert from_man_exp(0xf0, -4, 4, round_up)[:3] == (0, 15, 0)
+    assert from_man_exp(0xf1, -4, 4, round_up)[:3] == (0, 1, 4)
+    assert from_man_exp(0xff, -4, 4, round_up)[:3] == (0, 1, 4)
+    assert from_man_exp(-0xf0, -4, 4, round_up)[:3] == (1, 15, 0)
+    assert from_man_exp(-0xf1, -4, 4, round_up)[:3] == (1, 1, 4)
+    assert from_man_exp(-0xff, -4, 4, round_up)[:3] == (1, 1, 4)
+
+def test_round_floor():
+    assert from_man_exp(0, -4, 4, round_floor)[:3] == (0, 0, 0)
+    assert from_man_exp(0xf0, -4, 4, round_floor)[:3] == (0, 15, 0)
+    assert from_man_exp(0xf1, -4, 4, round_floor)[:3] == (0, 15, 0)
+    assert from_man_exp(0xff, -4, 4, round_floor)[:3] == (0, 15, 0)
+    assert from_man_exp(-0xf0, -4, 4, round_floor)[:3] == (1, 15, 0)
+    assert from_man_exp(-0xf1, -4, 4, round_floor)[:3] == (1, 1, 4)
+    assert from_man_exp(-0xff, -4, 4, round_floor)[:3] == (1, 1, 4)
+
+def test_round_ceiling():
+    assert from_man_exp(0, -4, 4, round_ceiling)[:3] == (0, 0, 0)
+    assert from_man_exp(0xf0, -4, 4, round_ceiling)[:3] == (0, 15, 0)
+    assert from_man_exp(0xf1, -4, 4, round_ceiling)[:3] == (0, 1, 4)
+    assert from_man_exp(0xff, -4, 4, round_ceiling)[:3] == (0, 1, 4)
+    assert from_man_exp(-0xf0, -4, 4, round_ceiling)[:3] == (1, 15, 0)
+    assert from_man_exp(-0xf1, -4, 4, round_ceiling)[:3] == (1, 15, 0)
+    assert from_man_exp(-0xff, -4, 4, round_ceiling)[:3] == (1, 15, 0)
+
+def test_round_nearest():
+    assert from_man_exp(0, -4, 4, round_nearest)[:3] == (0, 0, 0)
+    assert from_man_exp(0xf0, -4, 4, round_nearest)[:3] == (0, 15, 0)
+    assert from_man_exp(0xf7, -4, 4, round_nearest)[:3] == (0, 15, 0)
+    assert from_man_exp(0xf8, -4, 4, round_nearest)[:3] == (0, 1, 4)    # 1111.1000 -> 10000.0
+    assert from_man_exp(0xf9, -4, 4, round_nearest)[:3] == (0, 1, 4)    # 1111.1001 -> 10000.0
+    assert from_man_exp(0xe8, -4, 4, round_nearest)[:3] == (0, 7, 1)    # 1110.1000 -> 1110.0
+    assert from_man_exp(0xe9, -4, 4, round_nearest)[:3] == (0, 15, 0)     # 1110.1001 -> 1111.0
+    assert from_man_exp(-0xf0, -4, 4, round_nearest)[:3] == (1, 15, 0)
+    assert from_man_exp(-0xf7, -4, 4, round_nearest)[:3] == (1, 15, 0)
+    assert from_man_exp(-0xf8, -4, 4, round_nearest)[:3] == (1, 1, 4)
+    assert from_man_exp(-0xf9, -4, 4, round_nearest)[:3] == (1, 1, 4)
+    assert from_man_exp(-0xe8, -4, 4, round_nearest)[:3] == (1, 7, 1)
+    assert from_man_exp(-0xe9, -4, 4, round_nearest)[:3] == (1, 15, 0)
+
+def test_rounding_bugs():
+    # 1 less than power-of-two cases
+    assert from_man_exp(72057594037927935, -56, 53, round_up) == (0, 1, 0, 1)
+    assert from_man_exp(73786976294838205979, -65, 53, round_nearest) == (0, 1, 1, 1)
+    assert from_man_exp(31, 0, 4, round_up) == (0, 1, 5, 1)
+    assert from_man_exp(-31, 0, 4, round_floor) == (1, 1, 5, 1)
+    assert from_man_exp(255, 0, 7, round_up) == (0, 1, 8, 1)
+    assert from_man_exp(-255, 0, 7, round_floor) == (1, 1, 8, 1)
+
+def test_rounding_issue_200():
+    a = from_man_exp(9867,-100)
+    b = from_man_exp(9867,-200)
+    c = from_man_exp(-1,0)
+    z = (1, 1023, -10, 10)
+    assert mpf_add(a, c, 10, 'd') == z
+    assert mpf_add(b, c, 10, 'd') == z
+    assert mpf_add(c, a, 10, 'd') == z
+    assert mpf_add(c, b, 10, 'd') == z
+
+def test_perturb():
+    a = fone
+    b = from_float(0.99999999999999989)
+    c = from_float(1.0000000000000002)
+    assert mpf_perturb(a, 0, 53, round_nearest) == a
+    assert mpf_perturb(a, 1, 53, round_nearest) == a
+    assert mpf_perturb(a, 0, 53, round_up) == c
+    assert mpf_perturb(a, 0, 53, round_ceiling) == c
+    assert mpf_perturb(a, 0, 53, round_down) == a
+    assert mpf_perturb(a, 0, 53, round_floor) == a
+    assert mpf_perturb(a, 1, 53, round_up) == a
+    assert mpf_perturb(a, 1, 53, round_ceiling) == a
+    assert mpf_perturb(a, 1, 53, round_down) == b
+    assert mpf_perturb(a, 1, 53, round_floor) == b
+    a = mpf_neg(a)
+    b = mpf_neg(b)
+    c = mpf_neg(c)
+    assert mpf_perturb(a, 0, 53, round_nearest) == a
+    assert mpf_perturb(a, 1, 53, round_nearest) == a
+    assert mpf_perturb(a, 0, 53, round_up) == a
+    assert mpf_perturb(a, 0, 53, round_floor) == a
+    assert mpf_perturb(a, 0, 53, round_down) == b
+    assert mpf_perturb(a, 0, 53, round_ceiling) == b
+    assert mpf_perturb(a, 1, 53, round_up) == c
+    assert mpf_perturb(a, 1, 53, round_floor) == c
+    assert mpf_perturb(a, 1, 53, round_down) == a
+    assert mpf_perturb(a, 1, 53, round_ceiling) == a
+
+def test_add_exact():
+    ff = from_float
+    assert mpf_add(ff(3.0), ff(2.5)) == ff(5.5)
+    assert mpf_add(ff(3.0), ff(-2.5)) == ff(0.5)
+    assert mpf_add(ff(-3.0), ff(2.5)) == ff(-0.5)
+    assert mpf_add(ff(-3.0), ff(-2.5)) == ff(-5.5)
+    assert mpf_sub(mpf_add(fone, ff(1e-100)), fone) == ff(1e-100)
+    assert mpf_sub(mpf_add(ff(1e-100), fone), fone) == ff(1e-100)
+    assert mpf_sub(mpf_add(fone, ff(-1e-100)), fone) == ff(-1e-100)
+    assert mpf_sub(mpf_add(ff(-1e-100), fone), fone) == ff(-1e-100)
+    assert mpf_add(fone, fzero) == fone
+    assert mpf_add(fzero, fone) == fone
+    assert mpf_add(fzero, fzero) == fzero
+
+def test_long_exponent_shifts():
+    mp.dps = 15
+    # Check for possible bugs due to exponent arithmetic overflow
+    # in a C implementation
+    x = mpf(1)
+    for p in [32, 64]:
+        a = ldexp(1,2**(p-1))
+        b = ldexp(1,2**p)
+        c = ldexp(1,2**(p+1))
+        d = ldexp(1,-2**(p-1))
+        e = ldexp(1,-2**p)
+        f = ldexp(1,-2**(p+1))
+        assert (x+a) == a
+        assert (x+b) == b
+        assert (x+c) == c
+        assert (x+d) == x
+        assert (x+e) == x
+        assert (x+f) == x
+        assert (a+x) == a
+        assert (b+x) == b
+        assert (c+x) == c
+        assert (d+x) == x
+        assert (e+x) == x
+        assert (f+x) == x
+        assert (x-a) == -a
+        assert (x-b) == -b
+        assert (x-c) == -c
+        assert (x-d) == x
+        assert (x-e) == x
+        assert (x-f) == x
+        assert (a-x) == a
+        assert (b-x) == b
+        assert (c-x) == c
+        assert (d-x) == -x
+        assert (e-x) == -x
+        assert (f-x) == -x
+
+def test_float_rounding():
+    mp.prec = 64
+    for x in [mpf(1), mpf(1)+eps, mpf(1)-eps, -mpf(1)+eps, -mpf(1)-eps]:
+        fa = float(x)
+        fb = float(fadd(x,0,prec=53,rounding='n'))
+        assert fa == fb
+        z = mpc(x,x)
+        ca = complex(z)
+        cb = complex(fadd(z,0,prec=53,rounding='n'))
+        assert ca == cb
+        for rnd in ['n', 'd', 'u', 'f', 'c']:
+            fa = to_float(x._mpf_, rnd=rnd)
+            fb = to_float(fadd(x,0,prec=53,rounding=rnd)._mpf_, rnd=rnd)
+            assert fa == fb
+    mp.prec = 53
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_calculus.py b/lib/python3.10/site-packages/mpmath/tests/test_calculus.py
new file mode 100644
index 0000000000000000000000000000000000000000..f0a59773d672f0db20bb5072773472a5a3cc1d1f
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_calculus.py
@@ -0,0 +1,216 @@
+import pytest
+from mpmath import *
+
+def test_approximation():
+    mp.dps = 15
+    f = lambda x: cos(2-2*x)/x
+    p, err = chebyfit(f, [2, 4], 8, error=True)
+    assert err < 1e-5
+    for i in range(10):
+        x = 2 + i/5.
+        assert abs(polyval(p, x) - f(x)) < err
+
+def test_limits():
+    mp.dps = 15
+    assert limit(lambda x: (x-sin(x))/x**3, 0).ae(mpf(1)/6)
+    assert limit(lambda n: (1+1/n)**n, inf).ae(e)
+
+def test_polyval():
+    assert polyval([], 3) == 0
+    assert polyval([0], 3) == 0
+    assert polyval([5], 3) == 5
+    # 4x^3 - 2x + 5
+    p = [4, 0, -2, 5]
+    assert polyval(p,4) == 253
+    assert polyval(p,4,derivative=True) == (253, 190)
+
+def test_polyroots():
+    p = polyroots([1,-4])
+    assert p[0].ae(4)
+    p, q = polyroots([1,2,3])
+    assert p.ae(-1 - sqrt(2)*j)
+    assert q.ae(-1 + sqrt(2)*j)
+    #this is not a real test, it only tests a specific case
+    assert polyroots([1]) == []
+    pytest.raises(ValueError, lambda: polyroots([0]))
+
+def test_polyroots_legendre():
+    n = 64
+    coeffs = [11975573020964041433067793888190275875, 0,
+        -190100434726484311252477736051902332000, 0,
+        1437919688271127330313741595496589239248, 0,
+        -6897338342113537600691931230430793911840, 0,
+        23556405536185284408974715545252277554280, 0,
+        -60969520211303089058522793175947071316960, 0,
+        124284021969194758465450309166353645376880, 0,
+        -204721258548015217049921875719981284186016, 0,
+        277415422258095841688223780704620656114900, 0,
+        -313237834141273382807123548182995095192800, 0,
+        297432255354328395601259515935229287637200, 0,
+        -239057700565161140389797367947941296605600, 0,
+        163356095386193445933028201431093219347160, 0,
+        -95158890516229191805647495979277603503200, 0,
+        47310254620162038075933656063247634556400, 0,
+        -20071017111583894941305187420771723751200, 0,
+        7255051932731034189479516844750603752850, 0,
+        -2228176940331017311443863996901733412640, 0,
+        579006552594977616773047095969088431600, 0,
+        -126584428502545713788439446082310831200, 0,
+        23112325428835593809686977515028663000, 0,
+        -3491517141958743235617737161547844000, 0,
+        431305058712550634988073414073557200, 0,
+        -42927166660756742088912492757452000, 0,
+        3378527005707706553294038781836500, 0,
+        -205277590220215081719131470288800, 0,
+        9330799555464321896324157740400, 0,
+        -304114948474392713657972548576, 0,
+        6695289961520387531608984680, 0,
+        -91048139350447232095702560, 0,
+        659769125727878493447120, 0,
+        -1905929106580294155360, 0,
+        916312070471295267]
+
+    with mp.workdps(3):
+        with pytest.raises(mp.NoConvergence):
+            polyroots(coeffs, maxsteps=5, cleanup=True, error=False,
+                      extraprec=n*10)
+
+        roots = polyroots(coeffs, maxsteps=50, cleanup=True, error=False,
+                    extraprec=n*10)
+        roots = [str(r) for r in roots]
+        assert roots == \
+            ['-0.999', '-0.996', '-0.991', '-0.983', '-0.973', '-0.961',
+            '-0.946', '-0.93', '-0.911', '-0.889', '-0.866', '-0.841',
+            '-0.813', '-0.784', '-0.753', '-0.72', '-0.685', '-0.649',
+            '-0.611', '-0.572', '-0.531', '-0.489', '-0.446', '-0.402',
+            '-0.357', '-0.311', '-0.265', '-0.217', '-0.17', '-0.121',
+            '-0.073', '-0.0243', '0.0243', '0.073', '0.121', '0.17', '0.217',
+            '0.265', '0.311', '0.357', '0.402', '0.446', '0.489', '0.531',
+            '0.572', '0.611', '0.649', '0.685', '0.72', '0.753', '0.784',
+            '0.813', '0.841', '0.866', '0.889', '0.911', '0.93', '0.946',
+            '0.961', '0.973', '0.983', '0.991', '0.996', '0.999']
+
+def test_polyroots_legendre_init():
+    extra_prec = 100
+    coeffs = [11975573020964041433067793888190275875, 0,
+        -190100434726484311252477736051902332000, 0,
+        1437919688271127330313741595496589239248, 0,
+        -6897338342113537600691931230430793911840, 0,
+        23556405536185284408974715545252277554280, 0,
+        -60969520211303089058522793175947071316960, 0,
+        124284021969194758465450309166353645376880, 0,
+        -204721258548015217049921875719981284186016, 0,
+        277415422258095841688223780704620656114900, 0,
+        -313237834141273382807123548182995095192800, 0,
+        297432255354328395601259515935229287637200, 0,
+        -239057700565161140389797367947941296605600, 0,
+        163356095386193445933028201431093219347160, 0,
+        -95158890516229191805647495979277603503200, 0,
+        47310254620162038075933656063247634556400, 0,
+        -20071017111583894941305187420771723751200, 0,
+        7255051932731034189479516844750603752850, 0,
+        -2228176940331017311443863996901733412640, 0,
+        579006552594977616773047095969088431600, 0,
+        -126584428502545713788439446082310831200, 0,
+        23112325428835593809686977515028663000, 0,
+        -3491517141958743235617737161547844000, 0,
+        431305058712550634988073414073557200, 0,
+        -42927166660756742088912492757452000, 0,
+        3378527005707706553294038781836500, 0,
+        -205277590220215081719131470288800, 0,
+        9330799555464321896324157740400, 0,
+        -304114948474392713657972548576, 0,
+        6695289961520387531608984680, 0,
+        -91048139350447232095702560, 0,
+        659769125727878493447120, 0,
+        -1905929106580294155360, 0,
+        916312070471295267]
+
+    roots_init =  matrix(['-0.999', '-0.996',  '-0.991', '-0.983', '-0.973',
+                          '-0.961', '-0.946',  '-0.93',  '-0.911', '-0.889',
+                          '-0.866', '-0.841',  '-0.813', '-0.784', '-0.753',
+                          '-0.72',  '-0.685',  '-0.649', '-0.611', '-0.572',
+                          '-0.531', '-0.489',  '-0.446', '-0.402', '-0.357',
+                          '-0.311', '-0.265',  '-0.217', '-0.17',  '-0.121',
+                          '-0.073', '-0.0243',  '0.0243', '0.073',  '0.121',
+                          '0.17',    '0.217',   '0.265', ' 0.311',  '0.357',
+                          '0.402',   '0.446',   '0.489',  '0.531',  '0.572',
+                          '0.611',   '0.649',   '0.685',  '0.72',   '0.753',
+                          '0.784',   '0.813',   '0.841',  '0.866',  '0.889',
+                          '0.911',   '0.93',    '0.946',  '0.961',  '0.973',
+                          '0.983',   '0.991',   '0.996',  '0.999',  '1.0'])
+    with mp.workdps(2*mp.dps):
+        roots_exact = polyroots(coeffs, maxsteps=50, cleanup=True, error=False,
+                                extraprec=2*extra_prec)
+    with pytest.raises(mp.NoConvergence):
+        polyroots(coeffs, maxsteps=5, cleanup=True, error=False,
+                  extraprec=extra_prec)
+    roots,err = polyroots(coeffs, maxsteps=5, cleanup=True, error=True,
+                          extraprec=extra_prec,roots_init=roots_init)
+    assert max(matrix(roots_exact)-matrix(roots).apply(abs)) < err
+    roots1,err1 = polyroots(coeffs, maxsteps=25, cleanup=True, error=True,
+                            extraprec=extra_prec,roots_init=roots_init[:60])
+    assert max(matrix(roots_exact)-matrix(roots1).apply(abs)) < err1
+
+def test_pade():
+    one = mpf(1)
+    mp.dps = 20
+    N = 10
+    a = [one]
+    k = 1
+    for i in range(1, N+1):
+        k *= i
+        a.append(one/k)
+    p, q = pade(a, N//2, N//2)
+    for x in arange(0, 1, 0.1):
+        r = polyval(p[::-1], x)/polyval(q[::-1], x)
+        assert(r.ae(exp(x), 1.0e-10))
+    mp.dps = 15
+
+def test_fourier():
+    mp.dps = 15
+    c, s = fourier(lambda x: x+1, [-1, 2], 2)
+    #plot([lambda x: x+1, lambda x: fourierval((c, s), [-1, 2], x)], [-1, 2])
+    assert c[0].ae(1.5)
+    assert c[1].ae(-3*sqrt(3)/(2*pi))
+    assert c[2].ae(3*sqrt(3)/(4*pi))
+    assert s[0] == 0
+    assert s[1].ae(3/(2*pi))
+    assert s[2].ae(3/(4*pi))
+    assert fourierval((c, s), [-1, 2], 1).ae(1.9134966715663442)
+
+def test_differint():
+    mp.dps = 15
+    assert differint(lambda t: t, 2, -0.5).ae(8*sqrt(2/pi)/3)
+
+def test_invlap():
+    mp.dps = 15
+    t = 0.01
+    fp = lambda p: 1/(p+1)**2
+    ft = lambda t: t*exp(-t)
+    ftt = ft(t)
+    assert invertlaplace(fp,t,method='talbot').ae(ftt)
+    assert invertlaplace(fp,t,method='stehfest').ae(ftt)
+    assert invertlaplace(fp,t,method='dehoog').ae(ftt)
+    assert invertlaplace(fp,t,method='cohen').ae(ftt)
+    t = 1.0
+    ftt = ft(t)
+    assert invertlaplace(fp,t,method='talbot').ae(ftt)
+    assert invertlaplace(fp,t,method='stehfest').ae(ftt)
+    assert invertlaplace(fp,t,method='dehoog').ae(ftt)
+    assert invertlaplace(fp,t,method='cohen').ae(ftt)
+
+    t = 0.01
+    fp = lambda p: log(p)/p
+    ft = lambda t: -euler-log(t)
+    ftt = ft(t)
+    assert invertlaplace(fp,t,method='talbot').ae(ftt)
+    assert invertlaplace(fp,t,method='stehfest').ae(ftt)
+    assert invertlaplace(fp,t,method='dehoog').ae(ftt)
+    assert invertlaplace(fp,t,method='cohen').ae(ftt)
+    t = 1.0
+    ftt = ft(t)
+    assert invertlaplace(fp,t,method='talbot').ae(ftt)
+    assert invertlaplace(fp,t,method='stehfest').ae(ftt)
+    assert invertlaplace(fp,t,method='dehoog').ae(ftt)
+    assert invertlaplace(fp,t,method='cohen').ae(ftt)
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_compatibility.py b/lib/python3.10/site-packages/mpmath/tests/test_compatibility.py
new file mode 100644
index 0000000000000000000000000000000000000000..f26d6044b521306b6d1eaeadc5c7839be226dc54
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_compatibility.py
@@ -0,0 +1,77 @@
+from mpmath import *
+from random import seed, randint, random
+import math
+
+# Test compatibility with Python floats, which are
+# IEEE doubles (53-bit)
+
+N = 5000
+seed(1)
+
+# Choosing exponents between roughly -140, 140 ensures that
+# the Python floats don't overflow or underflow
+xs = [(random()-1) * 10**randint(-140, 140) for x in range(N)]
+ys = [(random()-1) * 10**randint(-140, 140) for x in range(N)]
+
+# include some equal values
+ys[int(N*0.8):] = xs[int(N*0.8):]
+
+# Detect whether Python is compiled to use 80-bit floating-point
+# instructions, in which case the double compatibility test breaks
+uses_x87 = -4.1974624032366689e+117 / -8.4657370748010221e-47 \
+    == 4.9581771393902231e+163
+
+def test_double_compatibility():
+    mp.prec = 53
+    for x, y in zip(xs, ys):
+        mpx = mpf(x)
+        mpy = mpf(y)
+        assert mpf(x) == x
+        assert (mpx < mpy) == (x < y)
+        assert (mpx > mpy) == (x > y)
+        assert (mpx == mpy) == (x == y)
+        assert (mpx != mpy) == (x != y)
+        assert (mpx <= mpy) == (x <= y)
+        assert (mpx >= mpy) == (x >= y)
+        assert mpx == mpx
+        if uses_x87:
+            mp.prec = 64
+            a = mpx + mpy
+            b = mpx * mpy
+            c = mpx / mpy
+            d = mpx % mpy
+            mp.prec = 53
+            assert +a == x + y
+            assert +b == x * y
+            assert +c == x / y
+            assert +d == x % y
+        else:
+            assert mpx + mpy == x + y
+            assert mpx * mpy == x * y
+            assert mpx / mpy == x / y
+            assert mpx % mpy == x % y
+        assert abs(mpx) == abs(x)
+        assert mpf(repr(x)) == x
+        assert ceil(mpx) == math.ceil(x)
+        assert floor(mpx) == math.floor(x)
+
+def test_sqrt():
+    # this fails quite often. it appers to be float
+    # that rounds the wrong way, not mpf
+    fail = 0
+    mp.prec = 53
+    for x in xs:
+        x = abs(x)
+        mp.prec = 100
+        mp_high = mpf(x)**0.5
+        mp.prec = 53
+        mp_low = mpf(x)**0.5
+        fp = x**0.5
+        assert abs(mp_low-mp_high) <= abs(fp-mp_high)
+        fail += mp_low != fp
+    assert fail < N/10
+
+def test_bugs():
+    # particular bugs
+    assert mpf(4.4408920985006262E-16) < mpf(1.7763568394002505E-15)
+    assert mpf(-4.4408920985006262E-16) > mpf(-1.7763568394002505E-15)
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_convert.py b/lib/python3.10/site-packages/mpmath/tests/test_convert.py
new file mode 100644
index 0000000000000000000000000000000000000000..cb1db5b55c89e980e08fc3fa43cc9715ad68cac9
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_convert.py
@@ -0,0 +1,233 @@
+import random
+from mpmath import *
+from mpmath.libmp import *
+
+
+def test_basic_string():
+    """
+    Test basic string conversion
+    """
+    mp.dps = 15
+    assert mpf('3') == mpf('3.0') == mpf('0003.') == mpf('0.03e2') == mpf(3.0)
+    assert mpf('30') == mpf('30.0') == mpf('00030.') == mpf(30.0)
+    for i in range(10):
+        for j in range(10):
+            assert mpf('%ie%i' % (i,j)) == i * 10**j
+    assert str(mpf('25000.0')) == '25000.0'
+    assert str(mpf('2500.0')) == '2500.0'
+    assert str(mpf('250.0')) == '250.0'
+    assert str(mpf('25.0')) == '25.0'
+    assert str(mpf('2.5')) == '2.5'
+    assert str(mpf('0.25')) == '0.25'
+    assert str(mpf('0.025')) == '0.025'
+    assert str(mpf('0.0025')) == '0.0025'
+    assert str(mpf('0.00025')) == '0.00025'
+    assert str(mpf('0.000025')) == '2.5e-5'
+    assert str(mpf(0)) == '0.0'
+    assert str(mpf('2.5e1000000000000000000000')) == '2.5e+1000000000000000000000'
+    assert str(mpf('2.6e-1000000000000000000000')) == '2.6e-1000000000000000000000'
+    assert str(mpf(1.23402834e-15)) == '1.23402834e-15'
+    assert str(mpf(-1.23402834e-15)) == '-1.23402834e-15'
+    assert str(mpf(-1.2344e-15)) == '-1.2344e-15'
+    assert repr(mpf(-1.2344e-15)) == "mpf('-1.2343999999999999e-15')"
+    assert str(mpf("2163048125L")) == '2163048125.0'
+    assert str(mpf("-2163048125l")) == '-2163048125.0'
+    assert str(mpf("-2163048125L/1088391168")) == '-1.98738118113799'
+    assert str(mpf("2163048125/1088391168l")) == '1.98738118113799'
+
+def test_pretty():
+    mp.pretty = True
+    assert repr(mpf(2.5)) == '2.5'
+    assert repr(mpc(2.5,3.5)) == '(2.5 + 3.5j)'
+    mp.pretty = False
+    iv.pretty = True
+    assert repr(mpi(2.5,3.5)) == '[2.5, 3.5]'
+    iv.pretty = False
+
+def test_str_whitespace():
+    assert mpf('1.26 ') == 1.26
+
+def test_unicode():
+    mp.dps = 15
+    try:
+        unicode = unicode
+    except NameError:
+        unicode = str
+    assert mpf(unicode('2.76')) == 2.76
+    assert mpf(unicode('inf')) == inf
+
+def test_str_format():
+    assert to_str(from_float(0.1),15,strip_zeros=False) == '0.100000000000000'
+    assert to_str(from_float(0.0),15,show_zero_exponent=True) == '0.0e+0'
+    assert to_str(from_float(0.0),0,show_zero_exponent=True) == '.0e+0'
+    assert to_str(from_float(0.0),0,show_zero_exponent=False) == '.0'
+    assert to_str(from_float(0.0),1,show_zero_exponent=True) == '0.0e+0'
+    assert to_str(from_float(0.0),1,show_zero_exponent=False) == '0.0'
+    assert to_str(from_float(1.23),3,show_zero_exponent=True) == '1.23e+0'
+    assert to_str(from_float(1.23456789000000e-2),15,strip_zeros=False,min_fixed=0,max_fixed=0) == '1.23456789000000e-2'
+    assert to_str(from_float(1.23456789000000e+2),15,strip_zeros=False,min_fixed=0,max_fixed=0) == '1.23456789000000e+2'
+    assert to_str(from_float(2.1287e14), 15, max_fixed=1000) == '212870000000000.0'
+    assert to_str(from_float(2.1287e15), 15, max_fixed=1000) == '2128700000000000.0'
+    assert to_str(from_float(2.1287e16), 15, max_fixed=1000) == '21287000000000000.0'
+    assert to_str(from_float(2.1287e30), 15, max_fixed=1000) == '2128700000000000000000000000000.0'
+
+def test_tight_string_conversion():
+    mp.dps = 15
+    # In an old version, '0.5' wasn't recognized as representing
+    # an exact binary number and was erroneously rounded up or down
+    assert from_str('0.5', 10, round_floor) == fhalf
+    assert from_str('0.5', 10, round_ceiling) == fhalf
+
+def test_eval_repr_invariant():
+    """Test that eval(repr(x)) == x"""
+    random.seed(123)
+    for dps in [10, 15, 20, 50, 100]:
+        mp.dps = dps
+        for i in range(1000):
+            a = mpf(random.random())**0.5 * 10**random.randint(-100, 100)
+            assert eval(repr(a)) == a
+    mp.dps = 15
+
+def test_str_bugs():
+    mp.dps = 15
+    # Decimal rounding used to give the wrong exponent in some cases
+    assert str(mpf('1e600')) == '1.0e+600'
+    assert str(mpf('1e10000')) == '1.0e+10000'
+
+def test_str_prec0():
+    assert to_str(from_float(1.234), 0) == '.0e+0'
+    assert to_str(from_float(1e-15), 0) == '.0e-15'
+    assert to_str(from_float(1e+15), 0) == '.0e+15'
+    assert to_str(from_float(-1e-15), 0) == '-.0e-15'
+    assert to_str(from_float(-1e+15), 0) == '-.0e+15'
+
+def test_convert_rational():
+    mp.dps = 15
+    assert from_rational(30, 5, 53, round_nearest) == (0, 3, 1, 2)
+    assert from_rational(-7, 4, 53, round_nearest) == (1, 7, -2, 3)
+    assert to_rational((0, 1, -1, 1)) == (1, 2)
+
+def test_custom_class():
+    class mympf:
+        @property
+        def _mpf_(self):
+            return mpf(3.5)._mpf_
+    class mympc:
+        @property
+        def _mpc_(self):
+            return mpf(3.5)._mpf_, mpf(2.5)._mpf_
+    assert mpf(2) + mympf() == 5.5
+    assert mympf() + mpf(2) == 5.5
+    assert mpf(mympf()) == 3.5
+    assert mympc() + mpc(2) == mpc(5.5, 2.5)
+    assert mpc(2) + mympc() == mpc(5.5, 2.5)
+    assert mpc(mympc()) == (3.5+2.5j)
+
+def test_conversion_methods():
+    class SomethingRandom:
+        pass
+    class SomethingReal:
+        def _mpmath_(self, prec, rounding):
+            return mp.make_mpf(from_str('1.3', prec, rounding))
+    class SomethingComplex:
+        def _mpmath_(self, prec, rounding):
+            return mp.make_mpc((from_str('1.3', prec, rounding), \
+                from_str('1.7', prec, rounding)))
+    x = mpf(3)
+    z = mpc(3)
+    a = SomethingRandom()
+    y = SomethingReal()
+    w = SomethingComplex()
+    for d in [15, 45]:
+        mp.dps = d
+        assert (x+y).ae(mpf('4.3'))
+        assert (y+x).ae(mpf('4.3'))
+        assert (x+w).ae(mpc('4.3', '1.7'))
+        assert (w+x).ae(mpc('4.3', '1.7'))
+        assert (z+y).ae(mpc('4.3'))
+        assert (y+z).ae(mpc('4.3'))
+        assert (z+w).ae(mpc('4.3', '1.7'))
+        assert (w+z).ae(mpc('4.3', '1.7'))
+        x-y; y-x; x-w; w-x; z-y; y-z; z-w; w-z
+        x*y; y*x; x*w; w*x; z*y; y*z; z*w; w*z
+        x/y; y/x; x/w; w/x; z/y; y/z; z/w; w/z
+        x**y; y**x; x**w; w**x; z**y; y**z; z**w; w**z
+        x==y; y==x; x==w; w==x; z==y; y==z; z==w; w==z
+    mp.dps = 15
+    assert x.__add__(a) is NotImplemented
+    assert x.__radd__(a) is NotImplemented
+    assert x.__lt__(a) is NotImplemented
+    assert x.__gt__(a) is NotImplemented
+    assert x.__le__(a) is NotImplemented
+    assert x.__ge__(a) is NotImplemented
+    assert x.__eq__(a) is NotImplemented
+    assert x.__ne__(a) is NotImplemented
+    # implementation detail
+    if hasattr(x, "__cmp__"):
+        assert x.__cmp__(a) is NotImplemented
+    assert x.__sub__(a) is NotImplemented
+    assert x.__rsub__(a) is NotImplemented
+    assert x.__mul__(a) is NotImplemented
+    assert x.__rmul__(a) is NotImplemented
+    assert x.__div__(a) is NotImplemented
+    assert x.__rdiv__(a) is NotImplemented
+    assert x.__mod__(a) is NotImplemented
+    assert x.__rmod__(a) is NotImplemented
+    assert x.__pow__(a) is NotImplemented
+    assert x.__rpow__(a) is NotImplemented
+    assert z.__add__(a) is NotImplemented
+    assert z.__radd__(a) is NotImplemented
+    assert z.__eq__(a) is NotImplemented
+    assert z.__ne__(a) is NotImplemented
+    assert z.__sub__(a) is NotImplemented
+    assert z.__rsub__(a) is NotImplemented
+    assert z.__mul__(a) is NotImplemented
+    assert z.__rmul__(a) is NotImplemented
+    assert z.__div__(a) is NotImplemented
+    assert z.__rdiv__(a) is NotImplemented
+    assert z.__pow__(a) is NotImplemented
+    assert z.__rpow__(a) is NotImplemented
+
+def test_mpmathify():
+    assert mpmathify('1/2') == 0.5
+    assert mpmathify('(1.0+1.0j)') == mpc(1, 1)
+    assert mpmathify('(1.2e-10 - 3.4e5j)') == mpc('1.2e-10', '-3.4e5')
+    assert mpmathify('1j') == mpc(1j)
+
+def test_issue548():
+    try:
+        # This expression is invalid, but may trigger the ReDOS vulnerability
+        # in the regular expression for parsing complex numbers.
+        mpmathify('(' + '1' * 5000 + '!j')
+    except:
+        return
+    # The expression is invalid and should raise an exception.
+    assert False
+
+def test_compatibility():
+    try:
+        import numpy as np
+        from fractions import Fraction
+        from decimal import Decimal
+        import decimal
+    except ImportError:
+        return
+    # numpy types
+    for nptype in np.core.numerictypes.typeDict.values():
+        if issubclass(nptype, np.complexfloating):
+            x = nptype(complex(0.5, -0.5))
+        elif issubclass(nptype, np.floating):
+            x = nptype(0.5)
+        elif issubclass(nptype, np.integer):
+            x = nptype(2)
+        # Handle the weird types
+        try: diff = np.abs(type(np.sqrt(x))(sqrt(x)) - np.sqrt(x))
+        except: continue
+        assert diff < 2.0**-53
+    #Fraction and Decimal
+    oldprec = mp.prec
+    mp.prec = 1000
+    decimal.getcontext().prec = mp.dps
+    assert sqrt(Fraction(2, 3)).ae(sqrt(mpf('2/3')))
+    assert sqrt(Decimal(2)/Decimal(3)).ae(sqrt(mpf('2/3')))
+    mp.prec = oldprec
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_diff.py b/lib/python3.10/site-packages/mpmath/tests/test_diff.py
new file mode 100644
index 0000000000000000000000000000000000000000..f5711609da38862eb4fd62c88d35f1704c9425a4
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_diff.py
@@ -0,0 +1,61 @@
+from mpmath import *
+
+def test_diff():
+    mp.dps = 15
+    assert diff(log, 2.0, n=0).ae(log(2))
+    assert diff(cos, 1.0).ae(-sin(1))
+    assert diff(abs, 0.0) == 0
+    assert diff(abs, 0.0, direction=1) == 1
+    assert diff(abs, 0.0, direction=-1) == -1
+    assert diff(exp, 1.0).ae(e)
+    assert diff(exp, 1.0, n=5).ae(e)
+    assert diff(exp, 2.0, n=5, direction=3*j).ae(e**2)
+    assert diff(lambda x: x**2, 3.0, method='quad').ae(6)
+    assert diff(lambda x: 3+x**5, 3.0, n=2, method='quad').ae(540)
+    assert diff(lambda x: 3+x**5, 3.0, n=2, method='step').ae(540)
+    assert diffun(sin)(2).ae(cos(2))
+    assert diffun(sin, n=2)(2).ae(-sin(2))
+
+def test_diffs():
+    mp.dps = 15
+    assert [chop(d) for d in diffs(sin, 0, 1)] == [0, 1]
+    assert [chop(d) for d in diffs(sin, 0, 1, method='quad')] == [0, 1]
+    assert [chop(d) for d in diffs(sin, 0, 2)] == [0, 1, 0]
+    assert [chop(d) for d in diffs(sin, 0, 2, method='quad')] == [0, 1, 0]
+
+def test_taylor():
+    mp.dps = 15
+    # Easy to test since the coefficients are exact in floating-point
+    assert taylor(sqrt, 1, 4) == [1, 0.5, -0.125, 0.0625, -0.0390625]
+
+def test_diff_partial():
+    mp.dps = 15
+    x,y,z = xyz = 2,3,7
+    f = lambda x,y,z: 3*x**2 * (y+2)**3 * z**5
+    assert diff(f, xyz, (0,0,0)).ae(25210500)
+    assert diff(f, xyz, (0,0,1)).ae(18007500)
+    assert diff(f, xyz, (0,0,2)).ae(10290000)
+    assert diff(f, xyz, (0,1,0)).ae(15126300)
+    assert diff(f, xyz, (0,1,1)).ae(10804500)
+    assert diff(f, xyz, (0,1,2)).ae(6174000)
+    assert diff(f, xyz, (0,2,0)).ae(6050520)
+    assert diff(f, xyz, (0,2,1)).ae(4321800)
+    assert diff(f, xyz, (0,2,2)).ae(2469600)
+    assert diff(f, xyz, (1,0,0)).ae(25210500)
+    assert diff(f, xyz, (1,0,1)).ae(18007500)
+    assert diff(f, xyz, (1,0,2)).ae(10290000)
+    assert diff(f, xyz, (1,1,0)).ae(15126300)
+    assert diff(f, xyz, (1,1,1)).ae(10804500)
+    assert diff(f, xyz, (1,1,2)).ae(6174000)
+    assert diff(f, xyz, (1,2,0)).ae(6050520)
+    assert diff(f, xyz, (1,2,1)).ae(4321800)
+    assert diff(f, xyz, (1,2,2)).ae(2469600)
+    assert diff(f, xyz, (2,0,0)).ae(12605250)
+    assert diff(f, xyz, (2,0,1)).ae(9003750)
+    assert diff(f, xyz, (2,0,2)).ae(5145000)
+    assert diff(f, xyz, (2,1,0)).ae(7563150)
+    assert diff(f, xyz, (2,1,1)).ae(5402250)
+    assert diff(f, xyz, (2,1,2)).ae(3087000)
+    assert diff(f, xyz, (2,2,0)).ae(3025260)
+    assert diff(f, xyz, (2,2,1)).ae(2160900)
+    assert diff(f, xyz, (2,2,2)).ae(1234800)
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_division.py b/lib/python3.10/site-packages/mpmath/tests/test_division.py
new file mode 100644
index 0000000000000000000000000000000000000000..c704cadeb953793ac0a887aa09c4278cf68a2824
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_division.py
@@ -0,0 +1,143 @@
+from mpmath.libmp import *
+from mpmath import mpf, mp
+
+from random import randint, choice, seed
+
+all_modes = [round_floor, round_ceiling, round_down, round_up, round_nearest]
+
+fb = from_bstr
+fi = from_int
+ff = from_float
+
+
+def test_div_1_3():
+    a = fi(1)
+    b = fi(3)
+    c = fi(-1)
+
+    # floor rounds down, ceiling rounds up
+    assert mpf_div(a, b, 7, round_floor)   == fb('0.01010101')
+    assert mpf_div(a, b, 7, round_ceiling) == fb('0.01010110')
+    assert mpf_div(a, b, 7, round_down)    == fb('0.01010101')
+    assert mpf_div(a, b, 7, round_up)      == fb('0.01010110')
+    assert mpf_div(a, b, 7, round_nearest) == fb('0.01010101')
+
+    # floor rounds up, ceiling rounds down
+    assert mpf_div(c, b, 7, round_floor)   == fb('-0.01010110')
+    assert mpf_div(c, b, 7, round_ceiling) == fb('-0.01010101')
+    assert mpf_div(c, b, 7, round_down)    == fb('-0.01010101')
+    assert mpf_div(c, b, 7, round_up)      == fb('-0.01010110')
+    assert mpf_div(c, b, 7, round_nearest) == fb('-0.01010101')
+
+def test_mpf_divi_1_3():
+    a = 1
+    b = fi(3)
+    c = -1
+    assert mpf_rdiv_int(a, b, 7, round_floor)   == fb('0.01010101')
+    assert mpf_rdiv_int(a, b, 7, round_ceiling) == fb('0.01010110')
+    assert mpf_rdiv_int(a, b, 7, round_down)    == fb('0.01010101')
+    assert mpf_rdiv_int(a, b, 7, round_up)      == fb('0.01010110')
+    assert mpf_rdiv_int(a, b, 7, round_nearest) == fb('0.01010101')
+    assert mpf_rdiv_int(c, b, 7, round_floor)   == fb('-0.01010110')
+    assert mpf_rdiv_int(c, b, 7, round_ceiling) == fb('-0.01010101')
+    assert mpf_rdiv_int(c, b, 7, round_down)    == fb('-0.01010101')
+    assert mpf_rdiv_int(c, b, 7, round_up)      == fb('-0.01010110')
+    assert mpf_rdiv_int(c, b, 7, round_nearest) == fb('-0.01010101')
+
+
+def test_div_300():
+
+    q = fi(1000000)
+    a = fi(300499999)    # a/q is a little less than a half-integer
+    b = fi(300500000)    # b/q exactly a half-integer
+    c = fi(300500001)    # c/q is a little more than a half-integer
+
+    # Check nearest integer rounding (prec=9 as 2**8 < 300 < 2**9)
+
+    assert mpf_div(a, q, 9, round_down) == fi(300)
+    assert mpf_div(b, q, 9, round_down) == fi(300)
+    assert mpf_div(c, q, 9, round_down) == fi(300)
+    assert mpf_div(a, q, 9, round_up) == fi(301)
+    assert mpf_div(b, q, 9, round_up) == fi(301)
+    assert mpf_div(c, q, 9, round_up) == fi(301)
+
+    # Nearest even integer is down
+    assert mpf_div(a, q, 9, round_nearest) == fi(300)
+    assert mpf_div(b, q, 9, round_nearest) == fi(300)
+    assert mpf_div(c, q, 9, round_nearest) == fi(301)
+
+    # Nearest even integer is up
+    a = fi(301499999)
+    b = fi(301500000)
+    c = fi(301500001)
+    assert mpf_div(a, q, 9, round_nearest) == fi(301)
+    assert mpf_div(b, q, 9, round_nearest) == fi(302)
+    assert mpf_div(c, q, 9, round_nearest) == fi(302)
+
+
+def test_tight_integer_division():
+    # Test that integer division at tightest possible precision is exact
+    N = 100
+    seed(1)
+    for i in range(N):
+        a = choice([1, -1]) * randint(1, 1<<randint(10, 100))
+        b = choice([1, -1]) * randint(1, 1<<randint(10, 100))
+        p = a * b
+        width = bitcount(abs(b)) - trailing(b)
+        a = fi(a); b = fi(b); p = fi(p)
+        for mode in all_modes:
+            assert mpf_div(p, a, width, mode) == b
+
+
+def test_epsilon_rounding():
+    # Verify that mpf_div uses infinite precision; this result will
+    # appear to be exactly 0.101 to a near-sighted algorithm
+
+    a = fb('0.101' + ('0'*200) + '1')
+    b = fb('1.10101')
+    c = mpf_mul(a, b, 250, round_floor) # exact
+    assert mpf_div(c, b, bitcount(a[1]), round_floor) == a # exact
+
+    assert mpf_div(c, b, 2, round_down) == fb('0.10')
+    assert mpf_div(c, b, 3, round_down) == fb('0.101')
+    assert mpf_div(c, b, 2, round_up) == fb('0.11')
+    assert mpf_div(c, b, 3, round_up) == fb('0.110')
+    assert mpf_div(c, b, 2, round_floor) == fb('0.10')
+    assert mpf_div(c, b, 3, round_floor) == fb('0.101')
+    assert mpf_div(c, b, 2, round_ceiling) == fb('0.11')
+    assert mpf_div(c, b, 3, round_ceiling) == fb('0.110')
+
+    # The same for negative numbers
+    a = fb('-0.101' + ('0'*200) + '1')
+    b = fb('1.10101')
+    c = mpf_mul(a, b, 250, round_floor)
+    assert mpf_div(c, b, bitcount(a[1]), round_floor) == a
+
+    assert mpf_div(c, b, 2, round_down) == fb('-0.10')
+    assert mpf_div(c, b, 3, round_up) == fb('-0.110')
+
+    # Floor goes up, ceiling goes down
+    assert mpf_div(c, b, 2, round_floor) == fb('-0.11')
+    assert mpf_div(c, b, 3, round_floor) == fb('-0.110')
+    assert mpf_div(c, b, 2, round_ceiling) == fb('-0.10')
+    assert mpf_div(c, b, 3, round_ceiling) == fb('-0.101')
+
+
+def test_mod():
+    mp.dps = 15
+    assert mpf(234) % 1 == 0
+    assert mpf(-3) % 256 == 253
+    assert mpf(0.25) % 23490.5 == 0.25
+    assert mpf(0.25) % -23490.5 == -23490.25
+    assert mpf(-0.25) % 23490.5 == 23490.25
+    assert mpf(-0.25) % -23490.5 == -0.25
+    # Check that these cases are handled efficiently
+    assert mpf('1e10000000000') % 1 == 0
+    assert mpf('1.23e-1000000000') % 1 == mpf('1.23e-1000000000')
+    # test __rmod__
+    assert 3 % mpf('1.75') == 1.25
+
+def test_div_negative_rnd_bug():
+    mp.dps = 15
+    assert (-3) / mpf('0.1531879017645047') == mpf('-19.583791966887116')
+    assert mpf('-2.6342475750861301') / mpf('0.35126216427941814') == mpf('-7.4993775104985909')
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_eigen.py b/lib/python3.10/site-packages/mpmath/tests/test_eigen.py
new file mode 100644
index 0000000000000000000000000000000000000000..048b621b82733362eb2edca07f6adc0934a7ef64
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_eigen.py
@@ -0,0 +1,179 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+from mpmath import mp
+from mpmath import libmp
+
+xrange = libmp.backend.xrange
+
+def run_hessenberg(A, verbose = 0):
+    if verbose > 1:
+        print("original matrix (hessenberg):\n", A)
+
+    n = A.rows
+
+    Q, H = mp.hessenberg(A)
+
+    if verbose > 1:
+        print("Q:\n",Q)
+        print("H:\n",H)
+
+    B = Q * H * Q.transpose_conj()
+
+    eps = mp.exp(0.8 * mp.log(mp.eps))
+
+    err0 = 0
+    for x in xrange(n):
+        for y in xrange(n):
+            err0 += abs(A[y,x] - B[y,x])
+    err0 /= n * n
+
+    err1 = 0
+    for x in xrange(n):
+        for y in xrange(x + 2, n):
+            err1 += abs(H[y,x])
+
+    if verbose > 0:
+        print("difference (H):", err0, err1)
+
+    if verbose > 1:
+        print("B:\n", B)
+
+    assert err0 < eps
+    assert err1 == 0
+
+
+def run_schur(A, verbose = 0):
+    if verbose > 1:
+        print("original matrix (schur):\n", A)
+
+    n = A.rows
+
+    Q, R = mp.schur(A)
+
+    if verbose > 1:
+        print("Q:\n", Q)
+        print("R:\n", R)
+
+    B = Q * R * Q.transpose_conj()
+    C = Q * Q.transpose_conj()
+
+    eps = mp.exp(0.8 * mp.log(mp.eps))
+
+    err0 = 0
+    for x in xrange(n):
+        for y in xrange(n):
+            err0 += abs(A[y,x] - B[y,x])
+    err0 /= n * n
+
+    err1 = 0
+    for x in xrange(n):
+        for y in xrange(n):
+            if x == y:
+                C[y,x] -= 1
+            err1 += abs(C[y,x])
+    err1 /= n * n
+
+    err2 = 0
+    for x in xrange(n):
+        for y in xrange(x + 1, n):
+            err2 += abs(R[y,x])
+
+    if verbose > 0:
+        print("difference (S):", err0, err1, err2)
+
+    if verbose > 1:
+        print("B:\n", B)
+
+    assert err0 < eps
+    assert err1 < eps
+    assert err2 == 0
+
+def run_eig(A, verbose = 0):
+    if verbose > 1:
+        print("original matrix (eig):\n", A)
+
+    n = A.rows
+
+    E, EL, ER = mp.eig(A, left = True, right = True)
+
+    if verbose > 1:
+        print("E:\n", E)
+        print("EL:\n", EL)
+        print("ER:\n", ER)
+
+    eps = mp.exp(0.8 * mp.log(mp.eps))
+
+    err0 = 0
+    for i in xrange(n):
+        B = A * ER[:,i] - E[i] * ER[:,i]
+        err0 = max(err0, mp.mnorm(B))
+
+        B = EL[i,:] * A - EL[i,:] * E[i]
+        err0 = max(err0, mp.mnorm(B))
+
+    err0 /= n * n
+
+    if verbose > 0:
+        print("difference (E):", err0)
+
+    assert err0 < eps
+
+#####################
+
+def test_eig_dyn():
+    v = 0
+    for i in xrange(5):
+        n = 1 + int(mp.rand() * 5)
+        if mp.rand() > 0.5:
+            # real
+            A = 2 * mp.randmatrix(n, n) - 1
+            if mp.rand() > 0.5:
+                A *= 10
+                for x in xrange(n):
+                    for y in xrange(n):
+                        A[x,y] = int(A[x,y])
+        else:
+            A = (2 * mp.randmatrix(n, n) - 1) + 1j * (2 * mp.randmatrix(n, n) - 1)
+            if mp.rand() > 0.5:
+                A *= 10
+                for x in xrange(n):
+                    for y in xrange(n):
+                        A[x,y] = int(mp.re(A[x,y])) + 1j * int(mp.im(A[x,y]))
+
+        run_hessenberg(A, verbose = v)
+        run_schur(A, verbose = v)
+        run_eig(A, verbose = v)
+
+def test_eig():
+    v = 0
+    AS = []
+
+    A = mp.matrix([[2, 1, 0],  # jordan block of size 3
+                   [0, 2, 1],
+                   [0, 0, 2]])
+    AS.append(A)
+    AS.append(A.transpose())
+
+    A = mp.matrix([[2, 0, 0],  # jordan block of size 2
+                   [0, 2, 1],
+                   [0, 0, 2]])
+    AS.append(A)
+    AS.append(A.transpose())
+
+    A = mp.matrix([[2, 0, 1],  # jordan block of size 2
+                   [0, 2, 0],
+                   [0, 0, 2]])
+    AS.append(A)
+    AS.append(A.transpose())
+
+    A=  mp.matrix([[0, 0, 1],  # cyclic
+                   [1, 0, 0],
+                   [0, 1, 0]])
+    AS.append(A)
+    AS.append(A.transpose())
+
+    for A in AS:
+        run_hessenberg(A, verbose = v)
+        run_schur(A, verbose = v)
+        run_eig(A, verbose = v)
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_eigen_symmetric.py b/lib/python3.10/site-packages/mpmath/tests/test_eigen_symmetric.py
new file mode 100644
index 0000000000000000000000000000000000000000..aab3d8ea3142aada6e14ad6d3ea25a7e8293554d
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_eigen_symmetric.py
@@ -0,0 +1,357 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+from mpmath import mp
+from mpmath import libmp
+
+xrange = libmp.backend.xrange
+
+def run_eigsy(A, verbose = False):
+    if verbose:
+        print("original matrix:\n", str(A))
+
+    D, Q = mp.eigsy(A)
+    B = Q * mp.diag(D) * Q.transpose()
+    C = A - B
+    E = Q * Q.transpose() - mp.eye(A.rows)
+
+    if verbose:
+        print("eigenvalues:\n", D)
+        print("eigenvectors:\n", Q)
+
+    NC = mp.mnorm(C)
+    NE = mp.mnorm(E)
+
+    if verbose:
+        print("difference:", NC, "\n", C, "\n")
+        print("difference:", NE, "\n", E, "\n")
+
+    eps = mp.exp( 0.8 * mp.log(mp.eps))
+
+    assert NC < eps
+    assert NE < eps
+
+    return NC
+
+def run_eighe(A, verbose = False):
+    if verbose:
+        print("original matrix:\n", str(A))
+
+    D, Q = mp.eighe(A)
+    B = Q * mp.diag(D) * Q.transpose_conj()
+    C = A - B
+    E = Q * Q.transpose_conj() - mp.eye(A.rows)
+
+    if verbose:
+        print("eigenvalues:\n", D)
+        print("eigenvectors:\n", Q)
+
+    NC = mp.mnorm(C)
+    NE = mp.mnorm(E)
+
+    if verbose:
+        print("difference:", NC, "\n", C, "\n")
+        print("difference:", NE, "\n", E, "\n")
+
+    eps = mp.exp( 0.8 * mp.log(mp.eps))
+
+    assert NC < eps
+    assert NE < eps
+
+    return NC
+
+def run_svd_r(A, full_matrices = False, verbose = True):
+
+    m, n = A.rows, A.cols
+
+    eps = mp.exp(0.8 * mp.log(mp.eps))
+
+    if verbose:
+        print("original matrix:\n", str(A))
+        print("full", full_matrices)
+
+    U, S0, V = mp.svd_r(A, full_matrices = full_matrices)
+
+    S = mp.zeros(U.cols, V.rows)
+    for j in xrange(min(m, n)):
+        S[j,j] = S0[j]
+
+    if verbose:
+        print("U:\n", str(U))
+        print("S:\n", str(S0))
+        print("V:\n", str(V))
+
+    C = U * S * V - A
+    err = mp.mnorm(C)
+    if verbose:
+        print("C\n", str(C), "\n", err)
+    assert err < eps
+
+    D = V * V.transpose() - mp.eye(V.rows)
+    err = mp.mnorm(D)
+    if verbose:
+        print("D:\n", str(D), "\n", err)
+    assert err < eps
+
+    E = U.transpose() * U - mp.eye(U.cols)
+    err = mp.mnorm(E)
+    if verbose:
+        print("E:\n", str(E), "\n", err)
+    assert err < eps
+
+def run_svd_c(A, full_matrices = False, verbose = True):
+
+    m, n = A.rows, A.cols
+
+    eps = mp.exp(0.8 * mp.log(mp.eps))
+
+    if verbose:
+        print("original matrix:\n", str(A))
+        print("full", full_matrices)
+
+    U, S0, V = mp.svd_c(A, full_matrices = full_matrices)
+
+    S = mp.zeros(U.cols, V.rows)
+    for j in xrange(min(m, n)):
+        S[j,j] = S0[j]
+
+    if verbose:
+        print("U:\n", str(U))
+        print("S:\n", str(S0))
+        print("V:\n", str(V))
+
+    C = U * S * V - A
+    err = mp.mnorm(C)
+    if verbose:
+        print("C\n", str(C), "\n", err)
+    assert err  < eps
+
+    D = V * V.transpose_conj() - mp.eye(V.rows)
+    err = mp.mnorm(D)
+    if verbose:
+        print("D:\n", str(D), "\n", err)
+    assert err < eps
+
+    E = U.transpose_conj() * U - mp.eye(U.cols)
+    err = mp.mnorm(E)
+    if verbose:
+        print("E:\n", str(E), "\n", err)
+    assert err < eps
+
+def run_gauss(qtype, a, b):
+    eps = 1e-5
+
+    d, e = mp.gauss_quadrature(len(a), qtype)
+    d -= mp.matrix(a)
+    e -= mp.matrix(b)
+
+    assert mp.mnorm(d) < eps
+    assert mp.mnorm(e) < eps
+
+def irandmatrix(n, range = 10):
+    """
+    random matrix with integer entries
+    """
+    A = mp.matrix(n, n)
+    for i in xrange(n):
+        for j in xrange(n):
+            A[i,j]=int( (2 * mp.rand() - 1) * range)
+    return A
+
+#######################
+
+def test_eighe_fixed_matrix():
+    A = mp.matrix([[2, 3], [3, 5]])
+    run_eigsy(A)
+    run_eighe(A)
+
+    A = mp.matrix([[7, -11], [-11, 13]])
+    run_eigsy(A)
+    run_eighe(A)
+
+    A = mp.matrix([[2, 11, 7], [11, 3, 13], [7, 13, 5]])
+    run_eigsy(A)
+    run_eighe(A)
+
+    A = mp.matrix([[2, 0, 7], [0, 3, 1], [7, 1, 5]])
+    run_eigsy(A)
+    run_eighe(A)
+
+    #
+
+    A = mp.matrix([[2, 3+7j], [3-7j, 5]])
+    run_eighe(A)
+
+    A = mp.matrix([[2, -11j, 0], [+11j, 3, 29j], [0, -29j, 5]])
+    run_eighe(A)
+
+    A = mp.matrix([[2, 11 + 17j, 7 + 19j], [11 - 17j, 3, -13 + 23j], [7 - 19j, -13 - 23j, 5]])
+    run_eighe(A)
+
+def test_eigsy_randmatrix():
+    N = 5
+
+    for a in xrange(10):
+        A = 2 * mp.randmatrix(N, N) - 1
+
+        for i in xrange(0, N):
+            for j in xrange(i + 1, N):
+                A[j,i] = A[i,j]
+
+        run_eigsy(A)
+
+def test_eighe_randmatrix():
+    N = 5
+
+    for a in xrange(10):
+        A = (2 * mp.randmatrix(N, N) - 1) + 1j * (2 * mp.randmatrix(N, N) - 1)
+
+        for i in xrange(0, N):
+            A[i,i] = mp.re(A[i,i])
+            for j in xrange(i + 1, N):
+                A[j,i] = mp.conj(A[i,j])
+
+        run_eighe(A)
+
+def test_eigsy_irandmatrix():
+    N = 4
+    R = 4
+
+    for a in xrange(10):
+        A=irandmatrix(N, R)
+
+        for i in xrange(0, N):
+            for j in xrange(i + 1, N):
+                A[j,i] = A[i,j]
+
+        run_eigsy(A)
+
+def test_eighe_irandmatrix():
+    N = 4
+    R = 4
+
+    for a in xrange(10):
+        A=irandmatrix(N, R) + 1j * irandmatrix(N, R)
+
+        for i in xrange(0, N):
+            A[i,i] = mp.re(A[i,i])
+            for j in xrange(i + 1, N):
+                A[j,i] = mp.conj(A[i,j])
+
+        run_eighe(A)
+
+def test_svd_r_rand():
+    for i in xrange(5):
+        full = mp.rand() > 0.5
+        m = 1 + int(mp.rand() * 10)
+        n = 1 + int(mp.rand() * 10)
+        A = 2 * mp.randmatrix(m, n) - 1
+        if mp.rand() > 0.5:
+            A *= 10
+            for x in xrange(m):
+                for y in xrange(n):
+                    A[x,y]=int(A[x,y])
+
+        run_svd_r(A, full_matrices = full, verbose = False)
+
+def test_svd_c_rand():
+    for i in xrange(5):
+        full = mp.rand() > 0.5
+        m = 1 + int(mp.rand() * 10)
+        n = 1 + int(mp.rand() * 10)
+        A = (2 * mp.randmatrix(m, n) - 1) + 1j * (2 * mp.randmatrix(m, n) - 1)
+        if mp.rand() > 0.5:
+            A *= 10
+            for x in xrange(m):
+                for y in xrange(n):
+                    A[x,y]=int(mp.re(A[x,y])) + 1j * int(mp.im(A[x,y]))
+
+        run_svd_c(A, full_matrices=full, verbose=False)
+
+def test_svd_test_case():
+    # a test case from Golub and Reinsch
+    #  (see wilkinson/reinsch: handbook for auto. comp., vol ii-linear algebra, 134-151(1971).)
+
+    eps = mp.exp(0.8 * mp.log(mp.eps))
+
+    a = [[22, 10,  2,   3,  7],
+         [14,  7, 10,   0,  8],
+         [-1, 13, -1, -11,  3],
+         [-3, -2, 13,  -2,  4],
+         [ 9,  8,  1,  -2,  4],
+         [ 9,  1, -7,   5, -1],
+         [ 2, -6,  6,   5,  1],
+         [ 4,  5,  0,  -2,  2]]
+
+    a = mp.matrix(a)
+    b = mp.matrix([mp.sqrt(1248), 20, mp.sqrt(384), 0, 0])
+
+    S = mp.svd_r(a, compute_uv = False)
+    S -= b
+    assert mp.mnorm(S) < eps
+
+    S = mp.svd_c(a, compute_uv = False)
+    S -= b
+    assert mp.mnorm(S) < eps
+
+
+def test_gauss_quadrature_static():
+    a = [-0.57735027,  0.57735027]
+    b = [ 1,  1]
+    run_gauss("legendre", a , b)
+
+    a = [ -0.906179846,  -0.538469310,   0,           0.538469310,   0.906179846]
+    b = [  0.23692689,    0.47862867,    0.56888889,  0.47862867,    0.23692689]
+    run_gauss("legendre", a , b)
+
+    a = [ 0.06943184,  0.33000948,  0.66999052,  0.93056816]
+    b = [ 0.17392742,  0.32607258,  0.32607258,  0.17392742]
+    run_gauss("legendre01", a , b)
+
+    a = [-0.70710678,  0.70710678]
+    b = [ 0.88622693,  0.88622693]
+    run_gauss("hermite", a , b)
+
+    a = [ -2.02018287,  -0.958572465,   0,           0.958572465,   2.02018287]
+    b = [  0.01995324,   0.39361932,    0.94530872,  0.39361932,    0.01995324]
+    run_gauss("hermite", a , b)
+
+    a = [ 0.41577456,  2.29428036,  6.28994508]
+    b = [ 0.71109301,  0.27851773,  0.01038926]
+    run_gauss("laguerre", a , b)
+
+def test_gauss_quadrature_dynamic(verbose = False):
+    n = 5
+
+    A = mp.randmatrix(2 * n, 1)
+
+    def F(x):
+        r = 0
+        for i in xrange(len(A) - 1, -1, -1):
+            r = r * x + A[i]
+        return r
+
+    def run(qtype, FW, R, alpha = 0, beta = 0):
+        X, W = mp.gauss_quadrature(n, qtype, alpha = alpha, beta = beta)
+
+        a = 0
+        for i in xrange(len(X)):
+            a += W[i] * F(X[i])
+
+        b = mp.quad(lambda x: FW(x) * F(x), R)
+
+        c = mp.fabs(a - b)
+
+        if verbose:
+            print(qtype, c, a, b)
+
+        assert c < 1e-5
+
+    run("legendre", lambda x: 1, [-1, 1])
+    run("legendre01", lambda x: 1, [0, 1])
+    run("hermite", lambda x: mp.exp(-x*x), [-mp.inf, mp.inf])
+    run("laguerre", lambda x: mp.exp(-x), [0, mp.inf])
+    run("glaguerre", lambda x: mp.sqrt(x)*mp.exp(-x), [0, mp.inf], alpha = 1 / mp.mpf(2))
+    run("chebyshev1", lambda x: 1/mp.sqrt(1-x*x), [-1, 1])
+    run("chebyshev2", lambda x: mp.sqrt(1-x*x), [-1, 1])
+    run("jacobi", lambda x: (1-x)**(1/mp.mpf(3)) * (1+x)**(1/mp.mpf(5)), [-1, 1], alpha = 1 / mp.mpf(3), beta = 1 / mp.mpf(5) )
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_elliptic.py b/lib/python3.10/site-packages/mpmath/tests/test_elliptic.py
new file mode 100644
index 0000000000000000000000000000000000000000..4dddc2df34b8d2fa7f2028b3501e5b7f140d8912
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_elliptic.py
@@ -0,0 +1,670 @@
+"""
+Limited tests of the elliptic functions module.  A full suite of
+extensive testing can be found in elliptic_torture_tests.py
+
+Author of the first version: M.T. Taschuk
+
+References:
+
+[1] Abramowitz & Stegun. 'Handbook of Mathematical Functions, 9th Ed.',
+    (Dover duplicate of 1972 edition)
+[2] Whittaker 'A Course of Modern Analysis, 4th Ed.', 1946,
+    Cambridge University Press
+
+"""
+
+import mpmath
+import random
+import pytest
+
+from mpmath import *
+
+def mpc_ae(a, b, eps=eps):
+    res = True
+    res = res and a.real.ae(b.real, eps)
+    res = res and a.imag.ae(b.imag, eps)
+    return res
+
+zero = mpf(0)
+one = mpf(1)
+
+jsn = ellipfun('sn')
+jcn = ellipfun('cn')
+jdn = ellipfun('dn')
+
+calculate_nome = lambda k: qfrom(k=k)
+
+def test_ellipfun():
+    mp.dps = 15
+    assert ellipfun('ss', 0, 0) == 1
+    assert ellipfun('cc', 0, 0) == 1
+    assert ellipfun('dd', 0, 0) == 1
+    assert ellipfun('nn', 0, 0) == 1
+    assert ellipfun('sn', 0.25, 0).ae(sin(0.25))
+    assert ellipfun('cn', 0.25, 0).ae(cos(0.25))
+    assert ellipfun('dn', 0.25, 0).ae(1)
+    assert ellipfun('ns', 0.25, 0).ae(csc(0.25))
+    assert ellipfun('nc', 0.25, 0).ae(sec(0.25))
+    assert ellipfun('nd', 0.25, 0).ae(1)
+    assert ellipfun('sc', 0.25, 0).ae(tan(0.25))
+    assert ellipfun('sd', 0.25, 0).ae(sin(0.25))
+    assert ellipfun('cd', 0.25, 0).ae(cos(0.25))
+    assert ellipfun('cs', 0.25, 0).ae(cot(0.25))
+    assert ellipfun('dc', 0.25, 0).ae(sec(0.25))
+    assert ellipfun('ds', 0.25, 0).ae(csc(0.25))
+    assert ellipfun('sn', 0.25, 1).ae(tanh(0.25))
+    assert ellipfun('cn', 0.25, 1).ae(sech(0.25))
+    assert ellipfun('dn', 0.25, 1).ae(sech(0.25))
+    assert ellipfun('ns', 0.25, 1).ae(coth(0.25))
+    assert ellipfun('nc', 0.25, 1).ae(cosh(0.25))
+    assert ellipfun('nd', 0.25, 1).ae(cosh(0.25))
+    assert ellipfun('sc', 0.25, 1).ae(sinh(0.25))
+    assert ellipfun('sd', 0.25, 1).ae(sinh(0.25))
+    assert ellipfun('cd', 0.25, 1).ae(1)
+    assert ellipfun('cs', 0.25, 1).ae(csch(0.25))
+    assert ellipfun('dc', 0.25, 1).ae(1)
+    assert ellipfun('ds', 0.25, 1).ae(csch(0.25))
+    assert ellipfun('sn', 0.25, 0.5).ae(0.24615967096986145833)
+    assert ellipfun('cn', 0.25, 0.5).ae(0.96922928989378439337)
+    assert ellipfun('dn', 0.25, 0.5).ae(0.98473484156599474563)
+    assert ellipfun('ns', 0.25, 0.5).ae(4.0624038700573130369)
+    assert ellipfun('nc', 0.25, 0.5).ae(1.0317476065024692949)
+    assert ellipfun('nd', 0.25, 0.5).ae(1.0155017958029488665)
+    assert ellipfun('sc', 0.25, 0.5).ae(0.25397465134058993408)
+    assert ellipfun('sd', 0.25, 0.5).ae(0.24997558792415733063)
+    assert ellipfun('cd', 0.25, 0.5).ae(0.98425408443195497052)
+    assert ellipfun('cs', 0.25, 0.5).ae(3.9374008182374110826)
+    assert ellipfun('dc', 0.25, 0.5).ae(1.0159978158253033913)
+    assert ellipfun('ds', 0.25, 0.5).ae(4.0003906313579720593)
+
+
+
+
+def test_calculate_nome():
+    mp.dps = 100
+
+    q = calculate_nome(zero)
+    assert(q == zero)
+
+    mp.dps = 25
+    # used Mathematica's EllipticNomeQ[m]
+    math1 = [(mpf(1)/10, mpf('0.006584651553858370274473060')),
+             (mpf(2)/10, mpf('0.01394285727531826872146409')),
+             (mpf(3)/10, mpf('0.02227743615715350822901627')),
+             (mpf(4)/10, mpf('0.03188334731336317755064299')),
+             (mpf(5)/10, mpf('0.04321391826377224977441774')),
+             (mpf(6)/10, mpf('0.05702025781460967637754953')),
+             (mpf(7)/10, mpf('0.07468994353717944761143751')),
+             (mpf(8)/10, mpf('0.09927369733882489703607378')),
+             (mpf(9)/10, mpf('0.1401731269542615524091055')),
+             (mpf(9)/10, mpf('0.1401731269542615524091055'))]
+
+    for i in math1:
+        m = i[0]
+        q = calculate_nome(sqrt(m))
+        assert q.ae(i[1])
+
+    mp.dps = 15
+
+def test_jtheta():
+    mp.dps = 25
+
+    z = q = zero
+    for n in range(1,5):
+        value = jtheta(n, z, q)
+        assert(value == (n-1)//2)
+
+    for q in [one, mpf(2)]:
+        for n in range(1,5):
+            pytest.raises(ValueError, lambda: jtheta(n, z, q))
+
+    z = one/10
+    q = one/11
+
+    # Mathematical N[EllipticTheta[1, 1/10, 1/11], 25]
+    res = mpf('0.1069552990104042681962096')
+    result = jtheta(1, z, q)
+    assert(result.ae(res))
+
+    # Mathematica N[EllipticTheta[2, 1/10, 1/11], 25]
+    res = mpf('1.101385760258855791140606')
+    result = jtheta(2, z, q)
+    assert(result.ae(res))
+
+    # Mathematica N[EllipticTheta[3, 1/10, 1/11], 25]
+    res = mpf('1.178319743354331061795905')
+    result = jtheta(3, z, q)
+    assert(result.ae(res))
+
+    # Mathematica N[EllipticTheta[4, 1/10, 1/11], 25]
+    res = mpf('0.8219318954665153577314573')
+    result = jtheta(4, z, q)
+    assert(result.ae(res))
+
+    # test for sin zeros for jtheta(1, z, q)
+    # test for cos zeros for jtheta(2, z, q)
+    z1 = pi
+    z2 = pi/2
+    for i in range(10):
+        qstring = str(random.random())
+        q = mpf(qstring)
+        result = jtheta(1, z1, q)
+        assert(result.ae(0))
+        result = jtheta(2, z2, q)
+        assert(result.ae(0))
+    mp.dps = 15
+
+
+def test_jtheta_issue_79():
+    # near the circle of covergence |q| = 1 the convergence slows
+    # down; for |q| > Q_LIM the theta functions raise ValueError
+    mp.dps = 30
+    mp.dps += 30
+    q = mpf(6)/10 - one/10**6 - mpf(8)/10 * j
+    mp.dps -= 30
+    # Mathematica run first
+    # N[EllipticTheta[3, 1, 6/10 - 10^-6 - 8/10*I], 2000]
+    # then it works:
+    # N[EllipticTheta[3, 1, 6/10 - 10^-6 - 8/10*I], 30]
+    res = mpf('32.0031009628901652627099524264') + \
+          mpf('16.6153027998236087899308935624') * j
+    result = jtheta(3, 1, q)
+    # check that for abs(q) > Q_LIM a ValueError exception is raised
+    mp.dps += 30
+    q = mpf(6)/10 - one/10**7 - mpf(8)/10 * j
+    mp.dps -= 30
+    pytest.raises(ValueError, lambda: jtheta(3, 1, q))
+
+    # bug reported in issue 79
+    mp.dps = 100
+    z = (1+j)/3
+    q = mpf(368983957219251)/10**15 + mpf(636363636363636)/10**15 * j
+    # Mathematica N[EllipticTheta[1, z, q], 35]
+    res = mpf('2.4439389177990737589761828991467471') + \
+          mpf('0.5446453005688226915290954851851490') *j
+    mp.dps = 30
+    result = jtheta(1, z, q)
+    assert(result.ae(res))
+    mp.dps = 80
+    z = 3 + 4*j
+    q = 0.5 + 0.5*j
+    r1 = jtheta(1, z, q)
+    mp.dps = 15
+    r2 = jtheta(1, z, q)
+    assert r1.ae(r2)
+    mp.dps = 80
+    z = 3 + j
+    q1 = exp(j*3)
+    # longer test
+    # for n in range(1, 6)
+    for n in range(1, 2):
+        mp.dps = 80
+        q = q1*(1 - mpf(1)/10**n)
+        r1 = jtheta(1, z, q)
+        mp.dps = 15
+        r2 = jtheta(1, z, q)
+    assert r1.ae(r2)
+    mp.dps = 15
+    # issue 79 about high derivatives
+    assert jtheta(3, 4.5, 0.25, 9).ae(1359.04892680683)
+    assert jtheta(3, 4.5, 0.25, 50).ae(-6.14832772630905e+33)
+    mp.dps = 50
+    r = jtheta(3, 4.5, 0.25, 9)
+    assert r.ae('1359.048926806828939547859396600218966947753213803')
+    r = jtheta(3, 4.5, 0.25, 50)
+    assert r.ae('-6148327726309051673317975084654262.4119215720343656')
+
+def test_jtheta_identities():
+    """
+    Tests the some of the jacobi identidies found in Abramowitz,
+    Sec. 16.28, Pg. 576. The identities are tested to 1 part in 10^98.
+    """
+    mp.dps = 110
+    eps1 = ldexp(eps, 30)
+
+    for i in range(10):
+        qstring = str(random.random())
+        q = mpf(qstring)
+
+        zstring = str(10*random.random())
+        z = mpf(zstring)
+        # Abramowitz 16.28.1
+        # v_1(z, q)**2 * v_4(0, q)**2 =   v_3(z, q)**2 * v_2(0, q)**2
+        #                               - v_2(z, q)**2 * v_3(0, q)**2
+        term1 = (jtheta(1, z, q)**2) * (jtheta(4, zero, q)**2)
+        term2 = (jtheta(3, z, q)**2) * (jtheta(2, zero, q)**2)
+        term3 = (jtheta(2, z, q)**2) * (jtheta(3, zero, q)**2)
+        equality = term1 - term2 + term3
+        assert(equality.ae(0, eps1))
+
+        zstring = str(100*random.random())
+        z = mpf(zstring)
+        # Abramowitz 16.28.2
+        # v_2(z, q)**2 * v_4(0, q)**2 =   v_4(z, q)**2 * v_2(0, q)**2
+        #                               - v_1(z, q)**2 * v_3(0, q)**2
+        term1 = (jtheta(2, z, q)**2) * (jtheta(4, zero, q)**2)
+        term2 = (jtheta(4, z, q)**2) * (jtheta(2, zero, q)**2)
+        term3 = (jtheta(1, z, q)**2) * (jtheta(3, zero, q)**2)
+        equality = term1 - term2 + term3
+        assert(equality.ae(0, eps1))
+
+        # Abramowitz 16.28.3
+        # v_3(z, q)**2 * v_4(0, q)**2 =   v_4(z, q)**2 * v_3(0, q)**2
+        #                               - v_1(z, q)**2 * v_2(0, q)**2
+        term1 = (jtheta(3, z, q)**2) * (jtheta(4, zero, q)**2)
+        term2 = (jtheta(4, z, q)**2) * (jtheta(3, zero, q)**2)
+        term3 = (jtheta(1, z, q)**2) * (jtheta(2, zero, q)**2)
+        equality = term1 - term2 + term3
+        assert(equality.ae(0, eps1))
+
+        # Abramowitz 16.28.4
+        # v_4(z, q)**2 * v_4(0, q)**2 =   v_3(z, q)**2 * v_3(0, q)**2
+        #                               - v_2(z, q)**2 * v_2(0, q)**2
+        term1 = (jtheta(4, z, q)**2) * (jtheta(4, zero, q)**2)
+        term2 = (jtheta(3, z, q)**2) * (jtheta(3, zero, q)**2)
+        term3 = (jtheta(2, z, q)**2) * (jtheta(2, zero, q)**2)
+        equality = term1 - term2 + term3
+        assert(equality.ae(0, eps1))
+
+        # Abramowitz 16.28.5
+        # v_2(0, q)**4 + v_4(0, q)**4 == v_3(0, q)**4
+        term1 = (jtheta(2, zero, q))**4
+        term2 = (jtheta(4, zero, q))**4
+        term3 = (jtheta(3, zero, q))**4
+        equality = term1 + term2 - term3
+        assert(equality.ae(0, eps1))
+    mp.dps = 15
+
+def test_jtheta_complex():
+    mp.dps = 30
+    z = mpf(1)/4 + j/8
+    q = mpf(1)/3 + j/7
+    # Mathematica N[EllipticTheta[1, 1/4 + I/8, 1/3 + I/7], 35]
+    res = mpf('0.31618034835986160705729105731678285') + \
+          mpf('0.07542013825835103435142515194358975') * j
+    r = jtheta(1, z, q)
+    assert(mpc_ae(r, res))
+
+    # Mathematica N[EllipticTheta[2, 1/4 + I/8, 1/3 + I/7], 35]
+    res = mpf('1.6530986428239765928634711417951828') + \
+          mpf('0.2015344864707197230526742145361455') * j
+    r = jtheta(2, z, q)
+    assert(mpc_ae(r, res))
+
+    # Mathematica N[EllipticTheta[3, 1/4 + I/8, 1/3 + I/7], 35]
+    res = mpf('1.6520564411784228184326012700348340') + \
+          mpf('0.1998129119671271328684690067401823') * j
+    r = jtheta(3, z, q)
+    assert(mpc_ae(r, res))
+
+    # Mathematica N[EllipticTheta[4, 1/4 + I/8, 1/3 + I/7], 35]
+    res = mpf('0.37619082382228348252047624089973824') - \
+          mpf('0.15623022130983652972686227200681074') * j
+    r = jtheta(4, z, q)
+    assert(mpc_ae(r, res))
+
+    # check some theta function identities
+    mp.dos = 100
+    z = mpf(1)/4 + j/8
+    q = mpf(1)/3 + j/7
+    mp.dps += 10
+    a = [0,0, jtheta(2, 0, q), jtheta(3, 0, q), jtheta(4, 0, q)]
+    t = [0, jtheta(1, z, q), jtheta(2, z, q), jtheta(3, z, q), jtheta(4, z, q)]
+    r = [(t[2]*a[4])**2 - (t[4]*a[2])**2 + (t[1] *a[3])**2,
+        (t[3]*a[4])**2 - (t[4]*a[3])**2 + (t[1] *a[2])**2,
+        (t[1]*a[4])**2 - (t[3]*a[2])**2 + (t[2] *a[3])**2,
+        (t[4]*a[4])**2 - (t[3]*a[3])**2 + (t[2] *a[2])**2,
+        a[2]**4 + a[4]**4 - a[3]**4]
+    mp.dps -= 10
+    for x in r:
+        assert(mpc_ae(x, mpc(0)))
+    mp.dps = 15
+
+def test_djtheta():
+    mp.dps = 30
+
+    z = one/7 + j/3
+    q = one/8 + j/5
+    # Mathematica N[EllipticThetaPrime[1, 1/7 + I/3, 1/8 + I/5], 35]
+    res = mpf('1.5555195883277196036090928995803201') - \
+          mpf('0.02439761276895463494054149673076275') * j
+    result = jtheta(1, z, q, 1)
+    assert(mpc_ae(result, res))
+
+    # Mathematica N[EllipticThetaPrime[2, 1/7 + I/3, 1/8 + I/5], 35]
+    res = mpf('0.19825296689470982332701283509685662') - \
+          mpf('0.46038135182282106983251742935250009') * j
+    result = jtheta(2, z, q, 1)
+    assert(mpc_ae(result, res))
+
+    # Mathematica N[EllipticThetaPrime[3, 1/7 + I/3, 1/8 + I/5], 35]
+    res = mpf('0.36492498415476212680896699407390026') - \
+          mpf('0.57743812698666990209897034525640369') * j
+    result = jtheta(3, z, q, 1)
+    assert(mpc_ae(result, res))
+
+    # Mathematica N[EllipticThetaPrime[4, 1/7 + I/3, 1/8 + I/5], 35]
+    res = mpf('-0.38936892528126996010818803742007352') + \
+          mpf('0.66549886179739128256269617407313625') * j
+    result = jtheta(4, z, q, 1)
+    assert(mpc_ae(result, res))
+
+    for i in range(10):
+        q = (one*random.random() + j*random.random())/2
+        # identity in Wittaker, Watson &21.41
+        a = jtheta(1, 0, q, 1)
+        b = jtheta(2, 0, q)*jtheta(3, 0, q)*jtheta(4, 0, q)
+        assert(a.ae(b))
+
+    # test higher derivatives
+    mp.dps = 20
+    for q,z in [(one/3, one/5), (one/3 + j/8, one/5),
+        (one/3, one/5 + j/8), (one/3 + j/7, one/5 + j/8)]:
+        for n in [1, 2, 3, 4]:
+            r = jtheta(n, z, q, 2)
+            r1 = diff(lambda zz: jtheta(n, zz, q), z, n=2)
+            assert r.ae(r1)
+            r = jtheta(n, z, q, 3)
+            r1 = diff(lambda zz: jtheta(n, zz, q), z, n=3)
+            assert r.ae(r1)
+
+    # identity in Wittaker, Watson &21.41
+    q = one/3
+    z = zero
+    a = [0]*5
+    a[1] = jtheta(1, z, q, 3)/jtheta(1, z, q, 1)
+    for n in [2,3,4]:
+        a[n] = jtheta(n, z, q, 2)/jtheta(n, z, q)
+    equality = a[2] + a[3] + a[4] - a[1]
+    assert(equality.ae(0))
+    mp.dps = 15
+
+def test_jsn():
+    """
+    Test some special cases of the sn(z, q) function.
+    """
+    mp.dps = 100
+
+    # trival case
+    result = jsn(zero, zero)
+    assert(result == zero)
+
+    # Abramowitz Table 16.5
+    #
+    # sn(0, m) = 0
+
+    for i in range(10):
+        qstring = str(random.random())
+        q = mpf(qstring)
+
+        equality = jsn(zero, q)
+        assert(equality.ae(0))
+
+    # Abramowitz Table 16.6.1
+    #
+    # sn(z, 0) = sin(z), m == 0
+    #
+    # sn(z, 1) = tanh(z), m == 1
+    #
+    # It would be nice to test these, but I find that they run
+    # in to numerical trouble.  I'm currently treating as a boundary
+    # case for sn function.
+
+    mp.dps = 25
+    arg = one/10
+    #N[JacobiSN[1/10, 2^-100], 25]
+    res = mpf('0.09983341664682815230681420')
+    m = ldexp(one, -100)
+    result = jsn(arg, m)
+    assert(result.ae(res))
+
+    # N[JacobiSN[1/10, 1/10], 25]
+    res = mpf('0.09981686718599080096451168')
+    result = jsn(arg, arg)
+    assert(result.ae(res))
+    mp.dps = 15
+
+def test_jcn():
+    """
+    Test some special cases of the cn(z, q) function.
+    """
+    mp.dps = 100
+
+    # Abramowitz Table 16.5
+    # cn(0, q) = 1
+    qstring = str(random.random())
+    q = mpf(qstring)
+    cn = jcn(zero, q)
+    assert(cn.ae(one))
+
+    # Abramowitz Table 16.6.2
+    #
+    # cn(u, 0) = cos(u), m == 0
+    #
+    # cn(u, 1) = sech(z), m == 1
+    #
+    # It would be nice to test these, but I find that they run
+    # in to numerical trouble.  I'm currently treating as a boundary
+    # case for cn function.
+
+    mp.dps = 25
+    arg = one/10
+    m = ldexp(one, -100)
+    #N[JacobiCN[1/10, 2^-100], 25]
+    res = mpf('0.9950041652780257660955620')
+    result = jcn(arg, m)
+    assert(result.ae(res))
+
+    # N[JacobiCN[1/10, 1/10], 25]
+    res = mpf('0.9950058256237368748520459')
+    result = jcn(arg, arg)
+    assert(result.ae(res))
+    mp.dps = 15
+
+def test_jdn():
+    """
+    Test some special cases of the dn(z, q) function.
+    """
+    mp.dps = 100
+
+    # Abramowitz Table 16.5
+    # dn(0, q) = 1
+    mstring = str(random.random())
+    m = mpf(mstring)
+
+    dn = jdn(zero, m)
+    assert(dn.ae(one))
+
+    mp.dps = 25
+    # N[JacobiDN[1/10, 1/10], 25]
+    res = mpf('0.9995017055025556219713297')
+    arg = one/10
+    result = jdn(arg, arg)
+    assert(result.ae(res))
+    mp.dps = 15
+
+
+def test_sn_cn_dn_identities():
+    """
+    Tests the some of the jacobi elliptic function identities found
+    on Mathworld. Haven't found in Abramowitz.
+    """
+    mp.dps = 100
+    N = 5
+    for i in range(N):
+        qstring = str(random.random())
+        q = mpf(qstring)
+        zstring = str(100*random.random())
+        z = mpf(zstring)
+
+        # MathWorld
+        # sn(z, q)**2 + cn(z, q)**2 == 1
+        term1 = jsn(z, q)**2
+        term2 = jcn(z, q)**2
+        equality = one - term1 - term2
+        assert(equality.ae(0))
+
+    # MathWorld
+    # k**2 * sn(z, m)**2 + dn(z, m)**2 == 1
+    for i in range(N):
+        mstring = str(random.random())
+        m = mpf(qstring)
+        k = m.sqrt()
+        zstring = str(10*random.random())
+        z = mpf(zstring)
+        term1 = k**2 * jsn(z, m)**2
+        term2 = jdn(z, m)**2
+        equality = one - term1 - term2
+        assert(equality.ae(0))
+
+
+    for i in range(N):
+        mstring = str(random.random())
+        m = mpf(mstring)
+        k = m.sqrt()
+        zstring = str(random.random())
+        z = mpf(zstring)
+
+        # MathWorld
+        # k**2 * cn(z, m)**2 + (1 - k**2) = dn(z, m)**2
+        term1 = k**2 * jcn(z, m)**2
+        term2 = 1 - k**2
+        term3 = jdn(z, m)**2
+        equality = term3 - term1 - term2
+        assert(equality.ae(0))
+
+        K = ellipk(k**2)
+        # Abramowitz Table 16.5
+        # sn(K, m) = 1; K is K(k), first complete elliptic integral
+        r = jsn(K, m)
+        assert(r.ae(one))
+
+        # Abramowitz Table 16.5
+        # cn(K, q) = 0; K is K(k), first complete elliptic integral
+        equality = jcn(K, m)
+        assert(equality.ae(0))
+
+        # Abramowitz Table 16.6.3
+        # dn(z, 0) = 1, m == 0
+        z = m
+        value = jdn(z, zero)
+        assert(value.ae(one))
+
+    mp.dps = 15
+
+def test_sn_cn_dn_complex():
+    mp.dps = 30
+    # N[JacobiSN[1/4 + I/8, 1/3 + I/7], 35] in Mathematica
+    res = mpf('0.2495674401066275492326652143537') + \
+          mpf('0.12017344422863833381301051702823') * j
+    u = mpf(1)/4 + j/8
+    m = mpf(1)/3 + j/7
+    r = jsn(u, m)
+    assert(mpc_ae(r, res))
+
+    #N[JacobiCN[1/4 + I/8, 1/3 + I/7], 35]
+    res = mpf('0.9762691700944007312693721148331') - \
+          mpf('0.0307203994181623243583169154824')*j
+    r = jcn(u, m)
+    #assert r.real.ae(res.real)
+    #assert r.imag.ae(res.imag)
+    assert(mpc_ae(r, res))
+
+    #N[JacobiDN[1/4 + I/8, 1/3 + I/7], 35]
+    res = mpf('0.99639490163039577560547478589753039') - \
+          mpf('0.01346296520008176393432491077244994')*j
+    r = jdn(u, m)
+    assert(mpc_ae(r, res))
+    mp.dps = 15
+
+def test_elliptic_integrals():
+    # Test cases from Carlson's paper
+    mp.dps = 15
+    assert elliprd(0,2,1).ae(1.7972103521033883112)
+    assert elliprd(2,3,4).ae(0.16510527294261053349)
+    assert elliprd(j,-j,2).ae(0.65933854154219768919)
+    assert elliprd(0,j,-j).ae(1.2708196271909686299 + 2.7811120159520578777j)
+    assert elliprd(0,j-1,j).ae(-1.8577235439239060056 - 0.96193450888838559989j)
+    assert elliprd(-2-j,-j,-1+j).ae(1.8249027393703805305 - 1.2218475784827035855j)
+    # extra test cases
+    assert elliprg(0,0,0) == 0
+    assert elliprg(0,0,16).ae(2)
+    assert elliprg(0,16,0).ae(2)
+    assert elliprg(16,0,0).ae(2)
+    assert elliprg(1,4,0).ae(1.2110560275684595248036)
+    assert elliprg(1,0,4).ae(1.2110560275684595248036)
+    assert elliprg(0,4,1).ae(1.2110560275684595248036)
+    # should be symmetric -- fixes a bug present in the paper
+    x,y,z = 1,1j,-1+1j
+    assert elliprg(x,y,z).ae(0.64139146875812627545 + 0.58085463774808290907j)
+    assert elliprg(x,z,y).ae(0.64139146875812627545 + 0.58085463774808290907j)
+    assert elliprg(y,x,z).ae(0.64139146875812627545 + 0.58085463774808290907j)
+    assert elliprg(y,z,x).ae(0.64139146875812627545 + 0.58085463774808290907j)
+    assert elliprg(z,x,y).ae(0.64139146875812627545 + 0.58085463774808290907j)
+    assert elliprg(z,y,x).ae(0.64139146875812627545 + 0.58085463774808290907j)
+
+    for n in [5, 15, 30, 60, 100]:
+        mp.dps = n
+        assert elliprf(1,2,0).ae('1.3110287771460599052324197949455597068413774757158115814084108519003952935352071251151477664807145467230678763')
+        assert elliprf(0.5,1,0).ae('1.854074677301371918433850347195260046217598823521766905585928045056021776838119978357271861650371897277771871')
+        assert elliprf(j,-j,0).ae('1.854074677301371918433850347195260046217598823521766905585928045056021776838119978357271861650371897277771871')
+        assert elliprf(j-1,j,0).ae(mpc('0.79612586584233913293056938229563057846592264089185680214929401744498956943287031832657642790719940442165621412',
+            '-1.2138566698364959864300942567386038975419875860741507618279563735753073152507112254567291141460317931258599889'))
+        assert elliprf(2,3,4).ae('0.58408284167715170669284916892566789240351359699303216166309375305508295130412919665541330837704050454472379308')
+        assert elliprf(j,-j,2).ae('1.0441445654064360931078658361850779139591660747973017593275012615517220315993723776182276555339288363064476126')
+        assert elliprf(j-1,j,1-j).ae(mpc('0.93912050218619371196624617169781141161485651998254431830645241993282941057500174238125105410055253623847335313',
+            '-0.53296252018635269264859303449447908970360344322834582313172115220559316331271520508208025270300138589669326136'))
+        assert elliprc(0,0.25).ae(+pi)
+        assert elliprc(2.25,2).ae(+ln2)
+        assert elliprc(0,j).ae(mpc('1.1107207345395915617539702475151734246536554223439225557713489017391086982748684776438317336911913093408525532',
+            '-1.1107207345395915617539702475151734246536554223439225557713489017391086982748684776438317336911913093408525532'))
+        assert elliprc(-j,j).ae(mpc('1.2260849569072198222319655083097718755633725139745941606203839524036426936825652935738621522906572884239069297',
+            '-0.34471136988767679699935618332997956653521218571295874986708834375026550946053920574015526038040124556716711353'))
+        assert elliprc(0.25,-2).ae(ln2/3)
+        assert elliprc(j,-1).ae(mpc('0.77778596920447389875196055840799837589537035343923012237628610795937014001905822029050288316217145443865649819',
+            '0.1983248499342877364755170948292130095921681309577950696116251029742793455964385947473103628983664877025779304'))
+        assert elliprj(0,1,2,3).ae('0.77688623778582332014190282640545501102298064276022952731669118325952563819813258230708177398475643634103990878')
+        assert elliprj(2,3,4,5).ae('0.14297579667156753833233879421985774801466647854232626336218889885463800128817976132826443904216546421431528308')
+        assert elliprj(2,3,4,-1+j).ae(mpc('0.13613945827770535203521374457913768360237593025944342652613569368333226052158214183059386307242563164036672709',
+            '-0.38207561624427164249600936454845112611060375760094156571007648297226090050927156176977091273224510621553615189'))
+        assert elliprj(j,-j,0,2).ae('1.6490011662710884518243257224860232300246792717163891216346170272567376981346412066066050103935109581019055806')
+        assert elliprj(-1+j,-1-j,1,2).ae('0.94148358841220238083044612133767270187474673547917988681610772381758628963408843935027667916713866133196845063')
+        assert elliprj(j,-j,0,1-j).ae(mpc('1.8260115229009316249372594065790946657011067182850435297162034335356430755397401849070610280860044610878657501',
+            '1.2290661908643471500163617732957042849283739403009556715926326841959667290840290081010472716420690899886276961'))
+        assert elliprj(-1+j,-1-j,1,-3+j).ae(mpc('-0.61127970812028172123588152373622636829986597243716610650831553882054127570542477508023027578037045504958619422',
+            '-1.0684038390006807880182112972232562745485871763154040245065581157751693730095703406209466903752930797510491155'))
+        assert elliprj(-1+j,-2-j,-j,-1+j).ae(mpc('1.8249027393703805304622013339009022294368078659619988943515764258335975852685224202567854526307030593012768954',
+            '-1.2218475784827035854568450371590419833166777535029296025352291308244564398645467465067845461070602841312456831'))
+
+        assert elliprg(0,16,16).ae(+pi)
+        assert elliprg(2,3,4).ae('1.7255030280692277601061148835701141842692457170470456590515892070736643637303053506944907685301315299153040991')
+        assert elliprg(0,j,-j).ae('0.42360654239698954330324956174109581824072295516347109253028968632986700241706737986160014699730561497106114281')
+        assert elliprg(j-1,j,0).ae(mpc('0.44660591677018372656731970402124510811555212083508861036067729944477855594654762496407405328607219895053798354',
+            '0.70768352357515390073102719507612395221369717586839400605901402910893345301718731499237159587077682267374159282'))
+        assert elliprg(-j,j-1,j).ae(mpc('0.36023392184473309033675652092928695596803358846377334894215349632203382573844427952830064383286995172598964266',
+            '0.40348623401722113740956336997761033878615232917480045914551915169013722542827052849476969199578321834819903921'))
+        assert elliprg(0, mpf('0.0796'), 4).ae('1.0284758090288040009838871385180217366569777284430590125081211090574701293154645750017813190805144572673802094')
+    mp.dps = 15
+
+    # more test cases for the branch of ellippi / elliprj
+    assert elliprj(-1-0.5j, -10-6j, -10-3j, -5+10j).ae(0.128470516743927699 + 0.102175950778504625j, abs_eps=1e-8)
+    assert elliprj(1.987, 4.463 - 1.614j, 0, -3.965).ae(-0.341575118513811305 - 0.394703757004268486j, abs_eps=1e-8)
+    assert elliprj(0.3068, -4.037+0.632j, 1.654, -0.9609).ae(-1.14735199581485639 - 0.134450158867472264j, abs_eps=1e-8)
+    assert elliprj(0.3068, -4.037-0.632j, 1.654, -0.9609).ae(1.758765901861727 - 0.161002343366626892j, abs_eps=1e-5)
+    assert elliprj(0.3068, -4.037+0.0632j, 1.654, -0.9609).ae(-1.17157627949475577 - 0.069182614173988811j, abs_eps=1e-8)
+    assert elliprj(0.3068, -4.037+0.00632j, 1.654, -0.9609).ae(-1.17337595670549633 - 0.0623069224526925j, abs_eps=1e-8)
+
+    # these require accurate integration
+    assert elliprj(0.3068, -4.037-0.0632j, 1.654, -0.9609).ae(1.77940452391261626 + 0.0388711305592447234j)
+    assert elliprj(0.3068, -4.037-0.00632j, 1.654, -0.9609).ae(1.77806722756403055 + 0.0592749824572262329j)
+    # issue #571
+    assert ellippi(2.1 + 0.94j, 2.3 + 0.98j, 2.5 + 0.01j).ae(-0.40652414240811963438 + 2.1547659461404749309j)
+
+    assert ellippi(2.0-1.0j, 2.0+1.0j).ae(1.8578723151271115 - 1.18642180609983531j)
+    assert ellippi(2.0-0.5j, 0.5+1.0j).ae(0.936761970766645807 - 1.61876787838890786j)
+    assert ellippi(2.0, 1.0+1.0j).ae(0.999881420735506708 - 2.4139272867045391j)
+    assert ellippi(2.0+1.0j, 2.0-1.0j).ae(1.8578723151271115 + 1.18642180609983531j)
+    assert ellippi(2.0+1.0j, 2.0).ae(2.78474654927885845 + 2.02204728966993314j)
+
+def test_issue_238():
+    assert isnan(qfrom(m=nan))
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_fp.py b/lib/python3.10/site-packages/mpmath/tests/test_fp.py
new file mode 100644
index 0000000000000000000000000000000000000000..99f3759c3071c4d55e0481472f3d16c1f5df1fef
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_fp.py
@@ -0,0 +1,1671 @@
+"""
+Easy-to-use test-generating code:
+
+cases = '''
+exp 2.25
+log 2.25
+'''
+
+from mpmath import *
+mp.dps = 20
+for test in cases.splitlines():
+    if not test:
+        continue
+    words = test.split()
+    fname = words[0]
+    args = words[1:]
+    argstr = ", ".join(args)
+    testline = "%s(%s)" % (fname, argstr)
+    ans = str(eval(testline))
+    print "    assert ae(fp.%s, %s)" % (testline, ans)
+
+"""
+
+from mpmath import fp
+
+def ae(x, y, tol=1e-12):
+    if x == y:
+        return True
+    return abs(x-y) <= tol*abs(y)
+
+def test_conj():
+    assert fp.conj(4) == 4
+    assert fp.conj(3+4j) == 3-4j
+    assert fp.fdot([1,2],[3,2+1j], conjugate=True) == 7-2j
+
+def test_fp_number_parts():
+    assert ae(fp.arg(3), 0.0)
+    assert ae(fp.arg(-3), 3.1415926535897932385)
+    assert ae(fp.arg(3j), 1.5707963267948966192)
+    assert ae(fp.arg(-3j), -1.5707963267948966192)
+    assert ae(fp.arg(2+3j), 0.98279372324732906799)
+    assert ae(fp.arg(-1-1j), -2.3561944901923449288)
+    assert ae(fp.re(2.5), 2.5)
+    assert ae(fp.re(2.5+3j), 2.5)
+    assert ae(fp.im(2.5), 0.0)
+    assert ae(fp.im(2.5+3j), 3.0)
+    assert ae(fp.floor(2.5), 2.0)
+    assert ae(fp.floor(2), 2.0)
+    assert ae(fp.floor(2.0+0j), (2.0 + 0.0j))
+    assert ae(fp.floor(-1.5-0.5j), (-2.0 - 1.0j))
+    assert ae(fp.ceil(2.5), 3.0)
+    assert ae(fp.ceil(2), 2.0)
+    assert ae(fp.ceil(2.0+0j), (2.0 + 0.0j))
+    assert ae(fp.ceil(-1.5-0.5j), (-1.0 + 0.0j))
+
+def test_fp_cospi_sinpi():
+    assert ae(fp.sinpi(0), 0.0)
+    assert ae(fp.sinpi(0.25), 0.7071067811865475244)
+    assert ae(fp.sinpi(0.5), 1.0)
+    assert ae(fp.sinpi(0.75), 0.7071067811865475244)
+    assert ae(fp.sinpi(1), 0.0)
+    assert ae(fp.sinpi(1.25), -0.7071067811865475244)
+    assert ae(fp.sinpi(1.5), -1.0)
+    assert ae(fp.sinpi(1.75), -0.7071067811865475244)
+    assert ae(fp.sinpi(2), 0.0)
+    assert ae(fp.sinpi(2.25), 0.7071067811865475244)
+    assert ae(fp.sinpi(0+3j), (0.0 + 6195.8238636085899556j))
+    assert ae(fp.sinpi(0.25+3j), (4381.1091260582448033 + 4381.1090689950686908j))
+    assert ae(fp.sinpi(0.5+3j), (6195.8239443081075259 + 0.0j))
+    assert ae(fp.sinpi(0.75+3j), (4381.1091260582448033 - 4381.1090689950686908j))
+    assert ae(fp.sinpi(1+3j), (0.0 - 6195.8238636085899556j))
+    assert ae(fp.sinpi(1.25+3j), (-4381.1091260582448033 - 4381.1090689950686908j))
+    assert ae(fp.sinpi(1.5+3j), (-6195.8239443081075259 + 0.0j))
+    assert ae(fp.sinpi(1.75+3j), (-4381.1091260582448033 + 4381.1090689950686908j))
+    assert ae(fp.sinpi(2+3j), (0.0 + 6195.8238636085899556j))
+    assert ae(fp.sinpi(2.25+3j), (4381.1091260582448033 + 4381.1090689950686908j))
+    assert ae(fp.sinpi(-0.75), -0.7071067811865475244)
+    assert ae(fp.sinpi(-1e-10), -3.1415926535897933529e-10)
+    assert ae(fp.sinpi(1e-10), 3.1415926535897933529e-10)
+    assert ae(fp.sinpi(1e-10+1e-10j), (3.141592653589793353e-10 + 3.1415926535897933528e-10j))
+    assert ae(fp.sinpi(1e-10-1e-10j), (3.141592653589793353e-10 - 3.1415926535897933528e-10j))
+    assert ae(fp.sinpi(-1e-10+1e-10j), (-3.141592653589793353e-10 + 3.1415926535897933528e-10j))
+    assert ae(fp.sinpi(-1e-10-1e-10j), (-3.141592653589793353e-10 - 3.1415926535897933528e-10j))
+    assert ae(fp.cospi(0), 1.0)
+    assert ae(fp.cospi(0.25), 0.7071067811865475244)
+    assert ae(fp.cospi(0.5), 0.0)
+    assert ae(fp.cospi(0.75), -0.7071067811865475244)
+    assert ae(fp.cospi(1), -1.0)
+    assert ae(fp.cospi(1.25), -0.7071067811865475244)
+    assert ae(fp.cospi(1.5), 0.0)
+    assert ae(fp.cospi(1.75), 0.7071067811865475244)
+    assert ae(fp.cospi(2), 1.0)
+    assert ae(fp.cospi(2.25), 0.7071067811865475244)
+    assert ae(fp.cospi(0+3j), (6195.8239443081075259 + 0.0j))
+    assert ae(fp.cospi(0.25+3j), (4381.1091260582448033 - 4381.1090689950686908j))
+    assert ae(fp.cospi(0.5+3j), (0.0 - 6195.8238636085899556j))
+    assert ae(fp.cospi(0.75+3j), (-4381.1091260582448033 - 4381.1090689950686908j))
+    assert ae(fp.cospi(1+3j), (-6195.8239443081075259 + 0.0j))
+    assert ae(fp.cospi(1.25+3j), (-4381.1091260582448033 + 4381.1090689950686908j))
+    assert ae(fp.cospi(1.5+3j), (0.0 + 6195.8238636085899556j))
+    assert ae(fp.cospi(1.75+3j), (4381.1091260582448033 + 4381.1090689950686908j))
+    assert ae(fp.cospi(2+3j), (6195.8239443081075259 + 0.0j))
+    assert ae(fp.cospi(2.25+3j), (4381.1091260582448033 - 4381.1090689950686908j))
+    assert ae(fp.cospi(-0.75), -0.7071067811865475244)
+    assert ae(fp.sinpi(-0.7), -0.80901699437494750611)
+    assert ae(fp.cospi(-0.7), -0.5877852522924730163)
+    assert ae(fp.cospi(-3+2j), (-267.74676148374822225 + 0.0j))
+    assert ae(fp.sinpi(-3+2j), (0.0 - 267.74489404101651426j))
+    assert ae(fp.sinpi(-0.7+2j), (-216.6116802292079471 - 157.37650009392034693j))
+    assert ae(fp.cospi(-0.7+2j), (-157.37759774921754565 + 216.61016943630197336j))
+
+def test_fp_expj():
+    assert ae(fp.expj(0), (1.0 + 0.0j))
+    assert ae(fp.expj(1), (0.5403023058681397174 + 0.84147098480789650665j))
+    assert ae(fp.expj(2), (-0.416146836547142387 + 0.9092974268256816954j))
+    assert ae(fp.expj(0.75), (0.73168886887382088631 + 0.68163876002333416673j))
+    assert ae(fp.expj(2+3j), (-0.020718731002242879378 + 0.045271253156092975488j))
+    assert ae(fp.expjpi(0), (1.0 + 0.0j))
+    assert ae(fp.expjpi(1), (-1.0 + 0.0j))
+    assert ae(fp.expjpi(2), (1.0 + 0.0j))
+    assert ae(fp.expjpi(0.75), (-0.7071067811865475244 + 0.7071067811865475244j))
+    assert ae(fp.expjpi(2+3j), (0.000080699517570304599239 + 0.0j))
+
+def test_fp_bernoulli():
+    assert ae(fp.bernoulli(0), 1.0)
+    assert ae(fp.bernoulli(1), -0.5)
+    assert ae(fp.bernoulli(2), 0.16666666666666666667)
+    assert ae(fp.bernoulli(10), 0.075757575757575757576)
+    assert ae(fp.bernoulli(11), 0.0)
+
+def test_fp_gamma():
+    assert ae(fp.gamma(1), 1.0)
+    assert ae(fp.gamma(1.5), 0.88622692545275801365)
+    assert ae(fp.gamma(10), 362880.0)
+    assert ae(fp.gamma(-0.5), -3.5449077018110320546)
+    assert ae(fp.gamma(-7.1), 0.0016478244570263333622)
+    assert ae(fp.gamma(12.3), 83385367.899970000963)
+    assert ae(fp.gamma(2+0j), (1.0 + 0.0j))
+    assert ae(fp.gamma(-2.5+0j), (-0.94530872048294188123 + 0.0j))
+    assert ae(fp.gamma(3+4j), (0.0052255384713692141947 - 0.17254707929430018772j))
+    assert ae(fp.gamma(-3-4j), (0.00001460997305874775607 - 0.000020760733311509070396j))
+    assert ae(fp.fac(0), 1.0)
+    assert ae(fp.fac(1), 1.0)
+    assert ae(fp.fac(20), 2432902008176640000.0)
+    assert ae(fp.fac(-3.5), -0.94530872048294188123)
+    assert ae(fp.fac(2+3j), (-0.44011340763700171113 - 0.06363724312631702183j))
+    assert ae(fp.loggamma(1.0), 0.0)
+    assert ae(fp.loggamma(2.0), 0.0)
+    assert ae(fp.loggamma(3.0), 0.69314718055994530942)
+    assert ae(fp.loggamma(7.25), 7.0521854507385394449)
+    assert ae(fp.loggamma(1000.0), 5905.2204232091812118)
+    assert ae(fp.loggamma(1e50), 1.1412925464970229298e+52)
+    assert ae(fp.loggamma(1e25+1e25j), (5.6125802751733671621e+26 + 5.7696599078528568383e+26j))
+    assert ae(fp.loggamma(3+4j), (-1.7566267846037841105 + 4.7426644380346579282j))
+    assert ae(fp.loggamma(-0.5), (1.2655121234846453965 - 3.1415926535897932385j))
+    assert ae(fp.loggamma(-1.25), (1.3664317612369762346 - 6.2831853071795864769j))
+    assert ae(fp.loggamma(-2.75), (0.0044878975359557733115 - 9.4247779607693797154j))
+    assert ae(fp.loggamma(-3.5), (-1.3090066849930420464 - 12.566370614359172954j))
+    assert ae(fp.loggamma(-4.5), (-2.8130840817693161197 - 15.707963267948966192j))
+    assert ae(fp.loggamma(-2+3j), (-6.776523813485657093 - 4.568791367260286402j))
+    assert ae(fp.loggamma(-1000.3), (-5912.8440347785205041 - 3144.7342462433830317j))
+    assert ae(fp.loggamma(-100-100j), (-632.35117666833135562 - 158.37641469650352462j))
+    assert ae(fp.loggamma(1e-10), 23.025850929882735237)
+    assert ae(fp.loggamma(-1e-10), (23.02585092999817837 - 3.1415926535897932385j))
+    assert ae(fp.loggamma(1e-10j), (23.025850929940456804 - 1.5707963268526181857j))
+    assert ae(fp.loggamma(1e-10j-1e-10), (22.679277339718205716 - 2.3561944902500664954j))
+
+def test_fp_psi():
+    assert ae(fp.psi(0, 3.7), 1.1671535393615114409)
+    assert ae(fp.psi(0, 0.5), -1.9635100260214234794)
+    assert ae(fp.psi(0, 1), -0.57721566490153286061)
+    assert ae(fp.psi(0, -2.5), 1.1031566406452431872)
+    assert ae(fp.psi(0, 12.9), 2.5179671503279156347)
+    assert ae(fp.psi(0, 100), 4.6001618527380874002)
+    assert ae(fp.psi(0, 2500.3), 7.8239660143238547877)
+    assert ae(fp.psi(0, 1e40), 92.103403719761827391)
+    assert ae(fp.psi(0, 1e200), 460.51701859880913677)
+    assert ae(fp.psi(0, 3.7+0j), (1.1671535393615114409 + 0.0j))
+    assert ae(fp.psi(1, 3), 0.39493406684822643647)
+    assert ae(fp.psi(3, 2+3j), (-0.05383196209159972116 + 0.0076890935247364805218j))
+    assert ae(fp.psi(4, -0.5+1j), (1.2719531355492328195 - 18.211833410936276774j))
+    assert ae(fp.harmonic(0), 0.0)
+    assert ae(fp.harmonic(1), 1.0)
+    assert ae(fp.harmonic(2), 1.5)
+    assert ae(fp.harmonic(100), 5.1873775176396202608)
+    assert ae(fp.harmonic(-2.5), 1.2803723055467760478)
+    assert ae(fp.harmonic(2+3j), (1.9390425294578375875 + 0.87336044981834544043j))
+    assert ae(fp.harmonic(-5-4j), (2.3725754822349437733 - 2.4160904444801621j))
+
+def test_fp_zeta():
+    assert ae(fp.zeta(1e100), 1.0)
+    assert ae(fp.zeta(3), 1.2020569031595942854)
+    assert ae(fp.zeta(2+0j), (1.6449340668482264365 + 0.0j))
+    assert ae(fp.zeta(0.93), -13.713619351638164784)
+    assert ae(fp.zeta(1.74), 1.9796863545771774095)
+    assert ae(fp.zeta(0.0), -0.5)
+    assert ae(fp.zeta(-1.0), -0.083333333333333333333)
+    assert ae(fp.zeta(-2.0), 0.0)
+    assert ae(fp.zeta(-3.0), 0.0083333333333333333333)
+    assert ae(fp.zeta(-500.0), 0.0)
+    assert ae(fp.zeta(-7.4), 0.0036537321227995882447)
+    assert ae(fp.zeta(2.1), 1.5602165335033620158)
+    assert ae(fp.zeta(26.9), 1.0000000079854809935)
+    assert ae(fp.zeta(26), 1.0000000149015548284)
+    assert ae(fp.zeta(27), 1.0000000074507117898)
+    assert ae(fp.zeta(28), 1.0000000037253340248)
+    assert ae(fp.zeta(27.1), 1.000000006951755045)
+    assert ae(fp.zeta(32.7), 1.0000000001433243232)
+    assert ae(fp.zeta(100), 1.0)
+    assert ae(fp.altzeta(3.5), 0.92755357777394803511)
+    assert ae(fp.altzeta(1), 0.69314718055994530942)
+    assert ae(fp.altzeta(2), 0.82246703342411321824)
+    assert ae(fp.altzeta(0), 0.5)
+    assert ae(fp.zeta(-2+3j, 1), (0.13297115587929864827 + 0.12305330040458776494j))
+    assert ae(fp.zeta(-2+3j, 5), (18.384866151867576927 - 11.377015110597711009j))
+    assert ae(fp.zeta(1.0000000001), 9999999173.1735741337)
+    assert ae(fp.zeta(0.9999999999), -9999999172.0191428039)
+    assert ae(fp.zeta(1+0.000000001j), (0.57721566490153286061 - 999999999.99999993765j))
+    assert ae(fp.primezeta(2.5+4j), (-0.16922458243438033385 - 0.010847965298387727811j))
+    assert ae(fp.primezeta(4), 0.076993139764246844943)
+    assert ae(fp.riemannr(3.7), 2.3034079839110855717)
+    assert ae(fp.riemannr(8), 3.9011860449341499474)
+    assert ae(fp.riemannr(3+4j), (2.2369653314259991796 + 1.6339943856990281694j))
+
+def test_fp_hyp2f1():
+    assert ae(fp.hyp2f1(1, (3,2), 3.25, 5.0), (-0.46600275923108143059 - 0.74393667908854842325j))
+    assert ae(fp.hyp2f1(1+1j, (3,2), 3.25, 5.0), (-5.9208875603806515987 - 2.3813557707889590686j))
+    assert ae(fp.hyp2f1(1+1j, (3,2), 3.25, 2+3j), (0.17174552030925080445 + 0.19589781970539389999j))
+
+def test_fp_erf():
+    assert fp.erf(2) == fp.erf(2.0) == fp.erf(2.0+0.0j)
+    assert fp.erf(fp.inf) == 1.0
+    assert fp.erf(fp.ninf) == -1.0
+    assert ae(fp.erf(0), 0.0)
+    assert ae(fp.erf(-0), -0.0)
+    assert ae(fp.erf(0.3), 0.32862675945912741619)
+    assert ae(fp.erf(-0.3), -0.32862675945912741619)
+    assert ae(fp.erf(0.9), 0.79690821242283213966)
+    assert ae(fp.erf(-0.9), -0.79690821242283213966)
+    assert ae(fp.erf(1.0), 0.84270079294971486934)
+    assert ae(fp.erf(-1.0), -0.84270079294971486934)
+    assert ae(fp.erf(1.1), 0.88020506957408172966)
+    assert ae(fp.erf(-1.1), -0.88020506957408172966)
+    assert ae(fp.erf(8.5), 1.0)
+    assert ae(fp.erf(-8.5), -1.0)
+    assert ae(fp.erf(9.1), 1.0)
+    assert ae(fp.erf(-9.1), -1.0)
+    assert ae(fp.erf(20.0), 1.0)
+    assert ae(fp.erf(-20.0), -1.0)
+    assert ae(fp.erf(10000.0), 1.0)
+    assert ae(fp.erf(-10000.0), -1.0)
+    assert ae(fp.erf(1e+50), 1.0)
+    assert ae(fp.erf(-1e+50), -1.0)
+    assert ae(fp.erf(1j), 1.650425758797542876j)
+    assert ae(fp.erf(-1j), -1.650425758797542876j)
+    assert ae(fp.erf((2+3j)), (-20.829461427614568389 + 8.6873182714701631444j))
+    assert ae(fp.erf(-(2+3j)), -(-20.829461427614568389 + 8.6873182714701631444j))
+    assert ae(fp.erf((8+9j)), (-1072004.2525062051158 + 364149.91954310255423j))
+    assert ae(fp.erf(-(8+9j)), -(-1072004.2525062051158 + 364149.91954310255423j))
+    assert fp.erfc(fp.inf) == 0.0
+    assert fp.erfc(fp.ninf) == 2.0
+    assert fp.erfc(0) == 1
+    assert fp.erfc(-0.0) == 1
+    assert fp.erfc(0+0j) == 1
+    assert ae(fp.erfc(0.3), 0.67137324054087258381)
+    assert ae(fp.erfc(-0.3), 1.3286267594591274162)
+    assert ae(fp.erfc(0.9), 0.20309178757716786034)
+    assert ae(fp.erfc(-0.9), 1.7969082124228321397)
+    assert ae(fp.erfc(1.0), 0.15729920705028513066)
+    assert ae(fp.erfc(-1.0), 1.8427007929497148693)
+    assert ae(fp.erfc(1.1), 0.11979493042591827034)
+    assert ae(fp.erfc(-1.1), 1.8802050695740817297)
+    assert ae(fp.erfc(8.5), 2.7623240713337714461e-33)
+    assert ae(fp.erfc(-8.5), 2.0)
+    assert ae(fp.erfc(9.1), 6.6969004279886077452e-38)
+    assert ae(fp.erfc(-9.1), 2.0)
+    assert ae(fp.erfc(20.0), 5.3958656116079009289e-176)
+    assert ae(fp.erfc(-20.0), 2.0)
+    assert ae(fp.erfc(10000.0), 0.0)
+    assert ae(fp.erfc(-10000.0), 2.0)
+    assert ae(fp.erfc(1e+50), 0.0)
+    assert ae(fp.erfc(-1e+50), 2.0)
+    assert ae(fp.erfc(1j), (1.0 - 1.650425758797542876j))
+    assert ae(fp.erfc(-1j), (1.0 + 1.650425758797542876j))
+    assert ae(fp.erfc((2+3j)), (21.829461427614568389 - 8.6873182714701631444j), 1e-13)
+    assert ae(fp.erfc(-(2+3j)), (-19.829461427614568389 + 8.6873182714701631444j), 1e-13)
+    assert ae(fp.erfc((8+9j)), (1072005.2525062051158 - 364149.91954310255423j))
+    assert ae(fp.erfc(-(8+9j)), (-1072003.2525062051158 + 364149.91954310255423j))
+    assert ae(fp.erfc(20+0j), (5.3958656116079009289e-176 + 0.0j))
+
+def test_fp_lambertw():
+    assert ae(fp.lambertw(0.0), 0.0)
+    assert ae(fp.lambertw(1.0), 0.567143290409783873)
+    assert ae(fp.lambertw(7.5), 1.5662309537823875394)
+    assert ae(fp.lambertw(-0.25), -0.35740295618138890307)
+    assert ae(fp.lambertw(-10.0), (1.3699809685212708156 + 2.140194527074713196j))
+    assert ae(fp.lambertw(0+0j), (0.0 + 0.0j))
+    assert ae(fp.lambertw(4+0j), (1.2021678731970429392 + 0.0j))
+    assert ae(fp.lambertw(1000.5), 5.2500227450408980127)
+    assert ae(fp.lambertw(1e100), 224.84310644511850156)
+    assert ae(fp.lambertw(-1000.0), (5.1501630246362515223 + 2.6641981432905204596j))
+    assert ae(fp.lambertw(1e-10), 9.9999999990000003645e-11)
+    assert ae(fp.lambertw(1e-10j), (1.0000000000000000728e-20 + 1.0000000000000000364e-10j))
+    assert ae(fp.lambertw(3+4j), (1.2815618061237758782 + 0.53309522202097107131j))
+    assert ae(fp.lambertw(-3-4j), (1.0750730665692549276 - 1.3251023817343588823j))
+    assert ae(fp.lambertw(10000+1000j), (7.2361526563371602186 + 0.087567810943839352034j))
+    assert ae(fp.lambertw(0.0, -1), -fp.inf)
+    assert ae(fp.lambertw(1.0, -1), (-1.5339133197935745079 - 4.3751851530618983855j))
+    assert ae(fp.lambertw(7.5, -1), (0.44125668415098614999 - 4.8039842008452390179j))
+    assert ae(fp.lambertw(-0.25, -1), -2.1532923641103496492)
+    assert ae(fp.lambertw(-10.0, -1), (1.3699809685212708156 - 2.140194527074713196j))
+    assert ae(fp.lambertw(0+0j, -1), -fp.inf)
+    assert ae(fp.lambertw(4+0j, -1), (-0.15730793189620765317 - 4.6787800704666656212j))
+    assert ae(fp.lambertw(1000.5, -1), (4.9153765415404024736 - 5.4465682700815159569j))
+    assert ae(fp.lambertw(1e100, -1), (224.84272130101601052 - 6.2553713838167244141j))
+    assert ae(fp.lambertw(-1000.0, -1), (5.1501630246362515223 - 2.6641981432905204596j))
+    assert ae(fp.lambertw(1e-10, -1), (-26.303186778379041521 - 3.2650939117038283975j))
+    assert ae(fp.lambertw(1e-10j, -1), (-26.297238779529035028 - 1.6328071613455765135j))
+    assert ae(fp.lambertw(3+4j, -1), (0.25856740686699741676 - 3.8521166861614355895j))
+    assert ae(fp.lambertw(-3-4j, -1), (-0.32028750204310768396 - 6.8801677192091972343j))
+    assert ae(fp.lambertw(10000+1000j, -1), (7.0255308742285435567 - 5.5177506835734067601j))
+    assert ae(fp.lambertw(0.0, 2), -fp.inf)
+    assert ae(fp.lambertw(1.0, 2), (-2.4015851048680028842 + 10.776299516115070898j))
+    assert ae(fp.lambertw(7.5, 2), (-0.38003357962843791529 + 10.960916473368746184j))
+    assert ae(fp.lambertw(-0.25, 2), (-4.0558735269061511898 + 13.852334658567271386j))
+    assert ae(fp.lambertw(-10.0, 2), (-0.34479123764318858696 + 14.112740596763592363j))
+    assert ae(fp.lambertw(0+0j, 2), -fp.inf)
+    assert ae(fp.lambertw(4+0j, 2), (-1.0070343323804262788 + 10.903476551861683082j))
+    assert ae(fp.lambertw(1000.5, 2), (4.4076185165459395295 + 11.365524591091402177j))
+    assert ae(fp.lambertw(1e100, 2), (224.84156762724875878 + 12.510785262632255672j))
+    assert ae(fp.lambertw(-1000.0, 2), (4.1984245610246530756 + 14.420478573754313845j))
+    assert ae(fp.lambertw(1e-10, 2), (-26.362258095445866488 + 9.7800247407031482519j))
+    assert ae(fp.lambertw(1e-10j, 2), (-26.384250801683084252 + 11.403535950607739763j))
+    assert ae(fp.lambertw(3+4j, 2), (-0.86554679943333993562 + 11.849956798331992027j))
+    assert ae(fp.lambertw(-3-4j, 2), (-0.55792273874679112639 + 8.7173627024159324811j))
+    assert ae(fp.lambertw(10000+1000j, 2), (6.6223802254585662734 + 11.61348646825020766j))
+
+def test_fp_stress_ei_e1():
+    # Can be tightened on recent Pythons with more accurate math/cmath
+    ATOL = 1e-13
+    PTOL = 1e-12
+    v = fp.e1(1.1641532182693481445e-10)
+    assert ae(v, 22.296641293693077672, tol=ATOL)
+    assert type(v) is float
+    v = fp.e1(0.25)
+    assert ae(v, 1.0442826344437381945, tol=ATOL)
+    assert type(v) is float
+    v = fp.e1(1.0)
+    assert ae(v, 0.21938393439552027368, tol=ATOL)
+    assert type(v) is float
+    v = fp.e1(2.0)
+    assert ae(v, 0.048900510708061119567, tol=ATOL)
+    assert type(v) is float
+    v = fp.e1(5.0)
+    assert ae(v, 0.0011482955912753257973, tol=ATOL)
+    assert type(v) is float
+    v = fp.e1(20.0)
+    assert ae(v, 9.8355252906498816904e-11, tol=ATOL)
+    assert type(v) is float
+    v = fp.e1(30.0)
+    assert ae(v, 3.0215520106888125448e-15, tol=ATOL)
+    assert type(v) is float
+    v = fp.e1(40.0)
+    assert ae(v, 1.0367732614516569722e-19, tol=ATOL)
+    assert type(v) is float
+    v = fp.e1(50.0)
+    assert ae(v, 3.7832640295504590187e-24, tol=ATOL)
+    assert type(v) is float
+    v = fp.e1(80.0)
+    assert ae(v, 2.2285432586884729112e-37, tol=ATOL)
+    assert type(v) is float
+    v = fp.e1((1.1641532182693481445e-10 + 0.0j))
+    assert ae(v, (22.296641293693077672 + 0.0j), tol=ATOL)
+    assert ae(v.real, 22.296641293693077672, tol=PTOL)
+    assert v.imag == 0
+    v = fp.e1((0.25 + 0.0j))
+    assert ae(v, (1.0442826344437381945 + 0.0j), tol=ATOL)
+    assert ae(v.real, 1.0442826344437381945, tol=PTOL)
+    assert v.imag == 0
+    v = fp.e1((1.0 + 0.0j))
+    assert ae(v, (0.21938393439552027368 + 0.0j), tol=ATOL)
+    assert ae(v.real, 0.21938393439552027368, tol=PTOL)
+    assert v.imag == 0
+    v = fp.e1((2.0 + 0.0j))
+    assert ae(v, (0.048900510708061119567 + 0.0j), tol=ATOL)
+    assert ae(v.real, 0.048900510708061119567, tol=PTOL)
+    assert v.imag == 0
+    v = fp.e1((5.0 + 0.0j))
+    assert ae(v, (0.0011482955912753257973 + 0.0j), tol=ATOL)
+    assert ae(v.real, 0.0011482955912753257973, tol=PTOL)
+    assert v.imag == 0
+    v = fp.e1((20.0 + 0.0j))
+    assert ae(v, (9.8355252906498816904e-11 + 0.0j), tol=ATOL)
+    assert ae(v.real, 9.8355252906498816904e-11, tol=PTOL)
+    assert v.imag == 0
+    v = fp.e1((30.0 + 0.0j))
+    assert ae(v, (3.0215520106888125448e-15 + 0.0j), tol=ATOL)
+    assert ae(v.real, 3.0215520106888125448e-15, tol=PTOL)
+    assert v.imag == 0
+    v = fp.e1((40.0 + 0.0j))
+    assert ae(v, (1.0367732614516569722e-19 + 0.0j), tol=ATOL)
+    assert ae(v.real, 1.0367732614516569722e-19, tol=PTOL)
+    assert v.imag == 0
+    v = fp.e1((50.0 + 0.0j))
+    assert ae(v, (3.7832640295504590187e-24 + 0.0j), tol=ATOL)
+    assert ae(v.real, 3.7832640295504590187e-24, tol=PTOL)
+    assert v.imag == 0
+    v = fp.e1((80.0 + 0.0j))
+    assert ae(v, (2.2285432586884729112e-37 + 0.0j), tol=ATOL)
+    assert ae(v.real, 2.2285432586884729112e-37, tol=PTOL)
+    assert v.imag == 0
+    v = fp.e1((4.6566128730773925781e-10 + 1.1641532182693481445e-10j))
+    assert ae(v, (20.880034622014215597 - 0.24497866301044883237j), tol=ATOL)
+    assert ae(v.real, 20.880034622014215597, tol=PTOL)
+    assert ae(v.imag, -0.24497866301044883237, tol=PTOL)
+    v = fp.e1((1.0 + 0.25j))
+    assert ae(v, (0.19731063945004229095 - 0.087366045774299963672j), tol=ATOL)
+    assert ae(v.real, 0.19731063945004229095, tol=PTOL)
+    assert ae(v.imag, -0.087366045774299963672, tol=PTOL)
+    v = fp.e1((4.0 + 1.0j))
+    assert ae(v, (0.0013106173980145506944 - 0.0034542480199350626699j), tol=ATOL)
+    assert ae(v.real, 0.0013106173980145506944, tol=PTOL)
+    assert ae(v.imag, -0.0034542480199350626699, tol=PTOL)
+    v = fp.e1((8.0 + 2.0j))
+    assert ae(v, (-0.000022278049065270225945 - 0.000029191940456521555288j), tol=ATOL)
+    assert ae(v.real, -0.000022278049065270225945, tol=PTOL)
+    assert ae(v.imag, -0.000029191940456521555288, tol=PTOL)
+    v = fp.e1((20.0 + 5.0j))
+    assert ae(v, (4.7711374515765346894e-11 + 8.2902652405126947359e-11j), tol=ATOL)
+    assert ae(v.real, 4.7711374515765346894e-11, tol=PTOL)
+    assert ae(v.imag, 8.2902652405126947359e-11, tol=PTOL)
+    v = fp.e1((80.0 + 20.0j))
+    assert ae(v, (3.8353473865788235787e-38 - 2.129247592349605139e-37j), tol=ATOL)
+    assert ae(v.real, 3.8353473865788235787e-38, tol=PTOL)
+    assert ae(v.imag, -2.129247592349605139e-37, tol=PTOL)
+    v = fp.e1((120.0 + 30.0j))
+    assert ae(v, (2.3836002337480334716e-55 + 5.6704043587126198306e-55j), tol=ATOL)
+    assert ae(v.real, 2.3836002337480334716e-55, tol=PTOL)
+    assert ae(v.imag, 5.6704043587126198306e-55, tol=PTOL)
+    v = fp.e1((160.0 + 40.0j))
+    assert ae(v, (-1.6238022898654510661e-72 - 1.104172355572287367e-72j), tol=ATOL)
+    assert ae(v.real, -1.6238022898654510661e-72, tol=PTOL)
+    assert ae(v.imag, -1.104172355572287367e-72, tol=PTOL)
+    v = fp.e1((200.0 + 50.0j))
+    assert ae(v, (6.6800061461666228487e-90 + 1.4473816083541016115e-91j), tol=ATOL)
+    assert ae(v.real, 6.6800061461666228487e-90, tol=PTOL)
+    assert ae(v.imag, 1.4473816083541016115e-91, tol=PTOL)
+    v = fp.e1((320.0 + 80.0j))
+    assert ae(v, (4.2737871527778786157e-143 + 3.1789935525785660314e-142j), tol=ATOL)
+    assert ae(v.real, 4.2737871527778786157e-143, tol=PTOL)
+    assert ae(v.imag, 3.1789935525785660314e-142, tol=PTOL)
+    v = fp.e1((1.1641532182693481445e-10 + 1.1641532182693481445e-10j))
+    assert ae(v, (21.950067703413105017 - 0.7853981632810329878j), tol=ATOL)
+    assert ae(v.real, 21.950067703413105017, tol=PTOL)
+    assert ae(v.imag, -0.7853981632810329878, tol=PTOL)
+    v = fp.e1((0.25 + 0.25j))
+    assert ae(v, (0.71092525792923287894 - 0.56491812441304194711j), tol=ATOL)
+    assert ae(v.real, 0.71092525792923287894, tol=PTOL)
+    assert ae(v.imag, -0.56491812441304194711, tol=PTOL)
+    v = fp.e1((1.0 + 1.0j))
+    assert ae(v, (0.00028162445198141832551 - 0.17932453503935894015j), tol=ATOL)
+    assert ae(v.real, 0.00028162445198141832551, tol=PTOL)
+    assert ae(v.imag, -0.17932453503935894015, tol=PTOL)
+    v = fp.e1((2.0 + 2.0j))
+    assert ae(v, (-0.033767089606562004246 - 0.018599414169750541925j), tol=ATOL)
+    assert ae(v.real, -0.033767089606562004246, tol=PTOL)
+    assert ae(v.imag, -0.018599414169750541925, tol=PTOL)
+    v = fp.e1((5.0 + 5.0j))
+    assert ae(v, (0.0007266506660356393891 + 0.00047102780163522245054j), tol=ATOL)
+    assert ae(v.real, 0.0007266506660356393891, tol=PTOL)
+    assert ae(v.imag, 0.00047102780163522245054, tol=PTOL)
+    v = fp.e1((20.0 + 20.0j))
+    assert ae(v, (-2.3824537449367396579e-11 - 6.6969873156525615158e-11j), tol=ATOL)
+    assert ae(v.real, -2.3824537449367396579e-11, tol=PTOL)
+    assert ae(v.imag, -6.6969873156525615158e-11, tol=PTOL)
+    v = fp.e1((30.0 + 30.0j))
+    assert ae(v, (1.7316045841744061617e-15 + 1.3065678019487308689e-15j), tol=ATOL)
+    assert ae(v.real, 1.7316045841744061617e-15, tol=PTOL)
+    assert ae(v.imag, 1.3065678019487308689e-15, tol=PTOL)
+    v = fp.e1((40.0 + 40.0j))
+    assert ae(v, (-7.4001043002899232182e-20 - 4.991847855336816304e-21j), tol=ATOL)
+    assert ae(v.real, -7.4001043002899232182e-20, tol=PTOL)
+    assert ae(v.imag, -4.991847855336816304e-21, tol=PTOL)
+    v = fp.e1((50.0 + 50.0j))
+    assert ae(v, (2.3566128324644641219e-24 - 1.3188326726201614778e-24j), tol=ATOL)
+    assert ae(v.real, 2.3566128324644641219e-24, tol=PTOL)
+    assert ae(v.imag, -1.3188326726201614778e-24, tol=PTOL)
+    v = fp.e1((80.0 + 80.0j))
+    assert ae(v, (9.8279750572186526673e-38 + 1.243952841288868831e-37j), tol=ATOL)
+    assert ae(v.real, 9.8279750572186526673e-38, tol=PTOL)
+    assert ae(v.imag, 1.243952841288868831e-37, tol=PTOL)
+    v = fp.e1((1.1641532182693481445e-10 + 4.6566128730773925781e-10j))
+    assert ae(v, (20.880034621664969632 - 1.3258176632023711778j), tol=ATOL)
+    assert ae(v.real, 20.880034621664969632, tol=PTOL)
+    assert ae(v.imag, -1.3258176632023711778, tol=PTOL)
+    v = fp.e1((0.25 + 1.0j))
+    assert ae(v, (-0.16868306393667788761 - 0.4858011885947426971j), tol=ATOL)
+    assert ae(v.real, -0.16868306393667788761, tol=PTOL)
+    assert ae(v.imag, -0.4858011885947426971, tol=PTOL)
+    v = fp.e1((1.0 + 4.0j))
+    assert ae(v, (0.03373591813926547318 + 0.073523452241083821877j), tol=ATOL)
+    assert ae(v.real, 0.03373591813926547318, tol=PTOL)
+    assert ae(v.imag, 0.073523452241083821877, tol=PTOL)
+    v = fp.e1((2.0 + 8.0j))
+    assert ae(v, (-0.015392833434733785143 - 0.0031747121557605415914j), tol=ATOL)
+    assert ae(v.real, -0.015392833434733785143, tol=PTOL)
+    assert ae(v.imag, -0.0031747121557605415914, tol=PTOL)
+    v = fp.e1((5.0 + 20.0j))
+    assert ae(v, (-0.00024419662286542966525 - 0.00021008322966152755674j), tol=ATOL)
+    assert ae(v.real, -0.00024419662286542966525, tol=PTOL)
+    assert ae(v.imag, -0.00021008322966152755674, tol=PTOL)
+    v = fp.e1((20.0 + 80.0j))
+    assert ae(v, (2.3255552781051330088e-11 + 8.9463918891349438007e-12j), tol=ATOL)
+    assert ae(v.real, 2.3255552781051330088e-11, tol=PTOL)
+    assert ae(v.imag, 8.9463918891349438007e-12, tol=PTOL)
+    v = fp.e1((30.0 + 120.0j))
+    assert ae(v, (-2.7068919097124652332e-16 - 7.0477762411705130239e-16j), tol=ATOL)
+    assert ae(v.real, -2.7068919097124652332e-16, tol=PTOL)
+    assert ae(v.imag, -7.0477762411705130239e-16, tol=PTOL)
+    v = fp.e1((40.0 + 160.0j))
+    assert ae(v, (-1.1695597827678024687e-20 + 2.2907401455645736661e-20j), tol=ATOL)
+    assert ae(v.real, -1.1695597827678024687e-20, tol=PTOL)
+    assert ae(v.imag, 2.2907401455645736661e-20, tol=PTOL)
+    v = fp.e1((50.0 + 200.0j))
+    assert ae(v, (9.0323746914410162531e-25 - 2.3950601790033530935e-25j), tol=ATOL)
+    assert ae(v.real, 9.0323746914410162531e-25, tol=PTOL)
+    assert ae(v.imag, -2.3950601790033530935e-25, tol=PTOL)
+    v = fp.e1((80.0 + 320.0j))
+    assert ae(v, (3.4819106748728063576e-38 - 4.215653005615772724e-38j), tol=ATOL)
+    assert ae(v.real, 3.4819106748728063576e-38, tol=PTOL)
+    assert ae(v.imag, -4.215653005615772724e-38, tol=PTOL)
+    v = fp.e1((0.0 + 1.1641532182693481445e-10j))
+    assert ae(v, (22.29664129357666235 - 1.5707963266784812974j), tol=ATOL)
+    assert ae(v.real, 22.29664129357666235, tol=PTOL)
+    assert ae(v.imag, -1.5707963266784812974, tol=PTOL)
+    v = fp.e1((0.0 + 0.25j))
+    assert ae(v, (0.82466306258094565309 - 1.3216627564751394551j), tol=ATOL)
+    assert ae(v.real, 0.82466306258094565309, tol=PTOL)
+    assert ae(v.imag, -1.3216627564751394551, tol=PTOL)
+    v = fp.e1((0.0 + 1.0j))
+    assert ae(v, (-0.33740392290096813466 - 0.62471325642771360429j), tol=ATOL)
+    assert ae(v.real, -0.33740392290096813466, tol=PTOL)
+    assert ae(v.imag, -0.62471325642771360429, tol=PTOL)
+    v = fp.e1((0.0 + 2.0j))
+    assert ae(v, (-0.4229808287748649957 + 0.034616650007798229345j), tol=ATOL)
+    assert ae(v.real, -0.4229808287748649957, tol=PTOL)
+    assert ae(v.imag, 0.034616650007798229345, tol=PTOL)
+    v = fp.e1((0.0 + 5.0j))
+    assert ae(v, (0.19002974965664387862 - 0.020865081850222481957j), tol=ATOL)
+    assert ae(v.real, 0.19002974965664387862, tol=PTOL)
+    assert ae(v.imag, -0.020865081850222481957, tol=PTOL)
+    v = fp.e1((0.0 + 20.0j))
+    assert ae(v, (-0.04441982084535331654 - 0.022554625751456779068j), tol=ATOL)
+    assert ae(v.real, -0.04441982084535331654, tol=PTOL)
+    assert ae(v.imag, -0.022554625751456779068, tol=PTOL)
+    v = fp.e1((0.0 + 30.0j))
+    assert ae(v, (0.033032417282071143779 - 0.0040397867645455082476j), tol=ATOL)
+    assert ae(v.real, 0.033032417282071143779, tol=PTOL)
+    assert ae(v.imag, -0.0040397867645455082476, tol=PTOL)
+    v = fp.e1((0.0 + 40.0j))
+    assert ae(v, (-0.019020007896208766962 + 0.016188792559887887544j), tol=ATOL)
+    assert ae(v.real, -0.019020007896208766962, tol=PTOL)
+    assert ae(v.imag, 0.016188792559887887544, tol=PTOL)
+    v = fp.e1((0.0 + 50.0j))
+    assert ae(v, (0.0056283863241163054402 - 0.019179254308960724503j), tol=ATOL)
+    assert ae(v.real, 0.0056283863241163054402, tol=PTOL)
+    assert ae(v.imag, -0.019179254308960724503, tol=PTOL)
+    v = fp.e1((0.0 + 80.0j))
+    assert ae(v, (0.012402501155070958192 + 0.0015345601175906961199j), tol=ATOL)
+    assert ae(v.real, 0.012402501155070958192, tol=PTOL)
+    assert ae(v.imag, 0.0015345601175906961199, tol=PTOL)
+    v = fp.e1((-1.1641532182693481445e-10 + 4.6566128730773925781e-10j))
+    assert ae(v, (20.880034621432138988 - 1.8157749894560994861j), tol=ATOL)
+    assert ae(v.real, 20.880034621432138988, tol=PTOL)
+    assert ae(v.imag, -1.8157749894560994861, tol=PTOL)
+    v = fp.e1((-0.25 + 1.0j))
+    assert ae(v, (-0.59066621214766308594 - 0.74474454765205036972j), tol=ATOL)
+    assert ae(v.real, -0.59066621214766308594, tol=PTOL)
+    assert ae(v.imag, -0.74474454765205036972, tol=PTOL)
+    v = fp.e1((-1.0 + 4.0j))
+    assert ae(v, (0.49739047283060471093 + 0.41543605404038863174j), tol=ATOL)
+    assert ae(v.real, 0.49739047283060471093, tol=PTOL)
+    assert ae(v.imag, 0.41543605404038863174, tol=PTOL)
+    v = fp.e1((-2.0 + 8.0j))
+    assert ae(v, (-0.8705211147733730969 + 0.24099328498605539667j), tol=ATOL)
+    assert ae(v.real, -0.8705211147733730969, tol=PTOL)
+    assert ae(v.imag, 0.24099328498605539667, tol=PTOL)
+    v = fp.e1((-5.0 + 20.0j))
+    assert ae(v, (-7.0789514293925893007 - 1.6102177171960790536j), tol=ATOL)
+    assert ae(v.real, -7.0789514293925893007, tol=PTOL)
+    assert ae(v.imag, -1.6102177171960790536, tol=PTOL)
+    v = fp.e1((-20.0 + 80.0j))
+    assert ae(v, (5855431.4907298084434 - 720920.93315409165707j), tol=ATOL)
+    assert ae(v.real, 5855431.4907298084434, tol=PTOL)
+    assert ae(v.imag, -720920.93315409165707, tol=PTOL)
+    v = fp.e1((-30.0 + 120.0j))
+    assert ae(v, (-65402491644.703470747 - 56697658399.657460294j), tol=ATOL)
+    assert ae(v.real, -65402491644.703470747, tol=PTOL)
+    assert ae(v.imag, -56697658399.657460294, tol=PTOL)
+    v = fp.e1((-40.0 + 160.0j))
+    assert ae(v, (25504929379604.776769 + 1429035198630573.2463j), tol=ATOL)
+    assert ae(v.real, 25504929379604.776769, tol=PTOL)
+    assert ae(v.imag, 1429035198630573.2463, tol=PTOL)
+    v = fp.e1((-50.0 + 200.0j))
+    assert ae(v, (18437746526988116954.0 - 17146362239046152345.0j), tol=ATOL)
+    assert ae(v.real, 18437746526988116954.0, tol=PTOL)
+    assert ae(v.imag, -17146362239046152345.0, tol=PTOL)
+    v = fp.e1((-80.0 + 320.0j))
+    assert ae(v, (3.3464697299634526706e+31 - 1.6473152633843023919e+32j), tol=ATOL)
+    assert ae(v.real, 3.3464697299634526706e+31, tol=PTOL)
+    assert ae(v.imag, -1.6473152633843023919e+32, tol=PTOL)
+    v = fp.e1((-4.6566128730773925781e-10 + 1.1641532182693481445e-10j))
+    assert ae(v, (20.880034621082893023 - 2.8966139903465137624j), tol=ATOL)
+    assert ae(v.real, 20.880034621082893023, tol=PTOL)
+    assert ae(v.imag, -2.8966139903465137624, tol=PTOL)
+    v = fp.e1((-1.0 + 0.25j))
+    assert ae(v, (-1.8942716983721074932 - 2.4689102827070540799j), tol=ATOL)
+    assert ae(v.real, -1.8942716983721074932, tol=PTOL)
+    assert ae(v.imag, -2.4689102827070540799, tol=PTOL)
+    v = fp.e1((-4.0 + 1.0j))
+    assert ae(v, (-14.806699492675420438 + 9.1384225230837893776j), tol=ATOL)
+    assert ae(v.real, -14.806699492675420438, tol=PTOL)
+    assert ae(v.imag, 9.1384225230837893776, tol=PTOL)
+    v = fp.e1((-8.0 + 2.0j))
+    assert ae(v, (54.633252667426386294 + 413.20318163814670688j), tol=ATOL)
+    assert ae(v.real, 54.633252667426386294, tol=PTOL)
+    assert ae(v.imag, 413.20318163814670688, tol=PTOL)
+    v = fp.e1((-20.0 + 5.0j))
+    assert ae(v, (-711836.97165402624643 - 24745250.939695900956j), tol=ATOL)
+    assert ae(v.real, -711836.97165402624643, tol=PTOL)
+    assert ae(v.imag, -24745250.939695900956, tol=PTOL)
+    v = fp.e1((-80.0 + 20.0j))
+    assert ae(v, (-4.2139911108612653091e+32 + 5.3367124741918251637e+32j), tol=ATOL)
+    assert ae(v.real, -4.2139911108612653091e+32, tol=PTOL)
+    assert ae(v.imag, 5.3367124741918251637e+32, tol=PTOL)
+    v = fp.e1((-120.0 + 30.0j))
+    assert ae(v, (9.7760616203707508892e+48 - 1.058257682317195792e+50j), tol=ATOL)
+    assert ae(v.real, 9.7760616203707508892e+48, tol=PTOL)
+    assert ae(v.imag, -1.058257682317195792e+50, tol=PTOL)
+    v = fp.e1((-160.0 + 40.0j))
+    assert ae(v, (8.7065541466623638861e+66 + 1.6577106725141739889e+67j), tol=ATOL)
+    assert ae(v.real, 8.7065541466623638861e+66, tol=PTOL)
+    assert ae(v.imag, 1.6577106725141739889e+67, tol=PTOL)
+    v = fp.e1((-200.0 + 50.0j))
+    assert ae(v, (-3.070744996327018106e+84 - 1.7243244846769415903e+84j), tol=ATOL)
+    assert ae(v.real, -3.070744996327018106e+84, tol=PTOL)
+    assert ae(v.imag, -1.7243244846769415903e+84, tol=PTOL)
+    v = fp.e1((-320.0 + 80.0j))
+    assert ae(v, (9.9960598637998647276e+135 - 2.6855081527595608863e+136j), tol=ATOL)
+    assert ae(v.real, 9.9960598637998647276e+135, tol=PTOL)
+    assert ae(v.imag, -2.6855081527595608863e+136, tol=PTOL)
+    v = fp.e1(-1.1641532182693481445e-10)
+    assert ae(v, (22.296641293460247028 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, 22.296641293460247028, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1(-0.25)
+    assert ae(v, (0.54254326466191372953 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, 0.54254326466191372953, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1(-1.0)
+    assert ae(v, (-1.8951178163559367555 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -1.8951178163559367555, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1(-2.0)
+    assert ae(v, (-4.9542343560018901634 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -4.9542343560018901634, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1(-5.0)
+    assert ae(v, (-40.185275355803177455 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -40.185275355803177455, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1(-20.0)
+    assert ae(v, (-25615652.66405658882 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -25615652.66405658882, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1(-30.0)
+    assert ae(v, (-368973209407.27419706 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -368973209407.27419706, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1(-40.0)
+    assert ae(v, (-6039718263611241.5784 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -6039718263611241.5784, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1(-50.0)
+    assert ae(v, (-1.0585636897131690963e+20 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -1.0585636897131690963e+20, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1(-80.0)
+    assert ae(v, (-7.0146000049047999696e+32 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -7.0146000049047999696e+32, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1((-1.1641532182693481445e-10 + 0.0j))
+    assert ae(v, (22.296641293460247028 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, 22.296641293460247028, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1((-0.25 + 0.0j))
+    assert ae(v, (0.54254326466191372953 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, 0.54254326466191372953, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1((-1.0 + 0.0j))
+    assert ae(v, (-1.8951178163559367555 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -1.8951178163559367555, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1((-2.0 + 0.0j))
+    assert ae(v, (-4.9542343560018901634 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -4.9542343560018901634, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1((-5.0 + 0.0j))
+    assert ae(v, (-40.185275355803177455 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -40.185275355803177455, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1((-20.0 + 0.0j))
+    assert ae(v, (-25615652.66405658882 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -25615652.66405658882, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1((-30.0 + 0.0j))
+    assert ae(v, (-368973209407.27419706 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -368973209407.27419706, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1((-40.0 + 0.0j))
+    assert ae(v, (-6039718263611241.5784 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -6039718263611241.5784, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1((-50.0 + 0.0j))
+    assert ae(v, (-1.0585636897131690963e+20 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -1.0585636897131690963e+20, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1((-80.0 + 0.0j))
+    assert ae(v, (-7.0146000049047999696e+32 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -7.0146000049047999696e+32, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1((-4.6566128730773925781e-10 - 1.1641532182693481445e-10j))
+    assert ae(v, (20.880034621082893023 + 2.8966139903465137624j), tol=ATOL)
+    assert ae(v.real, 20.880034621082893023, tol=PTOL)
+    assert ae(v.imag, 2.8966139903465137624, tol=PTOL)
+    v = fp.e1((-1.0 - 0.25j))
+    assert ae(v, (-1.8942716983721074932 + 2.4689102827070540799j), tol=ATOL)
+    assert ae(v.real, -1.8942716983721074932, tol=PTOL)
+    assert ae(v.imag, 2.4689102827070540799, tol=PTOL)
+    v = fp.e1((-4.0 - 1.0j))
+    assert ae(v, (-14.806699492675420438 - 9.1384225230837893776j), tol=ATOL)
+    assert ae(v.real, -14.806699492675420438, tol=PTOL)
+    assert ae(v.imag, -9.1384225230837893776, tol=PTOL)
+    v = fp.e1((-8.0 - 2.0j))
+    assert ae(v, (54.633252667426386294 - 413.20318163814670688j), tol=ATOL)
+    assert ae(v.real, 54.633252667426386294, tol=PTOL)
+    assert ae(v.imag, -413.20318163814670688, tol=PTOL)
+    v = fp.e1((-20.0 - 5.0j))
+    assert ae(v, (-711836.97165402624643 + 24745250.939695900956j), tol=ATOL)
+    assert ae(v.real, -711836.97165402624643, tol=PTOL)
+    assert ae(v.imag, 24745250.939695900956, tol=PTOL)
+    v = fp.e1((-80.0 - 20.0j))
+    assert ae(v, (-4.2139911108612653091e+32 - 5.3367124741918251637e+32j), tol=ATOL)
+    assert ae(v.real, -4.2139911108612653091e+32, tol=PTOL)
+    assert ae(v.imag, -5.3367124741918251637e+32, tol=PTOL)
+    v = fp.e1((-120.0 - 30.0j))
+    assert ae(v, (9.7760616203707508892e+48 + 1.058257682317195792e+50j), tol=ATOL)
+    assert ae(v.real, 9.7760616203707508892e+48, tol=PTOL)
+    assert ae(v.imag, 1.058257682317195792e+50, tol=PTOL)
+    v = fp.e1((-160.0 - 40.0j))
+    assert ae(v, (8.7065541466623638861e+66 - 1.6577106725141739889e+67j), tol=ATOL)
+    assert ae(v.real, 8.7065541466623638861e+66, tol=PTOL)
+    assert ae(v.imag, -1.6577106725141739889e+67, tol=PTOL)
+    v = fp.e1((-200.0 - 50.0j))
+    assert ae(v, (-3.070744996327018106e+84 + 1.7243244846769415903e+84j), tol=ATOL)
+    assert ae(v.real, -3.070744996327018106e+84, tol=PTOL)
+    assert ae(v.imag, 1.7243244846769415903e+84, tol=PTOL)
+    v = fp.e1((-320.0 - 80.0j))
+    assert ae(v, (9.9960598637998647276e+135 + 2.6855081527595608863e+136j), tol=ATOL)
+    assert ae(v.real, 9.9960598637998647276e+135, tol=PTOL)
+    assert ae(v.imag, 2.6855081527595608863e+136, tol=PTOL)
+    v = fp.e1((-1.1641532182693481445e-10 - 1.1641532182693481445e-10j))
+    assert ae(v, (21.950067703180274374 + 2.356194490075929607j), tol=ATOL)
+    assert ae(v.real, 21.950067703180274374, tol=PTOL)
+    assert ae(v.imag, 2.356194490075929607, tol=PTOL)
+    v = fp.e1((-0.25 - 0.25j))
+    assert ae(v, (0.21441047326710323254 + 2.0732153554307936389j), tol=ATOL)
+    assert ae(v.real, 0.21441047326710323254, tol=PTOL)
+    assert ae(v.imag, 2.0732153554307936389, tol=PTOL)
+    v = fp.e1((-1.0 - 1.0j))
+    assert ae(v, (-1.7646259855638540684 + 0.7538228020792708192j), tol=ATOL)
+    assert ae(v.real, -1.7646259855638540684, tol=PTOL)
+    assert ae(v.imag, 0.7538228020792708192, tol=PTOL)
+    v = fp.e1((-2.0 - 2.0j))
+    assert ae(v, (-1.8920781621855474089 - 2.1753697842428647236j), tol=ATOL)
+    assert ae(v.real, -1.8920781621855474089, tol=PTOL)
+    assert ae(v.imag, -2.1753697842428647236, tol=PTOL)
+    v = fp.e1((-5.0 - 5.0j))
+    assert ae(v, (13.470936071475245856 + 18.464085049321024206j), tol=ATOL)
+    assert ae(v.real, 13.470936071475245856, tol=PTOL)
+    assert ae(v.imag, 18.464085049321024206, tol=PTOL)
+    v = fp.e1((-20.0 - 20.0j))
+    assert ae(v, (-16589317.398788971896 - 5831702.3296441771206j), tol=ATOL)
+    assert ae(v.real, -16589317.398788971896, tol=PTOL)
+    assert ae(v.imag, -5831702.3296441771206, tol=PTOL)
+    v = fp.e1((-30.0 - 30.0j))
+    assert ae(v, (154596484273.69322527 + 204179357837.41389696j), tol=ATOL)
+    assert ae(v.real, 154596484273.69322527, tol=PTOL)
+    assert ae(v.imag, 204179357837.41389696, tol=PTOL)
+    v = fp.e1((-40.0 - 40.0j))
+    assert ae(v, (-287512180321448.45408 - 4203502407932314.974j), tol=ATOL)
+    assert ae(v.real, -287512180321448.45408, tol=PTOL)
+    assert ae(v.imag, -4203502407932314.974, tol=PTOL)
+    v = fp.e1((-50.0 - 50.0j))
+    assert ae(v, (-36128528616649268826.0 + 64648801861338741963.0j), tol=ATOL)
+    assert ae(v.real, -36128528616649268826.0, tol=PTOL)
+    assert ae(v.imag, 64648801861338741963.0, tol=PTOL)
+    v = fp.e1((-80.0 - 80.0j))
+    assert ae(v, (3.8674816337930010217e+32 + 3.0540709639658071041e+32j), tol=ATOL)
+    assert ae(v.real, 3.8674816337930010217e+32, tol=PTOL)
+    assert ae(v.imag, 3.0540709639658071041e+32, tol=PTOL)
+    v = fp.e1((-1.1641532182693481445e-10 - 4.6566128730773925781e-10j))
+    assert ae(v, (20.880034621432138988 + 1.8157749894560994861j), tol=ATOL)
+    assert ae(v.real, 20.880034621432138988, tol=PTOL)
+    assert ae(v.imag, 1.8157749894560994861, tol=PTOL)
+    v = fp.e1((-0.25 - 1.0j))
+    assert ae(v, (-0.59066621214766308594 + 0.74474454765205036972j), tol=ATOL)
+    assert ae(v.real, -0.59066621214766308594, tol=PTOL)
+    assert ae(v.imag, 0.74474454765205036972, tol=PTOL)
+    v = fp.e1((-1.0 - 4.0j))
+    assert ae(v, (0.49739047283060471093 - 0.41543605404038863174j), tol=ATOL)
+    assert ae(v.real, 0.49739047283060471093, tol=PTOL)
+    assert ae(v.imag, -0.41543605404038863174, tol=PTOL)
+    v = fp.e1((-2.0 - 8.0j))
+    assert ae(v, (-0.8705211147733730969 - 0.24099328498605539667j), tol=ATOL)
+    assert ae(v.real, -0.8705211147733730969, tol=PTOL)
+    assert ae(v.imag, -0.24099328498605539667, tol=PTOL)
+    v = fp.e1((-5.0 - 20.0j))
+    assert ae(v, (-7.0789514293925893007 + 1.6102177171960790536j), tol=ATOL)
+    assert ae(v.real, -7.0789514293925893007, tol=PTOL)
+    assert ae(v.imag, 1.6102177171960790536, tol=PTOL)
+    v = fp.e1((-20.0 - 80.0j))
+    assert ae(v, (5855431.4907298084434 + 720920.93315409165707j), tol=ATOL)
+    assert ae(v.real, 5855431.4907298084434, tol=PTOL)
+    assert ae(v.imag, 720920.93315409165707, tol=PTOL)
+    v = fp.e1((-30.0 - 120.0j))
+    assert ae(v, (-65402491644.703470747 + 56697658399.657460294j), tol=ATOL)
+    assert ae(v.real, -65402491644.703470747, tol=PTOL)
+    assert ae(v.imag, 56697658399.657460294, tol=PTOL)
+    v = fp.e1((-40.0 - 160.0j))
+    assert ae(v, (25504929379604.776769 - 1429035198630573.2463j), tol=ATOL)
+    assert ae(v.real, 25504929379604.776769, tol=PTOL)
+    assert ae(v.imag, -1429035198630573.2463, tol=PTOL)
+    v = fp.e1((-50.0 - 200.0j))
+    assert ae(v, (18437746526988116954.0 + 17146362239046152345.0j), tol=ATOL)
+    assert ae(v.real, 18437746526988116954.0, tol=PTOL)
+    assert ae(v.imag, 17146362239046152345.0, tol=PTOL)
+    v = fp.e1((-80.0 - 320.0j))
+    assert ae(v, (3.3464697299634526706e+31 + 1.6473152633843023919e+32j), tol=ATOL)
+    assert ae(v.real, 3.3464697299634526706e+31, tol=PTOL)
+    assert ae(v.imag, 1.6473152633843023919e+32, tol=PTOL)
+    v = fp.e1((0.0 - 1.1641532182693481445e-10j))
+    assert ae(v, (22.29664129357666235 + 1.5707963266784812974j), tol=ATOL)
+    assert ae(v.real, 22.29664129357666235, tol=PTOL)
+    assert ae(v.imag, 1.5707963266784812974, tol=PTOL)
+    v = fp.e1((0.0 - 0.25j))
+    assert ae(v, (0.82466306258094565309 + 1.3216627564751394551j), tol=ATOL)
+    assert ae(v.real, 0.82466306258094565309, tol=PTOL)
+    assert ae(v.imag, 1.3216627564751394551, tol=PTOL)
+    v = fp.e1((0.0 - 1.0j))
+    assert ae(v, (-0.33740392290096813466 + 0.62471325642771360429j), tol=ATOL)
+    assert ae(v.real, -0.33740392290096813466, tol=PTOL)
+    assert ae(v.imag, 0.62471325642771360429, tol=PTOL)
+    v = fp.e1((0.0 - 2.0j))
+    assert ae(v, (-0.4229808287748649957 - 0.034616650007798229345j), tol=ATOL)
+    assert ae(v.real, -0.4229808287748649957, tol=PTOL)
+    assert ae(v.imag, -0.034616650007798229345, tol=PTOL)
+    v = fp.e1((0.0 - 5.0j))
+    assert ae(v, (0.19002974965664387862 + 0.020865081850222481957j), tol=ATOL)
+    assert ae(v.real, 0.19002974965664387862, tol=PTOL)
+    assert ae(v.imag, 0.020865081850222481957, tol=PTOL)
+    v = fp.e1((0.0 - 20.0j))
+    assert ae(v, (-0.04441982084535331654 + 0.022554625751456779068j), tol=ATOL)
+    assert ae(v.real, -0.04441982084535331654, tol=PTOL)
+    assert ae(v.imag, 0.022554625751456779068, tol=PTOL)
+    v = fp.e1((0.0 - 30.0j))
+    assert ae(v, (0.033032417282071143779 + 0.0040397867645455082476j), tol=ATOL)
+    assert ae(v.real, 0.033032417282071143779, tol=PTOL)
+    assert ae(v.imag, 0.0040397867645455082476, tol=PTOL)
+    v = fp.e1((0.0 - 40.0j))
+    assert ae(v, (-0.019020007896208766962 - 0.016188792559887887544j), tol=ATOL)
+    assert ae(v.real, -0.019020007896208766962, tol=PTOL)
+    assert ae(v.imag, -0.016188792559887887544, tol=PTOL)
+    v = fp.e1((0.0 - 50.0j))
+    assert ae(v, (0.0056283863241163054402 + 0.019179254308960724503j), tol=ATOL)
+    assert ae(v.real, 0.0056283863241163054402, tol=PTOL)
+    assert ae(v.imag, 0.019179254308960724503, tol=PTOL)
+    v = fp.e1((0.0 - 80.0j))
+    assert ae(v, (0.012402501155070958192 - 0.0015345601175906961199j), tol=ATOL)
+    assert ae(v.real, 0.012402501155070958192, tol=PTOL)
+    assert ae(v.imag, -0.0015345601175906961199, tol=PTOL)
+    v = fp.e1((1.1641532182693481445e-10 - 4.6566128730773925781e-10j))
+    assert ae(v, (20.880034621664969632 + 1.3258176632023711778j), tol=ATOL)
+    assert ae(v.real, 20.880034621664969632, tol=PTOL)
+    assert ae(v.imag, 1.3258176632023711778, tol=PTOL)
+    v = fp.e1((0.25 - 1.0j))
+    assert ae(v, (-0.16868306393667788761 + 0.4858011885947426971j), tol=ATOL)
+    assert ae(v.real, -0.16868306393667788761, tol=PTOL)
+    assert ae(v.imag, 0.4858011885947426971, tol=PTOL)
+    v = fp.e1((1.0 - 4.0j))
+    assert ae(v, (0.03373591813926547318 - 0.073523452241083821877j), tol=ATOL)
+    assert ae(v.real, 0.03373591813926547318, tol=PTOL)
+    assert ae(v.imag, -0.073523452241083821877, tol=PTOL)
+    v = fp.e1((2.0 - 8.0j))
+    assert ae(v, (-0.015392833434733785143 + 0.0031747121557605415914j), tol=ATOL)
+    assert ae(v.real, -0.015392833434733785143, tol=PTOL)
+    assert ae(v.imag, 0.0031747121557605415914, tol=PTOL)
+    v = fp.e1((5.0 - 20.0j))
+    assert ae(v, (-0.00024419662286542966525 + 0.00021008322966152755674j), tol=ATOL)
+    assert ae(v.real, -0.00024419662286542966525, tol=PTOL)
+    assert ae(v.imag, 0.00021008322966152755674, tol=PTOL)
+    v = fp.e1((20.0 - 80.0j))
+    assert ae(v, (2.3255552781051330088e-11 - 8.9463918891349438007e-12j), tol=ATOL)
+    assert ae(v.real, 2.3255552781051330088e-11, tol=PTOL)
+    assert ae(v.imag, -8.9463918891349438007e-12, tol=PTOL)
+    v = fp.e1((30.0 - 120.0j))
+    assert ae(v, (-2.7068919097124652332e-16 + 7.0477762411705130239e-16j), tol=ATOL)
+    assert ae(v.real, -2.7068919097124652332e-16, tol=PTOL)
+    assert ae(v.imag, 7.0477762411705130239e-16, tol=PTOL)
+    v = fp.e1((40.0 - 160.0j))
+    assert ae(v, (-1.1695597827678024687e-20 - 2.2907401455645736661e-20j), tol=ATOL)
+    assert ae(v.real, -1.1695597827678024687e-20, tol=PTOL)
+    assert ae(v.imag, -2.2907401455645736661e-20, tol=PTOL)
+    v = fp.e1((50.0 - 200.0j))
+    assert ae(v, (9.0323746914410162531e-25 + 2.3950601790033530935e-25j), tol=ATOL)
+    assert ae(v.real, 9.0323746914410162531e-25, tol=PTOL)
+    assert ae(v.imag, 2.3950601790033530935e-25, tol=PTOL)
+    v = fp.e1((80.0 - 320.0j))
+    assert ae(v, (3.4819106748728063576e-38 + 4.215653005615772724e-38j), tol=ATOL)
+    assert ae(v.real, 3.4819106748728063576e-38, tol=PTOL)
+    assert ae(v.imag, 4.215653005615772724e-38, tol=PTOL)
+    v = fp.e1((1.1641532182693481445e-10 - 1.1641532182693481445e-10j))
+    assert ae(v, (21.950067703413105017 + 0.7853981632810329878j), tol=ATOL)
+    assert ae(v.real, 21.950067703413105017, tol=PTOL)
+    assert ae(v.imag, 0.7853981632810329878, tol=PTOL)
+    v = fp.e1((0.25 - 0.25j))
+    assert ae(v, (0.71092525792923287894 + 0.56491812441304194711j), tol=ATOL)
+    assert ae(v.real, 0.71092525792923287894, tol=PTOL)
+    assert ae(v.imag, 0.56491812441304194711, tol=PTOL)
+    v = fp.e1((1.0 - 1.0j))
+    assert ae(v, (0.00028162445198141832551 + 0.17932453503935894015j), tol=ATOL)
+    assert ae(v.real, 0.00028162445198141832551, tol=PTOL)
+    assert ae(v.imag, 0.17932453503935894015, tol=PTOL)
+    v = fp.e1((2.0 - 2.0j))
+    assert ae(v, (-0.033767089606562004246 + 0.018599414169750541925j), tol=ATOL)
+    assert ae(v.real, -0.033767089606562004246, tol=PTOL)
+    assert ae(v.imag, 0.018599414169750541925, tol=PTOL)
+    v = fp.e1((5.0 - 5.0j))
+    assert ae(v, (0.0007266506660356393891 - 0.00047102780163522245054j), tol=ATOL)
+    assert ae(v.real, 0.0007266506660356393891, tol=PTOL)
+    assert ae(v.imag, -0.00047102780163522245054, tol=PTOL)
+    v = fp.e1((20.0 - 20.0j))
+    assert ae(v, (-2.3824537449367396579e-11 + 6.6969873156525615158e-11j), tol=ATOL)
+    assert ae(v.real, -2.3824537449367396579e-11, tol=PTOL)
+    assert ae(v.imag, 6.6969873156525615158e-11, tol=PTOL)
+    v = fp.e1((30.0 - 30.0j))
+    assert ae(v, (1.7316045841744061617e-15 - 1.3065678019487308689e-15j), tol=ATOL)
+    assert ae(v.real, 1.7316045841744061617e-15, tol=PTOL)
+    assert ae(v.imag, -1.3065678019487308689e-15, tol=PTOL)
+    v = fp.e1((40.0 - 40.0j))
+    assert ae(v, (-7.4001043002899232182e-20 + 4.991847855336816304e-21j), tol=ATOL)
+    assert ae(v.real, -7.4001043002899232182e-20, tol=PTOL)
+    assert ae(v.imag, 4.991847855336816304e-21, tol=PTOL)
+    v = fp.e1((50.0 - 50.0j))
+    assert ae(v, (2.3566128324644641219e-24 + 1.3188326726201614778e-24j), tol=ATOL)
+    assert ae(v.real, 2.3566128324644641219e-24, tol=PTOL)
+    assert ae(v.imag, 1.3188326726201614778e-24, tol=PTOL)
+    v = fp.e1((80.0 - 80.0j))
+    assert ae(v, (9.8279750572186526673e-38 - 1.243952841288868831e-37j), tol=ATOL)
+    assert ae(v.real, 9.8279750572186526673e-38, tol=PTOL)
+    assert ae(v.imag, -1.243952841288868831e-37, tol=PTOL)
+    v = fp.e1((4.6566128730773925781e-10 - 1.1641532182693481445e-10j))
+    assert ae(v, (20.880034622014215597 + 0.24497866301044883237j), tol=ATOL)
+    assert ae(v.real, 20.880034622014215597, tol=PTOL)
+    assert ae(v.imag, 0.24497866301044883237, tol=PTOL)
+    v = fp.e1((1.0 - 0.25j))
+    assert ae(v, (0.19731063945004229095 + 0.087366045774299963672j), tol=ATOL)
+    assert ae(v.real, 0.19731063945004229095, tol=PTOL)
+    assert ae(v.imag, 0.087366045774299963672, tol=PTOL)
+    v = fp.e1((4.0 - 1.0j))
+    assert ae(v, (0.0013106173980145506944 + 0.0034542480199350626699j), tol=ATOL)
+    assert ae(v.real, 0.0013106173980145506944, tol=PTOL)
+    assert ae(v.imag, 0.0034542480199350626699, tol=PTOL)
+    v = fp.e1((8.0 - 2.0j))
+    assert ae(v, (-0.000022278049065270225945 + 0.000029191940456521555288j), tol=ATOL)
+    assert ae(v.real, -0.000022278049065270225945, tol=PTOL)
+    assert ae(v.imag, 0.000029191940456521555288, tol=PTOL)
+    v = fp.e1((20.0 - 5.0j))
+    assert ae(v, (4.7711374515765346894e-11 - 8.2902652405126947359e-11j), tol=ATOL)
+    assert ae(v.real, 4.7711374515765346894e-11, tol=PTOL)
+    assert ae(v.imag, -8.2902652405126947359e-11, tol=PTOL)
+    v = fp.e1((80.0 - 20.0j))
+    assert ae(v, (3.8353473865788235787e-38 + 2.129247592349605139e-37j), tol=ATOL)
+    assert ae(v.real, 3.8353473865788235787e-38, tol=PTOL)
+    assert ae(v.imag, 2.129247592349605139e-37, tol=PTOL)
+    v = fp.e1((120.0 - 30.0j))
+    assert ae(v, (2.3836002337480334716e-55 - 5.6704043587126198306e-55j), tol=ATOL)
+    assert ae(v.real, 2.3836002337480334716e-55, tol=PTOL)
+    assert ae(v.imag, -5.6704043587126198306e-55, tol=PTOL)
+    v = fp.e1((160.0 - 40.0j))
+    assert ae(v, (-1.6238022898654510661e-72 + 1.104172355572287367e-72j), tol=ATOL)
+    assert ae(v.real, -1.6238022898654510661e-72, tol=PTOL)
+    assert ae(v.imag, 1.104172355572287367e-72, tol=PTOL)
+    v = fp.e1((200.0 - 50.0j))
+    assert ae(v, (6.6800061461666228487e-90 - 1.4473816083541016115e-91j), tol=ATOL)
+    assert ae(v.real, 6.6800061461666228487e-90, tol=PTOL)
+    assert ae(v.imag, -1.4473816083541016115e-91, tol=PTOL)
+    v = fp.e1((320.0 - 80.0j))
+    assert ae(v, (4.2737871527778786157e-143 - 3.1789935525785660314e-142j), tol=ATOL)
+    assert ae(v.real, 4.2737871527778786157e-143, tol=PTOL)
+    assert ae(v.imag, -3.1789935525785660314e-142, tol=PTOL)
+    v = fp.ei(1.1641532182693481445e-10)
+    assert ae(v, -22.296641293460247028, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(0.25)
+    assert ae(v, -0.54254326466191372953, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(1.0)
+    assert ae(v, 1.8951178163559367555, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(2.0)
+    assert ae(v, 4.9542343560018901634, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(5.0)
+    assert ae(v, 40.185275355803177455, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(20.0)
+    assert ae(v, 25615652.66405658882, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(30.0)
+    assert ae(v, 368973209407.27419706, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(40.0)
+    assert ae(v, 6039718263611241.5784, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(50.0)
+    assert ae(v, 1.0585636897131690963e+20, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(80.0)
+    assert ae(v, 7.0146000049047999696e+32, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei((1.1641532182693481445e-10 + 0.0j))
+    assert ae(v, (-22.296641293460247028 + 0.0j), tol=ATOL)
+    assert ae(v.real, -22.296641293460247028, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((0.25 + 0.0j))
+    assert ae(v, (-0.54254326466191372953 + 0.0j), tol=ATOL)
+    assert ae(v.real, -0.54254326466191372953, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((1.0 + 0.0j))
+    assert ae(v, (1.8951178163559367555 + 0.0j), tol=ATOL)
+    assert ae(v.real, 1.8951178163559367555, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((2.0 + 0.0j))
+    assert ae(v, (4.9542343560018901634 + 0.0j), tol=ATOL)
+    assert ae(v.real, 4.9542343560018901634, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((5.0 + 0.0j))
+    assert ae(v, (40.185275355803177455 + 0.0j), tol=ATOL)
+    assert ae(v.real, 40.185275355803177455, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((20.0 + 0.0j))
+    assert ae(v, (25615652.66405658882 + 0.0j), tol=ATOL)
+    assert ae(v.real, 25615652.66405658882, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((30.0 + 0.0j))
+    assert ae(v, (368973209407.27419706 + 0.0j), tol=ATOL)
+    assert ae(v.real, 368973209407.27419706, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((40.0 + 0.0j))
+    assert ae(v, (6039718263611241.5784 + 0.0j), tol=ATOL)
+    assert ae(v.real, 6039718263611241.5784, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((50.0 + 0.0j))
+    assert ae(v, (1.0585636897131690963e+20 + 0.0j), tol=ATOL)
+    assert ae(v.real, 1.0585636897131690963e+20, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((80.0 + 0.0j))
+    assert ae(v, (7.0146000049047999696e+32 + 0.0j), tol=ATOL)
+    assert ae(v.real, 7.0146000049047999696e+32, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((4.6566128730773925781e-10 + 1.1641532182693481445e-10j))
+    assert ae(v, (-20.880034621082893023 + 0.24497866324327947603j), tol=ATOL)
+    assert ae(v.real, -20.880034621082893023, tol=PTOL)
+    assert ae(v.imag, 0.24497866324327947603, tol=PTOL)
+    v = fp.ei((1.0 + 0.25j))
+    assert ae(v, (1.8942716983721074932 + 0.67268237088273915854j), tol=ATOL)
+    assert ae(v.real, 1.8942716983721074932, tol=PTOL)
+    assert ae(v.imag, 0.67268237088273915854, tol=PTOL)
+    v = fp.ei((4.0 + 1.0j))
+    assert ae(v, (14.806699492675420438 + 12.280015176673582616j), tol=ATOL)
+    assert ae(v.real, 14.806699492675420438, tol=PTOL)
+    assert ae(v.imag, 12.280015176673582616, tol=PTOL)
+    v = fp.ei((8.0 + 2.0j))
+    assert ae(v, (-54.633252667426386294 + 416.34477429173650012j), tol=ATOL)
+    assert ae(v.real, -54.633252667426386294, tol=PTOL)
+    assert ae(v.imag, 416.34477429173650012, tol=PTOL)
+    v = fp.ei((20.0 + 5.0j))
+    assert ae(v, (711836.97165402624643 - 24745247.798103247366j), tol=ATOL)
+    assert ae(v.real, 711836.97165402624643, tol=PTOL)
+    assert ae(v.imag, -24745247.798103247366, tol=PTOL)
+    v = fp.ei((80.0 + 20.0j))
+    assert ae(v, (4.2139911108612653091e+32 + 5.3367124741918251637e+32j), tol=ATOL)
+    assert ae(v.real, 4.2139911108612653091e+32, tol=PTOL)
+    assert ae(v.imag, 5.3367124741918251637e+32, tol=PTOL)
+    v = fp.ei((120.0 + 30.0j))
+    assert ae(v, (-9.7760616203707508892e+48 - 1.058257682317195792e+50j), tol=ATOL)
+    assert ae(v.real, -9.7760616203707508892e+48, tol=PTOL)
+    assert ae(v.imag, -1.058257682317195792e+50, tol=PTOL)
+    v = fp.ei((160.0 + 40.0j))
+    assert ae(v, (-8.7065541466623638861e+66 + 1.6577106725141739889e+67j), tol=ATOL)
+    assert ae(v.real, -8.7065541466623638861e+66, tol=PTOL)
+    assert ae(v.imag, 1.6577106725141739889e+67, tol=PTOL)
+    v = fp.ei((200.0 + 50.0j))
+    assert ae(v, (3.070744996327018106e+84 - 1.7243244846769415903e+84j), tol=ATOL)
+    assert ae(v.real, 3.070744996327018106e+84, tol=PTOL)
+    assert ae(v.imag, -1.7243244846769415903e+84, tol=PTOL)
+    v = fp.ei((320.0 + 80.0j))
+    assert ae(v, (-9.9960598637998647276e+135 - 2.6855081527595608863e+136j), tol=ATOL)
+    assert ae(v.real, -9.9960598637998647276e+135, tol=PTOL)
+    assert ae(v.imag, -2.6855081527595608863e+136, tol=PTOL)
+    v = fp.ei((1.1641532182693481445e-10 + 1.1641532182693481445e-10j))
+    assert ae(v, (-21.950067703180274374 + 0.78539816351386363145j), tol=ATOL)
+    assert ae(v.real, -21.950067703180274374, tol=PTOL)
+    assert ae(v.imag, 0.78539816351386363145, tol=PTOL)
+    v = fp.ei((0.25 + 0.25j))
+    assert ae(v, (-0.21441047326710323254 + 1.0683772981589995996j), tol=ATOL)
+    assert ae(v.real, -0.21441047326710323254, tol=PTOL)
+    assert ae(v.imag, 1.0683772981589995996, tol=PTOL)
+    v = fp.ei((1.0 + 1.0j))
+    assert ae(v, (1.7646259855638540684 + 2.3877698515105224193j), tol=ATOL)
+    assert ae(v.real, 1.7646259855638540684, tol=PTOL)
+    assert ae(v.imag, 2.3877698515105224193, tol=PTOL)
+    v = fp.ei((2.0 + 2.0j))
+    assert ae(v, (1.8920781621855474089 + 5.3169624378326579621j), tol=ATOL)
+    assert ae(v.real, 1.8920781621855474089, tol=PTOL)
+    assert ae(v.imag, 5.3169624378326579621, tol=PTOL)
+    v = fp.ei((5.0 + 5.0j))
+    assert ae(v, (-13.470936071475245856 - 15.322492395731230968j), tol=ATOL)
+    assert ae(v.real, -13.470936071475245856, tol=PTOL)
+    assert ae(v.imag, -15.322492395731230968, tol=PTOL)
+    v = fp.ei((20.0 + 20.0j))
+    assert ae(v, (16589317.398788971896 + 5831705.4712368307104j), tol=ATOL)
+    assert ae(v.real, 16589317.398788971896, tol=PTOL)
+    assert ae(v.imag, 5831705.4712368307104, tol=PTOL)
+    v = fp.ei((30.0 + 30.0j))
+    assert ae(v, (-154596484273.69322527 - 204179357834.2723043j), tol=ATOL)
+    assert ae(v.real, -154596484273.69322527, tol=PTOL)
+    assert ae(v.imag, -204179357834.2723043, tol=PTOL)
+    v = fp.ei((40.0 + 40.0j))
+    assert ae(v, (287512180321448.45408 + 4203502407932318.1156j), tol=ATOL)
+    assert ae(v.real, 287512180321448.45408, tol=PTOL)
+    assert ae(v.imag, 4203502407932318.1156, tol=PTOL)
+    v = fp.ei((50.0 + 50.0j))
+    assert ae(v, (36128528616649268826.0 - 64648801861338741960.0j), tol=ATOL)
+    assert ae(v.real, 36128528616649268826.0, tol=PTOL)
+    assert ae(v.imag, -64648801861338741960.0, tol=PTOL)
+    v = fp.ei((80.0 + 80.0j))
+    assert ae(v, (-3.8674816337930010217e+32 - 3.0540709639658071041e+32j), tol=ATOL)
+    assert ae(v.real, -3.8674816337930010217e+32, tol=PTOL)
+    assert ae(v.imag, -3.0540709639658071041e+32, tol=PTOL)
+    v = fp.ei((1.1641532182693481445e-10 + 4.6566128730773925781e-10j))
+    assert ae(v, (-20.880034621432138988 + 1.3258176641336937524j), tol=ATOL)
+    assert ae(v.real, -20.880034621432138988, tol=PTOL)
+    assert ae(v.imag, 1.3258176641336937524, tol=PTOL)
+    v = fp.ei((0.25 + 1.0j))
+    assert ae(v, (0.59066621214766308594 + 2.3968481059377428687j), tol=ATOL)
+    assert ae(v.real, 0.59066621214766308594, tol=PTOL)
+    assert ae(v.imag, 2.3968481059377428687, tol=PTOL)
+    v = fp.ei((1.0 + 4.0j))
+    assert ae(v, (-0.49739047283060471093 + 3.5570287076301818702j), tol=ATOL)
+    assert ae(v.real, -0.49739047283060471093, tol=PTOL)
+    assert ae(v.imag, 3.5570287076301818702, tol=PTOL)
+    v = fp.ei((2.0 + 8.0j))
+    assert ae(v, (0.8705211147733730969 + 3.3825859385758486351j), tol=ATOL)
+    assert ae(v.real, 0.8705211147733730969, tol=PTOL)
+    assert ae(v.imag, 3.3825859385758486351, tol=PTOL)
+    v = fp.ei((5.0 + 20.0j))
+    assert ae(v, (7.0789514293925893007 + 1.5313749363937141849j), tol=ATOL)
+    assert ae(v.real, 7.0789514293925893007, tol=PTOL)
+    assert ae(v.imag, 1.5313749363937141849, tol=PTOL)
+    v = fp.ei((20.0 + 80.0j))
+    assert ae(v, (-5855431.4907298084434 - 720917.79156143806727j), tol=ATOL)
+    assert ae(v.real, -5855431.4907298084434, tol=PTOL)
+    assert ae(v.imag, -720917.79156143806727, tol=PTOL)
+    v = fp.ei((30.0 + 120.0j))
+    assert ae(v, (65402491644.703470747 - 56697658396.51586764j), tol=ATOL)
+    assert ae(v.real, 65402491644.703470747, tol=PTOL)
+    assert ae(v.imag, -56697658396.51586764, tol=PTOL)
+    v = fp.ei((40.0 + 160.0j))
+    assert ae(v, (-25504929379604.776769 + 1429035198630576.3879j), tol=ATOL)
+    assert ae(v.real, -25504929379604.776769, tol=PTOL)
+    assert ae(v.imag, 1429035198630576.3879, tol=PTOL)
+    v = fp.ei((50.0 + 200.0j))
+    assert ae(v, (-18437746526988116954.0 - 17146362239046152342.0j), tol=ATOL)
+    assert ae(v.real, -18437746526988116954.0, tol=PTOL)
+    assert ae(v.imag, -17146362239046152342.0, tol=PTOL)
+    v = fp.ei((80.0 + 320.0j))
+    assert ae(v, (-3.3464697299634526706e+31 - 1.6473152633843023919e+32j), tol=ATOL)
+    assert ae(v.real, -3.3464697299634526706e+31, tol=PTOL)
+    assert ae(v.imag, -1.6473152633843023919e+32, tol=PTOL)
+    v = fp.ei((0.0 + 1.1641532182693481445e-10j))
+    assert ae(v, (-22.29664129357666235 + 1.5707963269113119411j), tol=ATOL)
+    assert ae(v.real, -22.29664129357666235, tol=PTOL)
+    assert ae(v.imag, 1.5707963269113119411, tol=PTOL)
+    v = fp.ei((0.0 + 0.25j))
+    assert ae(v, (-0.82466306258094565309 + 1.8199298971146537833j), tol=ATOL)
+    assert ae(v.real, -0.82466306258094565309, tol=PTOL)
+    assert ae(v.imag, 1.8199298971146537833, tol=PTOL)
+    v = fp.ei((0.0 + 1.0j))
+    assert ae(v, (0.33740392290096813466 + 2.5168793971620796342j), tol=ATOL)
+    assert ae(v.real, 0.33740392290096813466, tol=PTOL)
+    assert ae(v.imag, 2.5168793971620796342, tol=PTOL)
+    v = fp.ei((0.0 + 2.0j))
+    assert ae(v, (0.4229808287748649957 + 3.1762093035975914678j), tol=ATOL)
+    assert ae(v.real, 0.4229808287748649957, tol=PTOL)
+    assert ae(v.imag, 3.1762093035975914678, tol=PTOL)
+    v = fp.ei((0.0 + 5.0j))
+    assert ae(v, (-0.19002974965664387862 + 3.1207275717395707565j), tol=ATOL)
+    assert ae(v.real, -0.19002974965664387862, tol=PTOL)
+    assert ae(v.imag, 3.1207275717395707565, tol=PTOL)
+    v = fp.ei((0.0 + 20.0j))
+    assert ae(v, (0.04441982084535331654 + 3.1190380278383364594j), tol=ATOL)
+    assert ae(v.real, 0.04441982084535331654, tol=PTOL)
+    assert ae(v.imag, 3.1190380278383364594, tol=PTOL)
+    v = fp.ei((0.0 + 30.0j))
+    assert ae(v, (-0.033032417282071143779 + 3.1375528668252477302j), tol=ATOL)
+    assert ae(v.real, -0.033032417282071143779, tol=PTOL)
+    assert ae(v.imag, 3.1375528668252477302, tol=PTOL)
+    v = fp.ei((0.0 + 40.0j))
+    assert ae(v, (0.019020007896208766962 + 3.157781446149681126j), tol=ATOL)
+    assert ae(v.real, 0.019020007896208766962, tol=PTOL)
+    assert ae(v.imag, 3.157781446149681126, tol=PTOL)
+    v = fp.ei((0.0 + 50.0j))
+    assert ae(v, (-0.0056283863241163054402 + 3.122413399280832514j), tol=ATOL)
+    assert ae(v.real, -0.0056283863241163054402, tol=PTOL)
+    assert ae(v.imag, 3.122413399280832514, tol=PTOL)
+    v = fp.ei((0.0 + 80.0j))
+    assert ae(v, (-0.012402501155070958192 + 3.1431272137073839346j), tol=ATOL)
+    assert ae(v.real, -0.012402501155070958192, tol=PTOL)
+    assert ae(v.imag, 3.1431272137073839346, tol=PTOL)
+    v = fp.ei((-1.1641532182693481445e-10 + 4.6566128730773925781e-10j))
+    assert ae(v, (-20.880034621664969632 + 1.8157749903874220607j), tol=ATOL)
+    assert ae(v.real, -20.880034621664969632, tol=PTOL)
+    assert ae(v.imag, 1.8157749903874220607, tol=PTOL)
+    v = fp.ei((-0.25 + 1.0j))
+    assert ae(v, (0.16868306393667788761 + 2.6557914649950505414j), tol=ATOL)
+    assert ae(v.real, 0.16868306393667788761, tol=PTOL)
+    assert ae(v.imag, 2.6557914649950505414, tol=PTOL)
+    v = fp.ei((-1.0 + 4.0j))
+    assert ae(v, (-0.03373591813926547318 + 3.2151161058308770603j), tol=ATOL)
+    assert ae(v.real, -0.03373591813926547318, tol=PTOL)
+    assert ae(v.imag, 3.2151161058308770603, tol=PTOL)
+    v = fp.ei((-2.0 + 8.0j))
+    assert ae(v, (0.015392833434733785143 + 3.1384179414340326969j), tol=ATOL)
+    assert ae(v.real, 0.015392833434733785143, tol=PTOL)
+    assert ae(v.imag, 3.1384179414340326969, tol=PTOL)
+    v = fp.ei((-5.0 + 20.0j))
+    assert ae(v, (0.00024419662286542966525 + 3.1413825703601317109j), tol=ATOL)
+    assert ae(v.real, 0.00024419662286542966525, tol=PTOL)
+    assert ae(v.imag, 3.1413825703601317109, tol=PTOL)
+    v = fp.ei((-20.0 + 80.0j))
+    assert ae(v, (-2.3255552781051330088e-11 + 3.1415926535987396304j), tol=ATOL)
+    assert ae(v.real, -2.3255552781051330088e-11, tol=PTOL)
+    assert ae(v.imag, 3.1415926535987396304, tol=PTOL)
+    v = fp.ei((-30.0 + 120.0j))
+    assert ae(v, (2.7068919097124652332e-16 + 3.1415926535897925337j), tol=ATOL)
+    assert ae(v.real, 2.7068919097124652332e-16, tol=PTOL)
+    assert ae(v.imag, 3.1415926535897925337, tol=PTOL)
+    v = fp.ei((-40.0 + 160.0j))
+    assert ae(v, (1.1695597827678024687e-20 + 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, 1.1695597827678024687e-20, tol=PTOL)
+    assert ae(v.imag, 3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-50.0 + 200.0j))
+    assert ae(v, (-9.0323746914410162531e-25 + 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -9.0323746914410162531e-25, tol=PTOL)
+    assert ae(v.imag, 3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-80.0 + 320.0j))
+    assert ae(v, (-3.4819106748728063576e-38 + 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -3.4819106748728063576e-38, tol=PTOL)
+    assert ae(v.imag, 3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-4.6566128730773925781e-10 + 1.1641532182693481445e-10j))
+    assert ae(v, (-20.880034622014215597 + 2.8966139905793444061j), tol=ATOL)
+    assert ae(v.real, -20.880034622014215597, tol=PTOL)
+    assert ae(v.imag, 2.8966139905793444061, tol=PTOL)
+    v = fp.ei((-1.0 + 0.25j))
+    assert ae(v, (-0.19731063945004229095 + 3.0542266078154932748j), tol=ATOL)
+    assert ae(v.real, -0.19731063945004229095, tol=PTOL)
+    assert ae(v.imag, 3.0542266078154932748, tol=PTOL)
+    v = fp.ei((-4.0 + 1.0j))
+    assert ae(v, (-0.0013106173980145506944 + 3.1381384055698581758j), tol=ATOL)
+    assert ae(v.real, -0.0013106173980145506944, tol=PTOL)
+    assert ae(v.imag, 3.1381384055698581758, tol=PTOL)
+    v = fp.ei((-8.0 + 2.0j))
+    assert ae(v, (0.000022278049065270225945 + 3.1415634616493367169j), tol=ATOL)
+    assert ae(v.real, 0.000022278049065270225945, tol=PTOL)
+    assert ae(v.imag, 3.1415634616493367169, tol=PTOL)
+    v = fp.ei((-20.0 + 5.0j))
+    assert ae(v, (-4.7711374515765346894e-11 + 3.1415926536726958909j), tol=ATOL)
+    assert ae(v.real, -4.7711374515765346894e-11, tol=PTOL)
+    assert ae(v.imag, 3.1415926536726958909, tol=PTOL)
+    v = fp.ei((-80.0 + 20.0j))
+    assert ae(v, (-3.8353473865788235787e-38 + 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -3.8353473865788235787e-38, tol=PTOL)
+    assert ae(v.imag, 3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-120.0 + 30.0j))
+    assert ae(v, (-2.3836002337480334716e-55 + 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -2.3836002337480334716e-55, tol=PTOL)
+    assert ae(v.imag, 3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-160.0 + 40.0j))
+    assert ae(v, (1.6238022898654510661e-72 + 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, 1.6238022898654510661e-72, tol=PTOL)
+    assert ae(v.imag, 3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-200.0 + 50.0j))
+    assert ae(v, (-6.6800061461666228487e-90 + 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -6.6800061461666228487e-90, tol=PTOL)
+    assert ae(v.imag, 3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-320.0 + 80.0j))
+    assert ae(v, (-4.2737871527778786157e-143 + 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -4.2737871527778786157e-143, tol=PTOL)
+    assert ae(v.imag, 3.1415926535897932385, tol=PTOL)
+    v = fp.ei(-1.1641532182693481445e-10)
+    assert ae(v, -22.296641293693077672, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(-0.25)
+    assert ae(v, -1.0442826344437381945, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(-1.0)
+    assert ae(v, -0.21938393439552027368, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(-2.0)
+    assert ae(v, -0.048900510708061119567, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(-5.0)
+    assert ae(v, -0.0011482955912753257973, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(-20.0)
+    assert ae(v, -9.8355252906498816904e-11, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(-30.0)
+    assert ae(v, -3.0215520106888125448e-15, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(-40.0)
+    assert ae(v, -1.0367732614516569722e-19, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(-50.0)
+    assert ae(v, -3.7832640295504590187e-24, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(-80.0)
+    assert ae(v, -2.2285432586884729112e-37, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei((-1.1641532182693481445e-10 + 0.0j))
+    assert ae(v, (-22.296641293693077672 + 0.0j), tol=ATOL)
+    assert ae(v.real, -22.296641293693077672, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((-0.25 + 0.0j))
+    assert ae(v, (-1.0442826344437381945 + 0.0j), tol=ATOL)
+    assert ae(v.real, -1.0442826344437381945, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((-1.0 + 0.0j))
+    assert ae(v, (-0.21938393439552027368 + 0.0j), tol=ATOL)
+    assert ae(v.real, -0.21938393439552027368, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((-2.0 + 0.0j))
+    assert ae(v, (-0.048900510708061119567 + 0.0j), tol=ATOL)
+    assert ae(v.real, -0.048900510708061119567, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((-5.0 + 0.0j))
+    assert ae(v, (-0.0011482955912753257973 + 0.0j), tol=ATOL)
+    assert ae(v.real, -0.0011482955912753257973, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((-20.0 + 0.0j))
+    assert ae(v, (-9.8355252906498816904e-11 + 0.0j), tol=ATOL)
+    assert ae(v.real, -9.8355252906498816904e-11, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((-30.0 + 0.0j))
+    assert ae(v, (-3.0215520106888125448e-15 + 0.0j), tol=ATOL)
+    assert ae(v.real, -3.0215520106888125448e-15, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((-40.0 + 0.0j))
+    assert ae(v, (-1.0367732614516569722e-19 + 0.0j), tol=ATOL)
+    assert ae(v.real, -1.0367732614516569722e-19, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((-50.0 + 0.0j))
+    assert ae(v, (-3.7832640295504590187e-24 + 0.0j), tol=ATOL)
+    assert ae(v.real, -3.7832640295504590187e-24, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((-80.0 + 0.0j))
+    assert ae(v, (-2.2285432586884729112e-37 + 0.0j), tol=ATOL)
+    assert ae(v.real, -2.2285432586884729112e-37, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((-4.6566128730773925781e-10 - 1.1641532182693481445e-10j))
+    assert ae(v, (-20.880034622014215597 - 2.8966139905793444061j), tol=ATOL)
+    assert ae(v.real, -20.880034622014215597, tol=PTOL)
+    assert ae(v.imag, -2.8966139905793444061, tol=PTOL)
+    v = fp.ei((-1.0 - 0.25j))
+    assert ae(v, (-0.19731063945004229095 - 3.0542266078154932748j), tol=ATOL)
+    assert ae(v.real, -0.19731063945004229095, tol=PTOL)
+    assert ae(v.imag, -3.0542266078154932748, tol=PTOL)
+    v = fp.ei((-4.0 - 1.0j))
+    assert ae(v, (-0.0013106173980145506944 - 3.1381384055698581758j), tol=ATOL)
+    assert ae(v.real, -0.0013106173980145506944, tol=PTOL)
+    assert ae(v.imag, -3.1381384055698581758, tol=PTOL)
+    v = fp.ei((-8.0 - 2.0j))
+    assert ae(v, (0.000022278049065270225945 - 3.1415634616493367169j), tol=ATOL)
+    assert ae(v.real, 0.000022278049065270225945, tol=PTOL)
+    assert ae(v.imag, -3.1415634616493367169, tol=PTOL)
+    v = fp.ei((-20.0 - 5.0j))
+    assert ae(v, (-4.7711374515765346894e-11 - 3.1415926536726958909j), tol=ATOL)
+    assert ae(v.real, -4.7711374515765346894e-11, tol=PTOL)
+    assert ae(v.imag, -3.1415926536726958909, tol=PTOL)
+    v = fp.ei((-80.0 - 20.0j))
+    assert ae(v, (-3.8353473865788235787e-38 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -3.8353473865788235787e-38, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-120.0 - 30.0j))
+    assert ae(v, (-2.3836002337480334716e-55 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -2.3836002337480334716e-55, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-160.0 - 40.0j))
+    assert ae(v, (1.6238022898654510661e-72 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, 1.6238022898654510661e-72, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-200.0 - 50.0j))
+    assert ae(v, (-6.6800061461666228487e-90 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -6.6800061461666228487e-90, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-320.0 - 80.0j))
+    assert ae(v, (-4.2737871527778786157e-143 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -4.2737871527778786157e-143, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-1.1641532182693481445e-10 - 1.1641532182693481445e-10j))
+    assert ae(v, (-21.950067703413105017 - 2.3561944903087602507j), tol=ATOL)
+    assert ae(v.real, -21.950067703413105017, tol=PTOL)
+    assert ae(v.imag, -2.3561944903087602507, tol=PTOL)
+    v = fp.ei((-0.25 - 0.25j))
+    assert ae(v, (-0.71092525792923287894 - 2.5766745291767512913j), tol=ATOL)
+    assert ae(v.real, -0.71092525792923287894, tol=PTOL)
+    assert ae(v.imag, -2.5766745291767512913, tol=PTOL)
+    v = fp.ei((-1.0 - 1.0j))
+    assert ae(v, (-0.00028162445198141832551 - 2.9622681185504342983j), tol=ATOL)
+    assert ae(v.real, -0.00028162445198141832551, tol=PTOL)
+    assert ae(v.imag, -2.9622681185504342983, tol=PTOL)
+    v = fp.ei((-2.0 - 2.0j))
+    assert ae(v, (0.033767089606562004246 - 3.1229932394200426965j), tol=ATOL)
+    assert ae(v.real, 0.033767089606562004246, tol=PTOL)
+    assert ae(v.imag, -3.1229932394200426965, tol=PTOL)
+    v = fp.ei((-5.0 - 5.0j))
+    assert ae(v, (-0.0007266506660356393891 - 3.1420636813914284609j), tol=ATOL)
+    assert ae(v.real, -0.0007266506660356393891, tol=PTOL)
+    assert ae(v.imag, -3.1420636813914284609, tol=PTOL)
+    v = fp.ei((-20.0 - 20.0j))
+    assert ae(v, (2.3824537449367396579e-11 - 3.1415926535228233653j), tol=ATOL)
+    assert ae(v.real, 2.3824537449367396579e-11, tol=PTOL)
+    assert ae(v.imag, -3.1415926535228233653, tol=PTOL)
+    v = fp.ei((-30.0 - 30.0j))
+    assert ae(v, (-1.7316045841744061617e-15 - 3.141592653589794545j), tol=ATOL)
+    assert ae(v.real, -1.7316045841744061617e-15, tol=PTOL)
+    assert ae(v.imag, -3.141592653589794545, tol=PTOL)
+    v = fp.ei((-40.0 - 40.0j))
+    assert ae(v, (7.4001043002899232182e-20 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, 7.4001043002899232182e-20, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-50.0 - 50.0j))
+    assert ae(v, (-2.3566128324644641219e-24 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -2.3566128324644641219e-24, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-80.0 - 80.0j))
+    assert ae(v, (-9.8279750572186526673e-38 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -9.8279750572186526673e-38, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-1.1641532182693481445e-10 - 4.6566128730773925781e-10j))
+    assert ae(v, (-20.880034621664969632 - 1.8157749903874220607j), tol=ATOL)
+    assert ae(v.real, -20.880034621664969632, tol=PTOL)
+    assert ae(v.imag, -1.8157749903874220607, tol=PTOL)
+    v = fp.ei((-0.25 - 1.0j))
+    assert ae(v, (0.16868306393667788761 - 2.6557914649950505414j), tol=ATOL)
+    assert ae(v.real, 0.16868306393667788761, tol=PTOL)
+    assert ae(v.imag, -2.6557914649950505414, tol=PTOL)
+    v = fp.ei((-1.0 - 4.0j))
+    assert ae(v, (-0.03373591813926547318 - 3.2151161058308770603j), tol=ATOL)
+    assert ae(v.real, -0.03373591813926547318, tol=PTOL)
+    assert ae(v.imag, -3.2151161058308770603, tol=PTOL)
+    v = fp.ei((-2.0 - 8.0j))
+    assert ae(v, (0.015392833434733785143 - 3.1384179414340326969j), tol=ATOL)
+    assert ae(v.real, 0.015392833434733785143, tol=PTOL)
+    assert ae(v.imag, -3.1384179414340326969, tol=PTOL)
+    v = fp.ei((-5.0 - 20.0j))
+    assert ae(v, (0.00024419662286542966525 - 3.1413825703601317109j), tol=ATOL)
+    assert ae(v.real, 0.00024419662286542966525, tol=PTOL)
+    assert ae(v.imag, -3.1413825703601317109, tol=PTOL)
+    v = fp.ei((-20.0 - 80.0j))
+    assert ae(v, (-2.3255552781051330088e-11 - 3.1415926535987396304j), tol=ATOL)
+    assert ae(v.real, -2.3255552781051330088e-11, tol=PTOL)
+    assert ae(v.imag, -3.1415926535987396304, tol=PTOL)
+    v = fp.ei((-30.0 - 120.0j))
+    assert ae(v, (2.7068919097124652332e-16 - 3.1415926535897925337j), tol=ATOL)
+    assert ae(v.real, 2.7068919097124652332e-16, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897925337, tol=PTOL)
+    v = fp.ei((-40.0 - 160.0j))
+    assert ae(v, (1.1695597827678024687e-20 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, 1.1695597827678024687e-20, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-50.0 - 200.0j))
+    assert ae(v, (-9.0323746914410162531e-25 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -9.0323746914410162531e-25, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-80.0 - 320.0j))
+    assert ae(v, (-3.4819106748728063576e-38 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -3.4819106748728063576e-38, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.ei((0.0 - 1.1641532182693481445e-10j))
+    assert ae(v, (-22.29664129357666235 - 1.5707963269113119411j), tol=ATOL)
+    assert ae(v.real, -22.29664129357666235, tol=PTOL)
+    assert ae(v.imag, -1.5707963269113119411, tol=PTOL)
+    v = fp.ei((0.0 - 0.25j))
+    assert ae(v, (-0.82466306258094565309 - 1.8199298971146537833j), tol=ATOL)
+    assert ae(v.real, -0.82466306258094565309, tol=PTOL)
+    assert ae(v.imag, -1.8199298971146537833, tol=PTOL)
+    v = fp.ei((0.0 - 1.0j))
+    assert ae(v, (0.33740392290096813466 - 2.5168793971620796342j), tol=ATOL)
+    assert ae(v.real, 0.33740392290096813466, tol=PTOL)
+    assert ae(v.imag, -2.5168793971620796342, tol=PTOL)
+    v = fp.ei((0.0 - 2.0j))
+    assert ae(v, (0.4229808287748649957 - 3.1762093035975914678j), tol=ATOL)
+    assert ae(v.real, 0.4229808287748649957, tol=PTOL)
+    assert ae(v.imag, -3.1762093035975914678, tol=PTOL)
+    v = fp.ei((0.0 - 5.0j))
+    assert ae(v, (-0.19002974965664387862 - 3.1207275717395707565j), tol=ATOL)
+    assert ae(v.real, -0.19002974965664387862, tol=PTOL)
+    assert ae(v.imag, -3.1207275717395707565, tol=PTOL)
+    v = fp.ei((0.0 - 20.0j))
+    assert ae(v, (0.04441982084535331654 - 3.1190380278383364594j), tol=ATOL)
+    assert ae(v.real, 0.04441982084535331654, tol=PTOL)
+    assert ae(v.imag, -3.1190380278383364594, tol=PTOL)
+    v = fp.ei((0.0 - 30.0j))
+    assert ae(v, (-0.033032417282071143779 - 3.1375528668252477302j), tol=ATOL)
+    assert ae(v.real, -0.033032417282071143779, tol=PTOL)
+    assert ae(v.imag, -3.1375528668252477302, tol=PTOL)
+    v = fp.ei((0.0 - 40.0j))
+    assert ae(v, (0.019020007896208766962 - 3.157781446149681126j), tol=ATOL)
+    assert ae(v.real, 0.019020007896208766962, tol=PTOL)
+    assert ae(v.imag, -3.157781446149681126, tol=PTOL)
+    v = fp.ei((0.0 - 50.0j))
+    assert ae(v, (-0.0056283863241163054402 - 3.122413399280832514j), tol=ATOL)
+    assert ae(v.real, -0.0056283863241163054402, tol=PTOL)
+    assert ae(v.imag, -3.122413399280832514, tol=PTOL)
+    v = fp.ei((0.0 - 80.0j))
+    assert ae(v, (-0.012402501155070958192 - 3.1431272137073839346j), tol=ATOL)
+    assert ae(v.real, -0.012402501155070958192, tol=PTOL)
+    assert ae(v.imag, -3.1431272137073839346, tol=PTOL)
+    v = fp.ei((1.1641532182693481445e-10 - 4.6566128730773925781e-10j))
+    assert ae(v, (-20.880034621432138988 - 1.3258176641336937524j), tol=ATOL)
+    assert ae(v.real, -20.880034621432138988, tol=PTOL)
+    assert ae(v.imag, -1.3258176641336937524, tol=PTOL)
+    v = fp.ei((0.25 - 1.0j))
+    assert ae(v, (0.59066621214766308594 - 2.3968481059377428687j), tol=ATOL)
+    assert ae(v.real, 0.59066621214766308594, tol=PTOL)
+    assert ae(v.imag, -2.3968481059377428687, tol=PTOL)
+    v = fp.ei((1.0 - 4.0j))
+    assert ae(v, (-0.49739047283060471093 - 3.5570287076301818702j), tol=ATOL)
+    assert ae(v.real, -0.49739047283060471093, tol=PTOL)
+    assert ae(v.imag, -3.5570287076301818702, tol=PTOL)
+    v = fp.ei((2.0 - 8.0j))
+    assert ae(v, (0.8705211147733730969 - 3.3825859385758486351j), tol=ATOL)
+    assert ae(v.real, 0.8705211147733730969, tol=PTOL)
+    assert ae(v.imag, -3.3825859385758486351, tol=PTOL)
+    v = fp.ei((5.0 - 20.0j))
+    assert ae(v, (7.0789514293925893007 - 1.5313749363937141849j), tol=ATOL)
+    assert ae(v.real, 7.0789514293925893007, tol=PTOL)
+    assert ae(v.imag, -1.5313749363937141849, tol=PTOL)
+    v = fp.ei((20.0 - 80.0j))
+    assert ae(v, (-5855431.4907298084434 + 720917.79156143806727j), tol=ATOL)
+    assert ae(v.real, -5855431.4907298084434, tol=PTOL)
+    assert ae(v.imag, 720917.79156143806727, tol=PTOL)
+    v = fp.ei((30.0 - 120.0j))
+    assert ae(v, (65402491644.703470747 + 56697658396.51586764j), tol=ATOL)
+    assert ae(v.real, 65402491644.703470747, tol=PTOL)
+    assert ae(v.imag, 56697658396.51586764, tol=PTOL)
+    v = fp.ei((40.0 - 160.0j))
+    assert ae(v, (-25504929379604.776769 - 1429035198630576.3879j), tol=ATOL)
+    assert ae(v.real, -25504929379604.776769, tol=PTOL)
+    assert ae(v.imag, -1429035198630576.3879, tol=PTOL)
+    v = fp.ei((50.0 - 200.0j))
+    assert ae(v, (-18437746526988116954.0 + 17146362239046152342.0j), tol=ATOL)
+    assert ae(v.real, -18437746526988116954.0, tol=PTOL)
+    assert ae(v.imag, 17146362239046152342.0, tol=PTOL)
+    v = fp.ei((80.0 - 320.0j))
+    assert ae(v, (-3.3464697299634526706e+31 + 1.6473152633843023919e+32j), tol=ATOL)
+    assert ae(v.real, -3.3464697299634526706e+31, tol=PTOL)
+    assert ae(v.imag, 1.6473152633843023919e+32, tol=PTOL)
+    v = fp.ei((1.1641532182693481445e-10 - 1.1641532182693481445e-10j))
+    assert ae(v, (-21.950067703180274374 - 0.78539816351386363145j), tol=ATOL)
+    assert ae(v.real, -21.950067703180274374, tol=PTOL)
+    assert ae(v.imag, -0.78539816351386363145, tol=PTOL)
+    v = fp.ei((0.25 - 0.25j))
+    assert ae(v, (-0.21441047326710323254 - 1.0683772981589995996j), tol=ATOL)
+    assert ae(v.real, -0.21441047326710323254, tol=PTOL)
+    assert ae(v.imag, -1.0683772981589995996, tol=PTOL)
+    v = fp.ei((1.0 - 1.0j))
+    assert ae(v, (1.7646259855638540684 - 2.3877698515105224193j), tol=ATOL)
+    assert ae(v.real, 1.7646259855638540684, tol=PTOL)
+    assert ae(v.imag, -2.3877698515105224193, tol=PTOL)
+    v = fp.ei((2.0 - 2.0j))
+    assert ae(v, (1.8920781621855474089 - 5.3169624378326579621j), tol=ATOL)
+    assert ae(v.real, 1.8920781621855474089, tol=PTOL)
+    assert ae(v.imag, -5.3169624378326579621, tol=PTOL)
+    v = fp.ei((5.0 - 5.0j))
+    assert ae(v, (-13.470936071475245856 + 15.322492395731230968j), tol=ATOL)
+    assert ae(v.real, -13.470936071475245856, tol=PTOL)
+    assert ae(v.imag, 15.322492395731230968, tol=PTOL)
+    v = fp.ei((20.0 - 20.0j))
+    assert ae(v, (16589317.398788971896 - 5831705.4712368307104j), tol=ATOL)
+    assert ae(v.real, 16589317.398788971896, tol=PTOL)
+    assert ae(v.imag, -5831705.4712368307104, tol=PTOL)
+    v = fp.ei((30.0 - 30.0j))
+    assert ae(v, (-154596484273.69322527 + 204179357834.2723043j), tol=ATOL)
+    assert ae(v.real, -154596484273.69322527, tol=PTOL)
+    assert ae(v.imag, 204179357834.2723043, tol=PTOL)
+    v = fp.ei((40.0 - 40.0j))
+    assert ae(v, (287512180321448.45408 - 4203502407932318.1156j), tol=ATOL)
+    assert ae(v.real, 287512180321448.45408, tol=PTOL)
+    assert ae(v.imag, -4203502407932318.1156, tol=PTOL)
+    v = fp.ei((50.0 - 50.0j))
+    assert ae(v, (36128528616649268826.0 + 64648801861338741960.0j), tol=ATOL)
+    assert ae(v.real, 36128528616649268826.0, tol=PTOL)
+    assert ae(v.imag, 64648801861338741960.0, tol=PTOL)
+    v = fp.ei((80.0 - 80.0j))
+    assert ae(v, (-3.8674816337930010217e+32 + 3.0540709639658071041e+32j), tol=ATOL)
+    assert ae(v.real, -3.8674816337930010217e+32, tol=PTOL)
+    assert ae(v.imag, 3.0540709639658071041e+32, tol=PTOL)
+    v = fp.ei((4.6566128730773925781e-10 - 1.1641532182693481445e-10j))
+    assert ae(v, (-20.880034621082893023 - 0.24497866324327947603j), tol=ATOL)
+    assert ae(v.real, -20.880034621082893023, tol=PTOL)
+    assert ae(v.imag, -0.24497866324327947603, tol=PTOL)
+    v = fp.ei((1.0 - 0.25j))
+    assert ae(v, (1.8942716983721074932 - 0.67268237088273915854j), tol=ATOL)
+    assert ae(v.real, 1.8942716983721074932, tol=PTOL)
+    assert ae(v.imag, -0.67268237088273915854, tol=PTOL)
+    v = fp.ei((4.0 - 1.0j))
+    assert ae(v, (14.806699492675420438 - 12.280015176673582616j), tol=ATOL)
+    assert ae(v.real, 14.806699492675420438, tol=PTOL)
+    assert ae(v.imag, -12.280015176673582616, tol=PTOL)
+    v = fp.ei((8.0 - 2.0j))
+    assert ae(v, (-54.633252667426386294 - 416.34477429173650012j), tol=ATOL)
+    assert ae(v.real, -54.633252667426386294, tol=PTOL)
+    assert ae(v.imag, -416.34477429173650012, tol=PTOL)
+    v = fp.ei((20.0 - 5.0j))
+    assert ae(v, (711836.97165402624643 + 24745247.798103247366j), tol=ATOL)
+    assert ae(v.real, 711836.97165402624643, tol=PTOL)
+    assert ae(v.imag, 24745247.798103247366, tol=PTOL)
+    v = fp.ei((80.0 - 20.0j))
+    assert ae(v, (4.2139911108612653091e+32 - 5.3367124741918251637e+32j), tol=ATOL)
+    assert ae(v.real, 4.2139911108612653091e+32, tol=PTOL)
+    assert ae(v.imag, -5.3367124741918251637e+32, tol=PTOL)
+    v = fp.ei((120.0 - 30.0j))
+    assert ae(v, (-9.7760616203707508892e+48 + 1.058257682317195792e+50j), tol=ATOL)
+    assert ae(v.real, -9.7760616203707508892e+48, tol=PTOL)
+    assert ae(v.imag, 1.058257682317195792e+50, tol=PTOL)
+    v = fp.ei((160.0 - 40.0j))
+    assert ae(v, (-8.7065541466623638861e+66 - 1.6577106725141739889e+67j), tol=ATOL)
+    assert ae(v.real, -8.7065541466623638861e+66, tol=PTOL)
+    assert ae(v.imag, -1.6577106725141739889e+67, tol=PTOL)
+    v = fp.ei((200.0 - 50.0j))
+    assert ae(v, (3.070744996327018106e+84 + 1.7243244846769415903e+84j), tol=ATOL)
+    assert ae(v.real, 3.070744996327018106e+84, tol=PTOL)
+    assert ae(v.imag, 1.7243244846769415903e+84, tol=PTOL)
+    v = fp.ei((320.0 - 80.0j))
+    assert ae(v, (-9.9960598637998647276e+135 + 2.6855081527595608863e+136j), tol=ATOL)
+    assert ae(v.real, -9.9960598637998647276e+135, tol=PTOL)
+    assert ae(v.imag, 2.6855081527595608863e+136, tol=PTOL)
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_functions.py b/lib/python3.10/site-packages/mpmath/tests/test_functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..3bfe852f008173eb636c147abc83d71dbdd4d23a
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_functions.py
@@ -0,0 +1,920 @@
+from mpmath.libmp import *
+from mpmath import *
+import random
+import time
+import math
+import cmath
+
+def mpc_ae(a, b, eps=eps):
+    res = True
+    res = res and a.real.ae(b.real, eps)
+    res = res and a.imag.ae(b.imag, eps)
+    return res
+
+#----------------------------------------------------------------------------
+# Constants and functions
+#
+
+tpi = "3.1415926535897932384626433832795028841971693993751058209749445923078\
+1640628620899862803482534211706798"
+te = "2.71828182845904523536028747135266249775724709369995957496696762772407\
+663035354759457138217852516642743"
+tdegree = "0.017453292519943295769236907684886127134428718885417254560971914\
+4017100911460344944368224156963450948221"
+teuler = "0.5772156649015328606065120900824024310421593359399235988057672348\
+84867726777664670936947063291746749516"
+tln2 = "0.693147180559945309417232121458176568075500134360255254120680009493\
+393621969694715605863326996418687542"
+tln10 = "2.30258509299404568401799145468436420760110148862877297603332790096\
+757260967735248023599720508959829834"
+tcatalan = "0.91596559417721901505460351493238411077414937428167213426649811\
+9621763019776254769479356512926115106249"
+tkhinchin = "2.6854520010653064453097148354817956938203822939944629530511523\
+4555721885953715200280114117493184769800"
+tglaisher = "1.2824271291006226368753425688697917277676889273250011920637400\
+2174040630885882646112973649195820237439420646"
+tapery = "1.2020569031595942853997381615114499907649862923404988817922715553\
+4183820578631309018645587360933525815"
+tphi = "1.618033988749894848204586834365638117720309179805762862135448622705\
+26046281890244970720720418939113748475"
+tmertens = "0.26149721284764278375542683860869585905156664826119920619206421\
+3924924510897368209714142631434246651052"
+ttwinprime = "0.660161815846869573927812110014555778432623360284733413319448\
+423335405642304495277143760031413839867912"
+
+def test_constants():
+    for prec in [3, 7, 10, 15, 20, 37, 80, 100, 29]:
+        mp.dps = prec
+        assert pi == mpf(tpi)
+        assert e == mpf(te)
+        assert degree == mpf(tdegree)
+        assert euler == mpf(teuler)
+        assert ln2 == mpf(tln2)
+        assert ln10 == mpf(tln10)
+        assert catalan == mpf(tcatalan)
+        assert khinchin == mpf(tkhinchin)
+        assert glaisher == mpf(tglaisher)
+        assert phi == mpf(tphi)
+        if prec < 50:
+            assert mertens == mpf(tmertens)
+            assert twinprime == mpf(ttwinprime)
+    mp.dps = 15
+    assert pi >= -1
+    assert pi > 2
+    assert pi > 3
+    assert pi < 4
+
+def test_exact_sqrts():
+    for i in range(20000):
+        assert sqrt(mpf(i*i)) == i
+    random.seed(1)
+    for prec in [100, 300, 1000, 10000]:
+        mp.dps = prec
+        for i in range(20):
+            A = random.randint(10**(prec//2-2), 10**(prec//2-1))
+            assert sqrt(mpf(A*A)) == A
+    mp.dps = 15
+    for i in range(100):
+        for a in [1, 8, 25, 112307]:
+            assert sqrt(mpf((a*a, 2*i))) == mpf((a, i))
+            assert sqrt(mpf((a*a, -2*i))) == mpf((a, -i))
+
+def test_sqrt_rounding():
+    for i in [2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15]:
+        i = from_int(i)
+        for dps in [7, 15, 83, 106, 2000]:
+            mp.dps = dps
+            a = mpf_pow_int(mpf_sqrt(i, mp.prec, round_down), 2, mp.prec, round_down)
+            b = mpf_pow_int(mpf_sqrt(i, mp.prec, round_up), 2, mp.prec, round_up)
+            assert mpf_lt(a, i)
+            assert mpf_gt(b, i)
+    random.seed(1234)
+    prec = 100
+    for rnd in [round_down, round_nearest, round_ceiling]:
+        for i in range(100):
+            a = mpf_rand(prec)
+            b = mpf_mul(a, a)
+            assert mpf_sqrt(b, prec, rnd) == a
+    # Test some extreme cases
+    mp.dps = 100
+    a = mpf(9) + 1e-90
+    b = mpf(9) - 1e-90
+    mp.dps = 15
+    assert sqrt(a, rounding='d') == 3
+    assert sqrt(a, rounding='n') == 3
+    assert sqrt(a, rounding='u') > 3
+    assert sqrt(b, rounding='d') < 3
+    assert sqrt(b, rounding='n') == 3
+    assert sqrt(b, rounding='u') == 3
+    # A worst case, from the MPFR test suite
+    assert sqrt(mpf('7.0503726185518891')) == mpf('2.655253776675949')
+
+def test_float_sqrt():
+    mp.dps = 15
+    # These should round identically
+    for x in [0, 1e-7, 0.1, 0.5, 1, 2, 3, 4, 5, 0.333, 76.19]:
+        assert sqrt(mpf(x)) == float(x)**0.5
+    assert sqrt(-1) == 1j
+    assert sqrt(-2).ae(cmath.sqrt(-2))
+    assert sqrt(-3).ae(cmath.sqrt(-3))
+    assert sqrt(-100).ae(cmath.sqrt(-100))
+    assert sqrt(1j).ae(cmath.sqrt(1j))
+    assert sqrt(-1j).ae(cmath.sqrt(-1j))
+    assert sqrt(math.pi + math.e*1j).ae(cmath.sqrt(math.pi + math.e*1j))
+    assert sqrt(math.pi - math.e*1j).ae(cmath.sqrt(math.pi - math.e*1j))
+
+def test_hypot():
+    assert hypot(0, 0) == 0
+    assert hypot(0, 0.33) == mpf(0.33)
+    assert hypot(0.33, 0) == mpf(0.33)
+    assert hypot(-0.33, 0) == mpf(0.33)
+    assert hypot(3, 4) == mpf(5)
+
+def test_exact_cbrt():
+    for i in range(0, 20000, 200):
+        assert cbrt(mpf(i*i*i)) == i
+    random.seed(1)
+    for prec in [100, 300, 1000, 10000]:
+        mp.dps = prec
+        A = random.randint(10**(prec//2-2), 10**(prec//2-1))
+        assert cbrt(mpf(A*A*A)) == A
+    mp.dps = 15
+
+def test_exp():
+    assert exp(0) == 1
+    assert exp(10000).ae(mpf('8.8068182256629215873e4342'))
+    assert exp(-10000).ae(mpf('1.1354838653147360985e-4343'))
+    a = exp(mpf((1, 8198646019315405, -53, 53)))
+    assert(a.bc == bitcount(a.man))
+    mp.prec = 67
+    a = exp(mpf((1, 1781864658064754565, -60, 61)))
+    assert(a.bc == bitcount(a.man))
+    mp.prec = 53
+    assert exp(ln2 * 10).ae(1024)
+    assert exp(2+2j).ae(cmath.exp(2+2j))
+
+def test_issue_73():
+    mp.dps = 512
+    a = exp(-1)
+    b = exp(1)
+    mp.dps = 15
+    assert (+a).ae(0.36787944117144233)
+    assert (+b).ae(2.7182818284590451)
+
+def test_log():
+    mp.dps = 15
+    assert log(1) == 0
+    for x in [0.5, 1.5, 2.0, 3.0, 100, 10**50, 1e-50]:
+        assert log(x).ae(math.log(x))
+        assert log(x, x) == 1
+    assert log(1024, 2) == 10
+    assert log(10**1234, 10) == 1234
+    assert log(2+2j).ae(cmath.log(2+2j))
+    # Accuracy near 1
+    assert (log(0.6+0.8j).real*10**17).ae(2.2204460492503131)
+    assert (log(0.6-0.8j).real*10**17).ae(2.2204460492503131)
+    assert (log(0.8-0.6j).real*10**17).ae(2.2204460492503131)
+    assert (log(1+1e-8j).real*10**16).ae(0.5)
+    assert (log(1-1e-8j).real*10**16).ae(0.5)
+    assert (log(-1+1e-8j).real*10**16).ae(0.5)
+    assert (log(-1-1e-8j).real*10**16).ae(0.5)
+    assert (log(1j+1e-8).real*10**16).ae(0.5)
+    assert (log(1j-1e-8).real*10**16).ae(0.5)
+    assert (log(-1j+1e-8).real*10**16).ae(0.5)
+    assert (log(-1j-1e-8).real*10**16).ae(0.5)
+    assert (log(1+1e-40j).real*10**80).ae(0.5)
+    assert (log(1j+1e-40).real*10**80).ae(0.5)
+    # Huge
+    assert log(ldexp(1.234,10**20)).ae(log(2)*1e20)
+    assert log(ldexp(1.234,10**200)).ae(log(2)*1e200)
+    # Some special values
+    assert log(mpc(0,0)) == mpc(-inf,0)
+    assert isnan(log(mpc(nan,0)).real)
+    assert isnan(log(mpc(nan,0)).imag)
+    assert isnan(log(mpc(0,nan)).real)
+    assert isnan(log(mpc(0,nan)).imag)
+    assert isnan(log(mpc(nan,1)).real)
+    assert isnan(log(mpc(nan,1)).imag)
+    assert isnan(log(mpc(1,nan)).real)
+    assert isnan(log(mpc(1,nan)).imag)
+
+def test_trig_hyperb_basic():
+    for x in (list(range(100)) + list(range(-100,0))):
+        t = x / 4.1
+        assert cos(mpf(t)).ae(math.cos(t))
+        assert sin(mpf(t)).ae(math.sin(t))
+        assert tan(mpf(t)).ae(math.tan(t))
+        assert cosh(mpf(t)).ae(math.cosh(t))
+        assert sinh(mpf(t)).ae(math.sinh(t))
+        assert tanh(mpf(t)).ae(math.tanh(t))
+    assert sin(1+1j).ae(cmath.sin(1+1j))
+    assert sin(-4-3.6j).ae(cmath.sin(-4-3.6j))
+    assert cos(1+1j).ae(cmath.cos(1+1j))
+    assert cos(-4-3.6j).ae(cmath.cos(-4-3.6j))
+
+def test_degrees():
+    assert cos(0*degree) == 1
+    assert cos(90*degree).ae(0)
+    assert cos(180*degree).ae(-1)
+    assert cos(270*degree).ae(0)
+    assert cos(360*degree).ae(1)
+    assert sin(0*degree) == 0
+    assert sin(90*degree).ae(1)
+    assert sin(180*degree).ae(0)
+    assert sin(270*degree).ae(-1)
+    assert sin(360*degree).ae(0)
+
+def random_complexes(N):
+    random.seed(1)
+    a = []
+    for i in range(N):
+        x1 = random.uniform(-10, 10)
+        y1 = random.uniform(-10, 10)
+        x2 = random.uniform(-10, 10)
+        y2 = random.uniform(-10, 10)
+        z1 = complex(x1, y1)
+        z2 = complex(x2, y2)
+        a.append((z1, z2))
+    return a
+
+def test_complex_powers():
+    for dps in [15, 30, 100]:
+        # Check accuracy for complex square root
+        mp.dps = dps
+        a = mpc(1j)**0.5
+        assert a.real == a.imag == mpf(2)**0.5 / 2
+    mp.dps = 15
+    random.seed(1)
+    for (z1, z2) in random_complexes(100):
+        assert (mpc(z1)**mpc(z2)).ae(z1**z2, 1e-12)
+    assert (e**(-pi*1j)).ae(-1)
+    mp.dps = 50
+    assert (e**(-pi*1j)).ae(-1)
+    mp.dps = 15
+
+def test_complex_sqrt_accuracy():
+    def test_mpc_sqrt(lst):
+        for a, b in lst:
+            z = mpc(a + j*b)
+            assert mpc_ae(sqrt(z*z), z)
+            z = mpc(-a + j*b)
+            assert mpc_ae(sqrt(z*z), -z)
+            z = mpc(a - j*b)
+            assert mpc_ae(sqrt(z*z), z)
+            z = mpc(-a - j*b)
+            assert mpc_ae(sqrt(z*z), -z)
+    random.seed(2)
+    N = 10
+    mp.dps = 30
+    dps = mp.dps
+    test_mpc_sqrt([(random.uniform(0, 10),random.uniform(0, 10)) for i in range(N)])
+    test_mpc_sqrt([(i + 0.1, (i + 0.2)*10**i) for i in range(N)])
+    mp.dps = 15
+
+def test_atan():
+    mp.dps = 15
+    assert atan(-2.3).ae(math.atan(-2.3))
+    assert atan(1e-50) == 1e-50
+    assert atan(1e50).ae(pi/2)
+    assert atan(-1e-50) == -1e-50
+    assert atan(-1e50).ae(-pi/2)
+    assert atan(10**1000).ae(pi/2)
+    for dps in [25, 70, 100, 300, 1000]:
+        mp.dps = dps
+        assert (4*atan(1)).ae(pi)
+    mp.dps = 15
+    pi2 = pi/2
+    assert atan(mpc(inf,-1)).ae(pi2)
+    assert atan(mpc(inf,0)).ae(pi2)
+    assert atan(mpc(inf,1)).ae(pi2)
+    assert atan(mpc(1,inf)).ae(pi2)
+    assert atan(mpc(0,inf)).ae(pi2)
+    assert atan(mpc(-1,inf)).ae(-pi2)
+    assert atan(mpc(-inf,1)).ae(-pi2)
+    assert atan(mpc(-inf,0)).ae(-pi2)
+    assert atan(mpc(-inf,-1)).ae(-pi2)
+    assert atan(mpc(-1,-inf)).ae(-pi2)
+    assert atan(mpc(0,-inf)).ae(-pi2)
+    assert atan(mpc(1,-inf)).ae(pi2)
+
+def test_atan2():
+    mp.dps = 15
+    assert atan2(1,1).ae(pi/4)
+    assert atan2(1,-1).ae(3*pi/4)
+    assert atan2(-1,-1).ae(-3*pi/4)
+    assert atan2(-1,1).ae(-pi/4)
+    assert atan2(-1,0).ae(-pi/2)
+    assert atan2(1,0).ae(pi/2)
+    assert atan2(0,0) == 0
+    assert atan2(inf,0).ae(pi/2)
+    assert atan2(-inf,0).ae(-pi/2)
+    assert isnan(atan2(inf,inf))
+    assert isnan(atan2(-inf,inf))
+    assert isnan(atan2(inf,-inf))
+    assert isnan(atan2(3,nan))
+    assert isnan(atan2(nan,3))
+    assert isnan(atan2(0,nan))
+    assert isnan(atan2(nan,0))
+    assert atan2(0,inf) == 0
+    assert atan2(0,-inf).ae(pi)
+    assert atan2(10,inf) == 0
+    assert atan2(-10,inf) == 0
+    assert atan2(-10,-inf).ae(-pi)
+    assert atan2(10,-inf).ae(pi)
+    assert atan2(inf,10).ae(pi/2)
+    assert atan2(inf,-10).ae(pi/2)
+    assert atan2(-inf,10).ae(-pi/2)
+    assert atan2(-inf,-10).ae(-pi/2)
+
+def test_areal_inverses():
+    assert asin(mpf(0)) == 0
+    assert asinh(mpf(0)) == 0
+    assert acosh(mpf(1)) == 0
+    assert isinstance(asin(mpf(0.5)), mpf)
+    assert isinstance(asin(mpf(2.0)), mpc)
+    assert isinstance(acos(mpf(0.5)), mpf)
+    assert isinstance(acos(mpf(2.0)), mpc)
+    assert isinstance(atanh(mpf(0.1)), mpf)
+    assert isinstance(atanh(mpf(1.1)), mpc)
+
+    random.seed(1)
+    for i in range(50):
+        x = random.uniform(0, 1)
+        assert asin(mpf(x)).ae(math.asin(x))
+        assert acos(mpf(x)).ae(math.acos(x))
+
+        x = random.uniform(-10, 10)
+        assert asinh(mpf(x)).ae(cmath.asinh(x).real)
+        assert isinstance(asinh(mpf(x)), mpf)
+        x = random.uniform(1, 10)
+        assert acosh(mpf(x)).ae(cmath.acosh(x).real)
+        assert isinstance(acosh(mpf(x)), mpf)
+        x = random.uniform(-10, 0.999)
+        assert isinstance(acosh(mpf(x)), mpc)
+
+        x = random.uniform(-1, 1)
+        assert atanh(mpf(x)).ae(cmath.atanh(x).real)
+        assert isinstance(atanh(mpf(x)), mpf)
+
+    dps = mp.dps
+    mp.dps = 300
+    assert isinstance(asin(0.5), mpf)
+    mp.dps = 1000
+    assert asin(1).ae(pi/2)
+    assert asin(-1).ae(-pi/2)
+    mp.dps = dps
+
+def test_invhyperb_inaccuracy():
+    mp.dps = 15
+    assert (asinh(1e-5)*10**5).ae(0.99999999998333333)
+    assert (asinh(1e-10)*10**10).ae(1)
+    assert (asinh(1e-50)*10**50).ae(1)
+    assert (asinh(-1e-5)*10**5).ae(-0.99999999998333333)
+    assert (asinh(-1e-10)*10**10).ae(-1)
+    assert (asinh(-1e-50)*10**50).ae(-1)
+    assert asinh(10**20).ae(46.744849040440862)
+    assert asinh(-10**20).ae(-46.744849040440862)
+    assert (tanh(1e-10)*10**10).ae(1)
+    assert (tanh(-1e-10)*10**10).ae(-1)
+    assert (atanh(1e-10)*10**10).ae(1)
+    assert (atanh(-1e-10)*10**10).ae(-1)
+
+def test_complex_functions():
+    for x in (list(range(10)) + list(range(-10,0))):
+        for y in (list(range(10)) + list(range(-10,0))):
+            z = complex(x, y)/4.3 + 0.01j
+            assert exp(mpc(z)).ae(cmath.exp(z))
+            assert log(mpc(z)).ae(cmath.log(z))
+            assert cos(mpc(z)).ae(cmath.cos(z))
+            assert sin(mpc(z)).ae(cmath.sin(z))
+            assert tan(mpc(z)).ae(cmath.tan(z))
+            assert sinh(mpc(z)).ae(cmath.sinh(z))
+            assert cosh(mpc(z)).ae(cmath.cosh(z))
+            assert tanh(mpc(z)).ae(cmath.tanh(z))
+
+def test_complex_inverse_functions():
+    mp.dps = 15
+    iv.dps = 15
+    for (z1, z2) in random_complexes(30):
+        # apparently cmath uses a different branch, so we
+        # can't use it for comparison
+        assert sinh(asinh(z1)).ae(z1)
+        #
+        assert acosh(z1).ae(cmath.acosh(z1))
+        assert atanh(z1).ae(cmath.atanh(z1))
+        assert atan(z1).ae(cmath.atan(z1))
+        # the reason we set a big eps here is that the cmath
+        # functions are inaccurate
+        assert asin(z1).ae(cmath.asin(z1), rel_eps=1e-12)
+        assert acos(z1).ae(cmath.acos(z1), rel_eps=1e-12)
+        one = mpf(1)
+    for i in range(-9, 10, 3):
+        for k in range(-9, 10, 3):
+            a = 0.9*j*10**k + 0.8*one*10**i
+            b = cos(acos(a))
+            assert b.ae(a)
+            b = sin(asin(a))
+            assert b.ae(a)
+    one = mpf(1)
+    err = 2*10**-15
+    for i in range(-9, 9, 3):
+        for k in range(-9, 9, 3):
+            a = -0.9*10**k + j*0.8*one*10**i
+            b = cosh(acosh(a))
+            assert b.ae(a, err)
+            b = sinh(asinh(a))
+            assert b.ae(a, err)
+
+def test_reciprocal_functions():
+    assert sec(3).ae(-1.01010866590799375)
+    assert csc(3).ae(7.08616739573718592)
+    assert cot(3).ae(-7.01525255143453347)
+    assert sech(3).ae(0.0993279274194332078)
+    assert csch(3).ae(0.0998215696688227329)
+    assert coth(3).ae(1.00496982331368917)
+    assert asec(3).ae(1.23095941734077468)
+    assert acsc(3).ae(0.339836909454121937)
+    assert acot(3).ae(0.321750554396642193)
+    assert asech(0.5).ae(1.31695789692481671)
+    assert acsch(3).ae(0.327450150237258443)
+    assert acoth(3).ae(0.346573590279972655)
+    assert acot(0).ae(1.5707963267948966192)
+    assert acoth(0).ae(1.5707963267948966192j)
+
+def test_ldexp():
+    mp.dps = 15
+    assert ldexp(mpf(2.5), 0) == 2.5
+    assert ldexp(mpf(2.5), -1) == 1.25
+    assert ldexp(mpf(2.5), 2) == 10
+    assert ldexp(mpf('inf'), 3) == mpf('inf')
+
+def test_frexp():
+    mp.dps = 15
+    assert frexp(0) == (0.0, 0)
+    assert frexp(9) == (0.5625, 4)
+    assert frexp(1) == (0.5, 1)
+    assert frexp(0.2) == (0.8, -2)
+    assert frexp(1000) == (0.9765625, 10)
+
+def test_aliases():
+    assert ln(7) == log(7)
+    assert log10(3.75) == log(3.75,10)
+    assert degrees(5.6) == 5.6 / degree
+    assert radians(5.6) == 5.6 * degree
+    assert power(-1,0.5) == j
+    assert fmod(25,7) == 4.0 and isinstance(fmod(25,7), mpf)
+
+def test_arg_sign():
+    assert arg(3) == 0
+    assert arg(-3).ae(pi)
+    assert arg(j).ae(pi/2)
+    assert arg(-j).ae(-pi/2)
+    assert arg(0) == 0
+    assert isnan(atan2(3,nan))
+    assert isnan(atan2(nan,3))
+    assert isnan(atan2(0,nan))
+    assert isnan(atan2(nan,0))
+    assert isnan(atan2(nan,nan))
+    assert arg(inf) == 0
+    assert arg(-inf).ae(pi)
+    assert isnan(arg(nan))
+    #assert arg(inf*j).ae(pi/2)
+    assert sign(0) == 0
+    assert sign(3) == 1
+    assert sign(-3) == -1
+    assert sign(inf) == 1
+    assert sign(-inf) == -1
+    assert isnan(sign(nan))
+    assert sign(j) == j
+    assert sign(-3*j) == -j
+    assert sign(1+j).ae((1+j)/sqrt(2))
+
+def test_misc_bugs():
+    # test that this doesn't raise an exception
+    mp.dps = 1000
+    log(1302)
+    mp.dps = 15
+
+def test_arange():
+    assert arange(10) == [mpf('0.0'), mpf('1.0'), mpf('2.0'), mpf('3.0'),
+                          mpf('4.0'), mpf('5.0'), mpf('6.0'), mpf('7.0'),
+                          mpf('8.0'), mpf('9.0')]
+    assert arange(-5, 5) == [mpf('-5.0'), mpf('-4.0'), mpf('-3.0'),
+                             mpf('-2.0'), mpf('-1.0'), mpf('0.0'),
+                             mpf('1.0'), mpf('2.0'), mpf('3.0'), mpf('4.0')]
+    assert arange(0, 1, 0.1) == [mpf('0.0'), mpf('0.10000000000000001'),
+                                 mpf('0.20000000000000001'),
+                                 mpf('0.30000000000000004'),
+                                 mpf('0.40000000000000002'),
+                                 mpf('0.5'), mpf('0.60000000000000009'),
+                                 mpf('0.70000000000000007'),
+                                 mpf('0.80000000000000004'),
+                                 mpf('0.90000000000000002')]
+    assert arange(17, -9, -3) == [mpf('17.0'), mpf('14.0'), mpf('11.0'),
+                                  mpf('8.0'), mpf('5.0'), mpf('2.0'),
+                                  mpf('-1.0'), mpf('-4.0'), mpf('-7.0')]
+    assert arange(0.2, 0.1, -0.1) == [mpf('0.20000000000000001')]
+    assert arange(0) == []
+    assert arange(1000, -1) == []
+    assert arange(-1.23, 3.21, -0.0000001) == []
+
+def test_linspace():
+    assert linspace(2, 9, 7) == [mpf('2.0'), mpf('3.166666666666667'),
+        mpf('4.3333333333333339'), mpf('5.5'), mpf('6.666666666666667'),
+        mpf('7.8333333333333339'), mpf('9.0')]
+    assert linspace(2, 9, 7, endpoint=0) == [mpf('2.0'), mpf('3.0'), mpf('4.0'),
+        mpf('5.0'), mpf('6.0'), mpf('7.0'), mpf('8.0')]
+    assert linspace(2, 7, 1) == [mpf(2)]
+
+def test_float_cbrt():
+    mp.dps = 30
+    for a in arange(0,10,0.1):
+        assert cbrt(a*a*a).ae(a, eps)
+    assert cbrt(-1).ae(0.5 + j*sqrt(3)/2)
+    one_third = mpf(1)/3
+    for a in arange(0,10,2.7) + [0.1 + 10**5]:
+        a = mpc(a + 1.1j)
+        r1 = cbrt(a)
+        mp.dps += 10
+        r2 = pow(a, one_third)
+        mp.dps -= 10
+        assert r1.ae(r2, eps)
+    mp.dps = 100
+    for n in range(100, 301, 100):
+        w = 10**n + j*10**-3
+        z = w*w*w
+        r = cbrt(z)
+        assert mpc_ae(r, w, eps)
+    mp.dps = 15
+
+def test_root():
+    mp.dps = 30
+    random.seed(1)
+    a = random.randint(0, 10000)
+    p = a*a*a
+    r = nthroot(mpf(p), 3)
+    assert r == a
+    for n in range(4, 10):
+        p = p*a
+        assert nthroot(mpf(p), n) == a
+    mp.dps = 40
+    for n in range(10, 5000, 100):
+        for a in [random.random()*10000, random.random()*10**100]:
+            r = nthroot(a, n)
+            r1 = pow(a, mpf(1)/n)
+            assert r.ae(r1)
+            r = nthroot(a, -n)
+            r1 = pow(a, -mpf(1)/n)
+            assert r.ae(r1)
+    # XXX: this is broken right now
+    # tests for nthroot rounding
+    for rnd in ['nearest', 'up', 'down']:
+        mp.rounding = rnd
+        for n in [-5, -3, 3, 5]:
+            prec = 50
+            for i in range(10):
+                mp.prec = prec
+                a = rand()
+                mp.prec = 2*prec
+                b = a**n
+                mp.prec = prec
+                r = nthroot(b, n)
+                assert r == a
+    mp.dps = 30
+    for n in range(3, 21):
+        a = (random.random() + j*random.random())
+        assert nthroot(a, n).ae(pow(a, mpf(1)/n))
+        assert mpc_ae(nthroot(a, n), pow(a, mpf(1)/n))
+        a = (random.random()*10**100 + j*random.random())
+        r = nthroot(a, n)
+        mp.dps += 4
+        r1 = pow(a, mpf(1)/n)
+        mp.dps -= 4
+        assert r.ae(r1)
+        assert mpc_ae(r, r1, eps)
+        r = nthroot(a, -n)
+        mp.dps += 4
+        r1 = pow(a, -mpf(1)/n)
+        mp.dps -= 4
+        assert r.ae(r1)
+        assert mpc_ae(r, r1, eps)
+    mp.dps = 15
+    assert nthroot(4, 1) == 4
+    assert nthroot(4, 0) == 1
+    assert nthroot(4, -1) == 0.25
+    assert nthroot(inf, 1) == inf
+    assert nthroot(inf, 2) == inf
+    assert nthroot(inf, 3) == inf
+    assert nthroot(inf, -1) == 0
+    assert nthroot(inf, -2) == 0
+    assert nthroot(inf, -3) == 0
+    assert nthroot(j, 1) == j
+    assert nthroot(j, 0) == 1
+    assert nthroot(j, -1) == -j
+    assert isnan(nthroot(nan, 1))
+    assert isnan(nthroot(nan, 0))
+    assert isnan(nthroot(nan, -1))
+    assert isnan(nthroot(inf, 0))
+    assert root(2,3) == nthroot(2,3)
+    assert root(16,4,0) == 2
+    assert root(16,4,1) == 2j
+    assert root(16,4,2) == -2
+    assert root(16,4,3) == -2j
+    assert root(16,4,4) == 2
+    assert root(-125,3,1) == -5
+
+def test_issue_136():
+    for dps in [20, 80]:
+        mp.dps = dps
+        r = nthroot(mpf('-1e-20'), 4)
+        assert r.ae(mpf(10)**(-5) * (1 + j) * mpf(2)**(-0.5))
+    mp.dps = 80
+    assert nthroot('-1e-3', 4).ae(mpf(10)**(-3./4) * (1 + j)/sqrt(2))
+    assert nthroot('-1e-6', 4).ae((1 + j)/(10 * sqrt(20)))
+    # Check that this doesn't take eternity to compute
+    mp.dps = 20
+    assert nthroot('-1e100000000', 4).ae((1+j)*mpf('1e25000000')/sqrt(2))
+    mp.dps = 15
+
+def test_mpcfun_real_imag():
+    mp.dps = 15
+    x = mpf(0.3)
+    y = mpf(0.4)
+    assert exp(mpc(x,0)) == exp(x)
+    assert exp(mpc(0,y)) == mpc(cos(y),sin(y))
+    assert cos(mpc(x,0)) == cos(x)
+    assert sin(mpc(x,0)) == sin(x)
+    assert cos(mpc(0,y)) == cosh(y)
+    assert sin(mpc(0,y)) == mpc(0,sinh(y))
+    assert cospi(mpc(x,0)) == cospi(x)
+    assert sinpi(mpc(x,0)) == sinpi(x)
+    assert cospi(mpc(0,y)).ae(cosh(pi*y))
+    assert sinpi(mpc(0,y)).ae(mpc(0,sinh(pi*y)))
+    c, s = cospi_sinpi(mpc(x,0))
+    assert c == cospi(x)
+    assert s == sinpi(x)
+    c, s = cospi_sinpi(mpc(0,y))
+    assert c.ae(cosh(pi*y))
+    assert s.ae(mpc(0,sinh(pi*y)))
+    c, s = cos_sin(mpc(x,0))
+    assert c == cos(x)
+    assert s == sin(x)
+    c, s = cos_sin(mpc(0,y))
+    assert c == cosh(y)
+    assert s == mpc(0,sinh(y))
+
+def test_perturbation_rounding():
+    mp.dps = 100
+    a = pi/10**50
+    b = -pi/10**50
+    c = 1 + a
+    d = 1 + b
+    mp.dps = 15
+    assert exp(a) == 1
+    assert exp(a, rounding='c') > 1
+    assert exp(b, rounding='c') == 1
+    assert exp(a, rounding='f') == 1
+    assert exp(b, rounding='f') < 1
+    assert cos(a) == 1
+    assert cos(a, rounding='c') == 1
+    assert cos(b, rounding='c') == 1
+    assert cos(a, rounding='f') < 1
+    assert cos(b, rounding='f') < 1
+    for f in [sin, atan, asinh, tanh]:
+        assert f(a) == +a
+        assert f(a, rounding='c') > a
+        assert f(a, rounding='f') < a
+        assert f(b) == +b
+        assert f(b, rounding='c') > b
+        assert f(b, rounding='f') < b
+    for f in [asin, tan, sinh, atanh]:
+        assert f(a) == +a
+        assert f(b) == +b
+        assert f(a, rounding='c') > a
+        assert f(b, rounding='c') > b
+        assert f(a, rounding='f') < a
+        assert f(b, rounding='f') < b
+    assert ln(c) == +a
+    assert ln(d) == +b
+    assert ln(c, rounding='c') > a
+    assert ln(c, rounding='f') < a
+    assert ln(d, rounding='c') > b
+    assert ln(d, rounding='f') < b
+    assert cosh(a) == 1
+    assert cosh(b) == 1
+    assert cosh(a, rounding='c') > 1
+    assert cosh(b, rounding='c') > 1
+    assert cosh(a, rounding='f') == 1
+    assert cosh(b, rounding='f') == 1
+
+def test_integer_parts():
+    assert floor(3.2) == 3
+    assert ceil(3.2) == 4
+    assert floor(3.2+5j) == 3+5j
+    assert ceil(3.2+5j) == 4+5j
+
+def test_complex_parts():
+    assert fabs('3') == 3
+    assert fabs(3+4j) == 5
+    assert re(3) == 3
+    assert re(1+4j) == 1
+    assert im(3) == 0
+    assert im(1+4j) == 4
+    assert conj(3) == 3
+    assert conj(3+4j) == 3-4j
+    assert mpf(3).conjugate() == 3
+
+def test_cospi_sinpi():
+    assert sinpi(0) == 0
+    assert sinpi(0.5) == 1
+    assert sinpi(1) == 0
+    assert sinpi(1.5) == -1
+    assert sinpi(2) == 0
+    assert sinpi(2.5) == 1
+    assert sinpi(-0.5) == -1
+    assert cospi(0) == 1
+    assert cospi(0.5) == 0
+    assert cospi(1) == -1
+    assert cospi(1.5) == 0
+    assert cospi(2) == 1
+    assert cospi(2.5) == 0
+    assert cospi(-0.5) == 0
+    assert cospi(100000000000.25).ae(sqrt(2)/2)
+    a = cospi(2+3j)
+    assert a.real.ae(cos((2+3j)*pi).real)
+    assert a.imag == 0
+    b = sinpi(2+3j)
+    assert b.imag.ae(sin((2+3j)*pi).imag)
+    assert b.real == 0
+    mp.dps = 35
+    x1 = mpf(10000) - mpf('1e-15')
+    x2 = mpf(10000) + mpf('1e-15')
+    x3 = mpf(10000.5) - mpf('1e-15')
+    x4 = mpf(10000.5) + mpf('1e-15')
+    x5 = mpf(10001) - mpf('1e-15')
+    x6 = mpf(10001) + mpf('1e-15')
+    x7 = mpf(10001.5) - mpf('1e-15')
+    x8 = mpf(10001.5) + mpf('1e-15')
+    mp.dps = 15
+    M = 10**15
+    assert (sinpi(x1)*M).ae(-pi)
+    assert (sinpi(x2)*M).ae(pi)
+    assert (cospi(x3)*M).ae(pi)
+    assert (cospi(x4)*M).ae(-pi)
+    assert (sinpi(x5)*M).ae(pi)
+    assert (sinpi(x6)*M).ae(-pi)
+    assert (cospi(x7)*M).ae(-pi)
+    assert (cospi(x8)*M).ae(pi)
+    assert 0.999 < cospi(x1, rounding='d') < 1
+    assert 0.999 < cospi(x2, rounding='d') < 1
+    assert 0.999 < sinpi(x3, rounding='d') < 1
+    assert 0.999 < sinpi(x4, rounding='d') < 1
+    assert -1 < cospi(x5, rounding='d') < -0.999
+    assert -1 < cospi(x6, rounding='d') < -0.999
+    assert -1 < sinpi(x7, rounding='d') < -0.999
+    assert -1 < sinpi(x8, rounding='d') < -0.999
+    assert (sinpi(1e-15)*M).ae(pi)
+    assert (sinpi(-1e-15)*M).ae(-pi)
+    assert cospi(1e-15) == 1
+    assert cospi(1e-15, rounding='d') < 1
+
+def test_expj():
+    assert expj(0) == 1
+    assert expj(1).ae(exp(j))
+    assert expj(j).ae(exp(-1))
+    assert expj(1+j).ae(exp(j*(1+j)))
+    assert expjpi(0) == 1
+    assert expjpi(1).ae(exp(j*pi))
+    assert expjpi(j).ae(exp(-pi))
+    assert expjpi(1+j).ae(exp(j*pi*(1+j)))
+    assert expjpi(-10**15 * j).ae('2.22579818340535731e+1364376353841841')
+
+def test_sinc():
+    assert sinc(0) == sincpi(0) == 1
+    assert sinc(inf) == sincpi(inf) == 0
+    assert sinc(-inf) == sincpi(-inf) == 0
+    assert sinc(2).ae(0.45464871341284084770)
+    assert sinc(2+3j).ae(0.4463290318402435457-2.7539470277436474940j)
+    assert sincpi(2) == 0
+    assert sincpi(1.5).ae(-0.212206590789193781)
+
+def test_fibonacci():
+    mp.dps = 15
+    assert [fibonacci(n) for n in range(-5, 10)] == \
+        [5, -3, 2, -1, 1, 0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
+    assert fib(2.5).ae(1.4893065462657091)
+    assert fib(3+4j).ae(-5248.51130728372 - 14195.962288353j)
+    assert fib(1000).ae(4.3466557686937455e+208)
+    assert str(fib(10**100)) == '6.24499112864607e+2089876402499787337692720892375554168224592399182109535392875613974104853496745963277658556235103534'
+    mp.dps = 2100
+    a = fib(10000)
+    assert a % 10**10 == 9947366875
+    mp.dps = 15
+    assert fibonacci(inf) == inf
+    assert fib(3+0j) == 2
+
+def test_call_with_dps():
+    mp.dps = 15
+    assert abs(exp(1, dps=30)-e(dps=35)) < 1e-29
+
+def test_tanh():
+    mp.dps = 15
+    assert tanh(0) == 0
+    assert tanh(inf) == 1
+    assert tanh(-inf) == -1
+    assert isnan(tanh(nan))
+    assert tanh(mpc('inf', '0')) == 1
+
+def test_atanh():
+    mp.dps = 15
+    assert atanh(0) == 0
+    assert atanh(0.5).ae(0.54930614433405484570)
+    assert atanh(-0.5).ae(-0.54930614433405484570)
+    assert atanh(1) == inf
+    assert atanh(-1) == -inf
+    assert isnan(atanh(nan))
+    assert isinstance(atanh(1), mpf)
+    assert isinstance(atanh(-1), mpf)
+    # Limits at infinity
+    jpi2 = j*pi/2
+    assert atanh(inf).ae(-jpi2)
+    assert atanh(-inf).ae(jpi2)
+    assert atanh(mpc(inf,-1)).ae(-jpi2)
+    assert atanh(mpc(inf,0)).ae(-jpi2)
+    assert atanh(mpc(inf,1)).ae(jpi2)
+    assert atanh(mpc(1,inf)).ae(jpi2)
+    assert atanh(mpc(0,inf)).ae(jpi2)
+    assert atanh(mpc(-1,inf)).ae(jpi2)
+    assert atanh(mpc(-inf,1)).ae(jpi2)
+    assert atanh(mpc(-inf,0)).ae(jpi2)
+    assert atanh(mpc(-inf,-1)).ae(-jpi2)
+    assert atanh(mpc(-1,-inf)).ae(-jpi2)
+    assert atanh(mpc(0,-inf)).ae(-jpi2)
+    assert atanh(mpc(1,-inf)).ae(-jpi2)
+
+def test_expm1():
+    mp.dps = 15
+    assert expm1(0) == 0
+    assert expm1(3).ae(exp(3)-1)
+    assert expm1(inf) == inf
+    assert expm1(1e-50).ae(1e-50)
+    assert (expm1(1e-10)*1e10).ae(1.00000000005)
+
+def test_log1p():
+    mp.dps = 15
+    assert log1p(0) == 0
+    assert log1p(3).ae(log(1+3))
+    assert log1p(inf) == inf
+    assert log1p(1e-50).ae(1e-50)
+    assert (log1p(1e-10)*1e10).ae(0.99999999995)
+
+def test_powm1():
+    mp.dps = 15
+    assert powm1(2,3) == 7
+    assert powm1(-1,2) == 0
+    assert powm1(-1,0) == 0
+    assert powm1(-2,0) == 0
+    assert powm1(3+4j,0) == 0
+    assert powm1(0,1) == -1
+    assert powm1(0,0) == 0
+    assert powm1(1,0) == 0
+    assert powm1(1,2) == 0
+    assert powm1(1,3+4j) == 0
+    assert powm1(1,5) == 0
+    assert powm1(j,4) == 0
+    assert powm1(-j,4) == 0
+    assert (powm1(2,1e-100)*1e100).ae(ln2)
+    assert powm1(2,'1e-100000000000') != 0
+    assert (powm1(fadd(1,1e-100,exact=True), 5)*1e100).ae(5)
+
+def test_unitroots():
+    assert unitroots(1) == [1]
+    assert unitroots(2) == [1, -1]
+    a, b, c = unitroots(3)
+    assert a == 1
+    assert b.ae(-0.5 + 0.86602540378443864676j)
+    assert c.ae(-0.5 - 0.86602540378443864676j)
+    assert unitroots(1, primitive=True) == [1]
+    assert unitroots(2, primitive=True) == [-1]
+    assert unitroots(3, primitive=True) == unitroots(3)[1:]
+    assert unitroots(4, primitive=True) == [j, -j]
+    assert len(unitroots(17, primitive=True)) == 16
+    assert len(unitroots(16, primitive=True)) == 8
+
+def test_cyclotomic():
+    mp.dps = 15
+    assert [cyclotomic(n,1) for n in range(31)] == [1,0,2,3,2,5,1,7,2,3,1,11,1,13,1,1,2,17,1,19,1,1,1,23,1,5,1,3,1,29,1]
+    assert [cyclotomic(n,-1) for n in range(31)] == [1,-2,0,1,2,1,3,1,2,1,5,1,1,1,7,1,2,1,3,1,1,1,11,1,1,1,13,1,1,1,1]
+    assert [cyclotomic(n,j) for n in range(21)] == [1,-1+j,1+j,j,0,1,-j,j,2,-j,1,j,3,1,-j,1,2,1,j,j,5]
+    assert [cyclotomic(n,-j) for n in range(21)] == [1,-1-j,1-j,-j,0,1,j,-j,2,j,1,-j,3,1,j,1,2,1,-j,-j,5]
+    assert cyclotomic(1624,j) == 1
+    assert cyclotomic(33600,j) == 1
+    u = sqrt(j, prec=500)
+    assert cyclotomic(8, u).ae(0)
+    assert cyclotomic(30, u).ae(5.8284271247461900976)
+    assert cyclotomic(2040, u).ae(1)
+    assert cyclotomic(0,2.5) == 1
+    assert cyclotomic(1,2.5) == 2.5-1
+    assert cyclotomic(2,2.5) == 2.5+1
+    assert cyclotomic(3,2.5) == 2.5**2 + 2.5 + 1
+    assert cyclotomic(7,2.5) == 406.234375
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_functions2.py b/lib/python3.10/site-packages/mpmath/tests/test_functions2.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b2d57fcec9be0db4d921b013f24fd6a5e0e9930
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_functions2.py
@@ -0,0 +1,2384 @@
+import math
+import pytest
+from mpmath import *
+
+def test_bessel():
+    mp.dps = 15
+    assert j0(1).ae(0.765197686557966551)
+    assert j0(pi).ae(-0.304242177644093864)
+    assert j0(1000).ae(0.0247866861524201746)
+    assert j0(-25).ae(0.0962667832759581162)
+    assert j1(1).ae(0.440050585744933516)
+    assert j1(pi).ae(0.284615343179752757)
+    assert j1(1000).ae(0.00472831190708952392)
+    assert j1(-25).ae(0.125350249580289905)
+    assert besselj(5,1).ae(0.000249757730211234431)
+    assert besselj(5+0j,1).ae(0.000249757730211234431)
+    assert besselj(5,pi).ae(0.0521411843671184747)
+    assert besselj(5,1000).ae(0.00502540694523318607)
+    assert besselj(5,-25).ae(0.0660079953984229934)
+    assert besselj(-3,2).ae(-0.128943249474402051)
+    assert besselj(-4,2).ae(0.0339957198075684341)
+    assert besselj(3,3+2j).ae(0.424718794929639595942 + 0.625665327745785804812j)
+    assert besselj(0.25,4).ae(-0.374760630804249715)
+    assert besselj(1+2j,3+4j).ae(0.319247428741872131 - 0.669557748880365678j)
+    assert (besselj(3, 10**10) * 10**5).ae(0.76765081748139204023)
+    assert bessely(-0.5, 0) == 0
+    assert bessely(0.5, 0) == -inf
+    assert bessely(1.5, 0) == -inf
+    assert bessely(0,0) == -inf
+    assert bessely(-0.4, 0) == -inf
+    assert bessely(-0.6, 0) == inf
+    assert bessely(-1, 0) == inf
+    assert bessely(-1.4, 0) == inf
+    assert bessely(-1.6, 0) == -inf
+    assert bessely(-1, 0) == inf
+    assert bessely(-2, 0) == -inf
+    assert bessely(-3, 0) == inf
+    assert bessely(0.5, 0) == -inf
+    assert bessely(1, 0) == -inf
+    assert bessely(1.5, 0) == -inf
+    assert bessely(2, 0) == -inf
+    assert bessely(2.5, 0) == -inf
+    assert bessely(3, 0) == -inf
+    assert bessely(0,0.5).ae(-0.44451873350670655715)
+    assert bessely(1,0.5).ae(-1.4714723926702430692)
+    assert bessely(-1,0.5).ae(1.4714723926702430692)
+    assert bessely(3.5,0.5).ae(-138.86400867242488443)
+    assert bessely(0,3+4j).ae(4.6047596915010138655-8.8110771408232264208j)
+    assert bessely(0,j).ae(-0.26803248203398854876+1.26606587775200833560j)
+    assert (bessely(3, 10**10) * 10**5).ae(0.21755917537013204058)
+    assert besseli(0,0) == 1
+    assert besseli(1,0) == 0
+    assert besseli(2,0) == 0
+    assert besseli(-1,0) == 0
+    assert besseli(-2,0) == 0
+    assert besseli(0,0.5).ae(1.0634833707413235193)
+    assert besseli(1,0.5).ae(0.25789430539089631636)
+    assert besseli(-1,0.5).ae(0.25789430539089631636)
+    assert besseli(3.5,0.5).ae(0.00068103597085793815863)
+    assert besseli(0,3+4j).ae(-3.3924877882755196097-1.3239458916287264815j)
+    assert besseli(0,j).ae(besselj(0,1))
+    assert (besseli(3, 10**10) * mpf(10)**(-4342944813)).ae(4.2996028505491271875)
+    assert besselk(0,0) == inf
+    assert besselk(1,0) == inf
+    assert besselk(2,0) == inf
+    assert besselk(-1,0) == inf
+    assert besselk(-2,0) == inf
+    assert besselk(0,0.5).ae(0.92441907122766586178)
+    assert besselk(1,0.5).ae(1.6564411200033008937)
+    assert besselk(-1,0.5).ae(1.6564411200033008937)
+    assert besselk(3.5,0.5).ae(207.48418747548460607)
+    assert besselk(0,3+4j).ae(-0.007239051213570155013+0.026510418350267677215j)
+    assert besselk(0,j).ae(-0.13863371520405399968-1.20196971531720649914j)
+    assert (besselk(3, 10**10) * mpf(10)**4342944824).ae(1.1628981033356187851)
+    # test for issue 331, bug reported by Michael Hartmann
+    for n in range(10,100,10):
+        mp.dps = n
+        assert besseli(91.5,24.7708).ae("4.00830632138673963619656140653537080438462342928377020695738635559218797348548092636896796324190271316137982810144874264e-41")
+
+def test_bessel_zeros():
+    mp.dps = 15
+    assert besseljzero(0,1).ae(2.40482555769577276869)
+    assert besseljzero(2,1).ae(5.1356223018406825563)
+    assert besseljzero(1,50).ae(157.86265540193029781)
+    assert besseljzero(10,1).ae(14.475500686554541220)
+    assert besseljzero(0.5,3).ae(9.4247779607693797153)
+    assert besseljzero(2,1,1).ae(3.0542369282271403228)
+    assert besselyzero(0,1).ae(0.89357696627916752158)
+    assert besselyzero(2,1).ae(3.3842417671495934727)
+    assert besselyzero(1,50).ae(156.29183520147840108)
+    assert besselyzero(10,1).ae(12.128927704415439387)
+    assert besselyzero(0.5,3).ae(7.8539816339744830962)
+    assert besselyzero(2,1,1).ae(5.0025829314460639452)
+
+def test_hankel():
+    mp.dps = 15
+    assert hankel1(0,0.5).ae(0.93846980724081290423-0.44451873350670655715j)
+    assert hankel1(1,0.5).ae(0.2422684576748738864-1.4714723926702430692j)
+    assert hankel1(-1,0.5).ae(-0.2422684576748738864+1.4714723926702430692j)
+    assert hankel1(1.5,0.5).ae(0.0917016996256513026-2.5214655504213378514j)
+    assert hankel1(1.5,3+4j).ae(0.0066806866476728165382-0.0036684231610839127106j)
+    assert hankel2(0,0.5).ae(0.93846980724081290423+0.44451873350670655715j)
+    assert hankel2(1,0.5).ae(0.2422684576748738864+1.4714723926702430692j)
+    assert hankel2(-1,0.5).ae(-0.2422684576748738864-1.4714723926702430692j)
+    assert hankel2(1.5,0.5).ae(0.0917016996256513026+2.5214655504213378514j)
+    assert hankel2(1.5,3+4j).ae(14.783528526098567526-7.397390270853446512j)
+
+def test_struve():
+    mp.dps = 15
+    assert struveh(2,3).ae(0.74238666967748318564)
+    assert struveh(-2.5,3).ae(0.41271003220971599344)
+    assert struvel(2,3).ae(1.7476573277362782744)
+    assert struvel(-2.5,3).ae(1.5153394466819651377)
+
+def test_whittaker():
+    mp.dps = 15
+    assert whitm(2,3,4).ae(49.753745589025246591)
+    assert whitw(2,3,4).ae(14.111656223052932215)
+
+def test_kelvin():
+    mp.dps = 15
+    assert ber(2,3).ae(0.80836846563726819091)
+    assert ber(3,4).ae(-0.28262680167242600233)
+    assert ber(-3,2).ae(-0.085611448496796363669)
+    assert bei(2,3).ae(-0.89102236377977331571)
+    assert bei(-3,2).ae(-0.14420994155731828415)
+    assert ker(2,3).ae(0.12839126695733458928)
+    assert ker(-3,2).ae(-0.29802153400559142783)
+    assert ker(0.5,3).ae(-0.085662378535217097524)
+    assert kei(2,3).ae(0.036804426134164634000)
+    assert kei(-3,2).ae(0.88682069845786731114)
+    assert kei(0.5,3).ae(0.013633041571314302948)
+
+def test_hyper_misc():
+    mp.dps = 15
+    assert hyp0f1(1,0) == 1
+    assert hyp1f1(1,2,0) == 1
+    assert hyp1f2(1,2,3,0) == 1
+    assert hyp2f1(1,2,3,0) == 1
+    assert hyp2f2(1,2,3,4,0) == 1
+    assert hyp2f3(1,2,3,4,5,0) == 1
+    # Degenerate case: 0F0
+    assert hyper([],[],0) == 1
+    assert hyper([],[],-2).ae(exp(-2))
+    # Degenerate case: 1F0
+    assert hyper([2],[],1.5) == 4
+    #
+    assert hyp2f1((1,3),(2,3),(5,6),mpf(27)/32).ae(1.6)
+    assert hyp2f1((1,4),(1,2),(3,4),mpf(80)/81).ae(1.8)
+    assert hyp2f1((2,3),(1,1),(3,2),(2+j)/3).ae(1.327531603558679093+0.439585080092769253j)
+    mp.dps = 25
+    v = mpc('1.2282306665029814734863026', '-0.1225033830118305184672133')
+    assert hyper([(3,4),2+j,1],[1,5,j/3],mpf(1)/5+j/8).ae(v)
+    mp.dps = 15
+
+def test_elliptic_integrals():
+    mp.dps = 15
+    assert ellipk(0).ae(pi/2)
+    assert ellipk(0.5).ae(gamma(0.25)**2/(4*sqrt(pi)))
+    assert ellipk(1) == inf
+    assert ellipk(1+0j) == inf
+    assert ellipk(-1).ae('1.3110287771460599052')
+    assert ellipk(-2).ae('1.1714200841467698589')
+    assert isinstance(ellipk(-2), mpf)
+    assert isinstance(ellipe(-2), mpf)
+    assert ellipk(-50).ae('0.47103424540873331679')
+    mp.dps = 30
+    n1 = +fraction(99999,100000)
+    n2 = +fraction(100001,100000)
+    mp.dps = 15
+    assert ellipk(n1).ae('7.1427724505817781901')
+    assert ellipk(n2).ae(mpc('7.1427417367963090109', '-1.5707923998261688019'))
+    assert ellipe(n1).ae('1.0000332138990829170')
+    v = ellipe(n2)
+    assert v.real.ae('0.999966786328145474069137')
+    assert (v.imag*10**6).ae('7.853952181727432')
+    assert ellipk(2).ae(mpc('1.3110287771460599052', '-1.3110287771460599052'))
+    assert ellipk(50).ae(mpc('0.22326753950210985451', '-0.47434723226254522087'))
+    assert ellipk(3+4j).ae(mpc('0.91119556380496500866', '0.63133428324134524388'))
+    assert ellipk(3-4j).ae(mpc('0.91119556380496500866', '-0.63133428324134524388'))
+    assert ellipk(-3+4j).ae(mpc('0.95357894880405122483', '0.23093044503746114444'))
+    assert ellipk(-3-4j).ae(mpc('0.95357894880405122483', '-0.23093044503746114444'))
+    assert isnan(ellipk(nan))
+    assert isnan(ellipe(nan))
+    assert ellipk(inf) == 0
+    assert isinstance(ellipk(inf), mpc)
+    assert ellipk(-inf) == 0
+    assert ellipk(1+0j) == inf
+    assert ellipe(0).ae(pi/2)
+    assert ellipe(0.5).ae(pi**(mpf(3)/2)/gamma(0.25)**2 +gamma(0.25)**2/(8*sqrt(pi)))
+    assert ellipe(1) == 1
+    assert ellipe(1+0j) == 1
+    assert ellipe(inf) == mpc(0,inf)
+    assert ellipe(-inf) == inf
+    assert ellipe(3+4j).ae(1.4995535209333469543-1.5778790079127582745j)
+    assert ellipe(3-4j).ae(1.4995535209333469543+1.5778790079127582745j)
+    assert ellipe(-3+4j).ae(2.5804237855343377803-0.8306096791000413778j)
+    assert ellipe(-3-4j).ae(2.5804237855343377803+0.8306096791000413778j)
+    assert ellipe(2).ae(0.59907011736779610372+0.59907011736779610372j)
+    assert ellipe('1e-1000000000').ae(pi/2)
+    assert ellipk('1e-1000000000').ae(pi/2)
+    assert ellipe(-pi).ae(2.4535865983838923)
+    mp.dps = 50
+    assert ellipk(1/pi).ae('1.724756270009501831744438120951614673874904182624739673')
+    assert ellipe(1/pi).ae('1.437129808135123030101542922290970050337425479058225712')
+    assert ellipk(-10*pi).ae('0.5519067523886233967683646782286965823151896970015484512')
+    assert ellipe(-10*pi).ae('5.926192483740483797854383268707108012328213431657645509')
+    v = ellipk(pi)
+    assert v.real.ae('0.973089521698042334840454592642137667227167622330325225')
+    assert v.imag.ae('-1.156151296372835303836814390793087600271609993858798016')
+    v = ellipe(pi)
+    assert v.real.ae('0.4632848917264710404078033487934663562998345622611263332')
+    assert v.imag.ae('1.0637961621753130852473300451583414489944099504180510966')
+    mp.dps = 15
+
+def test_exp_integrals():
+    mp.dps = 15
+    x = +e
+    z = e + sqrt(3)*j
+    assert ei(x).ae(8.21168165538361560)
+    assert li(x).ae(1.89511781635593676)
+    assert si(x).ae(1.82104026914756705)
+    assert ci(x).ae(0.213958001340379779)
+    assert shi(x).ae(4.11520706247846193)
+    assert chi(x).ae(4.09647459290515367)
+    assert fresnels(x).ae(0.437189718149787643)
+    assert fresnelc(x).ae(0.401777759590243012)
+    assert airyai(x).ae(0.0108502401568586681)
+    assert airybi(x).ae(8.98245748585468627)
+    assert ei(z).ae(3.72597969491314951 + 7.34213212314224421j)
+    assert li(z).ae(2.28662658112562502 + 1.50427225297269364j)
+    assert si(z).ae(2.48122029237669054 + 0.12684703275254834j)
+    assert ci(z).ae(0.169255590269456633 - 0.892020751420780353j)
+    assert shi(z).ae(1.85810366559344468 + 3.66435842914920263j)
+    assert chi(z).ae(1.86787602931970484 + 3.67777369399304159j)
+    assert fresnels(z/3).ae(0.034534397197008182 + 0.754859844188218737j)
+    assert fresnelc(z/3).ae(1.261581645990027372 + 0.417949198775061893j)
+    assert airyai(z).ae(-0.0162552579839056062 - 0.0018045715700210556j)
+    assert airybi(z).ae(-4.98856113282883371 + 2.08558537872180623j)
+    assert li(0) == 0.0
+    assert li(1) == -inf
+    assert li(inf) == inf
+    assert isinstance(li(0.7), mpf)
+    assert si(inf).ae(pi/2)
+    assert si(-inf).ae(-pi/2)
+    assert ci(inf) == 0
+    assert ci(0) == -inf
+    assert isinstance(ei(-0.7), mpf)
+    assert airyai(inf) == 0
+    assert airybi(inf) == inf
+    assert airyai(-inf) == 0
+    assert airybi(-inf) == 0
+    assert fresnels(inf) == 0.5
+    assert fresnelc(inf) == 0.5
+    assert fresnels(-inf) == -0.5
+    assert fresnelc(-inf) == -0.5
+    assert shi(0) == 0
+    assert shi(inf) == inf
+    assert shi(-inf) == -inf
+    assert chi(0) == -inf
+    assert chi(inf) == inf
+
+def test_ei():
+    mp.dps = 15
+    assert ei(0) == -inf
+    assert ei(inf) == inf
+    assert ei(-inf) == -0.0
+    assert ei(20+70j).ae(6.1041351911152984397e6 - 2.7324109310519928872e6j)
+    # tests for the asymptotic expansion
+    # values checked with Mathematica ExpIntegralEi
+    mp.dps = 50
+    r = ei(20000)
+    s = '3.8781962825045010930273870085501819470698476975019e+8681'
+    assert str(r) == s
+    r = ei(-200)
+    s = '-6.8852261063076355977108174824557929738368086933303e-90'
+    assert str(r) == s
+    r =ei(20000 + 10*j)
+    sre = '-3.255138234032069402493850638874410725961401274106e+8681'
+    sim = '-2.1081929993474403520785942429469187647767369645423e+8681'
+    assert str(r.real) == sre and str(r.imag) == sim
+    mp.dps = 15
+    # More asymptotic expansions
+    assert chi(-10**6+100j).ae('1.3077239389562548386e+434288 + 7.6808956999707408158e+434287j')
+    assert shi(-10**6+100j).ae('-1.3077239389562548386e+434288 - 7.6808956999707408158e+434287j')
+    mp.dps = 15
+    assert ei(10j).ae(-0.0454564330044553726+3.2291439210137706686j)
+    assert ei(100j).ae(-0.0051488251426104921+3.1330217936839529126j)
+    u = ei(fmul(10**20, j, exact=True))
+    assert u.real.ae(-6.4525128526578084421345e-21, abs_eps=0, rel_eps=8*eps)
+    assert u.imag.ae(pi)
+    assert ei(-10j).ae(-0.0454564330044553726-3.2291439210137706686j)
+    assert ei(-100j).ae(-0.0051488251426104921-3.1330217936839529126j)
+    u = ei(fmul(-10**20, j, exact=True))
+    assert u.real.ae(-6.4525128526578084421345e-21, abs_eps=0, rel_eps=8*eps)
+    assert u.imag.ae(-pi)
+    assert ei(10+10j).ae(-1576.1504265768517448+436.9192317011328140j)
+    u = ei(-10+10j)
+    assert u.real.ae(7.6698978415553488362543e-7, abs_eps=0, rel_eps=8*eps)
+    assert u.imag.ae(3.141595611735621062025)
+
+def test_e1():
+    mp.dps = 15
+    assert e1(0) == inf
+    assert e1(inf) == 0
+    assert e1(-inf) == mpc(-inf, -pi)
+    assert e1(10j).ae(0.045456433004455372635 + 0.087551267423977430100j)
+    assert e1(100j).ae(0.0051488251426104921444 - 0.0085708599058403258790j)
+    assert e1(fmul(10**20, j, exact=True)).ae(6.4525128526578084421e-21 - 7.6397040444172830039e-21j, abs_eps=0, rel_eps=8*eps)
+    assert e1(-10j).ae(0.045456433004455372635 - 0.087551267423977430100j)
+    assert e1(-100j).ae(0.0051488251426104921444 + 0.0085708599058403258790j)
+    assert e1(fmul(-10**20, j, exact=True)).ae(6.4525128526578084421e-21 + 7.6397040444172830039e-21j, abs_eps=0, rel_eps=8*eps)
+
+def test_expint():
+    mp.dps = 15
+    assert expint(0,0) == inf
+    assert expint(0,1).ae(1/e)
+    assert expint(0,1.5).ae(2/exp(1.5)/3)
+    assert expint(1,1).ae(-ei(-1))
+    assert expint(2,0).ae(1)
+    assert expint(3,0).ae(1/2.)
+    assert expint(4,0).ae(1/3.)
+    assert expint(-2, 0.5).ae(26/sqrt(e))
+    assert expint(-1,-1) == 0
+    assert expint(-2,-1).ae(-e)
+    assert expint(5.5, 0).ae(2/9.)
+    assert expint(2.00000001,0).ae(100000000./100000001)
+    assert expint(2+3j,4-j).ae(0.0023461179581675065414+0.0020395540604713669262j)
+    assert expint('1.01', '1e-1000').ae(99.9999999899412802)
+    assert expint('1.000000000001', 3.5).ae(0.00697013985754701819446)
+    assert expint(2,3).ae(3*ei(-3)+exp(-3))
+    assert (expint(10,20)*10**10).ae(0.694439055541231353)
+    assert expint(3,inf) == 0
+    assert expint(3.2,inf) == 0
+    assert expint(3.2+2j,inf) == 0
+    assert expint(1,3j).ae(-0.11962978600800032763 + 0.27785620120457163717j)
+    assert expint(1,3).ae(0.013048381094197037413)
+    assert expint(1,-3).ae(-ei(3)-pi*j)
+    #assert expint(3) == expint(1,3)
+    assert expint(1,-20).ae(-25615652.66405658882 - 3.1415926535897932385j)
+    assert expint(1000000,0).ae(1./999999)
+    assert expint(0,2+3j).ae(-0.025019798357114678171 + 0.027980439405104419040j)
+    assert expint(-1,2+3j).ae(-0.022411973626262070419 + 0.038058922011377716932j)
+    assert expint(-1.5,0) == inf
+
+def test_trig_integrals():
+    mp.dps = 30
+    assert si(mpf(1)/1000000).ae('0.000000999999999999944444444444446111')
+    assert ci(mpf(1)/1000000).ae('-13.2382948930629912435014366276')
+    assert si(10**10).ae('1.5707963267075846569685111517747537')
+    assert ci(10**10).ae('-4.87506025174822653785729773959e-11')
+    assert si(10**100).ae(pi/2)
+    assert (ci(10**100)*10**100).ae('-0.372376123661276688262086695553')
+    assert si(-3) == -si(3)
+    assert ci(-3).ae(ci(3) + pi*j)
+    # Test complex structure
+    mp.dps = 15
+    assert mp.ci(50).ae(-0.0056283863241163054402)
+    assert mp.ci(50+2j).ae(-0.018378282946133067149+0.070352808023688336193j)
+    assert mp.ci(20j).ae(1.28078263320282943611e7+1.5707963267949j)
+    assert mp.ci(-2+20j).ae(-4.050116856873293505e6+1.207476188206989909e7j)
+    assert mp.ci(-50+2j).ae(-0.0183782829461330671+3.0712398455661049023j)
+    assert mp.ci(-50).ae(-0.0056283863241163054+3.1415926535897932385j)
+    assert mp.ci(-50-2j).ae(-0.0183782829461330671-3.0712398455661049023j)
+    assert mp.ci(-2-20j).ae(-4.050116856873293505e6-1.207476188206989909e7j)
+    assert mp.ci(-20j).ae(1.28078263320282943611e7-1.5707963267949j)
+    assert mp.ci(50-2j).ae(-0.018378282946133067149-0.070352808023688336193j)
+    assert mp.si(50).ae(1.5516170724859358947)
+    assert mp.si(50+2j).ae(1.497884414277228461-0.017515007378437448j)
+    assert mp.si(20j).ae(1.2807826332028294459e7j)
+    assert mp.si(-2+20j).ae(-1.20747603112735722103e7-4.050116856873293554e6j)
+    assert mp.si(-50+2j).ae(-1.497884414277228461-0.017515007378437448j)
+    assert mp.si(-50).ae(-1.5516170724859358947)
+    assert mp.si(-50-2j).ae(-1.497884414277228461+0.017515007378437448j)
+    assert mp.si(-2-20j).ae(-1.20747603112735722103e7+4.050116856873293554e6j)
+    assert mp.si(-20j).ae(-1.2807826332028294459e7j)
+    assert mp.si(50-2j).ae(1.497884414277228461+0.017515007378437448j)
+    assert mp.chi(50j).ae(-0.0056283863241163054+1.5707963267948966192j)
+    assert mp.chi(-2+50j).ae(-0.0183782829461330671+1.6411491348185849554j)
+    assert mp.chi(-20).ae(1.28078263320282943611e7+3.1415926535898j)
+    assert mp.chi(-20-2j).ae(-4.050116856873293505e6+1.20747571696809187053e7j)
+    assert mp.chi(-2-50j).ae(-0.0183782829461330671-1.6411491348185849554j)
+    assert mp.chi(-50j).ae(-0.0056283863241163054-1.5707963267948966192j)
+    assert mp.chi(2-50j).ae(-0.0183782829461330671-1.500443518771208283j)
+    assert mp.chi(20-2j).ae(-4.050116856873293505e6-1.20747603112735722951e7j)
+    assert mp.chi(20).ae(1.2807826332028294361e7)
+    assert mp.chi(2+50j).ae(-0.0183782829461330671+1.500443518771208283j)
+    assert mp.shi(50j).ae(1.5516170724859358947j)
+    assert mp.shi(-2+50j).ae(0.017515007378437448+1.497884414277228461j)
+    assert mp.shi(-20).ae(-1.2807826332028294459e7)
+    assert mp.shi(-20-2j).ae(4.050116856873293554e6-1.20747603112735722103e7j)
+    assert mp.shi(-2-50j).ae(0.017515007378437448-1.497884414277228461j)
+    assert mp.shi(-50j).ae(-1.5516170724859358947j)
+    assert mp.shi(2-50j).ae(-0.017515007378437448-1.497884414277228461j)
+    assert mp.shi(20-2j).ae(-4.050116856873293554e6-1.20747603112735722103e7j)
+    assert mp.shi(20).ae(1.2807826332028294459e7)
+    assert mp.shi(2+50j).ae(-0.017515007378437448+1.497884414277228461j)
+    def ae(x,y,tol=1e-12):
+        return abs(x-y) <= abs(y)*tol
+    assert fp.ci(fp.inf) == 0
+    assert ae(fp.ci(fp.ninf), fp.pi*1j)
+    assert ae(fp.si(fp.inf), fp.pi/2)
+    assert ae(fp.si(fp.ninf), -fp.pi/2)
+    assert fp.si(0) == 0
+    assert ae(fp.ci(50), -0.0056283863241163054402)
+    assert ae(fp.ci(50+2j), -0.018378282946133067149+0.070352808023688336193j)
+    assert ae(fp.ci(20j), 1.28078263320282943611e7+1.5707963267949j)
+    assert ae(fp.ci(-2+20j), -4.050116856873293505e6+1.207476188206989909e7j)
+    assert ae(fp.ci(-50+2j), -0.0183782829461330671+3.0712398455661049023j)
+    assert ae(fp.ci(-50), -0.0056283863241163054+3.1415926535897932385j)
+    assert ae(fp.ci(-50-2j), -0.0183782829461330671-3.0712398455661049023j)
+    assert ae(fp.ci(-2-20j), -4.050116856873293505e6-1.207476188206989909e7j)
+    assert ae(fp.ci(-20j), 1.28078263320282943611e7-1.5707963267949j)
+    assert ae(fp.ci(50-2j), -0.018378282946133067149-0.070352808023688336193j)
+    assert ae(fp.si(50), 1.5516170724859358947)
+    assert ae(fp.si(50+2j), 1.497884414277228461-0.017515007378437448j)
+    assert ae(fp.si(20j), 1.2807826332028294459e7j)
+    assert ae(fp.si(-2+20j), -1.20747603112735722103e7-4.050116856873293554e6j)
+    assert ae(fp.si(-50+2j), -1.497884414277228461-0.017515007378437448j)
+    assert ae(fp.si(-50), -1.5516170724859358947)
+    assert ae(fp.si(-50-2j), -1.497884414277228461+0.017515007378437448j)
+    assert ae(fp.si(-2-20j), -1.20747603112735722103e7+4.050116856873293554e6j)
+    assert ae(fp.si(-20j), -1.2807826332028294459e7j)
+    assert ae(fp.si(50-2j), 1.497884414277228461+0.017515007378437448j)
+    assert ae(fp.chi(50j), -0.0056283863241163054+1.5707963267948966192j)
+    assert ae(fp.chi(-2+50j), -0.0183782829461330671+1.6411491348185849554j)
+    assert ae(fp.chi(-20), 1.28078263320282943611e7+3.1415926535898j)
+    assert ae(fp.chi(-20-2j), -4.050116856873293505e6+1.20747571696809187053e7j)
+    assert ae(fp.chi(-2-50j), -0.0183782829461330671-1.6411491348185849554j)
+    assert ae(fp.chi(-50j), -0.0056283863241163054-1.5707963267948966192j)
+    assert ae(fp.chi(2-50j), -0.0183782829461330671-1.500443518771208283j)
+    assert ae(fp.chi(20-2j), -4.050116856873293505e6-1.20747603112735722951e7j)
+    assert ae(fp.chi(20), 1.2807826332028294361e7)
+    assert ae(fp.chi(2+50j), -0.0183782829461330671+1.500443518771208283j)
+    assert ae(fp.shi(50j), 1.5516170724859358947j)
+    assert ae(fp.shi(-2+50j), 0.017515007378437448+1.497884414277228461j)
+    assert ae(fp.shi(-20), -1.2807826332028294459e7)
+    assert ae(fp.shi(-20-2j), 4.050116856873293554e6-1.20747603112735722103e7j)
+    assert ae(fp.shi(-2-50j), 0.017515007378437448-1.497884414277228461j)
+    assert ae(fp.shi(-50j), -1.5516170724859358947j)
+    assert ae(fp.shi(2-50j), -0.017515007378437448-1.497884414277228461j)
+    assert ae(fp.shi(20-2j), -4.050116856873293554e6-1.20747603112735722103e7j)
+    assert ae(fp.shi(20), 1.2807826332028294459e7)
+    assert ae(fp.shi(2+50j), -0.017515007378437448+1.497884414277228461j)
+
+def test_airy():
+    mp.dps = 15
+    assert (airyai(10)*10**10).ae(1.1047532552898687)
+    assert (airybi(10)/10**9).ae(0.45564115354822515)
+    assert (airyai(1000)*10**9158).ae(9.306933063179556004)
+    assert (airybi(1000)/10**9154).ae(5.4077118391949465477)
+    assert airyai(-1000).ae(0.055971895773019918842)
+    assert airybi(-1000).ae(-0.083264574117080633012)
+    assert (airyai(100+100j)*10**188).ae(2.9099582462207032076 + 2.353013591706178756j)
+    assert (airybi(100+100j)/10**185).ae(1.7086751714463652039 - 3.1416590020830804578j)
+
+def test_hyper_0f1():
+    mp.dps = 15
+    v = 8.63911136507950465
+    assert hyper([],[(1,3)],1.5).ae(v)
+    assert hyper([],[1/3.],1.5).ae(v)
+    assert hyp0f1(1/3.,1.5).ae(v)
+    assert hyp0f1((1,3),1.5).ae(v)
+    # Asymptotic expansion
+    assert hyp0f1(3,1e9).ae('4.9679055380347771271e+27455')
+    assert hyp0f1(3,1e9j).ae('-2.1222788784457702157e+19410 + 5.0840597555401854116e+19410j')
+
+def test_hyper_1f1():
+    mp.dps = 15
+    v = 1.2917526488617656673
+    assert hyper([(1,2)],[(3,2)],0.7).ae(v)
+    assert hyper([(1,2)],[(3,2)],0.7+0j).ae(v)
+    assert hyper([0.5],[(3,2)],0.7).ae(v)
+    assert hyper([0.5],[1.5],0.7).ae(v)
+    assert hyper([0.5],[(3,2)],0.7+0j).ae(v)
+    assert hyper([0.5],[1.5],0.7+0j).ae(v)
+    assert hyper([(1,2)],[1.5+0j],0.7).ae(v)
+    assert hyper([0.5+0j],[1.5],0.7).ae(v)
+    assert hyper([0.5+0j],[1.5+0j],0.7+0j).ae(v)
+    assert hyp1f1(0.5,1.5,0.7).ae(v)
+    assert hyp1f1((1,2),1.5,0.7).ae(v)
+    # Asymptotic expansion
+    assert hyp1f1(2,3,1e10).ae('2.1555012157015796988e+4342944809')
+    assert (hyp1f1(2,3,1e10j)*10**10).ae(-0.97501205020039745852 - 1.7462392454512132074j)
+    # Shouldn't use asymptotic expansion
+    assert hyp1f1(-2, 1, 10000).ae(49980001)
+    # Bug
+    assert hyp1f1(1j,fraction(1,3),0.415-69.739j).ae(25.857588206024346592 + 15.738060264515292063j)
+
+def test_hyper_2f1():
+    mp.dps = 15
+    v = 1.0652207633823291032
+    assert hyper([(1,2), (3,4)], [2], 0.3).ae(v)
+    assert hyper([(1,2), 0.75], [2], 0.3).ae(v)
+    assert hyper([0.5, 0.75], [2.0], 0.3).ae(v)
+    assert hyper([0.5, 0.75], [2.0], 0.3+0j).ae(v)
+    assert hyper([0.5+0j, (3,4)], [2.0], 0.3+0j).ae(v)
+    assert hyper([0.5+0j, (3,4)], [2.0], 0.3).ae(v)
+    assert hyper([0.5, (3,4)], [2.0+0j], 0.3).ae(v)
+    assert hyper([0.5+0j, 0.75+0j], [2.0+0j], 0.3+0j).ae(v)
+    v = 1.09234681096223231717 + 0.18104859169479360380j
+    assert hyper([(1,2),0.75+j], [2], 0.5).ae(v)
+    assert hyper([0.5,0.75+j], [2.0], 0.5).ae(v)
+    assert hyper([0.5,0.75+j], [2.0], 0.5+0j).ae(v)
+    assert hyper([0.5,0.75+j], [2.0+0j], 0.5+0j).ae(v)
+    v = 0.9625 - 0.125j
+    assert hyper([(3,2),-1],[4], 0.1+j/3).ae(v)
+    assert hyper([1.5,-1.0],[4], 0.1+j/3).ae(v)
+    assert hyper([1.5,-1.0],[4+0j], 0.1+j/3).ae(v)
+    assert hyper([1.5+0j,-1.0+0j],[4+0j], 0.1+j/3).ae(v)
+    v = 1.02111069501693445001 - 0.50402252613466859521j
+    assert hyper([(2,10),(3,10)],[(4,10)],1.5).ae(v)
+    assert hyper([0.2,(3,10)],[0.4+0j],1.5).ae(v)
+    assert hyper([0.2,(3,10)],[0.4+0j],1.5+0j).ae(v)
+    v = 0.76922501362865848528 + 0.32640579593235886194j
+    assert hyper([(2,10),(3,10)],[(4,10)],4+2j).ae(v)
+    assert hyper([0.2,(3,10)],[0.4+0j],4+2j).ae(v)
+    assert hyper([0.2,(3,10)],[(4,10)],4+2j).ae(v)
+
+def test_hyper_2f1_hard():
+    mp.dps = 15
+    # Singular cases
+    assert hyp2f1(2,-1,-1,3).ae(7)
+    assert hyp2f1(2,-1,-1,3,eliminate_all=True).ae(0.25)
+    assert hyp2f1(2,-2,-2,3).ae(34)
+    assert hyp2f1(2,-2,-2,3,eliminate_all=True).ae(0.25)
+    assert hyp2f1(2,-2,-3,3) == 14
+    assert hyp2f1(2,-3,-2,3) == inf
+    assert hyp2f1(2,-1.5,-1.5,3) == 0.25
+    assert hyp2f1(1,2,3,0) == 1
+    assert hyp2f1(0,1,0,0) == 1
+    assert hyp2f1(0,0,0,0) == 1
+    assert isnan(hyp2f1(1,1,0,0))
+    assert hyp2f1(2,-1,-5, 0.25+0.25j).ae(1.1+0.1j)
+    assert hyp2f1(2,-5,-5, 0.25+0.25j, eliminate=False).ae(163./128 + 125./128*j)
+    assert hyp2f1(0.7235, -1, -5, 0.3).ae(1.04341)
+    assert hyp2f1(0.7235, -5, -5, 0.3, eliminate=False).ae(1.2939225017815903812)
+    assert hyp2f1(-1,-2,4,1) == 1.5
+    assert hyp2f1(1,2,-3,1) == inf
+    assert hyp2f1(-2,-2,1,1) == 6
+    assert hyp2f1(1,-2,-4,1).ae(5./3)
+    assert hyp2f1(0,-6,-4,1) == 1
+    assert hyp2f1(0,-3,-4,1) == 1
+    assert hyp2f1(0,0,0,1) == 1
+    assert hyp2f1(1,0,0,1,eliminate=False) == 1
+    assert hyp2f1(1,1,0,1) == inf
+    assert hyp2f1(1,-6,-4,1) == inf
+    assert hyp2f1(-7.2,-0.5,-4.5,1) == 0
+    assert hyp2f1(-7.2,-1,-2,1).ae(-2.6)
+    assert hyp2f1(1,-0.5,-4.5, 1) == inf
+    assert hyp2f1(1,0.5,-4.5, 1) == -inf
+    # Check evaluation on / close to unit circle
+    z = exp(j*pi/3)
+    w = (nthroot(2,3)+1)*exp(j*pi/12)/nthroot(3,4)**3
+    assert hyp2f1('1/2','1/6','1/3', z).ae(w)
+    assert hyp2f1('1/2','1/6','1/3', z.conjugate()).ae(w.conjugate())
+    assert hyp2f1(0.25, (1,3), 2, '0.999').ae(1.06826449496030635)
+    assert hyp2f1(0.25, (1,3), 2, '1.001').ae(1.06867299254830309446-0.00001446586793975874j)
+    assert hyp2f1(0.25, (1,3), 2, -1).ae(0.96656584492524351673)
+    assert hyp2f1(0.25, (1,3), 2, j).ae(0.99041766248982072266+0.03777135604180735522j)
+    assert hyp2f1(2,3,5,'0.99').ae(27.699347904322690602)
+    assert hyp2f1((3,2),-0.5,3,'0.99').ae(0.68403036843911661388)
+    assert hyp2f1(2,3,5,1j).ae(0.37290667145974386127+0.59210004902748285917j)
+    assert fsum([hyp2f1((7,10),(2,3),(-1,2), 0.95*exp(j*k)) for k in range(1,15)]).ae(52.851400204289452922+6.244285013912953225j)
+    assert fsum([hyp2f1((7,10),(2,3),(-1,2), 1.05*exp(j*k)) for k in range(1,15)]).ae(54.506013786220655330-3.000118813413217097j)
+    assert fsum([hyp2f1((7,10),(2,3),(-1,2), exp(j*k)) for k in range(1,15)]).ae(55.792077935955314887+1.731986485778500241j)
+    assert hyp2f1(2,2.5,-3.25,0.999).ae(218373932801217082543180041.33)
+    # Branches
+    assert hyp2f1(1,1,2,1.01).ae(4.5595744415723676911-3.1104877758314784539j)
+    assert hyp2f1(1,1,2,1.01+0.1j).ae(2.4149427480552782484+1.4148224796836938829j)
+    assert hyp2f1(1,1,2,3+4j).ae(0.14576709331407297807+0.48379185417980360773j)
+    assert hyp2f1(1,1,2,4).ae(-0.27465307216702742285 - 0.78539816339744830962j)
+    assert hyp2f1(1,1,2,-4).ae(0.40235947810852509365)
+    # Other:
+    # Cancellation with a large parameter involved (bug reported on sage-devel)
+    assert hyp2f1(112, (51,10), (-9,10), -0.99999).ae(-1.6241361047970862961e-24, abs_eps=0, rel_eps=eps*16)
+
+def test_hyper_3f2_etc():
+    assert hyper([1,2,3],[1.5,8],-1).ae(0.67108992351533333030)
+    assert hyper([1,2,3,4],[5,6,7], -1).ae(0.90232988035425506008)
+    assert hyper([1,2,3],[1.25,5], 1).ae(28.924181329701905701)
+    assert hyper([1,2,3,4],[5,6,7],5).ae(1.5192307344006649499-1.1529845225075537461j)
+    assert hyper([1,2,3,4,5],[6,7,8,9],-1).ae(0.96288759462882357253)
+    assert hyper([1,2,3,4,5],[6,7,8,9],1).ae(1.0428697385885855841)
+    assert hyper([1,2,3,4,5],[6,7,8,9],5).ae(1.33980653631074769423-0.07143405251029226699j)
+    assert hyper([1,2.79,3.08,4.37],[5.2,6.1,7.3],5).ae(1.0996321464692607231-1.7748052293979985001j)
+    assert hyper([1,1,1],[1,2],1) == inf
+    assert hyper([1,1,1],[2,(101,100)],1).ae(100.01621213528313220)
+    # slow -- covered by doctests
+    #assert hyper([1,1,1],[2,3],0.9999).ae(1.2897972005319693905)
+
+def test_hyper_u():
+    mp.dps = 15
+    assert hyperu(2,-3,0).ae(0.05)
+    assert hyperu(2,-3.5,0).ae(4./99)
+    assert hyperu(2,0,0) == 0.5
+    assert hyperu(-5,1,0) == -120
+    assert hyperu(-5,2,0) == inf
+    assert hyperu(-5,-2,0) == 0
+    assert hyperu(7,7,3).ae(0.00014681269365593503986)  #exp(3)*gammainc(-6,3)
+    assert hyperu(2,-3,4).ae(0.011836478100271995559)
+    assert hyperu(3,4,5).ae(1./125)
+    assert hyperu(2,3,0.0625) == 256
+    assert hyperu(-1,2,0.25+0.5j) == -1.75+0.5j
+    assert hyperu(0.5,1.5,7.25).ae(2/sqrt(29))
+    assert hyperu(2,6,pi).ae(0.55804439825913399130)
+    assert (hyperu((3,2),8,100+201j)*10**4).ae(-0.3797318333856738798 - 2.9974928453561707782j)
+    assert (hyperu((5,2),(-1,2),-5000)*10**10).ae(-5.6681877926881664678j)
+    # XXX: fails because of undetected cancellation in low level series code
+    # Alternatively: could use asymptotic series here, if convergence test
+    # tweaked back to recognize this one
+    #assert (hyperu((5,2),(-1,2),-500)*10**7).ae(-1.82526906001593252847j)
+
+def test_hyper_2f0():
+    mp.dps = 15
+    assert hyper([1,2],[],3) == hyp2f0(1,2,3)
+    assert hyp2f0(2,3,7).ae(0.0116108068639728714668 - 0.0073727413865865802130j)
+    assert hyp2f0(2,3,0) == 1
+    assert hyp2f0(0,0,0) == 1
+    assert hyp2f0(-1,-1,1).ae(2)
+    assert hyp2f0(-4,1,1.5).ae(62.5)
+    assert hyp2f0(-4,1,50).ae(147029801)
+    assert hyp2f0(-4,1,0.0001).ae(0.99960011997600240000)
+    assert hyp2f0(0.5,0.25,0.001).ae(1.0001251174078538115)
+    assert hyp2f0(0.5,0.25,3+4j).ae(0.85548875824755163518 + 0.21636041283392292973j)
+    # Important: cancellation check
+    assert hyp2f0((1,6),(5,6),-0.02371708245126284498).ae(0.996785723120804309)
+    # Should be exact; polynomial case
+    assert hyp2f0(-2,1,0.5+0.5j,zeroprec=200) == 0
+    assert hyp2f0(1,-2,0.5+0.5j,zeroprec=200) == 0
+    # There used to be a bug in thresholds that made one of the following hang
+    for d in [15, 50, 80]:
+        mp.dps = d
+        assert hyp2f0(1.5, 0.5, 0.009).ae('1.006867007239309717945323585695344927904000945829843527398772456281301440034218290443367270629519483 + 1.238277162240704919639384945859073461954721356062919829456053965502443570466701567100438048602352623e-46j')
+
+def test_hyper_1f2():
+    mp.dps = 15
+    assert hyper([1],[2,3],4) == hyp1f2(1,2,3,4)
+    a1,b1,b2 = (1,10),(2,3),1./16
+    assert hyp1f2(a1,b1,b2,10).ae(298.7482725554557568)
+    assert hyp1f2(a1,b1,b2,100).ae(224128961.48602947604)
+    assert hyp1f2(a1,b1,b2,1000).ae(1.1669528298622675109e+27)
+    assert hyp1f2(a1,b1,b2,10000).ae(2.4780514622487212192e+86)
+    assert hyp1f2(a1,b1,b2,100000).ae(1.3885391458871523997e+274)
+    assert hyp1f2(a1,b1,b2,1000000).ae('9.8851796978960318255e+867')
+    assert hyp1f2(a1,b1,b2,10**7).ae('1.1505659189516303646e+2746')
+    assert hyp1f2(a1,b1,b2,10**8).ae('1.4672005404314334081e+8685')
+    assert hyp1f2(a1,b1,b2,10**20).ae('3.6888217332150976493e+8685889636')
+    assert hyp1f2(a1,b1,b2,10*j).ae(-16.163252524618572878 - 44.321567896480184312j)
+    assert hyp1f2(a1,b1,b2,100*j).ae(61938.155294517848171 + 637349.45215942348739j)
+    assert hyp1f2(a1,b1,b2,1000*j).ae(8455057657257695958.7 + 6261969266997571510.6j)
+    assert hyp1f2(a1,b1,b2,10000*j).ae(-8.9771211184008593089e+60 + 4.6550528111731631456e+59j)
+    assert hyp1f2(a1,b1,b2,100000*j).ae(2.6398091437239324225e+193 + 4.1658080666870618332e+193j)
+    assert hyp1f2(a1,b1,b2,1000000*j).ae('3.5999042951925965458e+613 + 1.5026014707128947992e+613j')
+    assert hyp1f2(a1,b1,b2,10**7*j).ae('-8.3208715051623234801e+1939 - 3.6752883490851869429e+1941j')
+    assert hyp1f2(a1,b1,b2,10**8*j).ae('2.0724195707891484454e+6140 - 1.3276619482724266387e+6141j')
+    assert hyp1f2(a1,b1,b2,10**20*j).ae('-1.1734497974795488504e+6141851462 + 1.1498106965385471542e+6141851462j')
+
+def test_hyper_2f3():
+    mp.dps = 15
+    assert hyper([1,2],[3,4,5],6) == hyp2f3(1,2,3,4,5,6)
+    a1,a2,b1,b2,b3 = (1,10),(2,3),(3,10), 2, 1./16
+    # Check asymptotic expansion
+    assert hyp2f3(a1,a2,b1,b2,b3,10).ae(128.98207160698659976)
+    assert hyp2f3(a1,a2,b1,b2,b3,1000).ae(6.6309632883131273141e25)
+    assert hyp2f3(a1,a2,b1,b2,b3,10000).ae(4.6863639362713340539e84)
+    assert hyp2f3(a1,a2,b1,b2,b3,100000).ae(8.6632451236103084119e271)
+    assert hyp2f3(a1,a2,b1,b2,b3,10**6).ae('2.0291718386574980641e865')
+    assert hyp2f3(a1,a2,b1,b2,b3,10**7).ae('7.7639836665710030977e2742')
+    assert hyp2f3(a1,a2,b1,b2,b3,10**8).ae('3.2537462584071268759e8681')
+    assert hyp2f3(a1,a2,b1,b2,b3,10**20).ae('1.2966030542911614163e+8685889627')
+    assert hyp2f3(a1,a2,b1,b2,b3,10*j).ae(-18.551602185587547854 - 13.348031097874113552j)
+    assert hyp2f3(a1,a2,b1,b2,b3,100*j).ae(78634.359124504488695 + 74459.535945281973996j)
+    assert hyp2f3(a1,a2,b1,b2,b3,1000*j).ae(597682550276527901.59 - 65136194809352613.078j)
+    assert hyp2f3(a1,a2,b1,b2,b3,10000*j).ae(-1.1779696326238582496e+59 + 1.2297607505213133872e+59j)
+    assert hyp2f3(a1,a2,b1,b2,b3,100000*j).ae(2.9844228969804380301e+191 + 7.5587163231490273296e+190j)
+    assert hyp2f3(a1,a2,b1,b2,b3,1000000*j).ae('7.4859161049322370311e+610 - 2.8467477015940090189e+610j')
+    assert hyp2f3(a1,a2,b1,b2,b3,10**7*j).ae('-1.7477645579418800826e+1938 - 1.7606522995808116405e+1938j')
+    assert hyp2f3(a1,a2,b1,b2,b3,10**8*j).ae('-1.6932731942958401784e+6137 - 2.4521909113114629368e+6137j')
+    assert hyp2f3(a1,a2,b1,b2,b3,10**20*j).ae('-2.0988815677627225449e+6141851451 + 5.7708223542739208681e+6141851452j')
+
+def test_hyper_2f2():
+    mp.dps = 15
+    assert hyper([1,2],[3,4],5) == hyp2f2(1,2,3,4,5)
+    a1,a2,b1,b2 = (3,10),4,(1,2),1./16
+    assert hyp2f2(a1,a2,b1,b2,10).ae(448225936.3377556696)
+    assert hyp2f2(a1,a2,b1,b2,10000).ae('1.2012553712966636711e+4358')
+    assert hyp2f2(a1,a2,b1,b2,-20000).ae(-0.04182343755661214626)
+    assert hyp2f2(a1,a2,b1,b2,10**20).ae('1.1148680024303263661e+43429448190325182840')
+
+def test_orthpoly():
+    mp.dps = 15
+    assert jacobi(-4,2,3,0.7).ae(22800./4913)
+    assert jacobi(3,2,4,5.5) == 4133.125
+    assert jacobi(1.5,5/6.,4,0).ae(-1.0851951434075508417)
+    assert jacobi(-2, 1, 2, 4).ae(-0.16)
+    assert jacobi(2, -1, 2.5, 4).ae(34.59375)
+    #assert jacobi(2, -1, 2, 4) == 28.5
+    assert legendre(5, 7) == 129367
+    assert legendre(0.5,0).ae(0.53935260118837935667)
+    assert legendre(-1,-1) == 1
+    assert legendre(0,-1) == 1
+    assert legendre(0, 1) == 1
+    assert legendre(1, -1) == -1
+    assert legendre(7, 1) == 1
+    assert legendre(7, -1) == -1
+    assert legendre(8,1.5).ae(15457523./32768)
+    assert legendre(j,-j).ae(2.4448182735671431011 + 0.6928881737669934843j)
+    assert chebyu(5,1) == 6
+    assert chebyt(3,2) == 26
+    assert legendre(3.5,-1) == inf
+    assert legendre(4.5,-1) == -inf
+    assert legendre(3.5+1j,-1) == mpc(inf,inf)
+    assert legendre(4.5+1j,-1) == mpc(-inf,-inf)
+    assert laguerre(4, -2, 3).ae(-1.125)
+    assert laguerre(3, 1+j, 0.5).ae(0.2291666666666666667 + 2.5416666666666666667j)
+
+def test_hermite():
+    mp.dps = 15
+    assert hermite(-2, 0).ae(0.5)
+    assert hermite(-1, 0).ae(0.88622692545275801365)
+    assert hermite(0, 0).ae(1)
+    assert hermite(1, 0) == 0
+    assert hermite(2, 0).ae(-2)
+    assert hermite(0, 2).ae(1)
+    assert hermite(1, 2).ae(4)
+    assert hermite(1, -2).ae(-4)
+    assert hermite(2, -2).ae(14)
+    assert hermite(0.5, 0).ae(0.69136733903629335053)
+    assert hermite(9, 0) == 0
+    assert hermite(4,4).ae(3340)
+    assert hermite(3,4).ae(464)
+    assert hermite(-4,4).ae(0.00018623860287512396181)
+    assert hermite(-3,4).ae(0.0016540169879668766270)
+    assert hermite(9, 2.5j).ae(13638725j)
+    assert hermite(9, -2.5j).ae(-13638725j)
+    assert hermite(9, 100).ae(511078883759363024000)
+    assert hermite(9, -100).ae(-511078883759363024000)
+    assert hermite(9, 100j).ae(512922083920643024000j)
+    assert hermite(9, -100j).ae(-512922083920643024000j)
+    assert hermite(-9.5, 2.5j).ae(-2.9004951258126778174e-6 + 1.7601372934039951100e-6j)
+    assert hermite(-9.5, -2.5j).ae(-2.9004951258126778174e-6 - 1.7601372934039951100e-6j)
+    assert hermite(-9.5, 100).ae(1.3776300722767084162e-22, abs_eps=0, rel_eps=eps)
+    assert hermite(-9.5, -100).ae('1.3106082028470671626e4355')
+    assert hermite(-9.5, 100j).ae(-9.7900218581864768430e-23 - 9.7900218581864768430e-23j, abs_eps=0, rel_eps=eps)
+    assert hermite(-9.5, -100j).ae(-9.7900218581864768430e-23 + 9.7900218581864768430e-23j, abs_eps=0, rel_eps=eps)
+    assert hermite(2+3j, -1-j).ae(851.3677063883687676 - 1496.4373467871007997j)
+
+def test_gegenbauer():
+    mp.dps = 15
+    assert gegenbauer(1,2,3).ae(12)
+    assert gegenbauer(2,3,4).ae(381)
+    assert gegenbauer(0,0,0) == 0
+    assert gegenbauer(2,-1,3) == 0
+    assert gegenbauer(-7, 0.5, 3).ae(8989)
+    assert gegenbauer(1, -0.5, 3).ae(-3)
+    assert gegenbauer(1, -1.5, 3).ae(-9)
+    assert gegenbauer(1, -0.5, 3).ae(-3)
+    assert gegenbauer(-0.5, -0.5, 3).ae(-2.6383553159023906245)
+    assert gegenbauer(2+3j, 1-j, 3+4j).ae(14.880536623203696780 + 20.022029711598032898j)
+    #assert gegenbauer(-2, -0.5, 3).ae(-12)
+
+def test_legenp():
+    mp.dps = 15
+    assert legenp(2,0,4) == legendre(2,4)
+    assert legenp(-2, -1, 0.5).ae(0.43301270189221932338)
+    assert legenp(-2, -1, 0.5, type=3).ae(0.43301270189221932338j)
+    assert legenp(-2, 1, 0.5).ae(-0.86602540378443864676)
+    assert legenp(2+j, 3+4j, -j).ae(134742.98773236786148 + 429782.72924463851745j)
+    assert legenp(2+j, 3+4j, -j, type=3).ae(802.59463394152268507 - 251.62481308942906447j)
+    assert legenp(2,4,3).ae(0)
+    assert legenp(2,4,3,type=3).ae(0)
+    assert legenp(2,1,0.5).ae(-1.2990381056766579701)
+    assert legenp(2,1,0.5,type=3).ae(1.2990381056766579701j)
+    assert legenp(3,2,3).ae(-360)
+    assert legenp(3,3,3).ae(240j*2**0.5)
+    assert legenp(3,4,3).ae(0)
+    assert legenp(0,0.5,2).ae(0.52503756790433198939 - 0.52503756790433198939j)
+    assert legenp(-1,-0.5,2).ae(0.60626116232846498110 + 0.60626116232846498110j)
+    assert legenp(-2,0.5,2).ae(1.5751127037129959682 - 1.5751127037129959682j)
+    assert legenp(-2,0.5,-0.5).ae(-0.85738275810499171286)
+
+def test_legenq():
+    mp.dps = 15
+    f = legenq
+    # Evaluation at poles
+    assert isnan(f(3,2,1))
+    assert isnan(f(3,2,-1))
+    assert isnan(f(3,2,1,type=3))
+    assert isnan(f(3,2,-1,type=3))
+    # Evaluation at 0
+    assert f(0,1,0,type=2).ae(-1)
+    assert f(-2,2,0,type=2,zeroprec=200).ae(0)
+    assert f(1.5,3,0,type=2).ae(-2.2239343475841951023)
+    assert f(0,1,0,type=3).ae(j)
+    assert f(-2,2,0,type=3,zeroprec=200).ae(0)
+    assert f(1.5,3,0,type=3).ae(2.2239343475841951022*(1-1j))
+    # Standard case, degree 0
+    assert f(0,0,-1.5).ae(-0.8047189562170501873 + 1.5707963267948966192j)
+    assert f(0,0,-0.5).ae(-0.54930614433405484570)
+    assert f(0,0,0,zeroprec=200).ae(0)
+    assert f(0,0,0.5).ae(0.54930614433405484570)
+    assert f(0,0,1.5).ae(0.8047189562170501873 - 1.5707963267948966192j)
+    assert f(0,0,-1.5,type=3).ae(-0.80471895621705018730)
+    assert f(0,0,-0.5,type=3).ae(-0.5493061443340548457 - 1.5707963267948966192j)
+    assert f(0,0,0,type=3).ae(-1.5707963267948966192j)
+    assert f(0,0,0.5,type=3).ae(0.5493061443340548457 - 1.5707963267948966192j)
+    assert f(0,0,1.5,type=3).ae(0.80471895621705018730)
+    # Standard case, degree 1
+    assert f(1,0,-1.5).ae(0.2070784343255752810 - 2.3561944901923449288j)
+    assert f(1,0,-0.5).ae(-0.72534692783297257715)
+    assert f(1,0,0).ae(-1)
+    assert f(1,0,0.5).ae(-0.72534692783297257715)
+    assert f(1,0,1.5).ae(0.2070784343255752810 - 2.3561944901923449288j)
+    # Standard case, degree 2
+    assert f(2,0,-1.5).ae(-0.0635669991240192885 + 4.5160394395353277803j)
+    assert f(2,0,-0.5).ae(0.81866326804175685571)
+    assert f(2,0,0,zeroprec=200).ae(0)
+    assert f(2,0,0.5).ae(-0.81866326804175685571)
+    assert f(2,0,1.5).ae(0.0635669991240192885 - 4.5160394395353277803j)
+    # Misc orders and degrees
+    assert f(2,3,1.5,type=2).ae(-5.7243340223994616228j)
+    assert f(2,3,1.5,type=3).ae(-5.7243340223994616228)
+    assert f(2,3,0.5,type=2).ae(-12.316805742712016310)
+    assert f(2,3,0.5,type=3).ae(-12.316805742712016310j)
+    assert f(2,3,-1.5,type=2).ae(-5.7243340223994616228j)
+    assert f(2,3,-1.5,type=3).ae(5.7243340223994616228)
+    assert f(2,3,-0.5,type=2).ae(-12.316805742712016310)
+    assert f(2,3,-0.5,type=3).ae(-12.316805742712016310j)
+    assert f(2+3j, 3+4j, 0.5, type=3).ae(0.0016119404873235186807 - 0.0005885900510718119836j)
+    assert f(2+3j, 3+4j, -1.5, type=3).ae(0.008451400254138808670 + 0.020645193304593235298j)
+    assert f(-2.5,1,-1.5).ae(3.9553395527435335749j)
+    assert f(-2.5,1,-0.5).ae(1.9290561746445456908)
+    assert f(-2.5,1,0).ae(1.2708196271909686299)
+    assert f(-2.5,1,0.5).ae(-0.31584812990742202869)
+    assert f(-2.5,1,1.5).ae(-3.9553395527435335742 + 0.2993235655044701706j)
+    assert f(-2.5,1,-1.5,type=3).ae(0.29932356550447017254j)
+    assert f(-2.5,1,-0.5,type=3).ae(-0.3158481299074220287 - 1.9290561746445456908j)
+    assert f(-2.5,1,0,type=3).ae(1.2708196271909686292 - 1.2708196271909686299j)
+    assert f(-2.5,1,0.5,type=3).ae(1.9290561746445456907 + 0.3158481299074220287j)
+    assert f(-2.5,1,1.5,type=3).ae(-0.29932356550447017254)
+
+def test_agm():
+    mp.dps = 15
+    assert agm(0,0) == 0
+    assert agm(0,1) == 0
+    assert agm(1,1) == 1
+    assert agm(7,7) == 7
+    assert agm(j,j) == j
+    assert (1/agm(1,sqrt(2))).ae(0.834626841674073186)
+    assert agm(1,2).ae(1.4567910310469068692)
+    assert agm(1,3).ae(1.8636167832448965424)
+    assert agm(1,j).ae(0.599070117367796104+0.599070117367796104j)
+    assert agm(2) == agm(1,2)
+    assert agm(-3,4).ae(0.63468509766550907+1.3443087080896272j)
+
+def test_gammainc():
+    mp.dps = 15
+    assert gammainc(2,5).ae(6*exp(-5))
+    assert gammainc(2,0,5).ae(1-6*exp(-5))
+    assert gammainc(2,3,5).ae(-6*exp(-5)+4*exp(-3))
+    assert gammainc(-2.5,-0.5).ae(-0.9453087204829418812-5.3164237738936178621j)
+    assert gammainc(0,2,4).ae(0.045121158298212213088)
+    assert gammainc(0,3).ae(0.013048381094197037413)
+    assert gammainc(0,2+j,1-j).ae(0.00910653685850304839-0.22378752918074432574j)
+    assert gammainc(0,1-j).ae(0.00028162445198141833+0.17932453503935894015j)
+    assert gammainc(3,4,5,True).ae(0.11345128607046320253)
+    assert gammainc(3.5,0,inf).ae(gamma(3.5))
+    assert gammainc(-150.5,500).ae('6.9825435345798951153e-627')
+    assert gammainc(-150.5,800).ae('4.6885137549474089431e-788')
+    assert gammainc(-3.5, -20.5).ae(0.27008820585226911 - 1310.31447140574997636j)
+    assert gammainc(-3.5, -200.5).ae(0.27008820585226911 - 5.3264597096208368435e76j) # XXX real part
+    assert gammainc(0,0,2) == inf
+    assert gammainc(1,b=1).ae(0.6321205588285576784)
+    assert gammainc(3,2,2) == 0
+    assert gammainc(2,3+j,3-j).ae(-0.28135485191849314194j)
+    assert gammainc(4+0j,1).ae(5.8860710587430771455)
+    # GH issue #301
+    assert gammainc(-1,-1).ae(-0.8231640121031084799 + 3.1415926535897932385j)
+    assert gammainc(-2,-1).ae(1.7707229202810768576 - 1.5707963267948966192j)
+    assert gammainc(-3,-1).ae(-1.4963349162467073643 + 0.5235987755982988731j)
+    assert gammainc(-4,-1).ae(1.05365418617643814992 - 0.13089969389957471827j)
+    # Regularized upper gamma
+    assert isnan(gammainc(0, 0, regularized=True))
+    assert gammainc(-1, 0, regularized=True) == inf
+    assert gammainc(1, 0, regularized=True) == 1
+    assert gammainc(0, 5, regularized=True) == 0
+    assert gammainc(0, 2+3j, regularized=True) == 0
+    assert gammainc(0, 5000, regularized=True) == 0
+    assert gammainc(0, 10**30, regularized=True) == 0
+    assert gammainc(-1, 5, regularized=True) == 0
+    assert gammainc(-1, 5000, regularized=True) == 0
+    assert gammainc(-1, 10**30, regularized=True) == 0
+    assert gammainc(-1, -5, regularized=True) == 0
+    assert gammainc(-1, -5000, regularized=True) == 0
+    assert gammainc(-1, -10**30, regularized=True) == 0
+    assert gammainc(-1, 3+4j, regularized=True) == 0
+    assert gammainc(1, 5, regularized=True).ae(exp(-5))
+    assert gammainc(1, 5000, regularized=True).ae(exp(-5000))
+    assert gammainc(1, 10**30, regularized=True).ae(exp(-10**30))
+    assert gammainc(1, 3+4j, regularized=True).ae(exp(-3-4j))
+    assert gammainc(-1000000,2).ae('1.3669297209397347754e-301037', abs_eps=0, rel_eps=8*eps)
+    assert gammainc(-1000000,2,regularized=True) == 0
+    assert gammainc(-1000000,3+4j).ae('-1.322575609404222361e-698979 - 4.9274570591854533273e-698978j', abs_eps=0, rel_eps=8*eps)
+    assert gammainc(-1000000,3+4j,regularized=True) == 0
+    assert gammainc(2+3j, 4+5j, regularized=True).ae(0.085422013530993285774-0.052595379150390078503j)
+    assert gammainc(1000j, 1000j, regularized=True).ae(0.49702647628921131761 + 0.00297355675013575341j)
+    # Generalized
+    assert gammainc(3,4,2) == -gammainc(3,2,4)
+    assert gammainc(4, 2, 3).ae(1.2593494302978947396)
+    assert gammainc(4, 2, 3, regularized=True).ae(0.20989157171631578993)
+    assert gammainc(0, 2, 3).ae(0.035852129613864082155)
+    assert gammainc(0, 2, 3, regularized=True) == 0
+    assert gammainc(-1, 2, 3).ae(0.015219822548487616132)
+    assert gammainc(-1, 2, 3, regularized=True) == 0
+    assert gammainc(0, 2, 3).ae(0.035852129613864082155)
+    assert gammainc(0, 2, 3, regularized=True) == 0
+    # Should use upper gammas
+    assert gammainc(5, 10000, 12000).ae('1.1359381951461801687e-4327', abs_eps=0, rel_eps=8*eps)
+    # Should use lower gammas
+    assert gammainc(10000, 2, 3).ae('8.1244514125995785934e4765')
+    # GH issue 306
+    assert gammainc(3,-1-1j) == 0
+    assert gammainc(3,-1+1j) == 0
+    assert gammainc(2,-1) == 0
+    assert gammainc(2,-1+0j) == 0
+    assert gammainc(2+0j,-1) == 0
+
+def test_gammainc_expint_n():
+    # These tests are intended to check all cases of the low-level code
+    # for upper gamma and expint with small integer index.
+    # Need to cover positive/negative arguments; small/large/huge arguments
+    # for both positive and negative indices, as well as indices 0 and 1
+    # which may be special-cased
+    mp.dps = 15
+    assert expint(-3,3.5).ae(0.021456366563296693987)
+    assert expint(-2,3.5).ae(0.014966633183073309405)
+    assert expint(-1,3.5).ae(0.011092916359219041088)
+    assert expint(0,3.5).ae(0.0086278238349481430685)
+    assert expint(1,3.5).ae(0.0069701398575483929193)
+    assert expint(2,3.5).ae(0.0058018939208991255223)
+    assert expint(3,3.5).ae(0.0049453773495857807058)
+    assert expint(-3,-3.5).ae(-4.6618170604073311319)
+    assert expint(-2,-3.5).ae(-5.5996974157555515963)
+    assert expint(-1,-3.5).ae(-6.7582555017739415818)
+    assert expint(0,-3.5).ae(-9.4615577024835182145)
+    assert expint(1,-3.5).ae(-13.925353995152335292 - 3.1415926535897932385j)
+    assert expint(2,-3.5).ae(-15.62328702434085977 - 10.995574287564276335j)
+    assert expint(3,-3.5).ae(-10.783026313250347722 - 19.242255003237483586j)
+    assert expint(-3,350).ae(2.8614825451252838069e-155, abs_eps=0, rel_eps=8*eps)
+    assert expint(-2,350).ae(2.8532837224504675901e-155, abs_eps=0, rel_eps=8*eps)
+    assert expint(-1,350).ae(2.8451316155828634555e-155, abs_eps=0, rel_eps=8*eps)
+    assert expint(0,350).ae(2.8370258275042797989e-155, abs_eps=0, rel_eps=8*eps)
+    assert expint(1,350).ae(2.8289659656701459404e-155, abs_eps=0, rel_eps=8*eps)
+    assert expint(2,350).ae(2.8209516419468505006e-155, abs_eps=0, rel_eps=8*eps)
+    assert expint(3,350).ae(2.8129824725501272171e-155, abs_eps=0, rel_eps=8*eps)
+    assert expint(-3,-350).ae(-2.8528796154044839443e+149)
+    assert expint(-2,-350).ae(-2.8610072121701264351e+149)
+    assert expint(-1,-350).ae(-2.8691813842677537647e+149)
+    assert expint(0,-350).ae(-2.8774025343659421709e+149)
+    u = expint(1,-350)
+    assert u.ae(-2.8856710698020863568e+149)
+    assert u.imag.ae(-3.1415926535897932385)
+    u = expint(2,-350)
+    assert u.ae(-2.8939874026504650534e+149)
+    assert u.imag.ae(-1099.5574287564276335)
+    u = expint(3,-350)
+    assert u.ae(-2.9023519497915044349e+149)
+    assert u.imag.ae(-192422.55003237483586)
+    assert expint(-3,350000000000000000000000).ae('2.1592908471792544286e-152003068666138139677919', abs_eps=0, rel_eps=8*eps)
+    assert expint(-2,350000000000000000000000).ae('2.1592908471792544286e-152003068666138139677919', abs_eps=0, rel_eps=8*eps)
+    assert expint(-1,350000000000000000000000).ae('2.1592908471792544286e-152003068666138139677919', abs_eps=0, rel_eps=8*eps)
+    assert expint(0,350000000000000000000000).ae('2.1592908471792544286e-152003068666138139677919', abs_eps=0, rel_eps=8*eps)
+    assert expint(1,350000000000000000000000).ae('2.1592908471792544286e-152003068666138139677919', abs_eps=0, rel_eps=8*eps)
+    assert expint(2,350000000000000000000000).ae('2.1592908471792544286e-152003068666138139677919', abs_eps=0, rel_eps=8*eps)
+    assert expint(3,350000000000000000000000).ae('2.1592908471792544286e-152003068666138139677919', abs_eps=0, rel_eps=8*eps)
+    assert expint(-3,-350000000000000000000000).ae('-3.7805306852415755699e+152003068666138139677871')
+    assert expint(-2,-350000000000000000000000).ae('-3.7805306852415755699e+152003068666138139677871')
+    assert expint(-1,-350000000000000000000000).ae('-3.7805306852415755699e+152003068666138139677871')
+    assert expint(0,-350000000000000000000000).ae('-3.7805306852415755699e+152003068666138139677871')
+    u = expint(1,-350000000000000000000000)
+    assert u.ae('-3.7805306852415755699e+152003068666138139677871')
+    assert u.imag.ae(-3.1415926535897932385)
+    u = expint(2,-350000000000000000000000)
+    assert u.imag.ae(-1.0995574287564276335e+24)
+    assert u.ae('-3.7805306852415755699e+152003068666138139677871')
+    u = expint(3,-350000000000000000000000)
+    assert u.imag.ae(-1.9242255003237483586e+47)
+    assert u.ae('-3.7805306852415755699e+152003068666138139677871')
+    # Small case; no branch cut
+    assert gammainc(-3,3.5).ae(0.00010020262545203707109)
+    assert gammainc(-2,3.5).ae(0.00040370427343557393517)
+    assert gammainc(-1,3.5).ae(0.0016576839773997501492)
+    assert gammainc(0,3.5).ae(0.0069701398575483929193)
+    assert gammainc(1,3.5).ae(0.03019738342231850074)
+    assert gammainc(2,3.5).ae(0.13588822540043325333)
+    assert gammainc(3,3.5).ae(0.64169439772426814072)
+    # Small case; with branch cut
+    assert gammainc(-3,-3.5).ae(0.03595832954467563286 + 0.52359877559829887308j)
+    assert gammainc(-2,-3.5).ae(-0.88024704597962022221 - 1.5707963267948966192j)
+    assert gammainc(-1,-3.5).ae(4.4637962926688170771 + 3.1415926535897932385j)
+    assert gammainc(0,-3.5).ae(-13.925353995152335292 - 3.1415926535897932385j)
+    assert gammainc(1,-3.5).ae(33.115451958692313751)
+    assert gammainc(2,-3.5).ae(-82.788629896730784377)
+    assert gammainc(3,-3.5).ae(240.08702670051927469)
+    # Asymptotic case; no branch cut
+    assert gammainc(-3,350).ae(6.5424095113340358813e-163, abs_eps=0, rel_eps=8*eps)
+    assert gammainc(-2,350).ae(2.296312222489899769e-160, abs_eps=0, rel_eps=8*eps)
+    assert gammainc(-1,350).ae(8.059861834133858573e-158, abs_eps=0, rel_eps=8*eps)
+    assert gammainc(0,350).ae(2.8289659656701459404e-155, abs_eps=0, rel_eps=8*eps)
+    assert gammainc(1,350).ae(9.9295903962649792963e-153, abs_eps=0, rel_eps=8*eps)
+    assert gammainc(2,350).ae(3.485286229089007733e-150, abs_eps=0, rel_eps=8*eps)
+    assert gammainc(3,350).ae(1.2233453960006379793e-147, abs_eps=0, rel_eps=8*eps)
+    # Asymptotic case; branch cut
+    u = gammainc(-3,-350)
+    assert u.ae(6.7889565783842895085e+141)
+    assert u.imag.ae(0.52359877559829887308)
+    u = gammainc(-2,-350)
+    assert u.ae(-2.3692668977889832121e+144)
+    assert u.imag.ae(-1.5707963267948966192)
+    u = gammainc(-1,-350)
+    assert u.ae(8.2685354361441858669e+146)
+    assert u.imag.ae(3.1415926535897932385)
+    u = gammainc(0,-350)
+    assert u.ae(-2.8856710698020863568e+149)
+    assert u.imag.ae(-3.1415926535897932385)
+    u = gammainc(1,-350)
+    assert u.ae(1.0070908870280797598e+152)
+    assert u.imag == 0
+    u = gammainc(2,-350)
+    assert u.ae(-3.5147471957279983618e+154)
+    assert u.imag == 0
+    u = gammainc(3,-350)
+    assert u.ae(1.2266568422179417091e+157)
+    assert u.imag == 0
+    # Extreme asymptotic case
+    assert gammainc(-3,350000000000000000000000).ae('5.0362468738874738859e-152003068666138139677990', abs_eps=0, rel_eps=8*eps)
+    assert gammainc(-2,350000000000000000000000).ae('1.7626864058606158601e-152003068666138139677966', abs_eps=0, rel_eps=8*eps)
+    assert gammainc(-1,350000000000000000000000).ae('6.1694024205121555102e-152003068666138139677943', abs_eps=0, rel_eps=8*eps)
+    assert gammainc(0,350000000000000000000000).ae('2.1592908471792544286e-152003068666138139677919', abs_eps=0, rel_eps=8*eps)
+    assert gammainc(1,350000000000000000000000).ae('7.5575179651273905e-152003068666138139677896', abs_eps=0, rel_eps=8*eps)
+    assert gammainc(2,350000000000000000000000).ae('2.645131287794586675e-152003068666138139677872', abs_eps=0, rel_eps=8*eps)
+    assert gammainc(3,350000000000000000000000).ae('9.2579595072810533625e-152003068666138139677849', abs_eps=0, rel_eps=8*eps)
+    u = gammainc(-3,-350000000000000000000000)
+    assert u.ae('8.8175642804468234866e+152003068666138139677800')
+    assert u.imag.ae(0.52359877559829887308)
+    u = gammainc(-2,-350000000000000000000000)
+    assert u.ae('-3.0861474981563882203e+152003068666138139677824')
+    assert u.imag.ae(-1.5707963267948966192)
+    u = gammainc(-1,-350000000000000000000000)
+    assert u.ae('1.0801516243547358771e+152003068666138139677848')
+    assert u.imag.ae(3.1415926535897932385)
+    u = gammainc(0,-350000000000000000000000)
+    assert u.ae('-3.7805306852415755699e+152003068666138139677871')
+    assert u.imag.ae(-3.1415926535897932385)
+    assert gammainc(1,-350000000000000000000000).ae('1.3231857398345514495e+152003068666138139677895')
+    assert gammainc(2,-350000000000000000000000).ae('-4.6311500894209300731e+152003068666138139677918')
+    assert gammainc(3,-350000000000000000000000).ae('1.6209025312973255256e+152003068666138139677942')
+
+def test_incomplete_beta():
+    mp.dps = 15
+    assert betainc(-2,-3,0.5,0.75).ae(63.4305673311255413583969)
+    assert betainc(4.5,0.5+2j,2.5,6).ae(0.2628801146130621387903065 + 0.5162565234467020592855378j)
+    assert betainc(4,5,0,6).ae(90747.77142857142857142857)
+
+def test_erf():
+    mp.dps = 15
+    assert erf(0) == 0
+    assert erf(1).ae(0.84270079294971486934)
+    assert erf(3+4j).ae(-120.186991395079444098 - 27.750337293623902498j)
+    assert erf(-4-3j).ae(-0.99991066178539168236 + 0.00004972026054496604j)
+    assert erf(pi).ae(0.99999112385363235839)
+    assert erf(1j).ae(1.6504257587975428760j)
+    assert erf(-1j).ae(-1.6504257587975428760j)
+    assert isinstance(erf(1), mpf)
+    assert isinstance(erf(-1), mpf)
+    assert isinstance(erf(0), mpf)
+    assert isinstance(erf(0j), mpc)
+    assert erf(inf) == 1
+    assert erf(-inf) == -1
+    assert erfi(0) == 0
+    assert erfi(1/pi).ae(0.371682698493894314)
+    assert erfi(inf) == inf
+    assert erfi(-inf) == -inf
+    assert erf(1+0j) == erf(1)
+    assert erfc(1+0j) == erfc(1)
+    assert erf(0.2+0.5j).ae(1 - erfc(0.2+0.5j))
+    assert erfc(0) == 1
+    assert erfc(1).ae(1-erf(1))
+    assert erfc(-1).ae(1-erf(-1))
+    assert erfc(1/pi).ae(1-erf(1/pi))
+    assert erfc(-10) == 2
+    assert erfc(-1000000) == 2
+    assert erfc(-inf) == 2
+    assert erfc(inf) == 0
+    assert isnan(erfc(nan))
+    assert (erfc(10**4)*mpf(10)**43429453).ae('3.63998738656420')
+    assert erf(8+9j).ae(-1072004.2525062051158 + 364149.91954310255423j)
+    assert erfc(8+9j).ae(1072005.2525062051158 - 364149.91954310255423j)
+    assert erfc(-8-9j).ae(-1072003.2525062051158 + 364149.91954310255423j)
+    mp.dps = 50
+    # This one does not use the asymptotic series
+    assert (erfc(10)*10**45).ae('2.0884875837625447570007862949577886115608181193212')
+    # This one does
+    assert (erfc(50)*10**1088).ae('2.0709207788416560484484478751657887929322509209954')
+    mp.dps = 15
+    assert str(erfc(10**50)) == '3.66744826532555e-4342944819032518276511289189166050822943970058036665661144537831658646492088707747292249493384317534'
+    assert erfinv(0) == 0
+    assert erfinv(0.5).ae(0.47693627620446987338)
+    assert erfinv(-0.5).ae(-0.47693627620446987338)
+    assert erfinv(1) == inf
+    assert erfinv(-1) == -inf
+    assert erf(erfinv(0.95)).ae(0.95)
+    assert erf(erfinv(0.999999999995)).ae(0.999999999995)
+    assert erf(erfinv(-0.999999999995)).ae(-0.999999999995)
+    mp.dps = 50
+    assert erf(erfinv('0.99999999999999999999999999999995')).ae('0.99999999999999999999999999999995')
+    assert erf(erfinv('0.999999999999999999999999999999995')).ae('0.999999999999999999999999999999995')
+    assert erf(erfinv('-0.999999999999999999999999999999995')).ae('-0.999999999999999999999999999999995')
+    mp.dps = 15
+    # Complex asymptotic expansions
+    v = erfc(50j)
+    assert v.real == 1
+    assert v.imag.ae('-6.1481820666053078736e+1083')
+    assert erfc(-100+5j).ae(2)
+    assert (erfc(100+5j)*10**4335).ae(2.3973567853824133572 - 3.9339259530609420597j)
+    assert erfc(100+100j).ae(0.00065234366376857698698 - 0.0039357263629214118437j)
+
+def test_pdf():
+    mp.dps = 15
+    assert npdf(-inf) == 0
+    assert npdf(inf) == 0
+    assert npdf(5,0,2).ae(npdf(5+4,4,2))
+    assert quadts(lambda x: npdf(x,-0.5,0.8), [-inf, inf]) == 1
+    assert ncdf(0) == 0.5
+    assert ncdf(3,3) == 0.5
+    assert ncdf(-inf) == 0
+    assert ncdf(inf) == 1
+    assert ncdf(10) == 1
+    # Verify that this is computed accurately
+    assert (ncdf(-10)*10**24).ae(7.619853024160526)
+
+def test_lambertw():
+    mp.dps = 15
+    assert lambertw(0) == 0
+    assert lambertw(0+0j) == 0
+    assert lambertw(inf) == inf
+    assert isnan(lambertw(nan))
+    assert lambertw(inf,1).real == inf
+    assert lambertw(inf,1).imag.ae(2*pi)
+    assert lambertw(-inf,1).real == inf
+    assert lambertw(-inf,1).imag.ae(3*pi)
+    assert lambertw(0,-1) == -inf
+    assert lambertw(0,1) == -inf
+    assert lambertw(0,3) == -inf
+    assert lambertw(e).ae(1)
+    assert lambertw(1).ae(0.567143290409783873)
+    assert lambertw(-pi/2).ae(j*pi/2)
+    assert lambertw(-log(2)/2).ae(-log(2))
+    assert lambertw(0.25).ae(0.203888354702240164)
+    assert lambertw(-0.25).ae(-0.357402956181388903)
+    assert lambertw(-1./10000,0).ae(-0.000100010001500266719)
+    assert lambertw(-0.25,-1).ae(-2.15329236411034965)
+    assert lambertw(0.25,-1).ae(-3.00899800997004620-4.07652978899159763j)
+    assert lambertw(-0.25,-1).ae(-2.15329236411034965)
+    assert lambertw(0.25,1).ae(-3.00899800997004620+4.07652978899159763j)
+    assert lambertw(-0.25,1).ae(-3.48973228422959210+7.41405453009603664j)
+    assert lambertw(-4).ae(0.67881197132094523+1.91195078174339937j)
+    assert lambertw(-4,1).ae(-0.66743107129800988+7.76827456802783084j)
+    assert lambertw(-4,-1).ae(0.67881197132094523-1.91195078174339937j)
+    assert lambertw(1000).ae(5.24960285240159623)
+    assert lambertw(1000,1).ae(4.91492239981054535+5.44652615979447070j)
+    assert lambertw(1000,-1).ae(4.91492239981054535-5.44652615979447070j)
+    assert lambertw(1000,5).ae(3.5010625305312892+29.9614548941181328j)
+    assert lambertw(3+4j).ae(1.281561806123775878+0.533095222020971071j)
+    assert lambertw(-0.4+0.4j).ae(-0.10396515323290657+0.61899273315171632j)
+    assert lambertw(3+4j,1).ae(-0.11691092896595324+5.61888039871282334j)
+    assert lambertw(3+4j,-1).ae(0.25856740686699742-3.85211668616143559j)
+    assert lambertw(-0.5,-1).ae(-0.794023632344689368-0.770111750510379110j)
+    assert lambertw(-1./10000,1).ae(-11.82350837248724344+6.80546081842002101j)
+    assert lambertw(-1./10000,-1).ae(-11.6671145325663544)
+    assert lambertw(-1./10000,-2).ae(-11.82350837248724344-6.80546081842002101j)
+    assert lambertw(-1./100000,4).ae(-14.9186890769540539+26.1856750178782046j)
+    assert lambertw(-1./100000,5).ae(-15.0931437726379218666+32.5525721210262290086j)
+    assert lambertw((2+j)/10).ae(0.173704503762911669+0.071781336752835511j)
+    assert lambertw((2+j)/10,1).ae(-3.21746028349820063+4.56175438896292539j)
+    assert lambertw((2+j)/10,-1).ae(-3.03781405002993088-3.53946629633505737j)
+    assert lambertw((2+j)/10,4).ae(-4.6878509692773249+23.8313630697683291j)
+    assert lambertw(-(2+j)/10).ae(-0.226933772515757933-0.164986470020154580j)
+    assert lambertw(-(2+j)/10,1).ae(-2.43569517046110001+0.76974067544756289j)
+    assert lambertw(-(2+j)/10,-1).ae(-3.54858738151989450-6.91627921869943589j)
+    assert lambertw(-(2+j)/10,4).ae(-4.5500846928118151+20.6672982215434637j)
+    mp.dps = 50
+    assert lambertw(pi).ae('1.073658194796149172092178407024821347547745350410314531')
+    mp.dps = 15
+    # Former bug in generated branch
+    assert lambertw(-0.5+0.002j).ae(-0.78917138132659918344 + 0.76743539379990327749j)
+    assert lambertw(-0.5-0.002j).ae(-0.78917138132659918344 - 0.76743539379990327749j)
+    assert lambertw(-0.448+0.4j).ae(-0.11855133765652382241 + 0.66570534313583423116j)
+    assert lambertw(-0.448-0.4j).ae(-0.11855133765652382241 - 0.66570534313583423116j)
+    assert lambertw(-0.65475+0.0001j).ae(-0.61053421111385310898+1.0396534993944097723803j)
+    # Huge branch index
+    w = lambertw(1,10**20)
+    assert w.real.ae(-47.889578926290259164)
+    assert w.imag.ae(6.2831853071795864769e+20)
+
+def test_lambertw_hard():
+    def check(x,y):
+        y = convert(y)
+        type_ok = True
+        if isinstance(y, mpf):
+            type_ok = isinstance(x, mpf)
+        real_ok = abs(x.real-y.real) <= abs(y.real)*8*eps
+        imag_ok = abs(x.imag-y.imag) <= abs(y.imag)*8*eps
+        #print x, y, abs(x.real-y.real), abs(x.imag-y.imag)
+        return real_ok and imag_ok
+    # Evaluation near 0
+    mp.dps = 15
+    assert check(lambertw(1e-10), 9.999999999000000000e-11)
+    assert check(lambertw(-1e-10), -1.000000000100000000e-10)
+    assert check(lambertw(1e-10j), 9.999999999999999999733e-21 + 9.99999999999999999985e-11j)
+    assert check(lambertw(-1e-10j), 9.999999999999999999733e-21 - 9.99999999999999999985e-11j)
+    assert check(lambertw(1e-10,1), -26.303186778379041559 + 3.265093911703828397j)
+    assert check(lambertw(-1e-10,1), -26.326236166739163892 + 6.526183280686333315j)
+    assert check(lambertw(1e-10j,1), -26.312931726911421551 + 4.896366881798013421j)
+    assert check(lambertw(-1e-10j,1), -26.297238779529035066 + 1.632807161345576513j)
+    assert check(lambertw(1e-10,-1), -26.303186778379041559 - 3.265093911703828397j)
+    assert check(lambertw(-1e-10,-1), -26.295238819246925694)
+    assert check(lambertw(1e-10j,-1), -26.297238779529035028 - 1.6328071613455765135j)
+    assert check(lambertw(-1e-10j,-1), -26.312931726911421551 - 4.896366881798013421j)
+    # Test evaluation very close to the branch point -1/e
+    # on the -1, 0, and 1 branches
+    add = lambda x, y: fadd(x,y,exact=True)
+    sub = lambda x, y: fsub(x,y,exact=True)
+    addj = lambda x, y: fadd(x,fmul(y,1j,exact=True),exact=True)
+    subj = lambda x, y: fadd(x,fmul(y,-1j,exact=True),exact=True)
+    mp.dps = 1500
+    a = -1/e + 10*eps
+    d3 = mpf('1e-3')
+    d10 = mpf('1e-10')
+    d20 = mpf('1e-20')
+    d40 = mpf('1e-40')
+    d80 = mpf('1e-80')
+    d300 = mpf('1e-300')
+    d1000 = mpf('1e-1000')
+    mp.dps = 15
+    # ---- Branch 0 ----
+    # -1/e + eps
+    assert check(lambertw(add(a,d3)), -0.92802015005456704876)
+    assert check(lambertw(add(a,d10)), -0.99997668374140088071)
+    assert check(lambertw(add(a,d20)), -0.99999999976683560186)
+    assert lambertw(add(a,d40)) == -1
+    assert lambertw(add(a,d80)) == -1
+    assert lambertw(add(a,d300)) == -1
+    assert lambertw(add(a,d1000)) == -1
+    # -1/e - eps
+    assert check(lambertw(sub(a,d3)), -0.99819016149860989001+0.07367191188934638577j)
+    assert check(lambertw(sub(a,d10)), -0.9999999998187812114595992+0.0000233164398140346109194j)
+    assert check(lambertw(sub(a,d20)), -0.99999999999999999998187+2.331643981597124203344e-10j)
+    assert check(lambertw(sub(a,d40)), -1.0+2.33164398159712420336e-20j)
+    assert check(lambertw(sub(a,d80)), -1.0+2.33164398159712420336e-40j)
+    assert check(lambertw(sub(a,d300)), -1.0+2.33164398159712420336e-150j)
+    assert check(lambertw(sub(a,d1000)), mpc(-1,'2.33164398159712420336e-500'))
+    # -1/e + eps*j
+    assert check(lambertw(addj(a,d3)), -0.94790387486938526634+0.05036819639190132490j)
+    assert check(lambertw(addj(a,d10)), -0.9999835127872943680999899+0.0000164870314895821225256j)
+    assert check(lambertw(addj(a,d20)), -0.999999999835127872929987+1.64872127051890935830e-10j)
+    assert check(lambertw(addj(a,d40)), -0.9999999999999999999835+1.6487212707001281468305e-20j)
+    assert check(lambertw(addj(a,d80)), -1.0 + 1.64872127070012814684865e-40j)
+    assert check(lambertw(addj(a,d300)), -1.0 + 1.64872127070012814684865e-150j)
+    assert check(lambertw(addj(a,d1000)), mpc(-1.0,'1.64872127070012814684865e-500'))
+    # -1/e - eps*j
+    assert check(lambertw(subj(a,d3)), -0.94790387486938526634-0.05036819639190132490j)
+    assert check(lambertw(subj(a,d10)), -0.9999835127872943680999899-0.0000164870314895821225256j)
+    assert check(lambertw(subj(a,d20)), -0.999999999835127872929987-1.64872127051890935830e-10j)
+    assert check(lambertw(subj(a,d40)), -0.9999999999999999999835-1.6487212707001281468305e-20j)
+    assert check(lambertw(subj(a,d80)), -1.0 - 1.64872127070012814684865e-40j)
+    assert check(lambertw(subj(a,d300)), -1.0 - 1.64872127070012814684865e-150j)
+    assert check(lambertw(subj(a,d1000)), mpc(-1.0,'-1.64872127070012814684865e-500'))
+    # ---- Branch 1 ----
+    assert check(lambertw(addj(a,d3),1), -3.088501303219933378005990 + 7.458676867597474813950098j)
+    assert check(lambertw(addj(a,d80),1), -3.088843015613043855957087 + 7.461489285654254556906117j)
+    assert check(lambertw(addj(a,d300),1), -3.088843015613043855957087 + 7.461489285654254556906117j)
+    assert check(lambertw(addj(a,d1000),1), -3.088843015613043855957087 + 7.461489285654254556906117j)
+    assert check(lambertw(subj(a,d3),1), -1.0520914180450129534365906 + 0.0539925638125450525673175j)
+    assert check(lambertw(subj(a,d10),1), -1.0000164872127056318529390 + 0.000016487393927159250398333077j)
+    assert check(lambertw(subj(a,d20),1), -1.0000000001648721270700128 + 1.64872127088134693542628e-10j)
+    assert check(lambertw(subj(a,d40),1), -1.000000000000000000016487 + 1.64872127070012814686677e-20j)
+    assert check(lambertw(subj(a,d80),1), -1.0 + 1.64872127070012814684865e-40j)
+    assert check(lambertw(subj(a,d300),1), -1.0 + 1.64872127070012814684865e-150j)
+    assert check(lambertw(subj(a,d1000),1), mpc(-1.0, '1.64872127070012814684865e-500'))
+    # ---- Branch -1 ----
+    # -1/e + eps
+    assert check(lambertw(add(a,d3),-1), -1.075608941186624989414945)
+    assert check(lambertw(add(a,d10),-1), -1.000023316621036696460620)
+    assert check(lambertw(add(a,d20),-1), -1.000000000233164398177834)
+    assert lambertw(add(a,d40),-1) == -1
+    assert lambertw(add(a,d80),-1) == -1
+    assert lambertw(add(a,d300),-1) == -1
+    assert lambertw(add(a,d1000),-1) == -1
+    # -1/e - eps
+    assert check(lambertw(sub(a,d3),-1), -0.99819016149860989001-0.07367191188934638577j)
+    assert check(lambertw(sub(a,d10),-1), -0.9999999998187812114595992-0.0000233164398140346109194j)
+    assert check(lambertw(sub(a,d20),-1), -0.99999999999999999998187-2.331643981597124203344e-10j)
+    assert check(lambertw(sub(a,d40),-1), -1.0-2.33164398159712420336e-20j)
+    assert check(lambertw(sub(a,d80),-1), -1.0-2.33164398159712420336e-40j)
+    assert check(lambertw(sub(a,d300),-1), -1.0-2.33164398159712420336e-150j)
+    assert check(lambertw(sub(a,d1000),-1), mpc(-1,'-2.33164398159712420336e-500'))
+    # -1/e + eps*j
+    assert check(lambertw(addj(a,d3),-1), -1.0520914180450129534365906 - 0.0539925638125450525673175j)
+    assert check(lambertw(addj(a,d10),-1), -1.0000164872127056318529390 - 0.0000164873939271592503983j)
+    assert check(lambertw(addj(a,d20),-1), -1.0000000001648721270700 - 1.64872127088134693542628e-10j)
+    assert check(lambertw(addj(a,d40),-1), -1.00000000000000000001648 - 1.6487212707001281468667726e-20j)
+    assert check(lambertw(addj(a,d80),-1), -1.0 - 1.64872127070012814684865e-40j)
+    assert check(lambertw(addj(a,d300),-1), -1.0 - 1.64872127070012814684865e-150j)
+    assert check(lambertw(addj(a,d1000),-1), mpc(-1.0,'-1.64872127070012814684865e-500'))
+    # -1/e - eps*j
+    assert check(lambertw(subj(a,d3),-1), -3.088501303219933378005990-7.458676867597474813950098j)
+    assert check(lambertw(subj(a,d10),-1), -3.088843015579260686911033-7.461489285372968780020716j)
+    assert check(lambertw(subj(a,d20),-1), -3.088843015613043855953708-7.461489285654254556877988j)
+    assert check(lambertw(subj(a,d40),-1), -3.088843015613043855957087-7.461489285654254556906117j)
+    assert check(lambertw(subj(a,d80),-1), -3.088843015613043855957087 - 7.461489285654254556906117j)
+    assert check(lambertw(subj(a,d300),-1), -3.088843015613043855957087 - 7.461489285654254556906117j)
+    assert check(lambertw(subj(a,d1000),-1), -3.088843015613043855957087 - 7.461489285654254556906117j)
+    # One more case, testing higher precision
+    mp.dps = 500
+    x = -1/e + mpf('1e-13')
+    ans = "-0.99999926266961377166355784455394913638782494543377383"\
+    "744978844374498153493943725364881490261187530235150668593869563"\
+    "168276697689459394902153960200361935311512317183678882"
+    mp.dps = 15
+    assert lambertw(x).ae(ans)
+    mp.dps = 50
+    assert lambertw(x).ae(ans)
+    mp.dps = 150
+    assert lambertw(x).ae(ans)
+
+def test_meijerg():
+    mp.dps = 15
+    assert meijerg([[2,3],[1]],[[0.5,2],[3,4]], 2.5).ae(4.2181028074787439386)
+    assert meijerg([[],[1+j]],[[1],[1]], 3+4j).ae(271.46290321152464592 - 703.03330399954820169j)
+    assert meijerg([[0.25],[1]],[[0.5],[2]],0) == 0
+    assert meijerg([[0],[]],[[0,0,'1/3','2/3'], []], '2/27').ae(2.2019391389653314120)
+    # Verify 1/z series being used
+    assert meijerg([[-3],[-0.5]], [[-1],[-2.5]], -0.5).ae(-1.338096165935754898687431)
+    assert meijerg([[1-(-1)],[1-(-2.5)]], [[1-(-3)],[1-(-0.5)]], -2.0).ae(-1.338096165935754898687431)
+    assert meijerg([[-3],[-0.5]], [[-1],[-2.5]], -1).ae(-(pi+4)/(4*pi))
+    a = 2.5
+    b = 1.25
+    for z in [mpf(0.25), mpf(2)]:
+        x1 = hyp1f1(a,b,z)
+        x2 = gamma(b)/gamma(a)*meijerg([[1-a],[]],[[0],[1-b]],-z)
+        x3 = gamma(b)/gamma(a)*meijerg([[1-0],[1-(1-b)]],[[1-(1-a)],[]],-1/z)
+        assert x1.ae(x2)
+        assert x1.ae(x3)
+
+def test_appellf1():
+    mp.dps = 15
+    assert appellf1(2,-2,1,1,2,3).ae(-1.75)
+    assert appellf1(2,1,-2,1,2,3).ae(-8)
+    assert appellf1(2,1,-2,1,0.5,0.25).ae(1.5)
+    assert appellf1(-2,1,3,2,3,3).ae(19)
+    assert appellf1(1,2,3,4,0.5,0.125).ae( 1.53843285792549786518)
+
+def test_coulomb():
+    # Note: most tests are doctests
+    # Test for a bug:
+    mp.dps = 15
+    assert coulombg(mpc(-5,0),2,3).ae(20.087729487721430394)
+
+def test_hyper_param_accuracy():
+    mp.dps = 15
+    As = [n+1e-10 for n in range(-5,-1)]
+    Bs = [n+1e-10 for n in range(-12,-5)]
+    assert hyper(As,Bs,10).ae(-381757055858.652671927)
+    assert legenp(0.5, 100, 0.25).ae(-2.4124576567211311755e+144)
+    assert (hyp1f1(1000,1,-100)*10**24).ae(5.2589445437370169113)
+    assert (hyp2f1(10, -900, 10.5, 0.99)*10**24).ae(1.9185370579660768203)
+    assert (hyp2f1(1000,1.5,-3.5,-1.5)*10**385).ae(-2.7367529051334000764)
+    assert hyp2f1(-5, 10, 3, 0.5, zeroprec=500) == 0
+    assert (hyp1f1(-10000, 1000, 100)*10**424).ae(-3.1046080515824859974)
+    assert (hyp2f1(1000,1.5,-3.5,-0.75,maxterms=100000)*10**231).ae(-4.0534790813913998643)
+    assert legenp(2, 3, 0.25) == 0
+    pytest.raises(ValueError, lambda: hypercomb(lambda a: [([],[],[],[],[a],[-a],0.5)], [3]))
+    assert hypercomb(lambda a: [([],[],[],[],[a],[-a],0.5)], [3], infprec=200) == inf
+    assert meijerg([[],[]],[[0,0,0,0],[]],0.1).ae(1.5680822343832351418)
+    assert (besselk(400,400)*10**94).ae(1.4387057277018550583)
+    mp.dps = 5
+    (hyp1f1(-5000.5, 1500, 100)*10**185).ae(8.5185229673381935522)
+    (hyp1f1(-5000, 1500, 100)*10**185).ae(9.1501213424563944311)
+    mp.dps = 15
+    (hyp1f1(-5000.5, 1500, 100)*10**185).ae(8.5185229673381935522)
+    (hyp1f1(-5000, 1500, 100)*10**185).ae(9.1501213424563944311)
+    assert hyp0f1(fadd(-20,'1e-100',exact=True), 0.25).ae(1.85014429040102783e+49)
+    assert hyp0f1((-20*10**100+1, 10**100), 0.25).ae(1.85014429040102783e+49)
+
+def test_hypercomb_zero_pow():
+    # check that 0^0 = 1
+    assert hypercomb(lambda a: (([0],[a],[],[],[],[],0),), [0]) == 1
+    assert meijerg([[-1.5],[]],[[0],[-0.75]],0).ae(1.4464090846320771425)
+
+def test_spherharm():
+    mp.dps = 15
+    t = 0.5; r = 0.25
+    assert spherharm(0,0,t,r).ae(0.28209479177387814347)
+    assert spherharm(1,-1,t,r).ae(0.16048941205971996369 - 0.04097967481096344271j)
+    assert spherharm(1,0,t,r).ae(0.42878904414183579379)
+    assert spherharm(1,1,t,r).ae(-0.16048941205971996369 - 0.04097967481096344271j)
+    assert spherharm(2,-2,t,r).ae(0.077915886919031181734 - 0.042565643022253962264j)
+    assert spherharm(2,-1,t,r).ae(0.31493387233497459884 - 0.08041582001959297689j)
+    assert spherharm(2,0,t,r).ae(0.41330596756220761898)
+    assert spherharm(2,1,t,r).ae(-0.31493387233497459884 - 0.08041582001959297689j)
+    assert spherharm(2,2,t,r).ae(0.077915886919031181734 + 0.042565643022253962264j)
+    assert spherharm(3,-3,t,r).ae(0.033640236589690881646 - 0.031339125318637082197j)
+    assert spherharm(3,-2,t,r).ae(0.18091018743101461963 - 0.09883168583167010241j)
+    assert spherharm(3,-1,t,r).ae(0.42796713930907320351 - 0.10927795157064962317j)
+    assert spherharm(3,0,t,r).ae(0.27861659336351639787)
+    assert spherharm(3,1,t,r).ae(-0.42796713930907320351 - 0.10927795157064962317j)
+    assert spherharm(3,2,t,r).ae(0.18091018743101461963 + 0.09883168583167010241j)
+    assert spherharm(3,3,t,r).ae(-0.033640236589690881646 - 0.031339125318637082197j)
+    assert spherharm(0,-1,t,r) == 0
+    assert spherharm(0,-2,t,r) == 0
+    assert spherharm(0,1,t,r) == 0
+    assert spherharm(0,2,t,r) == 0
+    assert spherharm(1,2,t,r) == 0
+    assert spherharm(1,3,t,r) == 0
+    assert spherharm(1,-2,t,r) == 0
+    assert spherharm(1,-3,t,r) == 0
+    assert spherharm(2,3,t,r) == 0
+    assert spherharm(2,4,t,r) == 0
+    assert spherharm(2,-3,t,r) == 0
+    assert spherharm(2,-4,t,r) == 0
+    assert spherharm(3,4.5,0.5,0.25).ae(-22.831053442240790148 + 10.910526059510013757j)
+    assert spherharm(2+3j, 1-j, 1+j, 3+4j).ae(-2.6582752037810116935 - 1.0909214905642160211j)
+    assert spherharm(-6,2.5,t,r).ae(0.39383644983851448178 + 0.28414687085358299021j)
+    assert spherharm(-3.5, 3, 0.5, 0.25).ae(0.014516852987544698924 - 0.015582769591477628495j)
+    assert spherharm(-3, 3, 0.5, 0.25) == 0
+    assert spherharm(-6, 3, 0.5, 0.25).ae(-0.16544349818782275459 - 0.15412657723253924562j)
+    assert spherharm(-6, 1.5, 0.5, 0.25).ae(0.032208193499767402477 + 0.012678000924063664921j)
+    assert spherharm(3,0,0,1).ae(0.74635266518023078283)
+    assert spherharm(3,-2,0,1) == 0
+    assert spherharm(3,-2,1,1).ae(-0.16270707338254028971 - 0.35552144137546777097j)
+
+def test_qfunctions():
+    mp.dps = 15
+    assert qp(2,3,100).ae('2.7291482267247332183e2391')
+
+def test_issue_239():
+    mp.prec = 150
+    x = ldexp(2476979795053773,-52)
+    assert betainc(206, 385, 0, 0.55, 1).ae('0.99999999999999999999996570910644857895771110649954')
+    mp.dps = 15
+    pytest.raises(ValueError, lambda: hyp2f1(-5,5,0.5,0.5))
+
+# Extra stress testing for Bessel functions
+# Reference zeros generated with the aid of scipy.special
+# jn_zero, jnp_zero, yn_zero, ynp_zero
+
+V = 15
+M = 15
+
+jn_small_zeros = \
+[[2.4048255576957728,
+  5.5200781102863106,
+  8.6537279129110122,
+  11.791534439014282,
+  14.930917708487786,
+  18.071063967910923,
+  21.211636629879259,
+  24.352471530749303,
+  27.493479132040255,
+  30.634606468431975,
+  33.775820213573569,
+  36.917098353664044,
+  40.058425764628239,
+  43.19979171317673,
+  46.341188371661814],
+ [3.8317059702075123,
+  7.0155866698156188,
+  10.173468135062722,
+  13.323691936314223,
+  16.470630050877633,
+  19.615858510468242,
+  22.760084380592772,
+  25.903672087618383,
+  29.046828534916855,
+  32.189679910974404,
+  35.332307550083865,
+  38.474766234771615,
+  41.617094212814451,
+  44.759318997652822,
+  47.901460887185447],
+ [5.1356223018406826,
+  8.4172441403998649,
+  11.619841172149059,
+  14.795951782351261,
+  17.959819494987826,
+  21.116997053021846,
+  24.270112313573103,
+  27.420573549984557,
+  30.569204495516397,
+  33.7165195092227,
+  36.86285651128381,
+  40.008446733478192,
+  43.153453778371463,
+  46.297996677236919,
+  49.442164110416873],
+ [6.3801618959239835,
+  9.7610231299816697,
+  13.015200721698434,
+  16.223466160318768,
+  19.409415226435012,
+  22.582729593104442,
+  25.748166699294978,
+  28.908350780921758,
+  32.064852407097709,
+  35.218670738610115,
+  38.370472434756944,
+  41.520719670406776,
+  44.669743116617253,
+  47.817785691533302,
+  50.965029906205183],
+ [7.5883424345038044,
+  11.064709488501185,
+  14.37253667161759,
+  17.615966049804833,
+  20.826932956962388,
+  24.01901952477111,
+  27.199087765981251,
+  30.371007667117247,
+  33.537137711819223,
+  36.699001128744649,
+  39.857627302180889,
+  43.01373772335443,
+  46.167853512924375,
+  49.320360686390272,
+  52.471551398458023],
+ [8.771483815959954,
+  12.338604197466944,
+  15.700174079711671,
+  18.980133875179921,
+  22.217799896561268,
+  25.430341154222704,
+  28.626618307291138,
+  31.811716724047763,
+  34.988781294559295,
+  38.159868561967132,
+  41.326383254047406,
+  44.489319123219673,
+  47.649399806697054,
+  50.80716520300633,
+  53.963026558378149],
+ [9.9361095242176849,
+  13.589290170541217,
+  17.003819667816014,
+  20.320789213566506,
+  23.58608443558139,
+  26.820151983411405,
+  30.033722386570469,
+  33.233041762847123,
+  36.422019668258457,
+  39.603239416075404,
+  42.778481613199507,
+  45.949015998042603,
+  49.11577372476426,
+  52.279453903601052,
+  55.440592068853149],
+ [11.086370019245084,
+  14.821268727013171,
+  18.287582832481726,
+  21.641541019848401,
+  24.934927887673022,
+  28.191188459483199,
+  31.42279419226558,
+  34.637089352069324,
+  37.838717382853611,
+  41.030773691585537,
+  44.21540850526126,
+  47.394165755570512,
+  50.568184679795566,
+  53.738325371963291,
+  56.905249991978781],
+ [12.225092264004655,
+  16.037774190887709,
+  19.554536430997055,
+  22.94517313187462,
+  26.266814641176644,
+  29.54565967099855,
+  32.795800037341462,
+  36.025615063869571,
+  39.240447995178135,
+  42.443887743273558,
+  45.638444182199141,
+  48.825930381553857,
+  52.007691456686903,
+  55.184747939289049,
+  58.357889025269694],
+ [13.354300477435331,
+  17.241220382489128,
+  20.807047789264107,
+  24.233885257750552,
+  27.583748963573006,
+  30.885378967696675,
+  34.154377923855096,
+  37.400099977156589,
+  40.628553718964528,
+  43.843801420337347,
+  47.048700737654032,
+  50.245326955305383,
+  53.435227157042058,
+  56.619580266508436,
+  59.799301630960228],
+ [14.475500686554541,
+  18.433463666966583,
+  22.046985364697802,
+  25.509450554182826,
+  28.887375063530457,
+  32.211856199712731,
+  35.499909205373851,
+  38.761807017881651,
+  42.004190236671805,
+  45.231574103535045,
+  48.447151387269394,
+  51.653251668165858,
+  54.851619075963349,
+  58.043587928232478,
+  61.230197977292681],
+ [15.589847884455485,
+  19.61596690396692,
+  23.275853726263409,
+  26.773322545509539,
+  30.17906117878486,
+  33.526364075588624,
+  36.833571341894905,
+  40.111823270954241,
+  43.368360947521711,
+  46.608132676274944,
+  49.834653510396724,
+  53.050498959135054,
+  56.257604715114484,
+  59.457456908388002,
+  62.651217388202912],
+ [16.698249933848246,
+  20.789906360078443,
+  24.494885043881354,
+  28.026709949973129,
+  31.45996003531804,
+  34.829986990290238,
+  38.156377504681354,
+  41.451092307939681,
+  44.721943543191147,
+  47.974293531269048,
+  51.211967004101068,
+  54.437776928325074,
+  57.653844811906946,
+  60.8618046824805,
+  64.062937824850136],
+ [17.801435153282442,
+  21.95624406783631,
+  25.705103053924724,
+  29.270630441874802,
+  32.731053310978403,
+  36.123657666448762,
+  39.469206825243883,
+  42.780439265447158,
+  46.06571091157561,
+  49.330780096443524,
+  52.579769064383396,
+  55.815719876305778,
+  59.040934037249271,
+  62.257189393731728,
+  65.465883797232125],
+ [18.899997953174024,
+  23.115778347252756,
+  26.907368976182104,
+  30.505950163896036,
+  33.993184984781542,
+  37.408185128639695,
+  40.772827853501868,
+  44.100590565798301,
+  47.400347780543231,
+  50.678236946479898,
+  53.93866620912693,
+  57.184898598119301,
+  60.419409852130297,
+  63.644117508962281,
+  66.860533012260103]]
+
+jnp_small_zeros = \
+[[0.0,
+  3.8317059702075123,
+  7.0155866698156188,
+  10.173468135062722,
+  13.323691936314223,
+  16.470630050877633,
+  19.615858510468242,
+  22.760084380592772,
+  25.903672087618383,
+  29.046828534916855,
+  32.189679910974404,
+  35.332307550083865,
+  38.474766234771615,
+  41.617094212814451,
+  44.759318997652822],
+ [1.8411837813406593,
+  5.3314427735250326,
+  8.5363163663462858,
+  11.706004902592064,
+  14.863588633909033,
+  18.015527862681804,
+  21.16436985918879,
+  24.311326857210776,
+  27.457050571059246,
+  30.601922972669094,
+  33.746182898667383,
+  36.889987409236811,
+  40.033444053350675,
+  43.176628965448822,
+  46.319597561173912],
+ [3.0542369282271403,
+  6.7061331941584591,
+  9.9694678230875958,
+  13.170370856016123,
+  16.347522318321783,
+  19.512912782488205,
+  22.671581772477426,
+  25.826037141785263,
+  28.977672772993679,
+  32.127327020443474,
+  35.275535050674691,
+  38.422654817555906,
+  41.568934936074314,
+  44.714553532819734,
+  47.859641607992093],
+ [4.2011889412105285,
+  8.0152365983759522,
+  11.345924310743006,
+  14.585848286167028,
+  17.78874786606647,
+  20.9724769365377,
+  24.144897432909265,
+  27.310057930204349,
+  30.470268806290424,
+  33.626949182796679,
+  36.781020675464386,
+  39.933108623659488,
+  43.083652662375079,
+  46.232971081836478,
+  49.381300092370349],
+ [5.3175531260839944,
+  9.2823962852416123,
+  12.681908442638891,
+  15.964107037731551,
+  19.196028800048905,
+  22.401032267689004,
+  25.589759681386733,
+  28.767836217666503,
+  31.938539340972783,
+  35.103916677346764,
+  38.265316987088158,
+  41.423666498500732,
+  44.579623137359257,
+  47.733667523865744,
+  50.886159153182682],
+ [6.4156163757002403,
+  10.519860873772308,
+  13.9871886301403,
+  17.312842487884625,
+  20.575514521386888,
+  23.803581476593863,
+  27.01030789777772,
+  30.20284907898166,
+  33.385443901010121,
+  36.560777686880356,
+  39.730640230067416,
+  42.896273163494417,
+  46.058566273567043,
+  49.218174614666636,
+  52.375591529563596],
+ [7.501266144684147,
+  11.734935953042708,
+  15.268181461097873,
+  18.637443009666202,
+  21.931715017802236,
+  25.183925599499626,
+  28.409776362510085,
+  31.617875716105035,
+  34.81339298429743,
+  37.999640897715301,
+  41.178849474321413,
+  44.352579199070217,
+  47.521956905768113,
+  50.687817781723741,
+  53.85079463676896],
+ [8.5778364897140741,
+  12.932386237089576,
+  16.529365884366944,
+  19.941853366527342,
+  23.268052926457571,
+  26.545032061823576,
+  29.790748583196614,
+  33.015178641375142,
+  36.224380548787162,
+  39.422274578939259,
+  42.611522172286684,
+  45.793999658055002,
+  48.971070951900596,
+  52.143752969301988,
+  55.312820330403446],
+ [9.6474216519972168,
+  14.115518907894618,
+  17.774012366915256,
+  21.229062622853124,
+  24.587197486317681,
+  27.889269427955092,
+  31.155326556188325,
+  34.39662855427218,
+  37.620078044197086,
+  40.830178681822041,
+  44.030010337966153,
+  47.221758471887113,
+  50.407020967034367,
+  53.586995435398319,
+  56.762598475105272],
+ [10.711433970699945,
+  15.28673766733295,
+  19.004593537946053,
+  22.501398726777283,
+  25.891277276839136,
+  29.218563499936081,
+  32.505247352375523,
+  35.763792928808799,
+  39.001902811514218,
+  42.224638430753279,
+  45.435483097475542,
+  48.636922645305525,
+  51.830783925834728,
+  55.01844255063594,
+  58.200955824859509],
+ [11.770876674955582,
+  16.447852748486498,
+  20.223031412681701,
+  23.760715860327448,
+  27.182021527190532,
+  30.534504754007074,
+  33.841965775135715,
+  37.118000423665604,
+  40.371068905333891,
+  43.606764901379516,
+  46.828959446564562,
+  50.040428970943456,
+  53.243223214220535,
+  56.438892058982552,
+  59.628631306921512],
+ [12.826491228033465,
+  17.600266557468326,
+  21.430854238060294,
+  25.008518704644261,
+  28.460857279654847,
+  31.838424458616998,
+  35.166714427392629,
+  38.460388720328256,
+  41.728625562624312,
+  44.977526250903469,
+  48.211333836373288,
+  51.433105171422278,
+  54.645106240447105,
+  57.849056857839799,
+  61.046288512821078],
+ [13.878843069697276,
+  18.745090916814406,
+  22.629300302835503,
+  26.246047773946584,
+  29.72897816891134,
+  33.131449953571661,
+  36.480548302231658,
+  39.791940718940855,
+  43.075486800191012,
+  46.337772104541405,
+  49.583396417633095,
+  52.815686826850452,
+  56.037118687012179,
+  59.249577075517968,
+  62.454525995970462],
+ [14.928374492964716,
+  19.88322436109951,
+  23.81938909003628,
+  27.474339750968247,
+  30.987394331665278,
+  34.414545662167183,
+  37.784378506209499,
+  41.113512376883377,
+  44.412454519229281,
+  47.688252845993366,
+  50.945849245830813,
+  54.188831071035124,
+  57.419876154678179,
+  60.641030026538746,
+  63.853885828967512],
+ [15.975438807484321,
+  21.015404934568315,
+  25.001971500138194,
+  28.694271223110755,
+  32.236969407878118,
+  35.688544091185301,
+  39.078998185245057,
+  42.425854432866141,
+  45.740236776624833,
+  49.029635055514276,
+  52.299319390331728,
+  55.553127779547459,
+  58.793933759028134,
+  62.02393848337554,
+  65.244860767043859]]
+
+yn_small_zeros = \
+[[0.89357696627916752,
+  3.9576784193148579,
+  7.0860510603017727,
+  10.222345043496417,
+  13.361097473872763,
+  16.500922441528091,
+  19.64130970088794,
+  22.782028047291559,
+  25.922957653180923,
+  29.064030252728398,
+  32.205204116493281,
+  35.346452305214321,
+  38.487756653081537,
+  41.629104466213808,
+  44.770486607221993],
+ [2.197141326031017,
+  5.4296810407941351,
+  8.5960058683311689,
+  11.749154830839881,
+  14.897442128336725,
+  18.043402276727856,
+  21.188068934142213,
+  24.331942571356912,
+  27.475294980449224,
+  30.618286491641115,
+  33.761017796109326,
+  36.90355531614295,
+  40.045944640266876,
+  43.188218097393211,
+  46.330399250701687],
+ [3.3842417671495935,
+  6.7938075132682675,
+  10.023477979360038,
+  13.209986710206416,
+  16.378966558947457,
+  19.539039990286384,
+  22.69395593890929,
+  25.845613720902269,
+  28.995080395650151,
+  32.143002257627551,
+  35.289793869635804,
+  38.435733485446343,
+  41.581014867297885,
+  44.725777117640461,
+  47.870122696676504],
+ [4.5270246611496439,
+  8.0975537628604907,
+  11.396466739595867,
+  14.623077742393873,
+  17.81845523294552,
+  20.997284754187761,
+  24.166235758581828,
+  27.328799850405162,
+  30.486989604098659,
+  33.642049384702463,
+  36.794791029185579,
+  39.945767226378749,
+  43.095367507846703,
+  46.2438744334407,
+  49.391498015725107],
+ [5.6451478942208959,
+  9.3616206152445429,
+  12.730144474090465,
+  15.999627085382479,
+  19.22442895931681,
+  22.424810599698521,
+  25.610267054939328,
+  28.785893657666548,
+  31.954686680031668,
+  35.118529525584828,
+  38.278668089521758,
+  41.435960629910073,
+  44.591018225353424,
+  47.744288086361052,
+  50.896105199722123],
+ [6.7471838248710219,
+  10.597176726782031,
+  14.033804104911233,
+  17.347086393228382,
+  20.602899017175335,
+  23.826536030287532,
+  27.030134937138834,
+  30.220335654231385,
+  33.401105611047908,
+  36.574972486670962,
+  39.743627733020277,
+  42.908248189569535,
+  46.069679073215439,
+  49.228543693445843,
+  52.385312123112282],
+ [7.8377378223268716,
+  11.811037107609447,
+  15.313615118517857,
+  18.670704965906724,
+  21.958290897126571,
+  25.206207715021249,
+  28.429037095235496,
+  31.634879502950644,
+  34.828638524084437,
+  38.013473399691765,
+  41.19151880917741,
+  44.364272633271975,
+  47.53281875312084,
+  50.697961822183806,
+  53.860312300118388],
+ [8.919605734873789,
+  13.007711435388313,
+  16.573915129085334,
+  19.974342312352426,
+  23.293972585596648,
+  26.5667563757203,
+  29.809531451608321,
+  33.031769327150685,
+  36.239265816598239,
+  39.435790312675323,
+  42.623910919472727,
+  45.805442883111651,
+  48.981708325514764,
+  52.153694518185572,
+  55.322154420959698],
+ [9.9946283820824834,
+  14.190361295800141,
+  17.817887841179873,
+  21.26093227125945,
+  24.612576377421522,
+  27.910524883974868,
+  31.173701563441602,
+  34.412862242025045,
+  37.634648706110989,
+  40.843415321050884,
+  44.04214994542435,
+  47.232978012841169,
+  50.417456447370186,
+  53.596753874948731,
+  56.771765754432457],
+ [11.064090256031013,
+  15.361301343575925,
+  19.047949646361388,
+  22.532765416313869,
+  25.91620496332662,
+  29.2394205079349,
+  32.523270869465881,
+  35.779715464475261,
+  39.016196664616095,
+  42.237627509803703,
+  45.4474001519274,
+  48.647941127433196,
+  51.841036928216499,
+  55.028034667184916,
+  58.209970905250097],
+ [12.128927704415439,
+  16.522284394784426,
+  20.265984501212254,
+  23.791669719454272,
+  27.206568881574774,
+  30.555020011020762,
+  33.859683872746356,
+  37.133649760307504,
+  40.385117593813002,
+  43.619533085646856,
+  46.840676630553575,
+  50.051265851897857,
+  53.253310556711732,
+  56.448332488918971,
+  59.637507005589829],
+ [13.189846995683845,
+  17.674674253171487,
+  21.473493977824902,
+  25.03913093040942,
+  28.485081336558058,
+  31.858644293774859,
+  35.184165245422787,
+  38.475796636190897,
+  41.742455848758449,
+  44.990096293791186,
+  48.222870660068338,
+  51.443777308699826,
+  54.655042589416311,
+  57.858358441436511,
+  61.055036135780528],
+ [14.247395665073945,
+  18.819555894710682,
+  22.671697117872794,
+  26.276375544903892,
+  29.752925495549038,
+  33.151412708998983,
+  36.497763772987645,
+  39.807134090704376,
+  43.089121522203808,
+  46.350163579538652,
+  49.594769786270069,
+  52.82620892320143,
+  56.046916910756961,
+  59.258751140598783,
+  62.463155567737854],
+ [15.30200785858925,
+  19.957808654258601,
+  23.861599172945054,
+  27.504429642227545,
+  31.011103429019229,
+  34.434283425782942,
+  37.801385632318459,
+  41.128514139788358,
+  44.425913324440663,
+  47.700482714581842,
+  50.957073905278458,
+  54.199216028087261,
+  57.429547607017405,
+  60.65008661807661,
+  63.862406280068586],
+ [16.354034360047551,
+  21.090156519983806,
+  25.044040298785627,
+  28.724161640881914,
+  32.260472459522644,
+  35.708083982611664,
+  39.095820003878235,
+  42.440684315990936,
+  45.75353669045622,
+  49.041718113283529,
+  52.310408280968073,
+  55.56338698149062,
+  58.803488508906895,
+  62.032886550960831,
+  65.253280088312461]]
+
+ynp_small_zeros = \
+[[2.197141326031017,
+  5.4296810407941351,
+  8.5960058683311689,
+  11.749154830839881,
+  14.897442128336725,
+  18.043402276727856,
+  21.188068934142213,
+  24.331942571356912,
+  27.475294980449224,
+  30.618286491641115,
+  33.761017796109326,
+  36.90355531614295,
+  40.045944640266876,
+  43.188218097393211,
+  46.330399250701687],
+ [3.6830228565851777,
+  6.9414999536541757,
+  10.123404655436613,
+  13.285758156782854,
+  16.440058007293282,
+  19.590241756629495,
+  22.738034717396327,
+  25.884314618788867,
+  29.029575819372535,
+  32.174118233366201,
+  35.318134458192094,
+  38.461753870997549,
+  41.605066618873108,
+  44.74813744908079,
+  47.891014070791065],
+ [5.0025829314460639,
+  8.3507247014130795,
+  11.574195465217647,
+  14.760909306207676,
+  17.931285939466855,
+  21.092894504412739,
+  24.249231678519058,
+  27.402145837145258,
+  30.552708880564553,
+  33.70158627151572,
+  36.849213419846257,
+  39.995887376143356,
+  43.141817835750686,
+  46.287157097544201,
+  49.432018469138281],
+ [6.2536332084598136,
+  9.6987879841487711,
+  12.972409052292216,
+  16.19044719506921,
+  19.38238844973613,
+  22.559791857764261,
+  25.728213194724094,
+  28.890678419054777,
+  32.048984005266337,
+  35.204266606440635,
+  38.357281675961019,
+  41.508551443818436,
+  44.658448731963676,
+  47.807246956681162,
+  50.95515126455207],
+ [7.4649217367571329,
+  11.005169149809189,
+  14.3317235192331,
+  17.58443601710272,
+  20.801062338411128,
+  23.997004122902644,
+  27.179886689853435,
+  30.353960608554323,
+  33.521797098666792,
+  36.685048382072301,
+  39.844826969405863,
+  43.001910515625288,
+  46.15685955107263,
+  49.310088614282257,
+  52.461911043685864],
+ [8.6495562436971983,
+  12.280868725807848,
+  15.660799304540377,
+  18.949739756016503,
+  22.192841809428241,
+  25.409072788867674,
+  28.608039283077593,
+  31.795195353138159,
+  34.973890634255288,
+  38.14630522169358,
+  41.313923188794905,
+  44.477791768537617,
+  47.638672065035628,
+  50.797131066967842,
+  53.953600129601663],
+ [9.8147970120105779,
+  13.532811875789828,
+  16.965526446046053,
+  20.291285512443867,
+  23.56186260680065,
+  26.799499736027237,
+  30.015665481543419,
+  33.216968050039509,
+  36.407516858984748,
+  39.590015243560459,
+  42.766320595957378,
+  45.937754257017323,
+  49.105283450953203,
+  52.269633324547373,
+  55.431358715604255],
+ [10.965152105242974,
+  14.765687379508912,
+  18.250123150217555,
+  21.612750053384621,
+  24.911310600813573,
+  28.171051927637585,
+  31.40518108895689,
+  34.621401012564177,
+  37.824552065973114,
+  41.017847386464902,
+  44.203512240871601,
+  47.3831408366063,
+  50.557907466622796,
+  53.728697478957026,
+  56.896191727313342],
+ [12.103641941939539,
+  15.982840905145284,
+  19.517731005559611,
+  22.916962141504605,
+  26.243700855690533,
+  29.525960140695407,
+  32.778568197561124,
+  36.010261572392516,
+  39.226578757802172,
+  42.43122493258747,
+  45.626783824134354,
+  48.815117837929515,
+  51.997606404328863,
+  55.175294723956816,
+  58.348990221754937],
+ [13.232403808592215,
+  17.186756572616758,
+  20.770762917490496,
+  24.206152448722253,
+  27.561059462697153,
+  30.866053571250639,
+  34.137476603379774,
+  37.385039772270268,
+  40.614946085165892,
+  43.831373184731238,
+  47.037251786726299,
+  50.234705848765229,
+  53.425316228549359,
+  56.610286079882087,
+  59.790548623216652],
+ [14.35301374369987,
+  18.379337301642568,
+  22.011118775283494,
+  25.482116178696707,
+  28.865046588695164,
+  32.192853922166294,
+  35.483296655830277,
+  38.747005493021857,
+  41.990815194320955,
+  45.219355876831731,
+  48.435892856078888,
+  51.642803925173029,
+  54.84186659475857,
+  58.034439083840155,
+  61.221578745109862],
+ [15.466672066554263,
+  19.562077985759503,
+  23.240325531101082,
+  26.746322986645901,
+  30.157042415639891,
+  33.507642948240263,
+  36.817212798512775,
+  40.097251300178642,
+  43.355193847719752,
+  46.596103410173672,
+  49.823567279972794,
+  53.040208868780832,
+  56.247996968470062,
+  59.448441365714251,
+  62.642721301357187],
+ [16.574317035530872,
+  20.73617763753932,
+  24.459631728238804,
+  27.999993668839644,
+  31.438208790267783,
+  34.811512070805535,
+  38.140243708611251,
+  41.436725143893739,
+  44.708963264433333,
+  47.962435051891027,
+  51.201037321915983,
+  54.427630745992975,
+  57.644369734615238,
+  60.852911791989989,
+  64.054555435720397],
+ [17.676697936439624,
+  21.9026148697762,
+  25.670073356263225,
+  29.244155124266438,
+  32.709534477396028,
+  36.105399554497548,
+  39.453272918267025,
+  42.766255701958017,
+  46.052899215578358,
+  49.319076602061401,
+  52.568982147952547,
+  55.805705507386287,
+  59.031580956740466,
+  62.248409689597653,
+  65.457606670836759],
+ [18.774423978290318,
+  23.06220035979272,
+  26.872520985976736,
+  30.479680663499762,
+  33.971869047372436,
+  37.390118854896324,
+  40.757072537673599,
+  44.086572292170345,
+  47.387688809191869,
+  50.66667461073936,
+  53.928009929563275,
+  57.175005343085052,
+  60.410169281219877,
+  63.635442539153021,
+  66.85235358587768]]
+
+@pytest.mark.slow
+def test_bessel_zeros_extra():
+    mp.dps = 15
+    for v in range(V):
+        for m in range(1,M+1):
+            print(v, m, "of", V, M)
+            # Twice to test cache (if used)
+            assert besseljzero(v,m).ae(jn_small_zeros[v][m-1])
+            assert besseljzero(v,m).ae(jn_small_zeros[v][m-1])
+            assert besseljzero(v,m,1).ae(jnp_small_zeros[v][m-1])
+            assert besseljzero(v,m,1).ae(jnp_small_zeros[v][m-1])
+            assert besselyzero(v,m).ae(yn_small_zeros[v][m-1])
+            assert besselyzero(v,m).ae(yn_small_zeros[v][m-1])
+            assert besselyzero(v,m,1).ae(ynp_small_zeros[v][m-1])
+            assert besselyzero(v,m,1).ae(ynp_small_zeros[v][m-1])
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_gammazeta.py b/lib/python3.10/site-packages/mpmath/tests/test_gammazeta.py
new file mode 100644
index 0000000000000000000000000000000000000000..6a18a7964d746561dfd5f81177cd78ccc46d2a5d
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_gammazeta.py
@@ -0,0 +1,698 @@
+from mpmath import *
+from mpmath.libmp import round_up, from_float, mpf_zeta_int
+
+def test_zeta_int_bug():
+    assert mpf_zeta_int(0, 10) == from_float(-0.5)
+
+def test_bernoulli():
+    assert bernfrac(0) == (1,1)
+    assert bernfrac(1) == (-1,2)
+    assert bernfrac(2) == (1,6)
+    assert bernfrac(3) == (0,1)
+    assert bernfrac(4) == (-1,30)
+    assert bernfrac(5) == (0,1)
+    assert bernfrac(6) == (1,42)
+    assert bernfrac(8) == (-1,30)
+    assert bernfrac(10) == (5,66)
+    assert bernfrac(12) == (-691,2730)
+    assert bernfrac(18) == (43867,798)
+    p, q = bernfrac(228)
+    assert p % 10**10 == 164918161
+    assert q == 625170
+    p, q = bernfrac(1000)
+    assert p % 10**10 == 7950421099
+    assert q == 342999030
+    mp.dps = 15
+    assert bernoulli(0) == 1
+    assert bernoulli(1) == -0.5
+    assert bernoulli(2).ae(1./6)
+    assert bernoulli(3) == 0
+    assert bernoulli(4).ae(-1./30)
+    assert bernoulli(5) == 0
+    assert bernoulli(6).ae(1./42)
+    assert str(bernoulli(10)) == '0.0757575757575758'
+    assert str(bernoulli(234)) == '7.62772793964344e+267'
+    assert str(bernoulli(10**5)) == '-5.82229431461335e+376755'
+    assert str(bernoulli(10**8+2)) == '1.19570355039953e+676752584'
+
+    mp.dps = 50
+    assert str(bernoulli(10)) == '0.075757575757575757575757575757575757575757575757576'
+    assert str(bernoulli(234)) == '7.6277279396434392486994969020496121553385863373331e+267'
+    assert str(bernoulli(10**5)) == '-5.8222943146133508236497045360612887555320691004308e+376755'
+    assert str(bernoulli(10**8+2)) == '1.1957035503995297272263047884604346914602088317782e+676752584'
+
+    mp.dps = 1000
+    assert bernoulli(10).ae(mpf(5)/66)
+
+    mp.dps = 50000
+    assert bernoulli(10).ae(mpf(5)/66)
+
+    mp.dps = 15
+
+def test_bernpoly_eulerpoly():
+    mp.dps = 15
+    assert bernpoly(0,-1).ae(1)
+    assert bernpoly(0,0).ae(1)
+    assert bernpoly(0,'1/2').ae(1)
+    assert bernpoly(0,'3/4').ae(1)
+    assert bernpoly(0,1).ae(1)
+    assert bernpoly(0,2).ae(1)
+    assert bernpoly(1,-1).ae('-3/2')
+    assert bernpoly(1,0).ae('-1/2')
+    assert bernpoly(1,'1/2').ae(0)
+    assert bernpoly(1,'3/4').ae('1/4')
+    assert bernpoly(1,1).ae('1/2')
+    assert bernpoly(1,2).ae('3/2')
+    assert bernpoly(2,-1).ae('13/6')
+    assert bernpoly(2,0).ae('1/6')
+    assert bernpoly(2,'1/2').ae('-1/12')
+    assert bernpoly(2,'3/4').ae('-1/48')
+    assert bernpoly(2,1).ae('1/6')
+    assert bernpoly(2,2).ae('13/6')
+    assert bernpoly(3,-1).ae(-3)
+    assert bernpoly(3,0).ae(0)
+    assert bernpoly(3,'1/2').ae(0)
+    assert bernpoly(3,'3/4').ae('-3/64')
+    assert bernpoly(3,1).ae(0)
+    assert bernpoly(3,2).ae(3)
+    assert bernpoly(4,-1).ae('119/30')
+    assert bernpoly(4,0).ae('-1/30')
+    assert bernpoly(4,'1/2').ae('7/240')
+    assert bernpoly(4,'3/4').ae('7/3840')
+    assert bernpoly(4,1).ae('-1/30')
+    assert bernpoly(4,2).ae('119/30')
+    assert bernpoly(5,-1).ae(-5)
+    assert bernpoly(5,0).ae(0)
+    assert bernpoly(5,'1/2').ae(0)
+    assert bernpoly(5,'3/4').ae('25/1024')
+    assert bernpoly(5,1).ae(0)
+    assert bernpoly(5,2).ae(5)
+    assert bernpoly(10,-1).ae('665/66')
+    assert bernpoly(10,0).ae('5/66')
+    assert bernpoly(10,'1/2').ae('-2555/33792')
+    assert bernpoly(10,'3/4').ae('-2555/34603008')
+    assert bernpoly(10,1).ae('5/66')
+    assert bernpoly(10,2).ae('665/66')
+    assert bernpoly(11,-1).ae(-11)
+    assert bernpoly(11,0).ae(0)
+    assert bernpoly(11,'1/2').ae(0)
+    assert bernpoly(11,'3/4').ae('-555731/4194304')
+    assert bernpoly(11,1).ae(0)
+    assert bernpoly(11,2).ae(11)
+    assert eulerpoly(0,-1).ae(1)
+    assert eulerpoly(0,0).ae(1)
+    assert eulerpoly(0,'1/2').ae(1)
+    assert eulerpoly(0,'3/4').ae(1)
+    assert eulerpoly(0,1).ae(1)
+    assert eulerpoly(0,2).ae(1)
+    assert eulerpoly(1,-1).ae('-3/2')
+    assert eulerpoly(1,0).ae('-1/2')
+    assert eulerpoly(1,'1/2').ae(0)
+    assert eulerpoly(1,'3/4').ae('1/4')
+    assert eulerpoly(1,1).ae('1/2')
+    assert eulerpoly(1,2).ae('3/2')
+    assert eulerpoly(2,-1).ae(2)
+    assert eulerpoly(2,0).ae(0)
+    assert eulerpoly(2,'1/2').ae('-1/4')
+    assert eulerpoly(2,'3/4').ae('-3/16')
+    assert eulerpoly(2,1).ae(0)
+    assert eulerpoly(2,2).ae(2)
+    assert eulerpoly(3,-1).ae('-9/4')
+    assert eulerpoly(3,0).ae('1/4')
+    assert eulerpoly(3,'1/2').ae(0)
+    assert eulerpoly(3,'3/4').ae('-11/64')
+    assert eulerpoly(3,1).ae('-1/4')
+    assert eulerpoly(3,2).ae('9/4')
+    assert eulerpoly(4,-1).ae(2)
+    assert eulerpoly(4,0).ae(0)
+    assert eulerpoly(4,'1/2').ae('5/16')
+    assert eulerpoly(4,'3/4').ae('57/256')
+    assert eulerpoly(4,1).ae(0)
+    assert eulerpoly(4,2).ae(2)
+    assert eulerpoly(5,-1).ae('-3/2')
+    assert eulerpoly(5,0).ae('-1/2')
+    assert eulerpoly(5,'1/2').ae(0)
+    assert eulerpoly(5,'3/4').ae('361/1024')
+    assert eulerpoly(5,1).ae('1/2')
+    assert eulerpoly(5,2).ae('3/2')
+    assert eulerpoly(10,-1).ae(2)
+    assert eulerpoly(10,0).ae(0)
+    assert eulerpoly(10,'1/2').ae('-50521/1024')
+    assert eulerpoly(10,'3/4').ae('-36581523/1048576')
+    assert eulerpoly(10,1).ae(0)
+    assert eulerpoly(10,2).ae(2)
+    assert eulerpoly(11,-1).ae('-699/4')
+    assert eulerpoly(11,0).ae('691/4')
+    assert eulerpoly(11,'1/2').ae(0)
+    assert eulerpoly(11,'3/4').ae('-512343611/4194304')
+    assert eulerpoly(11,1).ae('-691/4')
+    assert eulerpoly(11,2).ae('699/4')
+    # Potential accuracy issues
+    assert bernpoly(10000,10000).ae('5.8196915936323387117e+39999')
+    assert bernpoly(200,17.5).ae(3.8048418524583064909e244)
+    assert eulerpoly(200,17.5).ae(-3.7309911582655785929e275)
+
+def test_gamma():
+    mp.dps = 15
+    assert gamma(0.25).ae(3.6256099082219083119)
+    assert gamma(0.0001).ae(9999.4228832316241908)
+    assert gamma(300).ae('1.0201917073881354535e612')
+    assert gamma(-0.5).ae(-3.5449077018110320546)
+    assert gamma(-7.43).ae(0.00026524416464197007186)
+    #assert gamma(Rational(1,2)) == gamma(0.5)
+    #assert gamma(Rational(-7,3)).ae(gamma(mpf(-7)/3))
+    assert gamma(1+1j).ae(0.49801566811835604271 - 0.15494982830181068512j)
+    assert gamma(-1+0.01j).ae(-0.422733904013474115 + 99.985883082635367436j)
+    assert gamma(20+30j).ae(-1453876687.5534810 + 1163777777.8031573j)
+    # Should always give exact factorials when they can
+    # be represented as mpfs under the current working precision
+    fact = 1
+    for i in range(1, 18):
+        assert gamma(i) == fact
+        fact *= i
+    for dps in [170, 600]:
+        fact = 1
+        mp.dps = dps
+        for i in range(1, 105):
+            assert gamma(i) == fact
+            fact *= i
+    mp.dps = 100
+    assert gamma(0.5).ae(sqrt(pi))
+    mp.dps = 15
+    assert factorial(0) == fac(0) == 1
+    assert factorial(3) == 6
+    assert isnan(gamma(nan))
+    assert gamma(1100).ae('4.8579168073569433667e2866')
+    assert rgamma(0) == 0
+    assert rgamma(-1) == 0
+    assert rgamma(2) == 1.0
+    assert rgamma(3) == 0.5
+    assert loggamma(2+8j).ae(-8.5205176753667636926 + 10.8569497125597429366j)
+    assert loggamma('1e10000').ae('2.302485092994045684017991e10004')
+    assert loggamma('1e10000j').ae(mpc('-1.570796326794896619231322e10000','2.302485092994045684017991e10004'))
+
+def test_fac2():
+    mp.dps = 15
+    assert [fac2(n) for n in range(10)] == [1,1,2,3,8,15,48,105,384,945]
+    assert fac2(-5).ae(1./3)
+    assert fac2(-11).ae(-1./945)
+    assert fac2(50).ae(5.20469842636666623e32)
+    assert fac2(0.5+0.75j).ae(0.81546769394688069176-0.34901016085573266889j)
+    assert fac2(inf) == inf
+    assert isnan(fac2(-inf))
+
+def test_gamma_quotients():
+    mp.dps = 15
+    h = 1e-8
+    ep = 1e-4
+    G = gamma
+    assert gammaprod([-1],[-3,-4]) == 0
+    assert gammaprod([-1,0],[-5]) == inf
+    assert abs(gammaprod([-1],[-2]) - G(-1+h)/G(-2+h)) < 1e-4
+    assert abs(gammaprod([-4,-3],[-2,0]) - G(-4+h)*G(-3+h)/G(-2+h)/G(0+h)) < 1e-4
+    assert rf(3,0) == 1
+    assert rf(2.5,1) == 2.5
+    assert rf(-5,2) == 20
+    assert rf(j,j).ae(gamma(2*j)/gamma(j))
+    assert rf('-255.5815971722918','-0.5119253100282322').ae('-0.1952720278805729485')  # issue 421
+    assert ff(-2,0) == 1
+    assert ff(-2,1) == -2
+    assert ff(4,3) == 24
+    assert ff(3,4) == 0
+    assert binomial(0,0) == 1
+    assert binomial(1,0) == 1
+    assert binomial(0,-1) == 0
+    assert binomial(3,2) == 3
+    assert binomial(5,2) == 10
+    assert binomial(5,3) == 10
+    assert binomial(5,5) == 1
+    assert binomial(-1,0) == 1
+    assert binomial(-2,-4) == 3
+    assert binomial(4.5, 1.5) == 6.5625
+    assert binomial(1100,1) == 1100
+    assert binomial(1100,2) == 604450
+    assert beta(1,1) == 1
+    assert beta(0,0) == inf
+    assert beta(3,0) == inf
+    assert beta(-1,-1) == inf
+    assert beta(1.5,1).ae(2/3.)
+    assert beta(1.5,2.5).ae(pi/16)
+    assert (10**15*beta(10,100)).ae(2.3455339739604649879)
+    assert beta(inf,inf) == 0
+    assert isnan(beta(-inf,inf))
+    assert isnan(beta(-3,inf))
+    assert isnan(beta(0,inf))
+    assert beta(inf,0.5) == beta(0.5,inf) == 0
+    assert beta(inf,-1.5) == inf
+    assert beta(inf,-0.5) == -inf
+    assert beta(1+2j,-1-j/2).ae(1.16396542451069943086+0.08511695947832914640j)
+    assert beta(-0.5,0.5) == 0
+    assert beta(-3,3).ae(-1/3.)
+    assert beta('-255.5815971722918','-0.5119253100282322').ae('18.157330562703710339')  # issue 421
+
+def test_zeta():
+    mp.dps = 15
+    assert zeta(2).ae(pi**2 / 6)
+    assert zeta(2.0).ae(pi**2 / 6)
+    assert zeta(mpc(2)).ae(pi**2 / 6)
+    assert zeta(100).ae(1)
+    assert zeta(0).ae(-0.5)
+    assert zeta(0.5).ae(-1.46035450880958681)
+    assert zeta(-1).ae(-mpf(1)/12)
+    assert zeta(-2) == 0
+    assert zeta(-3).ae(mpf(1)/120)
+    assert zeta(-4) == 0
+    assert zeta(-100) == 0
+    assert isnan(zeta(nan))
+    assert zeta(1e-30).ae(-0.5)
+    assert zeta(-1e-30).ae(-0.5)
+    # Zeros in the critical strip
+    assert zeta(mpc(0.5, 14.1347251417346937904)).ae(0)
+    assert zeta(mpc(0.5, 21.0220396387715549926)).ae(0)
+    assert zeta(mpc(0.5, 25.0108575801456887632)).ae(0)
+    assert zeta(mpc(1e-30,1e-40)).ae(-0.5)
+    assert zeta(mpc(-1e-30,1e-40)).ae(-0.5)
+    mp.dps = 50
+    im = '236.5242296658162058024755079556629786895294952121891237'
+    assert zeta(mpc(0.5, im)).ae(0, 1e-46)
+    mp.dps = 15
+    # Complex reflection formula
+    assert (zeta(-60+3j) / 10**34).ae(8.6270183987866146+15.337398548226238j)
+    # issue #358
+    assert zeta(0,0.5) == 0
+    assert zeta(0,0) == 0.5
+    assert zeta(0,0.5,1).ae(-0.34657359027997265)
+    # see issue #390
+    assert zeta(-1.5,0.5j).ae(-0.13671400162512768475 + 0.11411333638426559139j)
+
+def test_altzeta():
+    mp.dps = 15
+    assert altzeta(-2) == 0
+    assert altzeta(-4) == 0
+    assert altzeta(-100) == 0
+    assert altzeta(0) == 0.5
+    assert altzeta(-1) == 0.25
+    assert altzeta(-3) == -0.125
+    assert altzeta(-5) == 0.25
+    assert altzeta(-21) == 1180529130.25
+    assert altzeta(1).ae(log(2))
+    assert altzeta(2).ae(pi**2/12)
+    assert altzeta(10).ae(73*pi**10/6842880)
+    assert altzeta(50) < 1
+    assert altzeta(60, rounding='d') < 1
+    assert altzeta(60, rounding='u') == 1
+    assert altzeta(10000, rounding='d') < 1
+    assert altzeta(10000, rounding='u') == 1
+    assert altzeta(3+0j) == altzeta(3)
+    s = 3+4j
+    assert altzeta(s).ae((1-2**(1-s))*zeta(s))
+    s = -3+4j
+    assert altzeta(s).ae((1-2**(1-s))*zeta(s))
+    assert altzeta(-100.5).ae(4.58595480083585913e+108)
+    assert altzeta(1.3).ae(0.73821404216623045)
+    assert altzeta(1e-30).ae(0.5)
+    assert altzeta(-1e-30).ae(0.5)
+    assert altzeta(mpc(1e-30,1e-40)).ae(0.5)
+    assert altzeta(mpc(-1e-30,1e-40)).ae(0.5)
+
+def test_zeta_huge():
+    mp.dps = 15
+    assert zeta(inf) == 1
+    mp.dps = 50
+    assert zeta(100).ae('1.0000000000000000000000000000007888609052210118073522')
+    assert zeta(40*pi).ae('1.0000000000000000000000000000000000000148407238666182')
+    mp.dps = 10000
+    v = zeta(33000)
+    mp.dps = 15
+    assert str(v-1) == '1.02363019598118e-9934'
+    assert zeta(pi*1000, rounding=round_up) > 1
+    assert zeta(3000, rounding=round_up) > 1
+    assert zeta(pi*1000) == 1
+    assert zeta(3000) == 1
+
+def test_zeta_negative():
+    mp.dps = 150
+    a = -pi*10**40
+    mp.dps = 15
+    assert str(zeta(a)) == '2.55880492708712e+1233536161668617575553892558646631323374078'
+    mp.dps = 50
+    assert str(zeta(a)) == '2.5588049270871154960875033337384432038436330847333e+1233536161668617575553892558646631323374078'
+    mp.dps = 15
+
+def test_polygamma():
+    mp.dps = 15
+    psi0 = lambda z: psi(0,z)
+    psi1 = lambda z: psi(1,z)
+    assert psi0(3) == psi(0,3) == digamma(3)
+    #assert psi2(3) == psi(2,3) == tetragamma(3)
+    #assert psi3(3) == psi(3,3) == pentagamma(3)
+    assert psi0(pi).ae(0.97721330794200673)
+    assert psi0(-pi).ae(7.8859523853854902)
+    assert psi0(-pi+1).ae(7.5676424992016996)
+    assert psi0(pi+j).ae(1.04224048313859376 + 0.35853686544063749j)
+    assert psi0(-pi-j).ae(1.3404026194821986 - 2.8824392476809402j)
+    assert findroot(psi0, 1).ae(1.4616321449683622)
+    assert psi0(1e-10).ae(-10000000000.57722)
+    assert psi0(1e-40).ae(-1.000000000000000e+40)
+    assert psi0(1e-10+1e-10j).ae(-5000000000.577215 + 5000000000.000000j)
+    assert psi0(1e-40+1e-40j).ae(-5.000000000000000e+39 + 5.000000000000000e+39j)
+    assert psi0(inf) == inf
+    assert psi1(inf) == 0
+    assert psi(2,inf) == 0
+    assert psi1(pi).ae(0.37424376965420049)
+    assert psi1(-pi).ae(53.030438740085385)
+    assert psi1(pi+j).ae(0.32935710377142464 - 0.12222163911221135j)
+    assert psi1(-pi-j).ae(-0.30065008356019703 + 0.01149892486928227j)
+    assert (10**6*psi(4,1+10*pi*j)).ae(-6.1491803479004446 - 0.3921316371664063j)
+    assert psi0(1+10*pi*j).ae(3.4473994217222650 + 1.5548808324857071j)
+    assert isnan(psi0(nan))
+    assert isnan(psi0(-inf))
+    assert psi0(-100.5).ae(4.615124601338064)
+    assert psi0(3+0j).ae(psi0(3))
+    assert psi0(-100+3j).ae(4.6106071768714086321+3.1117510556817394626j)
+    assert isnan(psi(2,mpc(0,inf)))
+    assert isnan(psi(2,mpc(0,nan)))
+    assert isnan(psi(2,mpc(0,-inf)))
+    assert isnan(psi(2,mpc(1,inf)))
+    assert isnan(psi(2,mpc(1,nan)))
+    assert isnan(psi(2,mpc(1,-inf)))
+    assert isnan(psi(2,mpc(inf,inf)))
+    assert isnan(psi(2,mpc(nan,nan)))
+    assert isnan(psi(2,mpc(-inf,-inf)))
+    mp.dps = 30
+    # issue #534
+    assert digamma(-0.75+1j).ae(mpc('0.46317279488182026118963809283042317', '2.4821070143037957102007677817351115'))
+    mp.dps = 15
+
+def test_polygamma_high_prec():
+    mp.dps = 100
+    assert str(psi(0,pi)) == "0.9772133079420067332920694864061823436408346099943256380095232865318105924777141317302075654362928734"
+    assert str(psi(10,pi)) == "-12.98876181434889529310283769414222588307175962213707170773803550518307617769657562747174101900659238"
+
+def test_polygamma_identities():
+    mp.dps = 15
+    psi0 = lambda z: psi(0,z)
+    psi1 = lambda z: psi(1,z)
+    psi2 = lambda z: psi(2,z)
+    assert psi0(0.5).ae(-euler-2*log(2))
+    assert psi0(1).ae(-euler)
+    assert psi1(0.5).ae(0.5*pi**2)
+    assert psi1(1).ae(pi**2/6)
+    assert psi1(0.25).ae(pi**2 + 8*catalan)
+    assert psi2(1).ae(-2*apery)
+    mp.dps = 20
+    u = -182*apery+4*sqrt(3)*pi**3
+    mp.dps = 15
+    assert psi(2,5/6.).ae(u)
+    assert psi(3,0.5).ae(pi**4)
+
+def test_foxtrot_identity():
+    # A test of the complex digamma function.
+    # See http://mathworld.wolfram.com/FoxTrotSeries.html and
+    # http://mathworld.wolfram.com/DigammaFunction.html
+    psi0 = lambda z: psi(0,z)
+    mp.dps = 50
+    a = (-1)**fraction(1,3)
+    b = (-1)**fraction(2,3)
+    x = -psi0(0.5*a) - psi0(-0.5*b) + psi0(0.5*(1+a)) + psi0(0.5*(1-b))
+    y = 2*pi*sech(0.5*sqrt(3)*pi)
+    assert x.ae(y)
+    mp.dps = 15
+
+def test_polygamma_high_order():
+    mp.dps = 100
+    assert str(psi(50, pi)) == "-1344100348958402765749252447726432491812.641985273160531055707095989227897753035823152397679626136483"
+    assert str(psi(50, pi + 14*e)) == "-0.00000000000000000189793739550804321623512073101895801993019919886375952881053090844591920308111549337295143780341396"
+    assert str(psi(50, pi + 14*e*j)) == ("(-0.0000000000000000522516941152169248975225472155683565752375889510631513244785"
+        "9377385233700094871256507814151956624433 - 0.00000000000000001813157041407010184"
+        "702414110218205348527862196327980417757665282244728963891298080199341480881811613j)")
+    mp.dps = 15
+    assert str(psi(50, pi)) == "-1.34410034895841e+39"
+    assert str(psi(50, pi + 14*e)) == "-1.89793739550804e-18"
+    assert str(psi(50, pi + 14*e*j)) == "(-5.2251694115217e-17 - 1.81315704140701e-17j)"
+
+def test_harmonic():
+    mp.dps = 15
+    assert harmonic(0) == 0
+    assert harmonic(1) == 1
+    assert harmonic(2) == 1.5
+    assert harmonic(3).ae(1. + 1./2 + 1./3)
+    assert harmonic(10**10).ae(23.603066594891989701)
+    assert harmonic(10**1000).ae(2303.162308658947)
+    assert harmonic(0.5).ae(2-2*log(2))
+    assert harmonic(inf) == inf
+    assert harmonic(2+0j) == 1.5+0j
+    assert harmonic(1+2j).ae(1.4918071802755104+0.92080728264223022j)
+
+def test_gamma_huge_1():
+    mp.dps = 500
+    x = mpf(10**10) / 7
+    mp.dps = 15
+    assert str(gamma(x)) == "6.26075321389519e+12458010678"
+    mp.dps = 50
+    assert str(gamma(x)) == "6.2607532138951929201303779291707455874010420783933e+12458010678"
+    mp.dps = 15
+
+def test_gamma_huge_2():
+    mp.dps = 500
+    x = mpf(10**100) / 19
+    mp.dps = 15
+    assert str(gamma(x)) == (\
+        "1.82341134776679e+5172997469323364168990133558175077136829182824042201886051511"
+        "9656908623426021308685461258226190190661")
+    mp.dps = 50
+    assert str(gamma(x)) == (\
+        "1.82341134776678875374414910350027596939980412984e+5172997469323364168990133558"
+        "1750771368291828240422018860515119656908623426021308685461258226190190661")
+
+def test_gamma_huge_3():
+    mp.dps = 500
+    x = 10**80 // 3 + 10**70*j / 7
+    mp.dps = 15
+    y = gamma(x)
+    assert str(y.real) == (\
+        "-6.82925203918106e+2636286142112569524501781477865238132302397236429627932441916"
+        "056964386399485392600")
+    assert str(y.imag) == (\
+        "8.54647143678418e+26362861421125695245017814778652381323023972364296279324419160"
+        "56964386399485392600")
+    mp.dps = 50
+    y = gamma(x)
+    assert str(y.real) == (\
+        "-6.8292520391810548460682736226799637356016538421817e+26362861421125695245017814"
+        "77865238132302397236429627932441916056964386399485392600")
+    assert str(y.imag) == (\
+        "8.5464714367841748507479306948130687511711420234015e+263628614211256952450178147"
+        "7865238132302397236429627932441916056964386399485392600")
+
+def test_gamma_huge_4():
+    x = 3200+11500j
+    mp.dps = 15
+    assert str(gamma(x)) == \
+        "(8.95783268539713e+5164 - 1.94678798329735e+5164j)"
+    mp.dps = 50
+    assert str(gamma(x)) == (\
+        "(8.9578326853971339570292952697675570822206567327092e+5164"
+        " - 1.9467879832973509568895402139429643650329524144794e+51"
+        "64j)")
+    mp.dps = 15
+
+def test_gamma_huge_5():
+    mp.dps = 500
+    x = 10**60 * j / 3
+    mp.dps = 15
+    y = gamma(x)
+    assert str(y.real) == "-3.27753899634941e-227396058973640224580963937571892628368354580620654233316839"
+    assert str(y.imag) == "-7.1519888950416e-227396058973640224580963937571892628368354580620654233316841"
+    mp.dps = 50
+    y = gamma(x)
+    assert str(y.real) == (\
+        "-3.2775389963494132168950056995974690946983219123935e-22739605897364022458096393"
+        "7571892628368354580620654233316839")
+    assert str(y.imag) == (\
+        "-7.1519888950415979749736749222530209713136588885897e-22739605897364022458096393"
+        "7571892628368354580620654233316841")
+    mp.dps = 15
+
+def test_gamma_huge_7():
+    mp.dps = 100
+    a = 3 + j/mpf(10)**1000
+    mp.dps = 15
+    y = gamma(a)
+    assert str(y.real) == "2.0"
+    # wrong
+    #assert str(y.imag) == "2.16735365342606e-1000"
+    assert str(y.imag) == "1.84556867019693e-1000"
+    mp.dps = 50
+    y = gamma(a)
+    assert str(y.real) == "2.0"
+    #assert str(y.imag) == "2.1673536534260596065418805612488708028522563689298e-1000"
+    assert str(y.imag) ==  "1.8455686701969342787869758198351951379156813281202e-1000"
+
+def test_stieltjes():
+    mp.dps = 15
+    assert stieltjes(0).ae(+euler)
+    mp.dps = 25
+    assert stieltjes(1).ae('-0.07281584548367672486058637587')
+    assert stieltjes(2).ae('-0.009690363192872318484530386035')
+    assert stieltjes(3).ae('0.002053834420303345866160046543')
+    assert stieltjes(4).ae('0.002325370065467300057468170178')
+    mp.dps = 15
+    assert stieltjes(1).ae(-0.07281584548367672486058637587)
+    assert stieltjes(2).ae(-0.009690363192872318484530386035)
+    assert stieltjes(3).ae(0.002053834420303345866160046543)
+    assert stieltjes(4).ae(0.0023253700654673000574681701775)
+
+def test_barnesg():
+    mp.dps = 15
+    assert barnesg(0) == barnesg(-1) == 0
+    assert [superfac(i) for i in range(8)] == [1, 1, 2, 12, 288, 34560, 24883200, 125411328000]
+    assert str(superfac(1000)) == '3.24570818422368e+1177245'
+    assert isnan(barnesg(nan))
+    assert isnan(superfac(nan))
+    assert isnan(hyperfac(nan))
+    assert barnesg(inf) == inf
+    assert superfac(inf) == inf
+    assert hyperfac(inf) == inf
+    assert isnan(superfac(-inf))
+    assert barnesg(0.7).ae(0.8068722730141471)
+    assert barnesg(2+3j).ae(-0.17810213864082169+0.04504542715447838j)
+    assert [hyperfac(n) for n in range(7)] == [1, 1, 4, 108, 27648, 86400000, 4031078400000]
+    assert [hyperfac(n) for n in range(0,-7,-1)] == [1,1,-1,-4,108,27648,-86400000]
+    a = barnesg(-3+0j)
+    assert a == 0 and isinstance(a, mpc)
+    a = hyperfac(-3+0j)
+    assert a == -4 and isinstance(a, mpc)
+
+def test_polylog():
+    mp.dps = 15
+    zs = [mpmathify(z) for z in [0, 0.5, 0.99, 4, -0.5, -4, 1j, 3+4j]]
+    for z in zs: assert polylog(1, z).ae(-log(1-z))
+    for z in zs: assert polylog(0, z).ae(z/(1-z))
+    for z in zs: assert polylog(-1, z).ae(z/(1-z)**2)
+    for z in zs: assert polylog(-2, z).ae(z*(1+z)/(1-z)**3)
+    for z in zs: assert polylog(-3, z).ae(z*(1+4*z+z**2)/(1-z)**4)
+    assert polylog(3, 7).ae(5.3192579921456754382-5.9479244480803301023j)
+    assert polylog(3, -7).ae(-4.5693548977219423182)
+    assert polylog(2, 0.9).ae(1.2997147230049587252)
+    assert polylog(2, -0.9).ae(-0.75216317921726162037)
+    assert polylog(2, 0.9j).ae(-0.17177943786580149299+0.83598828572550503226j)
+    assert polylog(2, 1.1).ae(1.9619991013055685931-0.2994257606855892575j)
+    assert polylog(2, -1.1).ae(-0.89083809026228260587)
+    assert polylog(2, 1.1*sqrt(j)).ae(0.58841571107611387722+1.09962542118827026011j)
+    assert polylog(-2, 0.9).ae(1710)
+    assert polylog(-2, -0.9).ae(-90/6859.)
+    assert polylog(3, 0.9).ae(1.0496589501864398696)
+    assert polylog(-3, 0.9).ae(48690)
+    assert polylog(-3, -4).ae(-0.0064)
+    assert polylog(0.5+j/3, 0.5+j/2).ae(0.31739144796565650535 + 0.99255390416556261437j)
+    assert polylog(3+4j,1).ae(zeta(3+4j))
+    assert polylog(3+4j,-1).ae(-altzeta(3+4j))
+    # issue 390
+    assert polylog(1.5, -48.910886523731889).ae(-6.272992229311817)
+    assert polylog(1.5, 200).ae(-8.349608319033686529 - 8.159694826434266042j)
+    assert polylog(-2+0j, -2).ae(mpf(1)/13.5)
+    assert polylog(-2+0j, 1.25).ae(-180)
+
+def test_bell_polyexp():
+    mp.dps = 15
+    # TODO: more tests for polyexp
+    assert (polyexp(0,1e-10)*10**10).ae(1.00000000005)
+    assert (polyexp(1,1e-10)*10**10).ae(1.0000000001)
+    assert polyexp(5,3j).ae(-607.7044517476176454+519.962786482001476087j)
+    assert polyexp(-1,3.5).ae(12.09537536175543444)
+    # bell(0,x) = 1
+    assert bell(0,0) == 1
+    assert bell(0,1) == 1
+    assert bell(0,2) == 1
+    assert bell(0,inf) == 1
+    assert bell(0,-inf) == 1
+    assert isnan(bell(0,nan))
+    # bell(1,x) = x
+    assert bell(1,4) == 4
+    assert bell(1,0) == 0
+    assert bell(1,inf) == inf
+    assert bell(1,-inf) == -inf
+    assert isnan(bell(1,nan))
+    # bell(2,x) = x*(1+x)
+    assert bell(2,-1) == 0
+    assert bell(2,0) == 0
+    # large orders / arguments
+    assert bell(10) == 115975
+    assert bell(10,1) == 115975
+    assert bell(10, -8) == 11054008
+    assert bell(5,-50) == -253087550
+    assert bell(50,-50).ae('3.4746902914629720259e74')
+    mp.dps = 80
+    assert bell(50,-50) == 347469029146297202586097646631767227177164818163463279814268368579055777450
+    assert bell(40,50) == 5575520134721105844739265207408344706846955281965031698187656176321717550
+    assert bell(74) == 5006908024247925379707076470957722220463116781409659160159536981161298714301202
+    mp.dps = 15
+    assert bell(10,20j) == 7504528595600+15649605360020j
+    # continuity of the generalization
+    assert bell(0.5,0).ae(sinc(pi*0.5))
+
+def test_primezeta():
+    mp.dps = 15
+    assert primezeta(0.9).ae(1.8388316154446882243 + 3.1415926535897932385j)
+    assert primezeta(4).ae(0.076993139764246844943)
+    assert primezeta(1) == inf
+    assert primezeta(inf) == 0
+    assert isnan(primezeta(nan))
+
+def test_rs_zeta():
+    mp.dps = 15
+    assert zeta(0.5+100000j).ae(1.0730320148577531321 + 5.7808485443635039843j)
+    assert zeta(0.75+100000j).ae(1.837852337251873704 + 1.9988492668661145358j)
+    assert zeta(0.5+1000000j, derivative=3).ae(1647.7744105852674733 - 1423.1270943036622097j)
+    assert zeta(1+1000000j, derivative=3).ae(3.4085866124523582894 - 18.179184721525947301j)
+    assert zeta(1+1000000j, derivative=1).ae(-0.10423479366985452134 - 0.74728992803359056244j)
+    assert zeta(0.5-1000000j, derivative=1).ae(11.636804066002521459 + 17.127254072212996004j)
+    # Additional sanity tests using fp arithmetic.
+    # Some more high-precision tests are found in the docstrings
+    def ae(x, y, tol=1e-6):
+        return abs(x-y) < tol*abs(y)
+    assert ae(fp.zeta(0.5-100000j), 1.0730320148577531321 - 5.7808485443635039843j)
+    assert ae(fp.zeta(0.75-100000j), 1.837852337251873704 - 1.9988492668661145358j)
+    assert ae(fp.zeta(0.5+1e6j), 0.076089069738227100006 + 2.8051021010192989554j)
+    assert ae(fp.zeta(0.5+1e6j, derivative=1), 11.636804066002521459 - 17.127254072212996004j)
+    assert ae(fp.zeta(1+1e6j), 0.94738726251047891048 + 0.59421999312091832833j)
+    assert ae(fp.zeta(1+1e6j, derivative=1), -0.10423479366985452134 - 0.74728992803359056244j)
+    assert ae(fp.zeta(0.5+100000j, derivative=1), 10.766962036817482375 - 30.92705282105996714j)
+    assert ae(fp.zeta(0.5+100000j, derivative=2), -119.40515625740538429 + 217.14780631141830251j)
+    assert ae(fp.zeta(0.5+100000j, derivative=3), 1129.7550282628460881 - 1685.4736895169690346j)
+    assert ae(fp.zeta(0.5+100000j, derivative=4), -10407.160819314958615 + 13777.786698628045085j)
+    assert ae(fp.zeta(0.75+100000j, derivative=1), -0.41742276699594321475 - 6.4453816275049955949j)
+    assert ae(fp.zeta(0.75+100000j, derivative=2), -9.214314279161977266 + 35.07290795337967899j)
+    assert ae(fp.zeta(0.75+100000j, derivative=3), 110.61331857820103469 - 236.87847130518129926j)
+    assert ae(fp.zeta(0.75+100000j, derivative=4), -1054.334275898559401 + 1769.9177890161596383j)
+
+def test_siegelz():
+    mp.dps = 15
+    assert siegelz(100000).ae(5.87959246868176504171)
+    assert siegelz(100000, derivative=2).ae(-54.1172711010126452832)
+    assert siegelz(100000, derivative=3).ae(-278.930831343966552538)
+    assert siegelz(100000+j,derivative=1).ae(678.214511857070283307-379.742160779916375413j)
+
+
+
+def test_zeta_near_1():
+    # Test for a former bug in mpf_zeta and mpc_zeta
+    mp.dps = 15
+    s1 = fadd(1, '1e-10', exact=True)
+    s2 = fadd(1, '-1e-10', exact=True)
+    s3 = fadd(1, '1e-10j', exact=True)
+    assert zeta(s1).ae(1.000000000057721566490881444e10)
+    assert zeta(s2).ae(-9.99999999942278433510574872e9)
+    z = zeta(s3)
+    assert z.real.ae(0.57721566490153286060)
+    assert z.imag.ae(-9.9999999999999999999927184e9)
+    mp.dps = 30
+    s1 = fadd(1, '1e-50', exact=True)
+    s2 = fadd(1, '-1e-50', exact=True)
+    s3 = fadd(1, '1e-50j', exact=True)
+    assert zeta(s1).ae('1e50')
+    assert zeta(s2).ae('-1e50')
+    z = zeta(s3)
+    assert z.real.ae('0.57721566490153286060651209008240243104215933593992')
+    assert z.imag.ae('-1e50')
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_hp.py b/lib/python3.10/site-packages/mpmath/tests/test_hp.py
new file mode 100644
index 0000000000000000000000000000000000000000..9eba0af798f64ac3f8d464e2d3bf231567a48c9b
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_hp.py
@@ -0,0 +1,291 @@
+"""
+Check that the output from irrational functions is accurate for
+high-precision input, from 5 to 200 digits. The reference values were
+verified with Mathematica.
+"""
+
+import time
+from mpmath import *
+
+precs = [5, 15, 28, 35, 57, 80, 100, 150, 200]
+
+# sqrt(3) + pi/2
+a = \
+"3.302847134363773912758768033145623809041389953497933538543279275605"\
+"841220051904536395163599428307109666700184672047856353516867399774243594"\
+"67433521615861420725323528325327484262075464241255915238845599752675"
+
+# e + 1/euler**2
+b = \
+"5.719681166601007617111261398629939965860873957353320734275716220045750"\
+"31474116300529519620938123730851145473473708966080207482581266469342214"\
+"824842256999042984813905047895479210702109260221361437411947323431"
+
+# sqrt(a)
+sqrt_a = \
+"1.817373691447021556327498239690365674922395036495564333152483422755"\
+"144321726165582817927383239308173567921345318453306994746434073691275094"\
+"484777905906961689902608644112196725896908619756404253109722911487"
+
+# sqrt(a+b*i).real
+sqrt_abi_real = \
+"2.225720098415113027729407777066107959851146508557282707197601407276"\
+"89160998185797504198062911768240808839104987021515555650875977724230130"\
+"3584116233925658621288393930286871862273400475179312570274423840384"
+
+# sqrt(a+b*i).imag
+sqrt_abi_imag = \
+"1.2849057639084690902371581529110949983261182430040898147672052833653668"\
+"0629534491275114877090834296831373498336559849050755848611854282001250"\
+"1924311019152914021365263161630765255610885489295778894976075186"
+
+# log(a)
+log_a = \
+"1.194784864491089550288313512105715261520511949410072046160598707069"\
+"4336653155025770546309137440687056366757650909754708302115204338077595203"\
+"83005773986664564927027147084436553262269459110211221152925732612"
+
+# log(a+b*i).real
+log_abi_real = \
+"1.8877985921697018111624077550443297276844736840853590212962006811663"\
+"04949387789489704203167470111267581371396245317618589339274243008242708"\
+"014251531496104028712866224020066439049377679709216784954509456421"
+
+# log(a+b*i).imag
+log_abi_imag = \
+"1.0471204952840802663567714297078763189256357109769672185219334169734948"\
+"4265809854092437285294686651806426649541504240470168212723133326542181"\
+"8300136462287639956713914482701017346851009323172531601894918640"
+
+# exp(a)
+exp_a = \
+"27.18994224087168661137253262213293847994194869430518354305430976149"\
+"382792035050358791398632888885200049857986258414049540376323785711941636"\
+"100358982497583832083513086941635049329804685212200507288797531143"
+
+# exp(a+b*i).real
+exp_abi_real = \
+"22.98606617170543596386921087657586890620262522816912505151109385026"\
+"40160179326569526152851983847133513990281518417211964710397233157168852"\
+"4963130831190142571659948419307628119985383887599493378056639916701"
+
+# exp(a+b*i).imag
+exp_abi_imag = \
+"-14.523557450291489727214750571590272774669907424478129280902375851196283"\
+"3377162379031724734050088565710975758824441845278120105728824497308303"\
+"6065619788140201636218705414429933685889542661364184694108251449"
+
+# a**b
+pow_a_b = \
+"928.7025342285568142947391505837660251004990092821305668257284426997"\
+"361966028275685583421197860603126498884545336686124793155581311527995550"\
+"580229264427202446131740932666832138634013168125809402143796691154"
+
+# (a**(a+b*i)).real
+pow_a_abi_real = \
+"44.09156071394489511956058111704382592976814280267142206420038656267"\
+"67707916510652790502399193109819563864568986234654864462095231138500505"\
+"8197456514795059492120303477512711977915544927440682508821426093455"
+
+# (a**(a+b*i)).imag
+pow_a_abi_imag = \
+"27.069371511573224750478105146737852141664955461266218367212527612279886"\
+"9322304536553254659049205414427707675802193810711302947536332040474573"\
+"8166261217563960235014674118610092944307893857862518964990092301"
+
+# ((a+b*i)**(a+b*i)).real
+pow_abi_abi_real = \
+"-0.15171310677859590091001057734676423076527145052787388589334350524"\
+"8084195882019497779202452975350579073716811284169068082670778986235179"\
+"0813026562962084477640470612184016755250592698408112493759742219150452"\
+
+# ((a+b*i)**(a+b*i)).imag
+pow_abi_abi_imag = \
+"1.2697592504953448936553147870155987153192995316950583150964099070426"\
+"4736837932577176947632535475040521749162383347758827307504526525647759"\
+"97547638617201824468382194146854367480471892602963428122896045019902"
+
+# sin(a)
+sin_a = \
+"-0.16055653857469062740274792907968048154164433772938156243509084009"\
+"38437090841460493108570147191289893388608611542655654723437248152535114"\
+"528368009465836614227575701220612124204622383149391870684288862269631"
+
+# sin(1000*a)
+sin_1000a = \
+"-0.85897040577443833776358106803777589664322997794126153477060795801"\
+"09151695416961724733492511852267067419573754315098042850381158563024337"\
+"216458577140500488715469780315833217177634490142748614625281171216863"
+
+# sin(a+b*i)
+sin_abi_real = \
+"-24.4696999681556977743346798696005278716053366404081910969773939630"\
+"7149215135459794473448465734589287491880563183624997435193637389884206"\
+"02151395451271809790360963144464736839412254746645151672423256977064"
+
+sin_abi_imag = \
+"-150.42505378241784671801405965872972765595073690984080160750785565810981"\
+"8314482499135443827055399655645954830931316357243750839088113122816583"\
+"7169201254329464271121058839499197583056427233866320456505060735"
+
+# cos
+cos_a = \
+"-0.98702664499035378399332439243967038895709261414476495730788864004"\
+"05406821549361039745258003422386169330787395654908532996287293003581554"\
+"257037193284199198069707141161341820684198547572456183525659969145501"
+
+cos_1000a = \
+"-0.51202523570982001856195696460663971099692261342827540426136215533"\
+"52686662667660613179619804463250686852463876088694806607652218586060613"\
+"951310588158830695735537073667299449753951774916401887657320950496820"
+
+# tan
+tan_a = \
+"0.162666873675188117341401059858835168007137819495998960250142156848"\
+"639654718809412181543343168174807985559916643549174530459883826451064966"\
+"7996119428949951351938178809444268785629011625179962457123195557310"
+
+tan_abi_real = \
+"6.822696615947538488826586186310162599974827139564433912601918442911"\
+"1026830824380070400102213741875804368044342309515353631134074491271890"\
+"467615882710035471686578162073677173148647065131872116479947620E-6"
+
+tan_abi_imag = \
+"0.9999795833048243692245661011298447587046967777739649018690797625964167"\
+"1446419978852235960862841608081413169601038230073129482874832053357571"\
+"62702259309150715669026865777947502665936317953101462202542168429"
+
+
+def test_hp():
+    for dps in precs:
+        mp.dps = dps + 8
+        aa = mpf(a)
+        bb = mpf(b)
+        a1000 = 1000*mpf(a)
+        abi = mpc(aa, bb)
+        mp.dps = dps
+        assert (sqrt(3) + pi/2).ae(aa)
+        assert (e + 1/euler**2).ae(bb)
+
+        assert sqrt(aa).ae(mpf(sqrt_a))
+        assert sqrt(abi).ae(mpc(sqrt_abi_real, sqrt_abi_imag))
+
+        assert log(aa).ae(mpf(log_a))
+        assert log(abi).ae(mpc(log_abi_real, log_abi_imag))
+
+        assert exp(aa).ae(mpf(exp_a))
+        assert exp(abi).ae(mpc(exp_abi_real, exp_abi_imag))
+
+        assert (aa**bb).ae(mpf(pow_a_b))
+        assert (aa**abi).ae(mpc(pow_a_abi_real, pow_a_abi_imag))
+        assert (abi**abi).ae(mpc(pow_abi_abi_real, pow_abi_abi_imag))
+
+        assert sin(a).ae(mpf(sin_a))
+        assert sin(a1000).ae(mpf(sin_1000a))
+        assert sin(abi).ae(mpc(sin_abi_real, sin_abi_imag))
+
+        assert cos(a).ae(mpf(cos_a))
+        assert cos(a1000).ae(mpf(cos_1000a))
+
+        assert tan(a).ae(mpf(tan_a))
+        assert tan(abi).ae(mpc(tan_abi_real, tan_abi_imag))
+
+        # check that complex cancellation is avoided so that both
+        # real and imaginary parts have high relative accuracy.
+        # abs_eps should be 0, but has to be set to 1e-205 to pass the
+        # 200-digit case, probably due to slight inaccuracy in the
+        # precomputed input
+        assert (tan(abi).real).ae(mpf(tan_abi_real), abs_eps=1e-205)
+        assert (tan(abi).imag).ae(mpf(tan_abi_imag), abs_eps=1e-205)
+    mp.dps = 460
+    assert str(log(3))[-20:] == '02166121184001409826'
+    mp.dps = 15
+
+# Since str(a) can differ in the last digit from rounded a, and I want
+# to compare the last digits of big numbers with the results in Mathematica,
+# I made this hack to get the last 20 digits of rounded a
+
+def last_digits(a):
+    r = repr(a)
+    s = str(a)
+    #dps = mp.dps
+    #mp.dps += 3
+    m = 10
+    r = r.replace(s[:-m],'')
+    r = r.replace("mpf('",'').replace("')",'')
+    num0 = 0
+    for c in r:
+        if c == '0':
+            num0 += 1
+        else:
+            break
+    b = float(int(r))/10**(len(r) - m)
+    if b >= 10**m - 0.5:  # pragma: no cover
+        raise NotImplementedError
+    n = int(round(b))
+    sn = str(n)
+    s = s[:-m] + '0'*num0 + sn
+    return s[-20:]
+
+# values checked with Mathematica
+def test_log_hp():
+    mp.dps = 2000
+    a = mpf(10)**15000/3
+    r = log(a)
+    res = last_digits(r)
+    # Mathematica N[Log[10^15000/3], 2000]
+    # ...7443804441768333470331
+    assert res == '43804441768333470331'
+
+    # see issue 145
+    r = log(mpf(3)/2)
+    # Mathematica N[Log[3/2], 2000]
+    # ...69653749808140753263288
+    res = last_digits(r)
+    assert res == '53749808140753263288'
+
+    mp.dps = 10000
+    r = log(2)
+    res = last_digits(r)
+    # Mathematica  N[Log[2], 10000]
+    # ...695615913401856601359655561
+    assert res == '13401856601359655561'
+    r = log(mpf(10)**10/3)
+    res = last_digits(r)
+    # Mathematica N[Log[10^10/3], 10000]
+    # ...587087654020631943060007154
+    assert res == '54020631943060007154', res
+    r = log(mpf(10)**100/3)
+    res = last_digits(r)
+    # Mathematica N[Log[10^100/3], 10000]
+    # ,,,59246336539088351652334666
+    assert res == '36539088351652334666', res
+    mp.dps += 10
+    a = 1 - mpf(1)/10**10
+    mp.dps -= 10
+    r = log(a)
+    res = last_digits(r)
+    # ...3310334360482956137216724048322957404
+    # 372167240483229574038733026370
+    # Mathematica N[Log[1 - 10^-10]*10^10, 10000]
+    # ...60482956137216724048322957404
+    assert res == '37216724048322957404', res
+    mp.dps = 10000
+    mp.dps += 100
+    a = 1 + mpf(1)/10**100
+    mp.dps -= 100
+
+    r = log(a)
+    res = last_digits(+r)
+    # Mathematica N[Log[1 + 10^-100]*10^10, 10030]
+    # ...3994733877377412241546890854692521568292338268273 10^-91
+    assert res == '39947338773774122415', res
+
+    mp.dps = 15
+
+def test_exp_hp():
+    mp.dps = 4000
+    r = exp(mpf(1)/10)
+    # IntegerPart[N[Exp[1/10] * 10^4000, 4000]]
+    # ...92167105162069688129
+    assert int(r * 10**mp.dps) % 10**20 == 92167105162069688129
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_identify.py b/lib/python3.10/site-packages/mpmath/tests/test_identify.py
new file mode 100644
index 0000000000000000000000000000000000000000..f75ab0bc4f04ecb614011e7f4599989465cab785
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_identify.py
@@ -0,0 +1,19 @@
+from mpmath import *
+
+def test_pslq():
+    mp.dps = 15
+    assert pslq([3*pi+4*e/7, pi, e, log(2)]) == [7, -21, -4, 0]
+    assert pslq([4.9999999999999991, 1]) == [1, -5]
+    assert pslq([2,1]) == [1, -2]
+
+def test_identify():
+    mp.dps = 20
+    assert identify(zeta(4), ['log(2)', 'pi**4']) == '((1/90)*pi**4)'
+    mp.dps = 15
+    assert identify(exp(5)) == 'exp(5)'
+    assert identify(exp(4)) == 'exp(4)'
+    assert identify(log(5)) == 'log(5)'
+    assert identify(exp(3*pi), ['pi']) == 'exp((3*pi))'
+    assert identify(3, full=True) == ['3', '3', '1/(1/3)', 'sqrt(9)',
+        '1/sqrt((1/9))', '(sqrt(12)/2)**2', '1/(sqrt(12)/6)**2']
+    assert identify(pi+1, {'a':+pi}) == '(1 + 1*a)'
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_interval.py b/lib/python3.10/site-packages/mpmath/tests/test_interval.py
new file mode 100644
index 0000000000000000000000000000000000000000..251fd8b7ddb00074e8ae27cce4a01d8f4f8fe151
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_interval.py
@@ -0,0 +1,453 @@
+from mpmath import *
+
+def test_interval_identity():
+    iv.dps = 15
+    assert mpi(2) == mpi(2, 2)
+    assert mpi(2) != mpi(-2, 2)
+    assert not (mpi(2) != mpi(2, 2))
+    assert mpi(-1, 1) == mpi(-1, 1)
+    assert str(mpi('0.1')) == "[0.099999999999999991673, 0.10000000000000000555]"
+    assert repr(mpi('0.1')) == "mpi('0.099999999999999992', '0.10000000000000001')"
+    u = mpi(-1, 3)
+    assert -1 in u
+    assert 2 in u
+    assert 3 in u
+    assert -1.1 not in u
+    assert 3.1 not in u
+    assert mpi(-1, 3) in u
+    assert mpi(0, 1) in u
+    assert mpi(-1.1, 2) not in u
+    assert mpi(2.5, 3.1) not in u
+    w = mpi(-inf, inf)
+    assert mpi(-5, 5) in w
+    assert mpi(2, inf) in w
+    assert mpi(0, 2) in mpi(0, 10)
+    assert not (3 in mpi(-inf, 0))
+
+def test_interval_hash():
+    assert hash(mpi(3)) == hash(3)
+    assert hash(mpi(3.25)) == hash(3.25)
+    assert hash(mpi(3,4)) == hash(mpi(3,4))
+    assert hash(iv.mpc(3)) == hash(3)
+    assert hash(iv.mpc(3,4)) == hash(3+4j)
+    assert hash(iv.mpc((1,3),(2,4))) == hash(iv.mpc((1,3),(2,4)))
+
+def test_interval_arithmetic():
+    iv.dps = 15
+    assert mpi(2) + mpi(3,4) == mpi(5,6)
+    assert mpi(1, 2)**2 == mpi(1, 4)
+    assert mpi(1) + mpi(0, 1e-50) == mpi(1, mpf('1.0000000000000002'))
+    x = 1 / (1 / mpi(3))
+    assert x.a < 3 < x.b
+    x = mpi(2) ** mpi(0.5)
+    iv.dps += 5
+    sq = iv.sqrt(2)
+    iv.dps -= 5
+    assert x.a < sq < x.b
+    assert mpi(1) / mpi(1, inf)
+    assert mpi(2, 3) / inf == mpi(0, 0)
+    assert mpi(0) / inf == 0
+    assert mpi(0) / 0 == mpi(-inf, inf)
+    assert mpi(inf) / 0 == mpi(-inf, inf)
+    assert mpi(0) * inf == mpi(-inf, inf)
+    assert 1 / mpi(2, inf) == mpi(0, 0.5)
+    assert str((mpi(50, 50) * mpi(-10, -10)) / 3) == \
+        '[-166.66666666666668561, -166.66666666666665719]'
+    assert mpi(0, 4) ** 3 == mpi(0, 64)
+    assert mpi(2,4).mid == 3
+    iv.dps = 30
+    a = mpi(iv.pi)
+    iv.dps = 15
+    b = +a
+    assert b.a < a.a
+    assert b.b > a.b
+    a = mpi(iv.pi)
+    assert a == +a
+    assert abs(mpi(-1,2)) == mpi(0,2)
+    assert abs(mpi(0.5,2)) == mpi(0.5,2)
+    assert abs(mpi(-3,2)) == mpi(0,3)
+    assert abs(mpi(-3,-0.5)) == mpi(0.5,3)
+    assert mpi(0) * mpi(2,3) == mpi(0)
+    assert mpi(2,3) * mpi(0) == mpi(0)
+    assert mpi(1,3).delta == 2
+    assert mpi(1,2) - mpi(3,4) == mpi(-3,-1)
+    assert mpi(-inf,0) - mpi(0,inf) == mpi(-inf,0)
+    assert mpi(-inf,0) - mpi(-inf,inf) == mpi(-inf,inf)
+    assert mpi(0,inf) - mpi(-inf,1) == mpi(-1,inf)
+
+def test_interval_mul():
+    assert mpi(-1, 0) * inf == mpi(-inf, 0)
+    assert mpi(-1, 0) * -inf == mpi(0, inf)
+    assert mpi(0, 1) * inf == mpi(0, inf)
+    assert mpi(0, 1) * mpi(0, inf) == mpi(0, inf)
+    assert mpi(-1, 1) * inf == mpi(-inf, inf)
+    assert mpi(-1, 1) * mpi(0, inf) == mpi(-inf, inf)
+    assert mpi(-1, 1) * mpi(-inf, inf) == mpi(-inf, inf)
+    assert mpi(-inf, 0) * mpi(0, 1) == mpi(-inf, 0)
+    assert mpi(-inf, 0) * mpi(0, 0) * mpi(-inf, 0)
+    assert mpi(-inf, 0) * mpi(-inf, inf) == mpi(-inf, inf)
+    assert mpi(-5,0)*mpi(-32,28) == mpi(-140,160)
+    assert mpi(2,3) * mpi(-1,2) == mpi(-3,6)
+    # Should be undefined?
+    assert mpi(inf, inf) * 0 == mpi(-inf, inf)
+    assert mpi(-inf, -inf) * 0 == mpi(-inf, inf)
+    assert mpi(0) * mpi(-inf,2) == mpi(-inf,inf)
+    assert mpi(0) * mpi(-2,inf) == mpi(-inf,inf)
+    assert mpi(-2,inf) * mpi(0) == mpi(-inf,inf)
+    assert mpi(-inf,2) * mpi(0) == mpi(-inf,inf)
+
+def test_interval_pow():
+    assert mpi(3)**2 == mpi(9, 9)
+    assert mpi(-3)**2 == mpi(9, 9)
+    assert mpi(-3, 1)**2 == mpi(0, 9)
+    assert mpi(-3, -1)**2 == mpi(1, 9)
+    assert mpi(-3, -1)**3 == mpi(-27, -1)
+    assert mpi(-3, 1)**3 == mpi(-27, 1)
+    assert mpi(-2, 3)**2 == mpi(0, 9)
+    assert mpi(-3, 2)**2 == mpi(0, 9)
+    assert mpi(4) ** -1 == mpi(0.25, 0.25)
+    assert mpi(-4) ** -1 == mpi(-0.25, -0.25)
+    assert mpi(4) ** -2 == mpi(0.0625, 0.0625)
+    assert mpi(-4) ** -2 == mpi(0.0625, 0.0625)
+    assert mpi(0, 1) ** inf == mpi(0, 1)
+    assert mpi(0, 1) ** -inf == mpi(1, inf)
+    assert mpi(0, inf) ** inf == mpi(0, inf)
+    assert mpi(0, inf) ** -inf == mpi(0, inf)
+    assert mpi(1, inf) ** inf == mpi(1, inf)
+    assert mpi(1, inf) ** -inf == mpi(0, 1)
+    assert mpi(2, 3) ** 1 == mpi(2, 3)
+    assert mpi(2, 3) ** 0 == 1
+    assert mpi(1,3) ** mpi(2) == mpi(1,9)
+
+def test_interval_sqrt():
+    assert mpi(4) ** 0.5 == mpi(2)
+
+def test_interval_div():
+    assert mpi(0.5, 1) / mpi(-1, 0) == mpi(-inf, -0.5)
+    assert mpi(0, 1) / mpi(0, 1) == mpi(0, inf)
+    assert mpi(inf, inf) / mpi(inf, inf) == mpi(0, inf)
+    assert mpi(inf, inf) / mpi(2, inf) == mpi(0, inf)
+    assert mpi(inf, inf) / mpi(2, 2) == mpi(inf, inf)
+    assert mpi(0, inf) / mpi(2, inf) == mpi(0, inf)
+    assert mpi(0, inf) / mpi(2, 2) == mpi(0, inf)
+    assert mpi(2, inf) / mpi(2, 2) == mpi(1, inf)
+    assert mpi(2, inf) / mpi(2, inf) == mpi(0, inf)
+    assert mpi(-4, 8) / mpi(1, inf) == mpi(-4, 8)
+    assert mpi(-4, 8) / mpi(0.5, inf) == mpi(-8, 16)
+    assert mpi(-inf, 8) / mpi(0.5, inf) == mpi(-inf, 16)
+    assert mpi(-inf, inf) / mpi(0.5, inf) == mpi(-inf, inf)
+    assert mpi(8, inf) / mpi(0.5, inf) == mpi(0, inf)
+    assert mpi(-8, inf) / mpi(0.5, inf) == mpi(-16, inf)
+    assert mpi(-4, 8) / mpi(inf, inf) == mpi(0, 0)
+    assert mpi(0, 8) / mpi(inf, inf) == mpi(0, 0)
+    assert mpi(0, 0) / mpi(inf, inf) == mpi(0, 0)
+    assert mpi(-inf, 0) / mpi(inf, inf) == mpi(-inf, 0)
+    assert mpi(-inf, 8) / mpi(inf, inf) == mpi(-inf, 0)
+    assert mpi(-inf, inf) / mpi(inf, inf) == mpi(-inf, inf)
+    assert mpi(-8, inf) / mpi(inf, inf) == mpi(0, inf)
+    assert mpi(0, inf) / mpi(inf, inf) == mpi(0, inf)
+    assert mpi(8, inf) / mpi(inf, inf) == mpi(0, inf)
+    assert mpi(inf, inf) / mpi(inf, inf) == mpi(0, inf)
+    assert mpi(-1, 2) / mpi(0, 1) == mpi(-inf, +inf)
+    assert mpi(0, 1) / mpi(0, 1) == mpi(0.0, +inf)
+    assert mpi(-1, 0) / mpi(0, 1) == mpi(-inf, 0.0)
+    assert mpi(-0.5, -0.25) / mpi(0, 1) == mpi(-inf, -0.25)
+    assert mpi(0.5, 1) / mpi(0, 1) == mpi(0.5, +inf)
+    assert mpi(0.5, 4) / mpi(0, 1) == mpi(0.5, +inf)
+    assert mpi(-1, -0.5) / mpi(0, 1) == mpi(-inf, -0.5)
+    assert mpi(-4, -0.5) / mpi(0, 1) == mpi(-inf, -0.5)
+    assert mpi(-1, 2) / mpi(-2, 0.5) == mpi(-inf, +inf)
+    assert mpi(0, 1) / mpi(-2, 0.5) == mpi(-inf, +inf)
+    assert mpi(-1, 0) / mpi(-2, 0.5) == mpi(-inf, +inf)
+    assert mpi(-0.5, -0.25) / mpi(-2, 0.5) == mpi(-inf, +inf)
+    assert mpi(0.5, 1) / mpi(-2, 0.5) == mpi(-inf, +inf)
+    assert mpi(0.5, 4) / mpi(-2, 0.5) == mpi(-inf, +inf)
+    assert mpi(-1, -0.5) / mpi(-2, 0.5) == mpi(-inf, +inf)
+    assert mpi(-4, -0.5) / mpi(-2, 0.5) == mpi(-inf, +inf)
+    assert mpi(-1, 2) / mpi(-1, 0) == mpi(-inf, +inf)
+    assert mpi(0, 1) / mpi(-1, 0) == mpi(-inf, 0.0)
+    assert mpi(-1, 0) / mpi(-1, 0) == mpi(0.0, +inf)
+    assert mpi(-0.5, -0.25) / mpi(-1, 0) == mpi(0.25, +inf)
+    assert mpi(0.5, 1) / mpi(-1, 0) == mpi(-inf, -0.5)
+    assert mpi(0.5, 4) / mpi(-1, 0) == mpi(-inf, -0.5)
+    assert mpi(-1, -0.5) / mpi(-1, 0) == mpi(0.5, +inf)
+    assert mpi(-4, -0.5) / mpi(-1, 0) == mpi(0.5, +inf)
+    assert mpi(-1, 2) / mpi(0.5, 1) == mpi(-2.0, 4.0)
+    assert mpi(0, 1) / mpi(0.5, 1) == mpi(0.0, 2.0)
+    assert mpi(-1, 0) / mpi(0.5, 1) == mpi(-2.0, 0.0)
+    assert mpi(-0.5, -0.25) / mpi(0.5, 1) == mpi(-1.0, -0.25)
+    assert mpi(0.5, 1) / mpi(0.5, 1) == mpi(0.5, 2.0)
+    assert mpi(0.5, 4) / mpi(0.5, 1) == mpi(0.5, 8.0)
+    assert mpi(-1, -0.5) / mpi(0.5, 1) == mpi(-2.0, -0.5)
+    assert mpi(-4, -0.5) / mpi(0.5, 1) == mpi(-8.0, -0.5)
+    assert mpi(-1, 2) / mpi(-2, -0.5) == mpi(-4.0, 2.0)
+    assert mpi(0, 1) / mpi(-2, -0.5) == mpi(-2.0, 0.0)
+    assert mpi(-1, 0) / mpi(-2, -0.5) == mpi(0.0, 2.0)
+    assert mpi(-0.5, -0.25) / mpi(-2, -0.5) == mpi(0.125, 1.0)
+    assert mpi(0.5, 1) / mpi(-2, -0.5) == mpi(-2.0, -0.25)
+    assert mpi(0.5, 4) / mpi(-2, -0.5) == mpi(-8.0, -0.25)
+    assert mpi(-1, -0.5) / mpi(-2, -0.5) == mpi(0.25, 2.0)
+    assert mpi(-4, -0.5) / mpi(-2, -0.5) == mpi(0.25, 8.0)
+    # Should be undefined?
+    assert mpi(0, 0) / mpi(0, 0) == mpi(-inf, inf)
+    assert mpi(0, 0) / mpi(0, 1) == mpi(-inf, inf)
+
+def test_interval_cos_sin():
+    iv.dps = 15
+    cos = iv.cos
+    sin = iv.sin
+    tan = iv.tan
+    pi = iv.pi
+    # Around 0
+    assert cos(mpi(0)) == 1
+    assert sin(mpi(0)) == 0
+    assert cos(mpi(0,1)) == mpi(0.54030230586813965399, 1.0)
+    assert sin(mpi(0,1)) == mpi(0, 0.8414709848078966159)
+    assert cos(mpi(1,2)) == mpi(-0.4161468365471424069, 0.54030230586813976501)
+    assert sin(mpi(1,2)) == mpi(0.84147098480789650488, 1.0)
+    assert sin(mpi(1,2.5)) == mpi(0.59847214410395643824, 1.0)
+    assert cos(mpi(-1, 1)) == mpi(0.54030230586813965399, 1.0)
+    assert cos(mpi(-1, 0.5)) == mpi(0.54030230586813965399, 1.0)
+    assert cos(mpi(-1, 1.5)) == mpi(0.070737201667702906405, 1.0)
+    assert sin(mpi(-1,1)) == mpi(-0.8414709848078966159, 0.8414709848078966159)
+    assert sin(mpi(-1,0.5)) == mpi(-0.8414709848078966159, 0.47942553860420300538)
+    assert mpi(-0.8414709848078966159, 1.00000000000000002e-100) in sin(mpi(-1,1e-100))
+    assert mpi(-2.00000000000000004e-100, 1.00000000000000002e-100) in sin(mpi(-2e-100,1e-100))
+    # Same interval
+    assert cos(mpi(2, 2.5))
+    assert cos(mpi(3.5, 4)) == mpi(-0.93645668729079634129, -0.65364362086361182946)
+    assert cos(mpi(5, 5.5)) == mpi(0.28366218546322624627, 0.70866977429126010168)
+    assert mpi(0.59847214410395654927, 0.90929742682568170942) in sin(mpi(2, 2.5))
+    assert sin(mpi(3.5, 4)) == mpi(-0.75680249530792831347, -0.35078322768961983646)
+    assert sin(mpi(5, 5.5)) == mpi(-0.95892427466313856499, -0.70554032557039181306)
+    # Higher roots
+    iv.dps = 55
+    w = 4*10**50 + mpi(0.5)
+    for p in [15, 40, 80]:
+        iv.dps = p
+        assert 0 in sin(4*mpi(pi))
+        assert 0 in sin(4*10**50*mpi(pi))
+        assert 0 in cos((4+0.5)*mpi(pi))
+        assert 0 in cos(w*mpi(pi))
+        assert 1 in cos(4*mpi(pi))
+        assert 1 in cos(4*10**50*mpi(pi))
+    iv.dps = 15
+    assert cos(mpi(2,inf)) == mpi(-1,1)
+    assert sin(mpi(2,inf)) == mpi(-1,1)
+    assert cos(mpi(-inf,2)) == mpi(-1,1)
+    assert sin(mpi(-inf,2)) == mpi(-1,1)
+    u = tan(mpi(0.5,1))
+    assert mpf(u.a).ae(mp.tan(0.5))
+    assert mpf(u.b).ae(mp.tan(1))
+    v = iv.cot(mpi(0.5,1))
+    assert mpf(v.a).ae(mp.cot(1))
+    assert mpf(v.b).ae(mp.cot(0.5))
+    # Sanity check of evaluation at n*pi and (n+1/2)*pi
+    for n in range(-5,7,2):
+        x = iv.cos(n*iv.pi)
+        assert -1 in x
+        assert x >= -1
+        assert x != -1
+        x = iv.sin((n+0.5)*iv.pi)
+        assert -1 in x
+        assert x >= -1
+        assert x != -1
+    for n in range(-6,8,2):
+        x = iv.cos(n*iv.pi)
+        assert 1 in x
+        assert x <= 1
+        if n:
+            assert x != 1
+        x = iv.sin((n+0.5)*iv.pi)
+        assert 1 in x
+        assert x <= 1
+        assert x != 1
+    for n in range(-6,7):
+        x = iv.cos((n+0.5)*iv.pi)
+        assert x.a < 0 < x.b
+        x = iv.sin(n*iv.pi)
+        if n:
+            assert x.a < 0 < x.b
+
+def test_interval_complex():
+    # TODO: many more tests
+    iv.dps = 15
+    mp.dps = 15
+    assert iv.mpc(2,3) == 2+3j
+    assert iv.mpc(2,3) != 2+4j
+    assert iv.mpc(2,3) != 1+3j
+    assert 1+3j in iv.mpc([1,2],[3,4])
+    assert 2+5j not in iv.mpc([1,2],[3,4])
+    assert iv.mpc(1,2) + 1j == 1+3j
+    assert iv.mpc([1,2],[2,3]) + 2+3j == iv.mpc([3,4],[5,6])
+    assert iv.mpc([2,4],[4,8]) / 2 == iv.mpc([1,2],[2,4])
+    assert iv.mpc([1,2],[2,4]) * 2j == iv.mpc([-8,-4],[2,4])
+    assert iv.mpc([2,4],[4,8]) / 2j == iv.mpc([2,4],[-2,-1])
+    assert iv.exp(2+3j).ae(mp.exp(2+3j))
+    assert iv.log(2+3j).ae(mp.log(2+3j))
+    assert (iv.mpc(2,3) ** iv.mpc(0.5,2)).ae(mp.mpc(2,3) ** mp.mpc(0.5,2))
+    assert 1j in (iv.mpf(-1) ** 0.5)
+    assert 1j in (iv.mpc(-1) ** 0.5)
+    assert abs(iv.mpc(0)) == 0
+    assert abs(iv.mpc(inf)) == inf
+    assert abs(iv.mpc(3,4)) == 5
+    assert abs(iv.mpc(4)) == 4
+    assert abs(iv.mpc(0,4)) == 4
+    assert abs(iv.mpc(0,[2,3])) == iv.mpf([2,3])
+    assert abs(iv.mpc(0,[-3,2])) == iv.mpf([0,3])
+    assert abs(iv.mpc([3,5],[4,12])) == iv.mpf([5,13])
+    assert abs(iv.mpc([3,5],[-4,12])) == iv.mpf([3,13])
+    assert iv.mpc(2,3) ** 0 == 1
+    assert iv.mpc(2,3) ** 1 == (2+3j)
+    assert iv.mpc(2,3) ** 2 == (2+3j)**2
+    assert iv.mpc(2,3) ** 3 == (2+3j)**3
+    assert iv.mpc(2,3) ** 4 == (2+3j)**4
+    assert iv.mpc(2,3) ** 5 == (2+3j)**5
+    assert iv.mpc(2,2) ** (-1) == (2+2j) ** (-1)
+    assert iv.mpc(2,2) ** (-2) == (2+2j) ** (-2)
+    assert iv.cos(2).ae(mp.cos(2))
+    assert iv.sin(2).ae(mp.sin(2))
+    assert iv.cos(2+3j).ae(mp.cos(2+3j))
+    assert iv.sin(2+3j).ae(mp.sin(2+3j))
+
+def test_interval_complex_arg():
+    mp.dps = 15
+    iv.dps = 15
+    assert iv.arg(3) == 0
+    assert iv.arg(0) == 0
+    assert iv.arg([0,3]) == 0
+    assert iv.arg(-3).ae(pi)
+    assert iv.arg(2+3j).ae(iv.arg(2+3j))
+    z = iv.mpc([-2,-1],[3,4])
+    t = iv.arg(z)
+    assert t.a.ae(mp.arg(-1+4j))
+    assert t.b.ae(mp.arg(-2+3j))
+    z = iv.mpc([-2,1],[3,4])
+    t = iv.arg(z)
+    assert t.a.ae(mp.arg(1+3j))
+    assert t.b.ae(mp.arg(-2+3j))
+    z = iv.mpc([1,2],[3,4])
+    t = iv.arg(z)
+    assert t.a.ae(mp.arg(2+3j))
+    assert t.b.ae(mp.arg(1+4j))
+    z = iv.mpc([1,2],[-2,3])
+    t = iv.arg(z)
+    assert t.a.ae(mp.arg(1-2j))
+    assert t.b.ae(mp.arg(1+3j))
+    z = iv.mpc([1,2],[-4,-3])
+    t = iv.arg(z)
+    assert t.a.ae(mp.arg(1-4j))
+    assert t.b.ae(mp.arg(2-3j))
+    z = iv.mpc([-1,2],[-4,-3])
+    t = iv.arg(z)
+    assert t.a.ae(mp.arg(-1-3j))
+    assert t.b.ae(mp.arg(2-3j))
+    z = iv.mpc([-2,-1],[-4,-3])
+    t = iv.arg(z)
+    assert t.a.ae(mp.arg(-2-3j))
+    assert t.b.ae(mp.arg(-1-4j))
+    z = iv.mpc([-2,-1],[-3,3])
+    t = iv.arg(z)
+    assert t.a.ae(-mp.pi)
+    assert t.b.ae(mp.pi)
+    z = iv.mpc([-2,2],[-3,3])
+    t = iv.arg(z)
+    assert t.a.ae(-mp.pi)
+    assert t.b.ae(mp.pi)
+
+def test_interval_ae():
+    iv.dps = 15
+    x = iv.mpf([1,2])
+    assert x.ae(1) is None
+    assert x.ae(1.5) is None
+    assert x.ae(2) is None
+    assert x.ae(2.01) is False
+    assert x.ae(0.99) is False
+    x = iv.mpf(3.5)
+    assert x.ae(3.5) is True
+    assert x.ae(3.5+1e-15) is True
+    assert x.ae(3.5-1e-15) is True
+    assert x.ae(3.501) is False
+    assert x.ae(3.499) is False
+    assert x.ae(iv.mpf([3.5,3.501])) is None
+    assert x.ae(iv.mpf([3.5,4.5+1e-15])) is None
+
+def test_interval_nstr():
+    iv.dps = n = 30
+    x = mpi(1, 2)
+    # FIXME: error_dps should not be necessary
+    assert iv.nstr(x, n, mode='plusminus', error_dps=6) == '1.5 +- 0.5'
+    assert iv.nstr(x, n, mode='plusminus', use_spaces=False, error_dps=6) == '1.5+-0.5'
+    assert iv.nstr(x, n, mode='percent') == '1.5 (33.33%)'
+    assert iv.nstr(x, n, mode='brackets', use_spaces=False) == '[1.0,2.0]'
+    assert iv.nstr(x, n, mode='brackets' , brackets=('<', '>')) == '<1.0, 2.0>'
+    x = mpi('5.2582327113062393041', '5.2582327113062749951')
+    assert iv.nstr(x, n, mode='diff') == '5.2582327113062[393041, 749951]'
+    assert iv.nstr(iv.cos(mpi(1)), n, mode='diff', use_spaces=False) == '0.54030230586813971740093660744[2955,3053]'
+    assert iv.nstr(mpi('1e123', '1e129'), n, mode='diff') == '[1.0e+123, 1.0e+129]'
+    exp = iv.exp
+    assert iv.nstr(iv.exp(mpi('5000.1')), n, mode='diff') == '3.2797365856787867069110487[0926, 1191]e+2171'
+    iv.dps = 15
+
+def test_mpi_from_str():
+    iv.dps = 15
+    assert iv.convert('1.5 +- 0.5') == mpi(mpf('1.0'), mpf('2.0'))
+    assert mpi(1, 2) in iv.convert('1.5 (33.33333333333333333333333333333%)')
+    assert iv.convert('[1, 2]') == mpi(1, 2)
+    assert iv.convert('1[2, 3]') == mpi(12, 13)
+    assert iv.convert('1.[23,46]e-8') == mpi('1.23e-8', '1.46e-8')
+    assert iv.convert('12[3.4,5.9]e4') == mpi('123.4e+4', '125.9e4')
+
+def test_interval_gamma():
+    mp.dps = 15
+    iv.dps = 15
+    # TODO: need many more tests
+    assert iv.rgamma(0) == 0
+    assert iv.fac(0) == 1
+    assert iv.fac(1) == 1
+    assert iv.fac(2) == 2
+    assert iv.fac(3) == 6
+    assert iv.gamma(0) == [-inf,inf]
+    assert iv.gamma(1) == 1
+    assert iv.gamma(2) == 1
+    assert iv.gamma(3) == 2
+    assert -3.5449077018110320546 in iv.gamma(-0.5)
+    assert iv.loggamma(1) == 0
+    assert iv.loggamma(2) == 0
+    assert 0.69314718055994530942 in iv.loggamma(3)
+    # Test tight log-gamma endpoints based on monotonicity
+    xs = [iv.mpc([2,3],[1,4]),
+          iv.mpc([2,3],[-4,-1]),
+          iv.mpc([2,3],[-1,4]),
+          iv.mpc([2,3],[-4,1]),
+          iv.mpc([2,3],[-4,4]),
+          iv.mpc([-3,-2],[2,4]),
+          iv.mpc([-3,-2],[-4,-2])]
+    for x in xs:
+        ys = [mp.loggamma(mp.mpc(x.a,x.c)),
+              mp.loggamma(mp.mpc(x.b,x.c)),
+              mp.loggamma(mp.mpc(x.a,x.d)),
+              mp.loggamma(mp.mpc(x.b,x.d))]
+        if 0 in x.imag:
+            ys += [mp.loggamma(x.a), mp.loggamma(x.b)]
+        min_real = min([y.real for y in ys])
+        max_real = max([y.real for y in ys])
+        min_imag = min([y.imag for y in ys])
+        max_imag = max([y.imag for y in ys])
+        z = iv.loggamma(x)
+        assert z.a.ae(min_real)
+        assert z.b.ae(max_real)
+        assert z.c.ae(min_imag)
+        assert z.d.ae(max_imag)
+
+def test_interval_conversions():
+    mp.dps = 15
+    iv.dps = 15
+    for a, b in ((-0.0, 0), (0.0, 0.5), (1.0, 1), \
+                 ('-inf', 20.5), ('-inf', float(sqrt(2)))):
+        r = mpi(a, b)
+        assert int(r.b) == int(b)
+        assert float(r.a) == float(a)
+        assert float(r.b) == float(b)
+        assert complex(r.a) == complex(a)
+        assert complex(r.b) == complex(b)
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_levin.py b/lib/python3.10/site-packages/mpmath/tests/test_levin.py
new file mode 100644
index 0000000000000000000000000000000000000000..b14855df4de1a45da27080dcd239267842a4ac7a
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_levin.py
@@ -0,0 +1,153 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+from mpmath import mp
+from mpmath import libmp
+
+xrange = libmp.backend.xrange
+
+# Attention:
+#   These tests run with 15-20 decimal digits precision. For higher precision the
+#   working precision must be raised.
+
+def test_levin_0():
+    mp.dps = 17
+    eps = mp.mpf(mp.eps)
+    with mp.extraprec(2 * mp.prec):
+        L = mp.levin(method = "levin", variant = "u")
+        S, s, n = [], 0, 1
+        while 1:
+            s += mp.one / (n * n)
+            n += 1
+            S.append(s)
+            v, e = L.update_psum(S)
+            if e < eps:
+                break
+            if n > 1000: raise RuntimeError("iteration limit exceeded")
+    eps = mp.exp(0.9 * mp.log(eps))
+    err = abs(v - mp.pi ** 2 / 6)
+    assert err < eps
+    w = mp.nsum(lambda n: 1/(n * n), [1, mp.inf], method = "levin", levin_variant = "u")
+    err = abs(v - w)
+    assert err < eps
+
+def test_levin_1():
+    mp.dps = 17
+    eps = mp.mpf(mp.eps)
+    with mp.extraprec(2 * mp.prec):
+        L = mp.levin(method = "levin", variant = "v")
+        A, n = [], 1
+        while 1:
+            s = mp.mpf(n) ** (2 + 3j)
+            n += 1
+            A.append(s)
+            v, e = L.update(A)
+            if e < eps:
+                break
+            if n > 1000: raise RuntimeError("iteration limit exceeded")
+    eps = mp.exp(0.9 * mp.log(eps))
+    err = abs(v - mp.zeta(-2-3j))
+    assert err < eps
+    w = mp.nsum(lambda n: n ** (2 + 3j), [1, mp.inf], method = "levin", levin_variant = "v")
+    err = abs(v - w)
+    assert err < eps
+
+def test_levin_2():
+    # [2] A. Sidi - "Pratical Extrapolation Methods" p.373
+    mp.dps = 17
+    z=mp.mpf(10)
+    eps = mp.mpf(mp.eps)
+    with mp.extraprec(2 * mp.prec):
+        L = mp.levin(method = "sidi", variant = "t")
+        n = 0
+        while 1:
+            s = (-1)**n * mp.fac(n) * z ** (-n)
+            v, e = L.step(s)
+            n += 1
+            if e < eps:
+                break
+            if n > 1000: raise RuntimeError("iteration limit exceeded")
+    eps = mp.exp(0.9 * mp.log(eps))
+    exact = mp.quad(lambda x: mp.exp(-x)/(1+x/z),[0,mp.inf])
+    # there is also a symbolic expression for the integral:
+    #   exact = z * mp.exp(z) * mp.expint(1,z)
+    err = abs(v - exact)
+    assert err < eps
+    w = mp.nsum(lambda n: (-1) ** n * mp.fac(n) * z ** (-n), [0, mp.inf], method = "sidi", levin_variant = "t")
+    assert err < eps
+
+def test_levin_3():
+    mp.dps = 17
+    z=mp.mpf(2)
+    eps = mp.mpf(mp.eps)
+    with mp.extraprec(7*mp.prec):  # we need copious amount of precision to sum this highly divergent series
+        L = mp.levin(method = "levin", variant = "t")
+        n, s = 0, 0
+        while 1:
+            s += (-z)**n * mp.fac(4 * n) / (mp.fac(n) * mp.fac(2 * n) * (4 ** n))
+            n += 1
+            v, e = L.step_psum(s)
+            if e < eps:
+                break
+            if n > 1000: raise RuntimeError("iteration limit exceeded")
+    eps = mp.exp(0.8 * mp.log(eps))
+    exact = mp.quad(lambda x: mp.exp( -x * x / 2 - z * x ** 4), [0,mp.inf]) * 2 / mp.sqrt(2 * mp.pi)
+    # there is also a symbolic expression for the integral:
+    #   exact = mp.exp(mp.one / (32 * z)) * mp.besselk(mp.one / 4, mp.one / (32 * z)) / (4 * mp.sqrt(z * mp.pi))
+    err = abs(v - exact)
+    assert err < eps
+    w = mp.nsum(lambda n: (-z)**n * mp.fac(4 * n) / (mp.fac(n) * mp.fac(2 * n) * (4 ** n)), [0, mp.inf], method = "levin", levin_variant = "t", workprec = 8*mp.prec, steps = [2] + [1 for x in xrange(1000)])
+    err = abs(v - w)
+    assert err < eps
+
+def test_levin_nsum():
+    mp.dps = 17
+
+    with mp.extraprec(mp.prec):
+        z = mp.mpf(10) ** (-10)
+        a = mp.nsum(lambda n: n**(-(1+z)), [1, mp.inf], method = "l") - 1 / z
+        assert abs(a - mp.euler) < 1e-10
+
+    eps = mp.exp(0.8 * mp.log(mp.eps))
+
+    a = mp.nsum(lambda n: (-1)**(n-1) / n, [1, mp.inf], method = "sidi")
+    assert abs(a - mp.log(2)) < eps
+
+    z = 2 + 1j
+    f = lambda n: mp.rf(2 / mp.mpf(3), n) * mp.rf(4 / mp.mpf(3), n) * z**n / (mp.rf(1 / mp.mpf(3), n) * mp.fac(n))
+    v = mp.nsum(f, [0, mp.inf], method = "levin", steps = [10 for x in xrange(1000)])
+    exact = mp.hyp2f1(2 / mp.mpf(3), 4 / mp.mpf(3), 1 / mp.mpf(3), z)
+    assert abs(exact - v) < eps
+
+def test_cohen_alt_0():
+    mp.dps = 17
+    AC = mp.cohen_alt()
+    S, s, n = [], 0, 1
+    while 1:
+        s += -((-1) ** n) * mp.one / (n * n)
+        n += 1
+        S.append(s)
+        v, e = AC.update_psum(S)
+        if e < mp.eps:
+            break
+        if n > 1000: raise RuntimeError("iteration limit exceeded")
+    eps = mp.exp(0.9 * mp.log(mp.eps))
+    err = abs(v - mp.pi ** 2 / 12)
+    assert err < eps
+
+def test_cohen_alt_1():
+    mp.dps = 17
+    A = []
+    AC = mp.cohen_alt()
+    n = 1
+    while 1:
+        A.append( mp.loggamma(1 + mp.one / (2 * n - 1)))
+        A.append(-mp.loggamma(1 + mp.one / (2 * n)))
+        n += 1
+        v, e = AC.update(A)
+        if e < mp.eps:
+            break
+        if n > 1000: raise RuntimeError("iteration limit exceeded")
+    v = mp.exp(v)
+    err = abs(v - 1.06215090557106)
+    assert err < 1e-12
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_linalg.py b/lib/python3.10/site-packages/mpmath/tests/test_linalg.py
new file mode 100644
index 0000000000000000000000000000000000000000..14256a79f8953d3e4ef8b296258560d48204f547
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_linalg.py
@@ -0,0 +1,332 @@
+# TODO: don't use round
+
+from __future__ import division
+
+import pytest
+from mpmath import *
+xrange = libmp.backend.xrange
+
+# XXX: these shouldn't be visible(?)
+LU_decomp = mp.LU_decomp
+L_solve = mp.L_solve
+U_solve = mp.U_solve
+householder = mp.householder
+improve_solution = mp.improve_solution
+
+A1 = matrix([[3, 1, 6],
+             [2, 1, 3],
+             [1, 1, 1]])
+b1 = [2, 7, 4]
+
+A2 = matrix([[ 2, -1, -1,  2],
+             [ 6, -2,  3, -1],
+             [-4,  2,  3, -2],
+             [ 2,  0,  4, -3]])
+b2 = [3, -3, -2, -1]
+
+A3 = matrix([[ 1,  0, -1, -1,  0],
+             [ 0,  1,  1,  0, -1],
+             [ 4, -5,  2,  0,  0],
+             [ 0,  0, -2,  9,-12],
+             [ 0,  5,  0,  0, 12]])
+b3 = [0, 0, 0, 0, 50]
+
+A4 = matrix([[10.235, -4.56,   0.,   -0.035,  5.67],
+             [-2.463,  1.27,   3.97, -8.63,   1.08],
+             [-6.58,   0.86,  -0.257, 9.32, -43.6 ],
+             [ 9.83,   7.39, -17.25,  0.036, 24.86],
+             [-9.31,  34.9,   78.56,  1.07,  65.8 ]])
+b4 = [8.95, 20.54, 7.42, 5.60, 58.43]
+
+A5 = matrix([[ 1,  2, -4],
+             [-2, -3,  5],
+             [ 3,  5, -8]])
+
+A6 = matrix([[ 1.377360,  2.481400,   5.359190],
+             [ 2.679280, -1.229560,  25.560210],
+             [-1.225280+1.e6,  9.910180, -35.049900-1.e6]])
+b6 = [23.500000, -15.760000, 2.340000]
+
+A7 = matrix([[1, -0.5],
+             [2, 1],
+             [-2, 6]])
+b7 = [3, 2, -4]
+
+A8 = matrix([[1, 2, 3],
+             [-1, 0, 1],
+             [-1, -2, -1],
+             [1, 0, -1]])
+b8 = [1, 2, 3, 4]
+
+A9 = matrix([[ 4,  2, -2],
+             [ 2,  5, -4],
+             [-2, -4, 5.5]])
+b9 = [10, 16, -15.5]
+
+A10 = matrix([[1.0 + 1.0j, 2.0, 2.0],
+            [4.0, 5.0, 6.0],
+            [7.0, 8.0, 9.0]])
+b10 = [1.0, 1.0 + 1.0j, 1.0]
+
+
+def test_LU_decomp():
+    A = A3.copy()
+    b = b3
+    A, p = LU_decomp(A)
+    y = L_solve(A, b, p)
+    x = U_solve(A, y)
+    assert p == [2, 1, 2, 3]
+    assert [round(i, 14) for i in x] == [3.78953107960742, 2.9989094874591098,
+            -0.081788440567070006, 3.8713195201744801, 2.9171210468920399]
+    A = A4.copy()
+    b = b4
+    A, p = LU_decomp(A)
+    y = L_solve(A, b, p)
+    x = U_solve(A, y)
+    assert p == [0, 3, 4, 3]
+    assert [round(i, 14) for i in x] == [2.6383625899619201, 2.6643834462368399,
+            0.79208015947958998, -2.5088376454101899, -1.0567657691375001]
+    A = randmatrix(3)
+    bak = A.copy()
+    LU_decomp(A, overwrite=1)
+    assert A != bak
+
+def test_inverse():
+    for A in [A1, A2, A5]:
+        inv = inverse(A)
+        assert mnorm(A*inv - eye(A.rows), 1) < 1.e-14
+
+def test_householder():
+    mp.dps = 15
+    A, b = A8, b8
+    H, p, x, r = householder(extend(A, b))
+    assert H == matrix(
+    [[mpf('3.0'), mpf('-2.0'), mpf('-1.0'), 0],
+     [-1.0,mpf('3.333333333333333'),mpf('-2.9999999999999991'),mpf('2.0')],
+     [-1.0, mpf('-0.66666666666666674'),mpf('2.8142135623730948'),
+      mpf('-2.8284271247461898')],
+     [1.0, mpf('-1.3333333333333333'),mpf('-0.20000000000000018'),
+      mpf('4.2426406871192857')]])
+    assert p == [-2, -2, mpf('-1.4142135623730949')]
+    assert round(norm(r, 2), 10) == 4.2426406870999998
+
+    y = [102.102, 58.344, 36.463, 24.310, 17.017, 12.376, 9.282, 7.140, 5.610,
+         4.488, 3.6465, 3.003]
+
+    def coeff(n):
+        # similiar to Hilbert matrix
+        A = []
+        for i in range(1, 13):
+            A.append([1. / (i + j - 1) for j in range(1, n + 1)])
+        return matrix(A)
+
+    residuals = []
+    refres = []
+    for n in range(2, 7):
+        A = coeff(n)
+        H, p, x, r = householder(extend(A, y))
+        x = matrix(x)
+        y = matrix(y)
+        residuals.append(norm(r, 2))
+        refres.append(norm(residual(A, x, y), 2))
+    assert [round(res, 10) for res in residuals] == [15.1733888877,
+           0.82378073210000002, 0.302645887, 0.0260109244,
+           0.00058653999999999998]
+    assert norm(matrix(residuals) - matrix(refres), inf) < 1.e-13
+
+    def hilbert_cmplx(n):
+        # Complexified  Hilbert matrix
+        A = hilbert(2*n,n)
+        v = randmatrix(2*n, 2, min=-1, max=1)
+        v = v.apply(lambda x: exp(1J*pi()*x))
+        A = diag(v[:,0])*A*diag(v[:n,1])
+        return A
+
+    residuals_cmplx = []
+    refres_cmplx = []
+    for n in range(2, 10):
+        A = hilbert_cmplx(n)
+        H, p, x, r = householder(A.copy())
+        residuals_cmplx.append(norm(r, 2))
+        refres_cmplx.append(norm(residual(A[:,:n-1], x, A[:,n-1]), 2))
+    assert norm(matrix(residuals_cmplx) - matrix(refres_cmplx), inf) < 1.e-13
+
+def test_factorization():
+    A = randmatrix(5)
+    P, L, U = lu(A)
+    assert mnorm(P*A - L*U, 1) < 1.e-15
+
+def test_solve():
+    assert norm(residual(A6, lu_solve(A6, b6), b6), inf) < 1.e-10
+    assert norm(residual(A7, lu_solve(A7, b7), b7), inf) < 1.5
+    assert norm(residual(A8, lu_solve(A8, b8), b8), inf) <= 3 + 1.e-10
+    assert norm(residual(A6, qr_solve(A6, b6)[0], b6), inf) < 1.e-10
+    assert norm(residual(A7, qr_solve(A7, b7)[0], b7), inf) < 1.5
+    assert norm(residual(A8, qr_solve(A8, b8)[0], b8), 2) <= 4.3
+    assert norm(residual(A10, lu_solve(A10, b10), b10), 2) < 1.e-10
+    assert norm(residual(A10, qr_solve(A10, b10)[0], b10), 2) < 1.e-10
+
+def test_solve_overdet_complex():
+    A = matrix([[1, 2j], [3, 4j], [5, 6]])
+    b = matrix([1 + j, 2, -j])
+    assert norm(residual(A, lu_solve(A, b), b)) < 1.0208
+
+def test_singular():
+    mp.dps = 15
+    A = [[5.6, 1.2], [7./15, .1]]
+    B = repr(zeros(2))
+    b = [1, 2]
+    for i in ['lu_solve(%s, %s)' % (A, b), 'lu_solve(%s, %s)' % (B, b),
+              'qr_solve(%s, %s)' % (A, b), 'qr_solve(%s, %s)' % (B, b)]:
+        pytest.raises((ZeroDivisionError, ValueError), lambda: eval(i))
+
+def test_cholesky():
+    assert fp.cholesky(fp.matrix(A9)) == fp.matrix([[2, 0, 0], [1, 2, 0], [-1, -3/2, 3/2]])
+    x = fp.cholesky_solve(A9, b9)
+    assert fp.norm(fp.residual(A9, x, b9), fp.inf) == 0
+
+def test_det():
+    assert det(A1) == 1
+    assert round(det(A2), 14) == 8
+    assert round(det(A3)) == 1834
+    assert round(det(A4)) == 4443376
+    assert det(A5) == 1
+    assert round(det(A6)) == 78356463
+    assert det(zeros(3)) == 0
+
+def test_cond():
+    mp.dps = 15
+    A = matrix([[1.2969, 0.8648], [0.2161, 0.1441]])
+    assert cond(A, lambda x: mnorm(x,1)) == mpf('327065209.73817754')
+    assert cond(A, lambda x: mnorm(x,inf)) == mpf('327065209.73817754')
+    assert cond(A, lambda x: mnorm(x,'F')) == mpf('249729266.80008656')
+
+@extradps(50)
+def test_precision():
+    A = randmatrix(10, 10)
+    assert mnorm(inverse(inverse(A)) - A, 1) < 1.e-45
+
+def test_interval_matrix():
+    mp.dps = 15
+    iv.dps = 15
+    a = iv.matrix([['0.1','0.3','1.0'],['7.1','5.5','4.8'],['3.2','4.4','5.6']])
+    b = iv.matrix(['4','0.6','0.5'])
+    c = iv.lu_solve(a, b)
+    assert c[0].delta < 1e-13
+    assert c[1].delta < 1e-13
+    assert c[2].delta < 1e-13
+    assert 5.25823271130625686059275 in c[0]
+    assert -13.155049396267837541163 in c[1]
+    assert 7.42069154774972557628979 in c[2]
+
+def test_LU_cache():
+    A = randmatrix(3)
+    LU = LU_decomp(A)
+    assert A._LU == LU_decomp(A)
+    A[0,0] = -1000
+    assert A._LU is None
+
+def test_improve_solution():
+    A = randmatrix(5, min=1e-20, max=1e20)
+    b = randmatrix(5, 1, min=-1000, max=1000)
+    x1 = lu_solve(A, b) + randmatrix(5, 1, min=-1e-5, max=1.e-5)
+    x2 = improve_solution(A, x1, b)
+    assert norm(residual(A, x2, b), 2) < norm(residual(A, x1, b), 2)
+
+def test_exp_pade():
+    for i in range(3):
+        dps = 15
+        extra = 15
+        mp.dps = dps + extra
+        dm = 0
+        N = 3
+        dg = range(1,N+1)
+        a = diag(dg)
+        expa = diag([exp(x) for x in dg])
+        # choose a random matrix not close to be singular
+        # to avoid adding too much extra precision in computing
+        # m**-1 * M * m
+        while abs(dm) < 0.01:
+            m = randmatrix(N)
+            dm = det(m)
+        m = m/dm
+        a1 = m**-1 * a * m
+        e2 = m**-1 * expa * m
+        mp.dps = dps
+        e1 = expm(a1, method='pade')
+        mp.dps = dps + extra
+        d = e2 - e1
+        #print d
+        mp.dps = dps
+        assert norm(d, inf).ae(0)
+    mp.dps = 15
+
+def test_qr():
+    mp.dps = 15                     # used default value for dps
+    lowlimit = -9                   # lower limit of matrix element value
+    uplimit = 9                     # uppter limit of matrix element value
+    maxm = 4                        # max matrix size
+    flg = False                     # toggle to create real vs complex matrix
+    zero = mpf('0.0')
+
+    for k in xrange(0,10):
+        exdps = 0
+        mode = 'full'
+        flg = bool(k % 2)
+
+        # generate arbitrary matrix size (2 to maxm)
+        num1 = nint(maxm*rand())
+        num2 = nint(maxm*rand())
+        m = int(max(num1, num2))
+        n = int(min(num1, num2))
+
+        # create matrix
+        A = mp.matrix(m,n)
+
+        # populate matrix values with arbitrary integers
+        if flg:
+            flg = False
+            dtype = 'complex'
+            for j in xrange(0,n):
+                for i in xrange(0,m):
+                    val = nint(lowlimit + (uplimit-lowlimit)*rand())
+                    val2 = nint(lowlimit + (uplimit-lowlimit)*rand())
+                    A[i,j] = mpc(val, val2)
+        else:
+            flg = True
+            dtype = 'real'
+            for j in xrange(0,n):
+                for i in xrange(0,m):
+                    val = nint(lowlimit + (uplimit-lowlimit)*rand())
+                    A[i,j] = mpf(val)
+
+        # perform A -> QR decomposition
+        Q, R = qr(A, mode, edps = exdps)
+
+        #print('\n\n A = \n', nstr(A, 4))
+        #print('\n Q = \n', nstr(Q, 4))
+        #print('\n R = \n', nstr(R, 4))
+        #print('\n Q*R = \n', nstr(Q*R, 4))
+
+        maxnorm = mpf('1.0E-11')
+        n1 = norm(A - Q * R)
+        #print '\n Norm of A - Q * R = ', n1
+        assert n1 <= maxnorm
+
+        if dtype == 'real':
+            n1 = norm(eye(m) - Q.T * Q)
+            #print ' Norm of I - Q.T * Q = ', n1
+            assert n1 <= maxnorm
+
+            n1 = norm(eye(m) - Q * Q.T)
+            #print ' Norm of I - Q * Q.T = ', n1
+            assert n1 <= maxnorm
+
+        if dtype == 'complex':
+            n1 = norm(eye(m) - Q.T * Q.conjugate())
+            #print ' Norm of I - Q.T * Q.conjugate() = ', n1
+            assert n1 <= maxnorm
+
+            n1 = norm(eye(m) - Q.conjugate() * Q.T)
+            #print ' Norm of I - Q.conjugate() * Q.T = ', n1
+            assert n1 <= maxnorm
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_matrices.py b/lib/python3.10/site-packages/mpmath/tests/test_matrices.py
new file mode 100644
index 0000000000000000000000000000000000000000..1547b90664dba66a98a7f026a04a4ed1aa1ed3b4
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_matrices.py
@@ -0,0 +1,253 @@
+import pytest
+import sys
+from mpmath import *
+
+def test_matrix_basic():
+    A1 = matrix(3)
+    for i in range(3):
+        A1[i,i] = 1
+    assert A1 == eye(3)
+    assert A1 == matrix(A1)
+    A2 = matrix(3, 2)
+    assert not A2._matrix__data
+    A3 = matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    assert list(A3) == list(range(1, 10))
+    A3[1,1] = 0
+    assert not (1, 1) in A3._matrix__data
+    A4 = matrix([[1, 2, 3], [4, 5, 6]])
+    A5 = matrix([[6, -1], [3, 2], [0, -3]])
+    assert A4 * A5 == matrix([[12, -6], [39, -12]])
+    assert A1 * A3 == A3 * A1 == A3
+    pytest.raises(ValueError, lambda: A2*A2)
+    l = [[10, 20, 30], [40, 0, 60], [70, 80, 90]]
+    A6 = matrix(l)
+    assert A6.tolist() == l
+    assert A6 == eval(repr(A6))
+    A6 = fp.matrix(A6)
+    assert A6 == eval(repr(A6))
+    assert A6*1j == eval(repr(A6*1j))
+    assert A3 * 10 == 10 * A3 == A6
+    assert A2.rows == 3
+    assert A2.cols == 2
+    A3.rows = 2
+    A3.cols = 2
+    assert len(A3._matrix__data) == 3
+    assert A4 + A4 == 2*A4
+    pytest.raises(ValueError, lambda: A4 + A2)
+    assert sum(A1 - A1) == 0
+    A7 = matrix([[1, 2], [3, 4], [5, 6], [7, 8]])
+    x = matrix([10, -10])
+    assert A7*x == matrix([-10, -10, -10, -10])
+    A8 = ones(5)
+    assert sum((A8 + 1) - (2 - zeros(5))) == 0
+    assert (1 + ones(4)) / 2 - 1 == zeros(4)
+    assert eye(3)**10 == eye(3)
+    pytest.raises(ValueError, lambda: A7**2)
+    A9 = randmatrix(3)
+    A10 = matrix(A9)
+    A9[0,0] = -100
+    assert A9 != A10
+    assert nstr(A9)
+
+def test_matmul():
+    """
+    Test the PEP465 "@" matrix multiplication syntax.
+    To avoid syntax errors when importing this file in Python 3.5 and below, we have to use exec() - sorry for that.
+    """
+    # TODO remove exec() wrapper as soon as we drop support for Python <= 3.5
+    if sys.hexversion < 0x30500f0:
+        # we are on Python < 3.5
+        pytest.skip("'@' (__matmul__) is only supported in Python 3.5 or newer")
+    A4 = matrix([[1, 2, 3], [4, 5, 6]])
+    A5 = matrix([[6, -1], [3, 2], [0, -3]])
+    exec("assert A4 @ A5 == A4 * A5")
+
+def test_matrix_slices():
+    A = matrix([    [1, 2, 3],
+                        [4, 5 ,6],
+                        [7, 8 ,9]])
+    V = matrix([1,2,3,4,5])
+
+    # Get slice
+    assert A[:,:] == A
+    assert A[:,1] == matrix([[2],[5],[8]])
+    assert A[2,:] == matrix([[7, 8 ,9]])
+    assert A[1:3,1:3] == matrix([[5,6],[8,9]])
+    assert V[2:4] == matrix([3,4])
+    pytest.raises(IndexError, lambda: A[:,1:6])
+
+    # Assign slice with matrix
+    A1 = matrix(3)
+    A1[:,:] = A
+    assert A1[:,:] == matrix([[1, 2, 3],
+                                        [4, 5 ,6],
+                                        [7, 8 ,9]])
+    A1[0,:] = matrix([[10, 11, 12]])
+    assert A1 == matrix([ [10, 11, 12],
+                                    [4, 5 ,6],
+                                    [7, 8 ,9]])
+    A1[:,2] = matrix([[13], [14], [15]])
+    assert A1 == matrix([ [10, 11, 13],
+                                    [4, 5 ,14],
+                                    [7, 8 ,15]])
+    A1[:2,:2] = matrix([[16, 17], [18 , 19]])
+    assert A1 == matrix([ [16, 17, 13],
+                                    [18, 19 ,14],
+                                    [7, 8 ,15]])
+    V[1:3] = 10
+    assert V == matrix([1,10,10,4,5])
+    with pytest.raises(ValueError):
+        A1[2,:] = A[:,1]
+
+    with pytest.raises(IndexError):
+        A1[2,1:20] = A[:,:]
+
+    # Assign slice with scalar
+    A1[:,2] = 10
+    assert A1 == matrix([ [16, 17, 10],
+                                    [18, 19 ,10],
+                                    [7, 8 ,10]])
+    A1[:,:] = 40
+    for x in A1:
+        assert x == 40
+
+
+def test_matrix_power():
+    A = matrix([[1, 2], [3, 4]])
+    assert A**2 == A*A
+    assert A**3 == A*A*A
+    assert A**-1 == inverse(A)
+    assert A**-2 == inverse(A*A)
+
+def test_matrix_transform():
+    A = matrix([[1, 2], [3, 4], [5, 6]])
+    assert A.T == A.transpose() == matrix([[1, 3, 5], [2, 4, 6]])
+    swap_row(A, 1, 2)
+    assert A == matrix([[1, 2], [5, 6], [3, 4]])
+    l = [1, 2]
+    swap_row(l, 0, 1)
+    assert l == [2, 1]
+    assert extend(eye(3), [1,2,3]) == matrix([[1,0,0,1],[0,1,0,2],[0,0,1,3]])
+
+def test_matrix_conjugate():
+    A = matrix([[1 + j, 0], [2, j]])
+    assert A.conjugate() == matrix([[mpc(1, -1), 0], [2, mpc(0, -1)]])
+    assert A.transpose_conj() == A.H == matrix([[mpc(1, -1), 2],
+                                                [0, mpc(0, -1)]])
+
+def test_matrix_creation():
+    assert diag([1, 2, 3]) == matrix([[1, 0, 0], [0, 2, 0], [0, 0, 3]])
+    A1 = ones(2, 3)
+    assert A1.rows == 2 and A1.cols == 3
+    for a in A1:
+        assert a == 1
+    A2 = zeros(3, 2)
+    assert A2.rows == 3 and A2.cols == 2
+    for a in A2:
+        assert a == 0
+    assert randmatrix(10) != randmatrix(10)
+    one = mpf(1)
+    assert hilbert(3) == matrix([[one, one/2, one/3],
+                                 [one/2, one/3, one/4],
+                                 [one/3, one/4, one/5]])
+
+def test_norms():
+    # matrix norms
+    A = matrix([[1, -2], [-3, -1], [2, 1]])
+    assert mnorm(A,1) == 6
+    assert mnorm(A,inf) == 4
+    assert mnorm(A,'F') == sqrt(20)
+    # vector norms
+    assert norm(-3) == 3
+    x = [1, -2, 7, -12]
+    assert norm(x, 1) == 22
+    assert round(norm(x, 2), 10) == 14.0712472795
+    assert round(norm(x, 10), 10) == 12.0054633727
+    assert norm(x, inf) == 12
+
+def test_vector():
+    x = matrix([0, 1, 2, 3, 4])
+    assert x == matrix([[0], [1], [2], [3], [4]])
+    assert x[3] == 3
+    assert len(x._matrix__data) == 4
+    assert list(x) == list(range(5))
+    x[0] = -10
+    x[4] = 0
+    assert x[0] == -10
+    assert len(x) == len(x.T) == 5
+    assert x.T*x == matrix([[114]])
+
+def test_matrix_copy():
+    A = ones(6)
+    B = A.copy()
+    C = +A
+    assert A == B
+    assert A == C
+    B[0,0] = 0
+    assert A != B
+    C[0,0] = 42
+    assert A != C
+
+def test_matrix_numpy():
+    try:
+        import numpy
+    except ImportError:
+        return
+    l = [[1, 2], [3, 4], [5, 6]]
+    a = numpy.array(l)
+    assert matrix(l) == matrix(a)
+
+def test_interval_matrix_scalar_mult():
+    """Multiplication of iv.matrix and any scalar type"""
+    a = mpi(-1, 1)
+    b = a + a * 2j
+    c = mpf(42)
+    d = c + c * 2j
+    e = 1.234
+    f = fp.convert(e)
+    g = e + e * 3j
+    h = fp.convert(g)
+    M = iv.ones(1)
+    for x in [a, b, c, d, e, f, g, h]:
+        assert x * M == iv.matrix([x])
+        assert M * x == iv.matrix([x])
+
+@pytest.mark.xfail()
+def test_interval_matrix_matrix_mult():
+    """Multiplication of iv.matrix and other matrix types"""
+    A = ones(1)
+    B = fp.ones(1)
+    M = iv.ones(1)
+    for X in [A, B, M]:
+        assert X * M == iv.matrix(X)
+        assert X * M == X
+        assert M * X == iv.matrix(X)
+        assert M * X == X
+
+def test_matrix_conversion_to_iv():
+    # Test that matrices with foreign datatypes are properly converted
+    for other_type_eye in [eye(3), fp.eye(3), iv.eye(3)]:
+        A = iv.matrix(other_type_eye)
+        B = iv.eye(3)
+        assert type(A[0,0]) == type(B[0,0])
+        assert A.tolist() == B.tolist()
+
+def test_interval_matrix_mult_bug():
+    # regression test for interval matrix multiplication:
+    # result must be nonzero-width and contain the exact result
+    x = convert('1.00000000000001') # note: this is implicitly rounded to some near mpf float value
+    A = matrix([[x]])
+    B = iv.matrix(A)
+    C = iv.matrix([[x]])
+    assert B == C
+    B = B * B
+    C = C * C
+    assert B == C
+    assert B[0, 0].delta > 1e-16
+    assert B[0, 0].delta < 3e-16
+    assert C[0, 0].delta > 1e-16
+    assert C[0, 0].delta < 3e-16
+    assert mp.mpf('1.00000000000001998401444325291756783368705994138804689654') in B[0, 0]
+    assert mp.mpf('1.00000000000001998401444325291756783368705994138804689654') in C[0, 0]
+    # the following caused an error before the bug was fixed
+    assert iv.matrix(mp.eye(2)) * (iv.ones(2) + mpi(1, 2)) == iv.matrix([[mpi(2, 3), mpi(2, 3)], [mpi(2, 3), mpi(2, 3)]])
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_mpmath.py b/lib/python3.10/site-packages/mpmath/tests/test_mpmath.py
new file mode 100644
index 0000000000000000000000000000000000000000..9f1fe36ae9b1b0feca4677eeb90396bfa7ed8f7a
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_mpmath.py
@@ -0,0 +1,7 @@
+from mpmath.libmp import *
+from mpmath import *
+
+def test_newstyle_classes():
+    for cls in [mp, fp, iv, mpf, mpc]:
+        for s in cls.__class__.__mro__:
+            assert isinstance(s, type)
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_ode.py b/lib/python3.10/site-packages/mpmath/tests/test_ode.py
new file mode 100644
index 0000000000000000000000000000000000000000..6b6dbffa79cfd4ca6dbf14f8591296ee48b16682
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_ode.py
@@ -0,0 +1,73 @@
+#from mpmath.calculus import ODE_step_euler, ODE_step_rk4, odeint, arange
+from mpmath import odefun, cos, sin, mpf, sinc, mp
+
+'''
+solvers = [ODE_step_euler, ODE_step_rk4]
+
+def test_ode1():
+    """
+    Let's solve:
+
+    x'' + w**2 * x = 0
+
+    i.e. x1 = x, x2 = x1':
+
+    x1' =  x2
+    x2' = -x1
+    """
+    def derivs((x1, x2), t):
+        return x2, -x1
+
+    for solver in solvers:
+        t = arange(0, 3.1415926, 0.005)
+        sol = odeint(derivs, (0., 1.), t, solver)
+        x1 = [a[0] for a in sol]
+        x2 = [a[1] for a in sol]
+        # the result is x1 = sin(t), x2 = cos(t)
+        # let's just check the end points for t = pi
+        assert abs(x1[-1]) < 1e-2
+        assert abs(x2[-1] - (-1)) < 1e-2
+
+def test_ode2():
+    """
+    Let's solve:
+
+    x' - x = 0
+
+    i.e. x = exp(x)
+
+    """
+    def derivs((x), t):
+        return x
+
+    for solver in solvers:
+        t = arange(0, 1, 1e-3)
+        sol = odeint(derivs, (1.,), t, solver)
+        x = [a[0] for a in sol]
+        # the result is x = exp(t)
+        # let's just check the end point for t = 1, i.e. x = e
+        assert abs(x[-1] - 2.718281828) < 1e-2
+'''
+
+def test_odefun_rational():
+    mp.dps = 15
+    # A rational function
+    f = lambda t: 1/(1+mpf(t)**2)
+    g = odefun(lambda x, y: [-2*x*y[0]**2], 0, [f(0)])
+    assert f(2).ae(g(2)[0])
+
+def test_odefun_sinc_large():
+    mp.dps = 15
+    # Sinc function; test for large x
+    f = sinc
+    g = odefun(lambda x, y: [(cos(x)-y[0])/x], 1, [f(1)], tol=0.01, degree=5)
+    assert abs(f(100) - g(100)[0])/f(100) < 0.01
+
+def test_odefun_harmonic():
+    mp.dps = 15
+    # Harmonic oscillator
+    f = odefun(lambda x, y: [-y[1], y[0]], 0, [1, 0])
+    for x in [0, 1, 2.5, 8, 3.7]:    #  we go back to 3.7 to check caching
+        c, s = f(x)
+        assert c.ae(cos(x))
+        assert s.ae(sin(x))
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_pickle.py b/lib/python3.10/site-packages/mpmath/tests/test_pickle.py
new file mode 100644
index 0000000000000000000000000000000000000000..c3d96e73a53603e0fa3f9525c5c0059725bdffb7
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_pickle.py
@@ -0,0 +1,27 @@
+import os
+import tempfile
+import pickle
+
+from mpmath import *
+
+def pickler(obj):
+    fn = tempfile.mktemp()
+
+    f = open(fn, 'wb')
+    pickle.dump(obj, f)
+    f.close()
+
+    f = open(fn, 'rb')
+    obj2 = pickle.load(f)
+    f.close()
+    os.remove(fn)
+
+    return obj2
+
+def test_pickle():
+
+    obj = mpf('0.5')
+    assert obj == pickler(obj)
+
+    obj = mpc('0.5','0.2')
+    assert obj == pickler(obj)
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_power.py b/lib/python3.10/site-packages/mpmath/tests/test_power.py
new file mode 100644
index 0000000000000000000000000000000000000000..7a2447a62c36f9e02df79b9a40a8603f8a69b1d8
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_power.py
@@ -0,0 +1,156 @@
+from mpmath import *
+from mpmath.libmp import *
+
+import random
+
+def test_fractional_pow():
+    mp.dps = 15
+    assert mpf(16) ** 2.5 == 1024
+    assert mpf(64) ** 0.5 == 8
+    assert mpf(64) ** -0.5 == 0.125
+    assert mpf(16) ** -2.5 == 0.0009765625
+    assert (mpf(10) ** 0.5).ae(3.1622776601683791)
+    assert (mpf(10) ** 2.5).ae(316.2277660168379)
+    assert (mpf(10) ** -0.5).ae(0.31622776601683794)
+    assert (mpf(10) ** -2.5).ae(0.0031622776601683794)
+    assert (mpf(10) ** 0.3).ae(1.9952623149688795)
+    assert (mpf(10) ** -0.3).ae(0.50118723362727224)
+
+def test_pow_integer_direction():
+    """
+    Test that inexact integer powers are rounded in the right
+    direction.
+    """
+    random.seed(1234)
+    for prec in [10, 53, 200]:
+        for i in range(50):
+            a = random.randint(1<<(prec-1), 1<<prec)
+            b = random.randint(2, 100)
+            ab = a**b
+            # note: could actually be exact, but that's very unlikely!
+            assert to_int(mpf_pow(from_int(a), from_int(b), prec, round_down)) < ab
+            assert to_int(mpf_pow(from_int(a), from_int(b), prec, round_up)) > ab
+
+
+def test_pow_epsilon_rounding():
+    """
+    Stress test directed rounding for powers with integer exponents.
+    Basically, we look at the following cases:
+
+    >>> 1.0001 ** -5 # doctest: +SKIP
+    0.99950014996500702
+    >>> 0.9999 ** -5 # doctest: +SKIP
+    1.000500150035007
+    >>> (-1.0001) ** -5 # doctest: +SKIP
+    -0.99950014996500702
+    >>> (-0.9999) ** -5 # doctest: +SKIP
+    -1.000500150035007
+
+    >>> 1.0001 ** -6 # doctest: +SKIP
+    0.99940020994401269
+    >>> 0.9999 ** -6 # doctest: +SKIP
+    1.0006002100560125
+    >>> (-1.0001) ** -6 # doctest: +SKIP
+    0.99940020994401269
+    >>> (-0.9999) ** -6 # doctest: +SKIP
+    1.0006002100560125
+
+    etc.
+
+    We run the tests with values a very small epsilon away from 1:
+    small enough that the result is indistinguishable from 1 when
+    rounded to nearest at the output precision. We check that the
+    result is not erroneously rounded to 1 in cases where the
+    rounding should be done strictly away from 1.
+    """
+
+    def powr(x, n, r):
+        return make_mpf(mpf_pow_int(x._mpf_, n, mp.prec, r))
+
+    for (inprec, outprec) in [(100, 20), (5000, 3000)]:
+
+        mp.prec = inprec
+
+        pos10001 = mpf(1) + mpf(2)**(-inprec+5)
+        pos09999 = mpf(1) - mpf(2)**(-inprec+5)
+        neg10001 = -pos10001
+        neg09999 = -pos09999
+
+        mp.prec = outprec
+        r = round_up
+        assert powr(pos10001, 5, r) > 1
+        assert powr(pos09999, 5, r) == 1
+        assert powr(neg10001, 5, r) < -1
+        assert powr(neg09999, 5, r) == -1
+        assert powr(pos10001, 6, r) > 1
+        assert powr(pos09999, 6, r) == 1
+        assert powr(neg10001, 6, r) > 1
+        assert powr(neg09999, 6, r) == 1
+
+        assert powr(pos10001, -5, r) == 1
+        assert powr(pos09999, -5, r) > 1
+        assert powr(neg10001, -5, r) == -1
+        assert powr(neg09999, -5, r) < -1
+        assert powr(pos10001, -6, r) == 1
+        assert powr(pos09999, -6, r) > 1
+        assert powr(neg10001, -6, r) == 1
+        assert powr(neg09999, -6, r) > 1
+
+        r = round_down
+        assert powr(pos10001, 5, r) == 1
+        assert powr(pos09999, 5, r) < 1
+        assert powr(neg10001, 5, r) == -1
+        assert powr(neg09999, 5, r) > -1
+        assert powr(pos10001, 6, r) == 1
+        assert powr(pos09999, 6, r) < 1
+        assert powr(neg10001, 6, r) == 1
+        assert powr(neg09999, 6, r) < 1
+
+        assert powr(pos10001, -5, r) < 1
+        assert powr(pos09999, -5, r) == 1
+        assert powr(neg10001, -5, r) > -1
+        assert powr(neg09999, -5, r) == -1
+        assert powr(pos10001, -6, r) < 1
+        assert powr(pos09999, -6, r) == 1
+        assert powr(neg10001, -6, r) < 1
+        assert powr(neg09999, -6, r) == 1
+
+        r = round_ceiling
+        assert powr(pos10001, 5, r) > 1
+        assert powr(pos09999, 5, r) == 1
+        assert powr(neg10001, 5, r) == -1
+        assert powr(neg09999, 5, r) > -1
+        assert powr(pos10001, 6, r) > 1
+        assert powr(pos09999, 6, r) == 1
+        assert powr(neg10001, 6, r) > 1
+        assert powr(neg09999, 6, r) == 1
+
+        assert powr(pos10001, -5, r) == 1
+        assert powr(pos09999, -5, r) > 1
+        assert powr(neg10001, -5, r) > -1
+        assert powr(neg09999, -5, r) == -1
+        assert powr(pos10001, -6, r) == 1
+        assert powr(pos09999, -6, r) > 1
+        assert powr(neg10001, -6, r) == 1
+        assert powr(neg09999, -6, r) > 1
+
+        r = round_floor
+        assert powr(pos10001, 5, r) == 1
+        assert powr(pos09999, 5, r) < 1
+        assert powr(neg10001, 5, r) < -1
+        assert powr(neg09999, 5, r) == -1
+        assert powr(pos10001, 6, r) == 1
+        assert powr(pos09999, 6, r) < 1
+        assert powr(neg10001, 6, r) == 1
+        assert powr(neg09999, 6, r) < 1
+
+        assert powr(pos10001, -5, r) < 1
+        assert powr(pos09999, -5, r) == 1
+        assert powr(neg10001, -5, r) == -1
+        assert powr(neg09999, -5, r) < -1
+        assert powr(pos10001, -6, r) < 1
+        assert powr(pos09999, -6, r) == 1
+        assert powr(neg10001, -6, r) < 1
+        assert powr(neg09999, -6, r) == 1
+
+    mp.dps = 15
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_quad.py b/lib/python3.10/site-packages/mpmath/tests/test_quad.py
new file mode 100644
index 0000000000000000000000000000000000000000..fc71c5f5ef9c0ecd876c988e7d033b321f065cdc
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_quad.py
@@ -0,0 +1,95 @@
+import pytest
+from mpmath import *
+
+def ae(a, b):
+    return abs(a-b) < 10**(-mp.dps+5)
+
+def test_basic_integrals():
+    for prec in [15, 30, 100]:
+        mp.dps = prec
+        assert ae(quadts(lambda x: x**3 - 3*x**2, [-2, 4]), -12)
+        assert ae(quadgl(lambda x: x**3 - 3*x**2, [-2, 4]), -12)
+        assert ae(quadts(sin, [0, pi]), 2)
+        assert ae(quadts(sin, [0, 2*pi]), 0)
+        assert ae(quadts(exp, [-inf, -1]), 1/e)
+        assert ae(quadts(lambda x: exp(-x), [0, inf]), 1)
+        assert ae(quadts(lambda x: exp(-x*x), [-inf, inf]), sqrt(pi))
+        assert ae(quadts(lambda x: 1/(1+x*x), [-1, 1]), pi/2)
+        assert ae(quadts(lambda x: 1/(1+x*x), [-inf, inf]), pi)
+        assert ae(quadts(lambda x: 2*sqrt(1-x*x), [-1, 1]), pi)
+    mp.dps = 15
+
+def test_multiple_intervals():
+    y,err = quad(lambda x: sign(x), [-0.5, 0.9, 1], maxdegree=2, error=True)
+    assert abs(y-0.5) < 2*err
+
+def test_quad_symmetry():
+    assert quadts(sin, [-1, 1]) == 0
+    assert quadgl(sin, [-1, 1]) == 0
+
+def test_quad_infinite_mirror():
+    # Check mirrored infinite interval
+    assert ae(quad(lambda x: exp(-x*x), [inf,-inf]), -sqrt(pi))
+    assert ae(quad(lambda x: exp(x), [0,-inf]), -1)
+
+def test_quadgl_linear():
+    assert quadgl(lambda x: x, [0, 1], maxdegree=1).ae(0.5)
+
+def test_complex_integration():
+    assert quadts(lambda x: x, [0, 1+j]).ae(j)
+
+def test_quadosc():
+    mp.dps = 15
+    assert quadosc(lambda x: sin(x)/x, [0, inf], period=2*pi).ae(pi/2)
+
+# Double integrals
+def test_double_trivial():
+    assert ae(quadts(lambda x, y: x, [0, 1], [0, 1]), 0.5)
+    assert ae(quadts(lambda x, y: x, [-1, 1], [-1, 1]), 0.0)
+
+def test_double_1():
+    assert ae(quadts(lambda x, y: cos(x+y/2), [-pi/2, pi/2], [0, pi]), 4)
+
+def test_double_2():
+    assert ae(quadts(lambda x, y: (x-1)/((1-x*y)*log(x*y)), [0, 1], [0, 1]), euler)
+
+def test_double_3():
+    assert ae(quadts(lambda x, y: 1/sqrt(1+x*x+y*y), [-1, 1], [-1, 1]), 4*log(2+sqrt(3))-2*pi/3)
+
+def test_double_4():
+    assert ae(quadts(lambda x, y: 1/(1-x*x * y*y), [0, 1], [0, 1]), pi**2 / 8)
+
+def test_double_5():
+    assert ae(quadts(lambda x, y: 1/(1-x*y), [0, 1], [0, 1]), pi**2 / 6)
+
+def test_double_6():
+    assert ae(quadts(lambda x, y: exp(-(x+y)), [0, inf], [0, inf]), 1)
+
+def test_double_7():
+    assert ae(quadts(lambda x, y: exp(-x*x-y*y), [-inf, inf], [-inf, inf]), pi)
+
+
+# Test integrals from "Experimentation in Mathematics" by Borwein,
+# Bailey & Girgensohn
+def test_expmath_integrals():
+    for prec in [15, 30, 50]:
+        mp.dps = prec
+        assert ae(quadts(lambda x: x/sinh(x), [0, inf]),                    pi**2 / 4)
+        assert ae(quadts(lambda x: log(x)**2 / (1+x**2), [0, inf]),         pi**3 / 8)
+        assert ae(quadts(lambda x: (1+x**2)/(1+x**4), [0, inf]),            pi/sqrt(2))
+        assert ae(quadts(lambda x: log(x)/cosh(x)**2, [0, inf]),            log(pi)-2*log(2)-euler)
+        assert ae(quadts(lambda x: log(1+x**3)/(1-x+x**2), [0, inf]),       2*pi*log(3)/sqrt(3))
+        assert ae(quadts(lambda x: log(x)**2 / (x**2+x+1), [0, 1]),         8*pi**3 / (81*sqrt(3)))
+        assert ae(quadts(lambda x: log(cos(x))**2, [0, pi/2]),              pi/2 * (log(2)**2+pi**2/12))
+        assert ae(quadts(lambda x: x**2 / sin(x)**2, [0, pi/2]),            pi*log(2))
+        assert ae(quadts(lambda x: x**2/sqrt(exp(x)-1), [0, inf]),          4*pi*(log(2)**2 + pi**2/12))
+        assert ae(quadts(lambda x: x*exp(-x)*sqrt(1-exp(-2*x)), [0, inf]),  pi*(1+2*log(2))/8)
+    mp.dps = 15
+
+# Do not reach full accuracy
+@pytest.mark.xfail
+def test_expmath_fail():
+    assert ae(quadts(lambda x: sqrt(tan(x)), [0, pi/2]),          pi*sqrt(2)/2)
+    assert ae(quadts(lambda x: atan(x)/(x*sqrt(1-x**2)), [0, 1]), pi*log(1+sqrt(2))/2)
+    assert ae(quadts(lambda x: log(1+x**2)/x**2, [0, 1]),         pi/2-log(2))
+    assert ae(quadts(lambda x: x**2/((1+x**4)*sqrt(1-x**4)), [0, 1]),     pi/8)
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_rootfinding.py b/lib/python3.10/site-packages/mpmath/tests/test_rootfinding.py
new file mode 100644
index 0000000000000000000000000000000000000000..7c3c06463682eb1fd60efeb75b809bbb932a241c
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_rootfinding.py
@@ -0,0 +1,91 @@
+import pytest
+from mpmath import *
+from mpmath.calculus.optimization import Secant, Muller, Bisection, Illinois, \
+    Pegasus, Anderson, Ridder, ANewton, Newton, MNewton, MDNewton
+
+def test_findroot():
+    # old tests, assuming secant
+    mp.dps = 15
+    assert findroot(lambda x: 4*x-3, mpf(5)).ae(0.75)
+    assert findroot(sin, mpf(3)).ae(pi)
+    assert findroot(sin, (mpf(3), mpf(3.14))).ae(pi)
+    assert findroot(lambda x: x*x+1, mpc(2+2j)).ae(1j)
+    # test all solvers with 1 starting point
+    f = lambda x: cos(x)
+    for solver in [Newton, Secant, MNewton, Muller, ANewton]:
+        x = findroot(f, 2., solver=solver)
+        assert abs(f(x)) < eps
+    # test all solvers with interval of 2 points
+    for solver in [Secant, Muller, Bisection, Illinois, Pegasus, Anderson,
+                   Ridder]:
+        x = findroot(f, (1., 2.), solver=solver)
+        assert abs(f(x)) < eps
+    # test types
+    f = lambda x: (x - 2)**2
+
+    assert isinstance(findroot(f, 1, tol=1e-10), mpf)
+    assert isinstance(iv.findroot(f, 1., tol=1e-10), iv.mpf)
+    assert isinstance(fp.findroot(f, 1, tol=1e-10), float)
+    assert isinstance(fp.findroot(f, 1+0j, tol=1e-10), complex)
+
+    # issue 401
+    with pytest.raises(ValueError):
+        with workprec(2):
+            findroot(lambda x: x**2 - 4456178*x + 60372201703370,
+                     mpc(real='5.278e+13', imag='-5.278e+13'))
+
+    # issue 192
+    with pytest.raises(ValueError):
+        findroot(lambda x: -1, 0)
+
+    # issue 387
+    with pytest.raises(ValueError):
+        findroot(lambda p: (1 - p)**30 - 1, 0.9)
+
+def test_bisection():
+    # issue 273
+    assert findroot(lambda x: x**2-1,(0,2),solver='bisect') == 1
+
+def test_mnewton():
+    f = lambda x: polyval([1,3,3,1],x)
+    x = findroot(f, -0.9, solver='mnewton')
+    assert abs(f(x)) < eps
+
+def test_anewton():
+    f = lambda x: (x - 2)**100
+    x = findroot(f, 1., solver=ANewton)
+    assert abs(f(x)) < eps
+
+def test_muller():
+    f = lambda x: (2 + x)**3 + 2
+    x = findroot(f, 1., solver=Muller)
+    assert abs(f(x)) < eps
+
+def test_multiplicity():
+    for i in range(1, 5):
+        assert multiplicity(lambda x: (x - 1)**i, 1) == i
+    assert multiplicity(lambda x: x**2, 1) == 0
+
+def test_multidimensional():
+    def f(*x):
+        return [3*x[0]**2-2*x[1]**2-1, x[0]**2-2*x[0]+x[1]**2+2*x[1]-8]
+    assert mnorm(jacobian(f, (1,-2)) - matrix([[6,8],[0,-2]]),1) < 1.e-7
+    for x, error in MDNewton(mp, f, (1,-2), verbose=0,
+                             norm=lambda x: norm(x, inf)):
+        pass
+    assert norm(f(*x), 2) < 1e-14
+    # The Chinese mathematician Zhu Shijie was the very first to solve this
+    # nonlinear system 700 years ago
+    f1 = lambda x, y: -x + 2*y
+    f2 = lambda x, y: (x**2 + x*(y**2 - 2) - 4*y)  /  (x + 4)
+    f3 = lambda x, y: sqrt(x**2 + y**2)
+    def f(x, y):
+        f1x = f1(x, y)
+        return (f2(x, y) - f1x, f3(x, y) - f1x)
+    x = findroot(f, (10, 10))
+    assert [int(round(i)) for i in x] == [3, 4]
+
+def test_trivial():
+    assert findroot(lambda x: 0, 1) == 1
+    assert findroot(lambda x: x, 0) == 0
+    #assert findroot(lambda x, y: x + y, (1, -1)) == (1, -1)
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_special.py b/lib/python3.10/site-packages/mpmath/tests/test_special.py
new file mode 100644
index 0000000000000000000000000000000000000000..30825abd89ada00f937260cb51ef649546be7021
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_special.py
@@ -0,0 +1,113 @@
+from mpmath import *
+
+def test_special():
+    assert inf == inf
+    assert inf != -inf
+    assert -inf == -inf
+    assert inf != nan
+    assert nan != nan
+    assert isnan(nan)
+    assert --inf == inf
+    assert abs(inf) == inf
+    assert abs(-inf) == inf
+    assert abs(nan) != abs(nan)
+
+    assert isnan(inf - inf)
+    assert isnan(inf + (-inf))
+    assert isnan(-inf - (-inf))
+
+    assert isnan(inf + nan)
+    assert isnan(-inf + nan)
+
+    assert mpf(2) + inf == inf
+    assert 2 + inf == inf
+    assert mpf(2) - inf == -inf
+    assert 2 - inf == -inf
+
+    assert inf > 3
+    assert 3 < inf
+    assert 3 > -inf
+    assert -inf < 3
+    assert inf > mpf(3)
+    assert mpf(3) < inf
+    assert mpf(3) > -inf
+    assert -inf < mpf(3)
+
+    assert not (nan < 3)
+    assert not (nan > 3)
+
+    assert isnan(inf * 0)
+    assert isnan(-inf * 0)
+    assert inf * 3 == inf
+    assert inf * -3 == -inf
+    assert -inf * 3 == -inf
+    assert -inf * -3 == inf
+    assert inf * inf == inf
+    assert -inf * -inf == inf
+
+    assert isnan(nan / 3)
+    assert inf / -3 == -inf
+    assert inf / 3 == inf
+    assert 3 / inf == 0
+    assert -3 / inf == 0
+    assert 0 / inf == 0
+    assert isnan(inf / inf)
+    assert isnan(inf / -inf)
+    assert isnan(inf / nan)
+
+    assert mpf('inf') == mpf('+inf') == inf
+    assert mpf('-inf') == -inf
+    assert isnan(mpf('nan'))
+
+    assert isinf(inf)
+    assert isinf(-inf)
+    assert not isinf(mpf(0))
+    assert not isinf(nan)
+
+def test_special_powers():
+    assert inf**3 == inf
+    assert isnan(inf**0)
+    assert inf**-3 == 0
+    assert (-inf)**2 == inf
+    assert (-inf)**3 == -inf
+    assert isnan((-inf)**0)
+    assert (-inf)**-2 == 0
+    assert (-inf)**-3 == 0
+    assert isnan(nan**5)
+    assert isnan(nan**0)
+
+def test_functions_special():
+    assert exp(inf) == inf
+    assert exp(-inf) == 0
+    assert isnan(exp(nan))
+    assert log(inf) == inf
+    assert isnan(log(nan))
+    assert isnan(sin(inf))
+    assert isnan(sin(nan))
+    assert atan(inf).ae(pi/2)
+    assert atan(-inf).ae(-pi/2)
+    assert isnan(sqrt(nan))
+    assert sqrt(inf) == inf
+
+def test_convert_special():
+    float_inf = 1e300 * 1e300
+    float_ninf = -float_inf
+    float_nan = float_inf/float_ninf
+    assert mpf(3) * float_inf == inf
+    assert mpf(3) * float_ninf == -inf
+    assert isnan(mpf(3) * float_nan)
+    assert not (mpf(3) < float_nan)
+    assert not (mpf(3) > float_nan)
+    assert not (mpf(3) <= float_nan)
+    assert not (mpf(3) >= float_nan)
+    assert float(mpf('1e1000')) == float_inf
+    assert float(mpf('-1e1000')) == float_ninf
+    assert float(mpf('1e100000000000000000')) == float_inf
+    assert float(mpf('-1e100000000000000000')) == float_ninf
+    assert float(mpf('1e-100000000000000000')) == 0.0
+
+def test_div_bug():
+    assert isnan(nan/1)
+    assert isnan(nan/2)
+    assert inf/2 == inf
+    assert (-inf)/2 == -inf
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_str.py b/lib/python3.10/site-packages/mpmath/tests/test_str.py
new file mode 100644
index 0000000000000000000000000000000000000000..569244f252c057ec1029b7efbd8b0ffbfbc47522
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_str.py
@@ -0,0 +1,14 @@
+from mpmath import nstr, matrix, inf
+
+def test_nstr():
+    m = matrix([[0.75, 0.190940654, -0.0299195971],
+                [0.190940654, 0.65625, 0.205663228],
+                [-0.0299195971, 0.205663228, 0.64453125e-20]])
+    assert nstr(m, 4, min_fixed=-inf) == \
+    '''[    0.75  0.1909                    -0.02992]
+[  0.1909  0.6563                      0.2057]
+[-0.02992  0.2057  0.000000000000000000006445]'''
+    assert nstr(m, 4) == \
+    '''[    0.75  0.1909   -0.02992]
+[  0.1909  0.6563     0.2057]
+[-0.02992  0.2057  6.445e-21]'''
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_summation.py b/lib/python3.10/site-packages/mpmath/tests/test_summation.py
new file mode 100644
index 0000000000000000000000000000000000000000..04ffd29f994e1e6310678eec292c0e03f2d6c725
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_summation.py
@@ -0,0 +1,53 @@
+from mpmath import *
+
+def test_sumem():
+    mp.dps = 15
+    assert sumem(lambda k: 1/k**2.5, [50, 100]).ae(0.0012524505324784962)
+    assert sumem(lambda k: k**4 + 3*k + 1, [10, 100]).ae(2050333103)
+
+def test_nsum():
+    mp.dps = 15
+    assert nsum(lambda x: x**2, [1, 3]) == 14
+    assert nsum(lambda k: 1/factorial(k), [0, inf]).ae(e)
+    assert nsum(lambda k: (-1)**(k+1) / k, [1, inf]).ae(log(2))
+    assert nsum(lambda k: (-1)**(k+1) / k**2, [1, inf]).ae(pi**2 / 12)
+    assert nsum(lambda k: (-1)**k / log(k), [2, inf]).ae(0.9242998972229388)
+    assert nsum(lambda k: 1/k**2, [1, inf]).ae(pi**2 / 6)
+    assert nsum(lambda k: 2**k/fac(k), [0, inf]).ae(exp(2))
+    assert nsum(lambda k: 1/k**2, [4, inf], method='e').ae(0.2838229557371153)
+    assert abs(fp.nsum(lambda k: 1/k**4, [1, fp.inf]) - 1.082323233711138) < 1e-5
+    assert abs(fp.nsum(lambda k: 1/k**4, [1, fp.inf], method='e') - 1.082323233711138) < 1e-4
+
+def test_nprod():
+    mp.dps = 15
+    assert nprod(lambda k: exp(1/k**2), [1,inf], method='r').ae(exp(pi**2/6))
+    assert nprod(lambda x: x**2, [1, 3]) == 36
+
+def test_fsum():
+    mp.dps = 15
+    assert fsum([]) == 0
+    assert fsum([-4]) == -4
+    assert fsum([2,3]) == 5
+    assert fsum([1e-100,1]) == 1
+    assert fsum([1,1e-100]) == 1
+    assert fsum([1e100,1]) == 1e100
+    assert fsum([1,1e100]) == 1e100
+    assert fsum([1e-100,0]) == 1e-100
+    assert fsum([1e-100,1e100,1e-100]) == 1e100
+    assert fsum([2,1+1j,1]) == 4+1j
+    assert fsum([2,inf,3]) == inf
+    assert fsum([2,-1], absolute=1) == 3
+    assert fsum([2,-1], squared=1) == 5
+    assert fsum([1,1+j], squared=1) == 1+2j
+    assert fsum([1,3+4j], absolute=1) == 6
+    assert fsum([1,2+3j], absolute=1, squared=1) == 14
+    assert isnan(fsum([inf,-inf]))
+    assert fsum([inf,-inf], absolute=1) == inf
+    assert fsum([inf,-inf], squared=1) == inf
+    assert fsum([inf,-inf], absolute=1, squared=1) == inf
+    assert iv.fsum([1,mpi(2,3)]) == mpi(3,4)
+
+def test_fprod():
+    mp.dps = 15
+    assert fprod([]) == 1
+    assert fprod([2,3]) == 6
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_trig.py b/lib/python3.10/site-packages/mpmath/tests/test_trig.py
new file mode 100644
index 0000000000000000000000000000000000000000..c70a2a0ff4c44c784404ecdb15357d5b91a992d6
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_trig.py
@@ -0,0 +1,136 @@
+from mpmath import *
+from mpmath.libmp import *
+
+def test_trig_misc_hard():
+    mp.prec = 53
+    # Worst-case input for an IEEE double, from a paper by Kahan
+    x = ldexp(6381956970095103,797)
+    assert cos(x) == mpf('-4.6871659242546277e-19')
+    assert sin(x) == 1
+
+    mp.prec = 150
+    a = mpf(10**50)
+    mp.prec = 53
+    assert sin(a).ae(-0.7896724934293100827)
+    assert cos(a).ae(-0.6135286082336635622)
+
+    # Check relative accuracy close to x = zero
+    assert sin(1e-100) == 1e-100  # when rounding to nearest
+    assert sin(1e-6).ae(9.999999999998333e-007, rel_eps=2e-15, abs_eps=0)
+    assert sin(1e-6j).ae(1.0000000000001666e-006j, rel_eps=2e-15, abs_eps=0)
+    assert sin(-1e-6j).ae(-1.0000000000001666e-006j, rel_eps=2e-15, abs_eps=0)
+    assert cos(1e-100) == 1
+    assert cos(1e-6).ae(0.9999999999995)
+    assert cos(-1e-6j).ae(1.0000000000005)
+    assert tan(1e-100) == 1e-100
+    assert tan(1e-6).ae(1.0000000000003335e-006, rel_eps=2e-15, abs_eps=0)
+    assert tan(1e-6j).ae(9.9999999999966644e-007j, rel_eps=2e-15, abs_eps=0)
+    assert tan(-1e-6j).ae(-9.9999999999966644e-007j, rel_eps=2e-15, abs_eps=0)
+
+def test_trig_near_zero():
+    mp.dps = 15
+
+    for r in [round_nearest, round_down, round_up, round_floor, round_ceiling]:
+        assert sin(0, rounding=r) == 0
+        assert cos(0, rounding=r) == 1
+
+    a = mpf('1e-100')
+    b = mpf('-1e-100')
+
+    assert sin(a, rounding=round_nearest) == a
+    assert sin(a, rounding=round_down) < a
+    assert sin(a, rounding=round_floor) < a
+    assert sin(a, rounding=round_up) >= a
+    assert sin(a, rounding=round_ceiling) >= a
+    assert sin(b, rounding=round_nearest) == b
+    assert sin(b, rounding=round_down) > b
+    assert sin(b, rounding=round_floor) <= b
+    assert sin(b, rounding=round_up) <= b
+    assert sin(b, rounding=round_ceiling) > b
+
+    assert cos(a, rounding=round_nearest) == 1
+    assert cos(a, rounding=round_down) < 1
+    assert cos(a, rounding=round_floor) < 1
+    assert cos(a, rounding=round_up) == 1
+    assert cos(a, rounding=round_ceiling) == 1
+    assert cos(b, rounding=round_nearest) == 1
+    assert cos(b, rounding=round_down) < 1
+    assert cos(b, rounding=round_floor) < 1
+    assert cos(b, rounding=round_up) == 1
+    assert cos(b, rounding=round_ceiling) == 1
+
+
+def test_trig_near_n_pi():
+
+    mp.dps = 15
+    a = [n*pi for n in [1, 2, 6, 11, 100, 1001, 10000, 100001]]
+    mp.dps = 135
+    a.append(10**100 * pi)
+    mp.dps = 15
+
+    assert sin(a[0]) == mpf('1.2246467991473531772e-16')
+    assert sin(a[1]) == mpf('-2.4492935982947063545e-16')
+    assert sin(a[2]) == mpf('-7.3478807948841190634e-16')
+    assert sin(a[3]) == mpf('4.8998251578625894243e-15')
+    assert sin(a[4]) == mpf('1.9643867237284719452e-15')
+    assert sin(a[5]) == mpf('-8.8632615209684813458e-15')
+    assert sin(a[6]) == mpf('-4.8568235395684898392e-13')
+    assert sin(a[7]) == mpf('3.9087342299491231029e-11')
+    assert sin(a[8]) == mpf('-1.369235466754566993528e-36')
+
+    r = round_nearest
+    assert cos(a[0], rounding=r) == -1
+    assert cos(a[1], rounding=r) == 1
+    assert cos(a[2], rounding=r) == 1
+    assert cos(a[3], rounding=r) == -1
+    assert cos(a[4], rounding=r) == 1
+    assert cos(a[5], rounding=r) == -1
+    assert cos(a[6], rounding=r) == 1
+    assert cos(a[7], rounding=r) == -1
+    assert cos(a[8], rounding=r) == 1
+
+    r = round_up
+    assert cos(a[0], rounding=r) == -1
+    assert cos(a[1], rounding=r) == 1
+    assert cos(a[2], rounding=r) == 1
+    assert cos(a[3], rounding=r) == -1
+    assert cos(a[4], rounding=r) == 1
+    assert cos(a[5], rounding=r) == -1
+    assert cos(a[6], rounding=r) == 1
+    assert cos(a[7], rounding=r) == -1
+    assert cos(a[8], rounding=r) == 1
+
+    r = round_down
+    assert cos(a[0], rounding=r) > -1
+    assert cos(a[1], rounding=r) < 1
+    assert cos(a[2], rounding=r) < 1
+    assert cos(a[3], rounding=r) > -1
+    assert cos(a[4], rounding=r) < 1
+    assert cos(a[5], rounding=r) > -1
+    assert cos(a[6], rounding=r) < 1
+    assert cos(a[7], rounding=r) > -1
+    assert cos(a[8], rounding=r) < 1
+
+    r = round_floor
+    assert cos(a[0], rounding=r) == -1
+    assert cos(a[1], rounding=r) < 1
+    assert cos(a[2], rounding=r) < 1
+    assert cos(a[3], rounding=r) == -1
+    assert cos(a[4], rounding=r) < 1
+    assert cos(a[5], rounding=r) == -1
+    assert cos(a[6], rounding=r) < 1
+    assert cos(a[7], rounding=r) == -1
+    assert cos(a[8], rounding=r) < 1
+
+    r = round_ceiling
+    assert cos(a[0], rounding=r) > -1
+    assert cos(a[1], rounding=r) == 1
+    assert cos(a[2], rounding=r) == 1
+    assert cos(a[3], rounding=r) > -1
+    assert cos(a[4], rounding=r) == 1
+    assert cos(a[5], rounding=r) > -1
+    assert cos(a[6], rounding=r) == 1
+    assert cos(a[7], rounding=r) > -1
+    assert cos(a[8], rounding=r) == 1
+
+    mp.dps = 15
diff --git a/lib/python3.10/site-packages/mpmath/tests/test_visualization.py b/lib/python3.10/site-packages/mpmath/tests/test_visualization.py
new file mode 100644
index 0000000000000000000000000000000000000000..81ffd05194322f00e4c75dc02bc862b383468bff
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/test_visualization.py
@@ -0,0 +1,32 @@
+"""
+Limited tests of the visualization module. Right now it just makes
+sure that passing custom Axes works.
+
+"""
+
+from mpmath import mp, fp
+
+def test_axes():
+    try:
+        import matplotlib
+        version = matplotlib.__version__.split("-")[0]
+        version = version.split(".")[:2]
+        if [int(_) for _ in version] < [0,99]:
+            raise ImportError
+        import pylab
+    except ImportError:
+        print("\nSkipping test (pylab not available or too old version)\n")
+        return
+    fig = pylab.figure()
+    axes = fig.add_subplot(111)
+    for ctx in [mp, fp]:
+        ctx.plot(lambda x: x**2, [0, 3], axes=axes)
+        assert axes.get_xlabel() == 'x'
+        assert axes.get_ylabel() == 'f(x)'
+
+    fig = pylab.figure()
+    axes = fig.add_subplot(111)
+    for ctx in [mp, fp]:
+        ctx.cplot(lambda z: z, [-2, 2], [-10, 10], axes=axes)
+    assert axes.get_xlabel() == 'Re(z)'
+    assert axes.get_ylabel() == 'Im(z)'
diff --git a/lib/python3.10/site-packages/mpmath/tests/torture.py b/lib/python3.10/site-packages/mpmath/tests/torture.py
new file mode 100644
index 0000000000000000000000000000000000000000..845d5c6d7d017e51e1ed9a8fe3106cfa32fd967f
--- /dev/null
+++ b/lib/python3.10/site-packages/mpmath/tests/torture.py
@@ -0,0 +1,224 @@
+"""
+Torture tests for asymptotics and high precision evaluation of
+special functions.
+
+(Other torture tests may also be placed here.)
+
+Running this file (gmpy recommended!) takes several CPU minutes.
+With Python 2.6+, multiprocessing is used automatically to run tests
+in parallel if many cores are available. (A single test may take between
+a second and several minutes; possibly more.)
+
+The idea:
+
+* We evaluate functions at positive, negative, imaginary, 45- and 135-degree
+  complex values with magnitudes between 10^-20 to 10^20, at precisions between
+  5 and 150 digits (we can go even higher for fast functions).
+
+* Comparing the result from two different precision levels provides
+  a strong consistency check (particularly for functions that use
+  different algorithms at different precision levels).
+
+* That the computation finishes at all (without failure), within reasonable
+  time, provides a check that evaluation works at all: that the code runs,
+  that it doesn't get stuck in an infinite loop, and that it doesn't use
+  some extremely slowly algorithm where it could use a faster one.
+
+TODO:
+
+* Speed up those functions that take long to finish!
+* Generalize to test more cases; more options.
+* Implement a timeout mechanism.
+* Some functions are notably absent, including the following:
+  * inverse trigonometric functions (some become inaccurate for complex arguments)
+  * ci, si (not implemented properly for large complex arguments)
+  * zeta functions (need to modify test not to try too large imaginary values)
+  * and others...
+
+"""
+
+
+import sys, os
+from timeit import default_timer as clock
+
+if "-nogmpy" in sys.argv:
+    sys.argv.remove('-nogmpy')
+    os.environ['MPMATH_NOGMPY'] = 'Y'
+
+filt = ''
+if not sys.argv[-1].endswith(".py"):
+    filt = sys.argv[-1]
+
+from mpmath import *
+from mpmath.libmp.backend import exec_
+
+def test_asymp(f, maxdps=150, verbose=False, huge_range=False):
+    dps = [5,15,25,50,90,150,500,1500,5000,10000]
+    dps = [p for p in dps if p <= maxdps]
+    def check(x,y,p,inpt):
+        if abs(x-y)/abs(y) < workprec(20)(power)(10, -p+1):
+            return
+        print()
+        print("Error!")
+        print("Input:", inpt)
+        print("dps =", p)
+        print("Result 1:", x)
+        print("Result 2:", y)
+        print("Absolute error:", abs(x-y))
+        print("Relative error:", abs(x-y)/abs(y))
+        raise AssertionError
+    exponents = range(-20,20)
+    if huge_range:
+        exponents += [-1000, -100, -50, 50, 100, 1000]
+    for n in exponents:
+        if verbose:
+            sys.stdout.write(". ")
+        mp.dps = 25
+        xpos = mpf(10)**n / 1.1287
+        xneg = -xpos
+        ximag = xpos*j
+        xcomplex1 = xpos*(1+j)
+        xcomplex2 = xpos*(-1+j)
+        for i in range(len(dps)):
+            if verbose:
+                print("Testing dps = %s" % dps[i])
+            mp.dps = dps[i]
+            new = f(xpos), f(xneg), f(ximag), f(xcomplex1), f(xcomplex2)
+            if i != 0:
+                p = dps[i-1]
+                check(prev[0], new[0], p, xpos)
+                check(prev[1], new[1], p, xneg)
+                check(prev[2], new[2], p, ximag)
+                check(prev[3], new[3], p, xcomplex1)
+                check(prev[4], new[4], p, xcomplex2)
+            prev = new
+    if verbose:
+        print()
+
+a1, a2, a3, a4, a5 = 1.5, -2.25, 3.125, 4, 2
+
+def test_bernoulli_huge():
+    p, q = bernfrac(9000)
+    assert p % 10**10 == 9636701091
+    assert q == 4091851784687571609141381951327092757255270
+    mp.dps = 15
+    assert str(bernoulli(10**100)) == '-2.58183325604736e+987675256497386331227838638980680030172857347883537824464410652557820800494271520411283004120790908623'
+    mp.dps = 50
+    assert str(bernoulli(10**100)) == '-2.5818332560473632073252488656039475548106223822913e+987675256497386331227838638980680030172857347883537824464410652557820800494271520411283004120790908623'
+    mp.dps = 15
+
+cases = """\
+test_bernoulli_huge()
+test_asymp(lambda z: +pi, maxdps=10000)
+test_asymp(lambda z: +e, maxdps=10000)
+test_asymp(lambda z: +ln2, maxdps=10000)
+test_asymp(lambda z: +ln10, maxdps=10000)
+test_asymp(lambda z: +phi, maxdps=10000)
+test_asymp(lambda z: +catalan, maxdps=5000)
+test_asymp(lambda z: +euler, maxdps=5000)
+test_asymp(lambda z: +glaisher, maxdps=1000)
+test_asymp(lambda z: +khinchin, maxdps=1000)
+test_asymp(lambda z: +twinprime, maxdps=150)
+test_asymp(lambda z: stieltjes(2), maxdps=150)
+test_asymp(lambda z: +mertens, maxdps=150)
+test_asymp(lambda z: +apery, maxdps=5000)
+test_asymp(sqrt, maxdps=10000, huge_range=True)
+test_asymp(cbrt, maxdps=5000, huge_range=True)
+test_asymp(lambda z: root(z,4), maxdps=5000, huge_range=True)
+test_asymp(lambda z: root(z,-5), maxdps=5000, huge_range=True)
+test_asymp(exp, maxdps=5000, huge_range=True)
+test_asymp(expm1, maxdps=1500)
+test_asymp(ln, maxdps=5000, huge_range=True)
+test_asymp(cosh, maxdps=5000)
+test_asymp(sinh, maxdps=5000)
+test_asymp(tanh, maxdps=1500)
+test_asymp(sin, maxdps=5000, huge_range=True)
+test_asymp(cos, maxdps=5000, huge_range=True)
+test_asymp(tan, maxdps=1500)
+test_asymp(agm, maxdps=1500, huge_range=True)
+test_asymp(ellipk, maxdps=1500)
+test_asymp(ellipe, maxdps=1500)
+test_asymp(lambertw, huge_range=True)
+test_asymp(lambda z: lambertw(z,-1))
+test_asymp(lambda z: lambertw(z,1))
+test_asymp(lambda z: lambertw(z,4))
+test_asymp(gamma)
+test_asymp(loggamma)  # huge_range=True ?
+test_asymp(ei)
+test_asymp(e1)
+test_asymp(li, huge_range=True)
+test_asymp(ci)
+test_asymp(si)
+test_asymp(chi)
+test_asymp(shi)
+test_asymp(erf)
+test_asymp(erfc)
+test_asymp(erfi)
+test_asymp(lambda z: besselj(2, z))
+test_asymp(lambda z: bessely(2, z))
+test_asymp(lambda z: besseli(2, z))
+test_asymp(lambda z: besselk(2, z))
+test_asymp(lambda z: besselj(-2.25, z))
+test_asymp(lambda z: bessely(-2.25, z))
+test_asymp(lambda z: besseli(-2.25, z))
+test_asymp(lambda z: besselk(-2.25, z))
+test_asymp(airyai)
+test_asymp(airybi)
+test_asymp(lambda z: hyp0f1(a1, z))
+test_asymp(lambda z: hyp1f1(a1, a2, z))
+test_asymp(lambda z: hyp1f2(a1, a2, a3, z))
+test_asymp(lambda z: hyp2f0(a1, a2, z))
+test_asymp(lambda z: hyperu(a1, a2, z))
+test_asymp(lambda z: hyp2f1(a1, a2, a3, z))
+test_asymp(lambda z: hyp2f2(a1, a2, a3, a4, z))
+test_asymp(lambda z: hyp2f3(a1, a2, a3, a4, a5, z))
+test_asymp(lambda z: coulombf(a1, a2, z))
+test_asymp(lambda z: coulombg(a1, a2, z))
+test_asymp(lambda z: polylog(2,z))
+test_asymp(lambda z: polylog(3,z))
+test_asymp(lambda z: polylog(-2,z))
+test_asymp(lambda z: expint(4, z))
+test_asymp(lambda z: expint(-4, z))
+test_asymp(lambda z: expint(2.25, z))
+test_asymp(lambda z: gammainc(2.5, z, 5))
+test_asymp(lambda z: gammainc(2.5, 5, z))
+test_asymp(lambda z: hermite(3, z))
+test_asymp(lambda z: hermite(2.5, z))
+test_asymp(lambda z: legendre(3, z))
+test_asymp(lambda z: legendre(4, z))
+test_asymp(lambda z: legendre(2.5, z))
+test_asymp(lambda z: legenp(a1, a2, z))
+test_asymp(lambda z: legenq(a1, a2, z), maxdps=90)   # abnormally slow
+test_asymp(lambda z: jtheta(1, z, 0.5))
+test_asymp(lambda z: jtheta(2, z, 0.5))
+test_asymp(lambda z: jtheta(3, z, 0.5))
+test_asymp(lambda z: jtheta(4, z, 0.5))
+test_asymp(lambda z: jtheta(1, z, 0.5, 1))
+test_asymp(lambda z: jtheta(2, z, 0.5, 1))
+test_asymp(lambda z: jtheta(3, z, 0.5, 1))
+test_asymp(lambda z: jtheta(4, z, 0.5, 1))
+test_asymp(barnesg, maxdps=90)
+"""
+
+def testit(line):
+    if filt in line:
+        print(line)
+        t1 = clock()
+        exec_(line, globals(), locals())
+        t2 = clock()
+        elapsed = t2-t1
+        print("Time:", elapsed, "for", line, "(OK)")
+
+if __name__ == '__main__':
+    try:
+        from multiprocessing import Pool
+        mapf = Pool(None).map
+        print("Running tests with multiprocessing")
+    except ImportError:
+        print("Not using multiprocessing")
+        mapf = map
+    t1 = clock()
+    tasks = cases.splitlines()
+    mapf(testit, tasks)
+    t2 = clock()
+    print("Cumulative wall time:", t2-t1)
diff --git a/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/__init__.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..959b2a81e8c27cf6e00a86258d4a11b3fb320dbb
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/__init__.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/dataframe.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/dataframe.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e9b054e88b526b751fd22204571d4400967db570
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/dataframe.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/expr.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/expr.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9a2c21f649755f39fc5a7ac1dd23caccc344e1b8
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/expr.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/group_by.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/group_by.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f6686aadbded96185796b1dbbab7b907c82c0dda
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/group_by.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/namespace.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/namespace.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3f8c46ba01cfd7cbc71a9226420218b20e636ac6
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/namespace.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/selectors.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/selectors.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..91ee5b430bd2e0bc6872c0bdddb054d9fec81160
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/selectors.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/series.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/series.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fb08c6c350391c54e895a756e777857cf7fc0ef6
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/series.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/series_cat.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/series_cat.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cdf1632fce4f9e794d174f72df48c0837c726a44
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/series_cat.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/series_dt.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/series_dt.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5d58b4d0310c0984cae40f4ff7cd9b20c213f92f
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/series_dt.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/series_list.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/series_list.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fde60a3a15415cba9caae2653170d864b9be93c4
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/series_list.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/series_str.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/series_str.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..22a93034a23e7756a8aa3f250002c85737e310e5
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/series_str.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/series_struct.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/series_struct.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b57ed7e7269fd691f11eaf132f4736f9e5702e95
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/series_struct.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/typing.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/typing.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0e429ae20eb52c6fab02fe72a4dbb4b0c77d2209
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/typing.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/utils.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/utils.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6206f19e66558b3424595c126ae642d55e0f4bee
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/utils.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/__init__.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2fe6e64afc982635b7aa39b5f9bfcce1b6233398
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/__init__.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/any_namespace.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/any_namespace.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5a913d441489e61368ddce7d8c6acf8a1df8f12f
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/any_namespace.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/dataframe.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/dataframe.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..924166eabdb65085fc92e6bb3e3493f0c55474c5
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/dataframe.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/expr.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/expr.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c2156ddcd2310ca7542f472f14973846361b4c9b
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/expr.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/group_by.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/group_by.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..09c3092aef0bff9b21f7b8d6ec58b197154ba0ff
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/group_by.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/namespace.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/namespace.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..015d4562fb0715dba3338ebf93a9ded5c23c1027
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/namespace.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/selectors.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/selectors.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..24f6411d5ac98c639e54ec3e454d4a90daac9533
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/selectors.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/series.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/series.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d53f8f403c68ba7f58d866f248884a8e4f99f79b
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/series.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/typing.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/typing.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d5cb13736ede047abebe1eeab710fd241e97d5ab
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/typing.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/when_then.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/when_then.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ca175767cec3e4d3dffda2dfbcf7207f4528424a
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/when_then.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/window.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/window.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c8f46bcee275e4fa2727cc17a387a50ec7f89309
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_compliant/__pycache__/window.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_dask/__pycache__/__init__.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_dask/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..af1096efbaac2f1194cae8e32279a1fa0072a1d7
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_dask/__pycache__/__init__.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_dask/__pycache__/dataframe.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_dask/__pycache__/dataframe.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1002eabb192e8cef484a2a45dcd4df3db79b0f85
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_dask/__pycache__/dataframe.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_dask/__pycache__/expr.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_dask/__pycache__/expr.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e4b35fbd2c1b98b6c0fa270fea2c41d1fb6bdd9e
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_dask/__pycache__/expr.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_dask/__pycache__/expr_dt.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_dask/__pycache__/expr_dt.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c9216c34b5fd9ab7fd82cb8e6b6ad2a05281bc1b
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_dask/__pycache__/expr_dt.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_dask/__pycache__/expr_str.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_dask/__pycache__/expr_str.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..09a0d6f2defac27a36c9ab2ea07d5355cdeaa6a6
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_dask/__pycache__/expr_str.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_dask/__pycache__/group_by.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_dask/__pycache__/group_by.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1b54b1e975de51389539a4d167ed46a2b302ffdf
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_dask/__pycache__/group_by.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_dask/__pycache__/namespace.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_dask/__pycache__/namespace.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3cf77fc3d5738cf465f0bc95202d83d6b1509d2b
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_dask/__pycache__/namespace.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_dask/__pycache__/selectors.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_dask/__pycache__/selectors.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..58a3522dede2f138a8cdfe99f7f9d9f7b656b466
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_dask/__pycache__/selectors.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_dask/__pycache__/utils.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_dask/__pycache__/utils.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0271c009ca994311241c389e994306349ed46c04
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_dask/__pycache__/utils.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/__init__.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e422194fe1f75c9f2caef25201ddb5283ae82c34
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/__init__.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/dataframe.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/dataframe.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fe1fc009ff9c1c501006fce28837d48c053ec788
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/dataframe.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/expr.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/expr.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..066588743757e1edec5083e39f0d55bbe029861d
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/expr.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/expr_dt.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/expr_dt.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1e112f607af4752292c65ed6a3a6ee8d8fa4a85d
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/expr_dt.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/expr_list.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/expr_list.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fcb7a218bb2a56d96537f90feef11ed7f5960d3e
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/expr_list.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/expr_str.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/expr_str.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..06bfc6ec2bd895fec4a1cfabe64bea4680e2375f
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/expr_str.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/expr_struct.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/expr_struct.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e435c25ee4e46c2f74f8666fa04fc326614c0092
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/expr_struct.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/group_by.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/group_by.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..deb4b61de314cb62ce6d88b4e30a88864b145f2f
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/group_by.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/namespace.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/namespace.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4214b25fabfbadfd5a2db45aba88defe916928c3
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/namespace.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/selectors.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/selectors.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..42e592358fcea2b6d8879166108ad451983c5df9
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/selectors.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/series.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/series.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..80110c60b931ff9e0d11cb4b9c5c2aff8dbccbc8
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/series.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/typing.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/typing.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..69f6cbaa71cb250ee353f5b9ffb8881d77f1852a
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/typing.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/utils.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/utils.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3992e9d3a4863057b52a28de4f6fd0ff32b25427
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/utils.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_ibis/__pycache__/__init__.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_ibis/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f5a753b1e1794ff3a8c875fd7f9fd7ad5e12514d
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_ibis/__pycache__/__init__.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/_ibis/__pycache__/utils.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/_ibis/__pycache__/utils.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..16aac2d48297af1bc2695f92e973bfe2ba4e2242
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/_ibis/__pycache__/utils.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/stable/__pycache__/__init__.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/stable/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..19374782efe4415e7ed8c2c37864c6a69ac4fdf0
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/stable/__pycache__/__init__.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/stable/v1/__init__.py b/lib/python3.10/site-packages/narwhals/stable/v1/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..99680b903989a4821ec53498c9b45c7e3c433fa4
--- /dev/null
+++ b/lib/python3.10/site-packages/narwhals/stable/v1/__init__.py
@@ -0,0 +1,1389 @@
+from __future__ import annotations
+
+from functools import wraps
+from typing import TYPE_CHECKING, Any, Callable, Literal, cast, overload
+
+import narwhals as nw
+from narwhals import exceptions, functions as nw_f
+from narwhals._exceptions import issue_warning
+from narwhals._typing_compat import TypeVar, assert_never
+from narwhals._utils import (
+    Implementation,
+    Version,
+    deprecate_native_namespace,
+    generate_temporary_column_name,
+    inherit_doc,
+    is_ordered_categorical,
+    maybe_align_index,
+    maybe_convert_dtypes,
+    maybe_get_index,
+    maybe_reset_index,
+    maybe_set_index,
+    validate_strict_and_pass_though,
+)
+from narwhals.dataframe import DataFrame as NwDataFrame, LazyFrame as NwLazyFrame
+from narwhals.dependencies import get_polars
+from narwhals.exceptions import InvalidIntoExprError
+from narwhals.expr import Expr as NwExpr
+from narwhals.functions import _new_series_impl, concat, show_versions
+from narwhals.schema import Schema as NwSchema
+from narwhals.series import Series as NwSeries
+from narwhals.stable.v1 import dependencies, dtypes, selectors
+from narwhals.stable.v1.dtypes import (
+    Array,
+    Binary,
+    Boolean,
+    Categorical,
+    Date,
+    Datetime,
+    Decimal,
+    Duration,
+    Enum,
+    Field,
+    Float32,
+    Float64,
+    Int8,
+    Int16,
+    Int32,
+    Int64,
+    Int128,
+    List,
+    Object,
+    String,
+    Struct,
+    Time,
+    UInt8,
+    UInt16,
+    UInt32,
+    UInt64,
+    UInt128,
+    Unknown,
+)
+from narwhals.translate import _from_native_impl, get_native_namespace, to_py_scalar
+from narwhals.typing import IntoDataFrameT, IntoFrameT
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Mapping, Sequence
+    from types import ModuleType
+
+    from typing_extensions import ParamSpec, Self
+
+    from narwhals._translate import IntoArrowTable
+    from narwhals.dataframe import MultiColSelector, MultiIndexSelector
+    from narwhals.dtypes import DType
+    from narwhals.typing import (
+        IntoDType,
+        IntoExpr,
+        IntoFrame,
+        IntoLazyFrameT,
+        IntoSeries,
+        NonNestedLiteral,
+        SingleColSelector,
+        SingleIndexSelector,
+        _1DArray,
+        _2DArray,
+    )
+
+    DataFrameT = TypeVar("DataFrameT", bound="DataFrame[Any]")
+    LazyFrameT = TypeVar("LazyFrameT", bound="LazyFrame[Any]")
+    SeriesT = TypeVar("SeriesT", bound="Series[Any]")
+    T = TypeVar("T", default=Any)
+    P = ParamSpec("P")
+    R = TypeVar("R")
+
+IntoSeriesT = TypeVar("IntoSeriesT", bound="IntoSeries", default=Any)
+
+
+class DataFrame(NwDataFrame[IntoDataFrameT]):
+    _version = Version.V1
+
+    @inherit_doc(NwDataFrame)
+    def __init__(self, df: Any, *, level: Literal["full", "lazy", "interchange"]) -> None:
+        assert df._version is Version.V1  # noqa: S101
+        super().__init__(df, level=level)
+
+    # We need to override any method which don't return Self so that type
+    # annotations are correct.
+
+    @classmethod
+    def from_arrow(
+        cls, native_frame: IntoArrowTable, *, backend: ModuleType | Implementation | str
+    ) -> DataFrame[Any]:
+        result = super().from_arrow(native_frame, backend=backend)
+        return cast("DataFrame[Any]", result)
+
+    @classmethod
+    def from_dict(
+        cls,
+        data: Mapping[str, Any],
+        schema: Mapping[str, DType] | Schema | None = None,
+        *,
+        backend: ModuleType | Implementation | str | None = None,
+    ) -> DataFrame[Any]:
+        result = super().from_dict(data, schema, backend=backend)
+        return cast("DataFrame[Any]", result)
+
+    @classmethod
+    def from_numpy(
+        cls,
+        data: _2DArray,
+        schema: Mapping[str, DType] | Schema | Sequence[str] | None = None,
+        *,
+        backend: ModuleType | Implementation | str,
+    ) -> DataFrame[Any]:
+        result = super().from_numpy(data, schema, backend=backend)
+        return cast("DataFrame[Any]", result)
+
+    @property
+    def _series(self) -> type[Series[Any]]:
+        return cast("type[Series[Any]]", Series)
+
+    @property
+    def _lazyframe(self) -> type[LazyFrame[Any]]:
+        return cast("type[LazyFrame[Any]]", LazyFrame)
+
+    @overload
+    def __getitem__(self, item: tuple[SingleIndexSelector, SingleColSelector]) -> Any: ...
+
+    @overload
+    def __getitem__(  # type: ignore[overload-overlap]
+        self, item: str | tuple[MultiIndexSelector, SingleColSelector]
+    ) -> Series[Any]: ...
+
+    @overload
+    def __getitem__(
+        self,
+        item: (
+            SingleIndexSelector
+            | MultiIndexSelector
+            | MultiColSelector
+            | tuple[SingleIndexSelector, MultiColSelector]
+            | tuple[MultiIndexSelector, MultiColSelector]
+        ),
+    ) -> Self: ...
+    def __getitem__(
+        self,
+        item: (
+            SingleIndexSelector
+            | SingleColSelector
+            | MultiColSelector
+            | MultiIndexSelector
+            | tuple[SingleIndexSelector, SingleColSelector]
+            | tuple[SingleIndexSelector, MultiColSelector]
+            | tuple[MultiIndexSelector, SingleColSelector]
+            | tuple[MultiIndexSelector, MultiColSelector]
+        ),
+    ) -> Series[Any] | Self | Any:
+        return super().__getitem__(item)
+
+    def get_column(self, name: str) -> Series:
+        # Type checkers complain that `nw.Series` is not assignable to `nw.v1.stable.Series`.
+        # However the return type actually is `nw.v1.stable.Series`, check `tests/v1_test.py`.
+        return super().get_column(name)  # type: ignore[return-value]
+
+    def lazy(
+        self, backend: ModuleType | Implementation | str | None = None
+    ) -> LazyFrame[Any]:
+        return _stableify(super().lazy(backend=backend))
+
+    @overload  # type: ignore[override]
+    def to_dict(self, *, as_series: Literal[True] = ...) -> dict[str, Series[Any]]: ...
+    @overload
+    def to_dict(self, *, as_series: Literal[False]) -> dict[str, list[Any]]: ...
+    @overload
+    def to_dict(
+        self, *, as_series: bool
+    ) -> dict[str, Series[Any]] | dict[str, list[Any]]: ...
+    def to_dict(
+        self, *, as_series: bool = True
+    ) -> dict[str, Series[Any]] | dict[str, list[Any]]:
+        # Type checkers complain that `nw.Series` is not assignable to `nw.v1.stable.Series`.
+        # However the return type actually is `nw.v1.stable.Series`, check `tests/v1_test.py::test_to_dict_as_series`.
+        return super().to_dict(as_series=as_series)  # type: ignore[return-value]
+
+    def is_duplicated(self) -> Series[Any]:
+        return _stableify(super().is_duplicated())
+
+    def is_unique(self) -> Series[Any]:
+        return _stableify(super().is_unique())
+
+    def _l1_norm(self) -> Self:
+        # Private, just used to test the stable API.
+        return self.select(all()._l1_norm())
+
+
+class LazyFrame(NwLazyFrame[IntoFrameT]):
+    @inherit_doc(NwLazyFrame)
+    def __init__(self, df: Any, *, level: Literal["full", "lazy", "interchange"]) -> None:
+        assert df._version is Version.V1  # noqa: S101
+        super().__init__(df, level=level)
+
+    @property
+    def _dataframe(self) -> type[DataFrame[Any]]:
+        return DataFrame
+
+    def _extract_compliant(self, arg: Any) -> Any:
+        # After v1, we raise when passing order-dependent or length-changing
+        # expressions to LazyFrame
+        from narwhals.dataframe import BaseFrame
+        from narwhals.expr import Expr
+        from narwhals.series import Series
+
+        if isinstance(arg, BaseFrame):
+            return arg._compliant_frame
+        if isinstance(arg, Series):  # pragma: no cover
+            msg = "Mixing Series with LazyFrame is not supported."
+            raise TypeError(msg)
+        if isinstance(arg, Expr):
+            # After stable.v1, we raise for order-dependent exprs or filtrations
+            return arg._to_compliant_expr(self.__narwhals_namespace__())
+        if isinstance(arg, str):
+            plx = self.__narwhals_namespace__()
+            return plx.col(arg)
+        if get_polars() is not None and "polars" in str(type(arg)):  # pragma: no cover
+            msg = (
+                f"Expected Narwhals object, got: {type(arg)}.\n\n"
+                "Perhaps you:\n"
+                "- Forgot a `nw.from_native` somewhere?\n"
+                "- Used `pl.col` instead of `nw.col`?"
+            )
+            raise TypeError(msg)
+        raise InvalidIntoExprError.from_invalid_type(type(arg))
+
+    def collect(
+        self, backend: ModuleType | Implementation | str | None = None, **kwargs: Any
+    ) -> DataFrame[Any]:
+        return _stableify(super().collect(backend=backend, **kwargs))
+
+    def _l1_norm(self) -> Self:
+        # Private, just used to test the stable API.
+        return self.select(all()._l1_norm())
+
+    def tail(self, n: int = 5) -> Self:
+        r"""Get the last `n` rows."""
+        return super().tail(n)
+
+    def gather_every(self, n: int, offset: int = 0) -> Self:
+        r"""Take every nth row in the DataFrame and return as a new DataFrame.
+
+        Arguments:
+            n: Gather every *n*-th row.
+            offset: Starting index.
+        """
+        return self._with_compliant(
+            self._compliant_frame.gather_every(n=n, offset=offset)  # type: ignore[attr-defined]
+        )
+
+    def with_row_index(
+        self, name: str = "index", *, order_by: str | Sequence[str] | None = None
+    ) -> Self:
+        order_by_ = [order_by] if isinstance(order_by, str) else order_by
+        return self._with_compliant(
+            self._compliant_frame.with_row_index(
+                name=name,
+                order_by=order_by_,  # type: ignore[arg-type]
+            )
+        )
+
+
+class Series(NwSeries[IntoSeriesT]):
+    @inherit_doc(NwSeries)
+    def __init__(
+        self, series: Any, *, level: Literal["full", "lazy", "interchange"]
+    ) -> None:
+        assert series._version is Version.V1  # noqa: S101
+        super().__init__(series, level=level)
+
+    # We need to override any method which don't return Self so that type
+    # annotations are correct.
+
+    @property
+    def _dataframe(self) -> type[DataFrame[Any]]:
+        return DataFrame
+
+    def to_frame(self) -> DataFrame[Any]:
+        return _stableify(super().to_frame())
+
+    def value_counts(
+        self,
+        *,
+        sort: bool = False,
+        parallel: bool = False,
+        name: str | None = None,
+        normalize: bool = False,
+    ) -> DataFrame[Any]:
+        return _stableify(
+            super().value_counts(
+                sort=sort, parallel=parallel, name=name, normalize=normalize
+            )
+        )
+
+    def hist(
+        self,
+        bins: list[float] | None = None,
+        *,
+        bin_count: int | None = None,
+        include_breakpoint: bool = True,
+    ) -> DataFrame[Any]:
+        from narwhals.exceptions import NarwhalsUnstableWarning
+
+        msg = (
+            "`Series.hist` is being called from the stable API although considered "
+            "an unstable feature."
+        )
+        issue_warning(msg, NarwhalsUnstableWarning)
+        return _stableify(
+            super().hist(
+                bins=bins, bin_count=bin_count, include_breakpoint=include_breakpoint
+            )
+        )
+
+
+class Expr(NwExpr):
+    def _l1_norm(self) -> Self:
+        return super()._taxicab_norm()
+
+    def head(self, n: int = 10) -> Self:
+        r"""Get the first `n` rows."""
+        return self._with_orderable_filtration(
+            lambda plx: self._to_compliant_expr(plx).head(n)  # type: ignore[attr-defined]
+        )
+
+    def tail(self, n: int = 10) -> Self:
+        r"""Get the last `n` rows."""
+        return self._with_orderable_filtration(
+            lambda plx: self._to_compliant_expr(plx).tail(n)  # type: ignore[attr-defined]
+        )
+
+    def gather_every(self, n: int, offset: int = 0) -> Self:
+        r"""Take every nth value in the Series and return as new Series.
+
+        Arguments:
+            n: Gather every *n*-th row.
+            offset: Starting index.
+        """
+        return self._with_orderable_filtration(
+            lambda plx: self._to_compliant_expr(plx).gather_every(n=n, offset=offset)  # type: ignore[attr-defined]
+        )
+
+    def unique(self, *, maintain_order: bool | None = None) -> Self:
+        """Return unique values of this expression."""
+        if maintain_order is not None:
+            msg = (
+                "`maintain_order` has no effect and is only kept around for backwards-compatibility. "
+                "You can safely remove this argument."
+            )
+            issue_warning(msg, UserWarning)
+        return self._with_filtration(lambda plx: self._to_compliant_expr(plx).unique())
+
+    def sort(self, *, descending: bool = False, nulls_last: bool = False) -> Self:
+        """Sort this column. Place null values first."""
+        return self._with_window(
+            lambda plx: self._to_compliant_expr(plx).sort(  # type: ignore[attr-defined]
+                descending=descending, nulls_last=nulls_last
+            )
+        )
+
+    def arg_max(self) -> Self:
+        """Returns the index of the maximum value."""
+        return self._with_orderable_aggregation(
+            lambda plx: self._to_compliant_expr(plx).arg_max()  # type: ignore[attr-defined]
+        )
+
+    def arg_min(self) -> Self:
+        """Returns the index of the minimum value."""
+        return self._with_orderable_aggregation(
+            lambda plx: self._to_compliant_expr(plx).arg_min()  # type: ignore[attr-defined]
+        )
+
+    def arg_true(self) -> Self:
+        """Find elements where boolean expression is True."""
+        return self._with_orderable_filtration(
+            lambda plx: self._to_compliant_expr(plx).arg_true()  # type: ignore[attr-defined]
+        )
+
+    def sample(
+        self,
+        n: int | None = None,
+        *,
+        fraction: float | None = None,
+        with_replacement: bool = False,
+        seed: int | None = None,
+    ) -> Self:
+        """Sample randomly from this expression.
+
+        Arguments:
+            n: Number of items to return. Cannot be used with fraction.
+            fraction: Fraction of items to return. Cannot be used with n.
+            with_replacement: Allow values to be sampled more than once.
+            seed: Seed for the random number generator. If set to None (default), a random
+                seed is generated for each sample operation.
+
+        Returns:
+            A new expression.
+        """
+        return self._with_filtration(
+            lambda plx: self._to_compliant_expr(plx).sample(  # type: ignore[attr-defined]
+                n, fraction=fraction, with_replacement=with_replacement, seed=seed
+            )
+        )
+
+
+class Schema(NwSchema):
+    _version = Version.V1
+
+    @inherit_doc(NwSchema)
+    def __init__(
+        self, schema: Mapping[str, DType] | Iterable[tuple[str, DType]] | None = None
+    ) -> None:
+        super().__init__(schema)
+
+
+@overload
+def _stableify(obj: NwDataFrame[IntoFrameT]) -> DataFrame[IntoFrameT]: ...
+@overload
+def _stableify(obj: NwLazyFrame[IntoFrameT]) -> LazyFrame[IntoFrameT]: ...
+@overload
+def _stableify(obj: NwSeries[IntoSeriesT]) -> Series[IntoSeriesT]: ...
+@overload
+def _stableify(obj: NwExpr) -> Expr: ...
+
+
+def _stableify(
+    obj: NwDataFrame[IntoFrameT]
+    | NwLazyFrame[IntoFrameT]
+    | NwSeries[IntoSeriesT]
+    | NwExpr,
+) -> DataFrame[IntoFrameT] | LazyFrame[IntoFrameT] | Series[IntoSeriesT] | Expr:
+    if isinstance(obj, NwDataFrame):
+        return DataFrame(obj._compliant_frame._with_version(Version.V1), level=obj._level)
+    if isinstance(obj, NwLazyFrame):
+        return LazyFrame(obj._compliant_frame._with_version(Version.V1), level=obj._level)
+    if isinstance(obj, NwSeries):
+        return Series(obj._compliant_series._with_version(Version.V1), level=obj._level)
+    if isinstance(obj, NwExpr):
+        return Expr(obj._to_compliant_expr, obj._metadata)
+    assert_never(obj)
+
+
+@overload
+def from_native(native_object: SeriesT, **kwds: Any) -> SeriesT: ...
+
+
+@overload
+def from_native(native_object: DataFrameT, **kwds: Any) -> DataFrameT: ...
+
+
+@overload
+def from_native(native_object: LazyFrameT, **kwds: Any) -> LazyFrameT: ...
+
+
+@overload
+def from_native(
+    native_object: DataFrameT | LazyFrameT, **kwds: Any
+) -> DataFrameT | LazyFrameT: ...
+
+
+@overload
+def from_native(
+    native_object: IntoDataFrameT | IntoSeriesT,
+    *,
+    strict: Literal[False],
+    eager_only: Literal[False] = ...,
+    eager_or_interchange_only: Literal[True],
+    series_only: Literal[False] = ...,
+    allow_series: Literal[True],
+) -> DataFrame[IntoDataFrameT] | Series[IntoSeriesT]: ...
+
+
+@overload
+def from_native(
+    native_object: IntoDataFrameT | IntoSeriesT,
+    *,
+    strict: Literal[False],
+    eager_only: Literal[True],
+    eager_or_interchange_only: Literal[False] = ...,
+    series_only: Literal[False] = ...,
+    allow_series: Literal[True],
+) -> DataFrame[IntoDataFrameT] | Series[IntoSeriesT]: ...
+
+
+@overload
+def from_native(
+    native_object: IntoDataFrameT,
+    *,
+    strict: Literal[False],
+    eager_only: Literal[False] = ...,
+    eager_or_interchange_only: Literal[True],
+    series_only: Literal[False] = ...,
+    allow_series: None = ...,
+) -> DataFrame[IntoDataFrameT]: ...
+
+
+@overload
+def from_native(
+    native_object: T,
+    *,
+    strict: Literal[False],
+    eager_only: Literal[False] = ...,
+    eager_or_interchange_only: Literal[True],
+    series_only: Literal[False] = ...,
+    allow_series: None = ...,
+) -> T: ...
+
+
+@overload
+def from_native(
+    native_object: IntoDataFrameT,
+    *,
+    strict: Literal[False],
+    eager_only: Literal[True],
+    eager_or_interchange_only: Literal[False] = ...,
+    series_only: Literal[False] = ...,
+    allow_series: None = ...,
+) -> DataFrame[IntoDataFrameT]: ...
+
+
+@overload
+def from_native(
+    native_object: T,
+    *,
+    strict: Literal[False],
+    eager_only: Literal[True],
+    eager_or_interchange_only: Literal[False] = ...,
+    series_only: Literal[False] = ...,
+    allow_series: None = ...,
+) -> T: ...
+
+
+@overload
+def from_native(
+    native_object: IntoFrameT | IntoSeriesT,
+    *,
+    strict: Literal[False],
+    eager_only: Literal[False] = ...,
+    eager_or_interchange_only: Literal[False] = ...,
+    series_only: Literal[False] = ...,
+    allow_series: Literal[True],
+) -> DataFrame[IntoFrameT] | LazyFrame[IntoFrameT] | Series[IntoSeriesT]: ...
+
+
+@overload
+def from_native(
+    native_object: IntoSeriesT,
+    *,
+    strict: Literal[False],
+    eager_only: Literal[False] = ...,
+    eager_or_interchange_only: Literal[False] = ...,
+    series_only: Literal[True],
+    allow_series: None = ...,
+) -> Series[IntoSeriesT]: ...
+
+
+@overload
+def from_native(
+    native_object: IntoFrameT,
+    *,
+    strict: Literal[False],
+    eager_only: Literal[False] = ...,
+    eager_or_interchange_only: Literal[False] = ...,
+    series_only: Literal[False] = ...,
+    allow_series: None = ...,
+) -> DataFrame[IntoFrameT] | LazyFrame[IntoFrameT]: ...
+
+
+@overload
+def from_native(
+    native_object: T,
+    *,
+    strict: Literal[False],
+    eager_only: Literal[False] = ...,
+    eager_or_interchange_only: Literal[False] = ...,
+    series_only: Literal[False] = ...,
+    allow_series: None = ...,
+) -> T: ...
+
+
+@overload
+def from_native(
+    native_object: IntoDataFrameT,
+    *,
+    strict: Literal[True] = ...,
+    eager_only: Literal[False] = ...,
+    eager_or_interchange_only: Literal[True],
+    series_only: Literal[False] = ...,
+    allow_series: None = ...,
+) -> DataFrame[IntoDataFrameT]: ...
+
+
+@overload
+def from_native(
+    native_object: IntoDataFrameT,
+    *,
+    strict: Literal[True] = ...,
+    eager_only: Literal[True],
+    eager_or_interchange_only: Literal[False] = ...,
+    series_only: Literal[False] = ...,
+    allow_series: None = ...,
+) -> DataFrame[IntoDataFrameT]: ...
+
+
+@overload
+def from_native(
+    native_object: IntoFrame | IntoSeries,
+    *,
+    strict: Literal[True] = ...,
+    eager_only: Literal[False] = ...,
+    eager_or_interchange_only: Literal[False] = ...,
+    series_only: Literal[False] = ...,
+    allow_series: Literal[True],
+) -> DataFrame[Any] | LazyFrame[Any] | Series[Any]: ...
+
+
+@overload
+def from_native(
+    native_object: IntoSeriesT,
+    *,
+    strict: Literal[True] = ...,
+    eager_only: Literal[False] = ...,
+    eager_or_interchange_only: Literal[False] = ...,
+    series_only: Literal[True],
+    allow_series: None = ...,
+) -> Series[IntoSeriesT]: ...
+
+
+@overload
+def from_native(
+    native_object: IntoLazyFrameT,
+    *,
+    strict: Literal[True] = ...,
+    eager_only: Literal[False] = ...,
+    eager_or_interchange_only: Literal[False] = ...,
+    series_only: Literal[False] = ...,
+    allow_series: None = ...,
+) -> LazyFrame[IntoLazyFrameT]: ...
+
+
+# NOTE: `pl.LazyFrame` originally matched here
+@overload
+def from_native(
+    native_object: IntoFrameT,
+    *,
+    strict: Literal[True] = ...,
+    eager_only: Literal[False] = ...,
+    eager_or_interchange_only: Literal[False] = ...,
+    series_only: Literal[False] = ...,
+    allow_series: None = ...,
+) -> DataFrame[IntoFrameT] | LazyFrame[IntoFrameT]: ...
+
+
+@overload
+def from_native(
+    native_object: IntoDataFrameT | IntoSeries,
+    *,
+    pass_through: Literal[True],
+    eager_only: Literal[False] = ...,
+    eager_or_interchange_only: Literal[True],
+    series_only: Literal[False] = ...,
+    allow_series: Literal[True],
+) -> DataFrame[IntoDataFrameT]: ...
+
+
+@overload
+def from_native(
+    native_object: IntoDataFrameT | IntoSeriesT,
+    *,
+    pass_through: Literal[True],
+    eager_only: Literal[True],
+    eager_or_interchange_only: Literal[False] = ...,
+    series_only: Literal[False] = ...,
+    allow_series: Literal[True],
+) -> DataFrame[IntoDataFrameT] | Series[IntoSeriesT]: ...
+
+
+@overload
+def from_native(
+    native_object: IntoDataFrameT,
+    *,
+    pass_through: Literal[True],
+    eager_only: Literal[False] = ...,
+    eager_or_interchange_only: Literal[True],
+    series_only: Literal[False] = ...,
+    allow_series: None = ...,
+) -> DataFrame[IntoDataFrameT]: ...
+
+
+@overload
+def from_native(
+    native_object: T,
+    *,
+    pass_through: Literal[True],
+    eager_only: Literal[False] = ...,
+    eager_or_interchange_only: Literal[True],
+    series_only: Literal[False] = ...,
+    allow_series: None = ...,
+) -> T: ...
+
+
+@overload
+def from_native(
+    native_object: IntoDataFrameT,
+    *,
+    pass_through: Literal[True],
+    eager_only: Literal[True],
+    eager_or_interchange_only: Literal[False] = ...,
+    series_only: Literal[False] = ...,
+    allow_series: None = ...,
+) -> DataFrame[IntoDataFrameT]: ...
+
+
+@overload
+def from_native(
+    native_object: T,
+    *,
+    pass_through: Literal[True],
+    eager_only: Literal[True],
+    eager_or_interchange_only: Literal[False] = ...,
+    series_only: Literal[False] = ...,
+    allow_series: None = ...,
+) -> T: ...
+
+
+@overload
+def from_native(
+    native_object: IntoFrameT | IntoSeriesT,
+    *,
+    pass_through: Literal[True],
+    eager_only: Literal[False] = ...,
+    eager_or_interchange_only: Literal[False] = ...,
+    series_only: Literal[False] = ...,
+    allow_series: Literal[True],
+) -> DataFrame[IntoFrameT] | LazyFrame[IntoFrameT] | Series[IntoSeriesT]: ...
+
+
+@overload
+def from_native(
+    native_object: IntoSeriesT,
+    *,
+    pass_through: Literal[True],
+    eager_only: Literal[False] = ...,
+    eager_or_interchange_only: Literal[False] = ...,
+    series_only: Literal[True],
+    allow_series: None = ...,
+) -> Series[IntoSeriesT]: ...
+
+
+@overload
+def from_native(
+    native_object: IntoFrameT,
+    *,
+    pass_through: Literal[True],
+    eager_only: Literal[False] = ...,
+    eager_or_interchange_only: Literal[False] = ...,
+    series_only: Literal[False] = ...,
+    allow_series: None = ...,
+) -> DataFrame[IntoFrameT] | LazyFrame[IntoFrameT]: ...
+
+
+@overload
+def from_native(
+    native_object: T,
+    *,
+    pass_through: Literal[True],
+    eager_only: Literal[False] = ...,
+    eager_or_interchange_only: Literal[False] = ...,
+    series_only: Literal[False] = ...,
+    allow_series: None = ...,
+) -> T: ...
+
+
+@overload
+def from_native(
+    native_object: IntoDataFrameT,
+    *,
+    pass_through: Literal[False] = ...,
+    eager_only: Literal[False] = ...,
+    eager_or_interchange_only: Literal[True],
+    series_only: Literal[False] = ...,
+    allow_series: None = ...,
+) -> DataFrame[IntoDataFrameT]: ...
+
+
+@overload
+def from_native(
+    native_object: IntoDataFrameT,
+    *,
+    pass_through: Literal[False] = ...,
+    eager_only: Literal[True],
+    eager_or_interchange_only: Literal[False] = ...,
+    series_only: Literal[False] = ...,
+    allow_series: None = ...,
+) -> DataFrame[IntoDataFrameT]: ...
+
+
+@overload
+def from_native(
+    native_object: IntoFrame | IntoSeries,
+    *,
+    pass_through: Literal[False] = ...,
+    eager_only: Literal[False] = ...,
+    eager_or_interchange_only: Literal[False] = ...,
+    series_only: Literal[False] = ...,
+    allow_series: Literal[True],
+) -> DataFrame[Any] | LazyFrame[Any] | Series[Any]: ...
+
+
+@overload
+def from_native(
+    native_object: IntoSeriesT,
+    *,
+    pass_through: Literal[False] = ...,
+    eager_only: Literal[False] = ...,
+    eager_or_interchange_only: Literal[False] = ...,
+    series_only: Literal[True],
+    allow_series: None = ...,
+) -> Series[IntoSeriesT]: ...
+
+
+@overload
+def from_native(
+    native_object: IntoFrameT,
+    *,
+    pass_through: Literal[False] = ...,
+    eager_only: Literal[False] = ...,
+    eager_or_interchange_only: Literal[False] = ...,
+    series_only: Literal[False] = ...,
+    allow_series: None = ...,
+) -> DataFrame[IntoFrameT] | LazyFrame[IntoFrameT]: ...
+
+
+# All params passed in as variables
+@overload
+def from_native(
+    native_object: Any,
+    *,
+    pass_through: bool,
+    eager_only: bool,
+    eager_or_interchange_only: bool = False,
+    series_only: bool,
+    allow_series: bool | None,
+) -> Any: ...
+
+
+def from_native(
+    native_object: IntoFrameT | IntoFrame | IntoSeriesT | IntoSeries | T,
+    *,
+    strict: bool | None = None,
+    pass_through: bool | None = None,
+    eager_only: bool = False,
+    eager_or_interchange_only: bool = False,
+    series_only: bool = False,
+    allow_series: bool | None = None,
+    **kwds: Any,
+) -> LazyFrame[IntoFrameT] | DataFrame[IntoFrameT] | Series[IntoSeriesT] | T:
+    """Convert `native_object` to Narwhals Dataframe, Lazyframe, or Series.
+
+    See `narwhals.from_native` for full docstring. Note that `native_namespace` is
+    an is the same as `backend` but only accepts module types - for new code, we
+    recommend using `backend`, as that's available beyond just `narwhals.stable.v1`.
+    """
+    # Early returns
+    if isinstance(native_object, (DataFrame, LazyFrame)) and not series_only:
+        return native_object
+    if isinstance(native_object, Series) and (series_only or allow_series):
+        return native_object
+
+    pass_through = validate_strict_and_pass_though(
+        strict, pass_through, pass_through_default=False
+    )
+    if kwds:
+        msg = f"from_native() got an unexpected keyword argument {next(iter(kwds))!r}"
+        raise TypeError(msg)
+
+    return _from_native_impl(  # type: ignore[no-any-return]
+        native_object,
+        pass_through=pass_through,
+        eager_only=eager_only,
+        eager_or_interchange_only=eager_or_interchange_only,
+        series_only=series_only,
+        allow_series=allow_series,
+        version=Version.V1,
+    )
+
+
+@overload
+def to_native(
+    narwhals_object: DataFrame[IntoDataFrameT], *, strict: Literal[True] = ...
+) -> IntoDataFrameT: ...
+@overload
+def to_native(
+    narwhals_object: LazyFrame[IntoFrameT], *, strict: Literal[True] = ...
+) -> IntoFrameT: ...
+@overload
+def to_native(
+    narwhals_object: Series[IntoSeriesT], *, strict: Literal[True] = ...
+) -> IntoSeriesT: ...
+@overload
+def to_native(narwhals_object: Any, *, strict: bool) -> Any: ...
+@overload
+def to_native(
+    narwhals_object: DataFrame[IntoDataFrameT], *, pass_through: Literal[False] = ...
+) -> IntoDataFrameT: ...
+@overload
+def to_native(
+    narwhals_object: LazyFrame[IntoFrameT], *, pass_through: Literal[False] = ...
+) -> IntoFrameT: ...
+@overload
+def to_native(
+    narwhals_object: Series[IntoSeriesT], *, pass_through: Literal[False] = ...
+) -> IntoSeriesT: ...
+@overload
+def to_native(narwhals_object: Any, *, pass_through: bool) -> Any: ...
+
+
+def to_native(
+    narwhals_object: DataFrame[IntoDataFrameT]
+    | LazyFrame[IntoFrameT]
+    | Series[IntoSeriesT],
+    *,
+    strict: bool | None = None,
+    pass_through: bool | None = None,
+) -> IntoFrameT | IntoSeriesT | Any:
+    """Convert Narwhals object to native one.
+
+    See `narwhals.to_native` for full docstring. Note that `native_namespace` is
+    an is the same as `backend` but only accepts module types - for new code, we
+    recommend using `backend`, as that's available beyond just `narwhals.stable.v1`.
+    """
+    from narwhals._utils import validate_strict_and_pass_though
+
+    pass_through = validate_strict_and_pass_though(
+        strict, pass_through, pass_through_default=False
+    )
+    return nw.to_native(narwhals_object, pass_through=pass_through)
+
+
+def narwhalify(
+    func: Callable[..., Any] | None = None,
+    *,
+    strict: bool | None = None,
+    pass_through: bool | None = None,
+    eager_only: bool = False,
+    eager_or_interchange_only: bool = False,
+    series_only: bool = False,
+    allow_series: bool | None = True,
+) -> Callable[..., Any]:
+    """Decorate function so it becomes dataframe-agnostic.
+
+    See `narwhals.narwhalify` for full docstring. Note that `native_namespace` is
+    an is the same as `backend` but only accepts module types - for new code, we
+    recommend using `backend`, as that's available beyond just `narwhals.stable.v1`.
+    """
+    pass_through = validate_strict_and_pass_though(
+        strict, pass_through, pass_through_default=True
+    )
+
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            args = [
+                from_native(
+                    arg,
+                    pass_through=pass_through,
+                    eager_only=eager_only,
+                    eager_or_interchange_only=eager_or_interchange_only,
+                    series_only=series_only,
+                    allow_series=allow_series,
+                )
+                for arg in args
+            ]  # type: ignore[assignment]
+
+            kwargs = {
+                name: from_native(
+                    value,
+                    pass_through=pass_through,
+                    eager_only=eager_only,
+                    eager_or_interchange_only=eager_or_interchange_only,
+                    series_only=series_only,
+                    allow_series=allow_series,
+                )
+                for name, value in kwargs.items()
+            }
+
+            backends = {
+                b()
+                for v in (*args, *kwargs.values())
+                if (b := getattr(v, "__native_namespace__", None))
+            }
+
+            if backends.__len__() > 1:
+                msg = "Found multiple backends. Make sure that all dataframe/series inputs come from the same backend."
+                raise ValueError(msg)
+
+            result = func(*args, **kwargs)
+
+            return to_native(result, pass_through=pass_through)
+
+        return wrapper
+
+    if func is None:
+        return decorator
+    else:
+        # If func is not None, it means the decorator is used without arguments
+        return decorator(func)
+
+
+def all() -> Expr:
+    return _stableify(nw.all())
+
+
+def col(*names: str | Iterable[str]) -> Expr:
+    return _stableify(nw.col(*names))
+
+
+def exclude(*names: str | Iterable[str]) -> Expr:
+    return _stableify(nw.exclude(*names))
+
+
+def nth(*indices: int | Sequence[int]) -> Expr:
+    return _stableify(nw.nth(*indices))
+
+
+def len() -> Expr:
+    return _stableify(nw.len())
+
+
+def lit(value: NonNestedLiteral, dtype: IntoDType | None = None) -> Expr:
+    return _stableify(nw.lit(value, dtype))
+
+
+def min(*columns: str) -> Expr:
+    return _stableify(nw.min(*columns))
+
+
+def max(*columns: str) -> Expr:
+    return _stableify(nw.max(*columns))
+
+
+def mean(*columns: str) -> Expr:
+    return _stableify(nw.mean(*columns))
+
+
+def median(*columns: str) -> Expr:
+    return _stableify(nw.median(*columns))
+
+
+def sum(*columns: str) -> Expr:
+    return _stableify(nw.sum(*columns))
+
+
+def sum_horizontal(*exprs: IntoExpr | Iterable[IntoExpr]) -> Expr:
+    return _stableify(nw.sum_horizontal(*exprs))
+
+
+def all_horizontal(
+    *exprs: IntoExpr | Iterable[IntoExpr], ignore_nulls: bool = False
+) -> Expr:
+    return _stableify(nw.all_horizontal(*exprs, ignore_nulls=ignore_nulls))
+
+
+def any_horizontal(
+    *exprs: IntoExpr | Iterable[IntoExpr], ignore_nulls: bool = False
+) -> Expr:
+    return _stableify(nw.any_horizontal(*exprs, ignore_nulls=ignore_nulls))
+
+
+def mean_horizontal(*exprs: IntoExpr | Iterable[IntoExpr]) -> Expr:
+    return _stableify(nw.mean_horizontal(*exprs))
+
+
+def min_horizontal(*exprs: IntoExpr | Iterable[IntoExpr]) -> Expr:
+    return _stableify(nw.min_horizontal(*exprs))
+
+
+def max_horizontal(*exprs: IntoExpr | Iterable[IntoExpr]) -> Expr:
+    return _stableify(nw.max_horizontal(*exprs))
+
+
+def concat_str(
+    exprs: IntoExpr | Iterable[IntoExpr],
+    *more_exprs: IntoExpr,
+    separator: str = "",
+    ignore_nulls: bool = False,
+) -> Expr:
+    return _stableify(
+        nw.concat_str(exprs, *more_exprs, separator=separator, ignore_nulls=ignore_nulls)
+    )
+
+
+def coalesce(exprs: IntoExpr | Iterable[IntoExpr], *more_exprs: IntoExpr) -> Expr:
+    return _stableify(nw.coalesce(exprs, *more_exprs))
+
+
+def get_level(
+    obj: DataFrame[Any] | LazyFrame[Any] | Series[IntoSeriesT],
+) -> Literal["full", "lazy", "interchange"]:
+    """Level of support Narwhals has for current object.
+
+    Arguments:
+        obj: Dataframe or Series.
+
+    Returns:
+        This can be one of
+
+            - 'full': full Narwhals API support
+            - 'lazy': only lazy operations are supported. This excludes anything
+              which involves iterating over rows in Python.
+            - 'interchange': only metadata operations are supported (`df.schema`)
+    """
+    return obj._level
+
+
+class When(nw_f.When):
+    @classmethod
+    def from_when(cls, when: nw_f.When) -> When:
+        return cls(when._predicate)
+
+    def then(self, value: IntoExpr | NonNestedLiteral | _1DArray) -> Then:
+        return Then.from_then(super().then(value))
+
+
+class Then(nw_f.Then, Expr):
+    @classmethod
+    def from_then(cls, then: nw_f.Then) -> Then:
+        return cls(then._to_compliant_expr, then._metadata)
+
+    def otherwise(self, value: IntoExpr | NonNestedLiteral | _1DArray) -> Expr:
+        return _stableify(super().otherwise(value))
+
+
+def when(*predicates: IntoExpr | Iterable[IntoExpr]) -> When:
+    return When.from_when(nw_f.when(*predicates))
+
+
+@deprecate_native_namespace(required=True)
+def new_series(
+    name: str,
+    values: Any,
+    dtype: IntoDType | None = None,
+    *,
+    backend: ModuleType | Implementation | str | None = None,
+    native_namespace: ModuleType | None = None,  # noqa: ARG001
+) -> Series[Any]:
+    """Instantiate Narwhals Series from iterable (e.g. list or array).
+
+    See `narwhals.new_series` for full docstring. Note that `native_namespace` is
+    an is the same as `backend` but only accepts module types - for new code, we
+    recommend using `backend`, as that's available beyond just `narwhals.stable.v1`.
+    """
+    backend = cast("ModuleType | Implementation | str", backend)
+    return _stableify(_new_series_impl(name, values, dtype, backend=backend))
+
+
+@deprecate_native_namespace(required=True)
+def from_arrow(
+    native_frame: IntoArrowTable,
+    *,
+    backend: ModuleType | Implementation | str | None = None,
+    native_namespace: ModuleType | None = None,  # noqa: ARG001
+) -> DataFrame[Any]:
+    """Construct a DataFrame from an object which supports the PyCapsule Interface.
+
+    See `narwhals.from_arrow` for full docstring. Note that `native_namespace` is
+    an is the same as `backend` but only accepts module types - for new code, we
+    recommend using `backend`, as that's available beyond just `narwhals.stable.v1`.
+    """
+    backend = cast("ModuleType | Implementation | str", backend)
+    return _stableify(nw_f.from_arrow(native_frame, backend=backend))
+
+
+@deprecate_native_namespace()
+def from_dict(
+    data: Mapping[str, Any],
+    schema: Mapping[str, DType] | Schema | None = None,
+    *,
+    backend: ModuleType | Implementation | str | None = None,
+    native_namespace: ModuleType | None = None,  # noqa: ARG001
+) -> DataFrame[Any]:
+    """Instantiate DataFrame from dictionary.
+
+    See `narwhals.from_dict` for full docstring. Note that `native_namespace` is
+    an is the same as `backend` but only accepts module types - for new code, we
+    recommend using `backend`, as that's available beyond just `narwhals.stable.v1`.
+    """
+    return _stableify(nw_f.from_dict(data, schema, backend=backend))
+
+
+@deprecate_native_namespace(required=True)
+def from_numpy(
+    data: _2DArray,
+    schema: Mapping[str, DType] | Schema | Sequence[str] | None = None,
+    *,
+    backend: ModuleType | Implementation | str | None = None,
+    native_namespace: ModuleType | None = None,  # noqa: ARG001
+) -> DataFrame[Any]:
+    """Construct a DataFrame from a NumPy ndarray.
+
+    See `narwhals.from_numpy` for full docstring. Note that `native_namespace` is
+    an is the same as `backend` but only accepts module types - for new code, we
+    recommend using `backend`, as that's available beyond just `narwhals.stable.v1`.
+    """
+    backend = cast("ModuleType | Implementation | str", backend)
+    return _stableify(nw_f.from_numpy(data, schema, backend=backend))
+
+
+@deprecate_native_namespace(required=True)
+def read_csv(
+    source: str,
+    *,
+    backend: ModuleType | Implementation | str | None = None,
+    native_namespace: ModuleType | None = None,  # noqa: ARG001
+    **kwargs: Any,
+) -> DataFrame[Any]:
+    """Read a CSV file into a DataFrame.
+
+    See `narwhals.read_csv` for full docstring. Note that `native_namespace` is
+    an is the same as `backend` but only accepts module types - for new code, we
+    recommend using `backend`, as that's available beyond just `narwhals.stable.v1`.
+    """
+    backend = cast("ModuleType | Implementation | str", backend)
+    return _stableify(nw_f.read_csv(source, backend=backend, **kwargs))
+
+
+@deprecate_native_namespace(required=True)
+def scan_csv(
+    source: str,
+    *,
+    backend: ModuleType | Implementation | str | None = None,
+    native_namespace: ModuleType | None = None,  # noqa: ARG001
+    **kwargs: Any,
+) -> LazyFrame[Any]:
+    """Lazily read from a CSV file.
+
+    See `narwhals.scan_csv` for full docstring. Note that `native_namespace` is
+    an is the same as `backend` but only accepts module types - for new code, we
+    recommend using `backend`, as that's available beyond just `narwhals.stable.v1`.
+    """
+    backend = cast("ModuleType | Implementation | str", backend)
+    return _stableify(nw_f.scan_csv(source, backend=backend, **kwargs))
+
+
+@deprecate_native_namespace(required=True)
+def read_parquet(
+    source: str,
+    *,
+    backend: ModuleType | Implementation | str | None = None,
+    native_namespace: ModuleType | None = None,  # noqa: ARG001
+    **kwargs: Any,
+) -> DataFrame[Any]:
+    """Read into a DataFrame from a parquet file.
+
+    See `narwhals.read_parquet` for full docstring. Note that `native_namespace` is
+    an is the same as `backend` but only accepts module types - for new code, we
+    recommend using `backend`, as that's available beyond just `narwhals.stable.v1`.
+    """
+    backend = cast("ModuleType | Implementation | str", backend)
+    return _stableify(nw_f.read_parquet(source, backend=backend, **kwargs))
+
+
+@deprecate_native_namespace(required=True)
+def scan_parquet(
+    source: str,
+    *,
+    backend: ModuleType | Implementation | str | None = None,
+    native_namespace: ModuleType | None = None,  # noqa: ARG001
+    **kwargs: Any,
+) -> LazyFrame[Any]:
+    """Lazily read from a parquet file.
+
+    See `narwhals.scan_parquet` for full docstring. Note that `native_namespace` is
+    an is the same as `backend` but only accepts module types - for new code, we
+    recommend using `backend`, as that's available beyond just `narwhals.stable.v1`.
+    """
+    backend = cast("ModuleType | Implementation | str", backend)
+    return _stableify(nw_f.scan_parquet(source, backend=backend, **kwargs))
+
+
+__all__ = [
+    "Array",
+    "Binary",
+    "Boolean",
+    "Categorical",
+    "DataFrame",
+    "Date",
+    "Datetime",
+    "Decimal",
+    "Duration",
+    "Enum",
+    "Expr",
+    "Field",
+    "Float32",
+    "Float64",
+    "Implementation",
+    "Int8",
+    "Int16",
+    "Int32",
+    "Int64",
+    "Int128",
+    "LazyFrame",
+    "List",
+    "Object",
+    "Schema",
+    "Series",
+    "String",
+    "Struct",
+    "Time",
+    "UInt8",
+    "UInt16",
+    "UInt32",
+    "UInt64",
+    "UInt128",
+    "Unknown",
+    "all",
+    "all_horizontal",
+    "any_horizontal",
+    "coalesce",
+    "col",
+    "concat",
+    "concat_str",
+    "dependencies",
+    "dtypes",
+    "exceptions",
+    "exclude",
+    "from_arrow",
+    "from_dict",
+    "from_native",
+    "from_numpy",
+    "generate_temporary_column_name",
+    "get_level",
+    "get_native_namespace",
+    "is_ordered_categorical",
+    "len",
+    "lit",
+    "max",
+    "max_horizontal",
+    "maybe_align_index",
+    "maybe_convert_dtypes",
+    "maybe_get_index",
+    "maybe_reset_index",
+    "maybe_set_index",
+    "mean",
+    "mean_horizontal",
+    "median",
+    "min",
+    "min_horizontal",
+    "narwhalify",
+    "new_series",
+    "nth",
+    "read_csv",
+    "read_parquet",
+    "scan_csv",
+    "scan_parquet",
+    "selectors",
+    "show_versions",
+    "sum",
+    "sum_horizontal",
+    "to_native",
+    "to_py_scalar",
+    "when",
+]
diff --git a/lib/python3.10/site-packages/narwhals/stable/v1/__pycache__/__init__.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/stable/v1/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9f354e02c8a7c39acaaa482e0da9c08970935dad
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/stable/v1/__pycache__/__init__.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/stable/v1/__pycache__/_dtypes.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/stable/v1/__pycache__/_dtypes.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d90e1de3c7c7ec2060b52ce7b8cca4b7eb7fb71d
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/stable/v1/__pycache__/_dtypes.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/stable/v1/__pycache__/_namespace.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/stable/v1/__pycache__/_namespace.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e7a224d9979ba8f2670a99092cf68cec493b07d7
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/stable/v1/__pycache__/_namespace.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/stable/v1/__pycache__/dependencies.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/stable/v1/__pycache__/dependencies.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d3f26e5265d180c3eb55c7d54ae79f135bdc2fff
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/stable/v1/__pycache__/dependencies.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/stable/v1/__pycache__/dtypes.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/stable/v1/__pycache__/dtypes.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ec49e1ce10ecf027bf55a21761274eac9bd28fc1
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/stable/v1/__pycache__/dtypes.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/stable/v1/__pycache__/selectors.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/stable/v1/__pycache__/selectors.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fb62bc814bd44764220a94850a1a886753b4219b
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/stable/v1/__pycache__/selectors.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/stable/v1/__pycache__/typing.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/stable/v1/__pycache__/typing.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e0685080ab394d380ce57767e2df0309fd35bbde
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/stable/v1/__pycache__/typing.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/stable/v1/_dtypes.py b/lib/python3.10/site-packages/narwhals/stable/v1/_dtypes.py
new file mode 100644
index 0000000000000000000000000000000000000000..060980c562dbfae73586c70150b4a5709dc6a2aa
--- /dev/null
+++ b/lib/python3.10/site-packages/narwhals/stable/v1/_dtypes.py
@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from narwhals._utils import inherit_doc
+from narwhals.dtypes import (
+    Array,
+    Binary,
+    Boolean,
+    Categorical,
+    Date,
+    Datetime as NwDatetime,
+    Decimal,
+    DType,
+    Duration as NwDuration,
+    Enum as NwEnum,
+    Field,
+    Float32,
+    Float64,
+    FloatType,
+    Int8,
+    Int16,
+    Int32,
+    Int64,
+    Int128,
+    IntegerType,
+    List,
+    NestedType,
+    NumericType,
+    Object,
+    SignedIntegerType,
+    String,
+    Struct,
+    Time,
+    UInt8,
+    UInt16,
+    UInt32,
+    UInt64,
+    UInt128,
+    Unknown,
+    UnsignedIntegerType,
+)
+
+if TYPE_CHECKING:
+    from datetime import timezone
+
+    from narwhals.typing import TimeUnit
+
+
+class Datetime(NwDatetime):
+    @inherit_doc(NwDatetime)
+    def __init__(
+        self, time_unit: TimeUnit = "us", time_zone: str | timezone | None = None
+    ) -> None:
+        super().__init__(time_unit, time_zone)
+
+    def __hash__(self) -> int:
+        return hash(self.__class__)
+
+
+class Duration(NwDuration):
+    @inherit_doc(NwDuration)
+    def __init__(self, time_unit: TimeUnit = "us") -> None:
+        super().__init__(time_unit)
+
+    def __hash__(self) -> int:
+        return hash(self.__class__)
+
+
+class Enum(NwEnum):
+    """A fixed categorical encoding of a unique set of strings.
+
+    Polars has an Enum data type, while pandas and PyArrow do not.
+
+    Examples:
+       >>> import polars as pl
+       >>> import narwhals.stable.v1 as nw
+       >>> data = ["beluga", "narwhal", "orca"]
+       >>> s_native = pl.Series(data, dtype=pl.Enum(data))
+       >>> nw.from_native(s_native, series_only=True).dtype
+       Enum
+    """
+
+    def __init__(self) -> None:
+        super(NwEnum, self).__init__()
+
+    def __eq__(self, other: DType | type[DType]) -> bool:  # type: ignore[override]
+        if type(other) is type:
+            return other in {type(self), NwEnum}
+        return isinstance(other, type(self))
+
+    def __hash__(self) -> int:  # pragma: no cover
+        return super(NwEnum, self).__hash__()
+
+    def __repr__(self) -> str:  # pragma: no cover
+        return super(NwEnum, self).__repr__()
+
+
+__all__ = [
+    "Array",
+    "Binary",
+    "Boolean",
+    "Categorical",
+    "DType",
+    "Date",
+    "Datetime",
+    "Decimal",
+    "Duration",
+    "Enum",
+    "Field",
+    "Float32",
+    "Float64",
+    "FloatType",
+    "Int8",
+    "Int16",
+    "Int32",
+    "Int64",
+    "Int128",
+    "IntegerType",
+    "List",
+    "NestedType",
+    "NumericType",
+    "Object",
+    "SignedIntegerType",
+    "String",
+    "Struct",
+    "Time",
+    "UInt8",
+    "UInt16",
+    "UInt32",
+    "UInt64",
+    "UInt128",
+    "Unknown",
+    "UnsignedIntegerType",
+]
diff --git a/lib/python3.10/site-packages/narwhals/stable/v1/_namespace.py b/lib/python3.10/site-packages/narwhals/stable/v1/_namespace.py
new file mode 100644
index 0000000000000000000000000000000000000000..8f11f0110216efc73bbc579e6a0656d86e21115e
--- /dev/null
+++ b/lib/python3.10/site-packages/narwhals/stable/v1/_namespace.py
@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from narwhals._compliant.typing import CompliantNamespaceT_co
+from narwhals._namespace import Namespace as NwNamespace
+from narwhals._utils import Version
+
+__all__ = ["Namespace"]
+
+
+class Namespace(NwNamespace[CompliantNamespaceT_co], version=Version.V1): ...
diff --git a/lib/python3.10/site-packages/narwhals/stable/v1/dependencies.py b/lib/python3.10/site-packages/narwhals/stable/v1/dependencies.py
new file mode 100644
index 0000000000000000000000000000000000000000..2674f2890f057bd657f178e0b70f09596410d376
--- /dev/null
+++ b/lib/python3.10/site-packages/narwhals/stable/v1/dependencies.py
@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    import cudf
+    import dask.dataframe as dd
+    import ibis
+    import modin.pandas as mpd
+    import pandas as pd
+    import polars as pl
+    import pyarrow as pa
+    from typing_extensions import TypeIs
+
+
+from narwhals.dependencies import (
+    IMPORT_HOOKS,
+    get_cudf,
+    get_dask_dataframe,
+    get_ibis,
+    get_modin,
+    get_numpy,
+    get_pandas,
+    get_polars,
+    get_pyarrow,
+    is_into_dataframe,
+    is_into_series,
+    is_narwhals_dataframe,
+    is_narwhals_lazyframe,
+    is_narwhals_series,
+    is_numpy_array,
+    is_pandas_index,
+)
+
+
+def is_pandas_dataframe(df: Any) -> TypeIs[pd.DataFrame]:
+    """Check whether `df` is a pandas DataFrame without importing pandas."""
+    return ((pd := get_pandas()) is not None and isinstance(df, pd.DataFrame)) or any(
+        (mod := sys.modules.get(module_name, None)) is not None
+        and isinstance(df, mod.pandas.DataFrame)
+        for module_name in IMPORT_HOOKS
+    )
+
+
+def is_pandas_series(ser: Any) -> TypeIs[pd.Series[Any]]:
+    """Check whether `ser` is a pandas Series without importing pandas."""
+    return ((pd := get_pandas()) is not None and isinstance(ser, pd.Series)) or any(
+        (mod := sys.modules.get(module_name, None)) is not None
+        and isinstance(ser, mod.pandas.Series)
+        for module_name in IMPORT_HOOKS
+    )
+
+
+def is_modin_dataframe(df: Any) -> TypeIs[mpd.DataFrame]:
+    """Check whether `df` is a modin DataFrame without importing modin."""
+    return (mpd := get_modin()) is not None and isinstance(df, mpd.DataFrame)
+
+
+def is_modin_series(ser: Any) -> TypeIs[mpd.Series]:
+    """Check whether `ser` is a modin Series without importing modin."""
+    return (mpd := get_modin()) is not None and isinstance(ser, mpd.Series)
+
+
+def is_cudf_dataframe(df: Any) -> TypeIs[cudf.DataFrame]:
+    """Check whether `df` is a cudf DataFrame without importing cudf."""
+    return (cudf := get_cudf()) is not None and isinstance(df, cudf.DataFrame)
+
+
+def is_cudf_series(ser: Any) -> TypeIs[cudf.Series[Any]]:
+    """Check whether `ser` is a cudf Series without importing cudf."""
+    return (cudf := get_cudf()) is not None and isinstance(ser, cudf.Series)
+
+
+def is_dask_dataframe(df: Any) -> TypeIs[dd.DataFrame]:
+    """Check whether `df` is a Dask DataFrame without importing Dask."""
+    return (dd := get_dask_dataframe()) is not None and isinstance(df, dd.DataFrame)
+
+
+def is_ibis_table(df: Any) -> TypeIs[ibis.Table]:
+    """Check whether `df` is a Ibis Table without importing Ibis."""
+    return (ibis := get_ibis()) is not None and isinstance(df, ibis.expr.types.Table)
+
+
+def is_polars_dataframe(df: Any) -> TypeIs[pl.DataFrame]:
+    """Check whether `df` is a Polars DataFrame without importing Polars."""
+    return (pl := get_polars()) is not None and isinstance(df, pl.DataFrame)
+
+
+def is_polars_lazyframe(df: Any) -> TypeIs[pl.LazyFrame]:
+    """Check whether `df` is a Polars LazyFrame without importing Polars."""
+    return (pl := get_polars()) is not None and isinstance(df, pl.LazyFrame)
+
+
+def is_polars_series(ser: Any) -> TypeIs[pl.Series]:
+    """Check whether `ser` is a Polars Series without importing Polars."""
+    return (pl := get_polars()) is not None and isinstance(ser, pl.Series)
+
+
+def is_pyarrow_chunked_array(ser: Any) -> TypeIs[pa.ChunkedArray[Any]]:
+    """Check whether `ser` is a PyArrow ChunkedArray without importing PyArrow."""
+    return (pa := get_pyarrow()) is not None and isinstance(ser, pa.ChunkedArray)
+
+
+def is_pyarrow_table(df: Any) -> TypeIs[pa.Table]:
+    """Check whether `df` is a PyArrow Table without importing PyArrow."""
+    return (pa := get_pyarrow()) is not None and isinstance(df, pa.Table)
+
+
+def is_pandas_like_dataframe(df: Any) -> bool:
+    """Check whether `df` is a pandas-like DataFrame without doing any imports.
+
+    By "pandas-like", we mean: pandas, Modin, cuDF.
+    """
+    return is_pandas_dataframe(df) or is_modin_dataframe(df) or is_cudf_dataframe(df)
+
+
+def is_pandas_like_series(ser: Any) -> bool:
+    """Check whether `ser` is a pandas-like Series without doing any imports.
+
+    By "pandas-like", we mean: pandas, Modin, cuDF.
+    """
+    return is_pandas_series(ser) or is_modin_series(ser) or is_cudf_series(ser)
+
+
+__all__ = [
+    "get_cudf",
+    "get_ibis",
+    "get_modin",
+    "get_numpy",
+    "get_pandas",
+    "get_polars",
+    "get_pyarrow",
+    "is_cudf_dataframe",
+    "is_cudf_series",
+    "is_dask_dataframe",
+    "is_ibis_table",
+    "is_into_dataframe",
+    "is_into_series",
+    "is_modin_dataframe",
+    "is_modin_series",
+    "is_narwhals_dataframe",
+    "is_narwhals_lazyframe",
+    "is_narwhals_series",
+    "is_numpy_array",
+    "is_pandas_dataframe",
+    "is_pandas_index",
+    "is_pandas_like_dataframe",
+    "is_pandas_like_series",
+    "is_pandas_series",
+    "is_polars_dataframe",
+    "is_polars_lazyframe",
+    "is_polars_series",
+    "is_pyarrow_chunked_array",
+    "is_pyarrow_table",
+]
diff --git a/lib/python3.10/site-packages/narwhals/stable/v1/dtypes.py b/lib/python3.10/site-packages/narwhals/stable/v1/dtypes.py
new file mode 100644
index 0000000000000000000000000000000000000000..a292be8a6010cd39b3c230132dad72e98d5346ab
--- /dev/null
+++ b/lib/python3.10/site-packages/narwhals/stable/v1/dtypes.py
@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from narwhals.stable.v1._dtypes import (
+    Array,
+    Binary,
+    Boolean,
+    Categorical,
+    Date,
+    Datetime,
+    Decimal,
+    DType,
+    Duration,
+    Enum,
+    Field,
+    Float32,
+    Float64,
+    FloatType,
+    Int8,
+    Int16,
+    Int32,
+    Int64,
+    Int128,
+    IntegerType,
+    List,
+    NestedType,
+    NumericType,
+    Object,
+    SignedIntegerType,
+    String,
+    Struct,
+    Time,
+    UInt8,
+    UInt16,
+    UInt32,
+    UInt64,
+    UInt128,
+    Unknown,
+    UnsignedIntegerType,
+)
+
+__all__ = [
+    "Array",
+    "Binary",
+    "Boolean",
+    "Categorical",
+    "DType",
+    "Date",
+    "Datetime",
+    "Decimal",
+    "Duration",
+    "Enum",
+    "Field",
+    "Float32",
+    "Float64",
+    "FloatType",
+    "Int8",
+    "Int16",
+    "Int32",
+    "Int64",
+    "Int128",
+    "IntegerType",
+    "List",
+    "NestedType",
+    "NumericType",
+    "Object",
+    "SignedIntegerType",
+    "String",
+    "Struct",
+    "Time",
+    "UInt8",
+    "UInt16",
+    "UInt32",
+    "UInt64",
+    "UInt128",
+    "Unknown",
+    "UnsignedIntegerType",
+]
diff --git a/lib/python3.10/site-packages/narwhals/stable/v1/selectors.py b/lib/python3.10/site-packages/narwhals/stable/v1/selectors.py
new file mode 100644
index 0000000000000000000000000000000000000000..ede128eb3cff3f36781c20e64cb0e25c0dbfce55
--- /dev/null
+++ b/lib/python3.10/site-packages/narwhals/stable/v1/selectors.py
@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from narwhals.selectors import (
+    all,
+    boolean,
+    by_dtype,
+    categorical,
+    datetime,
+    matches,
+    numeric,
+    string,
+)
+
+__all__ = [
+    "all",
+    "boolean",
+    "by_dtype",
+    "categorical",
+    "datetime",
+    "matches",
+    "numeric",
+    "string",
+]
diff --git a/lib/python3.10/site-packages/narwhals/stable/v1/typing.py b/lib/python3.10/site-packages/narwhals/stable/v1/typing.py
new file mode 100644
index 0000000000000000000000000000000000000000..c3a0b421bc2103ef6f787f904245b6a553f29055
--- /dev/null
+++ b/lib/python3.10/site-packages/narwhals/stable/v1/typing.py
@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Protocol, TypeVar, Union
+
+if TYPE_CHECKING:
+    import sys
+
+    from narwhals.stable.v1 import DataFrame, LazyFrame
+
+    if sys.version_info >= (3, 10):
+        from typing import TypeAlias
+    else:
+        from typing_extensions import TypeAlias
+
+    from narwhals.stable.v1 import Expr, Series
+
+    # All dataframes supported by Narwhals have a
+    # `columns` property. Their similarities don't extend
+    # _that_ much further unfortunately...
+    class NativeFrame(Protocol):
+        @property
+        def columns(self) -> Any: ...
+
+        def join(self, *args: Any, **kwargs: Any) -> Any: ...
+
+    class NativeSeries(Protocol):
+        def __len__(self) -> int: ...
+
+    class DataFrameLike(Protocol):
+        def __dataframe__(self, *args: Any, **kwargs: Any) -> Any: ...
+
+
+IntoExpr: TypeAlias = Union["Expr", str, "Series[Any]"]
+"""Anything which can be converted to an expression.
+
+Use this to mean "either a Narwhals expression, or something
+which can be converted into one". For example, `exprs` in `DataFrame.select` is
+typed to accept `IntoExpr`, as it can either accept a `nw.Expr`
+(e.g. `df.select(nw.col('a'))`) or a string which will be interpreted as a
+`nw.Expr`, e.g. `df.select('a')`.
+"""
+
+IntoDataFrame: TypeAlias = Union["NativeFrame", "DataFrame[Any]", "DataFrameLike"]
+"""Anything which can be converted to a Narwhals DataFrame.
+
+Use this if your function accepts a narwhalifiable object but doesn't care about its backend.
+
+Examples:
+    >>> import narwhals as nw
+    >>> from narwhals.typing import IntoDataFrame
+    >>> def agnostic_shape(df_native: IntoDataFrame) -> tuple[int, int]:
+    ...     df = nw.from_native(df_native, eager_only=True)
+    ...     return df.shape
+"""
+
+IntoFrame: TypeAlias = Union[
+    "NativeFrame", "DataFrame[Any]", "LazyFrame[Any]", "DataFrameLike"
+]
+"""Anything which can be converted to a Narwhals DataFrame or LazyFrame.
+
+Use this if your function can accept an object which can be converted to either
+`nw.DataFrame` or `nw.LazyFrame` and it doesn't care about its backend.
+
+Examples:
+    >>> import narwhals as nw
+    >>> from narwhals.typing import IntoFrame
+    >>> def agnostic_columns(df_native: IntoFrame) -> list[str]:
+    ...     df = nw.from_native(df_native)
+    ...     return df.collect_schema().names()
+"""
+
+Frame: TypeAlias = Union["DataFrame[Any]", "LazyFrame[Any]"]
+"""Narwhals DataFrame or Narwhals LazyFrame.
+
+Use this if your function can work with either and your function doesn't care
+about its backend.
+
+Examples:
+    >>> import narwhals as nw
+    >>> from narwhals.typing import Frame
+    >>> @nw.narwhalify
+    ... def agnostic_columns(df: Frame) -> list[str]:
+    ...     return df.columns
+"""
+
+IntoSeries: TypeAlias = Union["Series[Any]", "NativeSeries"]
+"""Anything which can be converted to a Narwhals Series.
+
+Use this if your function can accept an object which can be converted to `nw.Series`
+and it doesn't care about its backend.
+
+Examples:
+    >>> from typing import Any
+    >>> import narwhals as nw
+    >>> from narwhals.typing import IntoSeries
+    >>> def agnostic_to_list(s_native: IntoSeries) -> list[Any]:
+    ...     s = nw.from_native(s_native)
+    ...     return s.to_list()
+"""
+
+IntoFrameT = TypeVar("IntoFrameT", bound="IntoFrame")
+"""TypeVar bound to object convertible to Narwhals DataFrame or Narwhals LazyFrame.
+
+Use this if your function accepts an object which is convertible to `nw.DataFrame`
+or `nw.LazyFrame` and returns an object of the same type.
+
+Examples:
+    >>> import narwhals as nw
+    >>> from narwhals.typing import IntoFrameT
+    >>> def agnostic_func(df_native: IntoFrameT) -> IntoFrameT:
+    ...     df = nw.from_native(df_native)
+    ...     return df.with_columns(c=nw.col("a") + 1).to_native()
+"""
+
+IntoDataFrameT = TypeVar("IntoDataFrameT", bound="IntoDataFrame")
+"""TypeVar bound to object convertible to Narwhals DataFrame.
+
+Use this if your function accepts an object which can be converted to `nw.DataFrame`
+and returns an object of the same class.
+
+Examples:
+    >>> import narwhals as nw
+    >>> from narwhals.typing import IntoDataFrameT
+    >>> def agnostic_func(df_native: IntoDataFrameT) -> IntoDataFrameT:
+    ...     df = nw.from_native(df_native, eager_only=True)
+    ...     return df.with_columns(c=df["a"] + 1).to_native()
+"""
+
+FrameT = TypeVar("FrameT", "DataFrame[Any]", "LazyFrame[Any]")
+"""TypeVar bound to Narwhals DataFrame or Narwhals LazyFrame.
+
+Use this if your function accepts either `nw.DataFrame` or `nw.LazyFrame` and returns
+an object of the same kind.
+
+Examples:
+    >>> import narwhals as nw
+    >>> from narwhals.typing import FrameT
+    >>> @nw.narwhalify
+    ... def agnostic_func(df: FrameT) -> FrameT:
+    ...     return df.with_columns(c=nw.col("a") + 1)
+"""
+
+DataFrameT = TypeVar("DataFrameT", bound="DataFrame[Any]")
+"""TypeVar bound to Narwhals DataFrame.
+
+Use this if your function can accept a Narwhals DataFrame and returns a Narwhals
+DataFrame backed by the same backend.
+
+Examples:
+    >>> import narwhals as nw
+    >>> from narwhals.typing import DataFrameT
+    >>> @nw.narwhalify
+    >>> def func(df: DataFrameT) -> DataFrameT:
+    ...     return df.with_columns(c=df["a"] + 1)
+"""
+
+IntoSeriesT = TypeVar("IntoSeriesT", bound="IntoSeries")
+"""TypeVar bound to object convertible to Narwhals Series.
+
+Use this if your function accepts an object  which can be converted to `nw.Series`
+and returns an object of the same class.
+
+Examples:
+    >>> import narwhals as nw
+    >>> from narwhals.typing import IntoSeriesT
+    >>> def agnostic_abs(s_native: IntoSeriesT) -> IntoSeriesT:
+    ...     s = nw.from_native(s_native, series_only=True)
+    ...     return s.abs().to_native()
+"""
+
+
+__all__ = [
+    "DataFrameT",
+    "Frame",
+    "FrameT",
+    "IntoDataFrame",
+    "IntoDataFrameT",
+    "IntoExpr",
+    "IntoFrame",
+    "IntoFrameT",
+    "IntoSeries",
+    "IntoSeriesT",
+]
diff --git a/lib/python3.10/site-packages/narwhals/stable/v2/__init__.py b/lib/python3.10/site-packages/narwhals/stable/v2/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..93cd912b8a893834c070583ae4fafbe6668e2d7d
--- /dev/null
+++ b/lib/python3.10/site-packages/narwhals/stable/v2/__init__.py
@@ -0,0 +1,1257 @@
+from __future__ import annotations
+
+from functools import wraps
+from typing import TYPE_CHECKING, Any, Callable, Literal, cast, overload
+
+import narwhals as nw
+from narwhals import exceptions, functions as nw_f
+from narwhals._typing_compat import TypeVar, assert_never
+from narwhals._utils import (
+    Implementation,
+    Version,
+    generate_temporary_column_name,
+    inherit_doc,
+    is_ordered_categorical,
+    maybe_align_index,
+    maybe_convert_dtypes,
+    maybe_get_index,
+    maybe_reset_index,
+    maybe_set_index,
+    not_implemented,
+)
+from narwhals.dataframe import DataFrame as NwDataFrame, LazyFrame as NwLazyFrame
+from narwhals.dtypes import (
+    Array,
+    Binary,
+    Boolean,
+    Categorical,
+    Date,
+    Datetime,
+    Decimal,
+    Duration,
+    Enum,
+    Field,
+    Float32,
+    Float64,
+    Int8,
+    Int16,
+    Int32,
+    Int64,
+    Int128,
+    List,
+    Object,
+    String,
+    Struct,
+    Time,
+    UInt8,
+    UInt16,
+    UInt32,
+    UInt64,
+    UInt128,
+    Unknown,
+)
+from narwhals.expr import Expr as NwExpr
+from narwhals.functions import _new_series_impl, concat, show_versions
+from narwhals.schema import Schema as NwSchema
+from narwhals.series import Series as NwSeries
+from narwhals.stable.v2 import dependencies, dtypes, selectors
+from narwhals.translate import _from_native_impl, get_native_namespace, to_py_scalar
+from narwhals.typing import IntoDataFrameT, IntoFrameT
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Mapping, Sequence
+    from types import ModuleType
+
+    from typing_extensions import ParamSpec, Self
+
+    from narwhals._translate import IntoArrowTable
+    from narwhals.dataframe import MultiColSelector, MultiIndexSelector
+    from narwhals.dtypes import DType
+    from narwhals.typing import (
+        IntoDType,
+        IntoExpr,
+        IntoFrame,
+        IntoSeries,
+        NonNestedLiteral,
+        SingleColSelector,
+        SingleIndexSelector,
+        _1DArray,
+        _2DArray,
+    )
+
+    DataFrameT = TypeVar("DataFrameT", bound="DataFrame[Any]")
+    LazyFrameT = TypeVar("LazyFrameT", bound="LazyFrame[Any]")
+    SeriesT = TypeVar("SeriesT", bound="Series[Any]")
+    T = TypeVar("T", default=Any)
+    P = ParamSpec("P")
+    R = TypeVar("R")
+
+IntoSeriesT = TypeVar("IntoSeriesT", bound="IntoSeries", default=Any)
+
+
+class DataFrame(NwDataFrame[IntoDataFrameT]):
+    @inherit_doc(NwDataFrame)
+    def __init__(self, df: Any, *, level: Literal["full", "lazy", "interchange"]) -> None:
+        assert df._version is Version.V2  # noqa: S101
+        super().__init__(df, level=level)
+
+    # We need to override any method which don't return Self so that type
+    # annotations are correct.
+
+    @property
+    def _series(self) -> type[Series[Any]]:
+        return cast("type[Series[Any]]", Series)
+
+    @property
+    def _lazyframe(self) -> type[LazyFrame[Any]]:
+        return cast("type[LazyFrame[Any]]", LazyFrame)
+
+    @overload
+    def __getitem__(self, item: tuple[SingleIndexSelector, SingleColSelector]) -> Any: ...
+
+    @overload
+    def __getitem__(  # type: ignore[overload-overlap]
+        self, item: str | tuple[MultiIndexSelector, SingleColSelector]
+    ) -> Series[Any]: ...
+
+    @overload
+    def __getitem__(
+        self,
+        item: (
+            SingleIndexSelector
+            | MultiIndexSelector
+            | MultiColSelector
+            | tuple[SingleIndexSelector, MultiColSelector]
+            | tuple[MultiIndexSelector, MultiColSelector]
+        ),
+    ) -> Self: ...
+    def __getitem__(
+        self,
+        item: (
+            SingleIndexSelector
+            | SingleColSelector
+            | MultiColSelector
+            | MultiIndexSelector
+            | tuple[SingleIndexSelector, SingleColSelector]
+            | tuple[SingleIndexSelector, MultiColSelector]
+            | tuple[MultiIndexSelector, SingleColSelector]
+            | tuple[MultiIndexSelector, MultiColSelector]
+        ),
+    ) -> Series[Any] | Self | Any:
+        return super().__getitem__(item)
+
+    def get_column(self, name: str) -> Series:
+        # Type checkers complain that `nw.Series` is not assignable to `nw.v2.stable.Series`.
+        # However the return type actually is `nw.v2.stable.Series`, check `tests/v2_test.py`.
+        return super().get_column(name)  # type: ignore[return-value]
+
+    def lazy(
+        self, backend: ModuleType | Implementation | str | None = None
+    ) -> LazyFrame[Any]:
+        return _stableify(super().lazy(backend=backend))
+
+    @overload  # type: ignore[override]
+    def to_dict(self, *, as_series: Literal[True] = ...) -> dict[str, Series[Any]]: ...
+    @overload
+    def to_dict(self, *, as_series: Literal[False]) -> dict[str, list[Any]]: ...
+    @overload
+    def to_dict(
+        self, *, as_series: bool
+    ) -> dict[str, Series[Any]] | dict[str, list[Any]]: ...
+    def to_dict(
+        self, *, as_series: bool = True
+    ) -> dict[str, Series[Any]] | dict[str, list[Any]]:
+        # Type checkers complain that `nw.Series` is not assignable to `nw.v2.stable.Series`.
+        # However the return type actually is `nw.v2.stable.Series`, check `tests/v2_test.py::test_to_dict_as_series`.
+        return super().to_dict(as_series=as_series)  # type: ignore[return-value]
+
+    def is_duplicated(self) -> Series[Any]:
+        return _stableify(super().is_duplicated())
+
+    def is_unique(self) -> Series[Any]:
+        return _stableify(super().is_unique())
+
+
+class LazyFrame(NwLazyFrame[IntoFrameT]):
+    @inherit_doc(NwLazyFrame)
+    def __init__(self, df: Any, *, level: Literal["full", "lazy", "interchange"]) -> None:
+        assert df._version is Version.V2  # noqa: S101
+        super().__init__(df, level=level)
+
+    @property
+    def _dataframe(self) -> type[DataFrame[Any]]:
+        return DataFrame
+
+    def collect(
+        self, backend: ModuleType | Implementation | str | None = None, **kwargs: Any
+    ) -> DataFrame[Any]:
+        return _stableify(super().collect(backend=backend, **kwargs))
+
+
+class Series(NwSeries[IntoSeriesT]):
+    @inherit_doc(NwSeries)
+    def __init__(
+        self, series: Any, *, level: Literal["full", "lazy", "interchange"]
+    ) -> None:
+        assert series._version is Version.V2  # noqa: S101
+        super().__init__(series, level=level)
+
+    # We need to override any method which don't return Self so that type
+    # annotations are correct.
+
+    @property
+    def _dataframe(self) -> type[DataFrame[Any]]:
+        return DataFrame
+
+    def to_frame(self) -> DataFrame[Any]:
+        return _stableify(super().to_frame())
+
+    def value_counts(
+        self,
+        *,
+        sort: bool = False,
+        parallel: bool = False,
+        name: str | None = None,
+        normalize: bool = False,
+    ) -> DataFrame[Any]:
+        return _stableify(
+            super().value_counts(
+                sort=sort, parallel=parallel, name=name, normalize=normalize
+            )
+        )
+
+    # Too unstable to consider including here.
+    hist: Any = not_implemented()
+
+
+class Expr(NwExpr): ...
+
+
+class Schema(NwSchema):
+    _version = Version.V2
+
+    @inherit_doc(NwSchema)
+    def __init__(
+        self, schema: Mapping[str, DType] | Iterable[tuple[str, DType]] | None = None
+    ) -> None:
+        super().__init__(schema)
+
+
+@overload
+def _stableify(obj: NwDataFrame[IntoFrameT]) -> DataFrame[IntoFrameT]: ...
+@overload
+def _stableify(obj: NwLazyFrame[IntoFrameT]) -> LazyFrame[IntoFrameT]: ...
+@overload
+def _stableify(obj: NwSeries[IntoSeriesT]) -> Series[IntoSeriesT]: ...
+@overload
+def _stableify(obj: NwExpr) -> Expr: ...
+
+
+def _stableify(
+    obj: NwDataFrame[IntoFrameT]
+    | NwLazyFrame[IntoFrameT]
+    | NwSeries[IntoSeriesT]
+    | NwExpr,
+) -> DataFrame[IntoFrameT] | LazyFrame[IntoFrameT] | Series[IntoSeriesT] | Expr:
+    if isinstance(obj, NwDataFrame):
+        return DataFrame(obj._compliant_frame._with_version(Version.V2), level=obj._level)
+    if isinstance(obj, NwLazyFrame):
+        return LazyFrame(obj._compliant_frame._with_version(Version.V2), level=obj._level)
+    if isinstance(obj, NwSeries):
+        return Series(obj._compliant_series._with_version(Version.V2), level=obj._level)
+    if isinstance(obj, NwExpr):
+        return Expr(obj._to_compliant_expr, obj._metadata)
+    assert_never(obj)
+
+
+@overload
+def from_native(native_object: SeriesT, **kwds: Any) -> SeriesT: ...
+
+
+@overload
+def from_native(native_object: DataFrameT, **kwds: Any) -> DataFrameT: ...
+
+
+@overload
+def from_native(native_object: LazyFrameT, **kwds: Any) -> LazyFrameT: ...
+
+
+@overload
+def from_native(
+    native_object: DataFrameT | LazyFrameT, **kwds: Any
+) -> DataFrameT | LazyFrameT: ...
+
+
+@overload
+def from_native(
+    native_object: IntoDataFrameT | IntoSeries,
+    *,
+    pass_through: Literal[True],
+    eager_only: Literal[False] = ...,
+    series_only: Literal[False] = ...,
+    allow_series: Literal[True],
+) -> DataFrame[IntoDataFrameT]: ...
+
+
+@overload
+def from_native(
+    native_object: IntoDataFrameT | IntoSeriesT,
+    *,
+    pass_through: Literal[True],
+    eager_only: Literal[True],
+    series_only: Literal[False] = ...,
+    allow_series: Literal[True],
+) -> DataFrame[IntoDataFrameT] | Series[IntoSeriesT]: ...
+
+
+@overload
+def from_native(
+    native_object: IntoDataFrameT,
+    *,
+    pass_through: Literal[True],
+    eager_only: Literal[False] = ...,
+    series_only: Literal[False] = ...,
+    allow_series: None = ...,
+) -> DataFrame[IntoDataFrameT]: ...
+
+
+@overload
+def from_native(
+    native_object: T,
+    *,
+    pass_through: Literal[True],
+    eager_only: Literal[False] = ...,
+    series_only: Literal[False] = ...,
+    allow_series: None = ...,
+) -> T: ...
+
+
+@overload
+def from_native(
+    native_object: IntoDataFrameT,
+    *,
+    pass_through: Literal[True],
+    eager_only: Literal[True],
+    series_only: Literal[False] = ...,
+    allow_series: None = ...,
+) -> DataFrame[IntoDataFrameT]: ...
+
+
+@overload
+def from_native(
+    native_object: T,
+    *,
+    pass_through: Literal[True],
+    eager_only: Literal[True],
+    series_only: Literal[False] = ...,
+    allow_series: None = ...,
+) -> T: ...
+
+
+@overload
+def from_native(
+    native_object: IntoSeriesT,
+    *,
+    pass_through: Literal[True],
+    eager_only: Literal[False] = ...,
+    series_only: Literal[True],
+    allow_series: None = ...,
+) -> Series[IntoSeriesT]: ...
+
+
+@overload
+def from_native(
+    native_object: IntoDataFrameT,
+    *,
+    pass_through: Literal[False] = ...,
+    eager_only: Literal[False] = ...,
+    series_only: Literal[False] = ...,
+    allow_series: None = ...,
+) -> DataFrame[IntoDataFrameT]: ...
+
+
+@overload
+def from_native(
+    native_object: IntoDataFrameT,
+    *,
+    pass_through: Literal[False] = ...,
+    eager_only: Literal[True],
+    series_only: Literal[False] = ...,
+    allow_series: None = ...,
+) -> DataFrame[IntoDataFrameT]: ...
+
+
+@overload
+def from_native(
+    native_object: IntoFrame | IntoSeries,
+    *,
+    pass_through: Literal[False] = ...,
+    eager_only: Literal[False] = ...,
+    series_only: Literal[False] = ...,
+    allow_series: Literal[True],
+) -> DataFrame[Any] | LazyFrame[Any] | Series[Any]: ...
+
+
+@overload
+def from_native(
+    native_object: IntoSeriesT,
+    *,
+    pass_through: Literal[False] = ...,
+    eager_only: Literal[False] = ...,
+    series_only: Literal[True],
+    allow_series: None = ...,
+) -> Series[IntoSeriesT]: ...
+
+
+# All params passed in as variables
+@overload
+def from_native(
+    native_object: Any,
+    *,
+    pass_through: bool,
+    eager_only: bool,
+    series_only: bool,
+    allow_series: bool | None,
+) -> Any: ...
+
+
+def from_native(  # noqa: D417
+    native_object: IntoFrameT | IntoFrame | IntoSeriesT | IntoSeries | T,
+    *,
+    pass_through: bool = False,
+    eager_only: bool = False,
+    series_only: bool = False,
+    allow_series: bool | None = None,
+    **kwds: Any,
+) -> LazyFrame[IntoFrameT] | DataFrame[IntoFrameT] | Series[IntoSeriesT] | T:
+    """Convert `native_object` to Narwhals Dataframe, Lazyframe, or Series.
+
+    Arguments:
+        native_object: Raw object from user.
+            Depending on the other arguments, input object can be
+
+            - a Dataframe / Lazyframe / Series supported by Narwhals (pandas, Polars, PyArrow, ...)
+            - an object which implements `__narwhals_dataframe__`, `__narwhals_lazyframe__`,
+              or `__narwhals_series__`
+        pass_through: Determine what happens if the object can't be converted to Narwhals
+
+            - `False` (default): raise an error
+            - `True`: pass object through as-is
+        eager_only: Whether to only allow eager objects
+
+            - `False` (default): don't require `native_object` to be eager
+            - `True`: only convert to Narwhals if `native_object` is eager
+        series_only: Whether to only allow Series
+
+            - `False` (default): don't require `native_object` to be a Series
+            - `True`: only convert to Narwhals if `native_object` is a Series
+        allow_series: Whether to allow Series (default is only Dataframe / Lazyframe)
+
+            - `False` or `None` (default): don't convert to Narwhals if `native_object` is a Series
+            - `True`: allow `native_object` to be a Series
+
+    Returns:
+        DataFrame, LazyFrame, Series, or original object, depending
+            on which combination of parameters was passed.
+    """
+    # Early returns
+    if isinstance(native_object, (DataFrame, LazyFrame)) and not series_only:
+        return native_object
+    if isinstance(native_object, Series) and (series_only or allow_series):
+        return native_object
+
+    if kwds:
+        msg = f"from_native() got an unexpected keyword argument {next(iter(kwds))!r}"
+        raise TypeError(msg)
+
+    return _from_native_impl(  # type: ignore[no-any-return]
+        native_object,
+        pass_through=pass_through,
+        eager_only=eager_only,
+        series_only=series_only,
+        allow_series=allow_series,
+        version=Version.V2,
+    )
+
+
+@overload
+def to_native(
+    narwhals_object: DataFrame[IntoDataFrameT], *, pass_through: Literal[False] = ...
+) -> IntoDataFrameT: ...
+@overload
+def to_native(
+    narwhals_object: LazyFrame[IntoFrameT], *, pass_through: Literal[False] = ...
+) -> IntoFrameT: ...
+@overload
+def to_native(
+    narwhals_object: Series[IntoSeriesT], *, pass_through: Literal[False] = ...
+) -> IntoSeriesT: ...
+@overload
+def to_native(narwhals_object: Any, *, pass_through: bool) -> Any: ...
+
+
+def to_native(
+    narwhals_object: DataFrame[IntoDataFrameT]
+    | LazyFrame[IntoFrameT]
+    | Series[IntoSeriesT],
+    *,
+    pass_through: bool = False,
+) -> IntoFrameT | IntoSeriesT | Any:
+    """Convert Narwhals object to native one.
+
+    Arguments:
+        narwhals_object: Narwhals object.
+        pass_through: Determine what happens if `narwhals_object` isn't a Narwhals class
+
+            - `False` (default): raise an error
+            - `True`: pass object through as-is
+
+    Returns:
+        Object of class that user started with.
+    """
+    return nw.to_native(narwhals_object, pass_through=pass_through)
+
+
+def narwhalify(
+    func: Callable[..., Any] | None = None,
+    *,
+    pass_through: bool = True,
+    eager_only: bool = False,
+    series_only: bool = False,
+    allow_series: bool | None = True,
+) -> Callable[..., Any]:
+    """Decorate function so it becomes dataframe-agnostic.
+
+    This will try to convert any dataframe/series-like object into the Narwhals
+    respective DataFrame/Series, while leaving the other parameters as they are.
+    Similarly, if the output of the function is a Narwhals DataFrame or Series, it will be
+    converted back to the original dataframe/series type, while if the output is another
+    type it will be left as is.
+    By setting `pass_through=False`, then every input and every output will be required to be a
+    dataframe/series-like object.
+
+    Arguments:
+        func: Function to wrap in a `from_native`-`to_native` block.
+        pass_through: Determine what happens if the object can't be converted to Narwhals
+
+            - `False`: raise an error
+            - `True` (default): pass object through as-is
+        eager_only: Whether to only allow eager objects
+
+            - `False` (default): don't require `native_object` to be eager
+            - `True`: only convert to Narwhals if `native_object` is eager
+        series_only: Whether to only allow Series
+
+            - `False` (default): don't require `native_object` to be a Series
+            - `True`: only convert to Narwhals if `native_object` is a Series
+        allow_series: Whether to allow Series (default is only Dataframe / Lazyframe)
+
+            - `False` or `None`: don't convert to Narwhals if `native_object` is a Series
+            - `True` (default): allow `native_object` to be a Series
+
+    Returns:
+        Decorated function.
+    """
+
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            args = [
+                from_native(
+                    arg,
+                    pass_through=pass_through,
+                    eager_only=eager_only,
+                    series_only=series_only,
+                    allow_series=allow_series,
+                )
+                for arg in args
+            ]  # type: ignore[assignment]
+
+            kwargs = {
+                name: from_native(
+                    value,
+                    pass_through=pass_through,
+                    eager_only=eager_only,
+                    series_only=series_only,
+                    allow_series=allow_series,
+                )
+                for name, value in kwargs.items()
+            }
+
+            backends = {
+                b()
+                for v in (*args, *kwargs.values())
+                if (b := getattr(v, "__native_namespace__", None))
+            }
+
+            if backends.__len__() > 1:
+                msg = "Found multiple backends. Make sure that all dataframe/series inputs come from the same backend."
+                raise ValueError(msg)
+
+            result = func(*args, **kwargs)
+
+            return to_native(result, pass_through=pass_through)
+
+        return wrapper
+
+    if func is None:
+        return decorator
+    else:
+        # If func is not None, it means the decorator is used without arguments
+        return decorator(func)
+
+
+def all() -> Expr:
+    """Instantiate an expression representing all columns.
+
+    Returns:
+        A new expression.
+    """
+    return _stableify(nw.all())
+
+
+def col(*names: str | Iterable[str]) -> Expr:
+    """Creates an expression that references one or more columns by their name(s).
+
+    Arguments:
+        names: Name(s) of the columns to use.
+
+    Returns:
+        A new expression.
+    """
+    return _stableify(nw.col(*names))
+
+
+def exclude(*names: str | Iterable[str]) -> Expr:
+    """Creates an expression that excludes columns by their name(s).
+
+    Arguments:
+        names: Name(s) of the columns to exclude.
+
+    Returns:
+        A new expression.
+    """
+    return _stableify(nw.exclude(*names))
+
+
+def nth(*indices: int | Sequence[int]) -> Expr:
+    """Creates an expression that references one or more columns by their index(es).
+
+    Notes:
+        `nth` is not supported for Polars version<1.0.0. Please use
+        [`narwhals.col`][] instead.
+
+    Arguments:
+        indices: One or more indices representing the columns to retrieve.
+
+    Returns:
+        A new expression.
+    """
+    return _stableify(nw.nth(*indices))
+
+
+def len() -> Expr:
+    """Return the number of rows.
+
+    Returns:
+        A new expression.
+    """
+    return _stableify(nw.len())
+
+
+def lit(value: NonNestedLiteral, dtype: IntoDType | None = None) -> Expr:
+    """Return an expression representing a literal value.
+
+    Arguments:
+        value: The value to use as literal.
+        dtype: The data type of the literal value. If not provided, the data type will
+            be inferred by the native library.
+
+    Returns:
+        A new expression.
+    """
+    return _stableify(nw.lit(value, dtype))
+
+
+def min(*columns: str) -> Expr:
+    """Return the minimum value.
+
+    Note:
+       Syntactic sugar for ``nw.col(columns).min()``.
+
+    Arguments:
+        columns: Name(s) of the columns to use in the aggregation function.
+
+    Returns:
+        A new expression.
+    """
+    return _stableify(nw.min(*columns))
+
+
+def max(*columns: str) -> Expr:
+    """Return the maximum value.
+
+    Note:
+       Syntactic sugar for ``nw.col(columns).max()``.
+
+    Arguments:
+        columns: Name(s) of the columns to use in the aggregation function.
+
+    Returns:
+        A new expression.
+    """
+    return _stableify(nw.max(*columns))
+
+
+def mean(*columns: str) -> Expr:
+    """Get the mean value.
+
+    Note:
+        Syntactic sugar for ``nw.col(columns).mean()``
+
+    Arguments:
+        columns: Name(s) of the columns to use in the aggregation function
+
+    Returns:
+        A new expression.
+    """
+    return _stableify(nw.mean(*columns))
+
+
+def median(*columns: str) -> Expr:
+    """Get the median value.
+
+    Notes:
+        - Syntactic sugar for ``nw.col(columns).median()``
+        - Results might slightly differ across backends due to differences in the
+            underlying algorithms used to compute the median.
+
+    Arguments:
+        columns: Name(s) of the columns to use in the aggregation function
+
+    Returns:
+        A new expression.
+    """
+    return _stableify(nw.median(*columns))
+
+
+def sum(*columns: str) -> Expr:
+    """Sum all values.
+
+    Note:
+        Syntactic sugar for ``nw.col(columns).sum()``
+
+    Arguments:
+        columns: Name(s) of the columns to use in the aggregation function
+
+    Returns:
+        A new expression.
+    """
+    return _stableify(nw.sum(*columns))
+
+
+def sum_horizontal(*exprs: IntoExpr | Iterable[IntoExpr]) -> Expr:
+    """Sum all values horizontally across columns.
+
+    Warning:
+        Unlike Polars, we support horizontal sum over numeric columns only.
+
+    Arguments:
+        exprs: Name(s) of the columns to use in the aggregation function. Accepts
+            expression input.
+
+    Returns:
+        A new expression.
+    """
+    return _stableify(nw.sum_horizontal(*exprs))
+
+
+def all_horizontal(*exprs: IntoExpr | Iterable[IntoExpr], ignore_nulls: bool) -> Expr:
+    r"""Compute the bitwise AND horizontally across columns.
+
+    Arguments:
+        exprs: Name(s) of the columns to use in the aggregation function. Accepts
+            expression input.
+        ignore_nulls: Whether to ignore nulls:
+
+            - If `True`, null values are ignored. If there are no elements, the result
+              is `True`.
+            - If `False`, Kleene logic is followed. Note that this is not allowed for
+              pandas with classical NumPy dtypes when null values are present.
+
+    Returns:
+        A new expression.
+    """
+    return _stableify(nw.all_horizontal(*exprs, ignore_nulls=ignore_nulls))
+
+
+def any_horizontal(*exprs: IntoExpr | Iterable[IntoExpr], ignore_nulls: bool) -> Expr:
+    r"""Compute the bitwise OR horizontally across columns.
+
+    Arguments:
+        exprs: Name(s) of the columns to use in the aggregation function. Accepts
+            expression input.
+        ignore_nulls: Whether to ignore nulls:
+
+            - If `True`, null values are ignored. If there are no elements, the result
+              is `False`.
+            - If `False`, Kleene logic is followed. Note that this is not allowed for
+              pandas with classical NumPy dtypes when null values are present.
+
+    Returns:
+        A new expression.
+    """
+    return _stableify(nw.any_horizontal(*exprs, ignore_nulls=ignore_nulls))
+
+
+def mean_horizontal(*exprs: IntoExpr | Iterable[IntoExpr]) -> Expr:
+    """Compute the mean of all values horizontally across columns.
+
+    Arguments:
+        exprs: Name(s) of the columns to use in the aggregation function. Accepts
+            expression input.
+
+    Returns:
+        A new expression.
+    """
+    return _stableify(nw.mean_horizontal(*exprs))
+
+
+def min_horizontal(*exprs: IntoExpr | Iterable[IntoExpr]) -> Expr:
+    """Get the minimum value horizontally across columns.
+
+    Notes:
+        We support `min_horizontal` over numeric columns only.
+
+    Arguments:
+        exprs: Name(s) of the columns to use in the aggregation function. Accepts
+            expression input.
+
+    Returns:
+        A new expression.
+    """
+    return _stableify(nw.min_horizontal(*exprs))
+
+
+def max_horizontal(*exprs: IntoExpr | Iterable[IntoExpr]) -> Expr:
+    """Get the maximum value horizontally across columns.
+
+    Notes:
+        We support `max_horizontal` over numeric columns only.
+
+    Arguments:
+        exprs: Name(s) of the columns to use in the aggregation function. Accepts
+            expression input.
+
+    Returns:
+        A new expression.
+    """
+    return _stableify(nw.max_horizontal(*exprs))
+
+
+def concat_str(
+    exprs: IntoExpr | Iterable[IntoExpr],
+    *more_exprs: IntoExpr,
+    separator: str = "",
+    ignore_nulls: bool = False,
+) -> Expr:
+    r"""Horizontally concatenate columns into a single string column.
+
+    Arguments:
+        exprs: Columns to concatenate into a single string column. Accepts expression
+            input. Strings are parsed as column names, other non-expression inputs are
+            parsed as literals. Non-`String` columns are cast to `String`.
+        *more_exprs: Additional columns to concatenate into a single string column,
+            specified as positional arguments.
+        separator: String that will be used to separate the values of each column.
+        ignore_nulls: Ignore null values (default is `False`).
+            If set to `False`, null values will be propagated and if the row contains any
+            null values, the output is null.
+
+    Returns:
+        A new expression.
+    """
+    return _stableify(
+        nw.concat_str(exprs, *more_exprs, separator=separator, ignore_nulls=ignore_nulls)
+    )
+
+
+def coalesce(exprs: IntoExpr | Iterable[IntoExpr], *more_exprs: IntoExpr) -> Expr:
+    """Folds the columns from left to right, keeping the first non-null value.
+
+    Arguments:
+        exprs: Columns to coalesce, must be a str, nw.Expr, or nw.Series
+            where strings are parsed as column names and both nw.Expr/nw.Series
+            are passed through as-is. Scalar values must be wrapped in `nw.lit`.
+
+        *more_exprs: Additional columns to coalesce, specified as positional arguments.
+
+    Raises:
+        TypeError: If any of the inputs are not a str, nw.Expr, or nw.Series.
+
+    Returns:
+        A new expression.
+    """
+    return _stableify(nw.coalesce(exprs, *more_exprs))
+
+
+class When(nw_f.When):
+    @classmethod
+    def from_when(cls, when: nw_f.When) -> When:
+        return cls(when._predicate)
+
+    def then(self, value: IntoExpr | NonNestedLiteral | _1DArray) -> Then:
+        return Then.from_then(super().then(value))
+
+
+class Then(nw_f.Then, Expr):
+    @classmethod
+    def from_then(cls, then: nw_f.Then) -> Then:
+        return cls(then._to_compliant_expr, then._metadata)
+
+    def otherwise(self, value: IntoExpr | NonNestedLiteral | _1DArray) -> Expr:
+        return _stableify(super().otherwise(value))
+
+
+def when(*predicates: IntoExpr | Iterable[IntoExpr]) -> When:
+    """Start a `when-then-otherwise` expression.
+
+    Expression similar to an `if-else` statement in Python. Always initiated by a
+    `pl.when(<condition>).then(<value if condition>)`, and optionally followed by a
+    `.otherwise(<value if condition is false>)` can be appended at the end. If not
+    appended, and the condition is not `True`, `None` will be returned.
+
+    Info:
+        Chaining multiple `.when(<condition>).then(<value>)` statements is currently
+        not supported.
+        See [Narwhals#668](https://github.com/narwhals-dev/narwhals/issues/668).
+
+    Arguments:
+        predicates: Condition(s) that must be met in order to apply the subsequent
+            statement. Accepts one or more boolean expressions, which are implicitly
+            combined with `&`. String input is parsed as a column name.
+
+    Returns:
+        A "when" object, which `.then` can be called on.
+    """
+    return When.from_when(nw_f.when(*predicates))
+
+
+def new_series(
+    name: str,
+    values: Any,
+    dtype: IntoDType | None = None,
+    *,
+    backend: ModuleType | Implementation | str,
+) -> Series[Any]:
+    """Instantiate Narwhals Series from iterable (e.g. list or array).
+
+    Arguments:
+        name: Name of resulting Series.
+        values: Values of make Series from.
+        dtype: (Narwhals) dtype. If not provided, the native library
+            may auto-infer it from `values`.
+        backend: specifies which eager backend instantiate to.
+
+            `backend` can be specified in various ways
+
+            - As `Implementation.<BACKEND>` with `BACKEND` being `PANDAS`, `PYARROW`,
+                `POLARS`, `MODIN` or `CUDF`.
+            - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"` or `"cudf"`.
+            - Directly as a module `pandas`, `pyarrow`, `polars`, `modin` or `cudf`.
+
+    Returns:
+        A new Series
+    """
+    return _stableify(_new_series_impl(name, values, dtype, backend=backend))
+
+
+def from_arrow(
+    native_frame: IntoArrowTable, *, backend: ModuleType | Implementation | str
+) -> DataFrame[Any]:
+    """Construct a DataFrame from an object which supports the PyCapsule Interface.
+
+    Arguments:
+        native_frame: Object which implements `__arrow_c_stream__`.
+        backend: specifies which eager backend instantiate to.
+
+            `backend` can be specified in various ways
+
+            - As `Implementation.<BACKEND>` with `BACKEND` being `PANDAS`, `PYARROW`,
+                `POLARS`, `MODIN` or `CUDF`.
+            - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"` or `"cudf"`.
+            - Directly as a module `pandas`, `pyarrow`, `polars`, `modin` or `cudf`.
+
+    Returns:
+        A new DataFrame.
+    """
+    return _stableify(nw_f.from_arrow(native_frame, backend=backend))
+
+
+def from_dict(
+    data: Mapping[str, Any],
+    schema: Mapping[str, DType] | Schema | None = None,
+    *,
+    backend: ModuleType | Implementation | str | None = None,
+) -> DataFrame[Any]:
+    """Instantiate DataFrame from dictionary.
+
+    Indexes (if present, for pandas-like backends) are aligned following
+    the [left-hand-rule](../concepts/pandas_index.md/).
+
+    Notes:
+        For pandas-like dataframes, conversion to schema is applied after dataframe
+        creation.
+
+    Arguments:
+        data: Dictionary to create DataFrame from.
+        schema: The DataFrame schema as Schema or dict of {name: type}. If not
+            specified, the schema will be inferred by the native library.
+        backend: specifies which eager backend instantiate to. Only
+            necessary if inputs are not Narwhals Series.
+
+            `backend` can be specified in various ways
+
+            - As `Implementation.<BACKEND>` with `BACKEND` being `PANDAS`, `PYARROW`,
+                `POLARS`, `MODIN` or `CUDF`.
+            - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"` or `"cudf"`.
+            - Directly as a module `pandas`, `pyarrow`, `polars`, `modin` or `cudf`.
+
+    Returns:
+        A new DataFrame.
+    """
+    return _stableify(nw_f.from_dict(data, schema, backend=backend))
+
+
+def from_numpy(
+    data: _2DArray,
+    schema: Mapping[str, DType] | Schema | Sequence[str] | None = None,
+    *,
+    backend: ModuleType | Implementation | str,
+) -> DataFrame[Any]:
+    """Construct a DataFrame from a NumPy ndarray.
+
+    Notes:
+        Only row orientation is currently supported.
+
+        For pandas-like dataframes, conversion to schema is applied after dataframe
+        creation.
+
+    Arguments:
+        data: Two-dimensional data represented as a NumPy ndarray.
+        schema: The DataFrame schema as Schema, dict of {name: type}, or a sequence of str.
+        backend: specifies which eager backend instantiate to.
+
+            `backend` can be specified in various ways
+
+            - As `Implementation.<BACKEND>` with `BACKEND` being `PANDAS`, `PYARROW`,
+                `POLARS`, `MODIN` or `CUDF`.
+            - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"` or `"cudf"`.
+            - Directly as a module `pandas`, `pyarrow`, `polars`, `modin` or `cudf`.
+
+    Returns:
+        A new DataFrame.
+    """
+    return _stableify(nw_f.from_numpy(data, schema, backend=backend))
+
+
+def read_csv(
+    source: str, *, backend: ModuleType | Implementation | str, **kwargs: Any
+) -> DataFrame[Any]:
+    """Read a CSV file into a DataFrame.
+
+    Arguments:
+        source: Path to a file.
+        backend: The eager backend for DataFrame creation.
+            `backend` can be specified in various ways
+
+            - As `Implementation.<BACKEND>` with `BACKEND` being `PANDAS`, `PYARROW`,
+                `POLARS`, `MODIN` or `CUDF`.
+            - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"` or `"cudf"`.
+            - Directly as a module `pandas`, `pyarrow`, `polars`, `modin` or `cudf`.
+        kwargs: Extra keyword arguments which are passed to the native CSV reader.
+            For example, you could use
+            `nw.read_csv('file.csv', backend='pandas', engine='pyarrow')`.
+
+    Returns:
+        DataFrame.
+    """
+    return _stableify(nw_f.read_csv(source, backend=backend, **kwargs))
+
+
+def scan_csv(
+    source: str, *, backend: ModuleType | Implementation | str, **kwargs: Any
+) -> LazyFrame[Any]:
+    """Lazily read from a CSV file.
+
+    For the libraries that do not support lazy dataframes, the function reads
+    a csv file eagerly and then converts the resulting dataframe to a lazyframe.
+
+    Arguments:
+        source: Path to a file.
+        backend: The eager backend for DataFrame creation.
+            `backend` can be specified in various ways
+
+            - As `Implementation.<BACKEND>` with `BACKEND` being `PANDAS`, `PYARROW`,
+                `POLARS`, `MODIN` or `CUDF`.
+            - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"` or `"cudf"`.
+            - Directly as a module `pandas`, `pyarrow`, `polars`, `modin` or `cudf`.
+        kwargs: Extra keyword arguments which are passed to the native CSV reader.
+            For example, you could use
+            `nw.scan_csv('file.csv', backend=pd, engine='pyarrow')`.
+
+    Returns:
+        LazyFrame.
+    """
+    return _stableify(nw_f.scan_csv(source, backend=backend, **kwargs))
+
+
+def read_parquet(
+    source: str, *, backend: ModuleType | Implementation | str, **kwargs: Any
+) -> DataFrame[Any]:
+    """Read into a DataFrame from a parquet file.
+
+    Arguments:
+        source: Path to a file.
+        backend: The eager backend for DataFrame creation.
+            `backend` can be specified in various ways
+
+            - As `Implementation.<BACKEND>` with `BACKEND` being `PANDAS`, `PYARROW`,
+                `POLARS`, `MODIN` or `CUDF`.
+            - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"` or `"cudf"`.
+            - Directly as a module `pandas`, `pyarrow`, `polars`, `modin` or `cudf`.
+        kwargs: Extra keyword arguments which are passed to the native parquet reader.
+            For example, you could use
+            `nw.read_parquet('file.parquet', backend=pd, engine='pyarrow')`.
+
+    Returns:
+        DataFrame.
+    """
+    return _stableify(nw_f.read_parquet(source, backend=backend, **kwargs))
+
+
+def scan_parquet(
+    source: str, *, backend: ModuleType | Implementation | str, **kwargs: Any
+) -> LazyFrame[Any]:
+    """Lazily read from a parquet file.
+
+    For the libraries that do not support lazy dataframes, the function reads
+    a parquet file eagerly and then converts the resulting dataframe to a lazyframe.
+
+    Note:
+        Spark like backends require a session object to be passed in `kwargs`.
+
+        For instance:
+
+        ```py
+        import narwhals as nw
+        from sqlframe.duckdb import DuckDBSession
+
+        nw.scan_parquet(source, backend="sqlframe", session=DuckDBSession())
+        ```
+
+    Arguments:
+        source: Path to a file.
+        backend: The eager backend for DataFrame creation.
+            `backend` can be specified in various ways
+
+            - As `Implementation.<BACKEND>` with `BACKEND` being `PANDAS`, `PYARROW`,
+                `POLARS`, `MODIN`, `CUDF`, `PYSPARK` or `SQLFRAME`.
+            - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"`, `"cudf"`,
+                `"pyspark"` or `"sqlframe"`.
+            - Directly as a module `pandas`, `pyarrow`, `polars`, `modin`, `cudf`,
+                `pyspark.sql` or `sqlframe`.
+        kwargs: Extra keyword arguments which are passed to the native parquet reader.
+            For example, you could use
+            `nw.scan_parquet('file.parquet', backend=pd, engine='pyarrow')`.
+
+    Returns:
+        LazyFrame.
+    """
+    return _stableify(nw_f.scan_parquet(source, backend=backend, **kwargs))
+
+
+__all__ = [
+    "Array",
+    "Binary",
+    "Boolean",
+    "Categorical",
+    "DataFrame",
+    "Date",
+    "Datetime",
+    "Decimal",
+    "Duration",
+    "Enum",
+    "Expr",
+    "Field",
+    "Float32",
+    "Float64",
+    "Implementation",
+    "Int8",
+    "Int16",
+    "Int32",
+    "Int64",
+    "Int128",
+    "LazyFrame",
+    "List",
+    "Object",
+    "Schema",
+    "Series",
+    "String",
+    "Struct",
+    "Time",
+    "UInt8",
+    "UInt16",
+    "UInt32",
+    "UInt64",
+    "UInt128",
+    "Unknown",
+    "all",
+    "all_horizontal",
+    "any_horizontal",
+    "coalesce",
+    "col",
+    "concat",
+    "concat_str",
+    "dependencies",
+    "dtypes",
+    "dtypes",
+    "exceptions",
+    "exclude",
+    "from_arrow",
+    "from_dict",
+    "from_native",
+    "from_numpy",
+    "generate_temporary_column_name",
+    "get_native_namespace",
+    "is_ordered_categorical",
+    "len",
+    "lit",
+    "max",
+    "max_horizontal",
+    "maybe_align_index",
+    "maybe_convert_dtypes",
+    "maybe_get_index",
+    "maybe_reset_index",
+    "maybe_set_index",
+    "mean",
+    "mean_horizontal",
+    "median",
+    "min",
+    "min_horizontal",
+    "narwhalify",
+    "new_series",
+    "nth",
+    "read_csv",
+    "read_parquet",
+    "scan_csv",
+    "scan_parquet",
+    "selectors",
+    "selectors",
+    "show_versions",
+    "sum",
+    "sum_horizontal",
+    "to_native",
+    "to_py_scalar",
+    "when",
+]
diff --git a/lib/python3.10/site-packages/narwhals/stable/v2/__pycache__/__init__.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/stable/v2/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3ac796b5e878e66d8c9b5b1ff9597d5651f169af
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/stable/v2/__pycache__/__init__.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/stable/v2/__pycache__/_namespace.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/stable/v2/__pycache__/_namespace.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b9023b91dde28273f76125ac5c5a33bbe3272711
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/stable/v2/__pycache__/_namespace.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/stable/v2/__pycache__/dependencies.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/stable/v2/__pycache__/dependencies.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..12ff722f0d6dfcfdfaadae8ea051878befe2fd44
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/stable/v2/__pycache__/dependencies.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/stable/v2/__pycache__/dtypes.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/stable/v2/__pycache__/dtypes.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dd494216ed2e9a2037029336aaeb596ff7ccd569
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/stable/v2/__pycache__/dtypes.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/stable/v2/__pycache__/selectors.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/stable/v2/__pycache__/selectors.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..551a9fec5bac7ea809e0f9fa62eaff3f4fb647c3
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/stable/v2/__pycache__/selectors.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/stable/v2/__pycache__/typing.cpython-310.pyc b/lib/python3.10/site-packages/narwhals/stable/v2/__pycache__/typing.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ac73ce2f494be808a1098971bfe1879e031f3eb3
Binary files /dev/null and b/lib/python3.10/site-packages/narwhals/stable/v2/__pycache__/typing.cpython-310.pyc differ
diff --git a/lib/python3.10/site-packages/narwhals/stable/v2/_namespace.py b/lib/python3.10/site-packages/narwhals/stable/v2/_namespace.py
new file mode 100644
index 0000000000000000000000000000000000000000..b30093cc6c339729b5d6f49b46515e1b1525c3f8
--- /dev/null
+++ b/lib/python3.10/site-packages/narwhals/stable/v2/_namespace.py
@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from narwhals._compliant.typing import CompliantNamespaceT_co
+from narwhals._namespace import Namespace as NwNamespace
+from narwhals._utils import Version
+
+__all__ = ["Namespace"]
+
+
+class Namespace(NwNamespace[CompliantNamespaceT_co], version=Version.V2): ...
diff --git a/lib/python3.10/site-packages/narwhals/stable/v2/dependencies.py b/lib/python3.10/site-packages/narwhals/stable/v2/dependencies.py
new file mode 100644
index 0000000000000000000000000000000000000000..09dac9689283f5d30c56ad71bfadbba8cc811103
--- /dev/null
+++ b/lib/python3.10/site-packages/narwhals/stable/v2/dependencies.py
@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+from narwhals.dependencies import *  # noqa: F403
diff --git a/lib/python3.10/site-packages/narwhals/stable/v2/dtypes.py b/lib/python3.10/site-packages/narwhals/stable/v2/dtypes.py
new file mode 100644
index 0000000000000000000000000000000000000000..b2d9cb0a21f6a1c0cb469b9aebc188cb844f171f
--- /dev/null
+++ b/lib/python3.10/site-packages/narwhals/stable/v2/dtypes.py
@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+from narwhals.dtypes import *  # noqa: F403
diff --git a/lib/python3.10/site-packages/narwhals/stable/v2/selectors.py b/lib/python3.10/site-packages/narwhals/stable/v2/selectors.py
new file mode 100644
index 0000000000000000000000000000000000000000..79089a2761adc27d790f6cc108255875189591be
--- /dev/null
+++ b/lib/python3.10/site-packages/narwhals/stable/v2/selectors.py
@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+from narwhals.selectors import *  # noqa: F403
diff --git a/lib/python3.10/site-packages/narwhals/stable/v2/typing.py b/lib/python3.10/site-packages/narwhals/stable/v2/typing.py
new file mode 100644
index 0000000000000000000000000000000000000000..16d42804c2263ea659adb58dd28d2f1c53fb37c9
--- /dev/null
+++ b/lib/python3.10/site-packages/narwhals/stable/v2/typing.py
@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Protocol, TypeVar, Union
+
+if TYPE_CHECKING:
+    import sys
+
+    from narwhals.stable.v2 import DataFrame, LazyFrame
+
+    if sys.version_info >= (3, 10):
+        from typing import TypeAlias
+    else:
+        from typing_extensions import TypeAlias
+
+    from narwhals.stable.v2 import Expr, Series
+
+    # All dataframes supported by Narwhals have a
+    # `columns` property. Their similarities don't extend
+    # _that_ much further unfortunately...
+    class NativeFrame(Protocol):
+        @property
+        def columns(self) -> Any: ...
+
+        def join(self, *args: Any, **kwargs: Any) -> Any: ...
+
+    class NativeSeries(Protocol):
+        def __len__(self) -> int: ...
+
+
+IntoExpr: TypeAlias = Union["Expr", str, "Series[Any]"]
+"""Anything which can be converted to an expression.
+
+Use this to mean "either a Narwhals expression, or something
+which can be converted into one". For example, `exprs` in `DataFrame.select` is
+typed to accept `IntoExpr`, as it can either accept a `nw.Expr`
+(e.g. `df.select(nw.col('a'))`) or a string which will be interpreted as a
+`nw.Expr`, e.g. `df.select('a')`.
+"""
+
+IntoDataFrame: TypeAlias = Union["NativeFrame", "DataFrame[Any]"]
+"""Anything which can be converted to a Narwhals DataFrame.
+
+Use this if your function accepts a narwhalifiable object but doesn't care about its backend.
+
+Examples:
+    >>> import narwhals as nw
+    >>> from narwhals.typing import IntoDataFrame
+    >>> def agnostic_shape(df_native: IntoDataFrame) -> tuple[int, int]:
+    ...     df = nw.from_native(df_native, eager_only=True)
+    ...     return df.shape
+"""
+
+IntoFrame: TypeAlias = Union["NativeFrame", "DataFrame[Any]", "LazyFrame[Any]"]
+"""Anything which can be converted to a Narwhals DataFrame or LazyFrame.
+
+Use this if your function can accept an object which can be converted to either
+`nw.DataFrame` or `nw.LazyFrame` and it doesn't care about its backend.
+
+Examples:
+    >>> import narwhals as nw
+    >>> from narwhals.typing import IntoFrame
+    >>> def agnostic_columns(df_native: IntoFrame) -> list[str]:
+    ...     df = nw.from_native(df_native)
+    ...     return df.collect_schema().names()
+"""
+
+Frame: TypeAlias = Union["DataFrame[Any]", "LazyFrame[Any]"]
+"""Narwhals DataFrame or Narwhals LazyFrame.
+
+Use this if your function can work with either and your function doesn't care
+about its backend.
+
+Examples:
+    >>> import narwhals as nw
+    >>> from narwhals.typing import Frame
+    >>> @nw.narwhalify
+    ... def agnostic_columns(df: Frame) -> list[str]:
+    ...     return df.columns
+"""
+
+IntoSeries: TypeAlias = Union["Series[Any]", "NativeSeries"]
+"""Anything which can be converted to a Narwhals Series.
+
+Use this if your function can accept an object which can be converted to `nw.Series`
+and it doesn't care about its backend.
+
+Examples:
+    >>> from typing import Any
+    >>> import narwhals as nw
+    >>> from narwhals.typing import IntoSeries
+    >>> def agnostic_to_list(s_native: IntoSeries) -> list[Any]:
+    ...     s = nw.from_native(s_native)
+    ...     return s.to_list()
+"""
+
+IntoFrameT = TypeVar("IntoFrameT", bound="IntoFrame")
+"""TypeVar bound to object convertible to Narwhals DataFrame or Narwhals LazyFrame.
+
+Use this if your function accepts an object which is convertible to `nw.DataFrame`
+or `nw.LazyFrame` and returns an object of the same type.
+
+Examples:
+    >>> import narwhals as nw
+    >>> from narwhals.typing import IntoFrameT
+    >>> def agnostic_func(df_native: IntoFrameT) -> IntoFrameT:
+    ...     df = nw.from_native(df_native)
+    ...     return df.with_columns(c=nw.col("a") + 1).to_native()
+"""
+
+IntoDataFrameT = TypeVar("IntoDataFrameT", bound="IntoDataFrame")
+"""TypeVar bound to object convertible to Narwhals DataFrame.
+
+Use this if your function accepts an object which can be converted to `nw.DataFrame`
+and returns an object of the same class.
+
+Examples:
+    >>> import narwhals as nw
+    >>> from narwhals.typing import IntoDataFrameT
+    >>> def agnostic_func(df_native: IntoDataFrameT) -> IntoDataFrameT:
+    ...     df = nw.from_native(df_native, eager_only=True)
+    ...     return df.with_columns(c=df["a"] + 1).to_native()
+"""
+
+FrameT = TypeVar("FrameT", "DataFrame[Any]", "LazyFrame[Any]")
+"""TypeVar bound to Narwhals DataFrame or Narwhals LazyFrame.
+
+Use this if your function accepts either `nw.DataFrame` or `nw.LazyFrame` and returns
+an object of the same kind.
+
+Examples:
+    >>> import narwhals as nw
+    >>> from narwhals.typing import FrameT
+    >>> @nw.narwhalify
+    ... def agnostic_func(df: FrameT) -> FrameT:
+    ...     return df.with_columns(c=nw.col("a") + 1)
+"""
+
+DataFrameT = TypeVar("DataFrameT", bound="DataFrame[Any]")
+"""TypeVar bound to Narwhals DataFrame.
+
+Use this if your function can accept a Narwhals DataFrame and returns a Narwhals
+DataFrame backed by the same backend.
+
+Examples:
+    >>> import narwhals as nw
+    >>> from narwhals.typing import DataFrameT
+    >>> @nw.narwhalify
+    >>> def func(df: DataFrameT) -> DataFrameT:
+    ...     return df.with_columns(c=df["a"] + 1)
+"""
+
+IntoSeriesT = TypeVar("IntoSeriesT", bound="IntoSeries")
+"""TypeVar bound to object convertible to Narwhals Series.
+
+Use this if your function accepts an object  which can be converted to `nw.Series`
+and returns an object of the same class.
+
+Examples:
+    >>> import narwhals as nw
+    >>> from narwhals.typing import IntoSeriesT
+    >>> def agnostic_abs(s_native: IntoSeriesT) -> IntoSeriesT:
+    ...     s = nw.from_native(s_native, series_only=True)
+    ...     return s.abs().to_native()
+"""
+
+
+__all__ = [
+    "DataFrameT",
+    "Frame",
+    "FrameT",
+    "IntoDataFrame",
+    "IntoDataFrameT",
+    "IntoExpr",
+    "IntoFrame",
+    "IntoFrameT",
+    "IntoSeries",
+    "IntoSeriesT",
+]