Upload folder using huggingface_hub (part 16)

.gitattributes

@@ -385,3 +385,23 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.12/site-packages/scipy/special/_ufuncs.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.12/site-packages/scipy/special/_ufuncs_cxx.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.12/site-packages/scipy/special/cython_special.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/scipy/stats/_ansari_swilk_statistics.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/scipy/stats/_biasedurn.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/scipy/stats/_qmc_cy.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/scipy/stats/_qmvnt_cy.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/scipy/stats/_rcont/rcont.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/scipy/stats/_sobol.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/scipy/stats/_stats.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/scipy/stats/_stats_pythran.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/scipy/stats/_unuran/unuran_wrapper.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/scipy.libs/libgfortran-040039e1-0352e75f.so.5.0.0 filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/scipy.libs/libgfortran-83c28eba.so.5.0.0 filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/scipy.libs/libquadmath-2284e583.so.0.0.0 filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/scipy.libs/libquadmath-96973f99-934c22de.so.0.0.0 filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/scipy.libs/libscipy_openblas-5f890258.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/setuptools/_vendor/__pycache__/typing_extensions.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/setuptools/_vendor/backports/tarfile/__pycache__/__init__.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/setuptools/_vendor/inflect/__pycache__/__init__.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/__pycache__/more.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/setuptools/command/__pycache__/easy_install.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/__pycache__/fastjsonschema_validations.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text

.venv/lib/python3.12/site-packages/scipy-1.18.1.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

.venv/lib/python3.12/site-packages/scipy-1.18.1.dist-info/LICENSE.txt

@@ -0,0 +1,937 @@
+Copyright (c) 2001-2002 Enthought, Inc. 2003, SciPy Developers.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following
+   disclaimer in the documentation and/or other materials provided
+   with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived
+   from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----
+
+
+----
+
+This binary distribution of SciPy can also bundle the following software
+(depending on the build):
+
+
+Name: OpenBLAS
+Files: scipy.libs/libscipy_openblas*.so
+Description: bundled as a dynamically linked library
+Availability: https://github.com/OpenMathLib/OpenBLAS/
+License: BSD-3-Clause
+  Copyright (c) 2011-2014, The OpenBLAS Project
+  All rights reserved.
+  
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are
+  met:
+  
+     1. Redistributions of source code must retain the above copyright
+        notice, this list of conditions and the following disclaimer.
+  
+     2. Redistributions in binary form must reproduce the above copyright
+        notice, this list of conditions and the following disclaimer in
+        the documentation and/or other materials provided with the
+        distribution.
+     3. Neither the name of the OpenBLAS project nor the names of 
+        its contributors may be used to endorse or promote products 
+        derived from this software without specific prior written 
+        permission.
+  
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Name: LAPACK
+Files: scipy.libs/libscipy_openblas*.so
+Description: bundled in OpenBLAS
+Availability: https://github.com/OpenMathLib/OpenBLAS/
+License: BSD-3-Clause-Open-MPI
+  Copyright (c) 1992-2013 The University of Tennessee and The University
+                          of Tennessee Research Foundation.  All rights
+                          reserved.
+  Copyright (c) 2000-2013 The University of California Berkeley. All
+                          rights reserved.
+  Copyright (c) 2006-2013 The University of Colorado Denver.  All rights
+                          reserved.
+  
+  $COPYRIGHT$
+  
+  Additional copyrights may follow
+  
+  $HEADER$
+  
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are
+  met:
+  
+  - Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+  
+  - Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer listed
+    in this license in the documentation and/or other materials
+    provided with the distribution.
+  
+  - Neither the name of the copyright holders nor the names of its
+    contributors may be used to endorse or promote products derived from
+    this software without specific prior written permission.
+  
+  The copyright holders provide no reassurances that the source code
+  provided does not infringe any patent, copyright, or any other
+  intellectual property rights of third parties.  The copyright holders
+  disclaim any liability to any recipient for claims brought against
+  recipient by any third party for infringement of that parties
+  intellectual property rights.
+  
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Name: GCC runtime library
+Files: scipy.libs/libgfortran*.so
+Description: dynamically linked to files compiled with gcc
+Availability: https://gcc.gnu.org/git/?p=gcc.git;a=tree;f=libgfortran
+License: GPL-3.0-or-later WITH GCC-exception-3.1
+  Copyright (C) 2002-2017 Free Software Foundation, Inc.
+  
+  Libgfortran is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 3, or (at your option)
+  any later version.
+  
+  Libgfortran is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+  
+  Under Section 7 of GPL version 3, you are granted additional
+  permissions described in the GCC Runtime Library Exception, version
+  3.1, as published by the Free Software Foundation.
+  
+  You should have received a copy of the GNU General Public License and
+  a copy of the GCC Runtime Library Exception along with this program;
+  see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+  <http://www.gnu.org/licenses/>.
+
+----
+
+Full text of license texts referred to above follows (that they are
+listed below does not necessarily imply the conditions apply to the
+present binary release):
+
+----
+
+GCC RUNTIME LIBRARY EXCEPTION
+
+Version 3.1, 31 March 2009
+
+Copyright (C) 2009 Free Software Foundation, Inc. <http://fsf.org/>
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+This GCC Runtime Library Exception ("Exception") is an additional
+permission under section 7 of the GNU General Public License, version
+3 ("GPLv3"). It applies to a given file (the "Runtime Library") that
+bears a notice placed by the copyright holder of the file stating that
+the file is governed by GPLv3 along with this Exception.
+
+When you use GCC to compile a program, GCC may combine portions of
+certain GCC header files and runtime libraries with the compiled
+program. The purpose of this Exception is to allow compilation of
+non-GPL (including proprietary) programs to use, in this way, the
+header files and runtime libraries covered by this Exception.
+
+0. Definitions.
+
+A file is an "Independent Module" if it either requires the Runtime
+Library for execution after a Compilation Process, or makes use of an
+interface provided by the Runtime Library, but is not otherwise based
+on the Runtime Library.
+
+"GCC" means a version of the GNU Compiler Collection, with or without
+modifications, governed by version 3 (or a specified later version) of
+the GNU General Public License (GPL) with the option of using any
+subsequent versions published by the FSF.
+
+"GPL-compatible Software" is software whose conditions of propagation,
+modification and use would permit combination with GCC in accord with
+the license of GCC.
+
+"Target Code" refers to output from any compiler for a real or virtual
+target processor architecture, in executable form or suitable for
+input to an assembler, loader, linker and/or execution
+phase. Notwithstanding that, Target Code does not include data in any
+format that is used as a compiler intermediate representation, or used
+for producing a compiler intermediate representation.
+
+The "Compilation Process" transforms code entirely represented in
+non-intermediate languages designed for human-written code, and/or in
+Java Virtual Machine byte code, into Target Code. Thus, for example,
+use of source code generators and preprocessors need not be considered
+part of the Compilation Process, since the Compilation Process can be
+understood as starting with the output of the generators or
+preprocessors.
+
+A Compilation Process is "Eligible" if it is done using GCC, alone or
+with other GPL-compatible software, or if it is done without using any
+work based on GCC. For example, using non-GPL-compatible Software to
+optimize any GCC intermediate representations would not qualify as an
+Eligible Compilation Process.
+
+1. Grant of Additional Permission.
+
+You have permission to propagate a work of Target Code formed by
+combining the Runtime Library with Independent Modules, even if such
+propagation would otherwise violate the terms of GPLv3, provided that
+all Target Code was generated by Eligible Compilation Processes. You
+may then convey such a combination under terms of your choice,
+consistent with the licensing of the Independent Modules.
+
+2. No Weakening of GCC Copyleft.
+
+The availability of this Exception does not imply any general
+presumption that third-party software is unaffected by the copyleft
+requirements of the license of GCC.
+
+----
+
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
+
+
+Name: libquadmath
+Files: scipy.libs/libquadmath*.so
+Description: dynamically linked to files compiled with gcc
+Availability: https://gcc.gnu.org/git/?p=gcc.git;a=tree;f=libquadmath
+License: LGPL-2.1-or-later
+
+    GCC Quad-Precision Math Library
+    Copyright (C) 2010-2019 Free Software Foundation, Inc.
+    Written by Francois-Xavier Coudert  <fxcoudert@gcc.gnu.org>
+
+    This file is part of the libquadmath library.
+    Libquadmath is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    Libquadmath is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+    https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html

.venv/lib/python3.12/site-packages/scipy-1.18.1.dist-info/METADATA

@@ -0,0 +1,1092 @@
+Metadata-Version: 2.1
+Name: scipy
+Version: 1.18.1
+Summary: Fundamental algorithms for scientific computing in Python
+Maintainer-Email: SciPy Developers <scipy-dev@python.org>
+License: Copyright (c) 2001-2002 Enthought, Inc. 2003, SciPy Developers.
+         All rights reserved.
+         
+         Redistribution and use in source and binary forms, with or without
+         modification, are permitted provided that the following conditions
+         are met:
+         
+         1. Redistributions of source code must retain the above copyright
+            notice, this list of conditions and the following disclaimer.
+         
+         2. Redistributions in binary form must reproduce the above
+            copyright notice, this list of conditions and the following
+            disclaimer in the documentation and/or other materials provided
+            with the distribution.
+         
+         3. Neither the name of the copyright holder nor the names of its
+            contributors may be used to endorse or promote products derived
+            from this software without specific prior written permission.
+         
+         THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+         "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+         LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+         A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+         OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+         SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+         LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+         DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+         THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+         (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+         OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+         
+         ----
+         
+         
+         ----
+         
+         This binary distribution of SciPy can also bundle the following software
+         (depending on the build):
+         
+         
+         Name: OpenBLAS
+         Files: scipy.libs/libscipy_openblas*.so
+         Description: bundled as a dynamically linked library
+         Availability: https://github.com/OpenMathLib/OpenBLAS/
+         License: BSD-3-Clause
+           Copyright (c) 2011-2014, The OpenBLAS Project
+           All rights reserved.
+           
+           Redistribution and use in source and binary forms, with or without
+           modification, are permitted provided that the following conditions are
+           met:
+           
+              1. Redistributions of source code must retain the above copyright
+                 notice, this list of conditions and the following disclaimer.
+           
+              2. Redistributions in binary form must reproduce the above copyright
+                 notice, this list of conditions and the following disclaimer in
+                 the documentation and/or other materials provided with the
+                 distribution.
+              3. Neither the name of the OpenBLAS project nor the names of 
+                 its contributors may be used to endorse or promote products 
+                 derived from this software without specific prior written 
+                 permission.
+           
+           THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+           AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+           IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+           ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+           LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+           DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+           SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+           CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+           OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+           USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+         
+         
+         Name: LAPACK
+         Files: scipy.libs/libscipy_openblas*.so
+         Description: bundled in OpenBLAS
+         Availability: https://github.com/OpenMathLib/OpenBLAS/
+         License: BSD-3-Clause-Open-MPI
+           Copyright (c) 1992-2013 The University of Tennessee and The University
+                                   of Tennessee Research Foundation.  All rights
+                                   reserved.
+           Copyright (c) 2000-2013 The University of California Berkeley. All
+                                   rights reserved.
+           Copyright (c) 2006-2013 The University of Colorado Denver.  All rights
+                                   reserved.
+           
+           $COPYRIGHT$
+           
+           Additional copyrights may follow
+           
+           $HEADER$
+           
+           Redistribution and use in source and binary forms, with or without
+           modification, are permitted provided that the following conditions are
+           met:
+           
+           - Redistributions of source code must retain the above copyright
+             notice, this list of conditions and the following disclaimer.
+           
+           - Redistributions in binary form must reproduce the above copyright
+             notice, this list of conditions and the following disclaimer listed
+             in this license in the documentation and/or other materials
+             provided with the distribution.
+           
+           - Neither the name of the copyright holders nor the names of its
+             contributors may be used to endorse or promote products derived from
+             this software without specific prior written permission.
+           
+           The copyright holders provide no reassurances that the source code
+           provided does not infringe any patent, copyright, or any other
+           intellectual property rights of third parties.  The copyright holders
+           disclaim any liability to any recipient for claims brought against
+           recipient by any third party for infringement of that parties
+           intellectual property rights.
+           
+           THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+           "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+           LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+           A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+           OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+           SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+           LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+           DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+           THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+           (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+           OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+         
+         
+         Name: GCC runtime library
+         Files: scipy.libs/libgfortran*.so
+         Description: dynamically linked to files compiled with gcc
+         Availability: https://gcc.gnu.org/git/?p=gcc.git;a=tree;f=libgfortran
+         License: GPL-3.0-or-later WITH GCC-exception-3.1
+           Copyright (C) 2002-2017 Free Software Foundation, Inc.
+           
+           Libgfortran is free software; you can redistribute it and/or modify
+           it under the terms of the GNU General Public License as published by
+           the Free Software Foundation; either version 3, or (at your option)
+           any later version.
+           
+           Libgfortran is distributed in the hope that it will be useful,
+           but WITHOUT ANY WARRANTY; without even the implied warranty of
+           MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+           GNU General Public License for more details.
+           
+           Under Section 7 of GPL version 3, you are granted additional
+           permissions described in the GCC Runtime Library Exception, version
+           3.1, as published by the Free Software Foundation.
+           
+           You should have received a copy of the GNU General Public License and
+           a copy of the GCC Runtime Library Exception along with this program;
+           see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+           <http://www.gnu.org/licenses/>.
+         
+         ----
+         
+         Full text of license texts referred to above follows (that they are
+         listed below does not necessarily imply the conditions apply to the
+         present binary release):
+         
+         ----
+         
+         GCC RUNTIME LIBRARY EXCEPTION
+         
+         Version 3.1, 31 March 2009
+         
+         Copyright (C) 2009 Free Software Foundation, Inc. <http://fsf.org/>
+         
+         Everyone is permitted to copy and distribute verbatim copies of this
+         license document, but changing it is not allowed.
+         
+         This GCC Runtime Library Exception ("Exception") is an additional
+         permission under section 7 of the GNU General Public License, version
+         3 ("GPLv3"). It applies to a given file (the "Runtime Library") that
+         bears a notice placed by the copyright holder of the file stating that
+         the file is governed by GPLv3 along with this Exception.
+         
+         When you use GCC to compile a program, GCC may combine portions of
+         certain GCC header files and runtime libraries with the compiled
+         program. The purpose of this Exception is to allow compilation of
+         non-GPL (including proprietary) programs to use, in this way, the
+         header files and runtime libraries covered by this Exception.
+         
+         0. Definitions.
+         
+         A file is an "Independent Module" if it either requires the Runtime
+         Library for execution after a Compilation Process, or makes use of an
+         interface provided by the Runtime Library, but is not otherwise based
+         on the Runtime Library.
+         
+         "GCC" means a version of the GNU Compiler Collection, with or without
+         modifications, governed by version 3 (or a specified later version) of
+         the GNU General Public License (GPL) with the option of using any
+         subsequent versions published by the FSF.
+         
+         "GPL-compatible Software" is software whose conditions of propagation,
+         modification and use would permit combination with GCC in accord with
+         the license of GCC.
+         
+         "Target Code" refers to output from any compiler for a real or virtual
+         target processor architecture, in executable form or suitable for
+         input to an assembler, loader, linker and/or execution
+         phase. Notwithstanding that, Target Code does not include data in any
+         format that is used as a compiler intermediate representation, or used
+         for producing a compiler intermediate representation.
+         
+         The "Compilation Process" transforms code entirely represented in
+         non-intermediate languages designed for human-written code, and/or in
+         Java Virtual Machine byte code, into Target Code. Thus, for example,
+         use of source code generators and preprocessors need not be considered
+         part of the Compilation Process, since the Compilation Process can be
+         understood as starting with the output of the generators or
+         preprocessors.
+         
+         A Compilation Process is "Eligible" if it is done using GCC, alone or
+         with other GPL-compatible software, or if it is done without using any
+         work based on GCC. For example, using non-GPL-compatible Software to
+         optimize any GCC intermediate representations would not qualify as an
+         Eligible Compilation Process.
+         
+         1. Grant of Additional Permission.
+         
+         You have permission to propagate a work of Target Code formed by
+         combining the Runtime Library with Independent Modules, even if such
+         propagation would otherwise violate the terms of GPLv3, provided that
+         all Target Code was generated by Eligible Compilation Processes. You
+         may then convey such a combination under terms of your choice,
+         consistent with the licensing of the Independent Modules.
+         
+         2. No Weakening of GCC Copyleft.
+         
+         The availability of this Exception does not imply any general
+         presumption that third-party software is unaffected by the copyleft
+         requirements of the license of GCC.
+         
+         ----
+         
+                             GNU GENERAL PUBLIC LICENSE
+                                Version 3, 29 June 2007
+         
+          Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+          Everyone is permitted to copy and distribute verbatim copies
+          of this license document, but changing it is not allowed.
+         
+                                     Preamble
+         
+           The GNU General Public License is a free, copyleft license for
+         software and other kinds of works.
+         
+           The licenses for most software and other practical works are designed
+         to take away your freedom to share and change the works.  By contrast,
+         the GNU General Public License is intended to guarantee your freedom to
+         share and change all versions of a program--to make sure it remains free
+         software for all its users.  We, the Free Software Foundation, use the
+         GNU General Public License for most of our software; it applies also to
+         any other work released this way by its authors.  You can apply it to
+         your programs, too.
+         
+           When we speak of free software, we are referring to freedom, not
+         price.  Our General Public Licenses are designed to make sure that you
+         have the freedom to distribute copies of free software (and charge for
+         them if you wish), that you receive source code or can get it if you
+         want it, that you can change the software or use pieces of it in new
+         free programs, and that you know you can do these things.
+         
+           To protect your rights, we need to prevent others from denying you
+         these rights or asking you to surrender the rights.  Therefore, you have
+         certain responsibilities if you distribute copies of the software, or if
+         you modify it: responsibilities to respect the freedom of others.
+         
+           For example, if you distribute copies of such a program, whether
+         gratis or for a fee, you must pass on to the recipients the same
+         freedoms that you received.  You must make sure that they, too, receive
+         or can get the source code.  And you must show them these terms so they
+         know their rights.
+         
+           Developers that use the GNU GPL protect your rights with two steps:
+         (1) assert copyright on the software, and (2) offer you this License
+         giving you legal permission to copy, distribute and/or modify it.
+         
+           For the developers' and authors' protection, the GPL clearly explains
+         that there is no warranty for this free software.  For both users' and
+         authors' sake, the GPL requires that modified versions be marked as
+         changed, so that their problems will not be attributed erroneously to
+         authors of previous versions.
+         
+           Some devices are designed to deny users access to install or run
+         modified versions of the software inside them, although the manufacturer
+         can do so.  This is fundamentally incompatible with the aim of
+         protecting users' freedom to change the software.  The systematic
+         pattern of such abuse occurs in the area of products for individuals to
+         use, which is precisely where it is most unacceptable.  Therefore, we
+         have designed this version of the GPL to prohibit the practice for those
+         products.  If such problems arise substantially in other domains, we
+         stand ready to extend this provision to those domains in future versions
+         of the GPL, as needed to protect the freedom of users.
+         
+           Finally, every program is threatened constantly by software patents.
+         States should not allow patents to restrict development and use of
+         software on general-purpose computers, but in those that do, we wish to
+         avoid the special danger that patents applied to a free program could
+         make it effectively proprietary.  To prevent this, the GPL assures that
+         patents cannot be used to render the program non-free.
+         
+           The precise terms and conditions for copying, distribution and
+         modification follow.
+         
+                                TERMS AND CONDITIONS
+         
+           0. Definitions.
+         
+           "This License" refers to version 3 of the GNU General Public License.
+         
+           "Copyright" also means copyright-like laws that apply to other kinds of
+         works, such as semiconductor masks.
+         
+           "The Program" refers to any copyrightable work licensed under this
+         License.  Each licensee is addressed as "you".  "Licensees" and
+         "recipients" may be individuals or organizations.
+         
+           To "modify" a work means to copy from or adapt all or part of the work
+         in a fashion requiring copyright permission, other than the making of an
+         exact copy.  The resulting work is called a "modified version" of the
+         earlier work or a work "based on" the earlier work.
+         
+           A "covered work" means either the unmodified Program or a work based
+         on the Program.
+         
+           To "propagate" a work means to do anything with it that, without
+         permission, would make you directly or secondarily liable for
+         infringement under applicable copyright law, except executing it on a
+         computer or modifying a private copy.  Propagation includes copying,
+         distribution (with or without modification), making available to the
+         public, and in some countries other activities as well.
+         
+           To "convey" a work means any kind of propagation that enables other
+         parties to make or receive copies.  Mere interaction with a user through
+         a computer network, with no transfer of a copy, is not conveying.
+         
+           An interactive user interface displays "Appropriate Legal Notices"
+         to the extent that it includes a convenient and prominently visible
+         feature that (1) displays an appropriate copyright notice, and (2)
+         tells the user that there is no warranty for the work (except to the
+         extent that warranties are provided), that licensees may convey the
+         work under this License, and how to view a copy of this License.  If
+         the interface presents a list of user commands or options, such as a
+         menu, a prominent item in the list meets this criterion.
+         
+           1. Source Code.
+         
+           The "source code" for a work means the preferred form of the work
+         for making modifications to it.  "Object code" means any non-source
+         form of a work.
+         
+           A "Standard Interface" means an interface that either is an official
+         standard defined by a recognized standards body, or, in the case of
+         interfaces specified for a particular programming language, one that
+         is widely used among developers working in that language.
+         
+           The "System Libraries" of an executable work include anything, other
+         than the work as a whole, that (a) is included in the normal form of
+         packaging a Major Component, but which is not part of that Major
+         Component, and (b) serves only to enable use of the work with that
+         Major Component, or to implement a Standard Interface for which an
+         implementation is available to the public in source code form.  A
+         "Major Component", in this context, means a major essential component
+         (kernel, window system, and so on) of the specific operating system
+         (if any) on which the executable work runs, or a compiler used to
+         produce the work, or an object code interpreter used to run it.
+         
+           The "Corresponding Source" for a work in object code form means all
+         the source code needed to generate, install, and (for an executable
+         work) run the object code and to modify the work, including scripts to
+         control those activities.  However, it does not include the work's
+         System Libraries, or general-purpose tools or generally available free
+         programs which are used unmodified in performing those activities but
+         which are not part of the work.  For example, Corresponding Source
+         includes interface definition files associated with source files for
+         the work, and the source code for shared libraries and dynamically
+         linked subprograms that the work is specifically designed to require,
+         such as by intimate data communication or control flow between those
+         subprograms and other parts of the work.
+         
+           The Corresponding Source need not include anything that users
+         can regenerate automatically from other parts of the Corresponding
+         Source.
+         
+           The Corresponding Source for a work in source code form is that
+         same work.
+         
+           2. Basic Permissions.
+         
+           All rights granted under this License are granted for the term of
+         copyright on the Program, and are irrevocable provided the stated
+         conditions are met.  This License explicitly affirms your unlimited
+         permission to run the unmodified Program.  The output from running a
+         covered work is covered by this License only if the output, given its
+         content, constitutes a covered work.  This License acknowledges your
+         rights of fair use or other equivalent, as provided by copyright law.
+         
+           You may make, run and propagate covered works that you do not
+         convey, without conditions so long as your license otherwise remains
+         in force.  You may convey covered works to others for the sole purpose
+         of having them make modifications exclusively for you, or provide you
+         with facilities for running those works, provided that you comply with
+         the terms of this License in conveying all material for which you do
+         not control copyright.  Those thus making or running the covered works
+         for you must do so exclusively on your behalf, under your direction
+         and control, on terms that prohibit them from making any copies of
+         your copyrighted material outside their relationship with you.
+         
+           Conveying under any other circumstances is permitted solely under
+         the conditions stated below.  Sublicensing is not allowed; section 10
+         makes it unnecessary.
+         
+           3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+         
+           No covered work shall be deemed part of an effective technological
+         measure under any applicable law fulfilling obligations under article
+         11 of the WIPO copyright treaty adopted on 20 December 1996, or
+         similar laws prohibiting or restricting circumvention of such
+         measures.
+         
+           When you convey a covered work, you waive any legal power to forbid
+         circumvention of technological measures to the extent such circumvention
+         is effected by exercising rights under this License with respect to
+         the covered work, and you disclaim any intention to limit operation or
+         modification of the work as a means of enforcing, against the work's
+         users, your or third parties' legal rights to forbid circumvention of
+         technological measures.
+         
+           4. Conveying Verbatim Copies.
+         
+           You may convey verbatim copies of the Program's source code as you
+         receive it, in any medium, provided that you conspicuously and
+         appropriately publish on each copy an appropriate copyright notice;
+         keep intact all notices stating that this License and any
+         non-permissive terms added in accord with section 7 apply to the code;
+         keep intact all notices of the absence of any warranty; and give all
+         recipients a copy of this License along with the Program.
+         
+           You may charge any price or no price for each copy that you convey,
+         and you may offer support or warranty protection for a fee.
+         
+           5. Conveying Modified Source Versions.
+         
+           You may convey a work based on the Program, or the modifications to
+         produce it from the Program, in the form of source code under the
+         terms of section 4, provided that you also meet all of these conditions:
+         
+             a) The work must carry prominent notices stating that you modified
+             it, and giving a relevant date.
+         
+             b) The work must carry prominent notices stating that it is
+             released under this License and any conditions added under section
+             7.  This requirement modifies the requirement in section 4 to
+             "keep intact all notices".
+         
+             c) You must license the entire work, as a whole, under this
+             License to anyone who comes into possession of a copy.  This
+             License will therefore apply, along with any applicable section 7
+             additional terms, to the whole of the work, and all its parts,
+             regardless of how they are packaged.  This License gives no
+             permission to license the work in any other way, but it does not
+             invalidate such permission if you have separately received it.
+         
+             d) If the work has interactive user interfaces, each must display
+             Appropriate Legal Notices; however, if the Program has interactive
+             interfaces that do not display Appropriate Legal Notices, your
+             work need not make them do so.
+         
+           A compilation of a covered work with other separate and independent
+         works, which are not by their nature extensions of the covered work,
+         and which are not combined with it such as to form a larger program,
+         in or on a volume of a storage or distribution medium, is called an
+         "aggregate" if the compilation and its resulting copyright are not
+         used to limit the access or legal rights of the compilation's users
+         beyond what the individual works permit.  Inclusion of a covered work
+         in an aggregate does not cause this License to apply to the other
+         parts of the aggregate.
+         
+           6. Conveying Non-Source Forms.
+         
+           You may convey a covered work in object code form under the terms
+         of sections 4 and 5, provided that you also convey the
+         machine-readable Corresponding Source under the terms of this License,
+         in one of these ways:
+         
+             a) Convey the object code in, or embodied in, a physical product
+             (including a physical distribution medium), accompanied by the
+             Corresponding Source fixed on a durable physical medium
+             customarily used for software interchange.
+         
+             b) Convey the object code in, or embodied in, a physical product
+             (including a physical distribution medium), accompanied by a
+             written offer, valid for at least three years and valid for as
+             long as you offer spare parts or customer support for that product
+             model, to give anyone who possesses the object code either (1) a
+             copy of the Corresponding Source for all the software in the
+             product that is covered by this License, on a durable physical
+             medium customarily used for software interchange, for a price no
+             more than your reasonable cost of physically performing this
+             conveying of source, or (2) access to copy the
+             Corresponding Source from a network server at no charge.
+         
+             c) Convey individual copies of the object code with a copy of the
+             written offer to provide the Corresponding Source.  This
+             alternative is allowed only occasionally and noncommercially, and
+             only if you received the object code with such an offer, in accord
+             with subsection 6b.
+         
+             d) Convey the object code by offering access from a designated
+             place (gratis or for a charge), and offer equivalent access to the
+             Corresponding Source in the same way through the same place at no
+             further charge.  You need not require recipients to copy the
+             Corresponding Source along with the object code.  If the place to
+             copy the object code is a network server, the Corresponding Source
+             may be on a different server (operated by you or a third party)
+             that supports equivalent copying facilities, provided you maintain
+             clear directions next to the object code saying where to find the
+             Corresponding Source.  Regardless of what server hosts the
+             Corresponding Source, you remain obligated to ensure that it is
+             available for as long as needed to satisfy these requirements.
+         
+             e) Convey the object code using peer-to-peer transmission, provided
+             you inform other peers where the object code and Corresponding
+             Source of the work are being offered to the general public at no
+             charge under subsection 6d.
+         
+           A separable portion of the object code, whose source code is excluded
+         from the Corresponding Source as a System Library, need not be
+         included in conveying the object code work.
+         
+           A "User Product" is either (1) a "consumer product", which means any
+         tangible personal property which is normally used for personal, family,
+         or household purposes, or (2) anything designed or sold for incorporation
+         into a dwelling.  In determining whether a product is a consumer product,
+         doubtful cases shall be resolved in favor of coverage.  For a particular
+         product received by a particular user, "normally used" refers to a
+         typical or common use of that class of product, regardless of the status
+         of the particular user or of the way in which the particular user
+         actually uses, or expects or is expected to use, the product.  A product
+         is a consumer product regardless of whether the product has substantial
+         commercial, industrial or non-consumer uses, unless such uses represent
+         the only significant mode of use of the product.
+         
+           "Installation Information" for a User Product means any methods,
+         procedures, authorization keys, or other information required to install
+         and execute modified versions of a covered work in that User Product from
+         a modified version of its Corresponding Source.  The information must
+         suffice to ensure that the continued functioning of the modified object
+         code is in no case prevented or interfered with solely because
+         modification has been made.
+         
+           If you convey an object code work under this section in, or with, or
+         specifically for use in, a User Product, and the conveying occurs as
+         part of a transaction in which the right of possession and use of the
+         User Product is transferred to the recipient in perpetuity or for a
+         fixed term (regardless of how the transaction is characterized), the
+         Corresponding Source conveyed under this section must be accompanied
+         by the Installation Information.  But this requirement does not apply
+         if neither you nor any third party retains the ability to install
+         modified object code on the User Product (for example, the work has
+         been installed in ROM).
+         
+           The requirement to provide Installation Information does not include a
+         requirement to continue to provide support service, warranty, or updates
+         for a work that has been modified or installed by the recipient, or for
+         the User Product in which it has been modified or installed.  Access to a
+         network may be denied when the modification itself materially and
+         adversely affects the operation of the network or violates the rules and
+         protocols for communication across the network.
+         
+           Corresponding Source conveyed, and Installation Information provided,
+         in accord with this section must be in a format that is publicly
+         documented (and with an implementation available to the public in
+         source code form), and must require no special password or key for
+         unpacking, reading or copying.
+         
+           7. Additional Terms.
+         
+           "Additional permissions" are terms that supplement the terms of this
+         License by making exceptions from one or more of its conditions.
+         Additional permissions that are applicable to the entire Program shall
+         be treated as though they were included in this License, to the extent
+         that they are valid under applicable law.  If additional permissions
+         apply only to part of the Program, that part may be used separately
+         under those permissions, but the entire Program remains governed by
+         this License without regard to the additional permissions.
+         
+           When you convey a copy of a covered work, you may at your option
+         remove any additional permissions from that copy, or from any part of
+         it.  (Additional permissions may be written to require their own
+         removal in certain cases when you modify the work.)  You may place
+         additional permissions on material, added by you to a covered work,
+         for which you have or can give appropriate copyright permission.
+         
+           Notwithstanding any other provision of this License, for material you
+         add to a covered work, you may (if authorized by the copyright holders of
+         that material) supplement the terms of this License with terms:
+         
+             a) Disclaiming warranty or limiting liability differently from the
+             terms of sections 15 and 16 of this License; or
+         
+             b) Requiring preservation of specified reasonable legal notices or
+             author attributions in that material or in the Appropriate Legal
+             Notices displayed by works containing it; or
+         
+             c) Prohibiting misrepresentation of the origin of that material, or
+             requiring that modified versions of such material be marked in
+             reasonable ways as different from the original version; or
+         
+             d) Limiting the use for publicity purposes of names of licensors or
+             authors of the material; or
+         
+             e) Declining to grant rights under trademark law for use of some
+             trade names, trademarks, or service marks; or
+         
+             f) Requiring indemnification of licensors and authors of that
+             material by anyone who conveys the material (or modified versions of
+             it) with contractual assumptions of liability to the recipient, for
+             any liability that these contractual assumptions directly impose on
+             those licensors and authors.
+         
+           All other non-permissive additional terms are considered "further
+         restrictions" within the meaning of section 10.  If the Program as you
+         received it, or any part of it, contains a notice stating that it is
+         governed by this License along with a term that is a further
+         restriction, you may remove that term.  If a license document contains
+         a further restriction but permits relicensing or conveying under this
+         License, you may add to a covered work material governed by the terms
+         of that license document, provided that the further restriction does
+         not survive such relicensing or conveying.
+         
+           If you add terms to a covered work in accord with this section, you
+         must place, in the relevant source files, a statement of the
+         additional terms that apply to those files, or a notice indicating
+         where to find the applicable terms.
+         
+           Additional terms, permissive or non-permissive, may be stated in the
+         form of a separately written license, or stated as exceptions;
+         the above requirements apply either way.
+         
+           8. Termination.
+         
+           You may not propagate or modify a covered work except as expressly
+         provided under this License.  Any attempt otherwise to propagate or
+         modify it is void, and will automatically terminate your rights under
+         this License (including any patent licenses granted under the third
+         paragraph of section 11).
+         
+           However, if you cease all violation of this License, then your
+         license from a particular copyright holder is reinstated (a)
+         provisionally, unless and until the copyright holder explicitly and
+         finally terminates your license, and (b) permanently, if the copyright
+         holder fails to notify you of the violation by some reasonable means
+         prior to 60 days after the cessation.
+         
+           Moreover, your license from a particular copyright holder is
+         reinstated permanently if the copyright holder notifies you of the
+         violation by some reasonable means, this is the first time you have
+         received notice of violation of this License (for any work) from that
+         copyright holder, and you cure the violation prior to 30 days after
+         your receipt of the notice.
+         
+           Termination of your rights under this section does not terminate the
+         licenses of parties who have received copies or rights from you under
+         this License.  If your rights have been terminated and not permanently
+         reinstated, you do not qualify to receive new licenses for the same
+         material under section 10.
+         
+           9. Acceptance Not Required for Having Copies.
+         
+           You are not required to accept this License in order to receive or
+         run a copy of the Program.  Ancillary propagation of a covered work
+         occurring solely as a consequence of using peer-to-peer transmission
+         to receive a copy likewise does not require acceptance.  However,
+         nothing other than this License grants you permission to propagate or
+         modify any covered work.  These actions infringe copyright if you do
+         not accept this License.  Therefore, by modifying or propagating a
+         covered work, you indicate your acceptance of this License to do so.
+         
+           10. Automatic Licensing of Downstream Recipients.
+         
+           Each time you convey a covered work, the recipient automatically
+         receives a license from the original licensors, to run, modify and
+         propagate that work, subject to this License.  You are not responsible
+         for enforcing compliance by third parties with this License.
+         
+           An "entity transaction" is a transaction transferring control of an
+         organization, or substantially all assets of one, or subdividing an
+         organization, or merging organizations.  If propagation of a covered
+         work results from an entity transaction, each party to that
+         transaction who receives a copy of the work also receives whatever
+         licenses to the work the party's predecessor in interest had or could
+         give under the previous paragraph, plus a right to possession of the
+         Corresponding Source of the work from the predecessor in interest, if
+         the predecessor has it or can get it with reasonable efforts.
+         
+           You may not impose any further restrictions on the exercise of the
+         rights granted or affirmed under this License.  For example, you may
+         not impose a license fee, royalty, or other charge for exercise of
+         rights granted under this License, and you may not initiate litigation
+         (including a cross-claim or counterclaim in a lawsuit) alleging that
+         any patent claim is infringed by making, using, selling, offering for
+         sale, or importing the Program or any portion of it.
+         
+           11. Patents.
+         
+           A "contributor" is a copyright holder who authorizes use under this
+         License of the Program or a work on which the Program is based.  The
+         work thus licensed is called the contributor's "contributor version".
+         
+           A contributor's "essential patent claims" are all patent claims
+         owned or controlled by the contributor, whether already acquired or
+         hereafter acquired, that would be infringed by some manner, permitted
+         by this License, of making, using, or selling its contributor version,
+         but do not include claims that would be infringed only as a
+         consequence of further modification of the contributor version.  For
+         purposes of this definition, "control" includes the right to grant
+         patent sublicenses in a manner consistent with the requirements of
+         this License.
+         
+           Each contributor grants you a non-exclusive, worldwide, royalty-free
+         patent license under the contributor's essential patent claims, to
+         make, use, sell, offer for sale, import and otherwise run, modify and
+         propagate the contents of its contributor version.
+         
+           In the following three paragraphs, a "patent license" is any express
+         agreement or commitment, however denominated, not to enforce a patent
+         (such as an express permission to practice a patent or covenant not to
+         sue for patent infringement).  To "grant" such a patent license to a
+         party means to make such an agreement or commitment not to enforce a
+         patent against the party.
+         
+           If you convey a covered work, knowingly relying on a patent license,
+         and the Corresponding Source of the work is not available for anyone
+         to copy, free of charge and under the terms of this License, through a
+         publicly available network server or other readily accessible means,
+         then you must either (1) cause the Corresponding Source to be so
+         available, or (2) arrange to deprive yourself of the benefit of the
+         patent license for this particular work, or (3) arrange, in a manner
+         consistent with the requirements of this License, to extend the patent
+         license to downstream recipients.  "Knowingly relying" means you have
+         actual knowledge that, but for the patent license, your conveying the
+         covered work in a country, or your recipient's use of the covered work
+         in a country, would infringe one or more identifiable patents in that
+         country that you have reason to believe are valid.
+         
+           If, pursuant to or in connection with a single transaction or
+         arrangement, you convey, or propagate by procuring conveyance of, a
+         covered work, and grant a patent license to some of the parties
+         receiving the covered work authorizing them to use, propagate, modify
+         or convey a specific copy of the covered work, then the patent license
+         you grant is automatically extended to all recipients of the covered
+         work and works based on it.
+         
+           A patent license is "discriminatory" if it does not include within
+         the scope of its coverage, prohibits the exercise of, or is
+         conditioned on the non-exercise of one or more of the rights that are
+         specifically granted under this License.  You may not convey a covered
+         work if you are a party to an arrangement with a third party that is
+         in the business of distributing software, under which you make payment
+         to the third party based on the extent of your activity of conveying
+         the work, and under which the third party grants, to any of the
+         parties who would receive the covered work from you, a discriminatory
+         patent license (a) in connection with copies of the covered work
+         conveyed by you (or copies made from those copies), or (b) primarily
+         for and in connection with specific products or compilations that
+         contain the covered work, unless you entered into that arrangement,
+         or that patent license was granted, prior to 28 March 2007.
+         
+           Nothing in this License shall be construed as excluding or limiting
+         any implied license or other defenses to infringement that may
+         otherwise be available to you under applicable patent law.
+         
+           12. No Surrender of Others' Freedom.
+         
+           If conditions are imposed on you (whether by court order, agreement or
+         otherwise) that contradict the conditions of this License, they do not
+         excuse you from the conditions of this License.  If you cannot convey a
+         covered work so as to satisfy simultaneously your obligations under this
+         License and any other pertinent obligations, then as a consequence you may
+         not convey it at all.  For example, if you agree to terms that obligate you
+         to collect a royalty for further conveying from those to whom you convey
+         the Program, the only way you could satisfy both those terms and this
+         License would be to refrain entirely from conveying the Program.
+         
+           13. Use with the GNU Affero General Public License.
+         
+           Notwithstanding any other provision of this License, you have
+         permission to link or combine any covered work with a work licensed
+         under version 3 of the GNU Affero General Public License into a single
+         combined work, and to convey the resulting work.  The terms of this
+         License will continue to apply to the part which is the covered work,
+         but the special requirements of the GNU Affero General Public License,
+         section 13, concerning interaction through a network will apply to the
+         combination as such.
+         
+           14. Revised Versions of this License.
+         
+           The Free Software Foundation may publish revised and/or new versions of
+         the GNU General Public License from time to time.  Such new versions will
+         be similar in spirit to the present version, but may differ in detail to
+         address new problems or concerns.
+         
+           Each version is given a distinguishing version number.  If the
+         Program specifies that a certain numbered version of the GNU General
+         Public License "or any later version" applies to it, you have the
+         option of following the terms and conditions either of that numbered
+         version or of any later version published by the Free Software
+         Foundation.  If the Program does not specify a version number of the
+         GNU General Public License, you may choose any version ever published
+         by the Free Software Foundation.
+         
+           If the Program specifies that a proxy can decide which future
+         versions of the GNU General Public License can be used, that proxy's
+         public statement of acceptance of a version permanently authorizes you
+         to choose that version for the Program.
+         
+           Later license versions may give you additional or different
+         permissions.  However, no additional obligations are imposed on any
+         author or copyright holder as a result of your choosing to follow a
+         later version.
+         
+           15. Disclaimer of Warranty.
+         
+           THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+         APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+         HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+         OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+         THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+         PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+         IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+         ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+         
+           16. Limitation of Liability.
+         
+           IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+         WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+         THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+         GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+         USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+         DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+         PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+         EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+         SUCH DAMAGES.
+         
+           17. Interpretation of Sections 15 and 16.
+         
+           If the disclaimer of warranty and limitation of liability provided
+         above cannot be given local legal effect according to their terms,
+         reviewing courts shall apply local law that most closely approximates
+         an absolute waiver of all civil liability in connection with the
+         Program, unless a warranty or assumption of liability accompanies a
+         copy of the Program in return for a fee.
+         
+                              END OF TERMS AND CONDITIONS
+         
+                     How to Apply These Terms to Your New Programs
+         
+           If you develop a new program, and you want it to be of the greatest
+         possible use to the public, the best way to achieve this is to make it
+         free software which everyone can redistribute and change under these terms.
+         
+           To do so, attach the following notices to the program.  It is safest
+         to attach them to the start of each source file to most effectively
+         state the exclusion of warranty; and each file should have at least
+         the "copyright" line and a pointer to where the full notice is found.
+         
+             <one line to give the program's name and a brief idea of what it does.>
+             Copyright (C) <year>  <name of author>
+         
+             This program is free software: you can redistribute it and/or modify
+             it under the terms of the GNU General Public License as published by
+             the Free Software Foundation, either version 3 of the License, or
+             (at your option) any later version.
+         
+             This program is distributed in the hope that it will be useful,
+             but WITHOUT ANY WARRANTY; without even the implied warranty of
+             MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+             GNU General Public License for more details.
+         
+             You should have received a copy of the GNU General Public License
+             along with this program.  If not, see <http://www.gnu.org/licenses/>.
+         
+         Also add information on how to contact you by electronic and paper mail.
+         
+           If the program does terminal interaction, make it output a short
+         notice like this when it starts in an interactive mode:
+         
+             <program>  Copyright (C) <year>  <name of author>
+             This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+             This is free software, and you are welcome to redistribute it
+             under certain conditions; type `show c' for details.
+         
+         The hypothetical commands `show w' and `show c' should show the appropriate
+         parts of the General Public License.  Of course, your program's commands
+         might be different; for a GUI interface, you would use an "about box".
+         
+           You should also get your employer (if you work as a programmer) or school,
+         if any, to sign a "copyright disclaimer" for the program, if necessary.
+         For more information on this, and how to apply and follow the GNU GPL, see
+         <http://www.gnu.org/licenses/>.
+         
+           The GNU General Public License does not permit incorporating your program
+         into proprietary programs.  If your program is a subroutine library, you
+         may consider it more useful to permit linking proprietary applications with
+         the library.  If this is what you want to do, use the GNU Lesser General
+         Public License instead of this License.  But first, please read
+         <http://www.gnu.org/philosophy/why-not-lgpl.html>.
+         
+         
+         Name: libquadmath
+         Files: scipy.libs/libquadmath*.so
+         Description: dynamically linked to files compiled with gcc
+         Availability: https://gcc.gnu.org/git/?p=gcc.git;a=tree;f=libquadmath
+         License: LGPL-2.1-or-later
+         
+             GCC Quad-Precision Math Library
+             Copyright (C) 2010-2019 Free Software Foundation, Inc.
+             Written by Francois-Xavier Coudert  <fxcoudert@gcc.gnu.org>
+         
+             This file is part of the libquadmath library.
+             Libquadmath is free software; you can redistribute it and/or
+             modify it under the terms of the GNU Library General Public
+             License as published by the Free Software Foundation; either
+             version 2.1 of the License, or (at your option) any later version.
+         
+             Libquadmath is distributed in the hope that it will be useful,
+             but WITHOUT ANY WARRANTY; without even the implied warranty of
+             MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+             Lesser General Public License for more details.
+             https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html
+         
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Scientific/Engineering
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS
+Project-URL: homepage, https://scipy.org/
+Project-URL: documentation, https://docs.scipy.org/doc/scipy/
+Project-URL: source, https://github.com/scipy/scipy
+Project-URL: download, https://github.com/scipy/scipy/releases
+Project-URL: tracker, https://github.com/scipy/scipy/issues
+Requires-Python: >=3.12
+Requires-Dist: numpy<2.8,>=2.0.0
+Provides-Extra: test
+Requires-Dist: pytest>=8.0.0; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-timeout; extra == "test"
+Requires-Dist: pytest-xdist; extra == "test"
+Requires-Dist: asv; extra == "test"
+Requires-Dist: mpmath; extra == "test"
+Requires-Dist: gmpy2; extra == "test"
+Requires-Dist: threadpoolctl; extra == "test"
+Requires-Dist: scikit-umfpack; extra == "test"
+Requires-Dist: pooch; extra == "test"
+Requires-Dist: hypothesis>=6.30; extra == "test"
+Requires-Dist: array-api-strict>=2.3.1; extra == "test"
+Requires-Dist: Cython; extra == "test"
+Requires-Dist: meson; extra == "test"
+Requires-Dist: ninja; sys_platform != "emscripten" and extra == "test"
+Requires-Dist: scipy-doctest>=2.0.0; extra == "test"
+Provides-Extra: doc
+Requires-Dist: sphinx<8.2.0,>=5.0.0; extra == "doc"
+Requires-Dist: intersphinx_registry; extra == "doc"
+Requires-Dist: pydata-sphinx-theme>=0.15.2; extra == "doc"
+Requires-Dist: sphinx-copybutton; extra == "doc"
+Requires-Dist: sphinx-design>=0.4.0; extra == "doc"
+Requires-Dist: matplotlib>=3.5; extra == "doc"
+Requires-Dist: numpydoc; extra == "doc"
+Requires-Dist: jupytext; extra == "doc"
+Requires-Dist: myst-nb>=1.2.0; extra == "doc"
+Requires-Dist: pooch; extra == "doc"
+Requires-Dist: jupyterlite-sphinx>=0.19.1; extra == "doc"
+Requires-Dist: jupyterlite-pyodide-kernel; extra == "doc"
+Requires-Dist: linkify-it-py; extra == "doc"
+Requires-Dist: tabulate; extra == "doc"
+Provides-Extra: dev
+Requires-Dist: click<8.3.0; extra == "dev"
+Requires-Dist: spin; extra == "dev"
+Requires-Dist: mypy==1.19.1; extra == "dev"
+Requires-Dist: pyrefly==0.63.0; extra == "dev"
+Requires-Dist: typing_extensions; extra == "dev"
+Requires-Dist: types-psutil; extra == "dev"
+Requires-Dist: pycodestyle; extra == "dev"
+Requires-Dist: ruff>=0.12.0; extra == "dev"
+Requires-Dist: cython-lint>=0.12.2; extra == "dev"
+Description-Content-Type: text/x-rst
+
+.. image:: https://raw.githubusercontent.com/scipy/scipy/main/doc/source/_static/logo.svg
+  :target: https://scipy.org
+  :width: 110
+  :height: 110
+  :align: left
+
+.. image:: https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A
+  :target: https://numfocus.org
+
+.. image:: https://img.shields.io/pypi/dm/scipy.svg?label=Pypi%20downloads
+  :target: https://pypi.org/project/scipy/
+
+.. image:: https://img.shields.io/conda/dn/conda-forge/scipy.svg?label=Conda%20downloads
+  :target: https://anaconda.org/conda-forge/scipy
+
+.. image:: https://img.shields.io/badge/stackoverflow-Ask%20questions-blue.svg
+  :target: https://stackoverflow.com/questions/tagged/scipy
+
+.. image:: https://img.shields.io/badge/DOI-10.1038%2Fs41592--019--0686--2-blue.svg
+  :target: https://www.nature.com/articles/s41592-019-0686-2
+
+.. image:: https://insights.linuxfoundation.org/api/badge/health-score?project=scipy
+  :target: https://insights.linuxfoundation.org/project/scipy
+
+SciPy (pronounced "Sigh Pie") is an open-source software for mathematics,
+science, and engineering. It includes modules for statistics, optimization,
+integration, linear algebra, Fourier transforms, signal and image processing,
+ODE solvers, and more.
+
+- **Website:** https://scipy.org
+- **Documentation:** https://docs.scipy.org/doc/scipy/
+- **Development version of the documentation:** https://scipy.github.io/devdocs
+- **SciPy development forum:** https://discuss.scientific-python.org/c/contributor/scipy
+- **Stack Overflow:** https://stackoverflow.com/questions/tagged/scipy
+- **Source code:** https://github.com/scipy/scipy
+- **Contributing:** https://scipy.github.io/devdocs/dev/index.html
+- **Bug reports:** https://github.com/scipy/scipy/issues
+- **Code of Conduct:** https://docs.scipy.org/doc/scipy/dev/conduct/code_of_conduct.html
+- **Report a security vulnerability:** via Tidelift, as explained in
+  `our docs on Security <https://scipy.github.io/devdocs/tutorial/security.html>`__
+- **Citing in your work:** https://www.scipy.org/citing-scipy/
+
+SciPy is built to work with
+NumPy arrays, and provides many user-friendly and efficient numerical routines,
+such as routines for numerical integration and optimization. Together, they
+run on all popular operating systems, are quick to install, and are free of
+charge. NumPy and SciPy are easy to use, but powerful enough to be depended
+upon by some of the world's leading scientists and engineers. If you need to
+manipulate numbers on a computer and display or publish the results, give
+SciPy a try!
+
+For the installation instructions, see `our install
+guide <https://scipy.org/install/>`__.
+
+
+Call for Contributions
+----------------------
+
+We appreciate and welcome contributions. Small improvements or fixes are always appreciated; issues labeled as "good
+first issue" may be a good starting point. Have a look at `our contributing
+guide <https://scipy.github.io/devdocs/dev/index.html>`__.
+
+Writing code isn’t the only way to contribute to SciPy. You can also:
+
+- review pull requests
+- triage issues
+- develop tutorials, presentations, and other educational materials
+- maintain and improve `our website <https://github.com/scipy/scipy.org>`__
+- develop graphic design for our brand assets and promotional materials
+- help with outreach and onboard new contributors
+- write grant proposals and help with other fundraising efforts
+
+If you’re unsure where to start or how your skills fit in, reach out! You can
+ask on the `forum <https://discuss.scientific-python.org/c/contributor/scipy>`__
+or here, on GitHub, by leaving a comment on a relevant issue that is already
+open.
+
+If you are new to contributing to open source, `this
+guide <https://opensource.guide/how-to-contribute/>`__ helps explain why, what,
+and how to get involved.

.venv/lib/python3.12/site-packages/scipy-1.18.1.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: meson
+Root-Is-Purelib: false
+Tag: cp312-cp312-manylinux_2_27_x86_64
+Tag: cp312-cp312-manylinux_2_28_x86_64
+

.venv/lib/python3.12/site-packages/scipy-1.18.1.dist-info/sboms/auditwheel.cdx.json

@@ -0,0 +1 @@
+{"bomFormat": "CycloneDX", "specVersion": "1.4", "version": 1, "metadata": {"component": {"type": "library", "bom-ref": "pkg:pypi/scipy@1.18.1?file_name=scipy-1.18.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", "name": "scipy", "version": "1.18.1", "purl": "pkg:pypi/scipy@1.18.1?file_name=scipy-1.18.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl"}, "tools": [{"name": "auditwheel", "version": "6.7.0"}]}, "components": [{"type": "library", "bom-ref": "pkg:pypi/scipy@1.18.1?file_name=scipy-1.18.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", "name": "scipy", "version": "1.18.1", "purl": "pkg:pypi/scipy@1.18.1?file_name=scipy-1.18.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl"}, {"type": "library", "bom-ref": "pkg:rpm/almalinux/libquadmath@8.5.0-28.el8_10.alma.1#97b91febe2a1c7927c6482d6bd6567b83be3467f33c9d2764df1283f7ac9a5fa", "name": "libquadmath", "version": "8.5.0-28.el8_10.alma.1", "purl": "pkg:rpm/almalinux/libquadmath@8.5.0-28.el8_10.alma.1"}, {"type": "library", "bom-ref": "pkg:rpm/almalinux/libgfortran@8.5.0-28.el8_10.alma.1#3362720ce454cc402813e3cfe54f0eb4efaedcd690fa35129ddc4b3de40e0650", "name": "libgfortran", "version": "8.5.0-28.el8_10.alma.1", "purl": "pkg:rpm/almalinux/libgfortran@8.5.0-28.el8_10.alma.1"}], "dependencies": [{"ref": "pkg:pypi/scipy@1.18.1?file_name=scipy-1.18.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", "dependsOn": ["pkg:rpm/almalinux/libquadmath@8.5.0-28.el8_10.alma.1#97b91febe2a1c7927c6482d6bd6567b83be3467f33c9d2764df1283f7ac9a5fa", "pkg:rpm/almalinux/libgfortran@8.5.0-28.el8_10.alma.1#3362720ce454cc402813e3cfe54f0eb4efaedcd690fa35129ddc4b3de40e0650"]}, {"ref": "pkg:rpm/almalinux/libquadmath@8.5.0-28.el8_10.alma.1#97b91febe2a1c7927c6482d6bd6567b83be3467f33c9d2764df1283f7ac9a5fa"}, {"ref": "pkg:rpm/almalinux/libgfortran@8.5.0-28.el8_10.alma.1#3362720ce454cc402813e3cfe54f0eb4efaedcd690fa35129ddc4b3de40e0650"}]}

.venv/lib/python3.12/site-packages/scipy.libs/libgfortran-040039e1-0352e75f.so.5.0.0

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

.venv/lib/python3.12/site-packages/scipy.libs/libgfortran-83c28eba.so.5.0.0

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

.venv/lib/python3.12/site-packages/scipy.libs/libquadmath-2284e583.so.0.0.0

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

.venv/lib/python3.12/site-packages/scipy.libs/libquadmath-96973f99-934c22de.so.0.0.0

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

.venv/lib/python3.12/site-packages/scipy.libs/libscipy_openblas-5f890258.so

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

.venv/lib/python3.12/site-packages/scipy/special/tests/test_ellip_harm.py

@@ -0,0 +1,288 @@
+#
+# Tests for the Ellipsoidal Harmonic Function,
+# Distributed under the same license as SciPy itself.
+#
+import warnings
+
+import numpy as np
+from numpy.testing import assert_equal, assert_allclose, assert_
+from scipy.special._testutils import assert_func_equal
+from scipy.special import ellip_harm, ellip_harm_2, ellip_normal
+from scipy.integrate import IntegrationWarning
+from numpy import sqrt, pi
+
+
+def test_ellip_potential():
+    def change_coefficient(lambda1, mu, nu, h2, k2):
+        x = sqrt(lambda1**2*mu**2*nu**2/(h2*k2))
+        y = sqrt((lambda1**2 - h2)*(mu**2 - h2)*(h2 - nu**2)/(h2*(k2 - h2)))
+        z = sqrt((lambda1**2 - k2)*(k2 - mu**2)*(k2 - nu**2)/(k2*(k2 - h2)))
+        return x, y, z
+
+    def solid_int_ellip(lambda1, mu, nu, n, p, h2, k2):
+        return (ellip_harm(h2, k2, n, p, lambda1)*ellip_harm(h2, k2, n, p, mu)
+               * ellip_harm(h2, k2, n, p, nu))
+
+    def solid_int_ellip2(lambda1, mu, nu, n, p, h2, k2):
+        return (ellip_harm_2(h2, k2, n, p, lambda1)
+                * ellip_harm(h2, k2, n, p, mu)*ellip_harm(h2, k2, n, p, nu))
+
+    def summation(lambda1, mu1, nu1, lambda2, mu2, nu2, h2, k2):
+        tol = 1e-8
+        sum1 = 0
+        for n in range(20):
+            xsum = 0
+            for p in range(1, 2*n+2):
+                xsum += (4*pi*(solid_int_ellip(lambda2, mu2, nu2, n, p, h2, k2)
+                    * solid_int_ellip2(lambda1, mu1, nu1, n, p, h2, k2)) /
+                    (ellip_normal(h2, k2, n, p)*(2*n + 1)))
+            if abs(xsum) < 0.1*tol*abs(sum1):
+                break
+            sum1 += xsum
+        return sum1, xsum
+
+    def potential(lambda1, mu1, nu1, lambda2, mu2, nu2, h2, k2):
+        x1, y1, z1 = change_coefficient(lambda1, mu1, nu1, h2, k2)
+        x2, y2, z2 = change_coefficient(lambda2, mu2, nu2, h2, k2)
+        res = sqrt((x2 - x1)**2 + (y2 - y1)**2 + (z2 - z1)**2)
+        return 1/res
+
+    pts = [
+        (120, sqrt(19), 2, 41, sqrt(17), 2, 15, 25),
+        (120, sqrt(16), 3.2, 21, sqrt(11), 2.9, 11, 20),
+       ]
+
+    with warnings.catch_warnings():
+        warnings.filterwarnings(
+            "ignore", "The occurrence of roundoff error", IntegrationWarning)
+        warnings.filterwarnings(
+            "ignore", "The maximum number of subdivisions", IntegrationWarning)
+
+        for p in pts:
+            err_msg = repr(p)
+            exact = potential(*p)
+            result, last_term = summation(*p)
+            assert_allclose(exact, result, atol=0, rtol=1e-8, err_msg=err_msg)
+            assert_(abs(result - exact) < 10*abs(last_term), err_msg)
+
+
+def test_ellip_norm():
+
+    def G01(h2, k2):
+        return 4*pi
+
+    def G11(h2, k2):
+        return 4*pi*h2*k2/3
+
+    def G12(h2, k2):
+        return 4*pi*h2*(k2 - h2)/3
+
+    def G13(h2, k2):
+        return 4*pi*k2*(k2 - h2)/3
+
+    def G22(h2, k2):
+        res = (2*(h2**4 + k2**4) - 4*h2*k2*(h2**2 + k2**2) + 6*h2**2*k2**2 +
+        sqrt(h2**2 + k2**2 - h2*k2)*(-2*(h2**3 + k2**3) + 3*h2*k2*(h2 + k2)))
+        return 16*pi/405*res
+
+    def G21(h2, k2):
+        res = (2*(h2**4 + k2**4) - 4*h2*k2*(h2**2 + k2**2) + 6*h2**2*k2**2
+        + sqrt(h2**2 + k2**2 - h2*k2)*(2*(h2**3 + k2**3) - 3*h2*k2*(h2 + k2)))
+        return 16*pi/405*res
+
+    def G23(h2, k2):
+        return 4*pi*h2**2*k2*(k2 - h2)/15
+
+    def G24(h2, k2):
+        return 4*pi*h2*k2**2*(k2 - h2)/15
+
+    def G25(h2, k2):
+        return 4*pi*h2*k2*(k2 - h2)**2/15
+
+    def G32(h2, k2):
+        res = (16*(h2**4 + k2**4) - 36*h2*k2*(h2**2 + k2**2) + 46*h2**2*k2**2
+        + sqrt(4*(h2**2 + k2**2) - 7*h2*k2)*(-8*(h2**3 + k2**3) +
+        11*h2*k2*(h2 + k2)))
+        return 16*pi/13125*k2*h2*res
+
+    def G31(h2, k2):
+        res = (16*(h2**4 + k2**4) - 36*h2*k2*(h2**2 + k2**2) + 46*h2**2*k2**2
+        + sqrt(4*(h2**2 + k2**2) - 7*h2*k2)*(8*(h2**3 + k2**3) -
+        11*h2*k2*(h2 + k2)))
+        return 16*pi/13125*h2*k2*res
+
+    def G34(h2, k2):
+        res = (6*h2**4 + 16*k2**4 - 12*h2**3*k2 - 28*h2*k2**3 + 34*h2**2*k2**2
+        + sqrt(h2**2 + 4*k2**2 - h2*k2)*(-6*h2**3 - 8*k2**3 + 9*h2**2*k2 +
+                                            13*h2*k2**2))
+        return 16*pi/13125*h2*(k2 - h2)*res
+
+    def G33(h2, k2):
+        res = (6*h2**4 + 16*k2**4 - 12*h2**3*k2 - 28*h2*k2**3 + 34*h2**2*k2**2
+        + sqrt(h2**2 + 4*k2**2 - h2*k2)*(6*h2**3 + 8*k2**3 - 9*h2**2*k2 -
+        13*h2*k2**2))
+        return 16*pi/13125*h2*(k2 - h2)*res
+
+    def G36(h2, k2):
+        res = (16*h2**4 + 6*k2**4 - 28*h2**3*k2 - 12*h2*k2**3 + 34*h2**2*k2**2
+        + sqrt(4*h2**2 + k2**2 - h2*k2)*(-8*h2**3 - 6*k2**3 + 13*h2**2*k2 +
+        9*h2*k2**2))
+        return 16*pi/13125*k2*(k2 - h2)*res
+
+    def G35(h2, k2):
+        res = (16*h2**4 + 6*k2**4 - 28*h2**3*k2 - 12*h2*k2**3 + 34*h2**2*k2**2
+        + sqrt(4*h2**2 + k2**2 - h2*k2)*(8*h2**3 + 6*k2**3 - 13*h2**2*k2 -
+        9*h2*k2**2))
+        return 16*pi/13125*k2*(k2 - h2)*res
+
+    def G37(h2, k2):
+        return 4*pi*h2**2*k2**2*(k2 - h2)**2/105
+
+    known_funcs = {(0, 1): G01, (1, 1): G11, (1, 2): G12, (1, 3): G13,
+                   (2, 1): G21, (2, 2): G22, (2, 3): G23, (2, 4): G24,
+                   (2, 5): G25, (3, 1): G31, (3, 2): G32, (3, 3): G33,
+                   (3, 4): G34, (3, 5): G35, (3, 6): G36, (3, 7): G37}
+
+    def _ellip_norm(n, p, h2, k2):
+        func = known_funcs[n, p]
+        return func(h2, k2)
+    _ellip_norm = np.vectorize(_ellip_norm)
+
+    def ellip_normal_known(h2, k2, n, p):
+        return _ellip_norm(n, p, h2, k2)
+
+    # generate both large and small h2 < k2 pairs
+    np.random.seed(1234)
+    h2 = np.random.pareto(0.5, size=1)
+    k2 = h2 * (1 + np.random.pareto(0.5, size=h2.size))
+
+    points = []
+    for n in range(4):
+        for p in range(1, 2*n+2):
+            points.append((h2, k2, np.full(h2.size, n), np.full(h2.size, p)))
+    points = np.array(points)
+    with warnings.catch_warnings():
+        warnings.filterwarnings(
+            "ignore", "The occurrence of roundoff error", IntegrationWarning)
+        assert_func_equal(ellip_normal, ellip_normal_known, points, rtol=1e-12)
+
+
+def test_ellip_harm_2():
+
+    def I1(h2, k2, s):
+        res = (ellip_harm_2(h2, k2, 1, 1, s)/(3 * ellip_harm(h2, k2, 1, 1, s))
+        + ellip_harm_2(h2, k2, 1, 2, s)/(3 * ellip_harm(h2, k2, 1, 2, s)) +
+        ellip_harm_2(h2, k2, 1, 3, s)/(3 * ellip_harm(h2, k2, 1, 3, s)))
+        return res
+
+    with warnings.catch_warnings():
+        warnings.filterwarnings(
+            "ignore", "The occurrence of roundoff error", IntegrationWarning)
+        assert_allclose(I1(5, 8, 10), 1/(10*sqrt((100-5)*(100-8))),
+                        atol=1.5e-7, rtol=0)
+
+        # Values produced by code from arXiv:1204.0267
+        assert_allclose(ellip_harm_2(5, 8, 2, 1, 10), 0.00108056853382,
+                        atol=1.5e-7, rtol=0)
+        assert_allclose(ellip_harm_2(5, 8, 2, 2, 10), 0.00105820513809,
+                        atol=1.5e-7, rtol=0)
+        assert_allclose(ellip_harm_2(5, 8, 2, 3, 10), 0.00106058384743,
+                        atol=1.5e-7, rtol=0)
+        assert_allclose(ellip_harm_2(5, 8, 2, 4, 10), 0.00106774492306,
+                        atol=1.5e-7, rtol=0)
+        assert_allclose(ellip_harm_2(5, 8, 2, 5, 10), 0.00107976356454,
+                        atol=1.5e-7, rtol=0)
+
+
+def test_ellip_harm():
+
+    def E01(h2, k2, s):
+        return 1
+
+    def E11(h2, k2, s):
+        return s
+
+    def E12(h2, k2, s):
+        return sqrt(abs(s*s - h2))
+
+    def E13(h2, k2, s):
+        return sqrt(abs(s*s - k2))
+
+    def E21(h2, k2, s):
+        return s*s - 1/3*((h2 + k2) + sqrt(abs((h2 + k2)*(h2 + k2)-3*h2*k2)))
+
+    def E22(h2, k2, s):
+        return s*s - 1/3*((h2 + k2) - sqrt(abs((h2 + k2)*(h2 + k2)-3*h2*k2)))
+
+    def E23(h2, k2, s):
+        return s * sqrt(abs(s*s - h2))
+
+    def E24(h2, k2, s):
+        return s * sqrt(abs(s*s - k2))
+
+    def E25(h2, k2, s):
+        return sqrt(abs((s*s - h2)*(s*s - k2)))
+
+    def E31(h2, k2, s):
+        return s*s*s - (s/5)*(2*(h2 + k2) + sqrt(4*(h2 + k2)*(h2 + k2) -
+        15*h2*k2))
+
+    def E32(h2, k2, s):
+        return s*s*s - (s/5)*(2*(h2 + k2) - sqrt(4*(h2 + k2)*(h2 + k2) -
+        15*h2*k2))
+
+    def E33(h2, k2, s):
+        return sqrt(abs(s*s - h2))*(s*s - 1/5*((h2 + 2*k2) + sqrt(abs((h2 +
+        2*k2)*(h2 + 2*k2) - 5*h2*k2))))
+
+    def E34(h2, k2, s):
+        return sqrt(abs(s*s - h2))*(s*s - 1/5*((h2 + 2*k2) - sqrt(abs((h2 +
+        2*k2)*(h2 + 2*k2) - 5*h2*k2))))
+
+    def E35(h2, k2, s):
+        return sqrt(abs(s*s - k2))*(s*s - 1/5*((2*h2 + k2) + sqrt(abs((2*h2
+        + k2)*(2*h2 + k2) - 5*h2*k2))))
+
+    def E36(h2, k2, s):
+        return sqrt(abs(s*s - k2))*(s*s - 1/5*((2*h2 + k2) - sqrt(abs((2*h2
+        + k2)*(2*h2 + k2) - 5*h2*k2))))
+
+    def E37(h2, k2, s):
+        return s * sqrt(abs((s*s - h2)*(s*s - k2)))
+
+    assert_equal(ellip_harm(5, 8, 1, 2, 2.5, 1, 1),
+    ellip_harm(5, 8, 1, 2, 2.5))
+
+    known_funcs = {(0, 1): E01, (1, 1): E11, (1, 2): E12, (1, 3): E13,
+                   (2, 1): E21, (2, 2): E22, (2, 3): E23, (2, 4): E24,
+                   (2, 5): E25, (3, 1): E31, (3, 2): E32, (3, 3): E33,
+                   (3, 4): E34, (3, 5): E35, (3, 6): E36, (3, 7): E37}
+
+    point_ref = []
+
+    def ellip_harm_known(h2, k2, n, p, s):
+        for i in range(h2.size):
+            func = known_funcs[(int(n[i]), int(p[i]))]
+            point_ref.append(func(h2[i], k2[i], s[i]))
+        return point_ref
+
+    rng = np.random.RandomState(1234)
+    h2 = rng.pareto(0.5, size=30)
+    k2 = h2*(1 + rng.pareto(0.5, size=h2.size))
+    s = rng.pareto(0.5, size=h2.size)
+    points = []
+    for i in range(h2.size):
+        for n in range(4):
+            for p in range(1, 2*n+2):
+                points.append((h2[i], k2[i], n, p, s[i]))
+    points = np.array(points)
+    assert_func_equal(ellip_harm, ellip_harm_known, points, rtol=1e-12)
+
+
+def test_ellip_harm_invalid_p():
+    # Regression test. This should return nan.
+    n = 4
+    # Make p > 2*n + 1.
+    p = 2*n + 2
+    result = ellip_harm(0.5, 2.0, n, p, 0.2)
+    assert np.isnan(result)

.venv/lib/python3.12/site-packages/scipy/special/tests/test_erfinv.py

@@ -0,0 +1,89 @@
+import numpy as np
+from numpy.testing import assert_allclose, assert_equal
+import pytest
+
+import scipy.special as sc
+
+
+class TestInverseErrorFunction:
+    def test_compliment(self):
+        # Test erfcinv(1 - x) == erfinv(x)
+        x = np.linspace(-1, 1, 101)
+        assert_allclose(sc.erfcinv(1 - x), sc.erfinv(x), rtol=0, atol=1e-15)
+
+    def test_literal_values(self):
+        # The expected values were calculated with mpmath:
+        #
+        #   import mpmath
+        #   mpmath.mp.dps = 200
+        #   for y in [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]:
+        #       x = mpmath.erfinv(y)
+        #       print(x)
+        #
+        y = np.array([0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])
+        actual = sc.erfinv(y)
+        expected = [
+            0.0,
+            0.08885599049425769,
+            0.1791434546212917,
+            0.2724627147267543,
+            0.37080715859355795,
+            0.4769362762044699,
+            0.5951160814499948,
+            0.7328690779592167,
+            0.9061938024368233,
+            1.1630871536766743,
+        ]
+        assert_allclose(actual, expected, rtol=0, atol=1e-15)
+
+    @pytest.mark.parametrize(
+        'f, x, y',
+        [
+            (sc.erfinv, -1, -np.inf),
+            (sc.erfinv, 0, 0),
+            (sc.erfinv, 1, np.inf),
+            (sc.erfinv, -100, np.nan),
+            (sc.erfinv, 100, np.nan),
+            (sc.erfcinv, 0, np.inf),
+            (sc.erfcinv, 1, -0.0),
+            (sc.erfcinv, 2, -np.inf),
+            (sc.erfcinv, -100, np.nan),
+            (sc.erfcinv, 100, np.nan),
+        ],
+        ids=[
+            'erfinv at lower bound',
+            'erfinv at midpoint',
+            'erfinv at upper bound',
+            'erfinv below lower bound',
+            'erfinv above upper bound',
+            'erfcinv at lower bound',
+            'erfcinv at midpoint',
+            'erfcinv at upper bound',
+            'erfcinv below lower bound',
+            'erfcinv above upper bound',
+        ]
+    )
+    def test_domain_bounds(self, f, x, y):
+        assert_equal(f(x), y)
+
+    def test_erfinv_asympt(self):
+        # regression test for gh-12758: erfinv(x) loses precision at small x
+        # expected values precomputed with mpmath:
+        # >>> mpmath.mp.dps = 100
+        # >>> expected = [float(mpmath.erfinv(t)) for t in x]
+        x = np.array([1e-20, 1e-15, 1e-14, 1e-10, 1e-8, 0.9e-7, 1.1e-7, 1e-6])
+        expected = np.array([8.86226925452758e-21,
+                             8.862269254527581e-16,
+                             8.86226925452758e-15,
+                             8.862269254527581e-11,
+                             8.86226925452758e-09,
+                             7.97604232907484e-08,
+                             9.74849617998037e-08,
+                             8.8622692545299e-07])
+        assert_allclose(sc.erfinv(x), expected,
+                        rtol=1e-15)
+
+        # also test the roundtrip consistency
+        assert_allclose(sc.erf(sc.erfinv(x)),
+                        x,
+                        rtol=5e-15)

.venv/lib/python3.12/site-packages/scipy/special/tests/test_exponential_integrals.py

@@ -0,0 +1,123 @@
+import pytest
+
+import numpy as np
+from numpy.testing import assert_allclose
+import scipy.special as sc
+
+
+class TestExp1:
+
+    def test_branch_cut(self):
+        assert np.isnan(sc.exp1(-1))
+        assert sc.exp1(complex(-1, 0)).imag == (
+            -sc.exp1(complex(-1, -0.0)).imag
+        )
+
+        assert_allclose(
+            sc.exp1(complex(-1, 0)),
+            sc.exp1(-1 + 1e-20j),
+            atol=0,
+            rtol=1e-15
+        )
+        assert_allclose(
+            sc.exp1(complex(-1, -0.0)),
+            sc.exp1(-1 - 1e-20j),
+            atol=0,
+            rtol=1e-15
+        )
+
+    def test_834(self):
+        # Regression test for #834
+        a = sc.exp1(-complex(19.9999990))
+        b = sc.exp1(-complex(19.9999991))
+        assert_allclose(a.imag, b.imag, atol=0, rtol=1e-15)
+
+
+class TestScaledExp1:
+
+    @pytest.mark.parametrize('x, expected', [(0, 0), (np.inf, 1)])
+    def test_limits(self, x, expected):
+        y = sc._ufuncs._scaled_exp1(x)
+        assert y == expected
+
+    # The expected values were computed with mpmath, e.g.:
+    #
+    #   from mpmath import mp
+    #   mp.dps = 80
+    #   x = 1e-25
+    #   print(float(x*mp.exp(x)*np.expint(1, x)))
+    #
+    # prints 5.698741165994961e-24
+    #
+    # The method used to compute _scaled_exp1 changes at x=1
+    # and x=1250, so values at those inputs, and values just
+    # above and below them, are included in the test data.
+    @pytest.mark.parametrize('x, expected',
+                             [(1e-25, 5.698741165994961e-24),
+                              (0.1, 0.20146425447084518),
+                              (0.9995, 0.5962509885831002),
+                              (1.0, 0.5963473623231941),
+                              (1.0005, 0.5964436833238044),
+                              (2.5, 0.7588145912149602),
+                              (10.0, 0.9156333393978808),
+                              (100.0, 0.9901942286733019),
+                              (500.0, 0.9980079523802055),
+                              (1000.0, 0.9990019940238807),
+                              (1249.5, 0.9992009578306811),
+                              (1250.0, 0.9992012769377913),
+                              (1250.25, 0.9992014363957858),
+                              (2000.0, 0.9995004992514963),
+                              (1e4, 0.9999000199940024),
+                              (1e10, 0.9999999999),
+                              (1e15, 0.999999999999999),
+                              ])
+    def test_scaled_exp1(self, x, expected):
+        y = sc._ufuncs._scaled_exp1(x)
+        assert_allclose(y, expected, rtol=2e-15)
+
+
+class TestExpi:
+
+    @pytest.mark.parametrize('result', [
+        sc.expi(complex(-1, 0)),
+        sc.expi(complex(-1, -0.0)),
+        sc.expi(-1)
+    ])
+    def test_branch_cut(self, result):
+        desired = -0.21938393439552027368  # Computed using Mpmath
+        assert_allclose(result, desired, atol=0, rtol=1e-14)
+
+    def test_near_branch_cut(self):
+        lim_from_above = sc.expi(-1 + 1e-20j)
+        lim_from_below = sc.expi(-1 - 1e-20j)
+        assert_allclose(
+            lim_from_above.real,
+            lim_from_below.real,
+            atol=0,
+            rtol=1e-15
+        )
+        assert_allclose(
+            lim_from_above.imag,
+            -lim_from_below.imag,
+            atol=0,
+            rtol=1e-15
+        )
+
+    def test_continuity_on_positive_real_axis(self):
+        assert_allclose(
+            sc.expi(complex(1, 0)),
+            sc.expi(complex(1, -0.0)),
+            atol=0,
+            rtol=1e-15
+        )
+    
+    @pytest.mark.parametrize('x, expected', [(0, -np.inf), (np.inf, np.inf)]) 
+    def test_limits(self, x, expected):
+        y = sc.expi(x)
+        assert y == expected
+
+
+class TestExpn:
+
+    def test_out_of_domain(self):
+        assert all(np.isnan([sc.expn(-1, 1.0), sc.expn(1, -1.0)]))

.venv/lib/python3.12/site-packages/scipy/special/tests/test_extending.py

@@ -0,0 +1,28 @@
+import os
+import platform
+import sysconfig
+
+import pytest
+
+from scipy._lib._testutils import IS_EDITABLE,_test_cython_extension, cython
+from scipy.special import beta, gamma
+
+
+@pytest.mark.fail_slow(40)
+# essential per https://github.com/scipy/scipy/pull/20487#discussion_r1567057247
+@pytest.mark.skipif(IS_EDITABLE,
+                    reason='Editable install cannot find .pxd headers.')
+@pytest.mark.skipif((platform.system() == 'Windows' and
+                     sysconfig.get_config_var('Py_GIL_DISABLED')),
+                    reason='gh-22039')
+@pytest.mark.skipif(platform.machine() in ["wasm32", "wasm64"],
+                    reason="Can't start subprocess")
+@pytest.mark.skipif(cython is None, reason="requires cython")
+def test_cython(tmp_path):
+    srcdir = os.path.dirname(os.path.dirname(__file__))
+    extensions, extensions_cpp = _test_cython_extension(tmp_path, srcdir)
+    # actually test the cython c-extensions
+    assert extensions.cy_beta(0.5, 0.1) == beta(0.5, 0.1)
+    assert extensions.cy_gamma(0.5 + 1.0j) == gamma(0.5 + 1.0j)
+    assert extensions_cpp.cy_beta(0.5, 0.1) == beta(0.5, 0.1)
+    assert extensions_cpp.cy_gamma(0.5 + 1.0j) == gamma(0.5 + 1.0j)

.venv/lib/python3.12/site-packages/scipy/special/tests/test_faddeeva.py

@@ -0,0 +1,85 @@
+import pytest
+
+import numpy as np
+from numpy.testing import assert_allclose
+import scipy.special as sc
+from scipy.special._testutils import FuncData
+
+
+class TestVoigtProfile:
+
+    @pytest.mark.parametrize('x, sigma, gamma', [
+        (np.nan, 1, 1),
+        (0, np.nan, 1),
+        (0, 1, np.nan),
+        (1, np.nan, 0),
+        (np.nan, 1, 0),
+        (1, 0, np.nan),
+        (np.nan, 0, 1),
+        (np.nan, 0, 0)
+    ])
+    def test_nan(self, x, sigma, gamma):
+        assert np.isnan(sc.voigt_profile(x, sigma, gamma))
+
+    @pytest.mark.parametrize('x, desired', [
+        (-np.inf, 0),
+        (np.inf, 0)
+    ])
+    def test_inf(self, x, desired):
+        assert sc.voigt_profile(x, 1, 1) == desired
+
+    def test_against_mathematica(self):
+        # Results obtained from Mathematica by computing
+        #
+        # PDF[VoigtDistribution[gamma, sigma], x]
+        #
+        points = np.array([
+            [-7.89, 45.06, 6.66, 0.0077921073660388806401],
+            [-0.05, 7.98, 24.13, 0.012068223646769913478],
+            [-13.98, 16.83, 42.37, 0.0062442236362132357833],
+            [-12.66, 0.21, 6.32, 0.010052516161087379402],
+            [11.34, 4.25, 21.96, 0.0113698923627278917805],
+            [-11.56, 20.40, 30.53, 0.0076332760432097464987],
+            [-9.17, 25.61, 8.32, 0.011646345779083005429],
+            [16.59, 18.05, 2.50, 0.013637768837526809181],
+            [9.11, 2.12, 39.33, 0.0076644040807277677585],
+            [-43.33, 0.30, 45.68, 0.0036680463875330150996]
+        ])
+        FuncData(
+            sc.voigt_profile,
+            points,
+            (0, 1, 2),
+            3,
+            atol=0,
+            rtol=1e-15
+        ).check()
+
+    def test_symmetry(self):
+        x = np.linspace(0, 10, 20)
+        assert_allclose(
+            sc.voigt_profile(x, 1, 1),
+            sc.voigt_profile(-x, 1, 1),
+            rtol=1e-15,
+            atol=0
+        )
+
+    @pytest.mark.parametrize('x, sigma, gamma, desired', [
+        (0, 0, 0, np.inf),
+        (1, 0, 0, 0)
+    ])
+    def test_corner_cases(self, x, sigma, gamma, desired):
+        assert sc.voigt_profile(x, sigma, gamma) == desired
+
+    @pytest.mark.parametrize('sigma1, gamma1, sigma2, gamma2', [
+        (0, 1, 1e-16, 1),
+        (1, 0, 1, 1e-16),
+        (0, 0, 1e-16, 1e-16)
+    ])
+    def test_continuity(self, sigma1, gamma1, sigma2, gamma2):
+        x = np.linspace(1, 10, 20)
+        assert_allclose(
+            sc.voigt_profile(x, sigma1, gamma1),
+            sc.voigt_profile(x, sigma2, gamma2),
+            rtol=1e-16,
+            atol=1e-16
+        )

.venv/lib/python3.12/site-packages/scipy/special/tests/test_gamma.py

@@ -0,0 +1,12 @@
+import numpy as np
+import scipy.special as sc
+
+
+class TestRgamma:
+
+    def test_gh_11315(self):
+        assert sc.rgamma(-35) == 0
+
+    def test_rgamma_zeros(self):
+        x = np.array([0, -10, -100, -1000, -10000])
+        assert np.all(sc.rgamma(x) == 0)

.venv/lib/python3.12/site-packages/scipy/special/tests/test_gammainc.py

@@ -0,0 +1,152 @@
+import pytest
+
+import numpy as np
+from numpy.testing import assert_allclose, assert_array_equal
+
+import scipy.special as sc
+from scipy.special._testutils import FuncData
+
+
+INVALID_POINTS = [
+    (1, -1),
+    (0, 0),
+    (-1, 1),
+    (np.nan, 1),
+    (1, np.nan)
+]
+
+
+class TestGammainc:
+
+    @pytest.mark.parametrize('a, x', INVALID_POINTS)
+    def test_domain(self, a, x):
+        assert np.isnan(sc.gammainc(a, x))
+
+    def test_a_eq_0_x_gt_0(self):
+        assert sc.gammainc(0, 1) == 1
+
+    @pytest.mark.parametrize('a, x, desired', [
+        (np.inf, 1, 0),
+        (np.inf, 0, 0),
+        (np.inf, np.inf, np.nan),
+        (1, np.inf, 1)
+    ])
+    def test_infinite_arguments(self, a, x, desired):
+        result = sc.gammainc(a, x)
+        if np.isnan(desired):
+            assert np.isnan(result)
+        else:
+            assert result == desired
+
+    @pytest.mark.parametrize("x", [-np.inf, -1.0, -0.0, 0.0, np.inf, np.nan])
+    def test_a_nan(self, x):
+        assert np.isnan(sc.gammainc(np.nan, x))
+
+    @pytest.mark.parametrize("a", [-np.inf, -1.0, -0.0, 0.0, np.inf, np.nan])
+    def test_x_nan(self, a):
+        assert np.isnan(sc.gammainc(a, np.nan))
+
+    def test_infinite_limits(self):
+        # Test that large arguments converge to the hard-coded limits
+        # at infinity.
+        assert_allclose(
+            sc.gammainc(1000, 100),
+            sc.gammainc(np.inf, 100),
+            atol=1e-200,  # Use `atol` since the function converges to 0.
+            rtol=0
+        )
+        assert sc.gammainc(100, 1000) == sc.gammainc(100, np.inf)
+
+    def test_x_zero(self):
+        a = np.arange(1, 10)
+        assert_array_equal(sc.gammainc(a, 0), 0)
+
+    def test_limit_check(self):
+        result = sc.gammainc(1e-10, 1)
+        limit = sc.gammainc(0, 1)
+        assert np.isclose(result, limit)
+
+    def gammainc_line(self, x):
+        # The line a = x where a simpler asymptotic expansion (analog
+        # of DLMF 8.12.15) is available.
+        c = np.array([-1/3, -1/540, 25/6048, 101/155520,
+                      -3184811/3695155200, -2745493/8151736420])
+        res = 0
+        xfac = 1
+        for ck in c:
+            res -= ck*xfac
+            xfac /= x
+        res /= np.sqrt(2*np.pi*x)
+        res += 0.5
+        return res
+
+    def test_line(self):
+        x = np.logspace(np.log10(25), 300, 500)
+        a = x
+        dataset = np.vstack((a, x, self.gammainc_line(x))).T
+        FuncData(sc.gammainc, dataset, (0, 1), 2, rtol=1e-11).check()
+
+    def test_roundtrip(self):
+        a = np.logspace(-5, 10, 100)
+        x = np.logspace(-5, 10, 100)
+
+        y = sc.gammaincinv(a, sc.gammainc(a, x))
+        assert_allclose(x, y, rtol=1e-10)
+
+
+class TestGammaincc:
+
+    @pytest.mark.parametrize('a, x', INVALID_POINTS)
+    def test_domain(self, a, x):
+        assert np.isnan(sc.gammaincc(a, x))
+
+    def test_a_eq_0_x_gt_0(self):
+        assert sc.gammaincc(0, 1) == 0
+
+    @pytest.mark.parametrize('a, x, desired', [
+        (np.inf, 1, 1),
+        (np.inf, 0, 1),
+        (np.inf, np.inf, np.nan),
+        (1, np.inf, 0)
+    ])
+    def test_infinite_arguments(self, a, x, desired):
+        result = sc.gammaincc(a, x)
+        if np.isnan(desired):
+            assert np.isnan(result)
+        else:
+            assert result == desired
+
+    @pytest.mark.parametrize("x", [-np.inf, -1.0, -0.0, 0.0, np.inf, np.nan])
+    def test_a_nan(self, x):
+        assert np.isnan(sc.gammaincc(np.nan, x))
+
+    @pytest.mark.parametrize("a", [-np.inf, -1.0, -0.0, 0.0, np.inf, np.nan])
+    def test_x_nan(self, a):
+        assert np.isnan(sc.gammaincc(a, np.nan))
+
+    def test_infinite_limits(self):
+        # Test that large arguments converge to the hard-coded limits
+        # at infinity.
+        assert sc.gammaincc(1000, 100) == sc.gammaincc(np.inf, 100)
+        assert_allclose(
+            sc.gammaincc(100, 1000),
+            sc.gammaincc(100, np.inf),
+            atol=1e-200,  # Use `atol` since the function converges to 0.
+            rtol=0
+        )
+
+    def test_limit_check(self):
+        result = sc.gammaincc(1e-10,1)
+        limit = sc.gammaincc(0,1)
+        assert np.isclose(result, limit)
+
+    def test_x_zero(self):
+        a = np.arange(1, 10)
+        assert_array_equal(sc.gammaincc(a, 0), 1)
+
+    def test_roundtrip(self):
+        a = np.logspace(-5, 10, 100)
+        x = np.logspace(-5, 10, 100)
+
+        y = sc.gammainccinv(a, sc.gammaincc(a, x))
+        assert_allclose(x, y, rtol=1e-14)

.venv/lib/python3.12/site-packages/scipy/special/tests/test_gen_harmonic.py

@@ -0,0 +1,99 @@
+import numpy as np
+from numpy.testing import assert_allclose, assert_equal
+import pytest
+from scipy.special._ufuncs import _gen_harmonic, _normalized_gen_harmonic
+
+
+#
+# In the following tests, reference values were computed with mpmath.
+#
+
+@pytest.mark.parametrize('typ', [np.int32, np.int64, np.float64])
+@pytest.mark.parametrize(
+    'n, a, ref',
+    [(8, 9.0, 1.0020083884212339),
+     (1000, 2.5, 1.3414661912046497),
+     (10, 1.5, 1.9953364933456017),
+     (10000, 1.25, 4.1951168257387765),
+     (10000,1.00001, 9.787182620770265),
+     (80, 1.000002, 4.965460167788836),
+     (75, 1 + 1e-12, 4.901355630543771),
+     (100, 1 + 1e-14, 5.187377517639515),
+     (100, 1 + 8e-16, 5.187377517639611),
+     (100, 1.0, 5.187377517639621),
+     (7, 1.0, 2.592857142857143),
+     (8000, 1.0, 9.564474984261423),
+     (5, 1 - 1e-12, 2.2833333333347143),
+     (25000, 1 - 1e-12, 10.703866768669737),
+     (1000, 0.995, 7.6058022857089975),
+     (1000, 0.75, 19.055178975831392),
+     (10000, 0.25, 1332.5700547197382),
+     (5, 1e-8, 4.999999952125083),
+     (15, 1e-16, 14.999999999999996),
+     (100, 0.0, 100.0),
+     (4, -1.0, 10.0),
+     (75, -1.5, 19811.38815892374)]
+)
+def test_gen_harmonic(typ, n, a, ref):
+    h = _gen_harmonic(typ(n), a)
+    assert_allclose(h, ref, rtol=5e-15)
+
+
+@pytest.mark.parametrize('typ', [np.int32, np.int64, np.float64])
+@pytest.mark.parametrize(
+    'n, a, ref',
+    [(10, np.inf, 1.0),
+     (1, np.nan, 1.0),
+     (1, -np.inf, 1.0),
+     (3, np.nan, np.nan),
+     (-3, 1.0, np.nan)]
+)
+def test_gen_harmonic_exact_cases(typ, n, a, ref):
+    h = _gen_harmonic(typ(n), a)
+    assert_equal(h, ref)
+
+
+def test_gen_harmonic_n_nan():
+    h = _gen_harmonic(np.nan, 0.75)
+    assert_equal(h, np.nan)
+
+
+@pytest.mark.parametrize('typ', [np.int32, np.int64, np.float64])
+@pytest.mark.parametrize(
+    'j, k, n, a, ref',
+    [(400, 5000, 5000, 10.0, 4.2821759663214485e-25),
+     (400, 5000, 5000, 3.5, 1.11086549102426e-07),
+     (1, 2, 3, 1.5, 0.8755176866163012),
+     (300, 500, 500, 1 + 1e-14, 0.07559343891632035),
+     (1500, 2500, 3000, 1 - 1e-12, 0.05957291246371843),
+     (10, 12, 16, 0.5, 0.13601665344521513),
+     (16, 16, 20, 0.125, 0.04583107002260924),
+     (10, 12, 16, -0.5, 0.22359306724308234),
+     (1, 8000, 10000, -1.5, 0.5724512895513029)]
+)
+def test_normalized_gen_harmonic(typ, j, k, n, a, ref):
+    h = _normalized_gen_harmonic(typ(j), typ(k), typ(n), a)
+    assert_allclose(h, ref, 5e-15)
+
+
+@pytest.mark.parametrize('typ', [np.int32, np.int64, np.float64])
+@pytest.mark.parametrize(
+    'j, k, n, a, ref',
+    [(1, 1, 1, 0.5, 1.0),
+     (1, 1, 1, np.nan, 1.0),
+     (1, 2, 5, np.nan, np.nan),
+     (1, 2, 1, 1.25, np.nan),
+     (1, 2, 3, np.inf, 1.0),
+     (2, 3, 4, np.inf, 0.0),
+     (1, 1, 10, -np.inf, 0.0),
+     (2, 3, 4, -np.inf, np.nan),
+     (3, 6, 8, 0.0, 0.5)]
+)
+def test_normalized_gen_harmonic_exact_cases(typ, j, k, n, a, ref):
+    h = _normalized_gen_harmonic(typ(j), typ(k), typ(n), a)
+    assert_equal(h, ref)
+
+
+def test_normalized_gen_harmonic_input_nan():
+    h = _normalized_gen_harmonic(1.0, np.nan, 10.0, 1.05)
+    assert_equal(h, np.nan)

.venv/lib/python3.12/site-packages/scipy/special/tests/test_hyp2f1.py

@@ -0,0 +1,2566 @@
+"""Tests for hyp2f1 for complex values.
+
+Author: Albert Steppi, with credit to Adam Kullberg (FormerPhycisist) for
+the implementation of mp_hyp2f1 below, which modifies mpmath's hyp2f1 to
+return the same branch as scipy's on the standard branch cut.
+"""
+
+import sys
+import pytest
+import numpy as np
+from typing import NamedTuple
+from numpy.testing import assert_allclose
+
+from scipy.special import hyp2f1
+from scipy.special._testutils import check_version, MissingModule
+
+
+try:
+    import mpmath
+except ImportError:
+    mpmath = MissingModule("mpmath")
+
+
+def mp_hyp2f1(a, b, c, z):
+    """Return mpmath hyp2f1 calculated on same branch as scipy hyp2f1.
+
+    For most values of a,b,c mpmath returns the x - 0j branch of hyp2f1 on the
+    branch cut x=(1,inf) whereas scipy's hyp2f1 calculates the x + 0j branch.
+    Thus, to generate the right comparison values on the branch cut, we
+    evaluate mpmath.hyp2f1 at x + 1e-15*j.
+
+    The exception to this occurs when c-a=-m in which case both mpmath and
+    scipy calculate the x + 0j branch on the branch cut. When this happens
+    mpmath.hyp2f1 will be evaluated at the original z point.
+    """
+    on_branch_cut = z.real > 1.0 and abs(z.imag) < 1.0e-15
+    cond1 = abs(c - a - round(c - a)) < 1.0e-15 and round(c - a) <= 0
+    cond2 = abs(c - b - round(c - b)) < 1.0e-15 and round(c - b) <= 0
+    # Make sure imaginary part is *exactly* zero
+    if on_branch_cut:
+        z = z.real + 0.0j
+    if on_branch_cut and not (cond1 or cond2):
+        z_mpmath = z.real + 1.0e-15j
+    else:
+        z_mpmath = z
+    return complex(mpmath.hyp2f1(a, b, c, z_mpmath))
+
+
+class Hyp2f1TestCase(NamedTuple):
+    a: float
+    b: float
+    c: float
+    z: complex
+    expected: complex
+    rtol: float
+
+
+class TestHyp2f1:
+    """Tests for hyp2f1 for complex values.
+
+    Expected values for test cases were computed using mpmath. See
+    `scipy.special._precompute.hyp2f1_data`. The verbose style of specifying
+    test cases is used for readability and to make it easier to mark individual
+    cases as expected to fail. Expected failures are used to highlight cases
+    where improvements are needed. See
+    `scipy.special._precompute.hyp2f1_data.make_hyp2f1_test_cases` for a
+    function to generate the boilerplate for the test cases.
+
+    Assertions have been added to each test to ensure that the test cases match
+    the situations that are intended. A final test `test_test_hyp2f1` checks
+    that the expected values in the test cases actually match what is computed
+    by mpmath. This test is marked slow even though it isn't particularly slow
+    so that it won't run by default on continuous integration builds.
+    """
+    @pytest.mark.parametrize(
+        "hyp2f1_test_case",
+        [
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=0.5,
+                    b=0.2,
+                    c=-10,
+                    z=0.2 + 0.2j,
+                    expected=np.inf + 0j,
+                    rtol=0
+                )
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=0.5,
+                    b=0.2,
+                    c=-10,
+                    z=0 + 0j,
+                    expected=1 + 0j,
+                    rtol=0
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=0.5,
+                    b=0,
+                    c=-10,
+                    z=0.2 + 0.2j,
+                    expected=1 + 0j,
+                    rtol=0
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=0.5,
+                    b=0,
+                    c=0,
+                    z=0.2 + 0.2j,
+                    expected=1 + 0j,
+                    rtol=0,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=0.5,
+                    b=0.2,
+                    c=0,
+                    z=0.2 + 0.2j,
+                    expected=np.inf + 0j,
+                    rtol=0,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=0.5,
+                    b=0.2,
+                    c=0,
+                    z=0 + 0j,
+                    expected=np.nan + 0j,
+                    rtol=0,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=0.5,
+                    b=-5,
+                    c=-10,
+                    z=0.2 + 0.2j,
+                    expected=(1.0495404166666666+0.05708208333333334j),
+                    rtol=1e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=0.5,
+                    b=-10,
+                    c=-10,
+                    z=0.2 + 0.2j,
+                    expected=(1.092966013125+0.13455014673750001j),
+                    rtol=1e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-10,
+                    b=-20,
+                    c=-10,
+                    z=0.2 + 0.2j,
+                    expected=(-0.07712512000000005+0.12752814080000005j),
+                    rtol=1e-13,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-1,
+                    b=3.2,
+                    c=-1,
+                    z=0.2 + 0.2j,
+                    expected=(1.6400000000000001+0.6400000000000001j),
+                    rtol=1e-13,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-2,
+                    b=1.2,
+                    c=-4,
+                    z=1 + 0j,
+                    expected=1.8200000000000001 + 0j,
+                    rtol=1e-15,
+                ),
+            ),
+        ]
+    )
+    def test_c_non_positive_int(self, hyp2f1_test_case):
+        a, b, c, z, expected, rtol = hyp2f1_test_case
+        assert_allclose(hyp2f1(a, b, c, z), expected, rtol=rtol)
+
+    @pytest.mark.parametrize(
+        "hyp2f1_test_case",
+        [
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=0.5,
+                    b=0.2,
+                    c=1.5,
+                    z=1 + 0j,
+                    expected=1.1496439092239847 + 0j,
+                    rtol=1e-15
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=12.3,
+                    b=8.0,
+                    c=20.31,
+                    z=1 + 0j,
+                    expected=69280986.75273195 + 0j,
+                    rtol=1e-15
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=290.2,
+                    b=321.5,
+                    c=700.1,
+                    z=1 + 0j,
+                    expected=1.3396562400934e117 + 0j,
+                    rtol=1e-12,
+                ),
+            ),
+            # Note that here even mpmath produces different results for
+            # results that should be equivalent.
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=9.2,
+                    b=621.5,
+                    c=700.1,
+                    z=(1+0j),
+                    expected=(952726652.4158565+0j),
+                    rtol=5e-13,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=621.5,
+                    b=9.2,
+                    c=700.1,
+                    z=(1+0j),
+                    expected=(952726652.4160284+0j),
+                    rtol=5e-12,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-101.2,
+                    b=-400.4,
+                    c=-172.1,
+                    z=(1+0j),
+                    expected=(2.2253618341394838e+37+0j),
+                    rtol=1e-13,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-400.4,
+                    b=-101.2,
+                    c=-172.1,
+                    z=(1+0j),
+                    expected=(2.2253618341394838e+37+0j),
+                    rtol=5e-13,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=172.5,
+                    b=-201.3,
+                    c=151.2,
+                    z=(1+0j),
+                    expected=(7.072266653650905e-135+0j),
+                    rtol=5e-13,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-201.3,
+                    b=172.5,
+                    c=151.2,
+                    z=(1+0j),
+                    expected=(7.072266653650905e-135+0j),
+                    rtol=5e-13,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-102.1,
+                    b=-20.3,
+                    c=1.3,
+                    z=1 + 0j,
+                    expected=2.7899070752746906e22 + 0j,
+                    rtol=3e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-202.6,
+                    b=60.3,
+                    c=1.5,
+                    z=1 + 0j,
+                    expected=-1.3113641413099326e-56 + 0j,
+                    rtol=1e-12,
+                ),
+            ),
+        ],
+    )
+    def test_unital_argument(self, hyp2f1_test_case):
+        """Tests for case z = 1, c - a - b > 0.
+
+        Expected answers computed using mpmath.
+        """
+        a, b, c, z, expected, rtol = hyp2f1_test_case
+        assert z == 1 and c - a - b > 0  # Tests the test
+        assert_allclose(hyp2f1(a, b, c, z), expected, rtol=rtol)
+
+    @pytest.mark.parametrize(
+        "hyp2f1_test_case",
+        [
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=0.5,
+                    b=0.2,
+                    c=1.3,
+                    z=-1 + 0j,
+                    expected=0.9428846409614143 + 0j,
+                    rtol=1e-15),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=12.3,
+                    b=8.0,
+                    c=5.300000000000001,
+                    z=-1 + 0j,
+                    expected=-4.845809986595704e-06 + 0j,
+                    rtol=1e-15
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=221.5,
+                    b=90.2,
+                    c=132.3,
+                    z=-1 + 0j,
+                    expected=2.0490488728377282e-42 + 0j,
+                    rtol=1e-7,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-102.1,
+                    b=-20.3,
+                    c=-80.8,
+                    z=-1 + 0j,
+                    expected=45143784.46783885 + 0j,
+                    rtol=1e-7,
+                ),
+                marks=pytest.mark.xfail(
+                    condition=sys.maxsize < 2**32,
+                    reason="Fails on 32 bit.",
+                )
+            ),
+        ],
+    )
+    def test_special_case_z_near_minus_1(self, hyp2f1_test_case):
+        """Tests for case z ~ -1, c ~ 1 + a - b
+
+        Expected answers computed using mpmath.
+        """
+        a, b, c, z, expected, rtol = hyp2f1_test_case
+        assert abs(1 + a - b - c) < 1e-15 and abs(z + 1) < 1e-15
+        assert_allclose(hyp2f1(a, b, c, z), expected, rtol=rtol)
+
+    @pytest.mark.parametrize(
+        "hyp2f1_test_case",
+        [
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-4,
+                    b=2.02764642551431,
+                    c=1.0561196186065624,
+                    z=(0.9473684210526314-0.10526315789473695j),
+                    expected=(0.0031961077109535375-0.0011313924606557173j),
+                    rtol=1e-12,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-8,
+                    b=-7.937789122896016,
+                    c=-15.964218273004214,
+                    z=(2-0.10526315789473695j),
+                    expected=(0.005543763196412503-0.0025948879065698306j),
+                    rtol=5e-13,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-8,
+                    b=8.095813935368371,
+                    c=4.0013768449590685,
+                    z=(0.9473684210526314-0.10526315789473695j),
+                    expected=(-0.0003054674127221263-9.261359291755414e-05j),
+                    rtol=1e-10,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-4,
+                    b=-3.956227226099288,
+                    c=-3.9316537064827854,
+                    z=(1.1578947368421053-0.3157894736842106j),
+                    expected=(-0.0020809502580892937-0.0041877333232365095j),
+                    rtol=5e-12,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=2.02764642551431,
+                    b=-4,
+                    c=2.050308316530781,
+                    z=(0.9473684210526314-0.10526315789473695j),
+                    expected=(0.0011282435590058734+0.0002027062303465851j),
+                    rtol=5e-13,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-7.937789122896016,
+                    b=-8,
+                    c=-15.964218273004214,
+                    z=(1.3684210526315788+0.10526315789473673j),
+                    expected=(-9.134907719238265e-05-0.00040219233987390723j),
+                    rtol=5e-12,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=4.080187217753502,
+                    b=-4,
+                    c=4.0013768449590685,
+                    z=(0.9473684210526314-0.10526315789473695j),
+                    expected=(-0.000519013062087489-0.0005855883076830948j),
+                    rtol=5e-12,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-10000,
+                    b=2.2,
+                    c=93459345.3,
+                    z=(2+2j),
+                    expected=(0.9995292071559088-0.00047047067522659253j),
+                    rtol=1e-12,
+                ),
+            ),
+        ]
+    )
+    def test_a_b_negative_int(self, hyp2f1_test_case):
+        a, b, c, z, expected, rtol = hyp2f1_test_case
+        assert a == int(a) and a < 0 or b == int(b) and b < 0  # Tests the test
+        assert_allclose(hyp2f1(a, b, c, z), expected, rtol=rtol)
+
+    @pytest.mark.parametrize(
+        "hyp2f1_test_case",
+        [
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-0.5,
+                    b=-0.9629749245209605,
+                    c=-15.5,
+                    z=(1.1578947368421053-1.1578947368421053j),
+                    expected=(0.9778506962676361+0.044083801141231616j),
+                    rtol=3e-12,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=8.5,
+                    b=-3.9316537064827854,
+                    c=1.5,
+                    z=(0.9473684210526314-0.10526315789473695j),
+                    expected=(4.0793167523167675-10.11694246310966j),
+                    rtol=6e-12,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=8.5,
+                    b=-0.9629749245209605,
+                    c=2.5,
+                    z=(1.1578947368421053-0.10526315789473695j),
+                    expected=(-2.9692999501916915+0.6394599899845594j),
+                    rtol=1e-11,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-0.5,
+                    b=-0.9629749245209605,
+                    c=-15.5,
+                    z=(1.5789473684210522-1.1578947368421053j),
+                    expected=(0.9493076367106102-0.04316852977183447j),
+                    rtol=1e-11,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-0.9220024191881196,
+                    b=-0.5,
+                    c=-15.5,
+                    z=(0.5263157894736841+0.10526315789473673j),
+                    expected=(0.9844377175631795-0.003120587561483841j),
+                    rtol=1e-10,
+                ),
+            ),
+        ],
+    )
+    def test_a_b_neg_int_after_euler_hypergeometric_transformation(
+        self, hyp2f1_test_case
+    ):
+        a, b, c, z, expected, rtol = hyp2f1_test_case
+        assert (  # Tests the test
+            (abs(c - a - int(c - a)) < 1e-15 and c - a < 0) or
+            (abs(c - b - int(c - b)) < 1e-15 and c - b < 0)
+        )
+        assert_allclose(hyp2f1(a, b, c, z), expected, rtol=rtol)
+
+    @pytest.mark.parametrize(
+        "hyp2f1_test_case",
+        [
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-0.9220024191881196,
+                    b=-0.9629749245209605,
+                    c=-15.963511401609862,
+                    z=(0.10526315789473673-0.3157894736842106j),
+                    expected=(0.9941449585778349+0.01756335047931358j),
+                    rtol=1e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=1.0272592605282642,
+                    b=-0.9629749245209605,
+                    c=-15.963511401609862,
+                    z=(0.5263157894736841+0.5263157894736841j),
+                    expected=(1.0388722293372104-0.09549450380041416j),
+                    rtol=5e-11,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=2.02764642551431,
+                    b=1.0561196186065624,
+                    c=-7.93846038215665,
+                    z=(0.10526315789473673+0.7368421052631575j),
+                    expected=(2.1948378809826434+24.934157235172222j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=2.02764642551431,
+                    b=16.088264119063613,
+                    c=8.031683612216888,
+                    z=(0.3157894736842106-0.736842105263158j),
+                    expected=(-0.4075277891264672-0.06819344579666956j),
+                    rtol=2e-12,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=4.080187217753502,
+                    b=2.050308316530781,
+                    c=8.031683612216888,
+                    z=(0.7368421052631575-0.10526315789473695j),
+                    expected=(2.833535530740603-0.6925373701408158j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=2.02764642551431,
+                    b=2.050308316530781,
+                    c=4.078873014294075,
+                    z=(0.10526315789473673-0.3157894736842106j),
+                    expected=(1.005347176329683-0.3580736009337313j),
+                    rtol=5e-16,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-0.9220024191881196,
+                    b=-0.9629749245209605,
+                    c=-15.963511401609862,
+                    z=(0.3157894736842106-0.5263157894736843j),
+                    expected=(0.9824353641135369+0.029271018868990268j),
+                    rtol=5e-13,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-0.9220024191881196,
+                    b=-0.9629749245209605,
+                    c=-159.63511401609862,
+                    z=(0.3157894736842106-0.5263157894736843j),
+                    expected=(0.9982436200365834+0.002927268199671111j),
+                    rtol=1e-7,
+                ),
+                marks=pytest.mark.xfail(reason="Poor convergence.")
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=2.02764642551431,
+                    b=16.088264119063613,
+                    c=8.031683612216888,
+                    z=(0.5263157894736841-0.5263157894736843j),
+                    expected=(-0.6906825165778091+0.8176575137504892j),
+                    rtol=5e-13,
+                ),
+            ),
+        ]
+    )
+    def test_region1(self, hyp2f1_test_case):
+        """|z| < 0.9 and real(z) >= 0."""
+        a, b, c, z, expected, rtol = hyp2f1_test_case
+        assert abs(z) < 0.9 and z.real >= 0  # Tests the test
+        assert_allclose(hyp2f1(a, b, c, z), expected, rtol=rtol)
+
+    @pytest.mark.parametrize(
+        "hyp2f1_test_case",
+        [
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=2.02764642551431,
+                    b=1.0561196186065624,
+                    c=4.078873014294075,
+                    z=(-0.3157894736842106+0.7368421052631575j),
+                    expected=(0.7751915029081136+0.24068493258607315j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=16.087593263474208,
+                    b=16.088264119063613,
+                    c=2.0397202577726152,
+                    z=(-0.9473684210526316-0.3157894736842106j),
+                    expected=(6.564549348474962e-07+1.6761570598334562e-06j),
+                    rtol=5e-09,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=1.0272592605282642,
+                    b=2.050308316530781,
+                    c=16.056809865262608,
+                    z=(-0.10526315789473695-0.10526315789473695j),
+                    expected=(0.9862043298997204-0.013293151372712681j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=4.080187217753502,
+                    b=8.077282662161238,
+                    c=16.056809865262608,
+                    z=(-0.3157894736842106-0.736842105263158j),
+                    expected=(0.16163826638754716-0.41378530376373734j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=2.02764642551431,
+                    b=2.050308316530781,
+                    c=-0.906685989801748,
+                    z=(-0.5263157894736843+0.3157894736842106j),
+                    expected=(-6.256871535165936+0.13824973858225484j),
+                    rtol=1e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=2.02764642551431,
+                    b=8.077282662161238,
+                    c=-3.9924618758357022,
+                    z=(-0.9473684210526316-0.3157894736842106j),
+                    expected=(75.54672526086316+50.56157041797548j),
+                    rtol=5e-12,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=16.087593263474208,
+                    b=8.077282662161238,
+                    c=-1.9631175993998025,
+                    z=(-0.5263157894736843+0.5263157894736841j),
+                    expected=(282.0602536306534-82.31597306936214j),
+                    rtol=5e-13,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=8.095813935368371,
+                    b=-3.9316537064827854,
+                    c=8.031683612216888,
+                    z=(-0.5263157894736843-0.10526315789473695j),
+                    expected=(5.179603735575851+1.4445374002099813j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=4.080187217753502,
+                    b=-7.949900487447654,
+                    c=1.0651378143226575,
+                    z=(-0.3157894736842106-0.9473684210526316j),
+                    expected=(2317.623517606141-269.51476321010324j),
+                    rtol=5e-13,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=16.087593263474208,
+                    b=-1.92872979730171,
+                    c=2.0397202577726152,
+                    z=(-0.736842105263158-0.3157894736842106j),
+                    expected=(29.179154096175836+22.126690357535043j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=8.095813935368371,
+                    b=-3.9316537064827854,
+                    c=-15.963511401609862,
+                    z=(-0.736842105263158-0.10526315789473695j),
+                    expected=(0.20820247892032057-0.04763956711248794j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=1.0272592605282642,
+                    b=-15.964218273004214,
+                    c=-1.9631175993998025,
+                    z=(-0.3157894736842106-0.5263157894736843j),
+                    expected=(-157471.63920142158+991294.0587828817j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=8.095813935368371,
+                    b=-7.949900487447654,
+                    c=-7.93846038215665,
+                    z=(-0.10526315789473695-0.10526315789473695j),
+                    expected=(0.30765349653210194-0.2979706363594157j),
+                    rtol=1e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-3.956227226099288,
+                    b=1.0561196186065624,
+                    c=8.031683612216888,
+                    z=(-0.9473684210526316-0.10526315789473695j),
+                    expected=(1.6787607400597109+0.10056620134616838j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-7.937789122896016,
+                    b=16.088264119063613,
+                    c=4.078873014294075,
+                    z=(-0.5263157894736843-0.736842105263158j),
+                    expected=(7062.07842506049-12768.77955655703j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-7.937789122896016,
+                    b=16.088264119063613,
+                    c=2.0397202577726152,
+                    z=(-0.3157894736842106+0.7368421052631575j),
+                    expected=(54749.216391029935-23078.144720887536j),
+                    rtol=2e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-3.956227226099288,
+                    b=1.0561196186065624,
+                    c=-0.906685989801748,
+                    z=(-0.10526315789473695-0.10526315789473695j),
+                    expected=(1.21521766411428-4.449385173946672j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-15.980848054962111,
+                    b=4.0013768449590685,
+                    c=-1.9631175993998025,
+                    z=(-0.736842105263158+0.5263157894736841j),
+                    expected=(19234693144.196907+1617913967.7294445j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-1.9214641416286231,
+                    b=1.0561196186065624,
+                    c=-15.963511401609862,
+                    z=(-0.5263157894736843+0.3157894736842106j),
+                    expected=(0.9345201094534371+0.03745712558992195j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-7.937789122896016,
+                    b=-0.9629749245209605,
+                    c=2.0397202577726152,
+                    z=(-0.10526315789473695+0.10526315789473673j),
+                    expected=(0.605732446296829+0.398171533680972j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-1.9214641416286231,
+                    b=-15.964218273004214,
+                    c=2.0397202577726152,
+                    z=(-0.10526315789473695-0.5263157894736843j),
+                    expected=(-9.753761888305416-4.590126012666959j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-3.956227226099288,
+                    b=-1.92872979730171,
+                    c=2.0397202577726152,
+                    z=(-0.10526315789473695+0.3157894736842106j),
+                    expected=(0.45587226291120714+1.0694545265819797j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-0.9220024191881196,
+                    b=-7.949900487447654,
+                    c=-0.906685989801748,
+                    z=(-0.736842105263158+0.3157894736842106j),
+                    expected=(12.334808243233418-76.26089051819054j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-0.9220024191881196,
+                    b=-7.949900487447654,
+                    c=-15.963511401609862,
+                    z=(-0.5263157894736843+0.10526315789473673j),
+                    expected=(1.2396019687632678-0.047507973161146286j),
+                    rtol=1e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-15.980848054962111,
+                    b=-0.9629749245209605,
+                    c=-0.906685989801748,
+                    z=(-0.3157894736842106-0.5263157894736843j),
+                    expected=(97.7889554372208-18.999754543400016j),
+                    rtol=5e-13,
+                ),
+            ),
+        ]
+    )
+    def test_region2(self, hyp2f1_test_case):
+        """|z| < 1 and real(z) < 0."""
+        a, b, c, z, expected, rtol = hyp2f1_test_case
+        assert abs(z) < 1 and z.real < 0  # Tests the test
+        assert_allclose(hyp2f1(a, b, c, z), expected, rtol=rtol)
+
+    @pytest.mark.parametrize(
+        "hyp2f1_test_case",
+        [
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=16.25,
+                    b=-3.75,
+                    c=-3.5,
+                    z=(0.5263157894736841+0.7368421052631575j),
+                    expected=(-1279.4894322256655-2302.914821389276j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-15.75,
+                    b=8.25,
+                    c=-1.5,
+                    z=(0.9473684210526314+0.3157894736842106j),
+                    expected=(-8889.452798586273-11961.162305065242j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=2.25,
+                    b=2.25,
+                    c=-1.5,
+                    z=(0.5263157894736841-0.736842105263158j),
+                    expected=(-236.58971357952055-238.5228224781136j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-0.75,
+                    b=-7.75,
+                    c=-15.5,
+                    z=(0.5263157894736841+0.7368421052631575j),
+                    expected=(0.8116076584352279-0.29360565398246036j),
+                    rtol=5e-16,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=1.25,
+                    b=4.25,
+                    c=-0.5,
+                    z=(0.5263157894736841-0.736842105263158j),
+                    expected=(-28.119407485189985+98.89858821348005j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-0.75,
+                    b=2.25,
+                    c=1.5,
+                    z=(0.5263157894736841+0.7368421052631575j),
+                    expected=(0.5311049067450484-0.9434347326448517j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=8.25,
+                    b=-15.75,
+                    c=-7.5,
+                    z=(0.9473684210526314+0.10526315789473673j),
+                    expected=(1262084.378141873+1775569.6338380123j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-15.75,
+                    b=-7.75,
+                    c=-15.5,
+                    z=(0.5263157894736841-0.736842105263158j),
+                    expected=(-0.009810480794804165+0.3648997569257999j),
+                    rtol=1e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=8.25,
+                    b=2.25,
+                    c=-3.5,
+                    z=(0.5263157894736841-0.736842105263158j),
+                    expected=(585660.8815535795-33646.68398590896j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=4.080187217753502,
+                    b=-3.9316537064827854,
+                    c=-15.963511401609862,
+                    z=(0.9473684210526314-0.10526315789473695j),
+                    expected=(181899621848365.2-173207123998705.7j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-15.75,
+                    b=8.25,
+                    c=-0.5,
+                    z=(0.9473684210526314-0.10526315789473695j),
+                    expected=(0.04271686244952705-0.14087902824639406j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-7.937789122896016,
+                    b=-1.92872979730171,
+                    c=-0.906685989801748,
+                    z=(0.9473684210526314-0.3157894736842106j),
+                    expected=(-449.5119088817207+320.1423128036188j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-3.956227226099288,
+                    b=1.0561196186065624,
+                    c=8.031683612216888,
+                    z=(0.9473684210526314-0.10526315789473695j),
+                    expected=(0.6361479738012501+0.028575620091205088j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=4.25,
+                    b=16.25,
+                    c=16.5,
+                    z=(0.5263157894736841+0.7368421052631575j),
+                    expected=(-0.9038811840552261-1.5356250756164884j),
+                    rtol=1e-8,
+                ),
+                marks=pytest.mark.xfail(
+                    reason="Unhandled parameters."
+                )
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=8.25,
+                    b=-1.75,
+                    c=-1.5,
+                    z=(0.9473684210526314+0.3157894736842106j),
+                    expected=(653.0109150415394-4554.162605155542j),
+                    rtol=1e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-15.75,
+                    b=-3.75,
+                    c=4.5,
+                    z=(0.9473684210526314-0.10526315789473695j),
+                    expected=(118.7009859241035-34.18713648654642j),
+                    rtol=1e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=4.25,
+                    b=-15.75,
+                    c=-3.5,
+                    z=(0.5263157894736841+0.7368421052631575j),
+                    expected=(-540204.4774526551+4970059.109251281j),
+                    rtol=1e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=8.25,
+                    b=-15.75,
+                    c=-0.5,
+                    z=(0.5263157894736841-0.736842105263158j),
+                    expected=(2253490.972258385+3318620.683390017j),
+                    rtol=5e-13,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=16.25,
+                    b=-7.75,
+                    c=-7.5,
+                    z=(0.9473684210526314+0.3157894736842106j),
+                    expected=(-46159826.46716958-17880663.82218242j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-0.9220024191881196,
+                    b=-7.949900487447654,
+                    c=-7.93846038215665,
+                    z=(0.9473684210526314-0.10526315789473695j),
+                    expected=(0.07116833581404514+0.11823358038036977j),
+                    rtol=5e-13,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=16.087593263474208,
+                    b=4.0013768449590685,
+                    c=-7.93846038215665,
+                    z=(0.7368421052631575+0.5263157894736841j),
+                    expected=(4.7724909620664006e+17-6.039064078946702e+16j),
+                    rtol=5e-13,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=1.25,
+                    b=-7.75,
+                    c=1.5,
+                    z=(0.9473684210526314-0.10526315789473695j),
+                    expected=(0.0188022179759303+0.002921737281641378j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=1.0272592605282642,
+                    b=1.0561196186065624,
+                    c=-7.93846038215665,
+                    z=(0.7368421052631575-0.5263157894736843j),
+                    expected=(-9203.462928334846+12390.110518017136j),
+                    rtol=5e-13,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-3.75,
+                    b=-15.75,
+                    c=8.5,
+                    z=(0.7368421052631575+0.5263157894736841j),
+                    expected=(6.468457061368628+24.190040684917374j),
+                    rtol=6e-16,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=2.02764642551431,
+                    b=16.088264119063613,
+                    c=2.0397202577726152,
+                    z=(0.7368421052631575+0.5263157894736841j),
+                    expected=(2408.3451340186543-4275.257316636014j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-3.75,
+                    b=-7.75,
+                    c=8.5,
+                    z=(0.7368421052631575-0.5263157894736843j),
+                    expected=(4.1379984626381345-5.183654781039423j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=8.25,
+                    b=-7.75,
+                    c=-0.5,
+                    z=(0.5263157894736841+0.7368421052631575j),
+                    expected=(-81177.775295738+56079.73286548954j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=4.080187217753502,
+                    b=2.050308316530781,
+                    c=-0.906685989801748,
+                    z=(0.9473684210526314+0.3157894736842106j),
+                    expected=(1192868.5068926765+3624210.8182139914j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-7.937789122896016,
+                    b=-1.92872979730171,
+                    c=8.031683612216888,
+                    z=(0.5263157894736841+0.7368421052631575j),
+                    expected=(1.8286341846195202+1.9295255682312178j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=1.0272592605282642,
+                    b=1.0561196186065624,
+                    c=16.056809865262608,
+                    z=(0.7368421052631575-0.5263157894736843j),
+                    expected=(1.0514645669696452-0.0430834059440128j),
+                    rtol=5e-10,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=16.087593263474208,
+                    b=-15.964218273004214,
+                    c=2.0397202577726152,
+                    z=(0.5263157894736841+0.7368421052631575j),
+                    expected=(541983.236432269+288200.2043029435j),
+                    rtol=5e-13,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=2.25,
+                    b=8.25,
+                    c=1.5,
+                    z=(0.5263157894736841-0.736842105263158j),
+                    expected=(-10.931988086039945+1.9136272843579096j),
+                    rtol=1e-15,
+                ),
+            ),
+        ]
+    )
+    def test_region3(self, hyp2f1_test_case):
+        """0.9 <= |z| <= 1 and |1 - z| < 0.9."""
+        a, b, c, z, expected, rtol = hyp2f1_test_case
+        assert 0.9 <= abs(z) <= 1 and abs(1 - z) < 0.9  # Tests the test
+        assert_allclose(hyp2f1(a, b, c, z), expected, rtol=rtol)
+
+    @pytest.mark.parametrize(
+        "hyp2f1_test_case",
+        [
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=16.25,
+                    b=4.25,
+                    c=2.5,
+                    z=(0.4931034482758623-0.7965517241379311j),
+                    expected=(38.41207903409937-30.510151276075792j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=2.0,
+                    b=16.087593263474208,
+                    c=16.088264119063613,
+                    z=(0.5689655172413794-0.7965517241379311j),
+                    expected=(-0.6667857912761286-1.0206224321443573j),
+                    rtol=1e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=8.0,
+                    b=1.0272592605282642,
+                    c=-7.949900487447654,
+                    z=(0.4931034482758623-0.7965517241379311j),
+                    expected=(1679024.1647997478-2748129.775857212j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=4.080187217753502,
+                    b=16.0,
+                    c=-7.949900487447654,
+                    z=(0.4931034482758623-0.7965517241379311j),
+                    expected=(424747226301.16986-1245539049327.2856j),
+                    rtol=1e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=2.02764642551431,
+                    b=-15.964218273004214,
+                    c=4.0,
+                    z=(0.4931034482758623-0.7965517241379311j),
+                    expected=(-0.0057826199201757595+0.026359861999025885j),
+                    rtol=5e-06,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=2.02764642551431,
+                    b=-0.9629749245209605,
+                    c=2.0397202577726152,
+                    z=(0.5689655172413794-0.7965517241379311j),
+                    expected=(0.4671901063492606+0.7769632229834897j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=2.0,
+                    b=-3.956227226099288,
+                    c=-7.949900487447654,
+                    z=(0.4931034482758623+0.7965517241379312j),
+                    expected=(0.9422283708145973+1.3476905754773343j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=1.0,
+                    b=-15.980848054962111,
+                    c=-15.964218273004214,
+                    z=(0.4931034482758623-0.7965517241379311j),
+                    expected=(0.4168719497319604-0.9770953555235625j),
+                    rtol=5e-10,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-0.5,
+                    b=16.088264119063613,
+                    c=2.5,
+                    z=(0.5689655172413794+0.7965517241379312j),
+                    expected=(1.279096377550619-2.173827694297929j),
+                    rtol=5e-12,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-1.9214641416286231,
+                    b=4.0013768449590685,
+                    c=2.0397202577726152,
+                    z=(0.4931034482758623+0.7965517241379312j),
+                    expected=(-2.071520656161738-0.7846098268395909j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-0.9220024191881196,
+                    b=8.0,
+                    c=-0.9629749245209605,
+                    z=(0.5689655172413794-0.7965517241379311j),
+                    expected=(-7.740015495862889+3.386766435696699j),
+                    rtol=5e-12,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-1.9214641416286231,
+                    b=16.088264119063613,
+                    c=-7.93846038215665,
+                    z=(0.4931034482758623+0.7965517241379312j),
+                    expected=(-6318.553685853241-7133.416085202879j),
+                    rtol=5e-9,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-15.980848054962111,
+                    b=-3.9316537064827854,
+                    c=16.056809865262608,
+                    z=(0.5689655172413794+0.7965517241379312j),
+                    expected=(-0.8854577905547399+8.135089099967278j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-1.9214641416286231,
+                    b=-0.9629749245209605,
+                    c=4.078873014294075,
+                    z=(0.4931034482758623+0.7965517241379312j),
+                    expected=(1.224291301521487+0.36014711766402485j),
+                    rtol=1e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-15.75,
+                    b=-0.75,
+                    c=-1.5,
+                    z=(0.4931034482758623+0.7965517241379312j),
+                    expected=(-1.5765685855028473-3.9399766961046323j),
+                    rtol=1e-3,
+                ),
+                marks=pytest.mark.xfail(
+                    reason="Unhandled parameters."
+                )
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-15.980848054962111,
+                    b=-1.92872979730171,
+                    c=-7.93846038215665,
+                    z=(0.5689655172413794-0.7965517241379311j),
+                    expected=(56.794588688231194+4.556286783533971j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=4.5,
+                    b=4.5,
+                    c=2.050308316530781,
+                    z=(0.5689655172413794+0.7965517241379312j),
+                    expected=(-4.251456563455306+6.737837111569671j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=4.5,
+                    b=8.5,
+                    c=-1.92872979730171,
+                    z=(0.4931034482758623-0.7965517241379311j),
+                    expected=(2177143.9156599627-3313617.2748088865j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=2.5,
+                    b=-1.5,
+                    c=4.0013768449590685,
+                    z=(0.4931034482758623-0.7965517241379311j),
+                    expected=(0.45563554481603946+0.6212000158060831j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=8.5,
+                    b=-7.5,
+                    c=-15.964218273004214,
+                    z=(0.4931034482758623+0.7965517241379312j),
+                    expected=(61.03201617828073-37.185626416756214j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-15.5,
+                    b=16.5,
+                    c=4.0013768449590685,
+                    z=(0.4931034482758623+0.7965517241379312j),
+                    expected=(-33143.425963520735+20790.608514722644j),
+                    rtol=1e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-0.5,
+                    b=4.5,
+                    c=-0.9629749245209605,
+                    z=(0.5689655172413794+0.7965517241379312j),
+                    expected=(30.778600270824423-26.65160354466787j),
+                    rtol=5e-13,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-0.5,
+                    b=-3.5,
+                    c=16.088264119063613,
+                    z=(0.5689655172413794-0.7965517241379311j),
+                    expected=(1.0629792615560487-0.08308454486044772j),
+                    rtol=1e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-3.5,
+                    b=-7.5,
+                    c=-0.9629749245209605,
+                    z=(0.4931034482758623-0.7965517241379311j),
+                    expected=(17431.571802591767+3553.7129767034507j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=2.25,
+                    b=8.25,
+                    c=16.5,
+                    z=(0.11379310344827598+0.9482758620689657j),
+                    expected=(0.4468600750211926+0.7313214934036885j),
+                    rtol=1e-3,
+                ),
+                marks=pytest.mark.xfail(
+                    reason="Unhandled parameters."
+                )
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=8.25,
+                    b=16.25,
+                    c=4.5,
+                    z=(0.3413793103448277+0.8724137931034486j),
+                    expected=(-3.905704438293991+3.693347860329299j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=4.25,
+                    b=4.25,
+                    c=-0.5,
+                    z=(0.11379310344827598-0.9482758620689655j),
+                    expected=(-40.31777941834244-89.89852492432011j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=1.0272592605282642,
+                    b=8.0,
+                    c=-15.964218273004214,
+                    z=(0.11379310344827598-0.9482758620689655j),
+                    expected=(52584.347773055284-109197.86244309516j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=8.095813935368371,
+                    b=-15.964218273004214,
+                    c=16.056809865262608,
+                    z=(0.03793103448275881+0.9482758620689657j),
+                    expected=(-1.187733570412592-1.5147865053584582j),
+                    rtol=5e-10,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=4.080187217753502,
+                    b=-3.9316537064827854,
+                    c=1.0651378143226575,
+                    z=(0.26551724137931054+0.9482758620689657j),
+                    expected=(13.077494677898947+35.071599628224966j),
+                    rtol=5e-13,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=4.080187217753502,
+                    b=-3.5,
+                    c=-3.5,
+                    z=(0.26551724137931054+0.8724137931034486j),
+                    expected=(-0.5359656237994614-0.2344483936591811j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=4.25,
+                    b=-3.75,
+                    c=-1.5,
+                    z=(0.26551724137931054+0.9482758620689657j),
+                    expected=(1204.8114871663133+64.41022826840198j),
+                    rtol=5e-13,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-1.9214641416286231,
+                    b=16.0,
+                    c=4.0013768449590685,
+                    z=(0.03793103448275881-0.9482758620689655j),
+                    expected=(-9.85268872413994+7.011107558429154j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-7.937789122896016,
+                    b=16.0,
+                    c=4.0013768449590685,
+                    z=(0.3413793103448277-0.8724137931034484j),
+                    expected=(528.5522951158454-1412.21630264791j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-15.5,
+                    b=1.0561196186065624,
+                    c=-7.5,
+                    z=(0.4172413793103451+0.8724137931034486j),
+                    expected=(133306.45260685298+256510.7045225382j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-7.937789122896016,
+                    b=8.077282662161238,
+                    c=-15.963511401609862,
+                    z=(0.3413793103448277-0.8724137931034484j),
+                    expected=(-0.998555715276967+2.774198742229889j),
+                    rtol=5e-11,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-7.75,
+                    b=-0.75,
+                    c=1.5,
+                    z=(0.11379310344827598-0.9482758620689655j),
+                    expected=(2.072445019723025-2.9793504811373515j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-15.5,
+                    b=-1.92872979730171,
+                    c=1.5,
+                    z=(0.11379310344827598-0.9482758620689655j),
+                    expected=(-41.87581944176649-32.52980303527139j),
+                    rtol=5e-13,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-3.75,
+                    b=-15.75,
+                    c=-0.5,
+                    z=(0.11379310344827598-0.9482758620689655j),
+                    expected=(-3729.6214864209774-30627.510509112635j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-3.956227226099288,
+                    b=-15.964218273004214,
+                    c=-0.906685989801748,
+                    z=(0.03793103448275881+0.9482758620689657j),
+                    expected=(-131615.07820609974+145596.13384245415j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=1.5,
+                    b=16.5,
+                    c=16.088264119063613,
+                    z=(0.26551724137931054+0.8724137931034486j),
+                    expected=(0.18981844071070744+0.7855036242583742j),
+                    rtol=1e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=16.5,
+                    b=8.5,
+                    c=-3.9316537064827854,
+                    z=(0.11379310344827598-0.9482758620689655j),
+                    expected=(110224529.2376068+128287212.04290268j),
+                    rtol=5e-13,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=2.5,
+                    b=-7.5,
+                    c=4.0013768449590685,
+                    z=(0.3413793103448277-0.8724137931034484j),
+                    expected=(0.2722302180888523-0.21790187837266162j),
+                    rtol=1.2e-12,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=8.5,
+                    b=-7.5,
+                    c=-15.964218273004214,
+                    z=(0.11379310344827598-0.9482758620689655j),
+                    expected=(-2.8252338010989035+2.430661949756161j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-3.5,
+                    b=16.5,
+                    c=4.0013768449590685,
+                    z=(0.03793103448275881+0.9482758620689657j),
+                    expected=(-20.604894257647945+74.5109432558078j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-7.5,
+                    b=8.5,
+                    c=-0.9629749245209605,
+                    z=(0.3413793103448277+0.8724137931034486j),
+                    expected=(-2764422.521269463-3965966.9965808876j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-1.5,
+                    b=-0.5,
+                    c=1.0561196186065624,
+                    z=(0.26551724137931054+0.9482758620689657j),
+                    expected=(1.2262338560994905+0.6545051266925549j),
+                    rtol=1e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-0.5,
+                    b=-15.5,
+                    c=-7.949900487447654,
+                    z=(0.4172413793103451-0.8724137931034484j),
+                    expected=(-2258.1590330318213+8860.193389158803j),
+                    rtol=1.4e-10,
+                ),
+            ),
+        ]
+    )
+    def test_region4(self, hyp2f1_test_case):
+        """0.9 <= |z| <= 1 and |1 - z| >= 1.
+
+        This region is unhandled by of the standard transformations and
+        needs special care.
+        """
+        a, b, c, z, expected, rtol = hyp2f1_test_case
+        assert 0.9 <= abs(z) <= 1 and abs(1 - z) >= 0.9  # Tests the test
+        assert_allclose(hyp2f1(a, b, c, z), expected, rtol=rtol)
+
+    @pytest.mark.parametrize(
+        "hyp2f1_test_case",
+        [
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=4.5,
+                    b=16.088264119063613,
+                    c=8.5,
+                    z=(0.6448275862068968+0.8724137931034486j),
+                    expected=(0.018601324701770394-0.07618420586062377j),
+                    rtol=5e-08,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=8.25,
+                    b=4.25,
+                    c=4.5,
+                    z=(0.6448275862068968-0.8724137931034484j),
+                    expected=(-1.391549471425551-0.118036604903893j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=2.02764642551431,
+                    b=2.050308316530781,
+                    c=-1.9631175993998025,
+                    z=(0.6448275862068968+0.8724137931034486j),
+                    expected=(-2309.178768155151-1932.7247727595172j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=16.087593263474208,
+                    b=1.0,
+                    c=-15.964218273004214,
+                    z=(0.6448275862068968+0.8724137931034486j),
+                    expected=(85592537010.05054-8061416766688.324j),
+                    rtol=2e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=8.095813935368371,
+                    b=-0.5,
+                    c=1.5,
+                    z=(0.6448275862068968+0.8724137931034486j),
+                    expected=(1.2334498208515172-2.1639498536219732j),
+                    rtol=5e-11,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=16.087593263474208,
+                    b=-15.964218273004214,
+                    c=4.0,
+                    z=(0.6448275862068968+0.8724137931034486j),
+                    expected=(102266.35398605966-44976.97828737755j),
+                    rtol=1e-3,
+                ),
+                marks=pytest.mark.xfail(
+                    reason="Unhandled parameters."
+                )
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=4.0,
+                    b=-3.956227226099288,
+                    c=-15.964218273004214,
+                    z=(0.6448275862068968-0.8724137931034484j),
+                    expected=(-2.9590030930007236-4.190770764773225j),
+                    rtol=5e-13,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=4.080187217753502,
+                    b=-15.5,
+                    c=-7.5,
+                    z=(0.5689655172413794-0.8724137931034484j),
+                    expected=(-112554838.92074208+174941462.9202412j),
+                    rtol=5e-05,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-15.980848054962111,
+                    b=2.050308316530781,
+                    c=1.0,
+                    z=(0.6448275862068968-0.8724137931034484j),
+                    expected=(3.7519882374080145+7.360753798667486j),
+                    rtol=5e-13,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-7.937789122896016,
+                    b=2.050308316530781,
+                    c=4.0,
+                    z=(0.6448275862068968-0.8724137931034484j),
+                    expected=(0.000181132943964693+0.07742903103815582j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-7.937789122896016,
+                    b=4.0013768449590685,
+                    c=-1.9631175993998025,
+                    z=(0.5689655172413794+0.8724137931034486j),
+                    expected=(386338.760913596-386166.51762171905j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-15.980848054962111,
+                    b=8.0,
+                    c=-1.92872979730171,
+                    z=(0.6448275862068968+0.8724137931034486j),
+                    expected=(1348667126.3444858-2375132427.158893j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-3.5,
+                    b=-0.9629749245209605,
+                    c=4.5,
+                    z=(0.5689655172413794+0.8724137931034486j),
+                    expected=(1.428353429538678+0.6472718120804372j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-7.937789122896016,
+                    b=-0.9629749245209605,
+                    c=2.0397202577726152,
+                    z=(0.5689655172413794-0.8724137931034484j),
+                    expected=(3.1439267526119643-3.145305240375117j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-1.9214641416286231,
+                    b=-15.964218273004214,
+                    c=-7.93846038215665,
+                    z=(0.6448275862068968-0.8724137931034484j),
+                    expected=(75.27467675681773+144.0946946292215j),
+                    rtol=1e-07,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-3.75,
+                    b=-7.75,
+                    c=-7.5,
+                    z=(0.5689655172413794+0.8724137931034486j),
+                    expected=(-0.3699450626264222+0.8732812475910993j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=1.5,
+                    b=16.5,
+                    c=1.0561196186065624,
+                    z=(0.5689655172413794-0.8724137931034484j),
+                    expected=(5.5361025821300665-2.4709693474656285j),
+                    rtol=5e-09,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=1.5,
+                    b=8.5,
+                    c=-3.9316537064827854,
+                    z=(0.6448275862068968-0.8724137931034484j),
+                    expected=(-782805.6699207705-537192.581278909j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=2.5,
+                    b=-15.5,
+                    c=1.0561196186065624,
+                    z=(0.6448275862068968+0.8724137931034486j),
+                    expected=(12.345113400639693-14.993248992902007j),
+                    rtol=0.0005,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=1.5,
+                    b=-0.5,
+                    c=-15.964218273004214,
+                    z=(0.6448275862068968+0.8724137931034486j),
+                    expected=(23.698109392667842+97.15002033534108j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-7.5,
+                    b=16.5,
+                    c=4.0013768449590685,
+                    z=(0.6448275862068968-0.8724137931034484j),
+                    expected=(1115.2978631811834+915.9212658718577j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-15.5,
+                    b=16.5,
+                    c=-0.9629749245209605,
+                    z=(0.6448275862068968+0.8724137931034486j),
+                    expected=(642077722221.6489+535274495398.21027j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-7.5,
+                    b=-3.5,
+                    c=4.0013768449590685,
+                    z=(0.5689655172413794+0.8724137931034486j),
+                    expected=(-5.689219222945697+16.877463062787143j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-15.5,
+                    b=-1.5,
+                    c=-0.9629749245209605,
+                    z=(0.5689655172413794-0.8724137931034484j),
+                    expected=(-44.32070290703576+1026.9127058617403j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=16.25,
+                    b=2.25,
+                    c=4.5,
+                    z=(0.11379310344827598-1.024137931034483j),
+                    expected=(-0.021965227124574663+0.009908300237809064j),
+                    rtol=1e-3,
+                ),
+                marks=pytest.mark.xfail(
+                    reason="Unhandled parameters."
+                )
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=2.02764642551431,
+                    b=1.5,
+                    c=16.5,
+                    z=(0.26551724137931054+1.024137931034483j),
+                    expected=(1.0046072901244183+0.19945500134119992j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=16.087593263474208,
+                    b=1.0,
+                    c=-3.9316537064827854,
+                    z=(0.3413793103448277+0.9482758620689657j),
+                    expected=(21022.30133421465+49175.98317370489j),
+                    rtol=5e-13,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=4.080187217753502,
+                    b=16.088264119063613,
+                    c=-1.9631175993998025,
+                    z=(0.4172413793103451-0.9482758620689655j),
+                    expected=(-7024239.358547302+2481375.02681063j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=16.25,
+                    b=-15.75,
+                    c=1.5,
+                    z=(0.18965517241379315+1.024137931034483j),
+                    expected=(92371704.94848-403546832.548352j),
+                    rtol=5e-06,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=8.5,
+                    b=-7.949900487447654,
+                    c=8.5,
+                    z=(0.26551724137931054-1.024137931034483j),
+                    expected=(1.9335109845308265+5.986542524829654j),
+                    rtol=5e-10,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=8.095813935368371,
+                    b=-1.92872979730171,
+                    c=-7.93846038215665,
+                    z=(0.4931034482758623+0.8724137931034486j),
+                    expected=(-122.52639696039328-59.72428067512221j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=16.25,
+                    b=-1.75,
+                    c=-1.5,
+                    z=(0.4931034482758623+0.9482758620689657j),
+                    expected=(-90.40642053579428+50.50649180047921j),
+                    rtol=5e-08,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-3.5,
+                    b=8.077282662161238,
+                    c=16.5,
+                    z=(0.4931034482758623+0.9482758620689657j),
+                    expected=(-0.2155745818150323-0.564628986876639j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-0.9220024191881196,
+                    b=1.0561196186065624,
+                    c=8.031683612216888,
+                    z=(0.4172413793103451-0.9482758620689655j),
+                    expected=(0.9503140488280465+0.11574960074292677j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-0.75,
+                    b=2.25,
+                    c=-15.5,
+                    z=(0.4172413793103451+0.9482758620689657j),
+                    expected=(0.9285862488442175+0.8203699266719692j),
+                    rtol=5e-13,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-7.75,
+                    b=4.25,
+                    c=-15.5,
+                    z=(0.3413793103448277-0.9482758620689655j),
+                    expected=(-1.0509834850116921-1.1145522325486075j),
+                    rtol=1.1e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-7.937789122896016,
+                    b=-0.9629749245209605,
+                    c=2.0397202577726152,
+                    z=(0.4931034482758623-0.9482758620689655j),
+                    expected=(2.88119116536769-3.4249933450696806j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-15.5,
+                    b=-15.964218273004214,
+                    c=16.5,
+                    z=(0.18965517241379315+1.024137931034483j),
+                    expected=(199.65868451496038+347.79384207302877j),
+                    rtol=5e-12,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-15.75,
+                    b=-15.75,
+                    c=-3.5,
+                    z=(0.4931034482758623-0.8724137931034484j),
+                    expected=(-208138312553.07013+58631611809.026955j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-7.937789122896016,
+                    b=-15.5,
+                    c=-7.5,
+                    z=(0.3413793103448277+0.9482758620689657j),
+                    expected=(-23032.90519856288-18256.94050457296j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=4.5,
+                    b=1.5,
+                    c=1.0561196186065624,
+                    z=(0.4931034482758623-0.8724137931034484j),
+                    expected=(1.507342459587056+1.2332023580148403j),
+                    rtol=1e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=2.5,
+                    b=4.5,
+                    c=-3.9316537064827854,
+                    z=(0.4172413793103451+0.9482758620689657j),
+                    expected=(7044.766127108853-40210.365567285575j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=1.5,
+                    b=-1.5,
+                    c=1.0561196186065624,
+                    z=(0.03793103448275881+1.024137931034483j),
+                    expected=(0.2725347741628333-2.247314875514784j),
+                    rtol=1e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=4.5,
+                    b=-1.5,
+                    c=-7.949900487447654,
+                    z=(0.26551724137931054+1.024137931034483j),
+                    expected=(-11.250200011017546+12.597393659160472j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-7.5,
+                    b=8.5,
+                    c=16.088264119063613,
+                    z=(0.26551724137931054+1.024137931034483j),
+                    expected=(-0.18515160890991517+0.7959014164484782j),
+                    rtol=2e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-7.5,
+                    b=16.5,
+                    c=-3.9316537064827854,
+                    z=(0.3413793103448277-1.024137931034483j),
+                    expected=(998246378.8556538+1112032928.103645j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-1.5,
+                    b=-3.5,
+                    c=2.050308316530781,
+                    z=(0.03793103448275881+1.024137931034483j),
+                    expected=(0.5527670397711952+2.697662715303637j),
+                    rtol=1.2e-15,       # rtol bumped from 1e-15 in gh18414
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-15.5,
+                    b=-1.5,
+                    c=-0.9629749245209605,
+                    z=(0.4931034482758623-0.8724137931034484j),
+                    expected=(55.396931662136886+968.467463806326j),
+                    rtol=5e-14,
+                ),
+            ),
+        ]
+    )
+    def test_region5(self, hyp2f1_test_case):
+        """1 < |z| < 1.1 and |1 - z| >= 0.9 and real(z) >= 0"""
+        a, b, c, z, expected, rtol = hyp2f1_test_case
+        assert 1 < abs(z) < 1.1 and abs(1 - z) >= 0.9 and z.real >= 0
+        assert_allclose(hyp2f1(a, b, c, z), expected, rtol=rtol)
+
+    @pytest.mark.parametrize(
+        "hyp2f1_test_case",
+        [
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=8.095813935368371,
+                    b=4.0013768449590685,
+                    c=4.078873014294075,
+                    z=(-0.9473684210526316+0.5263157894736841j),
+                    expected=(-0.0018093573941378783+0.003481887377423739j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=16.087593263474208,
+                    b=2.050308316530781,
+                    c=1.0651378143226575,
+                    z=(-0.736842105263158-0.736842105263158j),
+                    expected=(-0.00023401243818780545-1.7983496305603562e-05j),
+                    rtol=1e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=1.0272592605282642,
+                    b=8.077282662161238,
+                    c=4.078873014294075,
+                    z=(-0.5263157894736843-0.9473684210526316j),
+                    expected=(0.22359773002226846-0.24092487123993353j),
+                    rtol=1e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=1.0272592605282642,
+                    b=2.050308316530781,
+                    c=-15.963511401609862,
+                    z=(-0.9473684210526316-0.5263157894736843j),
+                    expected=(1.191573745740011+0.14347394589721466j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=4.080187217753502,
+                    b=4.0013768449590685,
+                    c=-15.963511401609862,
+                    z=(-0.9473684210526316-0.5263157894736843j),
+                    expected=(31.822620756901784-66.09094396747611j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=4.080187217753502,
+                    b=8.077282662161238,
+                    c=-7.93846038215665,
+                    z=(-0.9473684210526316+0.5263157894736841j),
+                    expected=(207.16750179245952+34.80478274924269j),
+                    rtol=5e-12,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=8.095813935368371,
+                    b=-7.949900487447654,
+                    c=8.031683612216888,
+                    z=(-0.736842105263158+0.7368421052631575j),
+                    expected=(-159.62429364277145+9.154224290644898j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=1.0272592605282642,
+                    b=-1.92872979730171,
+                    c=16.056809865262608,
+                    z=(-0.9473684210526316+0.5263157894736841j),
+                    expected=(1.121122351247184-0.07170260470126685j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=16.087593263474208,
+                    b=-0.9629749245209605,
+                    c=16.056809865262608,
+                    z=(-0.9473684210526316+0.5263157894736841j),
+                    expected=(1.9040596681316053-0.4951799449960107j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=1.0272592605282642,
+                    b=-1.92872979730171,
+                    c=-0.906685989801748,
+                    z=(-0.9473684210526316-0.5263157894736843j),
+                    expected=(-14.496623497780739-21.897524523299875j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=4.080187217753502,
+                    b=-3.9316537064827854,
+                    c=-3.9924618758357022,
+                    z=(-0.5263157894736843-0.9473684210526316j),
+                    expected=(36.33473466026878+253.88728442029577j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=1.0272592605282642,
+                    b=-15.964218273004214,
+                    c=-0.906685989801748,
+                    z=(-0.9473684210526316+0.5263157894736841j),
+                    expected=(1505052.5653144997-50820766.81043443j),
+                    rtol=1e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-3.956227226099288,
+                    b=4.0013768449590685,
+                    c=1.0651378143226575,
+                    z=(-0.5263157894736843+0.9473684210526314j),
+                    expected=(-127.79407519260877-28.69899444941112j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-1.9214641416286231,
+                    b=8.077282662161238,
+                    c=16.056809865262608,
+                    z=(-0.9473684210526316-0.5263157894736843j),
+                    expected=(2.0623331933754976+0.741234463565458j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-3.956227226099288,
+                    b=8.077282662161238,
+                    c=2.0397202577726152,
+                    z=(-0.9473684210526316+0.5263157894736841j),
+                    expected=(30.729193458862525-292.5700835046965j),
+                    rtol=1e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-1.9214641416286231,
+                    b=1.0561196186065624,
+                    c=-1.9631175993998025,
+                    z=(-0.5263157894736843-0.9473684210526316j),
+                    expected=(1.1285917906203495-0.735264575450189j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-0.9220024191881196,
+                    b=1.0561196186065624,
+                    c=-3.9924618758357022,
+                    z=(-0.736842105263158+0.7368421052631575j),
+                    expected=(0.6356474446678052-0.02429663008952248j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-1.9214641416286231,
+                    b=16.088264119063613,
+                    c=-7.93846038215665,
+                    z=(-0.736842105263158+0.7368421052631575j),
+                    expected=(0.4718880510273174+0.655083067736377j),
+                    rtol=1e-11,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-7.937789122896016,
+                    b=-3.9316537064827854,
+                    c=16.056809865262608,
+                    z=(-0.9473684210526316+0.5263157894736841j),
+                    expected=(-0.14681550942352714+0.16092206364265146j),
+                    rtol=5e-11,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-0.9220024191881196,
+                    b=-15.964218273004214,
+                    c=1.0651378143226575,
+                    z=(-0.5263157894736843+0.9473684210526314j),
+                    expected=(-6.436835190526225+22.883156700606182j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-0.9220024191881196,
+                    b=-7.949900487447654,
+                    c=4.078873014294075,
+                    z=(-0.9473684210526316-0.5263157894736843j),
+                    expected=(-0.7505682955068583-1.1026583264249945j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-3.956227226099288,
+                    b=-3.9316537064827854,
+                    c=-7.93846038215665,
+                    z=(-0.9473684210526316-0.5263157894736843j),
+                    expected=(3.6247814989198166+2.596041360148318j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-3.956227226099288,
+                    b=-15.964218273004214,
+                    c=-1.9631175993998025,
+                    z=(-0.5263157894736843-0.9473684210526316j),
+                    expected=(-59537.65287927933-669074.4342539902j),
+                    rtol=5e-15,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=-3.956227226099288,
+                    b=-15.964218273004214,
+                    c=-1.9631175993998025,
+                    z=(-0.9473684210526316-0.5263157894736843j),
+                    expected=(-433084.9970266166+431088.393918521j),
+                    rtol=5e-14,
+                ),
+            ),
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=1,
+                    b=1,
+                    c=4,
+                    z=(3 + 4j),
+                    expected=(0.49234384000963544+0.6051340616612397j),
+                    rtol=5e-14,
+                ),
+            ),
+        ]
+    )
+    def test_region6(self, hyp2f1_test_case):
+        """|z| > 1 but not in region 5."""
+        a, b, c, z, expected, rtol = hyp2f1_test_case
+        assert (
+            abs(z) > 1 and
+            not (1 < abs(z) < 1.1 and abs(1 - z) >= 0.9 and z.real >= 0)
+        )
+        assert_allclose(hyp2f1(a, b, c, z), expected, rtol=rtol)
+
+
+    @pytest.mark.parametrize(
+        "hyp2f1_test_case",
+        [
+            # Broke when fixing gamma pole behavior in gh-21827
+            pytest.param(
+                Hyp2f1TestCase(
+                    a=1.3,
+                    b=-0.2,
+                    c=0.3,
+                    z=-2.1,
+                    expected=1.8202169687521206,
+                    rtol=5e-15,
+                ),
+            ),
+        ]
+    )
+    def test_miscellaneous(self, hyp2f1_test_case ):
+        a, b, c, z, expected, rtol = hyp2f1_test_case
+        assert_allclose(hyp2f1(a, b, c, z), expected, rtol=rtol)
+
+    @pytest.mark.slow
+    @check_version(mpmath, "1.0.0")
+    def test_test_hyp2f1(self):
+        """Test that expected values match what is computed by mpmath.
+
+        This gathers the parameters for the test cases out of the pytest marks.
+        The parameters are a, b, c, z, expected, rtol, where expected should
+        be the value of hyp2f1(a, b, c, z) computed with mpmath. The test
+        recomputes hyp2f1(a, b, c, z) using mpmath and verifies that expected
+        actually is the correct value. This allows the data for the tests to
+        live within the test code instead of an external datafile, while
+        avoiding having to compute the results with mpmath during the test,
+        except for when slow tests are being run.
+        """
+        test_methods = [
+            test_method for test_method in dir(self)
+            if test_method.startswith('test') and
+            # Filter properties and attributes (futureproofing).
+            callable(getattr(self, test_method)) and
+            # Filter out this test
+            test_method != 'test_test_hyp2f1'
+        ]
+        for test_method in test_methods:
+            params = self._get_test_parameters(getattr(self, test_method))
+            for a, b, c, z, expected, _ in params:
+                assert_allclose(mp_hyp2f1(a, b, c, z), expected, rtol=2.25e-16)
+
+    def _get_test_parameters(self, test_method):
+        """Get pytest.mark parameters for a test in this class."""
+        return [
+            case.values[0] for mark in test_method.pytestmark
+            if mark.name == 'parametrize'
+            for case in mark.args[1]
+        ]
+
+class TestHyp2f1ExtremeInputs:
+
+    @pytest.mark.parametrize("a", [1.0, 2.0, 3.0, -np.inf, np.inf])
+    @pytest.mark.parametrize("b", [3.0, 4.0, 5.0, -np.inf, np.inf])
+    @pytest.mark.parametrize("c", [3.0, 5.0, 6.0, 7.0])
+    @pytest.mark.parametrize("z", [4.0 + 1.0j])
+    def test_inf_a_b(self, a, b, c, z):
+        if np.any(np.isinf(np.asarray([a, b]))):
+            assert(np.isnan(hyp2f1(a, b, c, z)))
+
+    def test_large_a_b(self):
+        assert(np.isnan(hyp2f1(10**7, 1.0, 3.0, 4.0 + 1.0j)))
+        assert(np.isnan(hyp2f1(-10**7, 1.0, 3.0, 4.0 + 1.0j)))
+
+        assert(np.isnan(hyp2f1(1.0, 10**7, 3.0, 4.0 + 1.0j)))
+        assert(np.isnan(hyp2f1(1.0, -10**7, 3.0, 4.0 + 1.0j)))
+
+        # Already correct in main but testing for surety
+        assert(np.isnan(hyp2f1(np.inf, 1.0, 3.0, 4.0)))
+        assert(np.isnan(hyp2f1(1.0, np.inf, 3.0, 4.0)))

.venv/lib/python3.12/site-packages/scipy/special/tests/test_hypergeometric.py

@@ -0,0 +1,234 @@
+import pytest
+import numpy as np
+from numpy.testing import assert_allclose, assert_equal
+import scipy.special as sc
+
+
+class TestHyperu:
+
+    def test_negative_x(self):
+        a, b, x = np.meshgrid(
+            [-1, -0.5, 0, 0.5, 1],
+            [-1, -0.5, 0, 0.5, 1],
+            np.linspace(-100, -1, 10),
+        )
+        assert np.all(np.isnan(sc.hyperu(a, b, x)))
+
+    def test_special_cases(self):
+        assert sc.hyperu(0, 1, 1) == 1.0
+
+    @pytest.mark.parametrize('a', [0.5, 1, np.nan])
+    @pytest.mark.parametrize('b', [1, 2, np.nan])
+    @pytest.mark.parametrize('x', [0.25, 3, np.nan])
+    def test_nan_inputs(self, a, b, x):
+        assert np.isnan(sc.hyperu(a, b, x)) == np.any(np.isnan([a, b, x]))
+
+    @pytest.mark.parametrize(
+        'a,b,x,expected',
+        [(0.21581740448533887, 1.0, 1e-05, 3.6030558839391325),
+         (0.21581740448533887, 1.0, 0.00021544346900318823, 2.8783254988948976),
+         (0.21581740448533887, 1.0, 0.004641588833612777, 2.154928216691109),
+         (0.21581740448533887, 1.0, 0.1, 1.446546638718792),
+         (0.0030949064301273865, 1.0, 1e-05, 1.0356696454116199),
+         (0.0030949064301273865, 1.0, 0.00021544346900318823, 1.0261510362481985),
+         (0.0030949064301273865, 1.0, 0.004641588833612777, 1.0166326903402296),
+         (0.0030949064301273865, 1.0, 0.1, 1.0071174207698674),
+         (0.1509924314279033, 1.0, 1e-05, 2.806173846998948),
+         (0.1509924314279033, 1.0, 0.00021544346900318823, 2.3092158526816124),
+         (0.1509924314279033, 1.0, 0.004641588833612777, 1.812905980588048),
+         (0.1509924314279033, 1.0, 0.1, 1.3239738117634872),
+         (-0.010678995342969011, 1.0, 1e-05, 0.8775194903781114),
+         (-0.010678995342969011, 1.0, 0.00021544346900318823, 0.9101008998540128),
+         (-0.010678995342969011, 1.0, 0.004641588833612777, 0.9426854294058609),
+         (-0.010678995342969011, 1.0, 0.1, 0.9753065150174902),
+         (-0.06556622211831487, 1.0, 1e-05, 0.26435429752668904),
+         (-0.06556622211831487, 1.0, 0.00021544346900318823, 0.4574756033875781),
+         (-0.06556622211831487, 1.0, 0.004641588833612777, 0.6507121093358457),
+         (-0.06556622211831487, 1.0, 0.1, 0.8453129788602187),
+         (-0.21628242470175185, 1.0, 1e-05, -1.2318314201114489),
+         (-0.21628242470175185, 1.0, 0.00021544346900318823, -0.6704694233529538),
+         (-0.21628242470175185, 1.0, 0.004641588833612777, -0.10795098653682857),
+         (-0.21628242470175185, 1.0, 0.1, 0.4687227684115524)]
+    )
+    def test_gh_15650_mp(self, a, b, x, expected):
+        # See https://github.com/scipy/scipy/issues/15650
+        # b == 1, |a| < 0.25, 0 < x < 1
+        #
+        # This purpose of this test is to check the accuracy of results
+        # in the region that was impacted by gh-15650.
+        #
+        # Reference values computed with mpmath using the script:
+        #
+        # import itertools as it
+        # import numpy as np
+        #
+        # from mpmath import mp
+        #
+        # rng = np.random.default_rng(1234)
+        #
+        # cases = []
+        # for a, x in it.product(
+        #         np.random.uniform(-0.25, 0.25, size=6),
+        #         np.logspace(-5, -1, 4),
+        # ):
+        #     with mp.workdps(100):
+        #         cases.append((float(a), 1.0, float(x), float(mp.hyperu(a, 1.0, x))))
+        assert_allclose(sc.hyperu(a, b, x), expected, rtol=1e-13)
+
+    def test_gh_15650_sanity(self):
+        # The purpose of this test is to sanity check hyperu in the region that
+        # was impacted by gh-15650 by making sure there are no excessively large
+        # results, as were reported there.
+        a = np.linspace(-0.5, 0.5, 500)
+        x = np.linspace(1e-6, 1e-1, 500)
+        a, x = np.meshgrid(a, x)
+        results = sc.hyperu(a, 1.0, x)
+        assert np.all(np.abs(results) < 1e3)
+
+
+class TestHyp1f1:
+
+    @pytest.mark.parametrize('a, b, x', [
+        (np.nan, 1, 1),
+        (1, np.nan, 1),
+        (1, 1, np.nan)
+    ])
+    def test_nan_inputs(self, a, b, x):
+        assert np.isnan(sc.hyp1f1(a, b, x))
+
+    def test_poles(self):
+        assert_equal(sc.hyp1f1(1, [0, -1, -2, -3, -4], 0.5), np.inf)
+
+    @pytest.mark.parametrize('a, b, x, result', [
+        (-1, 1, 0.5, 0.5),
+        (1, 1, 0.5, 1.6487212707001281468),
+        (2, 1, 0.5, 2.4730819060501922203),
+        (1, 2, 0.5, 1.2974425414002562937),
+        (-10, 1, 0.5, -0.38937441413785204475)
+    ])
+    def test_special_cases(self, a, b, x, result):
+        # Hit all the special case branches at the beginning of the
+        # function. Desired answers computed using Mpmath.
+        assert_allclose(sc.hyp1f1(a, b, x), result, atol=0, rtol=1e-15)
+
+    @pytest.mark.parametrize('a, b, x, result', [
+        (1, 1, 0.44, 1.5527072185113360455),
+        (-1, 1, 0.44, 0.55999999999999999778),
+        (100, 100, 0.89, 2.4351296512898745592),
+        (-100, 100, 0.89, 0.40739062490768104667),
+        (1.5, 100, 59.99, 3.8073513625965598107),
+        (-1.5, 100, 59.99, 0.25099240047125826943)
+    ])
+    def test_geometric_convergence(self, a, b, x, result):
+        # Test the region where we are relying on the ratio of
+        #
+        # (|a| + 1) * |x| / |b|
+        #
+        # being small. Desired answers computed using Mpmath
+        assert_allclose(sc.hyp1f1(a, b, x), result, atol=0, rtol=1e-15)
+
+    @pytest.mark.parametrize('a, b, x, result', [
+        (-1, 1, 1.5, -0.5),
+        (-10, 1, 1.5, 0.41801777430943080357),
+        (-25, 1, 1.5, 0.25114491646037839809),
+        (-50, 1, 1.5, -0.25683643975194756115),
+        (-80, 1, 1.5, -0.24554329325751503601),
+        (-150, 1, 1.5, -0.173364795515420454496),
+    ])
+    def test_a_negative_integer(self, a, b, x, result):
+        # Desired answers computed using Mpmath.
+        assert_allclose(sc.hyp1f1(a, b, x), result, atol=0, rtol=2e-14)
+
+    @pytest.mark.parametrize('a, b, x, expected', [
+        (0.01, 150, -4, 0.99973683897677527773),        # gh-3492
+        (1, 5, 0.01, 1.0020033381011970966),            # gh-3593
+        (50, 100, 0.01, 1.0050126452421463411),         # gh-3593
+        (1, 0.3, -1e3, -7.011932249442947651455e-04),   # gh-14149
+        (1, 0.3, -1e4, -7.001190321418937164734e-05),   # gh-14149
+        (9, 8.5, -350, -5.224090831922378361082e-20),   # gh-17120
+        (9, 8.5, -355, -4.595407159813368193322e-20),   # gh-17120
+        (75, -123.5, 15, 3.425753920814889017493e+06),
+    ])
+    def test_assorted_cases(self, a, b, x, expected):
+        # Expected values were computed with mpmath.hyp1f1(a, b, x).
+        assert_allclose(sc.hyp1f1(a, b, x), expected, atol=0, rtol=1e-14)
+
+    def test_a_neg_int_and_b_equal_x(self):
+        # This is a case where the Boost wrapper will call hypergeometric_pFq
+        # instead of hypergeometric_1F1.  When we use a version of Boost in
+        # which https://github.com/boostorg/math/issues/833 is fixed, this
+        # test case can probably be moved into test_assorted_cases.
+        # The expected value was computed with mpmath.hyp1f1(a, b, x).
+        a = -10.0
+        b = 2.5
+        x = 2.5
+        expected = 0.0365323664364104338721
+        computed = sc.hyp1f1(a, b, x)
+        assert_allclose(computed, expected, atol=0, rtol=1e-13)
+
+    @pytest.mark.parametrize('a, b, x, desired', [
+        (-1, -2, 2, 2),
+        (-1, -4, 10, 3.5),
+        (-2, -2, 1, 2.5)
+    ])
+    def test_gh_11099(self, a, b, x, desired):
+        # All desired results computed using Mpmath
+        assert sc.hyp1f1(a, b, x) == desired
+
+    @pytest.mark.parametrize('a', [-3, -2])
+    def test_x_zero_a_and_b_neg_ints_and_a_ge_b(self, a):
+        assert sc.hyp1f1(a, -3, 0) == 1
+
+    # In the following tests with complex z, the reference values
+    # were computed with mpmath.hyp1f1(a, b, z), and verified with
+    # Wolfram Alpha Hypergeometric1F1(a, b, z), except for the
+    # case a=0.1, b=1, z=7-24j, where Wolfram Alpha reported
+    # "Standard computation time exceeded".  That reference value
+    # was confirmed in an online Matlab session, with the commands
+    #
+    #  > format long
+    #  > hypergeom(0.1, 1, 7-24i)
+    #  ans =
+    #   -3.712349651834209 + 4.554636556672912i
+    #
+    @pytest.mark.parametrize(
+        'a, b, z, ref',
+        [(-0.25, 0.5, 1+2j, 1.1814553180903435-1.2792130661292984j),
+         (0.25, 0.5, 1+2j, 0.24636797405707597+1.293434354945675j),
+         (25, 1.5, -2j, -516.1771262822523+407.04142751922024j),
+         (12, -1.5, -10+20j, -5098507.422706547-1341962.8043508842j),
+         pytest.param(
+             10, 250, 10-15j, 1.1985998416598884-0.8613474402403436j,
+             marks=pytest.mark.xfail,
+         ),
+         pytest.param(
+             0.1, 1, 7-24j, -3.712349651834209+4.554636556672913j,
+             marks=pytest.mark.xfail,
+         )
+         ],
+    )
+    def test_complex_z(self, a, b, z, ref):
+        h = sc.hyp1f1(a, b, z)
+        assert_allclose(h, ref, rtol=4e-15)
+
+    # The "legacy edge cases" mentioned in the comments in the following
+    # tests refers to the behavior of hyp1f1(a, b, x) when b is a nonpositive
+    # integer.  In some subcases, the behavior of SciPy does not match that
+    # of Boost (1.81+), mpmath and Mathematica (via Wolfram Alpha online).
+    # If the handling of these edges cases is changed to agree with those
+    # libraries, these test will have to be updated.
+
+    @pytest.mark.parametrize('b', [0, -1, -5])
+    def test_legacy_case1(self, b):
+        # Test results of hyp1f1(0, n, x) for n <= 0.
+        # This is a legacy edge case.
+        # Boost (versions greater than 1.80), Mathematica (via Wolfram Alpha
+        # online) and mpmath all return 1 in this case, but SciPy's hyp1f1
+        # returns inf.
+        assert_equal(sc.hyp1f1(0, b, [-1.5, 0, 1.5]), [np.inf, np.inf, np.inf])
+
+    def test_legacy_case2(self):
+        # This is a legacy edge case.
+        # In software such as boost (1.81+), mpmath and Mathematica,
+        # the value is 1.
+        assert sc.hyp1f1(-4, -3, 0) == np.inf

.venv/lib/python3.12/site-packages/scipy/special/tests/test_iv_ratio.py

@@ -0,0 +1,249 @@
+# This file contains unit tests for iv_ratio() and related functions.
+
+import pytest
+import numpy as np
+from numpy.testing import assert_equal, assert_allclose
+from scipy.special._ufuncs import (  # type: ignore[attr-defined]
+    _iv_ratio as iv_ratio,
+    _iv_ratio_c as iv_ratio_c,
+)
+
+
+class TestIvRatio:
+
+    @pytest.mark.parametrize('v,x,r', [
+        (0.5, 0.16666666666666666, 0.16514041292462933),
+        (0.5, 0.3333333333333333, 0.32151273753163434),
+        (0.5, 0.5, 0.46211715726000974),
+        (0.5, 0.6666666666666666, 0.5827829453479101),
+        (0.5, 0.8333333333333335, 0.6822617902381698),
+        (1, 0.3380952380952381, 0.1666773049170313),
+        (1, 0.7083333333333333, 0.33366443586989925),
+        (1, 1.1666666666666667, 0.5023355231537423),
+        (1, 1.8666666666666665, 0.674616572252164),
+        (1, 3.560606060606061, 0.844207659503163),
+        (2.34, 0.7975238095238094, 0.16704903081553285),
+        (2.34, 1.7133333333333334, 0.3360215931268845),
+        (2.34, 2.953333333333333, 0.50681909317803),
+        (2.34, 5.0826666666666656, 0.6755252698800679),
+        (2.34, 10.869696969696973, 0.8379351104498762),
+        (56.789, 19.46575238095238, 0.1667020505391409),
+        (56.789, 42.55008333333333, 0.33353809996933026),
+        (56.789, 75.552, 0.5003932381177826),
+        (56.789, 135.76026666666667, 0.6670528221946127),
+        (56.789, 307.8642424242425, 0.8334999441460798),
+    ])
+    def test_against_reference_values(self, v, x, r):
+        """The reference values are computed using mpmath as follows.
+
+        from mpmath import mp
+        mp.dps = 100
+
+        def iv_ratio_mp(v, x):
+            return mp.besseli(v, x) / mp.besseli(v - 1, x)
+
+        def _sample(n, *, v):
+            '''Return n positive real numbers x such that iv_ratio(v, x) are
+            roughly evenly spaced over (0, 1).  The formula is taken from [1].
+
+            [1] Banerjee A., Dhillon, I. S., Ghosh, J., Sra, S. (2005).
+                "Clustering on the Unit Hypersphere using von Mises-Fisher
+                Distributions."  Journal of Machine Learning Research,
+                6(46):1345-1382.
+            '''
+            r = np.arange(1, n+1) / (n+1)
+            return r * (2*v-r*r) / (1-r*r)
+
+        for v in (0.5, 1, 2.34, 56.789):
+            xs = _sample(5, v=v)
+            for x in xs:
+                print(f"({v}, {x}, {float(iv_ratio_mp(v,x))}),")
+        """
+        assert_allclose(iv_ratio(v, x), r, rtol=4e-16, atol=0)
+
+    @pytest.mark.parametrize('v,x,r', [
+        (1, np.inf, 1),
+        (np.inf, 1, 0),
+    ])
+    def test_inf(self, v, x, r):
+        """If exactly one of v or x is inf and the other is within domain,
+        should return 0 or 1 accordingly."""
+        assert_equal(iv_ratio(v, x), r)
+
+    @pytest.mark.parametrize('v', [0.49, -np.inf, np.nan, np.inf])
+    @pytest.mark.parametrize('x', [-np.finfo(float).smallest_normal,
+                                   -np.finfo(float).smallest_subnormal,
+                                   -np.inf, np.nan, np.inf])
+    def test_nan(self, v, x):
+        """If at least one argument is out of domain, or if v = x = inf,
+        the function should return nan."""
+        assert_equal(iv_ratio(v, x), np.nan)
+
+    @pytest.mark.parametrize('v', [0.5, 1, np.finfo(float).max, np.inf])
+    def test_zero_x(self, v):
+        """If x is +/-0.0, return x to ensure iv_ratio is an odd function."""
+        assert_equal(iv_ratio(v, 0.0), 0.0)
+        assert_equal(iv_ratio(v, -0.0), -0.0)
+
+    @pytest.mark.parametrize('v,x', [
+        (1, np.finfo(float).smallest_normal),
+        (1, np.finfo(float).smallest_subnormal),
+        (1, np.finfo(float).smallest_subnormal*2),
+        (1e20, 123),
+        (np.finfo(float).max, 1),
+        (np.finfo(float).max, np.sqrt(np.finfo(float).max)),
+    ])
+    def test_tiny_x(self, v, x):
+        """If x is much less than v, the bounds
+
+                    x                                 x
+        --------------------------- <= R <= -----------------------
+        v-0.5+sqrt(x**2+(v+0.5)**2)         v-1+sqrt(x**2+(v+1)**2)
+
+        collapses to R ~= x/2v.  Test against this asymptotic expression.
+        """
+        assert_equal(iv_ratio(v, x), (0.5*x)/v)
+
+    @pytest.mark.parametrize('v,x', [
+        (1, 1e16),
+        (1e20, 1e40),
+        (np.sqrt(np.finfo(float).max), np.finfo(float).max),
+    ])
+    def test_huge_x(self, v, x):
+        """If x is much greater than v, the bounds
+
+                    x                                 x
+        --------------------------- <= R <= ---------------------------
+        v-0.5+sqrt(x**2+(v+0.5)**2)         v-0.5+sqrt(x**2+(v-0.5)**2)
+
+        collapses to R ~= 1.  Test against this asymptotic expression.
+        """
+        assert_equal(iv_ratio(v, x), 1.0)
+
+    @pytest.mark.parametrize('v,x', [
+        (np.finfo(float).max, np.finfo(float).max),
+        (np.finfo(float).max / 3, np.finfo(float).max),
+        (np.finfo(float).max, np.finfo(float).max / 3),
+    ])
+    def test_huge_v_x(self, v, x):
+        """If both x and v are very large, the bounds
+
+                    x                                 x
+        --------------------------- <= R <= -----------------------
+        v-0.5+sqrt(x**2+(v+0.5)**2)         v-1+sqrt(x**2+(v+1)**2)
+
+        collapses to R ~= x/(v+sqrt(x**2+v**2).  Test against this asymptotic
+        expression, and in particular that no numerical overflow occurs during
+        intermediate calculations.
+        """
+        t = x / v
+        expected = t / (1 + np.hypot(1, t))
+        assert_allclose(iv_ratio(v, x), expected, rtol=4e-16, atol=0)
+
+
+class TestIvRatioC:
+
+    @pytest.mark.parametrize('v,x,r', [
+        (0.5, 0.16666666666666666, 0.8348595870753707),
+        (0.5, 0.3333333333333333, 0.6784872624683657),
+        (0.5, 0.5, 0.5378828427399902),
+        (0.5, 0.6666666666666666, 0.4172170546520899),
+        (0.5, 0.8333333333333335, 0.3177382097618302),
+        (1, 0.3380952380952381, 0.8333226950829686),
+        (1, 0.7083333333333333, 0.6663355641301008),
+        (1, 1.1666666666666667, 0.4976644768462577),
+        (1, 1.8666666666666665, 0.325383427747836),
+        (1, 3.560606060606061, 0.155792340496837),
+        (2.34, 0.7975238095238094, 0.8329509691844672),
+        (2.34, 1.7133333333333334, 0.6639784068731155),
+        (2.34, 2.953333333333333, 0.49318090682197),
+        (2.34, 5.0826666666666656, 0.3244747301199321),
+        (2.34, 10.869696969696973, 0.16206488955012377),
+        (56.789, 19.46575238095238, 0.8332979494608591),
+        (56.789, 42.55008333333333, 0.6664619000306697),
+        (56.789, 75.552, 0.4996067618822174),
+        (56.789, 135.76026666666667, 0.3329471778053873),
+        (56.789, 307.8642424242425, 0.16650005585392025),
+    ])
+    def test_against_reference_values(self, v, x, r):
+        """The reference values are one minus those of TestIvRatio."""
+        assert_allclose(iv_ratio_c(v, x), r, rtol=1e-15, atol=0)
+
+    @pytest.mark.parametrize('v,x,r', [
+        (1, np.inf, 0),
+        (np.inf, 1, 1),
+    ])
+    def test_inf(self, v, x, r):
+        """If exactly one of v or x is inf and the other is within domain,
+        should return 0 or 1 accordingly."""
+        assert_equal(iv_ratio_c(v, x), r)
+
+    @pytest.mark.parametrize('v', [0.49, -np.inf, np.nan, np.inf])
+    @pytest.mark.parametrize('x', [-np.finfo(float).smallest_normal,
+                                   -np.finfo(float).smallest_subnormal,
+                                   -np.inf, np.nan, np.inf])
+    def test_nan(self, v, x):
+        """If at least one argument is out of domain, or if v = x = inf,
+        the function should return nan."""
+        assert_equal(iv_ratio_c(v, x), np.nan)
+
+    @pytest.mark.parametrize('v', [0.5, 1, np.finfo(float).max, np.inf])
+    def test_zero_x(self, v):
+        """If x is +/-0.0, return 1."""
+        assert_equal(iv_ratio_c(v, 0.0), 1.0)
+        assert_equal(iv_ratio_c(v, -0.0), 1.0)
+
+    @pytest.mark.parametrize('v,x', [
+        (1, np.finfo(float).smallest_normal),
+        (1, np.finfo(float).smallest_subnormal),
+        (1, np.finfo(float).smallest_subnormal*2),
+        (1e20, 123),
+        (np.finfo(float).max, 1),
+        (np.finfo(float).max, np.sqrt(np.finfo(float).max)),
+    ])
+    def test_tiny_x(self, v, x):
+        """If x is much less than v, the bounds
+
+                    x                                 x
+        --------------------------- <= R <= -----------------------
+        v-0.5+sqrt(x**2+(v+0.5)**2)         v-1+sqrt(x**2+(v+1)**2)
+
+        collapses to 1-R ~= 1-x/2v.  Test against this asymptotic expression.
+        """
+        assert_equal(iv_ratio_c(v, x), 1.0-(0.5*x)/v)
+
+    @pytest.mark.parametrize('v,x', [
+        (1, 1e16),
+        (1e20, 1e40),
+        (np.sqrt(np.finfo(float).max), np.finfo(float).max),
+    ])
+    def test_huge_x(self, v, x):
+        """If x is much greater than v, the bounds
+
+                    x                                 x
+        --------------------------- <= R <= ---------------------------
+        v-0.5+sqrt(x**2+(v+0.5)**2)         v-0.5+sqrt(x**2+(v-0.5)**2)
+
+        collapses to 1-R ~= (v-0.5)/x.  Test against this asymptotic expression.
+        """
+        assert_allclose(iv_ratio_c(v, x), (v-0.5)/x, rtol=1e-15, atol=0)
+
+    @pytest.mark.parametrize('v,x', [
+        (np.finfo(float).max, np.finfo(float).max),
+        (np.finfo(float).max / 3, np.finfo(float).max),
+        (np.finfo(float).max, np.finfo(float).max / 3),
+    ])
+    def test_huge_v_x(self, v, x):
+        """If both x and v are very large, the bounds
+
+                    x                                 x
+        --------------------------- <= R <= -----------------------
+        v-0.5+sqrt(x**2+(v+0.5)**2)         v-1+sqrt(x**2+(v+1)**2)
+
+        collapses to 1 - R ~= 1 - x/(v+sqrt(x**2+v**2).  Test against this
+        asymptotic expression, and in particular that no numerical overflow
+        occurs during intermediate calculations.
+        """
+        t = x / v
+        expected = 1 - t / (1 + np.hypot(1, t))
+        assert_allclose(iv_ratio_c(v, x), expected, rtol=4e-16, atol=0)

.venv/lib/python3.12/site-packages/scipy/special/tests/test_kolmogorov.py

@@ -0,0 +1,491 @@
+import itertools
+
+import numpy as np
+from numpy.testing import assert_
+from scipy.special._testutils import FuncData
+
+from scipy.special import kolmogorov, kolmogi, smirnov, smirnovi
+from scipy.special._ufuncs import (_kolmogc, _kolmogci, _kolmogp,
+                                   _smirnovc, _smirnovci, _smirnovp)
+
+_rtol = 1e-10
+
+class TestSmirnov:
+    def test_nan(self):
+        assert_(np.isnan(smirnov(1, np.nan)))
+
+    def test_basic(self):
+        dataset = [(1, 0.1, 0.9),
+                   (1, 0.875, 0.125),
+                   (2, 0.875, 0.125 * 0.125),
+                   (3, 0.875, 0.125 * 0.125 * 0.125)]
+
+        dataset = np.asarray(dataset)
+        FuncData(
+            smirnov, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+        dataset[:, -1] = 1 - dataset[:, -1]
+        FuncData(
+            _smirnovc, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+
+    def test_x_equals_0(self):
+        dataset = [(n, 0, 1) for n in itertools.chain(range(2, 20), range(1010, 1020))]
+        dataset = np.asarray(dataset)
+        FuncData(
+            smirnov, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+        dataset[:, -1] = 1 - dataset[:, -1]
+        FuncData(
+            _smirnovc, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+
+    def test_x_equals_1(self):
+        dataset = [(n, 1, 0) for n in itertools.chain(range(2, 20), range(1010, 1020))]
+        dataset = np.asarray(dataset)
+        FuncData(
+            smirnov, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+        dataset[:, -1] = 1 - dataset[:, -1]
+        FuncData(
+            _smirnovc, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+
+    def test_x_equals_0point5(self):
+        dataset = [(1, 0.5, 0.5),
+                   (2, 0.5, 0.25),
+                   (3, 0.5, 0.166666666667),
+                   (4, 0.5, 0.09375),
+                   (5, 0.5, 0.056),
+                   (6, 0.5, 0.0327932098765),
+                   (7, 0.5, 0.0191958707681),
+                   (8, 0.5, 0.0112953186035),
+                   (9, 0.5, 0.00661933257355),
+                   (10, 0.5, 0.003888705)]
+
+        dataset = np.asarray(dataset)
+        FuncData(
+            smirnov, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+        dataset[:, -1] = 1 - dataset[:, -1]
+        FuncData(
+            _smirnovc, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+
+    def test_n_equals_1(self):
+        x = np.linspace(0, 1, 101, endpoint=True)
+        dataset = np.column_stack([[1]*len(x), x, 1-x])
+        FuncData(
+            smirnov, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+        dataset[:, -1] = 1 - dataset[:, -1]
+        FuncData(
+            _smirnovc, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+
+    def test_n_equals_2(self):
+        x = np.linspace(0.5, 1, 101, endpoint=True)
+        p = np.power(1-x, 2)
+        n = np.array([2] * len(x))
+        dataset = np.column_stack([n, x, p])
+        FuncData(
+            smirnov, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+        dataset[:, -1] = 1 - dataset[:, -1]
+        FuncData(
+            _smirnovc, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+
+    def test_n_equals_3(self):
+        x = np.linspace(0.7, 1, 31, endpoint=True)
+        p = np.power(1-x, 3)
+        n = np.array([3] * len(x))
+        dataset = np.column_stack([n, x, p])
+        FuncData(
+            smirnov, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+        dataset[:, -1] = 1 - dataset[:, -1]
+        FuncData(
+            _smirnovc, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+
+    def test_n_large(self):
+        # test for large values of n
+        # Probabilities should go down as n goes up
+        x = 0.4
+        pvals = np.array([smirnov(n, x) for n in range(400, 1100, 20)])
+        dfs = np.diff(pvals)
+        assert_(np.all(dfs <= 0), msg=f'Not all diffs negative {dfs}')
+
+
+class TestSmirnovi:
+    def test_nan(self):
+        assert_(np.isnan(smirnovi(1, np.nan)))
+
+    def test_basic(self):
+        dataset = [(1, 0.4, 0.6),
+                   (1, 0.6, 0.4),
+                   (1, 0.99, 0.01),
+                   (1, 0.01, 0.99),
+                   (2, 0.125 * 0.125, 0.875),
+                   (3, 0.125 * 0.125 * 0.125, 0.875),
+                   (10, 1.0 / 16 ** 10, 1 - 1.0 / 16)]
+
+        dataset = np.asarray(dataset)
+        FuncData(
+            smirnovi, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+        dataset[:, 1] = 1 - dataset[:, 1]
+        FuncData(
+            _smirnovci, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+
+    def test_x_equals_0(self):
+        dataset = [(n, 0, 1) for n in itertools.chain(range(2, 20), range(1010, 1020))]
+        dataset = np.asarray(dataset)
+        FuncData(
+            smirnovi, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+        dataset[:, 1] = 1 - dataset[:, 1]
+        FuncData(
+            _smirnovci, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+
+    def test_x_equals_1(self):
+        dataset = [(n, 1, 0) for n in itertools.chain(range(2, 20), range(1010, 1020))]
+        dataset = np.asarray(dataset)
+        FuncData(
+            smirnovi, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+        dataset[:, 1] = 1 - dataset[:, 1]
+        FuncData(
+            _smirnovci, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+
+    def test_n_equals_1(self):
+        pp = np.linspace(0, 1, 101, endpoint=True)
+        # dataset = np.array([(1, p, 1-p) for p in pp])
+        dataset = np.column_stack([[1]*len(pp), pp, 1-pp])
+        FuncData(
+            smirnovi, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+        dataset[:, 1] = 1 - dataset[:, 1]
+        FuncData(
+            _smirnovci, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+
+    def test_n_equals_2(self):
+        x = np.linspace(0.5, 1, 101, endpoint=True)
+        p = np.power(1-x, 2)
+        n = np.array([2] * len(x))
+        dataset = np.column_stack([n, p, x])
+        FuncData(
+            smirnovi, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+        dataset[:, 1] = 1 - dataset[:, 1]
+        FuncData(
+            _smirnovci, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+
+    def test_n_equals_3(self):
+        x = np.linspace(0.7, 1, 31, endpoint=True)
+        p = np.power(1-x, 3)
+        n = np.array([3] * len(x))
+        dataset = np.column_stack([n, p, x])
+        FuncData(
+            smirnovi, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+        dataset[:, 1] = 1 - dataset[:, 1]
+        FuncData(
+            _smirnovci, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+
+    def test_round_trip(self):
+        def _sm_smi(n, p):
+            return smirnov(n, smirnovi(n, p))
+
+        def _smc_smci(n, p):
+            return _smirnovc(n, _smirnovci(n, p))
+
+        dataset = [(1, 0.4, 0.4),
+                   (1, 0.6, 0.6),
+                   (2, 0.875, 0.875),
+                   (3, 0.875, 0.875),
+                   (3, 0.125, 0.125),
+                   (10, 0.999, 0.999),
+                   (10, 0.0001, 0.0001)]
+
+        dataset = np.asarray(dataset)
+        FuncData(
+            _sm_smi, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+        FuncData(
+            _smc_smci, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+
+    def test_x_equals_0point5(self):
+        dataset = [(1, 0.5, 0.5),
+                   (2, 0.5, 0.366025403784),
+                   (2, 0.25, 0.5),
+                   (3, 0.5, 0.297156508177),
+                   (4, 0.5, 0.255520481121),
+                   (5, 0.5, 0.234559536069),
+                   (6, 0.5, 0.21715965898),
+                   (7, 0.5, 0.202722580034),
+                   (8, 0.5, 0.190621765256),
+                   (9, 0.5, 0.180363501362),
+                   (10, 0.5, 0.17157867006)]
+
+        dataset = np.asarray(dataset)
+        FuncData(
+            smirnovi, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+        dataset[:, 1] = 1 - dataset[:, 1]
+        FuncData(
+            _smirnovci, dataset, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+
+
+class TestSmirnovp:
+    def test_nan(self):
+        assert_(np.isnan(_smirnovp(1, np.nan)))
+
+    def test_basic(self):
+        # Check derivative at endpoints
+        n1_10 = np.arange(1, 10)
+        dataset0 = np.column_stack([n1_10,
+                                    np.full_like(n1_10, 0),
+                                    np.full_like(n1_10, -1)])
+        FuncData(
+            _smirnovp, dataset0, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+
+        n2_10 = np.arange(2, 10)
+        dataset1 = np.column_stack([n2_10,
+                                    np.full_like(n2_10, 1.0),
+                                    np.full_like(n2_10, 0)])
+        FuncData(
+            _smirnovp, dataset1, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+
+    def test_oneminusoneovern(self):
+        # Check derivative at x=1-1/n
+        n = np.arange(1, 20)
+        x = 1.0/n
+        xm1 = 1-1.0/n
+        pp1 = -n * x**(n-1)
+        pp1 -= (1-np.sign(n-2)**2) * 0.5  # n=2, x=0.5, 1-1/n = 0.5, need to adjust
+        dataset1 = np.column_stack([n, xm1, pp1])
+        FuncData(
+            _smirnovp, dataset1, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+
+    def test_oneovertwon(self):
+        # Check derivative at x=1/2n  (Discontinuous at x=1/n, so check at x=1/2n)
+        n = np.arange(1, 20)
+        x = 1.0/2/n
+        pp = -(n*x+1) * (1+x)**(n-2)
+        dataset0 = np.column_stack([n, x, pp])
+        FuncData(
+            _smirnovp, dataset0, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+
+    def test_oneovern(self):
+        # Check derivative at x=1/n
+        # (Discontinuous at x=1/n, hard to tell if x==1/n, only use n=power of 2)
+        n = 2**np.arange(1, 10)
+        x = 1.0/n
+        pp = -(n*x+1) * (1+x)**(n-2) + 0.5
+        dataset0 = np.column_stack([n, x, pp])
+        FuncData(
+            _smirnovp, dataset0, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+
+    def test_oneovernclose(self):
+        # Check derivative at x=1/n
+        # (Discontinuous at x=1/n, test on either side: x=1/n +/- 2epsilon)
+        n = np.arange(3, 20)
+
+        x = 1.0/n - 2*np.finfo(float).eps
+        pp = -(n*x+1) * (1+x)**(n-2)
+        dataset0 = np.column_stack([n, x, pp])
+        FuncData(
+            _smirnovp, dataset0, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+
+        x = 1.0/n + 2*np.finfo(float).eps
+        pp = -(n*x+1) * (1+x)**(n-2) + 1
+        dataset1 = np.column_stack([n, x, pp])
+        FuncData(
+            _smirnovp, dataset1, (0, 1), 2, rtol=_rtol
+        ).check(dtypes=[int, float, float])
+
+
+class TestKolmogorov:
+    def test_nan(self):
+        assert_(np.isnan(kolmogorov(np.nan)))
+
+    def test_basic(self):
+        dataset = [(0, 1.0),
+                   (0.5, 0.96394524366487511),
+                   (0.8275735551899077, 0.5000000000000000),
+                   (1, 0.26999967167735456),
+                   (2, 0.00067092525577969533)]
+
+        dataset = np.asarray(dataset)
+        FuncData(kolmogorov, dataset, (0,), 1, rtol=_rtol).check()
+
+    def test_linspace(self):
+        x = np.linspace(0, 2.0, 21)
+        dataset = [1.0000000000000000, 1.0000000000000000, 0.9999999999994950,
+                   0.9999906941986655, 0.9971923267772983, 0.9639452436648751,
+                   0.8642827790506042, 0.7112351950296890, 0.5441424115741981,
+                   0.3927307079406543, 0.2699996716773546, 0.1777181926064012,
+                   0.1122496666707249, 0.0680922218447664, 0.0396818795381144,
+                   0.0222179626165251, 0.0119520432391966, 0.0061774306344441,
+                   0.0030676213475797, 0.0014636048371873, 0.0006709252557797]
+
+        dataset_c = [0.0000000000000000, 6.609305242245699e-53, 5.050407338670114e-13,
+                     9.305801334566668e-06, 0.0028076732227017, 0.0360547563351249,
+                     0.1357172209493958, 0.2887648049703110, 0.4558575884258019,
+                     0.6072692920593457, 0.7300003283226455, 0.8222818073935988,
+                     0.8877503333292751, 0.9319077781552336, 0.9603181204618857,
+                     0.9777820373834749, 0.9880479567608034, 0.9938225693655559,
+                     0.9969323786524203, 0.9985363951628127, 0.9993290747442203]
+
+        dataset = np.column_stack([x, dataset])
+        FuncData(kolmogorov, dataset, (0,), 1, rtol=_rtol).check()
+        dataset_c = np.column_stack([x, dataset_c])
+        FuncData(_kolmogc, dataset_c, (0,), 1, rtol=_rtol).check()
+
+    def test_linspacei(self):
+        p = np.linspace(0, 1.0, 21, endpoint=True)
+        dataset = [np.inf, 1.3580986393225507, 1.2238478702170823,
+                   1.1379465424937751, 1.0727491749396481, 1.0191847202536859,
+                   0.9730633753323726, 0.9320695842357622, 0.8947644549851197,
+                   0.8601710725555463, 0.8275735551899077, 0.7964065373291559,
+                   0.7661855555617682, 0.7364542888171910, 0.7067326523068980,
+                   0.6764476915028201, 0.6448126061663567, 0.6105590999244391,
+                   0.5711732651063401, 0.5196103791686224, 0.0000000000000000]
+
+        dataset_c = [0.0000000000000000, 0.5196103791686225, 0.5711732651063401,
+                     0.6105590999244391, 0.6448126061663567, 0.6764476915028201,
+                     0.7067326523068980, 0.7364542888171910, 0.7661855555617682,
+                     0.7964065373291559, 0.8275735551899077, 0.8601710725555463,
+                     0.8947644549851196, 0.9320695842357622, 0.9730633753323727,
+                     1.0191847202536859, 1.0727491749396481, 1.1379465424937754,
+                     1.2238478702170825, 1.3580986393225509, np.inf]
+
+        dataset = np.column_stack([p[1:], dataset[1:]])
+        FuncData(kolmogi, dataset, (0,), 1, rtol=_rtol).check()
+        dataset_c = np.column_stack([p[:-1], dataset_c[:-1]])
+        FuncData(_kolmogci, dataset_c, (0,), 1, rtol=_rtol).check()
+
+    def test_smallx(self):
+        epsilon = 0.1 ** np.arange(1, 14)
+        x = np.array([0.571173265106, 0.441027698518, 0.374219690278, 0.331392659217,
+                      0.300820537459, 0.277539353999, 0.259023494805, 0.243829561254,
+                      0.231063086389, 0.220135543236, 0.210641372041, 0.202290283658,
+                      0.19487060742])
+
+        dataset = np.column_stack([x, 1-epsilon])
+        FuncData(kolmogorov, dataset, (0,), 1, rtol=_rtol).check()
+
+    def test_round_trip(self):
+        def _ki_k(_x):
+            return kolmogi(kolmogorov(_x))
+
+        def _kci_kc(_x):
+            return _kolmogci(_kolmogc(_x))
+
+        x = np.linspace(0.0, 2.0, 21, endpoint=True)
+        # Exclude 0.1, 0.2.  0.2 almost makes succeeds, but 0.1 has no chance.
+        x02 = x[(x == 0) | (x > 0.21)]
+        dataset02 = np.column_stack([x02, x02])
+        FuncData(_ki_k, dataset02, (0,), 1, rtol=_rtol).check()
+
+        dataset = np.column_stack([x, x])
+        FuncData(_kci_kc, dataset, (0,), 1, rtol=_rtol).check()
+
+
+class TestKolmogi:
+    def test_nan(self):
+        assert_(np.isnan(kolmogi(np.nan)))
+
+    def test_basic(self):
+        dataset = [(1.0, 0),
+                   (0.96394524366487511, 0.5),
+                   (0.9, 0.571173265106),
+                   (0.5000000000000000, 0.8275735551899077),
+                   (0.26999967167735456, 1),
+                   (0.00067092525577969533, 2)]
+
+        dataset = np.asarray(dataset)
+        FuncData(kolmogi, dataset, (0,), 1, rtol=_rtol).check()
+
+    def test_smallpcdf(self):
+        epsilon = 0.5 ** np.arange(1, 55, 3)
+        # kolmogi(1-p) == _kolmogci(p) if  1-(1-p) == p, but not necessarily otherwise
+        # Use epsilon s.t. 1-(1-epsilon)) == epsilon,
+        # so can use same x-array for both results
+
+        x = np.array([0.8275735551899077, 0.5345255069097583, 0.4320114038786941,
+                      0.3736868442620478, 0.3345161714909591, 0.3057833329315859,
+                      0.2835052890528936, 0.2655578150208676, 0.2506869966107999,
+                      0.2380971058736669, 0.2272549289962079, 0.2177876361600040,
+                      0.2094254686862041, 0.2019676748836232, 0.1952612948137504,
+                      0.1891874239646641, 0.1836520225050326, 0.1785795904846466])
+
+        dataset = np.column_stack([1-epsilon, x])
+        FuncData(kolmogi, dataset, (0,), 1, rtol=_rtol).check()
+
+        dataset = np.column_stack([epsilon, x])
+        FuncData(_kolmogci, dataset, (0,), 1, rtol=_rtol).check()
+
+    def test_smallpsf(self):
+        epsilon = 0.5 ** np.arange(1, 55, 3)
+        # kolmogi(p) == _kolmogci(1-p) if  1-(1-p) == p, but not necessarily otherwise
+        # Use epsilon s.t. 1-(1-epsilon)) == epsilon,
+        # so can use same x-array for both results
+
+        x = np.array([0.8275735551899077, 1.3163786275161036, 1.6651092133663343,
+                      1.9525136345289607, 2.2027324540033235, 2.4272929437460848,
+                      2.6327688477341593, 2.8233300509220260, 3.0018183401530627,
+                      3.1702735084088891, 3.3302184446307912, 3.4828258153113318,
+                      3.6290214150152051, 3.7695513262825959, 3.9050272690877326,
+                      4.0359582187082550, 4.1627730557884890, 4.2858371743264527])
+
+        dataset = np.column_stack([epsilon, x])
+        FuncData(kolmogi, dataset, (0,), 1, rtol=_rtol).check()
+
+        dataset = np.column_stack([1-epsilon, x])
+        FuncData(_kolmogci, dataset, (0,), 1, rtol=_rtol).check()
+
+    def test_round_trip(self):
+        def _k_ki(_p):
+            return kolmogorov(kolmogi(_p))
+
+        p = np.linspace(0.1, 1.0, 10, endpoint=True)
+        dataset = np.column_stack([p, p])
+        FuncData(_k_ki, dataset, (0,), 1, rtol=_rtol).check()
+
+
+class TestKolmogp:
+    def test_nan(self):
+        assert_(np.isnan(_kolmogp(np.nan)))
+
+    def test_basic(self):
+        dataset = [(0.000000, -0.0),
+                   (0.200000, -1.532420541338916e-10),
+                   (0.400000, -0.1012254419260496),
+                   (0.600000, -1.324123244249925),
+                   (0.800000, -1.627024345636592),
+                   (1.000000, -1.071948558356941),
+                   (1.200000, -0.538512430720529),
+                   (1.400000, -0.2222133182429472),
+                   (1.600000, -0.07649302775520538),
+                   (1.800000, -0.02208687346347873),
+                   (2.000000, -0.005367402045629683)]
+
+        dataset = np.asarray(dataset)
+        FuncData(_kolmogp, dataset, (0,), 1, rtol=_rtol).check()

.venv/lib/python3.12/site-packages/scipy/special/tests/test_lambertw.py

@@ -0,0 +1,109 @@
+#
+# Tests for the lambertw function,
+# Adapted from the MPMath tests [1] by Yosef Meller, mellerf@netvision.net.il
+# Distributed under the same license as SciPy itself.
+#
+# [1] mpmath source code, Subversion revision 992
+#     http://code.google.com/p/mpmath/source/browse/trunk/mpmath/tests/test_functions2.py?spec=svn994&r=992
+
+import pytest
+import numpy as np
+from numpy.testing import assert_, assert_equal, assert_allclose
+from scipy.special import lambertw
+from numpy import nan, inf, pi, e, isnan, log, r_, array, complex128
+
+from scipy.special._testutils import FuncData
+
+
+def test_values():
+    assert_(isnan(lambertw(nan)))
+    assert_equal(lambertw(inf,1).real, inf)
+    assert_equal(lambertw(inf,1).imag, 2*pi)
+    assert_equal(lambertw(-inf,1).real, inf)
+    assert_equal(lambertw(-inf,1).imag, 3*pi)
+
+    assert_equal(lambertw(1.), lambertw(1., 0))
+
+    data = [
+        (0,0, 0),
+        (0+0j,0, 0),
+        (inf,0, inf),
+        (0,-1, -inf),
+        (0,1, -inf),
+        (0,3, -inf),
+        (e,0, 1),
+        (1,0, 0.567143290409783873),
+        (-pi/2,0, 1j*pi/2),
+        (-log(2)/2,0, -log(2)),
+        (0.25,0, 0.203888354702240164),
+        (-0.25,0, -0.357402956181388903),
+        (-1./10000,0, -0.000100010001500266719),
+        (-0.25,-1, -2.15329236411034965),
+        (0.25,-1, -3.00899800997004620-4.07652978899159763j),
+        (-0.25,-1, -2.15329236411034965),
+        (0.25,1, -3.00899800997004620+4.07652978899159763j),
+        (-0.25,1, -3.48973228422959210+7.41405453009603664j),
+        (-4,0, 0.67881197132094523+1.91195078174339937j),
+        (-4,1, -0.66743107129800988+7.76827456802783084j),
+        (-4,-1, 0.67881197132094523-1.91195078174339937j),
+        (1000,0, 5.24960285240159623),
+        (1000,1, 4.91492239981054535+5.44652615979447070j),
+        (1000,-1, 4.91492239981054535-5.44652615979447070j),
+        (1000,5, 3.5010625305312892+29.9614548941181328j),
+        (3+4j,0, 1.281561806123775878+0.533095222020971071j),
+        (-0.4+0.4j,0, -0.10396515323290657+0.61899273315171632j),
+        (3+4j,1, -0.11691092896595324+5.61888039871282334j),
+        (3+4j,-1, 0.25856740686699742-3.85211668616143559j),
+        (-0.5,-1, -0.794023632344689368-0.770111750510379110j),
+        (-1./10000,1, -11.82350837248724344+6.80546081842002101j),
+        (-1./10000,-1, -11.6671145325663544),
+        (-1./10000,-2, -11.82350837248724344-6.80546081842002101j),
+        (-1./100000,4, -14.9186890769540539+26.1856750178782046j),
+        (-1./100000,5, -15.0931437726379218666+32.5525721210262290086j),
+        ((2+1j)/10,0, 0.173704503762911669+0.071781336752835511j),
+        ((2+1j)/10,1, -3.21746028349820063+4.56175438896292539j),
+        ((2+1j)/10,-1, -3.03781405002993088-3.53946629633505737j),
+        ((2+1j)/10,4, -4.6878509692773249+23.8313630697683291j),
+        (-(2+1j)/10,0, -0.226933772515757933-0.164986470020154580j),
+        (-(2+1j)/10,1, -2.43569517046110001+0.76974067544756289j),
+        (-(2+1j)/10,-1, -3.54858738151989450-6.91627921869943589j),
+        (-(2+1j)/10,4, -4.5500846928118151+20.6672982215434637j),
+        (pi,0, 1.073658194796149172092178407024821347547745350410314531),
+
+        # Former bug in generated branch,
+        (-0.5+0.002j,0, -0.78917138132659918344 + 0.76743539379990327749j),
+        (-0.5-0.002j,0, -0.78917138132659918344 - 0.76743539379990327749j),
+        (-0.448+0.4j,0, -0.11855133765652382241 + 0.66570534313583423116j),
+        (-0.448-0.4j,0, -0.11855133765652382241 - 0.66570534313583423116j),
+    ]
+    data = array(data, dtype=complex128)
+
+    def w(x, y):
+        return lambertw(x, y.real.astype(int))
+    with np.errstate(all='ignore'):
+        FuncData(w, data, (0,1), 2, rtol=1e-10, atol=1e-13).check()
+
+
+def test_ufunc():
+    assert_allclose(lambertw(r_[0., e, 1.]), r_[0., 1., 0.567143290409783873],
+                    atol=1.5e-7, rtol=0)
+
+
+def test_lambertw_ufunc_loop_selection():
+    # see https://github.com/scipy/scipy/issues/4895
+    dt = np.dtype(np.complex128)
+    assert_equal(lambertw(0, 0, 0).dtype, dt)
+    assert_equal(lambertw([0], 0, 0).dtype, dt)
+    assert_equal(lambertw(0, [0], 0).dtype, dt)
+    assert_equal(lambertw(0, 0, [0]).dtype, dt)
+    assert_equal(lambertw([0], [0], [0]).dtype, dt)
+
+
+@pytest.mark.parametrize('z', [1e-316, -2e-320j, -5e-318+1e-320j])
+def test_lambertw_subnormal_k0(z):
+    # Verify that subnormal inputs are handled correctly on
+    # the branch k=0 (regression test for gh-16291).
+    w = lambertw(z)
+    # For values this small, we can be sure that numerically,
+    # lambertw(z) is z.
+    assert w == z

.venv/lib/python3.12/site-packages/scipy/special/tests/test_legendre.py

@@ -0,0 +1,1421 @@
+import math
+import warnings
+
+import numpy as np
+
+import pytest
+from numpy.testing import assert_equal, assert_allclose
+
+from scipy import special
+from scipy.special import (legendre_p, legendre_p_all, assoc_legendre_p,
+    assoc_legendre_p_all, sph_legendre_p, sph_legendre_p_all)
+
+
+# Base polynomials come from Abrahmowitz and Stegan
+class TestLegendre:
+    def test_legendre(self):
+        leg0 = special.legendre(0)
+        leg1 = special.legendre(1)
+        leg2 = special.legendre(2)
+        leg3 = special.legendre(3)
+        leg4 = special.legendre(4)
+        leg5 = special.legendre(5)
+        assert_equal(leg0.c, [1])
+        assert_equal(leg1.c, [1,0])
+        assert_allclose(leg2.c, np.array([3, 0, -1])/2.0,
+                        atol=1.5e-13, rtol=0)
+        assert_allclose(leg3.c, np.array([5, 0, -3, 0])/2.0,
+                        atol=1.5e-7, rtol=0)
+        assert_allclose(leg4.c, np.array([35, 0, -30, 0, 3])/8.0,
+                        atol=1.5e-7, rtol=0)
+        assert_allclose(leg5.c, np.array([63, 0, -70, 0, 15, 0])/8.0,
+                        atol=1.5e-7, rtol=0)
+
+class TestLegendreP:
+    @pytest.mark.parametrize("shape", [(10,), (4, 9), (3, 5, 7)])
+    def test_ode(self, shape):
+        rng = np.random.default_rng(1234)
+
+        n = rng.integers(0, 100, shape)
+        x = rng.uniform(-1, 1, shape)
+
+        p, p_jac, p_hess = legendre_p(n, x, diff_n=2)
+
+        assert p.shape == shape
+        assert p_jac.shape == p.shape
+        assert p_hess.shape == p_jac.shape
+
+        err = (1 - x * x) * p_hess - 2 * x * p_jac + n * (n + 1) * p
+        np.testing.assert_allclose(err, 0, atol=1e-10)
+
+    @pytest.mark.parametrize("n_max", [1, 2, 4, 8, 16, 32])
+    @pytest.mark.parametrize("x_shape", [(10,), (4, 9), (3, 5, 7)])
+    def test_all_ode(self, n_max, x_shape):
+        rng = np.random.default_rng(1234)
+
+        x = rng.uniform(-1, 1, x_shape)
+        p, p_jac, p_hess = legendre_p_all(n_max, x, diff_n=2)
+
+        n = np.arange(n_max + 1)
+        n = np.expand_dims(n, axis = tuple(range(1, x.ndim + 1)))
+
+        assert p.shape == (len(n),) + x.shape
+        assert p_jac.shape == p.shape
+        assert p_hess.shape == p_jac.shape
+
+        err = (1 - x * x) * p_hess - 2 * x * p_jac + n * (n + 1) * p
+        np.testing.assert_allclose(err, 0, atol=1e-10)
+
+
+class TestAssocLegendreP:
+    def test_assoc_legendre_gh23101(self):
+        z = np.array([-1, -.5, 0, .5, 1])
+        expected = assoc_legendre_p_1_0(z)
+        result = assoc_legendre_p(1, 0, z)
+        assert_allclose(np.squeeze(result), expected)
+
+        expected = assoc_legendre_p_3_0(z)
+        result = assoc_legendre_p(3, 0, z)
+        assert_allclose(np.squeeze(result), expected)
+
+    @pytest.mark.parametrize("shape", [(10,), (4, 9), (3, 5, 7, 10)])
+    @pytest.mark.parametrize("m_max", [5, 4])
+    @pytest.mark.parametrize("n_max", [7, 10])
+    def test_lpmn(self, shape, n_max, m_max):
+        rng = np.random.default_rng(1234)
+
+        x = rng.uniform(-0.99, 0.99, shape)
+        p_all, p_all_jac, p_all_hess = \
+            assoc_legendre_p_all(n_max, m_max, x, diff_n=2)
+
+        n = np.arange(n_max + 1)
+        n = np.expand_dims(n, axis = tuple(range(1, x.ndim + 2)))
+
+        m = np.concatenate([np.arange(m_max + 1), np.arange(-m_max, 0)])
+        m = np.expand_dims(m, axis = (0,) + tuple(range(2, x.ndim + 2)))
+
+        x = np.expand_dims(x, axis = (0, 1))
+        p, p_jac, p_hess = assoc_legendre_p(n, m, x, diff_n=2)
+
+        np.testing.assert_allclose(p, p_all)
+        np.testing.assert_allclose(p_jac, p_all_jac)
+        np.testing.assert_allclose(p_hess, p_all_hess)
+
+    @pytest.mark.parametrize("shape", [(10,), (4, 9), (3, 5, 7, 10)])
+    @pytest.mark.parametrize("norm", [True, False])
+    def test_ode(self, shape, norm):
+        rng = np.random.default_rng(1234)
+
+        n = rng.integers(0, 10, shape)
+        m = rng.integers(-10, 10, shape)
+        x = rng.uniform(-1, 1, shape)
+
+        p, p_jac, p_hess = assoc_legendre_p(n, m, x, norm=norm, diff_n=2)
+
+        assert p.shape == shape
+        assert p_jac.shape == p.shape
+        assert p_hess.shape == p_jac.shape
+
+        np.testing.assert_allclose((1 - x * x) * p_hess,
+            2 * x * p_jac - (n * (n + 1) - m * m / (1 - x * x)) * p,
+            rtol=1e-05, atol=1e-08)
+
+    @pytest.mark.parametrize("shape", [(10,), (4, 9), (3, 5, 7)])
+    def test_all(self, shape):
+        rng = np.random.default_rng(1234)
+
+        n_max = 20
+        m_max = 20
+
+        x = rng.uniform(-0.99, 0.99, shape)
+
+        p, p_jac, p_hess = assoc_legendre_p_all(n_max, m_max, x, diff_n=2)
+
+        m = np.concatenate([np.arange(m_max + 1), np.arange(-m_max, 0)])
+        n = np.arange(n_max + 1)
+
+        n = np.expand_dims(n, axis = tuple(range(1, x.ndim + 2)))
+        m = np.expand_dims(m, axis = (0,) + tuple(range(2, x.ndim + 2)))
+        np.testing.assert_allclose((1 - x * x) * p_hess,
+            2 * x * p_jac - (n * (n + 1) - m * m / (1 - x * x)) * p,
+            rtol=1e-05, atol=1e-08)
+
+    @pytest.mark.parametrize("shape", [(10,), (4, 9), (3, 5, 7)])
+    @pytest.mark.parametrize("norm", [True, False])
+    def test_specific(self, shape, norm):
+        rng = np.random.default_rng(1234)
+
+        x = rng.uniform(-0.99, 0.99, shape)
+
+        p, p_jac = assoc_legendre_p_all(4, 4, x, norm=norm, diff_n=1)
+
+        np.testing.assert_allclose(p[0, 0],
+            assoc_legendre_p_0_0(x, norm=norm))
+        np.testing.assert_allclose(p[0, 1], 0)
+        np.testing.assert_allclose(p[0, 2], 0)
+        np.testing.assert_allclose(p[0, 3], 0)
+        np.testing.assert_allclose(p[0, 4], 0)
+        np.testing.assert_allclose(p[0, -3], 0)
+        np.testing.assert_allclose(p[0, -2], 0)
+        np.testing.assert_allclose(p[0, -1], 0)
+
+        np.testing.assert_allclose(p[1, 0],
+            assoc_legendre_p_1_0(x, norm=norm))
+        np.testing.assert_allclose(p[1, 1],
+            assoc_legendre_p_1_1(x, norm=norm))
+        np.testing.assert_allclose(p[1, 2], 0)
+        np.testing.assert_allclose(p[1, 3], 0)
+        np.testing.assert_allclose(p[1, 4], 0)
+        np.testing.assert_allclose(p[1, -4], 0)
+        np.testing.assert_allclose(p[1, -3], 0)
+        np.testing.assert_allclose(p[1, -2], 0)
+        np.testing.assert_allclose(p[1, -1],
+            assoc_legendre_p_1_m1(x, norm=norm))
+
+        np.testing.assert_allclose(p[2, 0],
+            assoc_legendre_p_2_0(x, norm=norm))
+        np.testing.assert_allclose(p[2, 1],
+            assoc_legendre_p_2_1(x, norm=norm))
+        np.testing.assert_allclose(p[2, 2],
+            assoc_legendre_p_2_2(x, norm=norm))
+        np.testing.assert_allclose(p[2, 3], 0)
+        np.testing.assert_allclose(p[2, 4], 0)
+        np.testing.assert_allclose(p[2, -4], 0)
+        np.testing.assert_allclose(p[2, -3], 0)
+        np.testing.assert_allclose(p[2, -2],
+            assoc_legendre_p_2_m2(x, norm=norm))
+        np.testing.assert_allclose(p[2, -1],
+            assoc_legendre_p_2_m1(x, norm=norm))
+
+        np.testing.assert_allclose(p[3, 0],
+            assoc_legendre_p_3_0(x, norm=norm))
+        np.testing.assert_allclose(p[3, 1],
+            assoc_legendre_p_3_1(x, norm=norm))
+        np.testing.assert_allclose(p[3, 2],
+            assoc_legendre_p_3_2(x, norm=norm))
+        np.testing.assert_allclose(p[3, 3],
+            assoc_legendre_p_3_3(x, norm=norm))
+        np.testing.assert_allclose(p[3, 4], 0)
+        np.testing.assert_allclose(p[3, -4], 0)
+        np.testing.assert_allclose(p[3, -3],
+            assoc_legendre_p_3_m3(x, norm=norm))
+        np.testing.assert_allclose(p[3, -2],
+            assoc_legendre_p_3_m2(x, norm=norm))
+        np.testing.assert_allclose(p[3, -1],
+            assoc_legendre_p_3_m1(x, norm=norm))
+
+        np.testing.assert_allclose(p[4, 0],
+            assoc_legendre_p_4_0(x, norm=norm))
+        np.testing.assert_allclose(p[4, 1],
+            assoc_legendre_p_4_1(x, norm=norm))
+        np.testing.assert_allclose(p[4, 2],
+            assoc_legendre_p_4_2(x, norm=norm))
+        np.testing.assert_allclose(p[4, 3],
+            assoc_legendre_p_4_3(x, norm=norm))
+        np.testing.assert_allclose(p[4, 4],
+            assoc_legendre_p_4_4(x, norm=norm))
+        np.testing.assert_allclose(p[4, -4],
+            assoc_legendre_p_4_m4(x, norm=norm))
+        np.testing.assert_allclose(p[4, -3],
+            assoc_legendre_p_4_m3(x, norm=norm))
+        np.testing.assert_allclose(p[4, -2],
+            assoc_legendre_p_4_m2(x, norm=norm))
+        np.testing.assert_allclose(p[4, -1],
+            assoc_legendre_p_4_m1(x, norm=norm))
+
+        np.testing.assert_allclose(p_jac[0, 0],
+            assoc_legendre_p_0_0_jac(x, norm=norm))
+        np.testing.assert_allclose(p_jac[0, 1], 0)
+        np.testing.assert_allclose(p_jac[0, 2], 0)
+        np.testing.assert_allclose(p_jac[0, 3], 0)
+        np.testing.assert_allclose(p_jac[0, 4], 0)
+        np.testing.assert_allclose(p_jac[0, -4], 0)
+        np.testing.assert_allclose(p_jac[0, -3], 0)
+        np.testing.assert_allclose(p_jac[0, -2], 0)
+        np.testing.assert_allclose(p_jac[0, -1], 0)
+
+        np.testing.assert_allclose(p_jac[1, 0],
+            assoc_legendre_p_1_0_jac(x, norm=norm))
+        np.testing.assert_allclose(p_jac[1, 1],
+            assoc_legendre_p_1_1_jac(x, norm=norm))
+        np.testing.assert_allclose(p_jac[1, 2], 0)
+        np.testing.assert_allclose(p_jac[1, 3], 0)
+        np.testing.assert_allclose(p_jac[1, 4], 0)
+        np.testing.assert_allclose(p_jac[1, -4], 0)
+        np.testing.assert_allclose(p_jac[1, -3], 0)
+        np.testing.assert_allclose(p_jac[1, -2], 0)
+        np.testing.assert_allclose(p_jac[1, -1],
+            assoc_legendre_p_1_m1_jac(x, norm=norm))
+
+        np.testing.assert_allclose(p_jac[2, 0],
+            assoc_legendre_p_2_0_jac(x, norm=norm))
+        np.testing.assert_allclose(p_jac[2, 1],
+            assoc_legendre_p_2_1_jac(x, norm=norm))
+        np.testing.assert_allclose(p_jac[2, 2],
+            assoc_legendre_p_2_2_jac(x, norm=norm))
+        np.testing.assert_allclose(p_jac[2, 3], 0)
+        np.testing.assert_allclose(p_jac[2, 4], 0)
+        np.testing.assert_allclose(p_jac[2, -4], 0)
+        np.testing.assert_allclose(p_jac[2, -3], 0)
+        np.testing.assert_allclose(p_jac[2, -2],
+            assoc_legendre_p_2_m2_jac(x, norm=norm))
+        np.testing.assert_allclose(p_jac[2, -1],
+            assoc_legendre_p_2_m1_jac(x, norm=norm))
+
+        np.testing.assert_allclose(p_jac[3, 0],
+            assoc_legendre_p_3_0_jac(x, norm=norm))
+        np.testing.assert_allclose(p_jac[3, 1],
+            assoc_legendre_p_3_1_jac(x, norm=norm))
+        np.testing.assert_allclose(p_jac[3, 2],
+            assoc_legendre_p_3_2_jac(x, norm=norm))
+        np.testing.assert_allclose(p_jac[3, 3],
+            assoc_legendre_p_3_3_jac(x, norm=norm))
+        np.testing.assert_allclose(p_jac[3, 4], 0)
+        np.testing.assert_allclose(p_jac[3, -4], 0)
+        np.testing.assert_allclose(p_jac[3, -3],
+            assoc_legendre_p_3_m3_jac(x, norm=norm))
+        np.testing.assert_allclose(p_jac[3, -2],
+            assoc_legendre_p_3_m2_jac(x, norm=norm))
+        np.testing.assert_allclose(p_jac[3, -1],
+            assoc_legendre_p_3_m1_jac(x, norm=norm))
+
+        np.testing.assert_allclose(p_jac[4, 0],
+            assoc_legendre_p_4_0_jac(x, norm=norm))
+        np.testing.assert_allclose(p_jac[4, 1],
+            assoc_legendre_p_4_1_jac(x, norm=norm))
+        np.testing.assert_allclose(p_jac[4, 2],
+            assoc_legendre_p_4_2_jac(x, norm=norm))
+        np.testing.assert_allclose(p_jac[4, 3],
+            assoc_legendre_p_4_3_jac(x, norm=norm))
+        np.testing.assert_allclose(p_jac[4, 4],
+            assoc_legendre_p_4_4_jac(x, norm=norm))
+        np.testing.assert_allclose(p_jac[4, -4],
+            assoc_legendre_p_4_m4_jac(x, norm=norm))
+        np.testing.assert_allclose(p_jac[4, -3],
+            assoc_legendre_p_4_m3_jac(x, norm=norm))
+        np.testing.assert_allclose(p_jac[4, -2],
+            assoc_legendre_p_4_m2_jac(x, norm=norm))
+        np.testing.assert_allclose(p_jac[4, -1],
+            assoc_legendre_p_4_m1_jac(x, norm=norm))
+
+    @pytest.mark.parametrize("m_max", [7])
+    @pytest.mark.parametrize("n_max", [10])
+    @pytest.mark.parametrize("x", [1, -1])
+    def test_all_limits(self, m_max, n_max, x):
+        p, p_jac = assoc_legendre_p_all(n_max, m_max, x, diff_n=1)
+
+        n = np.arange(n_max + 1)
+
+        np.testing.assert_allclose(p_jac[:, 0],
+            pow(x, n + 1) * n * (n + 1) / 2)
+        np.testing.assert_allclose(p_jac[:, 1],
+            np.where(n >= 1, pow(x, n) * np.inf, 0))
+        np.testing.assert_allclose(p_jac[:, 2],
+            np.where(n >= 2, -pow(x, n + 1) * (n + 2) * (n + 1) * n * (n - 1) / 4, 0))
+        np.testing.assert_allclose(p_jac[:, -2],
+            np.where(n >= 2, -pow(x, n + 1) / 4, 0))
+        np.testing.assert_allclose(p_jac[:, -1],
+            np.where(n >= 1, -pow(x, n) * np.inf, 0))
+
+        for m in range(3, m_max + 1):
+            np.testing.assert_allclose(p_jac[:, m], 0)
+            np.testing.assert_allclose(p_jac[:, -m], 0)
+
+    @pytest.mark.parametrize("n", np.arange(0, 20))
+    def test_assoc_legendre_p_norm_m0(self, n):
+        # gh 24099
+        m = 0
+        z = np.linspace(-1, 1, 101)
+        p = assoc_legendre_p(n, m, z, norm=False)
+        p_norm = assoc_legendre_p(n, m, z, norm=True)
+        factor = np.sqrt((2 * n + 1) / 2)
+        np.testing.assert_allclose(p_norm, factor * p)
+
+    @pytest.mark.parametrize("n", np.arange(0, 20))
+    def test_assoc_legendre_p_all_norm_m0(self, n):
+        # gh 24099
+        m = 0
+        z = np.linspace(-1, 1, 101)
+        p_all = assoc_legendre_p_all(n, m, z, norm=False)[0, : n + 1, 0, :]
+        p_norm_all = assoc_legendre_p_all(n, m, z, norm=True)[0, : n + 1, 0, :]
+        factor = np.sqrt((2 * np.arange(n + 1) + 1) / 2)
+        factor = factor[:, np.newaxis]
+        np.testing.assert_allclose(p_norm_all, factor * p_all)
+
+
+class TestMultiAssocLegendreP:
+    @pytest.mark.parametrize("shape", [(1000,), (4, 9), (3, 5, 7)])
+    @pytest.mark.parametrize("branch_cut", [2, 3])
+    @pytest.mark.parametrize("z_min, z_max", [(-10 - 10j, 10 + 10j),
+        (-1, 1), (-10j, 10j)])
+    @pytest.mark.parametrize("norm", [True, False])
+    def test_specific(self, shape, branch_cut, z_min, z_max, norm):
+        rng = np.random.default_rng(1234)
+
+        z = rng.uniform(z_min.real, z_max.real, shape) + \
+            1j * rng.uniform(z_min.imag, z_max.imag, shape)
+
+        p, p_jac = assoc_legendre_p_all(4, 4,
+            z, branch_cut=branch_cut, norm=norm, diff_n=1)
+
+        np.testing.assert_allclose(p[0, 0],
+            assoc_legendre_p_0_0(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p[0, 1], 0)
+        np.testing.assert_allclose(p[0, 2], 0)
+        np.testing.assert_allclose(p[0, 3], 0)
+        np.testing.assert_allclose(p[0, 4], 0)
+        np.testing.assert_allclose(p[0, -4], 0)
+        np.testing.assert_allclose(p[0, -3], 0)
+        np.testing.assert_allclose(p[0, -2], 0)
+        np.testing.assert_allclose(p[0, -1], 0)
+
+        np.testing.assert_allclose(p[1, 0],
+            assoc_legendre_p_1_0(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p[1, 1],
+            assoc_legendre_p_1_1(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p[1, 2], 0)
+        np.testing.assert_allclose(p[1, 3], 0)
+        np.testing.assert_allclose(p[1, 4], 0)
+        np.testing.assert_allclose(p[1, -4], 0)
+        np.testing.assert_allclose(p[1, -3], 0)
+        np.testing.assert_allclose(p[1, -2], 0)
+        np.testing.assert_allclose(p[1, -1],
+            assoc_legendre_p_1_m1(z, branch_cut=branch_cut, norm=norm))
+
+        np.testing.assert_allclose(p[2, 0],
+            assoc_legendre_p_2_0(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p[2, 1],
+            assoc_legendre_p_2_1(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p[2, 2],
+            assoc_legendre_p_2_2(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p[2, 3], 0)
+        np.testing.assert_allclose(p[2, 4], 0)
+        np.testing.assert_allclose(p[2, -4], 0)
+        np.testing.assert_allclose(p[2, -3], 0)
+        np.testing.assert_allclose(p[2, -2],
+            assoc_legendre_p_2_m2(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p[2, -1],
+            assoc_legendre_p_2_m1(z, branch_cut=branch_cut, norm=norm))
+
+        np.testing.assert_allclose(p[3, 0],
+            assoc_legendre_p_3_0(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p[3, 1],
+            assoc_legendre_p_3_1(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p[3, 2],
+            assoc_legendre_p_3_2(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p[3, 3],
+            assoc_legendre_p_3_3(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p[3, 4], 0)
+        np.testing.assert_allclose(p[3, -4], 0)
+        np.testing.assert_allclose(p[3, -3],
+            assoc_legendre_p_3_m3(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p[3, -2],
+            assoc_legendre_p_3_m2(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p[3, -1],
+            assoc_legendre_p_3_m1(z, branch_cut=branch_cut, norm=norm))
+
+        np.testing.assert_allclose(p[4, 0],
+            assoc_legendre_p_4_0(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p[4, 1],
+            assoc_legendre_p_4_1(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p[4, 2],
+            assoc_legendre_p_4_2(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p[4, 3],
+            assoc_legendre_p_4_3(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p[4, 4],
+            assoc_legendre_p_4_4(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p[4, -4],
+            assoc_legendre_p_4_m4(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p[4, -3],
+            assoc_legendre_p_4_m3(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p[4, -2],
+            assoc_legendre_p_4_m2(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p[4, -1],
+            assoc_legendre_p_4_m1(z, branch_cut=branch_cut, norm=norm))
+
+        np.testing.assert_allclose(p_jac[0, 0],
+            assoc_legendre_p_0_0_jac(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p_jac[0, 1], 0)
+        np.testing.assert_allclose(p_jac[0, 2], 0)
+        np.testing.assert_allclose(p_jac[0, 3], 0)
+        np.testing.assert_allclose(p_jac[0, 4], 0)
+        np.testing.assert_allclose(p_jac[0, -4], 0)
+        np.testing.assert_allclose(p_jac[0, -3], 0)
+        np.testing.assert_allclose(p_jac[0, -2], 0)
+        np.testing.assert_allclose(p_jac[0, -1], 0)
+
+        np.testing.assert_allclose(p_jac[1, 0],
+            assoc_legendre_p_1_0_jac(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p_jac[1, 1],
+            assoc_legendre_p_1_1_jac(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p_jac[1, 2], 0)
+        np.testing.assert_allclose(p_jac[1, 3], 0)
+        np.testing.assert_allclose(p_jac[1, 4], 0)
+        np.testing.assert_allclose(p_jac[1, -4], 0)
+        np.testing.assert_allclose(p_jac[1, -3], 0)
+        np.testing.assert_allclose(p_jac[1, -2], 0)
+        np.testing.assert_allclose(p_jac[1, -1],
+            assoc_legendre_p_1_m1_jac(z, branch_cut=branch_cut, norm=norm))
+
+        np.testing.assert_allclose(p_jac[2, 0],
+            assoc_legendre_p_2_0_jac(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p_jac[2, 1],
+            assoc_legendre_p_2_1_jac(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p_jac[2, 2],
+            assoc_legendre_p_2_2_jac(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p_jac[2, 3], 0)
+        np.testing.assert_allclose(p_jac[2, 4], 0)
+        np.testing.assert_allclose(p_jac[2, -4], 0)
+        np.testing.assert_allclose(p_jac[2, -3], 0)
+        np.testing.assert_allclose(p_jac[2, -2],
+            assoc_legendre_p_2_m2_jac(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p_jac[2, -1],
+            assoc_legendre_p_2_m1_jac(z, branch_cut=branch_cut, norm=norm))
+
+        np.testing.assert_allclose(p_jac[3, 0],
+            assoc_legendre_p_3_0_jac(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p_jac[3, 1],
+            assoc_legendre_p_3_1_jac(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p_jac[3, 2],
+            assoc_legendre_p_3_2_jac(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p_jac[3, 3],
+            assoc_legendre_p_3_3_jac(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p_jac[3, 4], 0)
+        np.testing.assert_allclose(p_jac[3, -4], 0)
+        np.testing.assert_allclose(p_jac[3, -3],
+            assoc_legendre_p_3_m3_jac(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p_jac[3, -2],
+            assoc_legendre_p_3_m2_jac(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p_jac[3, -1],
+            assoc_legendre_p_3_m1_jac(z, branch_cut=branch_cut, norm=norm))
+
+        np.testing.assert_allclose(p_jac[4, 0],
+            assoc_legendre_p_4_0_jac(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p_jac[4, 1],
+            assoc_legendre_p_4_1_jac(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p_jac[4, 2],
+            assoc_legendre_p_4_2_jac(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p_jac[4, 3],
+            assoc_legendre_p_4_3_jac(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p_jac[4, 4],
+            assoc_legendre_p_4_4_jac(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p_jac[4, -4],
+            assoc_legendre_p_4_m4_jac(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p_jac[4, -3],
+            assoc_legendre_p_4_m3_jac(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p_jac[4, -2],
+            assoc_legendre_p_4_m2_jac(z, branch_cut=branch_cut, norm=norm))
+        np.testing.assert_allclose(p_jac[4, -1],
+            assoc_legendre_p_4_m1_jac(z, branch_cut=branch_cut, norm=norm))
+
+class TestSphLegendreP:
+    @pytest.mark.parametrize("shape", [(10,), (4, 9), (3, 5, 7)])
+    def test_specific(self, shape):
+        rng = np.random.default_rng(1234)
+
+        theta = rng.uniform(-np.pi, np.pi, shape)
+
+        p, p_jac = sph_legendre_p_all(4, 4, theta, diff_n=1)
+
+        np.testing.assert_allclose(p[0, 0],
+            sph_legendre_p_0_0(theta))
+        np.testing.assert_allclose(p[0, 1], 0)
+        np.testing.assert_allclose(p[0, 2], 0)
+        np.testing.assert_allclose(p[0, 3], 0)
+        np.testing.assert_allclose(p[0, 4], 0)
+        np.testing.assert_allclose(p[0, -3], 0)
+        np.testing.assert_allclose(p[0, -2], 0)
+        np.testing.assert_allclose(p[0, -1], 0)
+
+        np.testing.assert_allclose(p[1, 0],
+            sph_legendre_p_1_0(theta))
+        np.testing.assert_allclose(p[1, 1],
+            sph_legendre_p_1_1(theta))
+        np.testing.assert_allclose(p[1, 2], 0)
+        np.testing.assert_allclose(p[1, 3], 0)
+        np.testing.assert_allclose(p[1, 4], 0)
+        np.testing.assert_allclose(p[1, -4], 0)
+        np.testing.assert_allclose(p[1, -3], 0)
+        np.testing.assert_allclose(p[1, -2], 0)
+        np.testing.assert_allclose(p[1, -1],
+            sph_legendre_p_1_m1(theta))
+
+        np.testing.assert_allclose(p[2, 0],
+            sph_legendre_p_2_0(theta))
+        np.testing.assert_allclose(p[2, 1],
+            sph_legendre_p_2_1(theta))
+        np.testing.assert_allclose(p[2, 2],
+            sph_legendre_p_2_2(theta))
+        np.testing.assert_allclose(p[2, 3], 0)
+        np.testing.assert_allclose(p[2, 4], 0)
+        np.testing.assert_allclose(p[2, -4], 0)
+        np.testing.assert_allclose(p[2, -3], 0)
+        np.testing.assert_allclose(p[2, -2],
+            sph_legendre_p_2_m2(theta))
+        np.testing.assert_allclose(p[2, -1],
+            sph_legendre_p_2_m1(theta))
+
+        np.testing.assert_allclose(p[3, 0],
+            sph_legendre_p_3_0(theta))
+        np.testing.assert_allclose(p[3, 1],
+            sph_legendre_p_3_1(theta))
+        np.testing.assert_allclose(p[3, 2],
+            sph_legendre_p_3_2(theta))
+        np.testing.assert_allclose(p[3, 3],
+            sph_legendre_p_3_3(theta))
+        np.testing.assert_allclose(p[3, 4], 0)
+        np.testing.assert_allclose(p[3, -4], 0)
+        np.testing.assert_allclose(p[3, -3],
+            sph_legendre_p_3_m3(theta))
+        np.testing.assert_allclose(p[3, -2],
+            sph_legendre_p_3_m2(theta))
+        np.testing.assert_allclose(p[3, -1],
+            sph_legendre_p_3_m1(theta))
+
+        np.testing.assert_allclose(p[4, 0],
+            sph_legendre_p_4_0(theta))
+        np.testing.assert_allclose(p[4, 1],
+            sph_legendre_p_4_1(theta))
+        np.testing.assert_allclose(p[4, 2],
+            sph_legendre_p_4_2(theta))
+        np.testing.assert_allclose(p[4, 3],
+            sph_legendre_p_4_3(theta))
+        np.testing.assert_allclose(p[4, 4],
+            sph_legendre_p_4_4(theta))
+        np.testing.assert_allclose(p[4, -4],
+            sph_legendre_p_4_m4(theta))
+        np.testing.assert_allclose(p[4, -3],
+            sph_legendre_p_4_m3(theta))
+        np.testing.assert_allclose(p[4, -2],
+            sph_legendre_p_4_m2(theta))
+        np.testing.assert_allclose(p[4, -1],
+            sph_legendre_p_4_m1(theta))
+
+        np.testing.assert_allclose(p_jac[0, 0],
+            sph_legendre_p_0_0_jac(theta))
+        np.testing.assert_allclose(p_jac[0, 1], 0)
+        np.testing.assert_allclose(p_jac[0, 2], 0)
+        np.testing.assert_allclose(p_jac[0, 3], 0)
+        np.testing.assert_allclose(p_jac[0, 4], 0)
+        np.testing.assert_allclose(p_jac[0, -3], 0)
+        np.testing.assert_allclose(p_jac[0, -2], 0)
+        np.testing.assert_allclose(p_jac[0, -1], 0)
+
+        np.testing.assert_allclose(p_jac[1, 0],
+            sph_legendre_p_1_0_jac(theta))
+        np.testing.assert_allclose(p_jac[1, 1],
+            sph_legendre_p_1_1_jac(theta))
+        np.testing.assert_allclose(p_jac[1, 2], 0)
+        np.testing.assert_allclose(p_jac[1, 3], 0)
+        np.testing.assert_allclose(p_jac[1, 4], 0)
+        np.testing.assert_allclose(p_jac[1, -4], 0)
+        np.testing.assert_allclose(p_jac[1, -3], 0)
+        np.testing.assert_allclose(p_jac[1, -2], 0)
+        np.testing.assert_allclose(p_jac[1, -1],
+            sph_legendre_p_1_m1_jac(theta))
+
+        np.testing.assert_allclose(p_jac[2, 0],
+            sph_legendre_p_2_0_jac(theta))
+        np.testing.assert_allclose(p_jac[2, 1],
+            sph_legendre_p_2_1_jac(theta))
+        np.testing.assert_allclose(p_jac[2, 2],
+            sph_legendre_p_2_2_jac(theta))
+        np.testing.assert_allclose(p_jac[2, 3], 0)
+        np.testing.assert_allclose(p_jac[2, 4], 0)
+        np.testing.assert_allclose(p_jac[2, -4], 0)
+        np.testing.assert_allclose(p_jac[2, -3], 0)
+        np.testing.assert_allclose(p_jac[2, -2],
+            sph_legendre_p_2_m2_jac(theta))
+        np.testing.assert_allclose(p_jac[2, -1],
+            sph_legendre_p_2_m1_jac(theta))
+
+        np.testing.assert_allclose(p_jac[3, 0],
+            sph_legendre_p_3_0_jac(theta))
+        np.testing.assert_allclose(p_jac[3, 1],
+            sph_legendre_p_3_1_jac(theta))
+        np.testing.assert_allclose(p_jac[3, 2],
+            sph_legendre_p_3_2_jac(theta))
+        np.testing.assert_allclose(p_jac[3, 3],
+            sph_legendre_p_3_3_jac(theta))
+        np.testing.assert_allclose(p_jac[3, 4], 0)
+        np.testing.assert_allclose(p_jac[3, -4], 0)
+        np.testing.assert_allclose(p_jac[3, -3],
+            sph_legendre_p_3_m3_jac(theta))
+        np.testing.assert_allclose(p_jac[3, -2],
+            sph_legendre_p_3_m2_jac(theta))
+        np.testing.assert_allclose(p_jac[3, -1],
+            sph_legendre_p_3_m1_jac(theta))
+
+        np.testing.assert_allclose(p_jac[4, 0],
+            sph_legendre_p_4_0_jac(theta))
+        np.testing.assert_allclose(p_jac[4, 1],
+            sph_legendre_p_4_1_jac(theta))
+        np.testing.assert_allclose(p_jac[4, 2],
+            sph_legendre_p_4_2_jac(theta))
+        np.testing.assert_allclose(p_jac[4, 3],
+            sph_legendre_p_4_3_jac(theta))
+        np.testing.assert_allclose(p_jac[4, 4],
+            sph_legendre_p_4_4_jac(theta))
+        np.testing.assert_allclose(p_jac[4, -4],
+            sph_legendre_p_4_m4_jac(theta))
+        np.testing.assert_allclose(p_jac[4, -3],
+            sph_legendre_p_4_m3_jac(theta))
+        np.testing.assert_allclose(p_jac[4, -2],
+            sph_legendre_p_4_m2_jac(theta))
+        np.testing.assert_allclose(p_jac[4, -1],
+            sph_legendre_p_4_m1_jac(theta))
+
+    @pytest.mark.parametrize("shape", [(10,), (4, 9), (3, 5, 7, 10)])
+    def test_ode(self, shape):
+        rng = np.random.default_rng(1234)
+
+        n = rng.integers(0, 10, shape)
+        m = rng.integers(-10, 10, shape)
+        theta = rng.uniform(-np.pi, np.pi, shape)
+
+        p, p_jac, p_hess = sph_legendre_p(n, m, theta, diff_n=2)
+
+        assert p.shape == shape
+        assert p_jac.shape == p.shape
+        assert p_hess.shape == p_jac.shape
+
+        np.testing.assert_allclose(np.sin(theta) * p_hess, -np.cos(theta) * p_jac
+            - (n * (n + 1) * np.sin(theta) - m * m / np.sin(theta)) * p,
+            rtol=1e-05, atol=1e-08)
+
+class TestLegendreFunctions:
+    """
+    @pytest.mark.parametrize("m_max", [3])
+    @pytest.mark.parametrize("n_max", [5])
+    @pytest.mark.parametrize("z", [-1])
+    def test_clpmn_all_limits(self, m_max, n_max, z):
+        rng = np.random.default_rng(1234)
+
+        type = 2
+
+        p, p_jac = special.clpmn_all(m_max, n_max, type, z, diff_n=1)
+
+        n = np.arange(n_max + 1)
+
+        np.testing.assert_allclose(p_jac[0], pow(z, n + 1) * n * (n + 1) / 2)
+        np.testing.assert_allclose(p_jac[1], np.where(n >= 1, pow(z, n) * np.inf, 0))
+        np.testing.assert_allclose(p_jac[2], np.where(n >= 2,
+            -pow(z, n + 1) * (n + 2) * (n + 1) * n * (n - 1) / 4, 0))
+        np.testing.assert_allclose(p_jac[-2], np.where(n >= 2, -pow(z, n + 1) / 4, 0))
+        np.testing.assert_allclose(p_jac[-1], np.where(n >= 1, -pow(z, n) * np.inf, 0))
+
+        for m in range(3, m_max + 1):
+            np.testing.assert_allclose(p_jac[m], 0)
+            np.testing.assert_allclose(p_jac[-m], 0)
+    """
+
+    def test_lpmv(self):
+        lp = special.lpmv(0, 2, .5)
+        assert_allclose(lp, -0.125, atol=1.5e-7, rtol=0)
+        lp = special.lpmv(0, 40, .001)
+        assert_allclose(lp, 0.1252678976534484, atol=1.5e-7, rtol=0)
+
+        # XXX: this is outside the domain of the current implementation,
+        #      so ensure it returns a NaN rather than a wrong answer.
+        with np.errstate(all='ignore'):
+            lp = special.lpmv(-1,-1,.001)
+        assert lp != 0 or np.isnan(lp)
+
+    def test_lqmn(self):
+        lqmnf = special.lqmn(0, 2, .5)
+        lqf = special.lqn(2, .5)
+        assert_allclose(lqmnf[0][0], lqf[0], atol=1.5e-4, rtol=0)
+        assert_allclose(lqmnf[1][0], lqf[1], atol=1.5e-4, rtol=0)
+
+    def test_lqmn_gt1(self):
+        """algorithm for real arguments changes at 1.0001
+           test against analytical result for m=2, n=1
+        """
+        x0 = 1.0001
+        delta = 0.00002
+        for x in (x0-delta, x0+delta):
+            lq = special.lqmn(2, 1, x)[0][-1, -1]
+            expected = 2/(x*x-1)
+            assert_allclose(lq, expected, atol=1.5e-7, rtol=0)
+
+    def test_lqmn_shape(self):
+        a, b = special.lqmn(4, 4, 1.1)
+        assert_equal(a.shape, (5, 5))
+        assert_equal(b.shape, (5, 5))
+
+        a, b = special.lqmn(4, 0, 1.1)
+        assert_equal(a.shape, (5, 1))
+        assert_equal(b.shape, (5, 1))
+
+    def test_lqn(self):
+        lqf = special.lqn(2, .5)
+        assert_allclose(lqf, (np.array([0.5493, -0.7253, -0.8187]),
+                              np.array([1.3333, 1.216, -0.8427])),
+                        atol=1.5e-4, rtol=0)
+
+    @pytest.mark.parametrize("function", [special.lqn])
+    @pytest.mark.parametrize("n", [1, 2, 4, 8, 16, 32])
+    @pytest.mark.parametrize("z_complex", [False, True])
+    @pytest.mark.parametrize("z_inexact", [False, True])
+    @pytest.mark.parametrize(
+        "input_shape",
+        [
+            (), (1, ), (2, ), (2, 1), (1, 2), (2, 2), (2, 2, 1), (2, 2, 2)
+        ]
+    )
+    def test_array_inputs_lxn(self, function, n, z_complex, z_inexact, input_shape):
+        """Tests for correct output shapes."""
+        rng = np.random.default_rng(1234)
+        if z_inexact:
+            z = rng.integers(-3, 3, size=input_shape)
+        else:
+            z = rng.uniform(-1, 1, size=input_shape)
+
+        if z_complex:
+            z = 1j * z + 0.5j * z
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", category=DeprecationWarning)
+            P_z, P_d_z = function(n, z)
+        assert P_z.shape == (n + 1, ) + input_shape
+        assert P_d_z.shape == (n + 1, ) + input_shape
+
+    @pytest.mark.parametrize("function", [special.lqmn])
+    @pytest.mark.parametrize(
+        "m,n",
+        [(0, 1), (1, 2), (1, 4), (3, 8), (11, 16), (19, 32)]
+    )
+    @pytest.mark.parametrize("z_inexact", [False, True])
+    @pytest.mark.parametrize(
+        "input_shape", [
+            (), (1, ), (2, ), (2, 1), (1, 2), (2, 2), (2, 2, 1)
+        ]
+    )
+    def test_array_inputs_lxmn(self, function, m, n, z_inexact, input_shape):
+        """Tests for correct output shapes and dtypes."""
+        rng = np.random.default_rng(1234)
+        if z_inexact:
+            z = rng.integers(-3, 3, size=input_shape)
+        else:
+            z = rng.uniform(-1, 1, size=input_shape)
+
+        P_z, P_d_z = function(m, n, z)
+        assert P_z.shape == (m + 1, n + 1) + input_shape
+        assert P_d_z.shape == (m + 1, n + 1) + input_shape
+
+    @pytest.mark.parametrize("function", [special.lqmn])
+    @pytest.mark.parametrize(
+        "m,n",
+        [(0, 1), (1, 2), (1, 4), (3, 8), (11, 16), (19, 32)]
+    )
+    @pytest.mark.parametrize(
+        "input_shape", [
+            (), (1, ), (2, ), (2, 1), (1, 2), (2, 2), (2, 2, 1)
+        ]
+    )
+    def test_array_inputs_clxmn(self, function, m, n, input_shape):
+        """Tests for correct output shapes and dtypes."""
+        rng = np.random.default_rng(1234)
+        z = rng.uniform(-1, 1, size=input_shape)
+        z = 1j * z + 0.5j * z
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", category=DeprecationWarning)
+            P_z, P_d_z = function(m, n, z)
+
+        assert P_z.shape == (m + 1, n + 1) + input_shape
+        assert P_d_z.shape == (m + 1, n + 1) + input_shape
+
+def assoc_legendre_factor(n, m, norm):
+    if norm:
+        return (math.sqrt((2 * n + 1) *
+            math.factorial(n - m) / (2 * math.factorial(n + m))))
+
+    return 1
+
+def assoc_legendre_p_0_0(z, *, branch_cut=2, norm=False):
+    fac = assoc_legendre_factor(0, 0, norm)
+
+    return np.full_like(z, fac)
+
+def assoc_legendre_p_1_0(z, *, branch_cut=2, norm=False):
+    fac = assoc_legendre_factor(1, 0, norm)
+
+    return fac * z
+
+def assoc_legendre_p_1_1(z, *, branch_cut=2, norm=False):
+    branch_sign = np.where(branch_cut == 3, np.where(np.signbit(np.real(z)), 1, -1), -1)
+    branch_cut_sign = np.where(branch_cut == 3, -1, 1)
+    fac = assoc_legendre_factor(1, 1, norm)
+
+    w = np.sqrt(np.where(branch_cut == 3, z * z - 1, 1 - z * z))
+
+    return branch_cut_sign * branch_sign * fac * w
+
+def assoc_legendre_p_1_m1(z, *, branch_cut=2, norm=False):
+    branch_cut_sign = np.where(branch_cut == 3, -1, 1)
+    fac = assoc_legendre_factor(1, -1, norm)
+
+    return (-branch_cut_sign * fac *
+        assoc_legendre_p_1_1(z, branch_cut=branch_cut) / 2)
+
+def assoc_legendre_p_2_0(z, *, branch_cut=2, norm=False):
+    fac = assoc_legendre_factor(2, 0, norm)
+
+    return fac * (3 * z * z - 1) / 2
+
+def assoc_legendre_p_2_1(z, *, branch_cut=2, norm=False):
+    fac = assoc_legendre_factor(2, 1, norm)
+
+    return (3 * fac * z *
+        assoc_legendre_p_1_1(z, branch_cut=branch_cut))
+
+def assoc_legendre_p_2_2(z, *, branch_cut=2, norm=False):
+    branch_cut_sign = np.where(branch_cut == 3, -1, 1)
+    fac = assoc_legendre_factor(2, 2, norm)
+
+    return 3 * branch_cut_sign * fac * (1 - z * z)
+
+def assoc_legendre_p_2_m2(z, *, branch_cut=2, norm=False):
+    branch_cut_sign = np.where(branch_cut == 3, -1, 1)
+    fac = assoc_legendre_factor(2, -2, norm)
+
+    return branch_cut_sign * fac * (1 - z * z) / 8
+
+def assoc_legendre_p_2_m1(z, *, branch_cut=2, norm=False):
+    branch_cut_sign = np.where(branch_cut == 3, -1, 1)
+    fac = assoc_legendre_factor(2, -1, norm)
+
+    return (-branch_cut_sign * fac * z *
+        assoc_legendre_p_1_1(z, branch_cut=branch_cut) / 2)
+
+def assoc_legendre_p_3_0(z, *, branch_cut=2, norm=False):
+    fac = assoc_legendre_factor(3, 0, norm)
+
+    return fac * (5 * z * z - 3) * z / 2
+
+def assoc_legendre_p_3_1(z, *, branch_cut=2, norm=False):
+    fac = assoc_legendre_factor(3, 1, norm)
+
+    return (3 * fac * (5 * z * z - 1) *
+        assoc_legendre_p_1_1(z, branch_cut=branch_cut) / 2)
+
+def assoc_legendre_p_3_2(z, *, branch_cut=2, norm=False):
+    branch_cut_sign = np.where(branch_cut == 3, -1, 1)
+    fac = assoc_legendre_factor(3, 2, norm)
+
+    return 15 * branch_cut_sign * fac * (1 - z * z) * z
+
+def assoc_legendre_p_3_3(z, *, branch_cut=2, norm=False):
+    branch_cut_sign = np.where(branch_cut == 3, -1, 1)
+    fac = assoc_legendre_factor(3, 3, norm)
+
+    return (15 * branch_cut_sign * fac * (1 - z * z) *
+        assoc_legendre_p_1_1(z, branch_cut=branch_cut))
+
+def assoc_legendre_p_3_m3(z, *, branch_cut=2, norm=False):
+    fac = assoc_legendre_factor(3, -3, norm)
+
+    return (fac * (z * z - 1) *
+        assoc_legendre_p_1_1(z, branch_cut=branch_cut) / 48)
+
+def assoc_legendre_p_3_m2(z, *, branch_cut=2, norm=False):
+    branch_cut_sign = np.where(branch_cut == 3, -1, 1)
+    fac = assoc_legendre_factor(3, -2, norm)
+
+    return branch_cut_sign * fac * (1 - z * z) * z / 8
+
+def assoc_legendre_p_3_m1(z, *, branch_cut=2, norm=False):
+    branch_cut_sign = np.where(branch_cut == 3, -1, 1)
+    fac = assoc_legendre_factor(3, -1, norm)
+
+    return (branch_cut_sign * fac * (1 - 5 * z * z) *
+        assoc_legendre_p_1_1(z, branch_cut=branch_cut) / 8)
+
+def assoc_legendre_p_4_0(z, *, branch_cut=2, norm=False):
+    fac = assoc_legendre_factor(4, 0, norm)
+
+    return fac * ((35 * z * z - 30) * z * z + 3) / 8
+
+def assoc_legendre_p_4_1(z, *, branch_cut=2, norm=False):
+    fac = assoc_legendre_factor(4, 1, norm)
+
+    return (5 * fac * (7 * z * z - 3) * z *
+       assoc_legendre_p_1_1(z, branch_cut=branch_cut) / 2)
+
+def assoc_legendre_p_4_2(z, *, branch_cut=2, norm=False):
+    branch_cut_sign = np.where(branch_cut == 3, -1, 1)
+    fac = assoc_legendre_factor(4, 2, norm)
+
+    return 15 * branch_cut_sign * fac * ((8 - 7 * z * z) * z * z - 1) / 2
+
+def assoc_legendre_p_4_3(z, *, branch_cut=2, norm=False):
+    branch_cut_sign = np.where(branch_cut == 3, -1, 1)
+    fac = assoc_legendre_factor(4, 3, norm)
+
+    return (105 * branch_cut_sign * fac * (1 - z * z) * z *
+        assoc_legendre_p_1_1(z, branch_cut=branch_cut))
+
+def assoc_legendre_p_4_4(z, *, branch_cut=2, norm=False):
+    fac = assoc_legendre_factor(4, 4, norm)
+
+    return 105 * fac * np.square(z * z - 1)
+
+def assoc_legendre_p_4_m4(z, *, branch_cut=2, norm=False):
+    fac = assoc_legendre_factor(4, -4, norm)
+
+    return fac * np.square(z * z - 1) / 384
+
+def assoc_legendre_p_4_m3(z, *, branch_cut=2, norm=False):
+    fac = assoc_legendre_factor(4, -3, norm)
+
+    return (fac * (z * z - 1) * z *
+        assoc_legendre_p_1_1(z, branch_cut=branch_cut) / 48)
+
+def assoc_legendre_p_4_m2(z, *, branch_cut=2, norm=False):
+    branch_cut_sign = np.where(branch_cut == 3, -1, 1)
+    fac = assoc_legendre_factor(4, -2, norm)
+
+    return branch_cut_sign * fac * ((8 - 7 * z * z) * z * z - 1) / 48
+
+def assoc_legendre_p_4_m1(z, *, branch_cut=2, norm=False):
+    branch_cut_sign = np.where(branch_cut == 3, -1, 1)
+    fac = assoc_legendre_factor(4, -1, norm)
+
+    return (branch_cut_sign * fac * (3 - 7 * z * z) * z *
+        assoc_legendre_p_1_1(z, branch_cut=branch_cut) / 8)
+
+def assoc_legendre_p_1_1_jac_div_z(z, branch_cut=2):
+    branch_sign = np.where(branch_cut == 3, np.where(np.signbit(np.real(z)), 1, -1), -1)
+
+    out11_div_z = (-branch_sign /
+        np.sqrt(np.where(branch_cut == 3, z * z - 1, 1 - z * z)))
+
+    return out11_div_z
+
+def assoc_legendre_p_0_0_jac(z, *, branch_cut=2, norm=False):
+    return np.zeros_like(z)
+
+def assoc_legendre_p_1_0_jac(z, *, branch_cut=2, norm=False):
+    fac = assoc_legendre_factor(1, 0, norm)
+
+    return np.full_like(z, fac)
+
+def assoc_legendre_p_1_1_jac(z, *, branch_cut=2, norm=False):
+    fac = assoc_legendre_factor(1, 1, norm)
+
+    return (fac * z *
+        assoc_legendre_p_1_1_jac_div_z(z, branch_cut=branch_cut))
+
+def assoc_legendre_p_1_m1_jac(z, *, branch_cut=2, norm=False):
+    branch_cut_sign = np.where(branch_cut == 3, -1, 1)
+    fac = assoc_legendre_factor(1, -1, norm)
+
+    return (-branch_cut_sign * fac * z *
+        assoc_legendre_p_1_1_jac_div_z(z, branch_cut=branch_cut) / 2)
+
+def assoc_legendre_p_2_0_jac(z, *, branch_cut=2, norm=False):
+    fac = assoc_legendre_factor(2, 0, norm)
+
+    return 3 * fac * z
+
+def assoc_legendre_p_2_1_jac(z, *, branch_cut=2, norm=False):
+    fac = assoc_legendre_factor(2, 1, norm)
+
+    return (3 * fac * (2 * z * z - 1) *
+        assoc_legendre_p_1_1_jac_div_z(z, branch_cut=branch_cut))
+
+def assoc_legendre_p_2_2_jac(z, *, branch_cut=2, norm=False):
+    branch_cut_sign = np.where(branch_cut == 3, -1, 1)
+    fac = assoc_legendre_factor(2, 2, norm)
+
+    return -6 * branch_cut_sign * fac * z
+
+def assoc_legendre_p_2_m1_jac(z, *, branch_cut=2, norm=False):
+    branch_cut_sign = np.where(branch_cut == 3, -1, 1)
+    fac = assoc_legendre_factor(2, -1, norm)
+
+    return (branch_cut_sign * fac * (1 - 2 * z * z) *
+        assoc_legendre_p_1_1_jac_div_z(z, branch_cut=branch_cut) / 2)
+
+def assoc_legendre_p_2_m2_jac(z, *, branch_cut=2, norm=False):
+    branch_cut_sign = np.where(branch_cut == 3, -1, 1)
+    fac = assoc_legendre_factor(2, -2, norm)
+
+    return -branch_cut_sign * fac * z / 4
+
+def assoc_legendre_p_3_0_jac(z, *, branch_cut=2, norm=False):
+    fac = assoc_legendre_factor(3, 0, norm)
+
+    return 3 * fac * (5 * z * z - 1) / 2
+
+def assoc_legendre_p_3_1_jac(z, *, branch_cut=2, norm=False):
+    fac = assoc_legendre_factor(3, 1, norm)
+
+    return (3 * fac * (15 * z * z - 11) * z *
+        assoc_legendre_p_1_1_jac_div_z(z, branch_cut=branch_cut) / 2)
+
+def assoc_legendre_p_3_2_jac(z, *, branch_cut=2, norm=False):
+    branch_cut_sign = np.where(branch_cut == 3, -1, 1)
+    fac = assoc_legendre_factor(3, 2, norm)
+
+    return 15 * branch_cut_sign * fac * (1 - 3 * z * z)
+
+def assoc_legendre_p_3_3_jac(z, *, branch_cut=2, norm=False):
+    branch_cut_sign = np.where(branch_cut == 3, -1, 1)
+    fac = assoc_legendre_factor(3, 3, norm)
+
+    return (45 * branch_cut_sign * fac * (1 - z * z) * z *
+        assoc_legendre_p_1_1_jac_div_z(z, branch_cut=branch_cut))
+
+def assoc_legendre_p_3_m3_jac(z, *, branch_cut=2, norm=False):
+    fac = assoc_legendre_factor(3, -3, norm)
+
+    return (fac * (z * z - 1) * z *
+        assoc_legendre_p_1_1_jac_div_z(z, branch_cut=branch_cut) / 16)
+
+def assoc_legendre_p_3_m2_jac(z, *, branch_cut=2, norm=False):
+    branch_cut_sign = np.where(branch_cut == 3, -1, 1)
+    fac = assoc_legendre_factor(3, -2, norm)
+
+    return branch_cut_sign * fac * (1 - 3 * z * z) / 8
+
+def assoc_legendre_p_3_m1_jac(z, *, branch_cut=2, norm=False):
+    branch_cut_sign = np.where(branch_cut == 3, -1, 1)
+    fac = assoc_legendre_factor(3, -1, norm)
+
+    return (branch_cut_sign * fac * (11 - 15 * z * z) * z *
+        assoc_legendre_p_1_1_jac_div_z(z, branch_cut=branch_cut) / 8)
+
+def assoc_legendre_p_4_0_jac(z, *, branch_cut=2, norm=False):
+    fac = assoc_legendre_factor(4, 0, norm)
+
+    return 5 * fac * (7 * z * z - 3) * z / 2
+
+def assoc_legendre_p_4_1_jac(z, *, branch_cut=2, norm=False):
+    fac = assoc_legendre_factor(4, 1, norm)
+
+    return (5 * fac * ((28 * z * z - 27) * z * z + 3) *
+        assoc_legendre_p_1_1_jac_div_z(z, branch_cut=branch_cut) / 2)
+
+def assoc_legendre_p_4_2_jac(z, *, branch_cut=2, norm=False):
+    branch_cut_sign = np.where(branch_cut == 3, -1, 1)
+    fac = assoc_legendre_factor(4, 2, norm)
+
+    return 30 * branch_cut_sign * fac * (4 - 7 * z * z) * z
+
+def assoc_legendre_p_4_3_jac(z, *, branch_cut=2, norm=False):
+    branch_cut_sign = np.where(branch_cut == 3, -1, 1)
+    fac = assoc_legendre_factor(4, 3, norm)
+
+    return (105 * branch_cut_sign * fac * ((5 - 4 * z * z) * z * z - 1) *
+        assoc_legendre_p_1_1_jac_div_z(z, branch_cut=branch_cut))
+
+def assoc_legendre_p_4_4_jac(z, *, branch_cut=2, norm=False):
+    fac = assoc_legendre_factor(4, 4, norm)
+
+    return 420 * fac * (z * z - 1) * z
+
+def assoc_legendre_p_4_m4_jac(z, *, branch_cut=2, norm=False):
+    fac = assoc_legendre_factor(4, -4, norm)
+
+    return fac * (z * z - 1) * z / 96
+
+def assoc_legendre_p_4_m3_jac(z, *, branch_cut=2, norm=False):
+    fac = assoc_legendre_factor(4, -3, norm)
+
+    return (fac * ((4 * z * z - 5) * z * z + 1) *
+        assoc_legendre_p_1_1_jac_div_z(z, branch_cut=branch_cut) / 48)
+
+def assoc_legendre_p_4_m2_jac(z, *, branch_cut=2, norm=False):
+    branch_cut_sign = np.where(branch_cut == 3, -1, 1)
+    fac = assoc_legendre_factor(4, -2, norm)
+
+    return branch_cut_sign * fac * (4 - 7 * z * z) * z / 12
+
+def assoc_legendre_p_4_m1_jac(z, *, branch_cut=2, norm=False):
+    branch_cut_sign = np.where(branch_cut == 3, -1, 1)
+    fac = assoc_legendre_factor(4, -1, norm)
+
+    return (branch_cut_sign * fac * ((27 - 28 * z * z) * z * z - 3) *
+        assoc_legendre_p_1_1_jac_div_z(z, branch_cut=branch_cut) / 8)
+
+def sph_legendre_factor(n, m):
+    return assoc_legendre_factor(n, m, norm=True) / np.sqrt(2 * np.pi)
+
+def sph_legendre_p_0_0(theta):
+    fac = sph_legendre_factor(0, 0)
+
+    return np.full_like(theta, fac)
+
+def sph_legendre_p_1_0(theta):
+    fac = sph_legendre_factor(1, 0)
+
+    return fac * np.cos(theta)
+
+def sph_legendre_p_1_1(theta):
+    fac = sph_legendre_factor(1, 1)
+
+    return -fac * np.abs(np.sin(theta))
+
+def sph_legendre_p_1_m1(theta):
+    fac = sph_legendre_factor(1, -1)
+
+    return fac * np.abs(np.sin(theta)) / 2
+
+def sph_legendre_p_2_0(theta):
+    fac = sph_legendre_factor(2, 0)
+
+    return fac * (3 * np.square(np.cos(theta)) - 1) / 2
+
+def sph_legendre_p_2_1(theta):
+    fac = sph_legendre_factor(2, 1)
+
+    return -3 * fac * np.abs(np.sin(theta)) * np.cos(theta)
+
+def sph_legendre_p_2_2(theta):
+    fac = sph_legendre_factor(2, 2)
+
+    return 3 * fac * (1 - np.square(np.cos(theta)))
+
+def sph_legendre_p_2_m2(theta):
+    fac = sph_legendre_factor(2, -2)
+
+    return fac * (1 - np.square(np.cos(theta))) / 8
+
+def sph_legendre_p_2_m1(theta):
+    fac = sph_legendre_factor(2, -1)
+
+    return fac * np.cos(theta) * np.abs(np.sin(theta)) / 2
+
+def sph_legendre_p_3_0(theta):
+    fac = sph_legendre_factor(3, 0)
+
+    return (fac * (5 * np.square(np.cos(theta)) - 3) *
+        np.cos(theta) / 2)
+
+def sph_legendre_p_3_1(theta):
+    fac = sph_legendre_factor(3, 1)
+
+    return (-3 * fac * (5 * np.square(np.cos(theta)) - 1) *
+        np.abs(np.sin(theta)) / 2)
+
+def sph_legendre_p_3_2(theta):
+    fac = sph_legendre_factor(3, 2)
+
+    return (-15 * fac * (np.square(np.cos(theta)) - 1) *
+        np.cos(theta))
+
+def sph_legendre_p_3_3(theta):
+    fac = sph_legendre_factor(3, 3)
+
+    return -15 * fac * np.power(np.abs(np.sin(theta)), 3)
+
+def sph_legendre_p_3_m3(theta):
+    fac = sph_legendre_factor(3, -3)
+
+    return fac * np.power(np.abs(np.sin(theta)), 3) / 48
+
+def sph_legendre_p_3_m2(theta):
+    fac = sph_legendre_factor(3, -2)
+
+    return (-fac * (np.square(np.cos(theta)) - 1) *
+        np.cos(theta) / 8)
+
+def sph_legendre_p_3_m1(theta):
+    fac = sph_legendre_factor(3, -1)
+
+    return (fac * (5 * np.square(np.cos(theta)) - 1) *
+        np.abs(np.sin(theta)) / 8)
+
+def sph_legendre_p_4_0(theta):
+    fac = sph_legendre_factor(4, 0)
+
+    return (fac * (35 * np.square(np.square(np.cos(theta))) -
+        30 * np.square(np.cos(theta)) + 3) / 8)
+
+def sph_legendre_p_4_1(theta):
+    fac = sph_legendre_factor(4, 1)
+
+    return (-5 * fac * (7 * np.square(np.cos(theta)) - 3) *
+        np.cos(theta) * np.abs(np.sin(theta)) / 2)
+
+def sph_legendre_p_4_2(theta):
+    fac = sph_legendre_factor(4, 2)
+
+    return (-15 * fac * (7 * np.square(np.cos(theta)) - 1) *
+        (np.square(np.cos(theta)) - 1) / 2)
+
+def sph_legendre_p_4_3(theta):
+    fac = sph_legendre_factor(4, 3)
+
+    return -105 * fac * np.power(np.abs(np.sin(theta)), 3) * np.cos(theta)
+
+def sph_legendre_p_4_4(theta):
+    fac = sph_legendre_factor(4, 4)
+
+    return 105 * fac * np.square(np.square(np.cos(theta)) - 1)
+
+def sph_legendre_p_4_m4(theta):
+    fac = sph_legendre_factor(4, -4)
+
+    return fac * np.square(np.square(np.cos(theta)) - 1) / 384
+
+def sph_legendre_p_4_m3(theta):
+    fac = sph_legendre_factor(4, -3)
+
+    return (fac * np.power(np.abs(np.sin(theta)), 3) *
+        np.cos(theta) / 48)
+
+def sph_legendre_p_4_m2(theta):
+    fac = sph_legendre_factor(4, -2)
+
+    return (-fac * (7 * np.square(np.cos(theta)) - 1) *
+        (np.square(np.cos(theta)) - 1) / 48)
+
+def sph_legendre_p_4_m1(theta):
+    fac = sph_legendre_factor(4, -1)
+
+    return (fac * (7 * np.square(np.cos(theta)) - 3) *
+        np.cos(theta) * np.abs(np.sin(theta)) / 8)
+
+def sph_legendre_p_0_0_jac(theta):
+    return np.zeros_like(theta)
+
+def sph_legendre_p_1_0_jac(theta):
+    fac = sph_legendre_factor(1, 0)
+
+    return -fac * np.sin(theta)
+
+def sph_legendre_p_1_1_jac(theta):
+    fac = sph_legendre_factor(1, 1)
+
+    return -fac * np.cos(theta) * (2 * np.heaviside(np.sin(theta), 1) - 1)
+
+def sph_legendre_p_1_m1_jac(theta):
+    fac = sph_legendre_factor(1, -1)
+
+    return fac * np.cos(theta) * (2 * np.heaviside(np.sin(theta), 1) - 1) / 2
+
+def sph_legendre_p_2_0_jac(theta):
+    fac = sph_legendre_factor(2, 0)
+
+    return -3 * fac * np.cos(theta) * np.sin(theta)
+
+def sph_legendre_p_2_1_jac(theta):
+    fac = sph_legendre_factor(2, 1)
+
+    return (3 * fac * (-np.square(np.cos(theta)) *
+        (2 * np.heaviside(np.sin(theta), 1) - 1) +
+        np.abs(np.sin(theta)) * np.sin(theta)))
+
+def sph_legendre_p_2_2_jac(theta):
+    fac = sph_legendre_factor(2, 2)
+
+    return 6 * fac * np.sin(theta) * np.cos(theta)
+
+def sph_legendre_p_2_m2_jac(theta):
+    fac = sph_legendre_factor(2, -2)
+
+    return fac * np.sin(theta) * np.cos(theta) / 4
+
+def sph_legendre_p_2_m1_jac(theta):
+    fac = sph_legendre_factor(2, -1)
+
+    return (-fac * (-np.square(np.cos(theta)) *
+        (2 * np.heaviside(np.sin(theta), 1) - 1) +
+        np.abs(np.sin(theta)) * np.sin(theta)) / 2)
+
+def sph_legendre_p_3_0_jac(theta):
+    fac = sph_legendre_factor(3, 0)
+
+    return 3 * fac * (1 - 5 * np.square(np.cos(theta))) * np.sin(theta) / 2
+
+def sph_legendre_p_3_1_jac(theta):
+    fac = sph_legendre_factor(3, 1)
+
+    return (3 * fac * (11 - 15 * np.square(np.cos(theta))) * np.cos(theta) *
+        (2 * np.heaviside(np.sin(theta), 1) - 1) / 2)
+
+def sph_legendre_p_3_2_jac(theta):
+    fac = sph_legendre_factor(3, 2)
+
+    return 15 * fac * (3 * np.square(np.cos(theta)) - 1) * np.sin(theta)
+
+def sph_legendre_p_3_3_jac(theta):
+    fac = sph_legendre_factor(3, 3)
+
+    return -45 * fac * np.abs(np.sin(theta)) * np.sin(theta) * np.cos(theta)
+
+def sph_legendre_p_3_m3_jac(theta):
+    fac = sph_legendre_factor(3, -3)
+
+    return fac * np.abs(np.sin(theta)) * np.sin(theta) * np.cos(theta) / 16
+
+def sph_legendre_p_3_m2_jac(theta):
+    fac = sph_legendre_factor(3, -2)
+
+    return fac * (3 * np.square(np.cos(theta)) - 1) * np.sin(theta) / 8
+
+def sph_legendre_p_3_m1_jac(theta):
+    fac = sph_legendre_factor(3, -1)
+
+    return (-fac * (11 - 15 * np.square(np.cos(theta))) *
+        np.cos(theta) *
+        (2 * np.heaviside(np.sin(theta), 1) - 1) / 8)
+
+def sph_legendre_p_4_0_jac(theta):
+    fac = sph_legendre_factor(4, 0)
+
+    return (-5 * fac * (7 * np.square(np.cos(theta)) - 3) *
+        np.sin(theta) * np.cos(theta) / 2)
+
+def sph_legendre_p_4_1_jac(theta):
+    fac = sph_legendre_factor(4, 1)
+
+    return (5 * fac * (-3 + 27 * np.square(np.cos(theta)) -
+        28 * np.square(np.square(np.cos(theta)))) *
+        (2 * np.heaviside(np.sin(theta), 1) - 1) / 2)
+
+def sph_legendre_p_4_2_jac(theta):
+    fac = sph_legendre_factor(4, 2)
+
+    return (30 * fac * (7 * np.square(np.cos(theta)) - 4) *
+        np.sin(theta) * np.cos(theta))
+
+def sph_legendre_p_4_3_jac(theta):
+    fac = sph_legendre_factor(4, 3)
+
+    return (-105 * fac * (4 * np.square(np.cos(theta)) - 1) *
+        np.abs(np.sin(theta)) * np.sin(theta))
+
+def sph_legendre_p_4_4_jac(theta):
+    fac = sph_legendre_factor(4, 4)
+
+    return (-420 * fac * (np.square(np.cos(theta)) - 1) *
+        np.sin(theta) * np.cos(theta))
+
+def sph_legendre_p_4_m4_jac(theta):
+    fac = sph_legendre_factor(4, -4)
+
+    return (-fac * (np.square(np.cos(theta)) - 1) *
+        np.sin(theta) * np.cos(theta) / 96)
+
+def sph_legendre_p_4_m3_jac(theta):
+    fac = sph_legendre_factor(4, -3)
+
+    return (fac * (4 * np.square(np.cos(theta)) - 1) *
+        np.abs(np.sin(theta)) * np.sin(theta) / 48)
+
+def sph_legendre_p_4_m2_jac(theta):
+    fac = sph_legendre_factor(4, -2)
+
+    return (fac * (7 * np.square(np.cos(theta)) - 4) * np.sin(theta) *
+        np.cos(theta) / 12)
+
+def sph_legendre_p_4_m1_jac(theta):
+    fac = sph_legendre_factor(4, -1)
+
+    return (-fac * (-3 + 27 * np.square(np.cos(theta)) -
+        28 * np.square(np.square(np.cos(theta)))) *
+        (2 * np.heaviside(np.sin(theta), 1) - 1) / 8)

.venv/lib/python3.12/site-packages/scipy/special/tests/test_log1mexp.py

@@ -0,0 +1,85 @@
+import numpy as np
+import pytest
+
+from numpy.testing import assert_allclose, assert_equal
+
+from scipy.special._ufuncs import _log1mexp
+
+# # Test cases generated with the script
+#
+# import numpy as np
+
+# from mpmath import mp
+
+
+# def mp_log1mexp(x):
+#     with mp.workdps(324):
+#         return float(mp.log(mp.one - mp.exp(x)))
+
+# X = np.concat([-np.logspace(-1, -300, 20), np.linspace(-745, -1, 20)])
+
+# cases = [(float(x), mp_log1mexp(x)) for x in X]
+
+@pytest.mark.parametrize(
+    "x,expected",
+    [
+        (-0.1, -2.3521684610440907),
+        (-1.8329807108324374e-17, -38.538003135374026),
+        (-3.359818286283788e-33, -74.773421177754),
+        (-6.1584821106602796e-49, -111.00883922013399),
+        (-1.1288378916846929e-64, -147.24425726251397),
+        (-2.0691380811148324e-80, -183.47967530489393),
+        (-3.792690190732269e-96, -219.71509334727392),
+        (-6.951927961775534e-112, -255.95051138965394),
+        (-1.2742749857031425e-127, -292.1859294320339),
+        (-2.3357214690901785e-143, -328.42134747441384),
+        (-4.281332398719571e-159, -364.6567655167938),
+        (-7.847599703514559e-175, -400.8921835591739),
+        (-1.4384498882876776e-190, -437.1276016015538),
+        (-2.6366508987304307e-206, -473.3630196439338),
+        (-4.832930238571653e-222, -509.59843768631384),
+        (-8.858667904100796e-238, -545.8338557286938),
+        (-1.623776739188744e-253, -582.0692737710738),
+        (-2.9763514416312156e-269, -618.3046918134538),
+        (-5.455594781168782e-285, -654.5401098558336),
+        (-1e-300, -690.7755278982137),
+        (-745.0, -5e-324),
+        (-705.8421052631579, -2.8619931451743316e-307),
+        (-666.6842105263158, -2.9021923726875757e-290),
+        (-627.5263157894738, -2.9429562339405562e-273),
+        (-588.3684210526316, -2.9842926597143714e-256),
+        (-549.2105263157895, -3.0262096921839423e-239),
+        (-510.0526315789474, -3.0687154864846747e-222),
+        (-470.89473684210526, -3.1118183122979086e-205),
+        (-431.7368421052632, -3.155526555459449e-188),
+        (-392.5789473684211, -3.1998487195921207e-171),
+        (-353.42105263157896, -3.2447934277596653e-154),
+        (-314.2631578947369, -3.2903694241438367e-137),
+        (-275.1052631578948, -3.3365855757467166e-120),
+        (-235.94736842105266, -3.3834508741152875e-103),
+        (-196.78947368421052, -3.4309744370903894e-86),
+        (-157.63157894736844, -3.4791655105810003e-69),
+        (-118.47368421052636, -3.528033470363468e-52),
+        (-79.31578947368428, -3.577587823905024e-35),
+        (-40.157894736842195, -3.627838212213697e-18),
+        (-1.0, -0.4586751453870819),
+    ]
+)
+def test_log1mexp(x, expected):
+    observed = _log1mexp(x)
+    assert_allclose(observed, expected, rtol=1e-15, atol=1e-300)
+
+
+@pytest.mark.parametrize("x", [1.1, 1e10, np.inf])
+def test_log1mexp_out_of_domain(x):
+    observed = _log1mexp(x)
+    assert np.isnan(observed)
+
+
+@pytest.mark.parametrize(
+    "x,expected",
+    [(-np.inf, -0.0), (0.0, -np.inf), (-0.0, -np.inf), (np.nan, np.nan)]
+)
+def test_log1mexp_extreme(x, expected):
+    observed = _log1mexp(x)
+    assert_equal(expected, observed)

.venv/lib/python3.12/site-packages/scipy/special/tests/test_loggamma.py

@@ -0,0 +1,70 @@
+import numpy as np
+from numpy.testing import assert_allclose, assert_
+
+from scipy.special._testutils import FuncData
+from scipy.special import gamma, gammaln, loggamma
+
+
+def test_identities1():
+    # test the identity exp(loggamma(z)) = gamma(z)
+    x = np.array([-99.5, -9.5, -0.5, 0.5, 9.5, 99.5])
+    y = x.copy()
+    x, y = np.meshgrid(x, y)
+    z = (x + 1J*y).flatten()
+    dataset = np.vstack((z, gamma(z))).T
+
+    def f(z):
+        return np.exp(loggamma(z))
+
+    FuncData(f, dataset, 0, 1, rtol=1e-14, atol=1e-14).check()
+
+
+def test_identities2():
+    # test the identity loggamma(z + 1) = log(z) + loggamma(z)
+    x = np.array([-99.5, -9.5, -0.5, 0.5, 9.5, 99.5])
+    y = x.copy()
+    x, y = np.meshgrid(x, y)
+    z = (x + 1J*y).flatten()
+    dataset = np.vstack((z, np.log(z) + loggamma(z))).T
+
+    def f(z):
+        return loggamma(z + 1)
+
+    FuncData(f, dataset, 0, 1, rtol=1e-14, atol=1e-14).check()
+
+
+def test_complex_dispatch_realpart():
+    # Test that the real parts of loggamma and gammaln agree on the
+    # real axis.
+    x = np.r_[-np.logspace(10, -10), np.logspace(-10, 10)] + 0.5
+
+    dataset = np.vstack((x, gammaln(x))).T
+
+    def f(z):
+        z = np.array(z, dtype='complex128')
+        return loggamma(z).real
+
+    FuncData(f, dataset, 0, 1, rtol=1e-14, atol=1e-14).check()
+
+
+def test_real_dispatch():
+    x = np.logspace(-10, 10) + 0.5
+    dataset = np.vstack((x, gammaln(x))).T
+
+    FuncData(loggamma, dataset, 0, 1, rtol=1e-14, atol=1e-14).check()
+    assert_(loggamma(0) == np.inf)
+    assert_(np.isnan(loggamma(-1)))
+
+
+def test_gh_6536():
+    z = loggamma(complex(-3.4, +0.0))
+    zbar = loggamma(complex(-3.4, -0.0))
+    assert_allclose(z, zbar.conjugate(), rtol=1e-15, atol=0)
+
+
+def test_branch_cut():
+    # Make sure negative zero is treated correctly
+    x = -np.logspace(300, -30, 100)
+    z = np.asarray([complex(x0, 0.0) for x0 in x])
+    zbar = np.asarray([complex(x0, -0.0) for x0 in x])
+    assert_allclose(z, zbar.conjugate(), rtol=1e-15, atol=0)

.venv/lib/python3.12/site-packages/scipy/special/tests/test_logit.py

@@ -0,0 +1,161 @@
+import numpy as np
+from numpy.testing import assert_equal, assert_allclose
+from scipy.special import logit, expit, log_expit
+
+
+class TestLogit:
+
+    def check_logit_out(self, a, expected):
+        actual = logit(a)
+        assert_equal(actual.dtype, a.dtype)
+        rtol = 16*np.finfo(a.dtype).eps
+        assert_allclose(actual, expected, rtol=rtol)
+
+    def test_float32(self):
+        a = np.concatenate((np.linspace(0, 1, 10, dtype=np.float32),
+                            [np.float32(0.0001), np.float32(0.49999),
+                             np.float32(0.50001)]))
+        # Expected values computed with mpmath from float32 inputs, e.g.
+        #   from mpmath import mp
+        #   mp.dps = 200
+        #   a = np.float32(1/9)
+        #   print(np.float32(mp.log(a) - mp.log1p(-a)))
+        # prints `-2.0794415`.
+        expected = np.array([-np.inf, -2.0794415, -1.2527629, -6.9314712e-01,
+                             -2.2314353e-01,  2.2314365e-01,  6.9314724e-01,
+                             1.2527630, 2.0794415, np.inf,
+                             -9.2102404, -4.0054321e-05, 4.0054321e-05],
+                            dtype=np.float32)
+        self.check_logit_out(a, expected)
+
+    def test_float64(self):
+        a = np.concatenate((np.linspace(0, 1, 10, dtype=np.float64),
+                            [1e-8, 0.4999999999999, 0.50000000001]))
+        # Expected values computed with mpmath.
+        expected = np.array([-np.inf,
+                             -2.079441541679836,
+                             -1.252762968495368,
+                             -0.6931471805599454,
+                             -0.22314355131420985,
+                             0.22314355131420985,
+                             0.6931471805599452,
+                             1.2527629684953674,
+                             2.0794415416798353,
+                             np.inf,
+                             -18.420680733952366,
+                             -3.999023334699814e-13,
+                             4.000000330961484e-11])
+        self.check_logit_out(a, expected)
+
+    def test_nan(self):
+        expected = np.array([np.nan]*4)
+        with np.errstate(invalid='ignore'):
+            actual = logit(np.array([-3., -2., 2., 3.]))
+
+        assert_equal(expected, actual)
+
+
+class TestExpit:
+    def check_expit_out(self, dtype, expected):
+        a = np.linspace(-4, 4, 10)
+        a = np.array(a, dtype=dtype)
+        actual = expit(a)
+        assert_allclose(actual, expected, atol=1.5e-7, rtol=0)
+        assert_equal(actual.dtype, np.dtype(dtype))
+
+    def test_float32(self):
+        expected = np.array([0.01798621, 0.04265125,
+                            0.09777259, 0.20860852,
+                            0.39068246, 0.60931754,
+                            0.79139149, 0.9022274,
+                            0.95734876, 0.98201376], dtype=np.float32)
+        self.check_expit_out('f4', expected)
+
+    def test_float64(self):
+        expected = np.array([0.01798621, 0.04265125,
+                            0.0977726, 0.20860853,
+                            0.39068246, 0.60931754,
+                            0.79139147, 0.9022274,
+                            0.95734875, 0.98201379])
+        self.check_expit_out('f8', expected)
+
+    def test_large(self):
+        for dtype in (np.float32, np.float64, np.longdouble):
+            for n in (88, 89, 709, 710, 11356, 11357):
+                n = np.array(n, dtype=dtype)
+                assert_allclose(expit(n), 1.0, atol=1e-20)
+                assert_allclose(expit(-n), 0.0, atol=1e-20)
+                assert_equal(expit(n).dtype, dtype)
+                assert_equal(expit(-n).dtype, dtype)
+
+
+class TestLogExpit:
+
+    def test_large_negative(self):
+        x = np.array([-10000.0, -750.0, -500.0, -35.0])
+        y = log_expit(x)
+        assert_equal(y, x)
+
+    def test_large_positive(self):
+        x = np.array([750.0, 1000.0, 10000.0])
+        y = log_expit(x)
+        # y will contain -0.0, and -0.0 is used in the expected value,
+        # but assert_equal does not check the sign of zeros, and I don't
+        # think the sign is an essential part of the test (i.e. it would
+        # probably be OK if log_expit(1000) returned 0.0 instead of -0.0).
+        assert_equal(y, np.array([-0.0, -0.0, -0.0]))
+
+    def test_basic_float64(self):
+        x = np.array([-32, -20, -10, -3, -1, -0.1, -1e-9,
+                      0, 1e-9, 0.1, 1, 10, 100, 500, 710, 725, 735])
+        y = log_expit(x)
+        #
+        # Expected values were computed with mpmath:
+        #
+        #   import mpmath
+        #
+        #   mpmath.mp.dps = 100
+        #
+        #   def mp_log_expit(x):
+        #       return -mpmath.log1p(mpmath.exp(-x))
+        #
+        #   expected = [float(mp_log_expit(t)) for t in x]
+        #
+        expected = [-32.000000000000014, -20.000000002061153,
+                    -10.000045398899218, -3.048587351573742,
+                    -1.3132616875182228, -0.7443966600735709,
+                    -0.6931471810599453, -0.6931471805599453,
+                    -0.6931471800599454, -0.6443966600735709,
+                    -0.3132616875182228, -4.539889921686465e-05,
+                    -3.720075976020836e-44, -7.124576406741286e-218,
+                    -4.47628622567513e-309, -1.36930634e-315,
+                    -6.217e-320]
+
+        # When tested locally, only one value in y was not exactly equal to
+        # expected.  That was for x=1, and the y value differed from the
+        # expected by 1 ULP.  For this test, however, I'll use rtol=1e-15.
+        assert_allclose(y, expected, rtol=1e-15)
+
+    def test_basic_float32(self):
+        x = np.array([-32, -20, -10, -3, -1, -0.1, -1e-9,
+                      0, 1e-9, 0.1, 1, 10, 100], dtype=np.float32)
+        y = log_expit(x)
+        #
+        # Expected values were computed with mpmath:
+        #
+        #   import mpmath
+        #
+        #   mpmath.mp.dps = 100
+        #
+        #   def mp_log_expit(x):
+        #       return -mpmath.log1p(mpmath.exp(-x))
+        #
+        #   expected = [np.float32(mp_log_expit(t)) for t in x]
+        #
+        expected = np.array([-32.0, -20.0, -10.000046, -3.0485873,
+                             -1.3132616, -0.7443967, -0.6931472,
+                             -0.6931472, -0.6931472, -0.64439666,
+                             -0.3132617, -4.5398898e-05, -3.8e-44],
+                            dtype=np.float32)
+
+        assert_allclose(y, expected, rtol=5e-7)

.venv/lib/python3.12/site-packages/scipy/special/tests/test_logsumexp.py

@@ -0,0 +1,481 @@
+import itertools as it
+import math
+import pytest
+
+import numpy as np
+
+from scipy._lib._array_api import (is_array_api_strict, make_xp_test_case,
+                                   xp_default_dtype, xp_device)
+from scipy._lib._array_api_no_0d import (xp_assert_equal, xp_assert_close,
+                                         xp_assert_less)
+
+from scipy.special import log_softmax, logsumexp, softmax
+from scipy.special._logsumexp import _wrap_radians
+
+
+dtypes = ['float32', 'float64', 'int32', 'int64', 'complex64', 'complex128']
+integral_dtypes = ['int32', 'int64']
+
+
+@pytest.mark.uses_xp_capabilities(False, reason="private")
+def test_wrap_radians(xp):
+    x = xp.asarray([-math.pi-1, -math.pi, -1, -1e-300,
+                    0, 1e-300, 1, math.pi, math.pi+1])
+    ref = xp.asarray([math.pi-1, math.pi, -1, -1e-300,
+                    0, 1e-300, 1, math.pi, -math.pi+1])
+    res = _wrap_radians(x, xp=xp)
+    xp_assert_close(res, ref, atol=0)
+
+
+# numpy warning filters don't work for dask (dask/dask#3245)
+# (also we should not expect the numpy warning filter to work for any Array API
+# library)
+@pytest.mark.filterwarnings("ignore:invalid value encountered:RuntimeWarning")
+@pytest.mark.filterwarnings("ignore:divide by zero encountered:RuntimeWarning")
+@pytest.mark.filterwarnings("ignore:overflow encountered:RuntimeWarning")
+@make_xp_test_case(logsumexp)
+class TestLogSumExp:
+    def test_logsumexp(self, xp):
+        # Test with zero-size array
+        a = xp.asarray([])
+        desired = xp.asarray(-xp.inf)
+        xp_assert_equal(logsumexp(a), desired)
+
+        # Test whether logsumexp() function correctly handles large inputs.
+        a = xp.arange(200., dtype=xp.float64)
+        desired = xp.log(xp.sum(xp.exp(a)))
+        xp_assert_close(logsumexp(a), desired)
+
+        # Now test with large numbers
+        b = xp.asarray([1000., 1000.])
+        desired = xp.asarray(1000.0 + math.log(2.0))
+        xp_assert_close(logsumexp(b), desired)
+
+        n = 1000
+        b = xp.full((n,), 10000)
+        desired = xp.asarray(10000.0 + math.log(n))
+        xp_assert_close(logsumexp(b), desired)
+
+        x = xp.asarray([1e-40] * 1000000)
+        logx = xp.log(x)
+        X = xp.stack([x, x])
+        logX = xp.stack([logx, logx])
+        xp_assert_close(xp.exp(logsumexp(logX)), xp.sum(X))
+        xp_assert_close(xp.exp(logsumexp(logX, axis=0)), xp.sum(X, axis=0))
+        xp_assert_close(xp.exp(logsumexp(logX, axis=1)), xp.sum(X, axis=1))
+
+        # Handling special values properly
+        inf = xp.asarray([xp.inf])
+        nan = xp.asarray([xp.nan])
+        xp_assert_equal(logsumexp(inf), inf[0])
+        xp_assert_equal(logsumexp(-inf), -inf[0])
+        xp_assert_equal(logsumexp(nan), nan[0])
+        xp_assert_equal(logsumexp(xp.asarray([-xp.inf, -xp.inf])), -inf[0])
+
+        # Handling an array with different magnitudes on the axes
+        a = xp.asarray([[1e10, 1e-10],
+                        [-1e10, -np.inf]])
+        ref = xp.asarray([1e10, -1e10])
+        xp_assert_close(logsumexp(a, axis=-1), ref)
+
+        # Test keeping dimensions
+        ref = xp.expand_dims(ref, axis=-1)
+        xp_assert_close(logsumexp(a, axis=-1, keepdims=True), ref)
+
+        # Test multiple axes
+        xp_assert_close(logsumexp(a, axis=(-1, -2)), xp.asarray(1e10))
+
+    def test_logsumexp_b(self, xp):
+        a = xp.arange(200., dtype=xp.float64)
+        b = xp.arange(200., 0., -1.)
+        desired = xp.log(xp.sum(b*xp.exp(a)))
+        xp_assert_close(logsumexp(a, b=b), desired)
+
+        a = xp.asarray([1000, 1000])
+        b = xp.asarray([1.2, 1.2])
+        desired = xp.asarray(1000 + math.log(2 * 1.2))
+        xp_assert_close(logsumexp(a, b=b), desired)
+
+        x = xp.asarray([1e-40] * 100000)
+        b = xp.linspace(1, 1000, 100000)
+        logx = xp.log(x)
+        X = xp.stack((x, x))
+        logX = xp.stack((logx, logx))
+        B = xp.stack((b, b))
+        xp_assert_close(xp.exp(logsumexp(logX, b=B)), xp.sum(B * X))
+        xp_assert_close(xp.exp(logsumexp(logX, b=B, axis=0)), xp.sum(B * X, axis=0))
+        xp_assert_close(xp.exp(logsumexp(logX, b=B, axis=1)), xp.sum(B * X, axis=1))
+
+    def test_logsumexp_sign(self, xp):
+        a = xp.asarray([1, 1, 1])
+        b = xp.asarray([1, -1, -1])
+
+        r, s = logsumexp(a, b=b, return_sign=True)
+        xp_assert_close(r, xp.asarray(1.))
+        xp_assert_equal(s, xp.asarray(-1.))
+
+    def test_logsumexp_sign_zero(self, xp):
+        a = xp.asarray([1, 1])
+        b = xp.asarray([1, -1])
+
+        r, s = logsumexp(a, b=b, return_sign=True)
+        assert not xp.isfinite(r)
+        assert not xp.isnan(r)
+        assert r < 0
+        assert s == 0
+
+    def test_logsumexp_sign_shape(self, xp):
+        a = xp.ones((1, 2, 3, 4))
+        b = xp.ones_like(a)
+
+        r, s = logsumexp(a, axis=2, b=b, return_sign=True)
+        assert r.shape == s.shape == (1, 2, 4)
+
+        r, s = logsumexp(a, axis=(1, 3), b=b, return_sign=True)
+        assert r.shape == s.shape == (1,3)
+
+    def test_logsumexp_complex_sign(self, xp):
+        a = xp.asarray([1 + 1j, 2 - 1j, -2 + 3j])
+
+        r, s = logsumexp(a, return_sign=True)
+
+        expected_sumexp = xp.sum(xp.exp(a))
+        # This is the numpy>=2.0 convention for np.sign
+        expected_sign = expected_sumexp / xp.abs(expected_sumexp)
+
+        xp_assert_close(s, expected_sign)
+        xp_assert_close(s * xp.exp(r), expected_sumexp)
+
+    def test_logsumexp_shape(self, xp):
+        a = xp.ones((1, 2, 3, 4))
+        b = xp.ones_like(a)
+
+        r = logsumexp(a, axis=2, b=b)
+        assert r.shape == (1, 2, 4)
+
+        r = logsumexp(a, axis=(1, 3), b=b)
+        assert r.shape == (1, 3)
+
+    def test_logsumexp_b_zero(self, xp):
+        a = xp.asarray([1, 10000])
+        b = xp.asarray([1, 0])
+
+        xp_assert_close(logsumexp(a, b=b), xp.asarray(1.))
+
+    def test_logsumexp_b_shape(self, xp):
+        a = xp.zeros((4, 1, 2, 1))
+        b = xp.ones((3, 1, 5))
+
+        logsumexp(a, b=b)
+
+    @pytest.mark.parametrize('arg', (1, [1, 2, 3]))
+    def test_xp_invalid_input(self, arg):
+        assert logsumexp(arg) == logsumexp(np.asarray(np.atleast_1d(arg)))
+
+    def test_array_like(self):
+        a = [1000, 1000]
+        desired = np.asarray(1000.0 + math.log(2.0))
+        xp_assert_close(logsumexp(a), desired)
+
+    @pytest.mark.parametrize('dtype', dtypes)
+    def test_dtypes_a(self, dtype, xp):
+        dtype = getattr(xp, dtype)
+        a = xp.asarray([1000., 1000.], dtype=dtype)
+        desired_dtype = (xp.asarray(1.).dtype if xp.isdtype(dtype, 'integral')
+                         else dtype)  # true for all libraries tested
+        desired = xp.asarray(1000.0 + math.log(2.0), dtype=desired_dtype)
+        xp_assert_close(logsumexp(a), desired)
+
+    @pytest.mark.parametrize('dtype_a', dtypes)
+    @pytest.mark.parametrize('dtype_b', dtypes)
+    def test_dtypes_ab(self, dtype_a, dtype_b, xp):
+        xp_dtype_a = getattr(xp, dtype_a)
+        xp_dtype_b = getattr(xp, dtype_b)
+        a = xp.asarray([2, 1], dtype=xp_dtype_a)
+        b = xp.asarray([1, -1], dtype=xp_dtype_b)
+        if is_array_api_strict(xp):
+            # special-case for `TypeError: array_api_strict.float32 and
+            # and array_api_strict.int64 cannot be type promoted together`
+            xp_float_dtypes = [dtype for dtype in [xp_dtype_a, xp_dtype_b]
+                               if not xp.isdtype(dtype, 'integral')]
+            if len(xp_float_dtypes) < 2:  # at least one is integral
+                xp_float_dtypes.append(xp.asarray(1.).dtype)
+            desired_dtype = xp.result_type(*xp_float_dtypes)
+        else:
+            desired_dtype = xp.result_type(xp_dtype_a, xp_dtype_b)
+            if xp.isdtype(desired_dtype, 'integral'):
+               desired_dtype = xp_default_dtype(xp)
+        desired = xp.asarray(math.log(math.exp(2) - math.exp(1)), dtype=desired_dtype)
+        xp_assert_close(logsumexp(a, b=b), desired)
+
+    def test_gh18295(self, xp):
+        # gh-18295 noted loss of precision when real part of one element is much
+        # larger than the rest. Check that this is resolved.
+        a = xp.asarray([0.0, -40.0])
+        res = logsumexp(a)
+        ref = xp.logaddexp(a[0], a[1])
+        xp_assert_close(res, ref)
+
+    @pytest.mark.parametrize('dtype', ['complex64', 'complex128'])
+    def test_gh21610(self, xp, dtype):
+        # gh-21610 noted that `logsumexp` could return imaginary components
+        # outside the range (-pi, pi]. Check that this is resolved.
+        # While working on this, I noticed that all other tests passed even
+        # when the imaginary component of the result was zero. This suggested
+        # the need of a stronger test with imaginary dtype.
+        rng = np.random.default_rng(324984329582349862)
+        dtype = getattr(xp, dtype)
+        shape = (10, 100)
+        x = rng.uniform(1, 40, shape) + 1.j * rng.uniform(1, 40, shape)
+        x = xp.asarray(x, dtype=dtype)
+
+        res = logsumexp(x, axis=1)
+        ref = xp.log(xp.sum(xp.exp(x), axis=1))
+        max = xp.full_like(xp.imag(res), xp.pi)
+        xp_assert_less(xp.abs(xp.imag(res)), max)
+        xp_assert_close(res, ref)
+
+        out, sgn = logsumexp(x, return_sign=True, axis=1)
+        ref = xp.sum(xp.exp(x), axis=1)
+        xp_assert_less(xp.abs(xp.imag(sgn)), max)
+        xp_assert_close(out, xp.real(xp.log(ref)))
+        xp_assert_close(sgn, ref/xp.abs(ref))
+
+    def test_gh21709_small_imaginary(self, xp):
+        # Test that `logsumexp` does not lose relative precision of
+        # small imaginary components
+        x = xp.asarray([0, 0.+2.2204460492503132e-17j])
+        res = logsumexp(x)
+        # from mpmath import mp
+        # mp.dps = 100
+        # x, y = mp.mpc(0), mp.mpc('0', '2.2204460492503132e-17')
+        # ref = complex(mp.log(mp.exp(x) + mp.exp(y)))
+        ref = xp.asarray(0.6931471805599453+1.1102230246251566e-17j)
+        xp_assert_close(xp.real(res), xp.real(ref))
+        xp_assert_close(xp.imag(res), xp.imag(ref), atol=0, rtol=1e-15)
+
+
+    @pytest.mark.parametrize('x,y', list(it.product(
+        [
+            -np.inf,
+            np.inf,
+            complex(-np.inf, 0.),
+            complex(-np.inf, -0.),
+            complex(-np.inf, np.inf),
+            complex(-np.inf, -np.inf),
+            complex(np.inf, 0.),
+            complex(np.inf, -0.),
+            complex(np.inf, np.inf),
+            complex(np.inf, -np.inf),
+            # Phase in each quadrant.
+            complex(-np.inf, 0.7533),
+            complex(-np.inf, 2.3562),
+            complex(-np.inf, 3.9270),
+            complex(-np.inf, 5.4978),
+            complex(np.inf, 0.7533),
+            complex(np.inf, 2.3562),
+            complex(np.inf, 3.9270),
+            complex(np.inf, 5.4978),
+        ], repeat=2)
+    ))
+    def test_gh22601_infinite_elements(self, x, y, xp):
+        # Test that `logsumexp` does reasonable things in the presence of
+        # real and complex infinities.
+        res = logsumexp(xp.asarray([x, y]))
+        ref = xp.log(xp.sum(xp.exp(xp.asarray([x, y]))))
+        xp_assert_equal(res, ref)
+
+    def test_no_writeback(self, xp):
+        """Test that logsumexp doesn't accidentally write back to its parameters."""
+        a = xp.asarray([5., 4.])
+        b = xp.asarray([3., 2.])
+        logsumexp(a)
+        logsumexp(a, b=b)
+        xp_assert_equal(a, xp.asarray([5., 4.]))
+        xp_assert_equal(b, xp.asarray([3., 2.]))
+
+    @pytest.mark.parametrize("x_raw", [1.0, 1.0j, []])
+    def test_device(self, x_raw, xp, devices):
+        """Test input device propagation to output."""
+        for d in devices:
+            x = xp.asarray(x_raw, device=d)
+            assert xp_device(logsumexp(x)) == xp_device(x)
+            assert xp_device(logsumexp(x, b=x)) == xp_device(x)
+
+    def test_gh22903(self, xp):
+        # gh-22903 reported that `logsumexp` produced NaN where the weight associated
+        # with the max magnitude element was negative and `return_sign=False`, even if
+        # the net result should be the log of a positive number.
+
+        # result is log of positive number
+        a = xp.asarray([3.06409428, 0.37251854, 3.87471931])
+        b = xp.asarray([1.88190708, 2.84174795, -0.85016884])
+        xp_assert_close(logsumexp(a, b=b), logsumexp(a, b=b, return_sign=True)[0])
+
+        # result is log of negative number
+        b = xp.asarray([1.88190708, 2.84174795, -3.85016884])
+        xp_assert_close(logsumexp(a, b=b), xp.asarray(xp.nan))
+
+    @pytest.mark.parametrize("a, b, sign_ref",
+                             [([np.inf], None, 1.),
+                              ([np.inf], [-1.], -1.)])
+    def test_gh23548(self, xp, a, b, sign_ref):
+        # gh-23548 reported that `logsumexp` with `return_sign=True` returned a sign
+        # of NaN with infinite reals
+        a, b = xp.asarray(a), xp.asarray(b) if b is not None else None
+        val, sign = logsumexp(a, b=b, return_sign=True)
+        assert xp.isinf(val)
+        xp_assert_equal(sign, xp.asarray(sign_ref))
+
+
+@make_xp_test_case(softmax)
+class TestSoftmax:
+    def test_softmax_fixtures(self, xp):
+        xp_assert_close(softmax(xp.asarray([1000., 0., 0., 0.])),
+                        xp.asarray([1., 0., 0., 0.]), rtol=1e-13)
+        xp_assert_close(softmax(xp.asarray([1., 1.])),
+                        xp.asarray([.5, .5]), rtol=1e-13)
+        xp_assert_close(softmax(xp.asarray([0., 1.])),
+                        xp.asarray([1., np.e])/(1 + np.e),
+                        rtol=1e-13)
+
+        # Expected value computed using mpmath (with mpmath.mp.dps = 200) and then
+        # converted to float.
+        x = xp.arange(4, dtype=xp.float64)
+        expected = xp.asarray([0.03205860328008499,
+                               0.08714431874203256,
+                               0.23688281808991013,
+                               0.6439142598879722], dtype=xp.float64)
+
+        xp_assert_close(softmax(x), expected, rtol=1e-13)
+
+        # Translation property.  If all the values are changed by the same amount,
+        # the softmax result does not change.
+        xp_assert_close(softmax(x + 100), expected, rtol=1e-13)
+
+        # When axis=None, softmax operates on the entire array, and preserves
+        # the shape.
+        xp_assert_close(softmax(xp.reshape(x, (2, 2))),
+                        xp.reshape(expected, (2, 2)), rtol=1e-13)
+
+    def test_softmax_multi_axes(self, xp):
+        xp_assert_close(softmax(xp.asarray([[1000., 0.], [1000., 0.]]), axis=0),
+                        xp.asarray([[.5, .5], [.5, .5]]), rtol=1e-13)
+        xp_assert_close(softmax(xp.asarray([[1000., 0.], [1000., 0.]]), axis=1),
+                        xp.asarray([[1., 0.], [1., 0.]]), rtol=1e-13)
+
+        # Expected value computed using mpmath (with mpmath.mp.dps = 200) and then
+        # converted to float.
+        x = xp.asarray([[-25.,   0.,  25.,  50.],
+                        [  1., 325., 749., 750.]])
+        expected = xp.asarray([[2.678636961770877e-33,
+                                1.9287498479371314e-22,
+                                1.3887943864771144e-11,
+                                0.999999999986112],
+                               [0.0,
+                                1.9444526359919372e-185,
+                                0.2689414213699951,
+                                0.7310585786300048]])
+        xp_assert_close(softmax(x, axis=1), expected, rtol=1e-13)
+        xp_assert_close(softmax(x.T, axis=0), expected.T, rtol=1e-13)
+
+        # 3-d input, with a tuple for the axis.
+        x3d = xp.reshape(x, (2, 2, 2))
+        xp_assert_close(softmax(x3d, axis=(1, 2)),
+                        xp.reshape(expected, (2, 2, 2)), rtol=1e-13)
+
+    @pytest.mark.xfail_xp_backends("array_api_strict", reason="int->float promotion")
+    def test_softmax_int_array(self, xp):
+        xp_assert_close(softmax(xp.asarray([1000, 0, 0, 0])),
+                        xp.asarray([1., 0., 0., 0.]), rtol=1e-13)
+
+    def test_softmax_scalar(self):
+        xp_assert_close(softmax(1000), np.asarray(1.), rtol=1e-13)
+
+    def test_softmax_array_like(self):
+        xp_assert_close(softmax([1000, 0, 0, 0]),
+                        np.asarray([1., 0., 0., 0.]), rtol=1e-13)
+
+
+@make_xp_test_case(log_softmax)
+class TestLogSoftmax:
+    def test_log_softmax_basic(self, xp):
+        xp_assert_close(log_softmax(xp.asarray([1000., 1.])),
+                        xp.asarray([0., -999.]), rtol=1e-13)
+
+    @pytest.mark.xfail_xp_backends("array_api_strict", reason="int->float promotion")
+    def test_log_softmax_int_array(self, xp):
+        xp_assert_close(log_softmax(xp.asarray([1000, 1])),
+                        xp.asarray([0., -999.]), rtol=1e-13)
+
+    def test_log_softmax_scalar(self):
+        xp_assert_close(log_softmax(1.0), 0.0, rtol=1e-13)
+
+    def test_log_softmax_array_like(self):
+        xp_assert_close(log_softmax([1000, 1]),
+                        np.asarray([0., -999.]), rtol=1e-13)
+
+    @staticmethod
+    def data_1d(xp):
+        x = xp.arange(4, dtype=xp.float64)
+        # Expected value computed using mpmath (with mpmath.mp.dps = 200)
+        expect = [-3.4401896985611953,
+                  -2.4401896985611953,
+                  -1.4401896985611953,
+                  -0.44018969856119533]
+        return x, xp.asarray(expect, dtype=xp.float64)
+
+    @staticmethod
+    def data_2d(xp):
+        x = xp.reshape(xp.arange(8, dtype=xp.float64), (2, 4))
+
+        # Expected value computed using mpmath (with mpmath.mp.dps = 200)
+        expect = [[-3.4401896985611953,
+                   -2.4401896985611953,
+                   -1.4401896985611953,
+                   -0.44018969856119533],
+                  [-3.4401896985611953,
+                   -2.4401896985611953,
+                   -1.4401896985611953,
+                   -0.44018969856119533]]
+        return x, xp.asarray(expect, dtype=xp.float64)
+
+    @pytest.mark.parametrize("offset", [0, 100])
+    def test_log_softmax_translation(self, offset, xp):
+        # Translation property.  If all the values are changed by the same amount,
+        # the softmax result does not change.
+        x, expect = self.data_1d(xp)
+        x += offset
+        xp_assert_close(log_softmax(x), expect, rtol=1e-13)
+
+    def test_log_softmax_noneaxis(self, xp):
+        # When axis=None, softmax operates on the entire array, and preserves
+        # the shape.
+        x, expect = self.data_1d(xp)
+        x = xp.reshape(x, (2, 2))
+        expect = xp.reshape(expect, (2, 2))
+        xp_assert_close(log_softmax(x), expect, rtol=1e-13)
+
+    @pytest.mark.parametrize('axis_2d, expected_2d', [
+        (0, np.log(0.5) * np.ones((2, 2))),
+        (1, [[0., -999.], [0., -999.]]),
+    ])
+    def test_axes(self, axis_2d, expected_2d, xp):
+        x = xp.asarray([[1000., 1.], [1000., 1.]])
+        xp_assert_close(log_softmax(x, axis=axis_2d),
+                        xp.asarray(expected_2d, dtype=x.dtype), rtol=1e-13)
+
+    def test_log_softmax_2d_axis1(self, xp):
+        x, expect = self.data_2d(xp)
+        xp_assert_close(log_softmax(x, axis=1), expect, rtol=1e-13)
+
+    def test_log_softmax_2d_axis0(self, xp):
+        x, expect = self.data_2d(xp)
+        xp_assert_close(log_softmax(x.T, axis=0), expect.T, rtol=1e-13)
+
+    def test_log_softmax_3d(self, xp):
+        # 3D input, with a tuple for the axis.
+        x, expect = self.data_2d(xp)
+        x = xp.reshape(x, (2, 2, 2))
+        expect = xp.reshape(expect, (2, 2, 2))
+        xp_assert_close(log_softmax(x, axis=(1, 2)), expect, rtol=1e-13)

.venv/lib/python3.12/site-packages/scipy/special/tests/test_mpmath.py

@@ -0,0 +1,2160 @@
+"""
+Test SciPy functions versus mpmath, if available.
+
+"""
+import numpy as np
+from numpy.testing import assert_, assert_allclose
+from numpy import pi
+import pytest
+import itertools
+
+from scipy._external.packaging_version import version
+
+import scipy.special as sc
+from scipy.special._testutils import (
+    MissingModule, check_version, FuncData,
+    assert_func_equal)
+from scipy.special._mptestutils import (
+    Arg, FixedArg, ComplexArg, IntArg, assert_mpmath_equal,
+    nonfunctional_tooslow, trace_args, time_limited, exception_to_nan,
+    inf_to_nan)
+from scipy.special._ufuncs import (
+    _sinpi, _cospi, _lgam1p, _lanczos_sum_expg_scaled, _log1pmx,
+    _igam_fac)
+
+try:
+    import mpmath
+except ImportError:
+    mpmath = MissingModule('mpmath')
+
+pytestmark = pytest.mark.thread_unsafe(
+    reason=("mpmath gmpy2 backend is not thread-safe, "
+            "see https://github.com/mpmath/mpmath/issues/974"))
+
+# ------------------------------------------------------------------------------
+# expi
+# ------------------------------------------------------------------------------
+
+@check_version(mpmath, '0.10')
+def test_expi_complex():
+    dataset = []
+    for r in np.logspace(-99, 2, 10):
+        for p in np.linspace(0, 2*np.pi, 30):
+            z = r*np.exp(1j*p)
+            dataset.append((z, complex(mpmath.ei(z))))
+    dataset = np.array(dataset, dtype=np.cdouble)
+
+    FuncData(sc.expi, dataset, 0, 1).check()
+
+
+# ------------------------------------------------------------------------------
+# expn
+# ------------------------------------------------------------------------------
+
+@check_version(mpmath, '0.19')
+def test_expn_large_n():
+    # Test the transition to the asymptotic regime of n.
+    dataset = []
+    for n in [50, 51]:
+        for x in np.logspace(0, 4, 200):
+            with mpmath.workdps(100):
+                dataset.append((n, x, float(mpmath.expint(n, x))))
+    dataset = np.asarray(dataset)
+
+    FuncData(sc.expn, dataset, (0, 1), 2, rtol=1e-13).check()
+
+# ------------------------------------------------------------------------------
+# hyp0f1
+# ------------------------------------------------------------------------------
+
+
+@check_version(mpmath, '0.19')
+def test_hyp0f1_gh5764():
+    # Do a small and somewhat systematic test that runs quickly
+    dataset = []
+    axis = [-99.5, -9.5, -0.5, 0.5, 9.5, 99.5]
+    for v in axis:
+        for x in axis:
+            for y in axis:
+                z = x + 1j*y
+                # mpmath computes the answer correctly at dps ~ 17 but
+                # fails for 20 < dps < 120 (uses a different method);
+                # set the dps high enough that this isn't an issue
+                with mpmath.workdps(120):
+                    res = complex(mpmath.hyp0f1(v, z))
+                dataset.append((v, z, res))
+    dataset = np.array(dataset)
+
+    FuncData(lambda v, z: sc.hyp0f1(v.real, z), dataset, (0, 1), 2,
+             rtol=1e-13).check()
+
+
+@check_version(mpmath, '0.19')
+def test_hyp0f1_gh_1609():
+    # this is a regression test for gh-1609
+    vv = np.linspace(150, 180, 21)
+    af = sc.hyp0f1(vv, 0.5)
+    mf = np.array([mpmath.hyp0f1(v, 0.5) for v in vv])
+    assert_allclose(af, mf.astype(float), rtol=1e-12)
+
+
+# ------------------------------------------------------------------------------
+# hyperu
+# ------------------------------------------------------------------------------
+
+@check_version(mpmath, '1.1.0')
+def test_hyperu_around_0():
+    dataset = []
+    # DLMF 13.2.14-15 test points.
+    for n in np.arange(-5, 5):
+        for b in np.linspace(-5, 5, 20):
+            a = -n
+            dataset.append((a, b, 0, float(mpmath.hyperu(a, b, 0))))
+            a = -n + b - 1
+            dataset.append((a, b, 0, float(mpmath.hyperu(a, b, 0))))
+    # DLMF 13.2.16-22 test points.
+    for a in [-10.5, -1.5, -0.5, 0, 0.5, 1, 10]:
+        for b in [-1.0, -0.5, 0, 0.5, 1, 1.5, 2, 2.5]:
+            dataset.append((a, b, 0, float(mpmath.hyperu(a, b, 0))))
+    dataset = np.array(dataset)
+
+    FuncData(sc.hyperu, dataset, (0, 1, 2), 3, rtol=1e-15, atol=5e-13).check()
+
+
+# ------------------------------------------------------------------------------
+# hyp2f1
+# ------------------------------------------------------------------------------
+
+@check_version(mpmath, '1.0.0')
+def test_hyp2f1_strange_points():
+    pts = [
+        (2, -1, -1, 0.7),  # expected: 2.4
+        (2, -2, -2, 0.7),  # expected: 3.87
+    ]
+    pts += list(itertools.product([2, 1, -0.7, -1000], repeat=4))
+    pts = [
+        (a, b, c, x) for a, b, c, x in pts
+        if b == c and round(b) == b and b < 0 and b != -1000
+    ]
+    kw = dict(eliminate=True)
+    dataset = [p + (float(mpmath.hyp2f1(*p, **kw)),) for p in pts]
+    dataset = np.array(dataset, dtype=np.float64)
+
+    FuncData(sc.hyp2f1, dataset, (0,1,2,3), 4, rtol=1e-10).check()
+
+
+@check_version(mpmath, '0.13')
+def test_hyp2f1_real_some_points():
+    pts = [
+        (1, 2, 3, 0),
+        (1./3, 2./3, 5./6, 27./32),
+        (1./4, 1./2, 3./4, 80./81),
+        (2,-2, -3, 3),
+        (2, -3, -2, 3),
+        (2, -1.5, -1.5, 3),
+        (1, 2, 3, 0),
+        (0.7235, -1, -5, 0.3),
+        (0.25, 1./3, 2, 0.999),
+        (0.25, 1./3, 2, -1),
+        (2, 3, 5, 0.99),
+        (3./2, -0.5, 3, 0.99),
+        (2, 2.5, -3.25, 0.999),
+        (-8, 18.016500331508873, 10.805295997850628, 0.90875647507000001),
+        (-10, 900, -10.5, 0.99),
+        (-10, 900, 10.5, 0.99),
+        (-1, 2, 1, 1.0),
+        (-1, 2, 1, -1.0),
+        (-3, 13, 5, 1.0),
+        (-3, 13, 5, -1.0),
+        (0.5, 1 - 270.5, 1.5, 0.999**2),  # from issue 1561
+    ]
+    dataset = [p + (float(mpmath.hyp2f1(*p)),) for p in pts]
+    dataset = np.array(dataset, dtype=np.float64)
+
+    with np.errstate(invalid='ignore'):
+        FuncData(sc.hyp2f1, dataset, (0,1,2,3), 4, rtol=1e-10).check()
+
+
+@check_version(mpmath, '0.14')
+def test_hyp2f1_some_points_2():
+    # Taken from mpmath unit tests -- this point failed for mpmath 0.13 but
+    # was fixed in their SVN since then
+    pts = [
+        (112, (51,10), (-9,10), -0.99999),
+        (10,-900,10.5,0.99),
+        (10,-900,-10.5,0.99),
+    ]
+
+    def fev(x):
+        if isinstance(x, tuple):
+            return float(x[0]) / x[1]
+        else:
+            return x
+
+    dataset = [tuple(map(fev, p)) + (float(mpmath.hyp2f1(*p)),) for p in pts]
+    dataset = np.array(dataset, dtype=np.float64)
+
+    FuncData(sc.hyp2f1, dataset, (0,1,2,3), 4, rtol=1e-10).check()
+
+
+@check_version(mpmath, '0.13')
+def test_hyp2f1_real_some():
+    dataset = []
+    for a in [-10, -5, -1.8, 1.8, 5, 10]:
+        for b in [-2.5, -1, 1, 7.4]:
+            for c in [-9, -1.8, 5, 20.4]:
+                for z in [-10, -1.01, -0.99, 0, 0.6, 0.95, 1.5, 10]:
+                    try:
+                        v = float(mpmath.hyp2f1(a, b, c, z))
+                    except Exception:
+                        continue
+                    dataset.append((a, b, c, z, v))
+    dataset = np.array(dataset, dtype=np.float64)
+
+    with np.errstate(invalid='ignore'):
+        FuncData(sc.hyp2f1, dataset, (0,1,2,3), 4, rtol=1e-9,
+                 ignore_inf_sign=True).check()
+
+
+@check_version(mpmath, '0.12')
+@pytest.mark.slow
+def test_hyp2f1_real_random():
+    npoints = 500
+    dataset = np.zeros((npoints, 5), np.float64)
+
+    np.random.seed(1234)
+    dataset[:, 0] = np.random.pareto(1.5, npoints)
+    dataset[:, 1] = np.random.pareto(1.5, npoints)
+    dataset[:, 2] = np.random.pareto(1.5, npoints)
+    dataset[:, 3] = 2*np.random.rand(npoints) - 1
+
+    dataset[:, 0] *= (-1)**np.random.randint(2, npoints)
+    dataset[:, 1] *= (-1)**np.random.randint(2, npoints)
+    dataset[:, 2] *= (-1)**np.random.randint(2, npoints)
+
+    for ds in dataset:
+        if mpmath.__version__ < '0.14':
+            # mpmath < 0.14 fails for c too much smaller than a, b
+            if abs(ds[:2]).max() > abs(ds[2]):
+                ds[2] = abs(ds[:2]).max()
+        ds[4] = float(mpmath.hyp2f1(*tuple(ds[:4])))
+
+    FuncData(sc.hyp2f1, dataset, (0, 1, 2, 3), 4, rtol=1e-9).check()
+
+
+# ------------------------------------------------------------------------------
+# erf (complex)
+# ------------------------------------------------------------------------------
+
+@pytest.mark.slow()
+@check_version(mpmath, '0.14')
+def test_erf_complex():
+    # need to increase mpmath precision for this test
+    old_dps, old_prec = mpmath.mp.dps, mpmath.mp.prec
+    try:
+        mpmath.mp.dps = 70
+        x1, y1 = np.meshgrid(np.linspace(-10, 1, 31), np.linspace(-10, 1, 11))
+        x2, y2 = np.meshgrid(np.logspace(-80, .8, 31), np.logspace(-80, .8, 11))
+        points = np.r_[x1.ravel(),x2.ravel()] + 1j*np.r_[y1.ravel(), y2.ravel()]
+
+        assert_func_equal(sc.erf, lambda x: complex(mpmath.erf(x)), points,
+                          vectorized=False, rtol=1e-13)
+        assert_func_equal(sc.erfc, lambda x: complex(mpmath.erfc(x)), points,
+                          vectorized=False, rtol=1e-13)
+    finally:
+        mpmath.mp.dps, mpmath.mp.prec = old_dps, old_prec
+
+
+# ------------------------------------------------------------------------------
+# lpmv
+# ------------------------------------------------------------------------------
+
+@check_version(mpmath, '0.15')
+def test_lpmv():
+    pts = []
+    for x in [-0.99, -0.557, 1e-6, 0.132, 1]:
+        pts.extend([
+            (1, 1, x),
+            (1, -1, x),
+            (-1, 1, x),
+            (-1, -2, x),
+            (1, 1.7, x),
+            (1, -1.7, x),
+            (-1, 1.7, x),
+            (-1, -2.7, x),
+            (1, 10, x),
+            (1, 11, x),
+            (3, 8, x),
+            (5, 11, x),
+            (-3, 8, x),
+            (-5, 11, x),
+            (3, -8, x),
+            (5, -11, x),
+            (-3, -8, x),
+            (-5, -11, x),
+            (3, 8.3, x),
+            (5, 11.3, x),
+            (-3, 8.3, x),
+            (-5, 11.3, x),
+            (3, -8.3, x),
+            (5, -11.3, x),
+            (-3, -8.3, x),
+            (-5, -11.3, x),
+        ])
+
+    def mplegenp(nu, mu, x):
+        if mu == int(mu) and x == 1:
+            # mpmath 0.17 gets this wrong
+            if mu == 0:
+                return 1
+            else:
+                return 0
+        return mpmath.legenp(nu, mu, x)
+
+    dataset = [p + (mplegenp(p[1], p[0], p[2]),) for p in pts]
+    dataset = np.array(dataset, dtype=np.float64)
+
+    def evf(mu, nu, x):
+        return sc.lpmv(mu.astype(int), nu, x)
+
+    with np.errstate(invalid='ignore'):
+        FuncData(evf, dataset, (0,1,2), 3, rtol=1e-10, atol=1e-14).check()
+
+
+# ------------------------------------------------------------------------------
+# beta
+# ------------------------------------------------------------------------------
+
+@pytest.mark.slow
+@check_version(mpmath, '0.15')
+def test_beta():
+    np.random.seed(1234)
+
+    b = np.r_[np.logspace(-200, 200, 4),
+              np.logspace(-10, 10, 4),
+              np.logspace(-1, 1, 4),
+              np.arange(-10, 11, 1),
+              np.arange(-10, 11, 1) + 0.5,
+              -1, -2.3, -3, -100.3, -10003.4]
+    a = b
+
+    ab = np.array(np.broadcast_arrays(a[:,None], b[None,:])).reshape(2, -1).T
+
+    old_dps, old_prec = mpmath.mp.dps, mpmath.mp.prec
+    try:
+        mpmath.mp.dps = 400
+
+        assert_func_equal(sc.beta,
+                          lambda a, b: float(mpmath.beta(a, b)),
+                          ab,
+                          vectorized=False,
+                          rtol=1e-10,
+                          ignore_inf_sign=True)
+
+        assert_func_equal(
+            sc.betaln,
+            lambda a, b: float(mpmath.log(abs(mpmath.beta(a, b)))),
+            ab,
+            vectorized=False,
+            rtol=1e-10)
+    finally:
+        mpmath.mp.dps, mpmath.mp.prec = old_dps, old_prec
+
+
+# ------------------------------------------------------------------------------
+# loggamma
+# ------------------------------------------------------------------------------
+
+LOGGAMMA_TAYLOR_RADIUS = 0.2
+
+
+@check_version(mpmath, '0.19')
+def test_loggamma_taylor_transition():
+    # Make sure there isn't a big jump in accuracy when we move from
+    # using the Taylor series to using the recurrence relation.
+
+    r = LOGGAMMA_TAYLOR_RADIUS + np.array([-0.1, -0.01, 0, 0.01, 0.1])
+    theta = np.linspace(0, 2*np.pi, 20)
+    r, theta = np.meshgrid(r, theta)
+    dz = r*np.exp(1j*theta)
+    z = np.r_[1 + dz, 2 + dz].flatten()
+
+    dataset = [(z0, complex(mpmath.loggamma(z0))) for z0 in z]
+    dataset = np.array(dataset)
+
+    FuncData(sc.loggamma, dataset, 0, 1, rtol=5e-14).check()
+
+
+@check_version(mpmath, '0.19')
+def test_loggamma_taylor():
+    # Test around the zeros at z = 1, 2.
+
+    r = np.logspace(-16, np.log10(LOGGAMMA_TAYLOR_RADIUS), 10)
+    theta = np.linspace(0, 2*np.pi, 20)
+    r, theta = np.meshgrid(r, theta)
+    dz = r*np.exp(1j*theta)
+    z = np.r_[1 + dz, 2 + dz].flatten()
+
+    dataset = [(z0, complex(mpmath.loggamma(z0))) for z0 in z]
+    dataset = np.array(dataset)
+
+    FuncData(sc.loggamma, dataset, 0, 1, rtol=5e-14).check()
+
+
+# ------------------------------------------------------------------------------
+# rgamma
+# ------------------------------------------------------------------------------
+
+@check_version(mpmath, '0.19')
+@pytest.mark.slow
+def test_rgamma_zeros():
+    # Test around the zeros at z = 0, -1, -2, ...,  -169. (After -169 we
+    # get values that are out of floating point range even when we're
+    # within 0.1 of the zero.)
+
+    # Can't use too many points here or the test takes forever.
+    dx = np.r_[-np.logspace(-1, -13, 3), 0, np.logspace(-13, -1, 3)]
+    dy = dx.copy()
+    dx, dy = np.meshgrid(dx, dy)
+    dz = dx + 1j*dy
+    zeros = np.arange(0, -170, -1).reshape(1, 1, -1)
+    z = (zeros + np.dstack((dz,)*zeros.size)).flatten()
+    with mpmath.workdps(100):
+        dataset = [(z0, complex(mpmath.rgamma(z0))) for z0 in z]
+
+    dataset = np.array(dataset)
+    FuncData(sc.rgamma, dataset, 0, 1, rtol=1e-12).check()
+
+
+# ------------------------------------------------------------------------------
+# digamma
+# ------------------------------------------------------------------------------
+
+@check_version(mpmath, '0.19')
+@pytest.mark.slow
+def test_digamma_roots():
+    # Test the special-cased roots for digamma.
+    root = mpmath.findroot(mpmath.digamma, 1.5)
+    roots = [float(root)]
+    root = mpmath.findroot(mpmath.digamma, -0.5)
+    roots.append(float(root))
+    roots = np.array(roots)
+
+    # If we test beyond a radius of 0.24 mpmath will take forever.
+    dx = np.r_[-0.24, -np.logspace(-1, -15, 10), 0, np.logspace(-15, -1, 10), 0.24]
+    dy = dx.copy()
+    dx, dy = np.meshgrid(dx, dy)
+    dz = dx + 1j*dy
+    z = (roots + np.dstack((dz,)*roots.size)).flatten()
+    with mpmath.workdps(30):
+        dataset = [(z0, complex(mpmath.digamma(z0))) for z0 in z]
+
+    dataset = np.array(dataset)
+    FuncData(sc.digamma, dataset, 0, 1, rtol=1e-14).check()
+
+
+@check_version(mpmath, '0.19')
+def test_digamma_negreal():
+    # Test digamma around the negative real axis. Don't do this in
+    # TestSystematic because the points need some jiggering so that
+    # mpmath doesn't take forever.
+
+    digamma = exception_to_nan(mpmath.digamma)
+
+    x = -np.logspace(300, -30, 100)
+    y = np.r_[-np.logspace(0, -3, 5), 0, np.logspace(-3, 0, 5)]
+    x, y = np.meshgrid(x, y)
+    z = (x + 1j*y).flatten()
+
+    with mpmath.workdps(40):
+        dataset = [(z0, complex(digamma(z0))) for z0 in z]
+    dataset = np.asarray(dataset)
+
+    FuncData(sc.digamma, dataset, 0, 1, rtol=1e-13).check()
+
+
+@check_version(mpmath, '0.19')
+def test_digamma_boundary():
+    # Check that there isn't a jump in accuracy when we switch from
+    # using the asymptotic series to the reflection formula.
+
+    x = -np.logspace(300, -30, 100)
+    y = np.array([-6.1, -5.9, 5.9, 6.1])
+    x, y = np.meshgrid(x, y)
+    z = (x + 1j*y).flatten()
+
+    with mpmath.workdps(30):
+        dataset = [(z0, complex(mpmath.digamma(z0))) for z0 in z]
+    dataset = np.asarray(dataset)
+
+    FuncData(sc.digamma, dataset, 0, 1, rtol=1e-13).check()
+
+
+# ------------------------------------------------------------------------------
+# gammainc
+# ------------------------------------------------------------------------------
+
+@check_version(mpmath, '0.19')
+@pytest.mark.slow
+def test_gammainc_boundary():
+    # Test the transition to the asymptotic series.
+    small = 20
+    a = np.linspace(0.5*small, 2*small, 50)
+    x = a.copy()
+    a, x = np.meshgrid(a, x)
+    a, x = a.flatten(), x.flatten()
+    with mpmath.workdps(100):
+        dataset = [(a0, x0, float(mpmath.gammainc(a0, b=x0, regularized=True)))
+                   for a0, x0 in zip(a, x)]
+    dataset = np.array(dataset)
+
+    FuncData(sc.gammainc, dataset, (0, 1), 2, rtol=1e-12).check()
+
+
+# ------------------------------------------------------------------------------
+# spence
+# ------------------------------------------------------------------------------
+
+@check_version(mpmath, '0.19')
+@pytest.mark.slow
+def test_spence_circle():
+    # The trickiest region for spence is around the circle |z - 1| = 1,
+    # so test that region carefully.
+
+    def spence(z):
+        return complex(mpmath.polylog(2, 1 - z))
+
+    r = np.linspace(0.5, 1.5)
+    theta = np.linspace(0, 2*pi)
+    z = (1 + np.outer(r, np.exp(1j*theta))).flatten()
+    dataset = np.asarray([(z0, spence(z0)) for z0 in z])
+
+    FuncData(sc.spence, dataset, 0, 1, rtol=1e-14).check()
+
+
+# ------------------------------------------------------------------------------
+# sinpi and cospi
+# ------------------------------------------------------------------------------
+
+@check_version(mpmath, '0.19')
+def test_sinpi_zeros():
+    eps = np.finfo(float).eps
+    dx = np.r_[-np.logspace(0, -13, 3), 0, np.logspace(-13, 0, 3)]
+    dy = dx.copy()
+    dx, dy = np.meshgrid(dx, dy)
+    dz = dx + 1j*dy
+    zeros = np.arange(-100, 100, 1).reshape(1, 1, -1)
+    z = (zeros + np.dstack((dz,)*zeros.size)).flatten()
+    dataset = np.asarray([(z0, complex(mpmath.sinpi(z0)))
+                          for z0 in z])
+    FuncData(_sinpi, dataset, 0, 1, rtol=2*eps).check()
+
+
+@check_version(mpmath, '0.19')
+def test_cospi_zeros():
+    eps = np.finfo(float).eps
+    dx = np.r_[-np.logspace(0, -13, 3), 0, np.logspace(-13, 0, 3)]
+    dy = dx.copy()
+    dx, dy = np.meshgrid(dx, dy)
+    dz = dx + 1j*dy
+    zeros = (np.arange(-100, 100, 1) + 0.5).reshape(1, 1, -1)
+    z = (zeros + np.dstack((dz,)*zeros.size)).flatten()
+    dataset = np.asarray([(z0, complex(mpmath.cospi(z0)))
+                          for z0 in z])
+
+    FuncData(_cospi, dataset, 0, 1, rtol=2*eps).check()
+
+
+# ------------------------------------------------------------------------------
+# ellipj
+# ------------------------------------------------------------------------------
+
+@check_version(mpmath, '0.19')
+def test_dn_quarter_period():
+    def dn(u, m):
+        return sc.ellipj(u, m)[2]
+
+    def mpmath_dn(u, m):
+        return float(mpmath.ellipfun("dn", u=u, m=m))
+
+    m = np.linspace(0, 1, 20)
+    du = np.r_[-np.logspace(-1, -15, 10), 0, np.logspace(-15, -1, 10)]
+    dataset = []
+    for m0 in m:
+        u0 = float(mpmath.ellipk(m0))
+        for du0 in du:
+            p = u0 + du0
+            dataset.append((p, m0, mpmath_dn(p, m0)))
+    dataset = np.asarray(dataset)
+
+    FuncData(dn, dataset, (0, 1), 2, rtol=1e-10).check()
+
+
+# ------------------------------------------------------------------------------
+# Wright Omega
+# ------------------------------------------------------------------------------
+
+def _mpmath_wrightomega(z, dps):
+    with mpmath.workdps(dps):
+        z = mpmath.mpc(z)
+        unwind = mpmath.ceil((z.imag - mpmath.pi)/(2*mpmath.pi))
+        res = mpmath.lambertw(mpmath.exp(z), unwind)
+    return res
+
+
+@pytest.mark.slow
+@check_version(mpmath, '0.19')
+def test_wrightomega_branch():
+    x = -np.logspace(10, 0, 25)
+    picut_above = [np.nextafter(np.pi, np.inf)]
+    picut_below = [np.nextafter(np.pi, -np.inf)]
+    npicut_above = [np.nextafter(-np.pi, np.inf)]
+    npicut_below = [np.nextafter(-np.pi, -np.inf)]
+    for i in range(50):
+        picut_above.append(np.nextafter(picut_above[-1], np.inf))
+        picut_below.append(np.nextafter(picut_below[-1], -np.inf))
+        npicut_above.append(np.nextafter(npicut_above[-1], np.inf))
+        npicut_below.append(np.nextafter(npicut_below[-1], -np.inf))
+    y = np.hstack((picut_above, picut_below, npicut_above, npicut_below))
+    x, y = np.meshgrid(x, y)
+    z = (x + 1j*y).flatten()
+
+    dataset = np.asarray([(z0, complex(_mpmath_wrightomega(z0, 25)))
+                          for z0 in z])
+
+    FuncData(sc.wrightomega, dataset, 0, 1, rtol=1e-8).check()
+
+
+@pytest.mark.slow
+@check_version(mpmath, '0.19')
+def test_wrightomega_region1():
+    # This region gets less coverage in the TestSystematic test
+    x = np.linspace(-2, 1)
+    y = np.linspace(1, 2*np.pi)
+    x, y = np.meshgrid(x, y)
+    z = (x + 1j*y).flatten()
+
+    dataset = np.asarray([(z0, complex(_mpmath_wrightomega(z0, 25)))
+                          for z0 in z])
+
+    FuncData(sc.wrightomega, dataset, 0, 1, rtol=1e-15).check()
+
+
+@pytest.mark.slow
+@check_version(mpmath, '0.19')
+def test_wrightomega_region2():
+    # This region gets less coverage in the TestSystematic test
+    x = np.linspace(-2, 1)
+    y = np.linspace(-2*np.pi, -1)
+    x, y = np.meshgrid(x, y)
+    z = (x + 1j*y).flatten()
+
+    dataset = np.asarray([(z0, complex(_mpmath_wrightomega(z0, 25)))
+                          for z0 in z])
+
+    FuncData(sc.wrightomega, dataset, 0, 1, rtol=1e-15).check()
+
+
+# ------------------------------------------------------------------------------
+# lambertw
+# ------------------------------------------------------------------------------
+
+@pytest.mark.slow
+@check_version(mpmath, '0.19')
+def test_lambertw_smallz():
+    x, y = np.linspace(-1, 1, 25), np.linspace(-1, 1, 25)
+    x, y = np.meshgrid(x, y)
+    z = (x + 1j*y).flatten()
+
+    dataset = np.asarray([(z0, complex(mpmath.lambertw(z0)))
+                          for z0 in z])
+
+    FuncData(sc.lambertw, dataset, 0, 1, rtol=1e-13).check()
+
+
+# ------------------------------------------------------------------------------
+# Systematic tests
+# ------------------------------------------------------------------------------
+
+HYPERKW = dict(maxprec=200, maxterms=200)
+
+
+@pytest.mark.slow
+@check_version(mpmath, '0.17')
+class TestSystematic:
+
+    def test_airyai(self):
+        # oscillating function, limit range
+        assert_mpmath_equal(lambda z: sc.airy(z)[0],
+                            mpmath.airyai,
+                            [Arg(-1e8, 1e8)],
+                            rtol=1e-5)
+        assert_mpmath_equal(lambda z: sc.airy(z)[0],
+                            mpmath.airyai,
+                            [Arg(-1e3, 1e3)])
+
+    def test_airyai_complex(self):
+        assert_mpmath_equal(lambda z: sc.airy(z)[0],
+                            mpmath.airyai,
+                            [ComplexArg()])
+
+    def test_airyai_prime(self):
+        # oscillating function, limit range
+        assert_mpmath_equal(lambda z: sc.airy(z)[1], lambda z:
+                            mpmath.airyai(z, derivative=1),
+                            [Arg(-1e8, 1e8)],
+                            rtol=1e-5)
+        assert_mpmath_equal(lambda z: sc.airy(z)[1], lambda z:
+                            mpmath.airyai(z, derivative=1),
+                            [Arg(-1e3, 1e3)])
+
+    def test_airyai_prime_complex(self):
+        assert_mpmath_equal(lambda z: sc.airy(z)[1], lambda z:
+                            mpmath.airyai(z, derivative=1),
+                            [ComplexArg()])
+
+    def test_airybi(self):
+        # oscillating function, limit range
+        assert_mpmath_equal(lambda z: sc.airy(z)[2], lambda z:
+                            mpmath.airybi(z),
+                            [Arg(-1e8, 1e8)],
+                            rtol=1e-5)
+        assert_mpmath_equal(lambda z: sc.airy(z)[2], lambda z:
+                            mpmath.airybi(z),
+                            [Arg(-1e3, 1e3)])
+
+    def test_airybi_complex(self):
+        assert_mpmath_equal(lambda z: sc.airy(z)[2], lambda z:
+                            mpmath.airybi(z),
+                            [ComplexArg()])
+
+    def test_airybi_prime(self):
+        # oscillating function, limit range
+        assert_mpmath_equal(lambda z: sc.airy(z)[3], lambda z:
+                            mpmath.airybi(z, derivative=1),
+                            [Arg(-1e8, 1e8)],
+                            rtol=1e-5)
+        assert_mpmath_equal(lambda z: sc.airy(z)[3], lambda z:
+                            mpmath.airybi(z, derivative=1),
+                            [Arg(-1e3, 1e3)])
+
+    def test_airybi_prime_complex(self):
+        assert_mpmath_equal(lambda z: sc.airy(z)[3], lambda z:
+                            mpmath.airybi(z, derivative=1),
+                            [ComplexArg()])
+
+    def test_bei(self):
+        assert_mpmath_equal(sc.bei,
+                            exception_to_nan(lambda z: mpmath.bei(0, z, **HYPERKW)),
+                            [Arg(-1e3, 1e3)])
+
+    def test_ber(self):
+        assert_mpmath_equal(sc.ber,
+                            exception_to_nan(lambda z: mpmath.ber(0, z, **HYPERKW)),
+                            [Arg(-1e3, 1e3)])
+
+    def test_bernoulli(self):
+        assert_mpmath_equal(lambda n: sc.bernoulli(int(n))[int(n)],
+                            lambda n: float(mpmath.bernoulli(int(n))),
+                            [IntArg(0, 13000)],
+                            rtol=1e-9, n=13000)
+
+    def test_besseli(self):
+        assert_mpmath_equal(
+            sc.iv,
+            exception_to_nan(lambda v, z: mpmath.besseli(v, z, **HYPERKW)),
+            [Arg(-1e100, 1e100), Arg()],
+            atol=1e-270,
+        )
+
+    def test_besseli_complex(self):
+        assert_mpmath_equal(
+            lambda v, z: sc.iv(v.real, z),
+            exception_to_nan(lambda v, z: mpmath.besseli(v, z, **HYPERKW)),
+            [Arg(-1e100, 1e100), ComplexArg()],
+        )
+
+    def test_besselj(self):
+        assert_mpmath_equal(
+            sc.jv,
+            exception_to_nan(lambda v, z: mpmath.besselj(v, z, **HYPERKW)),
+            [Arg(-1e100, 1e100), Arg(-1e3, 1e3)],
+            ignore_inf_sign=True,
+        )
+
+        # loss of precision at large arguments due to oscillation
+        assert_mpmath_equal(
+            sc.jv,
+            exception_to_nan(lambda v, z: mpmath.besselj(v, z, **HYPERKW)),
+            [Arg(-1e100, 1e100), Arg(-1e8, 1e8)],
+            ignore_inf_sign=True,
+            rtol=1e-5,
+        )
+
+    def test_besselj_complex(self):
+        assert_mpmath_equal(
+            lambda v, z: sc.jv(v.real, z),
+            exception_to_nan(lambda v, z: mpmath.besselj(v, z, **HYPERKW)),
+            [Arg(), ComplexArg()]
+        )
+
+    def test_besselk(self):
+        assert_mpmath_equal(
+            sc.kv,
+            mpmath.besselk,
+            [Arg(-200, 200), Arg(0, np.inf)],
+            nan_ok=False,
+            rtol=1e-12,
+        )
+
+    def test_besselk_int(self):
+        assert_mpmath_equal(
+            sc.kn,
+            mpmath.besselk,
+            [IntArg(-200, 200), Arg(0, np.inf)],
+            nan_ok=False,
+            rtol=1e-12,
+        )
+
+    def test_besselk_complex(self):
+        assert_mpmath_equal(
+            lambda v, z: sc.kv(v.real, z),
+            exception_to_nan(lambda v, z: mpmath.besselk(v, z, **HYPERKW)),
+            [Arg(-1e100, 1e100), ComplexArg()],
+        )
+
+    def test_bessely(self):
+        def mpbessely(v, x):
+            r = float(mpmath.bessely(v, x, **HYPERKW))
+            if abs(r) > 1e305:
+                # overflowing to inf a bit earlier is OK
+                r = np.inf * np.sign(r)
+            if abs(r) == 0 and x == 0:
+                # invalid result from mpmath, point x=0 is a divergence
+                return np.nan
+            return r
+        assert_mpmath_equal(
+            sc.yv,
+            exception_to_nan(mpbessely),
+            [Arg(-1e100, 1e100), Arg(-1e8, 1e8)],
+            n=5000,
+        )
+
+    def test_bessely_complex(self):
+        def mpbessely(v, x):
+            r = complex(mpmath.bessely(v, x, **HYPERKW))
+            if abs(r) > 1e305:
+                # overflowing to inf a bit earlier is OK
+                with np.errstate(invalid='ignore'):
+                    r = np.inf * np.sign(r)
+            return r
+        assert_mpmath_equal(
+            lambda v, z: sc.yv(v.real, z),
+            exception_to_nan(mpbessely),
+            [Arg(), ComplexArg()],
+            n=15000,
+        )
+
+    def test_bessely_int(self):
+        def mpbessely(v, x):
+            r = float(mpmath.bessely(v, x))
+            if abs(r) == 0 and x == 0:
+                # invalid result from mpmath, point x=0 is a divergence
+                return np.nan
+            return r
+        assert_mpmath_equal(
+            lambda v, z: sc.yn(int(v), z),
+            exception_to_nan(mpbessely),
+            [IntArg(-1000, 1000), Arg(-1e8, 1e8)],
+        )
+
+    def test_beta(self):
+        bad_points = []
+
+        def beta(a, b, nonzero=False):
+            if a < -1e12 or b < -1e12:
+                # Function is defined here only at integers, but due
+                # to loss of precision this is numerically
+                # ill-defined. Don't compare values here.
+                return np.nan
+            if (a < 0 or b < 0) and (abs(float(a + b)) % 1) == 0:
+                # close to a zero of the function: mpmath and scipy
+                # will not round here the same, so the test needs to be
+                # run with an absolute tolerance
+                if nonzero:
+                    bad_points.append((float(a), float(b)))
+                    return np.nan
+            return mpmath.beta(a, b)
+
+        assert_mpmath_equal(
+            sc.beta,
+            lambda a, b: beta(a, b, nonzero=True),
+            [Arg(), Arg()],
+            dps=400,
+            ignore_inf_sign=True,
+        )
+
+        assert_mpmath_equal(
+            sc.beta,
+            beta,
+            np.array(bad_points),
+            dps=400,
+            ignore_inf_sign=True,
+            atol=1e-11,
+        )
+
+    def test_betainc(self):
+        assert_mpmath_equal(
+            sc.betainc,
+            time_limited()(
+                exception_to_nan(
+                    lambda a, b, x: mpmath.betainc(a, b, 0, x, regularized=True)
+                )
+            ),
+            [Arg(), Arg(), Arg()],
+        )
+
+    def test_betaincc(self):
+        assert_mpmath_equal(
+            sc.betaincc,
+            time_limited()(
+                exception_to_nan(
+                    lambda a, b, x: mpmath.betainc(a, b, x, 1, regularized=True)
+                )
+            ),
+            [Arg(), Arg(), Arg()],
+            dps=400,
+        )
+
+    def test_binom(self):
+        bad_points = []
+
+        def binomial(n, k, nonzero=False):
+            if abs(k) > 1e8*(abs(n) + 1):
+                # The binomial is rapidly oscillating in this region,
+                # and the function is numerically ill-defined. Don't
+                # compare values here.
+                return np.nan
+            if n < k and abs(float(n-k) - np.round(float(n-k))) < 1e-15:
+                # close to a zero of the function: mpmath and scipy
+                # will not round here the same, so the test needs to be
+                # run with an absolute tolerance
+                if nonzero:
+                    bad_points.append((float(n), float(k)))
+                    return np.nan
+            return mpmath.binomial(n, k)
+
+        assert_mpmath_equal(
+            sc.binom,
+            lambda n, k: binomial(n, k, nonzero=True),
+            [Arg(), Arg()],
+            dps=400,
+        )
+
+        assert_mpmath_equal(
+            sc.binom,
+            binomial,
+            np.array(bad_points),
+            dps=400,
+            atol=1e-14,
+        )
+
+    def test_chebyt_int(self):
+        assert_mpmath_equal(
+            lambda n, x: sc.eval_chebyt(int(n), x),
+            exception_to_nan(lambda n, x: mpmath.chebyt(n, x, **HYPERKW)),
+            [IntArg(), Arg()],
+            dps=50,
+        )
+
+    @pytest.mark.xfail(run=False, reason="some cases in hyp2f1 not fully accurate")
+    def test_chebyt(self):
+        assert_mpmath_equal(
+            sc.eval_chebyt,
+            lambda n, x: time_limited()(
+                exception_to_nan(mpmath.chebyt)
+            )(n, x, **HYPERKW),
+            [Arg(-101, 101), Arg()],
+            n=10000,
+        )
+
+    def test_chebyu_int(self):
+        assert_mpmath_equal(
+            lambda n, x: sc.eval_chebyu(int(n), x),
+            exception_to_nan(lambda n, x: mpmath.chebyu(n, x, **HYPERKW)),
+            [IntArg(), Arg()],
+            dps=50,
+        )
+
+    @pytest.mark.xfail(run=False, reason="some cases in hyp2f1 not fully accurate")
+    def test_chebyu(self):
+        assert_mpmath_equal(
+            sc.eval_chebyu,
+            lambda n, x: time_limited()(
+                exception_to_nan(mpmath.chebyu)
+            )(n, x, **HYPERKW),
+            [Arg(-101, 101), Arg()],
+        )
+
+    def test_chi(self):
+        def chi(x):
+            return sc.shichi(x)[1]
+        assert_mpmath_equal(chi, mpmath.chi, [Arg()])
+        # check asymptotic series cross-over
+        assert_mpmath_equal(chi, mpmath.chi, [FixedArg([88 - 1e-9, 88, 88 + 1e-9])])
+
+    def test_chi_complex(self):
+        def chi(z):
+            return sc.shichi(z)[1]
+        # chi oscillates as Im[z] -> +- inf, so limit range
+        assert_mpmath_equal(
+            chi,
+            mpmath.chi,
+            [ComplexArg(complex(-np.inf, -1e8), complex(np.inf, 1e8))],
+            rtol=1e-12,
+        )
+
+    def test_ci(self):
+        def ci(x):
+            return sc.sici(x)[1]
+        # oscillating function: limit range
+        assert_mpmath_equal(ci, mpmath.ci, [Arg(-1e8, 1e8)])
+
+    def test_ci_complex(self):
+        def ci(z):
+            return sc.sici(z)[1]
+        # ci oscillates as Re[z] -> +- inf, so limit range
+        assert_mpmath_equal(
+            ci,
+            mpmath.ci,
+            [ComplexArg(complex(-1e8, -np.inf), complex(1e8, np.inf))],
+            rtol=1e-8,
+        )
+
+    def test_cospi(self):
+        eps = np.finfo(float).eps
+        assert_mpmath_equal(_cospi, mpmath.cospi, [Arg()], nan_ok=False, rtol=2*eps)
+
+    def test_cospi_complex(self):
+        assert_mpmath_equal(
+            _cospi,
+            mpmath.cospi,
+            [ComplexArg()],
+            nan_ok=False,
+            rtol=1e-13,
+        )
+
+    def test_digamma(self):
+        assert_mpmath_equal(
+            sc.digamma,
+            exception_to_nan(mpmath.digamma),
+            [Arg()],
+            rtol=1e-12,
+            dps=50,
+        )
+
+    def test_digamma_complex(self):
+        # Test on a cut plane because mpmath will hang. See
+        # test_digamma_negreal for tests on the negative real axis.
+        def param_filter(z):
+            return np.where((z.real < 0) & (np.abs(z.imag) < 1.12), False, True)
+
+        assert_mpmath_equal(
+            sc.digamma,
+            exception_to_nan(mpmath.digamma),
+            [ComplexArg()],
+            rtol=1e-13,
+            dps=40,
+            param_filter=param_filter
+        )
+
+    def test_e1(self):
+        assert_mpmath_equal(
+            sc.exp1,
+            mpmath.e1,
+            [Arg()],
+            rtol=1e-14,
+        )
+
+    def test_e1_complex(self):
+        # E_1 oscillates as Im[z] -> +- inf, so limit range
+        assert_mpmath_equal(
+            sc.exp1,
+            mpmath.e1,
+            [ComplexArg(complex(-np.inf, -1e8), complex(np.inf, 1e8))],
+            rtol=1e-11,
+        )
+
+        # Check cross-over region
+        assert_mpmath_equal(
+            sc.exp1,
+            mpmath.e1,
+            (np.linspace(-50, 50, 171)[:, None]
+             + np.r_[0, np.logspace(-3, 2, 61), -np.logspace(-3, 2, 11)]*1j).ravel(),
+            rtol=1e-11,
+        )
+        assert_mpmath_equal(
+            sc.exp1,
+            mpmath.e1,
+            (np.linspace(-50, -35, 10000) + 0j),
+            rtol=1e-11,
+        )
+
+    def test_exprel(self):
+        assert_mpmath_equal(
+            sc.exprel,
+            lambda x: mpmath.expm1(x)/x if x != 0 else mpmath.mpf('1.0'),
+            [Arg(a=-np.log(np.finfo(np.float64).max),
+                 b=np.log(np.finfo(np.float64).max))],
+        )
+        assert_mpmath_equal(
+            sc.exprel,
+            lambda x: mpmath.expm1(x)/x if x != 0 else mpmath.mpf('1.0'),
+            np.array([1e-12, 1e-24, 0, 1e12, 1e24, np.inf]),
+            rtol=1e-11,
+        )
+        assert_(np.isinf(sc.exprel(np.inf)))
+        assert_(sc.exprel(-np.inf) == 0)
+
+    def test_expm1_complex(self):
+        # Oscillates as a function of Im[z], so limit range to avoid loss of precision
+        assert_mpmath_equal(
+            sc.expm1,
+            mpmath.expm1,
+            [ComplexArg(complex(-np.inf, -1e7), complex(np.inf, 1e7))],
+        )
+
+    def test_log1p_complex(self):
+        assert_mpmath_equal(
+            sc.log1p,
+            lambda x: mpmath.log(x+1),
+            [ComplexArg()],
+            dps=60,
+        )
+
+    def test_log1pmx(self):
+        assert_mpmath_equal(
+            _log1pmx,
+            lambda x: mpmath.log(x + 1) - x,
+            [Arg()],
+            dps=60,
+            rtol=1e-14,
+        )
+
+    def test_ei(self):
+        assert_mpmath_equal(sc.expi, mpmath.ei, [Arg()], rtol=1e-11)
+
+    def test_ei_complex(self):
+        # Ei oscillates as Im[z] -> +- inf, so limit range
+        assert_mpmath_equal(
+            sc.expi,
+            mpmath.ei,
+            [ComplexArg(complex(-np.inf, -1e8), complex(np.inf, 1e8))],
+            rtol=1e-9,
+        )
+
+    def test_ellipe(self):
+        assert_mpmath_equal(sc.ellipe, mpmath.ellipe, [Arg(b=1.0)])
+
+    def test_ellipeinc(self):
+        assert_mpmath_equal(sc.ellipeinc, mpmath.ellipe, [Arg(-1e3, 1e3), Arg(b=1.0)])
+
+    def test_ellipeinc_largephi(self):
+        assert_mpmath_equal(sc.ellipeinc, mpmath.ellipe, [Arg(), Arg()])
+
+    def test_ellipf(self):
+        assert_mpmath_equal(sc.ellipkinc, mpmath.ellipf, [Arg(-1e3, 1e3), Arg()])
+
+    def test_ellipf_largephi(self):
+        assert_mpmath_equal(sc.ellipkinc, mpmath.ellipf, [Arg(), Arg()])
+
+    def test_ellipk(self):
+        assert_mpmath_equal(sc.ellipk, mpmath.ellipk, [Arg(b=1.0)])
+        assert_mpmath_equal(
+            sc.ellipkm1,
+            lambda m: mpmath.ellipk(1 - m),
+            [Arg(a=0.0)],
+            dps=400,
+        )
+
+    def test_ellipkinc(self):
+        def ellipkinc(phi, m):
+            return mpmath.ellippi(0, phi, m)
+        assert_mpmath_equal(
+            sc.ellipkinc,
+            ellipkinc,
+            [Arg(-1e3, 1e3), Arg(b=1.0)],
+            ignore_inf_sign=True,
+        )
+
+    def test_ellipkinc_largephi(self):
+        def ellipkinc(phi, m):
+            return mpmath.ellippi(0, phi, m)
+        assert_mpmath_equal(
+            sc.ellipkinc,
+            ellipkinc,
+            [Arg(), Arg(b=1.0)],
+            ignore_inf_sign=True,
+        )
+
+    def test_ellipfun_sn(self):
+        def sn(u, m):
+            # mpmath doesn't get the zero at u = 0--fix that
+            if u == 0:
+                return 0
+            else:
+                return mpmath.ellipfun("sn", u=u, m=m)
+
+        # Oscillating function --- limit range of first argument; the
+        # loss of precision there is an expected numerical feature
+        # rather than an actual bug
+        assert_mpmath_equal(
+            lambda u, m: sc.ellipj(u, m)[0],
+            sn,
+            [Arg(-1e6, 1e6), Arg(a=0, b=1)],
+            rtol=1e-8,
+        )
+
+    def test_ellipfun_cn(self):
+        # see comment in ellipfun_sn
+        assert_mpmath_equal(
+            lambda u, m: sc.ellipj(u, m)[1],
+            lambda u, m: mpmath.ellipfun("cn", u=u, m=m),
+            [Arg(-1e6, 1e6), Arg(a=0, b=1)],
+            rtol=1e-8,
+        )
+
+    def test_ellipfun_dn(self):
+        # see comment in ellipfun_sn
+        assert_mpmath_equal(
+            lambda u, m: sc.ellipj(u, m)[2],
+            lambda u, m: mpmath.ellipfun("dn", u=u, m=m),
+            [Arg(-1e6, 1e6), Arg(a=0, b=1)],
+            rtol=1e-8,
+        )
+
+    def test_erf(self):
+        assert_mpmath_equal(sc.erf, lambda z: mpmath.erf(z), [Arg()])
+
+    def test_erf_complex(self):
+        assert_mpmath_equal(sc.erf, lambda z: mpmath.erf(z), [ComplexArg()], n=200)
+
+    def test_erfc(self):
+        assert_mpmath_equal(
+            sc.erfc,
+            exception_to_nan(lambda z: mpmath.erfc(z)),
+            [Arg()],
+            rtol=1e-13,
+        )
+
+    def test_erfc_complex(self):
+        assert_mpmath_equal(
+            sc.erfc,
+            exception_to_nan(lambda z: mpmath.erfc(z)),
+            [ComplexArg()],
+            n=200,
+        )
+
+    def test_erfi(self):
+        assert_mpmath_equal(sc.erfi, mpmath.erfi, [Arg()], n=200)
+
+    def test_erfi_complex(self):
+        assert_mpmath_equal(sc.erfi, mpmath.erfi, [ComplexArg()], n=200)
+
+    def test_ndtr(self):
+        assert_mpmath_equal(
+            sc.ndtr,
+            exception_to_nan(lambda z: mpmath.ncdf(z)),
+            [Arg()],
+            n=200,
+        )
+
+    def test_ndtr_complex(self):
+        assert_mpmath_equal(
+            sc.ndtr,
+            lambda z: mpmath.erfc(-z/np.sqrt(2.))/2.,
+            [ComplexArg(a=complex(-10000, -10000), b=complex(10000, 10000))],
+            n=400,
+        )
+
+    def test_log_ndtr(self):
+        assert_mpmath_equal(
+            sc.log_ndtr,
+            exception_to_nan(lambda z: mpmath.log(mpmath.ncdf(z))),
+            [Arg()], n=600, dps=300, rtol=1e-13,
+        )
+
+    def test_log_ndtr_complex(self):
+        assert_mpmath_equal(
+            sc.log_ndtr,
+            exception_to_nan(lambda z: mpmath.log(mpmath.erfc(-z/np.sqrt(2.))/2.)),
+            [ComplexArg(a=complex(-10000, -100), b=complex(10000, 100))],
+            n=200, dps=300,
+        )
+
+    def test_eulernum(self):
+        assert_mpmath_equal(
+            lambda n: sc.euler(n)[-1],
+            mpmath.eulernum,
+            [IntArg(1, 10000)],
+            n=10000,
+        )
+
+    def test_expint(self):
+        assert_mpmath_equal(
+            sc.expn,
+            mpmath.expint,
+            [IntArg(0, 200), Arg(0, np.inf)],
+            rtol=1e-13,
+            dps=160,
+        )
+
+    def test_fresnels(self):
+        def fresnels(x):
+            return sc.fresnel(x)[0]
+        assert_mpmath_equal(fresnels, mpmath.fresnels, [Arg()])
+
+    def test_fresnelc(self):
+        def fresnelc(x):
+            return sc.fresnel(x)[1]
+        assert_mpmath_equal(fresnelc, mpmath.fresnelc, [Arg()])
+
+    def test_gamma(self):
+        assert_mpmath_equal(sc.gamma, exception_to_nan(mpmath.gamma), [Arg()])
+
+    def test_gamma_complex(self):
+        assert_mpmath_equal(
+            sc.gamma,
+            exception_to_nan(mpmath.gamma),
+            [ComplexArg()],
+            rtol=5e-13,
+        )
+
+    def test_gammainc(self):
+        # Larger arguments are tested in test_data.py:test_local
+        assert_mpmath_equal(
+            sc.gammainc,
+            lambda z, b: mpmath.gammainc(z, b=b, regularized=True),
+            [Arg(0, 1e4, inclusive_a=False), Arg(0, 1e4)],
+            nan_ok=False,
+            rtol=1e-11,
+        )
+
+    def test_gammaincc(self):
+        # Larger arguments are tested in test_data.py:test_local
+        assert_mpmath_equal(
+            sc.gammaincc,
+            lambda z, a: mpmath.gammainc(z, a=a, regularized=True),
+            [Arg(0, 1e4, inclusive_a=False), Arg(0, 1e4)],
+            nan_ok=False,
+            rtol=1e-11,
+        )
+
+    def test_gammaln(self):
+        # The real part of loggamma is log(|gamma(z)|).
+        def f(z):
+            return mpmath.loggamma(z).real
+
+        assert_mpmath_equal(sc.gammaln, exception_to_nan(f), [Arg()])
+
+    @pytest.mark.xfail(run=False)
+    def test_gegenbauer(self):
+        assert_mpmath_equal(
+            sc.eval_gegenbauer,
+            exception_to_nan(mpmath.gegenbauer),
+            [Arg(-1e3, 1e3), Arg(), Arg()],
+        )
+
+    def test_gegenbauer_int(self):
+        # Redefine functions to deal with numerical + mpmath issues
+        def gegenbauer(n, a, x):
+            # Avoid overflow at large `a` (mpmath would need an even larger
+            # dps to handle this correctly, so just skip this region)
+            if abs(a) > 1e100:
+                return np.nan
+
+            # Deal with n=0, n=1 correctly; mpmath 0.17 doesn't do these
+            # always correctly
+            if n == 0:
+                r = 0.0 if a == 0.0 else 1.0
+            elif n == 1:
+                r = 2*a*x
+            else:
+                r = mpmath.gegenbauer(n, a, x)
+
+            # Mpmath 0.17 gives wrong results (spurious zero) in some cases, so
+            # compute the value by perturbing the result
+            if float(r) == 0 and a < -1 and float(a) == int(float(a)):
+                r = mpmath.gegenbauer(n, a + mpmath.mpf('1e-50'), x)
+                if abs(r) < mpmath.mpf('1e-50'):
+                    r = mpmath.mpf('0.0')
+
+            # Differing overflow thresholds in scipy vs. mpmath
+            if abs(r) > 1e270:
+                return np.inf
+            return r
+
+        def sc_gegenbauer(n, a, x):
+            r = sc.eval_gegenbauer(int(n), a, x)
+            # Differing overflow thresholds in scipy vs. mpmath
+            if abs(r) > 1e270:
+                return np.inf
+            return r
+        assert_mpmath_equal(
+            sc_gegenbauer,
+            exception_to_nan(gegenbauer),
+            [IntArg(0, 100), Arg(-1e9, 1e9), Arg()],
+            dps=100, ignore_inf_sign=True, rtol=1e-6,
+        )
+
+        # Check the small-x expansion
+        assert_mpmath_equal(
+            sc_gegenbauer,
+            exception_to_nan(gegenbauer),
+            [IntArg(0, 100), Arg(), FixedArg(np.logspace(-30, -4, 30))],
+            dps=100, ignore_inf_sign=True,
+        )
+
+    @pytest.mark.xfail(run=False)
+    def test_gegenbauer_complex(self):
+        assert_mpmath_equal(
+            lambda n, a, x: sc.eval_gegenbauer(int(n), a.real, x),
+            exception_to_nan(mpmath.gegenbauer),
+            [IntArg(0, 100), Arg(), ComplexArg()],
+        )
+
+    @nonfunctional_tooslow
+    def test_gegenbauer_complex_general(self):
+        assert_mpmath_equal(
+            lambda n, a, x: sc.eval_gegenbauer(n.real, a.real, x),
+            exception_to_nan(mpmath.gegenbauer),
+            [Arg(-1e3, 1e3), Arg(), ComplexArg()],
+        )
+
+    def test_hankel1(self):
+        assert_mpmath_equal(
+            sc.hankel1,
+            exception_to_nan(lambda v, x: mpmath.hankel1(v, x, **HYPERKW)),
+            [Arg(-1e20, 1e20), Arg()],
+        )
+
+    def test_hankel2(self):
+        assert_mpmath_equal(
+            sc.hankel2,
+            exception_to_nan(lambda v, x: mpmath.hankel2(v, x, **HYPERKW)),
+            [Arg(-1e20, 1e20), Arg()],
+        )
+
+    @pytest.mark.xfail(run=False, reason="issues at intermediately large orders")
+    def test_hermite(self):
+        assert_mpmath_equal(
+            lambda n, x: sc.eval_hermite(int(n), x),
+            exception_to_nan(mpmath.hermite),
+            [IntArg(0, 10000), Arg()],
+        )
+
+    # hurwitz: same as zeta
+
+    def test_hyp0f1(self):
+        # mpmath reports no convergence unless maxterms is large enough
+        KW = dict(maxprec=400, maxterms=1500)
+        # n=500 (non-xslow default) fails for one bad point
+        assert_mpmath_equal(
+            sc.hyp0f1,
+            lambda a, x: mpmath.hyp0f1(a, x, **KW),
+            [Arg(-1e7, 1e7), Arg(0, 1e5)],
+            n=5000,
+        )
+        # NB: The range of the second parameter ("z") is limited from below
+        # because of an overflow in the intermediate calculations. The way
+        # for fix it is to implement an asymptotic expansion for Bessel J
+        # (similar to what is implemented for Bessel I here).
+
+    def test_hyp0f1_complex(self):
+        assert_mpmath_equal(
+            lambda a, z: sc.hyp0f1(a.real, z),
+            exception_to_nan(lambda a, x: mpmath.hyp0f1(a, x, **HYPERKW)),
+            [Arg(-10, 10), ComplexArg(complex(-120, -120), complex(120, 120))],
+        )
+        # NB: The range of the first parameter ("v") are limited by an overflow
+        # in the intermediate calculations. Can be fixed by implementing an
+        # asymptotic expansion for Bessel functions for large order.
+
+    def test_hyp1f1(self):
+        def mpmath_hyp1f1(a, b, x):
+            try:
+                return mpmath.hyp1f1(a, b, x)
+            except ZeroDivisionError:
+                return np.inf
+
+        assert_mpmath_equal(
+            sc.hyp1f1,
+            mpmath_hyp1f1,
+            [Arg(-50, 50), Arg(1, 50, inclusive_a=False), Arg(-50, 50)],
+            n=500,
+            nan_ok=False,
+        )
+
+    @pytest.mark.xfail(run=False)
+    def test_hyp1f1_complex(self):
+        assert_mpmath_equal(
+            inf_to_nan(lambda a, b, x: sc.hyp1f1(a.real, b.real, x)),
+            exception_to_nan(lambda a, b, x: mpmath.hyp1f1(a, b, x, **HYPERKW)),
+            [Arg(-1e3, 1e3), Arg(-1e3, 1e3), ComplexArg()],
+            n=2000,
+        )
+
+    @nonfunctional_tooslow
+    def test_hyp2f1_complex(self):
+        # SciPy's hyp2f1 seems to have performance and accuracy problems
+        assert_mpmath_equal(
+            lambda a, b, c, x: sc.hyp2f1(a.real, b.real, c.real, x),
+            exception_to_nan(lambda a, b, c, x: mpmath.hyp2f1(a, b, c, x, **HYPERKW)),
+            [Arg(-1e2, 1e2), Arg(-1e2, 1e2), Arg(-1e2, 1e2), ComplexArg()],
+            n=10,
+        )
+
+    @pytest.mark.xfail(run=False)
+    def test_hyperu(self):
+        assert_mpmath_equal(
+            sc.hyperu,
+            exception_to_nan(lambda a, b, x: mpmath.hyperu(a, b, x, **HYPERKW)),
+            [Arg(), Arg(), Arg()],
+        )
+
+    @pytest.mark.xfail_on_32bit("mpmath issue gh-342: "
+                                "unsupported operand mpz, long for pow")
+    def test_igam_fac(self):
+        def mp_igam_fac(a, x):
+            return mpmath.power(x, a)*mpmath.exp(-x)/mpmath.gamma(a)
+
+        assert_mpmath_equal(
+            _igam_fac,
+            mp_igam_fac,
+            [Arg(0, 1e14, inclusive_a=False), Arg(0, 1e14)],
+            rtol=1e-10,
+            dps=29,
+        )
+
+    def test_j0(self):
+        # The Bessel function at large arguments is j0(x) ~ cos(x + phi)/sqrt(x)
+        # and at large arguments the phase of the cosine loses precision.
+        #
+        # This is numerically expected behavior, so we compare only up to
+        # 1e8 = 1e15 * 1e-7
+        assert_mpmath_equal(sc.j0, mpmath.j0, [Arg(-1e3, 1e3)])
+        assert_mpmath_equal(sc.j0, mpmath.j0, [Arg(-1e8, 1e8)], rtol=1e-5)
+
+    def test_j1(self):
+        # See comment in test_j0
+        assert_mpmath_equal(sc.j1, mpmath.j1, [Arg(-1e3, 1e3)])
+        assert_mpmath_equal(sc.j1, mpmath.j1, [Arg(-1e8, 1e8)], rtol=1e-5)
+
+    @pytest.mark.xfail(run=False)
+    def test_jacobi(self):
+        assert_mpmath_equal(
+            sc.eval_jacobi,
+            exception_to_nan(lambda a, b, c, x: mpmath.jacobi(a, b, c, x, **HYPERKW)),
+            [Arg(), Arg(), Arg(), Arg()],
+        )
+        assert_mpmath_equal(
+            lambda n, b, c, x: sc.eval_jacobi(int(n), b, c, x),
+            exception_to_nan(lambda a, b, c, x: mpmath.jacobi(a, b, c, x, **HYPERKW)),
+            [IntArg(), Arg(), Arg(), Arg()],
+        )
+
+    def test_jacobi_int(self):
+        # Redefine functions to deal with numerical + mpmath issues
+        def jacobi(n, a, b, x):
+            # Mpmath does not handle n=0 case always correctly
+            if n == 0:
+                return 1.0
+            return mpmath.jacobi(n, a, b, x)
+        assert_mpmath_equal(
+            lambda n, a, b, x: sc.eval_jacobi(int(n), a, b, x),
+            lambda n, a, b, x: exception_to_nan(jacobi)(n, a, b, x, **HYPERKW),
+            [IntArg(), Arg(), Arg(), Arg()],
+            n=4095,
+            dps=50,
+        )
+
+    def test_kei(self):
+        def kei(x):
+            if x == 0:
+                # work around mpmath issue at x=0
+                return -pi/4
+            return exception_to_nan(mpmath.kei)(0, x, **HYPERKW)
+        assert_mpmath_equal(sc.kei, kei, [Arg(-1e30, 1e30)], n=1000)
+
+    def test_ker(self):
+        assert_mpmath_equal(
+            sc.ker,
+            exception_to_nan(lambda x: mpmath.ker(0, x, **HYPERKW)),
+            [Arg(-1e30, 1e30)],
+            n=1000,
+        )
+
+    @nonfunctional_tooslow
+    def test_laguerre(self):
+        assert_mpmath_equal(
+            trace_args(sc.eval_laguerre),
+            lambda n, x: exception_to_nan(mpmath.laguerre)(n, x, **HYPERKW),
+            [Arg(), Arg()],
+        )
+
+    def test_laguerre_int(self):
+        assert_mpmath_equal(
+            lambda n, x: sc.eval_laguerre(int(n), x),
+            lambda n, x: exception_to_nan(mpmath.laguerre)(n, x, **HYPERKW),
+            [IntArg(), Arg()],
+            n=20000,
+        )
+
+    @pytest.mark.xfail_on_32bit("see gh-3551 for bad points")
+    def test_lambertw_real(self):
+        assert_mpmath_equal(
+            lambda x, k: sc.lambertw(x, int(k.real)),
+            lambda x, k: mpmath.lambertw(x, int(k.real)),
+            [ComplexArg(-np.inf, np.inf), IntArg(0, 10)],
+            rtol=1e-13, nan_ok=False,
+        )
+
+    def test_lanczos_sum_expg_scaled(self):
+        maxgamma = 171.624376956302725
+        e = np.exp(1)
+        g = 6.024680040776729583740234375
+
+        def gamma(x):
+            with np.errstate(over='ignore'):
+                fac = ((x + g - 0.5)/e)**(x - 0.5)
+                if fac != np.inf:
+                    res = fac*_lanczos_sum_expg_scaled(x)
+                else:
+                    fac = ((x + g - 0.5)/e)**(0.5*(x - 0.5))
+                    res = fac*_lanczos_sum_expg_scaled(x)
+                    res *= fac
+            return res
+
+        assert_mpmath_equal(
+            gamma,
+            mpmath.gamma,
+            [Arg(0, maxgamma, inclusive_a=False)],
+            rtol=1e-13,
+        )
+
+    @nonfunctional_tooslow
+    def test_legendre(self):
+        assert_mpmath_equal(sc.eval_legendre, mpmath.legendre, [Arg(), Arg()])
+
+    def test_legendre_int(self):
+        assert_mpmath_equal(
+            lambda n, x: sc.eval_legendre(int(n), x),
+            lambda n, x: exception_to_nan(mpmath.legendre)(n, x, **HYPERKW),
+            [IntArg(), Arg()],
+            n=20000,
+        )
+
+        # Check the small-x expansion
+        assert_mpmath_equal(
+            lambda n, x: sc.eval_legendre(int(n), x),
+            lambda n, x: exception_to_nan(mpmath.legendre)(n, x, **HYPERKW),
+            [IntArg(), FixedArg(np.logspace(-30, -4, 20))],
+        )
+
+    @pytest.mark.xfail(run=False, reason="apparently picks wrong function at |z| > 1")
+    def test_legenq(self):
+        def lqnm(n, m, z):
+            return sc.lqmn(m, n, z)[0][-1,-1]
+
+        def legenq(n, m, z):
+            if abs(z) < 1e-15:
+                # mpmath has bad performance here
+                return np.nan
+            return exception_to_nan(mpmath.legenq)(n, m, z, type=2)
+
+        assert_mpmath_equal(
+            lqnm,
+            legenq,
+            [IntArg(0, 100), IntArg(0, 100), Arg()],
+        )
+
+    @nonfunctional_tooslow
+    def test_legenq_complex(self):
+        def lqnm(n, m, z):
+            return sc.lqmn(int(m.real), int(n.real), z)[0][-1,-1]
+
+        def legenq(n, m, z):
+            if abs(z) < 1e-15:
+                # mpmath has bad performance here
+                return np.nan
+            return exception_to_nan(mpmath.legenq)(int(n.real), int(m.real), z, type=2)
+
+        assert_mpmath_equal(
+            lqnm,
+            legenq,
+            [IntArg(0, 100), IntArg(0, 100), ComplexArg()],
+            n=100,
+        )
+
+    def test_lgam1p(self):
+        def param_filter(x):
+            # Filter the poles
+            return np.where((np.floor(x) == x) & (x <= 0), False, True)
+
+        def mp_lgam1p(z):
+            # The real part of loggamma is log(|gamma(z)|)
+            return mpmath.loggamma(1 + z).real
+
+        assert_mpmath_equal(
+            _lgam1p,
+            mp_lgam1p,
+            [Arg()],
+            rtol=1e-13,
+            dps=100,
+            param_filter=param_filter,
+        )
+
+    def test_loggamma(self):
+        def mpmath_loggamma(z):
+            try:
+                res = mpmath.loggamma(z)
+            except ValueError:
+                res = complex(np.nan, np.nan)
+            return res
+
+        assert_mpmath_equal(
+            sc.loggamma,
+            mpmath_loggamma,
+            [ComplexArg()],
+            nan_ok=False,
+            distinguish_nan_and_inf=False,
+            rtol=5e-14,
+        )
+
+    @pytest.mark.xfail(run=False)
+    def test_pcfd(self):
+        def pcfd(v, x):
+            return sc.pbdv(v, x)[0]
+        assert_mpmath_equal(
+            pcfd,
+            exception_to_nan(lambda v, x: mpmath.pcfd(v, x, **HYPERKW)),
+            [Arg(), Arg()],
+        )
+
+    @pytest.mark.xfail(run=False, reason="it's not the same as the mpmath function --- "
+                                         "maybe different definition?")
+    def test_pcfv(self):
+        def pcfv(v, x):
+            return sc.pbvv(v, x)[0]
+        assert_mpmath_equal(
+            pcfv,
+            lambda v, x: time_limited()(exception_to_nan(mpmath.pcfv))(v, x, **HYPERKW),
+            [Arg(), Arg()],
+            n=1000,
+        )
+
+    def test_pcfw(self):
+        def pcfw(a, x):
+            return sc.pbwa(a, x)[0]
+
+        def dpcfw(a, x):
+            return sc.pbwa(a, x)[1]
+
+        def mpmath_dpcfw(a, x):
+            return mpmath.diff(mpmath.pcfw, (a, x), (0, 1))
+
+        # The Zhang and Jin implementation only uses Taylor series and
+        # is thus accurate in only a very small range.
+        assert_mpmath_equal(
+            pcfw,
+            mpmath.pcfw,
+            [Arg(-5, 5), Arg(-5, 5)],
+            rtol=2e-8,
+            n=100,
+        )
+
+        assert_mpmath_equal(
+            dpcfw,
+            mpmath_dpcfw,
+            [Arg(-5, 5), Arg(-5, 5)],
+            rtol=2e-9,
+            n=100,
+        )
+
+    @pytest.mark.xfail(run=False,
+                       reason="issues at large arguments (atol OK, rtol not) "
+                              "and <eps-close to z=0")
+    def test_polygamma(self):
+        assert_mpmath_equal(
+            sc.polygamma,
+            time_limited()(exception_to_nan(mpmath.polygamma)),
+            [IntArg(0, 1000), Arg()],
+        )
+
+    def test_rgamma(self):
+        assert_mpmath_equal(
+            sc.rgamma,
+            mpmath.rgamma,
+            [Arg(-8000, np.inf)],
+            n=5000,
+            nan_ok=False,
+            ignore_inf_sign=True,
+        )
+
+    def test_rgamma_complex(self):
+        assert_mpmath_equal(
+            sc.rgamma,
+            exception_to_nan(mpmath.rgamma),
+            [ComplexArg()],
+            rtol=5e-13,
+        )
+
+    @pytest.mark.xfail(reason=("see gh-3551 for bad points on 32 bit "
+                               "systems and gh-8095 for another bad "
+                               "point"))
+    def test_rf(self):
+        if version.parse(mpmath.__version__) >= version.Version("1.0.0"):
+            # no workarounds needed
+            mppoch = mpmath.rf
+        else:
+            def mppoch(a, m):
+                # deal with cases where the result in double precision
+                # hits exactly a non-positive integer, but the
+                # corresponding extended-precision mpf floats don't
+                if float(a + m) == int(a + m) and float(a + m) <= 0:
+                    a = mpmath.mpf(a)
+                    m = int(a + m) - a
+                return mpmath.rf(a, m)
+
+        assert_mpmath_equal(sc.poch, mppoch, [Arg(), Arg()], dps=400)
+
+    def test_sinpi(self):
+        eps = np.finfo(float).eps
+        assert_mpmath_equal(
+            _sinpi,
+            mpmath.sinpi,
+            [Arg()],
+            nan_ok=False,
+            rtol=2*eps,
+        )
+
+    def test_sinpi_complex(self):
+        assert_mpmath_equal(
+            _sinpi,
+            mpmath.sinpi,
+            [ComplexArg()],
+            nan_ok=False,
+            rtol=2e-14,
+        )
+
+    def test_shi(self):
+        def shi(x):
+            return sc.shichi(x)[0]
+        assert_mpmath_equal(shi, mpmath.shi, [Arg()])
+        # check asymptotic series cross-over
+        assert_mpmath_equal(shi, mpmath.shi, [FixedArg([88 - 1e-9, 88, 88 + 1e-9])])
+
+    def test_shi_complex(self):
+        def shi(z):
+            return sc.shichi(z)[0]
+        # shi oscillates as Im[z] -> +- inf, so limit range
+        assert_mpmath_equal(
+            shi,
+            mpmath.shi,
+            [ComplexArg(complex(-np.inf, -1e8), complex(np.inf, 1e8))],
+            rtol=1e-12,
+        )
+
+    def test_si(self):
+        def si(x):
+            return sc.sici(x)[0]
+        assert_mpmath_equal(si, mpmath.si, [Arg()])
+
+    def test_si_complex(self):
+        def si(z):
+            return sc.sici(z)[0]
+        # si oscillates as Re[z] -> +- inf, so limit range
+        assert_mpmath_equal(
+            si,
+            mpmath.si,
+            [ComplexArg(complex(-1e8, -np.inf), complex(1e8, np.inf))],
+            rtol=1e-12,
+        )
+
+    def test_spence(self):
+        # mpmath uses a different convention for the dilogarithm
+        def dilog(x):
+            return mpmath.polylog(2, 1 - x)
+        # Spence has a branch cut on the negative real axis
+        assert_mpmath_equal(
+            sc.spence,
+            exception_to_nan(dilog),
+            [Arg(0, np.inf)],
+            rtol=1e-14,
+        )
+
+    def test_spence_complex(self):
+        def dilog(z):
+            return mpmath.polylog(2, 1 - z)
+        assert_mpmath_equal(
+            sc.spence,
+            exception_to_nan(dilog),
+            [ComplexArg()],
+            rtol=1e-14,
+        )
+
+    def test_struveh(self):
+        assert_mpmath_equal(
+            sc.struve,
+            exception_to_nan(mpmath.struveh),
+            [Arg(-1e4, 1e4), Arg(0, 1e4)],
+            rtol=5e-10,
+        )
+
+    def test_struvel(self):
+        def mp_struvel(v, z):
+            if v < 0 and z < -v and abs(v) > 1000:
+                # larger DPS needed for correct results
+                old_dps = mpmath.mp.dps
+                try:
+                    mpmath.mp.dps = 500
+                    return mpmath.struvel(v, z)
+                finally:
+                    mpmath.mp.dps = old_dps
+            return mpmath.struvel(v, z)
+
+        assert_mpmath_equal(
+            sc.modstruve,
+            exception_to_nan(mp_struvel),
+            [Arg(-1e4, 1e4), Arg(0, 1e4)],
+            rtol=5e-10,
+            ignore_inf_sign=True,
+        )
+
+    def test_wrightomega_real(self):
+        def mpmath_wrightomega_real(x):
+            return mpmath.lambertw(mpmath.exp(x), mpmath.mpf('-0.5'))
+
+        # For x < -1000 the Wright Omega function is just 0 to double
+        # precision, and for x > 1e21 it is just x to double
+        # precision.
+        assert_mpmath_equal(
+            sc.wrightomega,
+            mpmath_wrightomega_real,
+            [Arg(-1000, 1e21)],
+            rtol=5e-15,
+            atol=0,
+            nan_ok=False,
+        )
+
+    def test_wrightomega(self):
+        assert_mpmath_equal(
+            sc.wrightomega,
+            lambda z: _mpmath_wrightomega(z, 25),
+            [ComplexArg()],
+            rtol=1e-14,
+            nan_ok=False,
+        )
+
+    def test_hurwitz_zeta(self):
+        assert_mpmath_equal(
+            sc.zeta,
+            exception_to_nan(mpmath.zeta),
+            [Arg(a=1, b=1e10, inclusive_a=False), Arg(a=0, inclusive_a=False)],
+        )
+
+    def test_riemann_zeta(self):
+        assert_mpmath_equal(
+            sc.zeta,
+            lambda x: mpmath.zeta(x) if x != 1 else mpmath.inf,
+            [Arg(-100, 100)],
+            nan_ok=False,
+            rtol=5e-13,
+        )
+
+    def test_zetac(self):
+        assert_mpmath_equal(
+            sc.zetac,
+            lambda x: mpmath.zeta(x) - 1 if x != 1 else mpmath.inf,
+            [Arg(-100, 100)],
+            nan_ok=False,
+            dps=45,
+            rtol=5e-13,
+        )
+
+    def test_boxcox(self):
+
+        def mp_boxcox(x, lmbda):
+            x = mpmath.mp.mpf(x)
+            lmbda = mpmath.mp.mpf(lmbda)
+            if lmbda == 0:
+                return mpmath.mp.log(x)
+            else:
+                return mpmath.mp.powm1(x, lmbda) / lmbda
+
+        assert_mpmath_equal(
+            sc.boxcox,
+            exception_to_nan(mp_boxcox),
+            [Arg(a=0, inclusive_a=False), Arg()],
+            n=200,
+            dps=60,
+            rtol=1e-13,
+        )
+
+    def test_boxcox1p(self):
+
+        def mp_boxcox1p(x, lmbda):
+            x = mpmath.mp.mpf(x)
+            lmbda = mpmath.mp.mpf(lmbda)
+            one = mpmath.mp.mpf(1)
+            if lmbda == 0:
+                return mpmath.mp.log(one + x)
+            else:
+                return mpmath.mp.powm1(one + x, lmbda) / lmbda
+
+        assert_mpmath_equal(
+            sc.boxcox1p,
+            exception_to_nan(mp_boxcox1p),
+            [Arg(a=-1, inclusive_a=False), Arg()],
+            n=200,
+            dps=60,
+            rtol=1e-13,
+        )
+
+    def test_spherical_jn(self):
+        def mp_spherical_jn(n, z):
+            arg = mpmath.mpmathify(z)
+            out = (mpmath.besselj(n + mpmath.mpf(1)/2, arg) /
+                   mpmath.sqrt(2*arg/mpmath.pi))
+            if arg.imag == 0:
+                return out.real
+            else:
+                return out
+
+        assert_mpmath_equal(
+            lambda n, z: sc.spherical_jn(int(n), z),
+            exception_to_nan(mp_spherical_jn),
+            [IntArg(0, 200), Arg(-1e8, 1e8)],
+            dps=300,
+            # underflow of `spherical_jn` is a bit premature; see gh-21629
+            param_filter=(None, lambda z: np.abs(z) > 1e-20),
+        )
+
+    def test_spherical_jn_complex(self):
+        def mp_spherical_jn(n, z):
+            arg = mpmath.mpmathify(z)
+            out = (mpmath.besselj(n + mpmath.mpf(1)/2, arg) /
+                   mpmath.sqrt(2*arg/mpmath.pi))
+            if arg.imag == 0:
+                return out.real
+            else:
+                return out
+
+        assert_mpmath_equal(
+            lambda n, z: sc.spherical_jn(int(n.real), z),
+            exception_to_nan(mp_spherical_jn),
+            [IntArg(0, 200), ComplexArg()]
+        )
+
+    def test_spherical_yn(self):
+        def mp_spherical_yn(n, z):
+            arg = mpmath.mpmathify(z)
+            out = (mpmath.bessely(n + mpmath.mpf(1)/2, arg) /
+                   mpmath.sqrt(2*arg/mpmath.pi))
+            if arg.imag == 0:
+                return out.real
+            else:
+                return out
+
+        assert_mpmath_equal(
+            lambda n, z: sc.spherical_yn(int(n), z),
+            exception_to_nan(mp_spherical_yn),
+            [IntArg(0, 200), Arg(-1e10, 1e10)],
+            dps=100,
+        )
+
+    def test_spherical_yn_complex(self):
+        def mp_spherical_yn(n, z):
+            arg = mpmath.mpmathify(z)
+            out = (mpmath.bessely(n + mpmath.mpf(1)/2, arg) /
+                   mpmath.sqrt(2*arg/mpmath.pi))
+            if arg.imag == 0:
+                return out.real
+            else:
+                return out
+
+        assert_mpmath_equal(
+            lambda n, z: sc.spherical_yn(int(n.real), z),
+            exception_to_nan(mp_spherical_yn),
+            [IntArg(0, 200), ComplexArg()],
+        )
+
+    def test_spherical_in(self):
+        def mp_spherical_in(n, z):
+            arg = mpmath.mpmathify(z)
+            out = (mpmath.besseli(n + mpmath.mpf(1)/2, arg) /
+                   mpmath.sqrt(2*arg/mpmath.pi))
+            if arg.imag == 0:
+                return out.real
+            else:
+                return out
+
+        assert_mpmath_equal(
+            lambda n, z: sc.spherical_in(int(n), z),
+            exception_to_nan(mp_spherical_in),
+            [IntArg(0, 200), Arg()],
+            dps=200,
+            atol=10**(-278),
+        )
+
+    def test_spherical_in_complex(self):
+        def mp_spherical_in(n, z):
+            arg = mpmath.mpmathify(z)
+            out = (mpmath.besseli(n + mpmath.mpf(1)/2, arg) /
+                   mpmath.sqrt(2*arg/mpmath.pi))
+            if arg.imag == 0:
+                return out.real
+            else:
+                return out
+
+        assert_mpmath_equal(
+            lambda n, z: sc.spherical_in(int(n.real), z),
+            exception_to_nan(mp_spherical_in),
+            [IntArg(0, 200), ComplexArg()],
+        )
+
+    def test_spherical_kn(self):
+        def mp_spherical_kn(n, z):
+            arg = mpmath.mpmathify(z)
+            out = (mpmath.besselk(n + mpmath.mpf(1)/2, arg) /
+                   mpmath.sqrt(2*arg/mpmath.pi))
+            if mpmath.mpmathify(z).imag == 0:
+                return out.real
+            else:
+                return out
+
+        assert_mpmath_equal(
+            lambda n, z: sc.spherical_kn(int(n), z),
+            exception_to_nan(mp_spherical_kn),
+            [IntArg(0, 150), Arg()],
+            dps=100,
+        )
+
+    @pytest.mark.xfail(run=False,
+                       reason="Accuracy issues near z = -1 inherited from kv.")
+    def test_spherical_kn_complex(self):
+        def mp_spherical_kn(n, z):
+            arg = mpmath.mpmathify(z)
+            out = (mpmath.besselk(n + mpmath.mpf(1)/2, arg) /
+                   mpmath.sqrt(2*arg/mpmath.pi))
+            if arg.imag == 0:
+                return out.real
+            else:
+                return out
+
+        assert_mpmath_equal(
+            lambda n, z: sc.spherical_kn(int(n.real), z),
+            exception_to_nan(mp_spherical_kn),
+            [IntArg(0, 200), ComplexArg()],
+            dps=200,
+        )

.venv/lib/python3.12/site-packages/scipy/special/tests/test_nan_inputs.py

@@ -0,0 +1,72 @@
+"""Test how the ufuncs in special handle nan inputs.
+
+"""
+import warnings
+
+from collections.abc import Callable
+
+import numpy as np
+from numpy.testing import assert_array_equal, assert_
+import pytest
+import scipy.special as sc
+
+
+KNOWNFAILURES: dict[str, Callable] = {}
+
+POSTPROCESSING: dict[str, Callable] = {}
+
+
+def _get_ufuncs():
+    ufuncs = []
+    ufunc_names = []
+    for name in sorted(sc.__dict__):
+        obj = sc.__dict__[name]
+        if not isinstance(obj, np.ufunc):
+            continue
+        msg = KNOWNFAILURES.get(obj)
+        if msg is None:
+            ufuncs.append(obj)
+            ufunc_names.append(name)
+        else:
+            fail = pytest.mark.xfail(run=False, reason=msg)
+            ufuncs.append(pytest.param(obj, marks=fail))
+            ufunc_names.append(name)
+    return ufuncs, ufunc_names
+
+
+UFUNCS, UFUNC_NAMES = _get_ufuncs()
+
+
+@pytest.mark.parametrize("func", UFUNCS, ids=UFUNC_NAMES)
+def test_nan_inputs(func):
+    args = (np.nan,)*func.nin
+    with warnings.catch_warnings():
+        # Ignore warnings about unsafe casts from legacy wrappers
+        warnings.filterwarnings(
+            "ignore",
+            "floating point number truncated to an integer",
+            RuntimeWarning
+        )
+        try:
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore", DeprecationWarning)
+                res = func(*args)
+        except TypeError:
+            # One of the arguments doesn't take real inputs
+            return
+    if func in POSTPROCESSING:
+        res = POSTPROCESSING[func](*res)
+
+    msg = f"got {res} instead of nan"
+    assert_array_equal(np.isnan(res), True, err_msg=msg)
+
+
+def test_legacy_cast():
+    with warnings.catch_warnings():
+        warnings.filterwarnings(
+            "ignore",
+            "floating point number truncated to an integer",
+            RuntimeWarning
+        )
+        res = sc.bdtrc(np.nan, 1, 0.5)
+        assert_(np.isnan(res))

.venv/lib/python3.12/site-packages/scipy/special/tests/test_ndtr.py

@@ -0,0 +1,77 @@
+import numpy as np
+from numpy.testing import assert_equal, assert_allclose
+import scipy.special as sc
+
+
+def test_ndtr():
+    assert_equal(sc.ndtr(0), 0.5)
+    assert_allclose(sc.ndtr(1), 0.8413447460685429)
+
+
+class TestNdtri:
+
+    def test_zero(self):
+        assert sc.ndtri(0.5) == 0.0
+
+    def test_asymptotes(self):
+        assert_equal(sc.ndtri([0.0, 1.0]), [-np.inf, np.inf])
+
+    def test_outside_of_domain(self):
+        assert all(np.isnan(sc.ndtri([-1.5, 1.5])))
+
+
+class TestLogNdtr:
+
+    # The expected values in these tests were computed with mpmath:
+    #
+    #   def log_ndtr_mp(x):
+    #       return mpmath.log(mpmath.ncdf(x))
+    #
+
+    def test_log_ndtr_moderate_le8(self):
+        x = np.array([-0.75, -0.25, 0, 0.5, 1.5, 2.5, 3, 4, 5, 7, 8])
+        expected = np.array([-1.4844482299196562,
+                             -0.9130617648111351,
+                             -0.6931471805599453,
+                             -0.3689464152886564,
+                             -0.06914345561223398,
+                             -0.006229025485860002,
+                             -0.0013508099647481938,
+                             -3.167174337748927e-05,
+                             -2.866516129637636e-07,
+                             -1.279812543886654e-12,
+                             -6.220960574271786e-16])
+        y = sc.log_ndtr(x)
+        assert_allclose(y, expected, rtol=1e-14)
+
+    def test_log_ndtr_values_8_16(self):
+        x = np.array([8.001, 8.06, 8.15, 8.5, 10, 12, 14, 16])
+        expected = [-6.170639424817055e-16,
+                    -3.814722443652823e-16,
+                    -1.819621363526629e-16,
+                    -9.479534822203318e-18,
+                    -7.619853024160525e-24,
+                    -1.776482112077679e-33,
+                    -7.7935368191928e-45,
+                    -6.388754400538087e-58]
+        y = sc.log_ndtr(x)
+        assert_allclose(y, expected, rtol=5e-14)
+
+    def test_log_ndtr_values_16_31(self):
+        x = np.array([16.15, 20.3, 21.4, 26.2, 30.9])
+        expected = [-5.678084565148492e-59,
+                    -6.429244467698346e-92,
+                    -6.680402412553295e-102,
+                    -1.328698078458869e-151,
+                    -5.972288641838264e-210]
+        y = sc.log_ndtr(x)
+        assert_allclose(y, expected, rtol=2e-13)
+
+    def test_log_ndtr_values_gt31(self):
+        x = np.array([31.6, 32.8, 34.9, 37.1])
+        expected = [-1.846036234858162e-219,
+                    -2.9440539964066835e-236,
+                    -3.71721649450857e-267,
+                    -1.4047119663106221e-301]
+        y = sc.log_ndtr(x)
+        assert_allclose(y, expected, rtol=3e-13)

.venv/lib/python3.12/site-packages/scipy/special/tests/test_ndtri_exp.py

@@ -0,0 +1,94 @@
+import pytest
+import numpy as np
+from numpy.testing import assert_equal, assert_allclose
+from scipy.special import log_ndtr, ndtri_exp
+from scipy.special._testutils import assert_func_equal
+
+
+def log_ndtr_ndtri_exp(y):
+    return log_ndtr(ndtri_exp(y))
+
+
+@pytest.fixture(scope="class")
+def uniform_random_points():
+    random_state = np.random.RandomState(1234)
+    points = random_state.random_sample(1000)
+    return points
+
+
+class TestNdtriExp:
+    """Tests that ndtri_exp is sufficiently close to an inverse of log_ndtr.
+
+    We have separate tests for the five intervals (-inf, -10),
+    [-10, -2), [-2, -0.14542), [-0.14542, -1e-6), and [-1e-6, 0).
+    ndtri_exp(y) is computed in three different ways depending on if y
+    is in (-inf, -2), [-2, log(1 - exp(-2))], or [log(1 - exp(-2), 0).
+    Each of these intervals is given its own test with two additional tests
+    for handling very small values and values very close to zero.
+    """
+
+    @pytest.mark.parametrize(
+        "test_input", [-1e1, -1e2, -1e10, -1e20, -np.finfo(float).max]
+    )
+    def test_very_small_arg(self, test_input, uniform_random_points):
+        scale = test_input
+        points = scale * (0.5 * uniform_random_points + 0.5)
+        assert_func_equal(
+            log_ndtr_ndtri_exp,
+            lambda y: y, points,
+            rtol=1e-14,
+            nan_ok=True
+        )
+
+    @pytest.mark.parametrize(
+        "interval,expected_rtol",
+        [
+            ((-10, -2), 1e-14),
+            ((-2, -0.14542), 1e-12),
+            ((-0.14542, -1e-6), 1e-10),
+            ((-1e-6, 0), 1e-6),
+        ],
+    )
+    def test_in_interval(self, interval, expected_rtol, uniform_random_points):
+        left, right = interval
+        points = (right - left) * uniform_random_points + left
+        assert_func_equal(
+            log_ndtr_ndtri_exp,
+            lambda y: y, points,
+            rtol=expected_rtol,
+            nan_ok=True
+        )
+
+    def test_extreme(self):
+        # bigneg is not quite the largest negative double precision value.
+        # Here's why:
+        # The round-trip calculation
+        #    y = ndtri_exp(bigneg)
+        #    bigneg2 = log_ndtr(y)
+        # where bigneg is a very large negative value, would--with infinite
+        # precision--result in bigneg2 == bigneg.  When bigneg is large enough,
+        # y is effectively equal to -sqrt(2)*sqrt(-bigneg), and log_ndtr(y) is
+        # effectively -(y/sqrt(2))**2.  If we use bigneg = np.finfo(float).min,
+        # then by construction, the theoretical value is the most negative
+        # finite value that can be represented with 64 bit float point.  This
+        # means tiny changes in how the computation proceeds can result in the
+        # return value being -inf.  (E.g. changing the constant representation
+        # of 1/sqrt(2) from 0.7071067811865475--which is the value returned by
+        # 1/np.sqrt(2)--to 0.7071067811865476--which is the most accurate 64
+        # bit floating point representation of 1/sqrt(2)--results in the
+        # round-trip that starts with np.finfo(float).min returning -inf.  So
+        # we'll move the bigneg value a few ULPs towards 0 to avoid this
+        # sensitivity.
+        # Use the reduce method to apply nextafter four times.
+        bigneg = np.nextafter.reduce([np.finfo(float).min, 0, 0, 0, 0])
+        # tinyneg is approx. -2.225e-308.
+        tinyneg = -np.finfo(float).tiny
+        x = np.array([tinyneg, bigneg])
+        result = log_ndtr_ndtri_exp(x)
+        assert_allclose(result, x, rtol=1e-12)
+
+    def test_asymptotes(self):
+        assert_equal(ndtri_exp([-np.inf, 0.0]), [-np.inf, np.inf])
+
+    def test_outside_domain(self):
+        assert np.isnan(ndtri_exp(1.0))

.venv/lib/python3.12/site-packages/scipy/special/tests/test_orthogonal.py

@@ -0,0 +1,823 @@
+import pytest
+from pytest import raises as assert_raises
+
+import numpy as np
+from numpy import array, sqrt
+from numpy.testing import assert_equal, assert_allclose
+
+from scipy import integrate
+import scipy.special as sc
+from scipy.special import gamma
+import scipy.special._orthogonal as orth
+
+
+class TestCheby:
+    def test_chebyc(self):
+        C0 = orth.chebyc(0)
+        C1 = orth.chebyc(1)
+        with np.errstate(all='ignore'):
+            C2 = orth.chebyc(2)
+            C3 = orth.chebyc(3)
+            C4 = orth.chebyc(4)
+            C5 = orth.chebyc(5)
+
+        assert_allclose(C0.c, [2], atol=1.5e-13, rtol=0)
+        assert_allclose(C1.c, [1, 0], atol=1.5e-13, rtol=0)
+        assert_allclose(C2.c, [1, 0, -2], atol=1.5e-13, rtol=0)
+        assert_allclose(C3.c, [1, 0, -3, 0], atol=1.5e-13, rtol=0)
+        assert_allclose(C4.c, [1, 0, -4, 0, 2], atol=1.5e-13, rtol=0)
+        assert_allclose(C5.c, [1, 0, -5, 0, 5, 0],atol=1.5e-13, rtol=0)
+
+    def test_chebys(self):
+        S0 = orth.chebys(0)
+        S1 = orth.chebys(1)
+        S2 = orth.chebys(2)
+        S3 = orth.chebys(3)
+        S4 = orth.chebys(4)
+        S5 = orth.chebys(5)
+        assert_allclose(S0.c, [1], atol=1.5e-13, rtol=0)
+        assert_allclose(S1.c, [1, 0], atol=1.5e-13, rtol=0)
+        assert_allclose(S2.c, [1, 0, -1], atol=1.5e-13, rtol=0)
+        assert_allclose(S3.c, [1, 0, -2, 0], atol=1.5e-13, rtol=0)
+        assert_allclose(S4.c, [1, 0, -3, 0, 1], atol=1.5e-13, rtol=0)
+        assert_allclose(S5.c, [1, 0, -4, 0, 3, 0], atol=1.5e-13, rtol=0)
+
+    def test_chebyt(self):
+        T0 = orth.chebyt(0)
+        T1 = orth.chebyt(1)
+        T2 = orth.chebyt(2)
+        T3 = orth.chebyt(3)
+        T4 = orth.chebyt(4)
+        T5 = orth.chebyt(5)
+        assert_allclose(T0.c, [1], atol=1.5e-13, rtol=0)
+        assert_allclose(T1.c, [1, 0], atol=1.5e-13, rtol=0)
+        assert_allclose(T2.c, [2, 0, -1], atol=1.5e-13, rtol=0)
+        assert_allclose(T3.c, [4, 0, -3, 0], atol=1.5e-13, rtol=0)
+        assert_allclose(T4.c, [8, 0, -8, 0, 1], atol=1.5e-13, rtol=0)
+        assert_allclose(T5.c, [16, 0, -20, 0, 5, 0], atol=1.5e-13, rtol=0)
+
+    def test_chebyu(self):
+        U0 = orth.chebyu(0)
+        U1 = orth.chebyu(1)
+        U2 = orth.chebyu(2)
+        U3 = orth.chebyu(3)
+        U4 = orth.chebyu(4)
+        U5 = orth.chebyu(5)
+        assert_allclose(U0.c, [1], atol=1.5e-13, rtol=0)
+        assert_allclose(U1.c, [2, 0], atol=1.5e-13, rtol=0)
+        assert_allclose(U2.c, [4, 0, -1], atol=1.5e-13, rtol=0)
+        assert_allclose(U3.c, [8, 0, -4, 0], atol=1.5e-13, rtol=0)
+        assert_allclose(U4.c, [16, 0, -12, 0, 1], atol=1.5e-13, rtol=0)
+        assert_allclose(U5.c, [32, 0, -32, 0, 6, 0], atol=1.5e-13, rtol=0)
+
+
+class TestGegenbauer:
+
+    def test_gegenbauer(self):
+        a = 5*np.random.random() - 0.5
+        if np.any(a == 0):
+            a = -0.2
+        Ca0 = orth.gegenbauer(0,a)
+        Ca1 = orth.gegenbauer(1,a)
+        Ca2 = orth.gegenbauer(2,a)
+        Ca3 = orth.gegenbauer(3,a)
+        Ca4 = orth.gegenbauer(4,a)
+        Ca5 = orth.gegenbauer(5,a)
+
+        assert_allclose(Ca0.c, array([1]), atol=1.5e-13, rtol=0)
+        assert_allclose(Ca1.c, array([2*a, 0]), atol=1.5e-13, rtol=0)
+        assert_allclose(Ca2.c, array([2*a*(a + 1), 0, -a]),
+                        atol=1.5e-13, rtol=0)
+        assert_allclose(Ca3.c, array([4*sc.poch(a, 3), 0,-6*a*(a + 1), 0])/3.0,
+                        atol=1.5e-11, rtol=0)
+        assert_allclose(Ca4.c, array([4*sc.poch(a, 4), 0, -12*sc.poch(a, 3),
+                                      0, 3*a*(a + 1)])/6.0,
+                        atol=1.5e-11, rtol=0)
+        assert_allclose(Ca5.c, array([4*sc.poch(a, 5), 0, -20*sc.poch(a, 4),
+                                      0, 15*sc.poch(a, 3), 0])/15.0,
+                        atol=1.5e-11, rtol=0)
+
+    @pytest.mark.parametrize('a', [0, 1])
+    def test_n_zero_gh8888(self, a):
+        # gh-8888 reported that gegenbauer(0, 0) returns NaN polynomial
+        Cn0 = orth.gegenbauer(0, a)
+        assert_equal(Cn0.c, np.asarray([1.]))
+
+    def test_valid_alpha(self):
+        # Check input validation of `alpha`
+        message = '`alpha` must be a finite number greater...'
+        with pytest.raises(ValueError, match=message):
+            orth.gegenbauer(0, np.nan)
+        with pytest.raises(ValueError, match=message):
+            orth.gegenbauer(1, -0.5)
+        with pytest.raises(ValueError, match=message):
+            orth.gegenbauer(2, -np.inf)
+
+
+class TestHermite:
+    def test_hermite(self):
+        H0 = orth.hermite(0)
+        H1 = orth.hermite(1)
+        H2 = orth.hermite(2)
+        H3 = orth.hermite(3)
+        H4 = orth.hermite(4)
+        H5 = orth.hermite(5)
+        assert_allclose(H0.c, [1], atol=1.5e-13, rtol=0)
+        assert_allclose(H1.c, [2, 0], atol=1.5e-13, rtol=0)
+        assert_allclose(H2.c, [4, 0, -2], atol=1.5e-13, rtol=0)
+        assert_allclose(H3.c, [8, 0, -12, 0], atol=1.5e-13, rtol=0)
+        assert_allclose(H4.c, [16, 0, -48, 0, 12], atol=1.5e-12, rtol=0)
+        assert_allclose(H5.c, [32, 0, -160, 0, 120, 0], atol=1.5e-12, rtol=0)
+
+    def test_hermitenorm(self):
+        # He_n(x) = 2**(-n/2) H_n(x/sqrt(2))
+        psub = np.poly1d([1.0/sqrt(2),0])
+        H0 = orth.hermitenorm(0)
+        H1 = orth.hermitenorm(1)
+        H2 = orth.hermitenorm(2)
+        H3 = orth.hermitenorm(3)
+        H4 = orth.hermitenorm(4)
+        H5 = orth.hermitenorm(5)
+        he0 = orth.hermite(0)(psub)
+        he1 = orth.hermite(1)(psub) / sqrt(2)
+        he2 = orth.hermite(2)(psub) / 2.0
+        he3 = orth.hermite(3)(psub) / (2*sqrt(2))
+        he4 = orth.hermite(4)(psub) / 4.0
+        he5 = orth.hermite(5)(psub) / (4.0*sqrt(2))
+
+        assert_allclose(H0.c, he0.c, atol=1.5e-13, rtol=0)
+        assert_allclose(H1.c, he1.c, atol=1.5e-13, rtol=0)
+        assert_allclose(H2.c, he2.c, atol=1.5e-13, rtol=0)
+        assert_allclose(H3.c, he3.c, atol=1.5e-13, rtol=0)
+        assert_allclose(H4.c, he4.c, atol=1.5e-13, rtol=0)
+        assert_allclose(H5.c, he5.c, atol=1.5e-13, rtol=0)
+
+
+class TestShLegendre:
+    def test_sh_legendre(self):
+        # P*_n(x) = P_n(2x-1)
+        psub = np.poly1d([2,-1])
+        Ps0 = orth.sh_legendre(0)
+        Ps1 = orth.sh_legendre(1)
+        Ps2 = orth.sh_legendre(2)
+        Ps3 = orth.sh_legendre(3)
+        Ps4 = orth.sh_legendre(4)
+        Ps5 = orth.sh_legendre(5)
+        pse0 = orth.legendre(0)(psub)
+        pse1 = orth.legendre(1)(psub)
+        pse2 = orth.legendre(2)(psub)
+        pse3 = orth.legendre(3)(psub)
+        pse4 = orth.legendre(4)(psub)
+        pse5 = orth.legendre(5)(psub)
+        assert_allclose(Ps0.c, pse0.c, atol=1.5e-13, rtol=0)
+        assert_allclose(Ps1.c, pse1.c, atol=1.5e-13, rtol=0)
+        assert_allclose(Ps2.c, pse2.c, atol=1.5e-13, rtol=0)
+        assert_allclose(Ps3.c, pse3.c, atol=1.5e-13, rtol=0)
+        assert_allclose(Ps4.c, pse4.c, atol=1.5e-12, rtol=0)
+        assert_allclose(Ps5.c, pse5.c, atol=1.5e-12, rtol=0)
+
+
+class TestShChebyt:
+    def test_sh_chebyt(self):
+        # T*_n(x) = T_n(2x-1)
+        psub = np.poly1d([2,-1])
+        Ts0 = orth.sh_chebyt(0)
+        Ts1 = orth.sh_chebyt(1)
+        Ts2 = orth.sh_chebyt(2)
+        Ts3 = orth.sh_chebyt(3)
+        Ts4 = orth.sh_chebyt(4)
+        Ts5 = orth.sh_chebyt(5)
+        tse0 = orth.chebyt(0)(psub)
+        tse1 = orth.chebyt(1)(psub)
+        tse2 = orth.chebyt(2)(psub)
+        tse3 = orth.chebyt(3)(psub)
+        tse4 = orth.chebyt(4)(psub)
+        tse5 = orth.chebyt(5)(psub)
+        assert_allclose(Ts0.c, tse0.c, atol=1.5e-13, rtol=0)
+        assert_allclose(Ts1.c, tse1.c, atol=1.5e-13, rtol=0)
+        assert_allclose(Ts2.c, tse2.c, atol=1.5e-13, rtol=0)
+        assert_allclose(Ts3.c, tse3.c, atol=1.5e-13, rtol=0)
+        assert_allclose(Ts4.c, tse4.c, atol=1.5e-12, rtol=0)
+        assert_allclose(Ts5.c, tse5.c, atol=1.5e-12, rtol=0)
+
+
+class TestShChebyu:
+    def test_sh_chebyu(self):
+        # U*_n(x) = U_n(2x-1)
+        psub = np.poly1d([2,-1])
+        Us0 = orth.sh_chebyu(0)
+        Us1 = orth.sh_chebyu(1)
+        Us2 = orth.sh_chebyu(2)
+        Us3 = orth.sh_chebyu(3)
+        Us4 = orth.sh_chebyu(4)
+        Us5 = orth.sh_chebyu(5)
+        use0 = orth.chebyu(0)(psub)
+        use1 = orth.chebyu(1)(psub)
+        use2 = orth.chebyu(2)(psub)
+        use3 = orth.chebyu(3)(psub)
+        use4 = orth.chebyu(4)(psub)
+        use5 = orth.chebyu(5)(psub)
+        assert_allclose(Us0.c, use0.c, atol=1.5e-13, rtol=0)
+        assert_allclose(Us1.c, use1.c, atol=1.5e-13, rtol=0)
+        assert_allclose(Us2.c, use2.c, atol=1.5e-13, rtol=0)
+        assert_allclose(Us3.c, use3.c, atol=1.5e-13, rtol=0)
+        assert_allclose(Us4.c, use4.c, atol=1.5e-12, rtol=0)
+        assert_allclose(Us5.c, use5.c, atol=1.5e-11, rtol=0)
+
+
+class TestShJacobi:
+    def test_sh_jacobi(self):
+        # G^(p,q)_n(x) = n! gamma(n+p)/gamma(2*n+p) * P^(p-q,q-1)_n(2*x-1)
+        def conv(n, p):
+            return gamma(n + 1) * gamma(n + p) / gamma(2 * n + p)
+        psub = np.poly1d([2,-1])
+        q = 4 * np.random.random()
+        p = q-1 + 2*np.random.random()
+        # print("shifted jacobi p,q = ", p, q)
+        G0 = orth.sh_jacobi(0,p,q)
+        G1 = orth.sh_jacobi(1,p,q)
+        G2 = orth.sh_jacobi(2,p,q)
+        G3 = orth.sh_jacobi(3,p,q)
+        G4 = orth.sh_jacobi(4,p,q)
+        G5 = orth.sh_jacobi(5,p,q)
+        ge0 = orth.jacobi(0,p-q,q-1)(psub) * conv(0,p)
+        ge1 = orth.jacobi(1,p-q,q-1)(psub) * conv(1,p)
+        ge2 = orth.jacobi(2,p-q,q-1)(psub) * conv(2,p)
+        ge3 = orth.jacobi(3,p-q,q-1)(psub) * conv(3,p)
+        ge4 = orth.jacobi(4,p-q,q-1)(psub) * conv(4,p)
+        ge5 = orth.jacobi(5,p-q,q-1)(psub) * conv(5,p)
+
+        assert_allclose(G0.c, ge0.c, atol=1.5e-13, rtol=0)
+        assert_allclose(G1.c, ge1.c, atol=1.5e-13, rtol=0)
+        assert_allclose(G2.c, ge2.c, atol=1.5e-13, rtol=0)
+        assert_allclose(G3.c, ge3.c, atol=1.5e-13, rtol=0)
+        assert_allclose(G4.c, ge4.c, atol=1.5e-13, rtol=0)
+        assert_allclose(G5.c, ge5.c, atol=1.5e-13, rtol=0)
+
+
+class TestCall:
+    def test_call(self):
+        poly = []
+        for n in range(5):
+            poly.extend([x.strip() for x in
+                (f"""
+                orth.jacobi({n},0.3,0.9)
+                orth.sh_jacobi({n},0.3,0.9)
+                orth.genlaguerre({n},0.3)
+                orth.laguerre({n})
+                orth.hermite({n})
+                orth.hermitenorm({n})
+                orth.gegenbauer({n},0.3)
+                orth.chebyt({n})
+                orth.chebyu({n})
+                orth.chebyc({n})
+                orth.chebys({n})
+                orth.sh_chebyt({n})
+                orth.sh_chebyu({n})
+                orth.legendre({n})
+                orth.sh_legendre({n})
+                """).split()])
+        with np.errstate(all='ignore'):
+            for pstr in poly:
+                p = eval(pstr)
+                assert_allclose(p(0.315), np.poly1d(p.coef)(0.315),
+                                atol=1.5e-7, rtol=0, err_msg=pstr)
+
+
+class TestGenlaguerre:
+    def test_regression(self):
+        assert_equal(orth.genlaguerre(1, 1, monic=False)(0), 2.)
+        assert_equal(orth.genlaguerre(1, 1, monic=True)(0), -2.)
+        assert_equal(orth.genlaguerre(1, 1, monic=False), np.poly1d([-1, 2]))
+        assert_equal(orth.genlaguerre(1, 1, monic=True), np.poly1d([1, -2]))
+
+
+def verify_gauss_quad(root_func, eval_func, weight_func, a, b, N,
+                      rtol=1e-15, atol=5e-14):
+    # this test is copied from numpy's TestGauss in test_hermite.py
+    x, w, mu = root_func(N, True)
+
+    n = np.arange(N, dtype=np.dtype("long"))
+    v = eval_func(n[:,np.newaxis], x)
+    vv = np.dot(v*w, v.T)
+    vd = 1 / np.sqrt(vv.diagonal())
+    vv = vd[:, np.newaxis] * vv * vd
+    assert_allclose(vv, np.eye(N), rtol, atol)
+
+    # check that the integral of 1 is correct
+    assert_allclose(w.sum(), mu, rtol, atol)
+
+    # compare the results of integrating a function with quad.
+    def f(x):
+        return x ** 3 - 3 * x ** 2 + x - 2
+    resI = integrate.quad(lambda x: f(x)*weight_func(x), a, b)
+    resG = np.vdot(f(x), w)
+    rtol = 1e-6 if 1e-6 < resI[1] else resI[1] * 10
+    assert_allclose(resI[0], resG, rtol=rtol)
+
+def test_roots_jacobi():
+    def rf(a, b):
+        return lambda n, mu: sc.roots_jacobi(n, a, b, mu)
+    def ef(a, b):
+        return lambda n, x: sc.eval_jacobi(n, a, b, x)
+    def wf(a, b):
+        return lambda x: (1 - x) ** a * (1 + x) ** b
+
+    vgq = verify_gauss_quad
+    vgq(rf(-0.5, -0.75), ef(-0.5, -0.75), wf(-0.5, -0.75), -1., 1., 5)
+    vgq(rf(-0.5, -0.75), ef(-0.5, -0.75), wf(-0.5, -0.75), -1., 1.,
+        25, atol=1e-12)
+    vgq(rf(-0.5, -0.75), ef(-0.5, -0.75), wf(-0.5, -0.75), -1., 1.,
+        100, atol=1e-11)
+
+    vgq(rf(0.5, -0.5), ef(0.5, -0.5), wf(0.5, -0.5), -1., 1., 5)
+    vgq(rf(0.5, -0.5), ef(0.5, -0.5), wf(0.5, -0.5), -1., 1., 25, atol=1.5e-13)
+    vgq(rf(0.5, -0.5), ef(0.5, -0.5), wf(0.5, -0.5), -1., 1., 100, atol=2e-12)
+
+    vgq(rf(1, 0.5), ef(1, 0.5), wf(1, 0.5), -1., 1., 5, atol=2e-13)
+    vgq(rf(1, 0.5), ef(1, 0.5), wf(1, 0.5), -1., 1., 25, atol=2e-13)
+    vgq(rf(1, 0.5), ef(1, 0.5), wf(1, 0.5), -1., 1., 100, atol=1e-12)
+
+    vgq(rf(0.9, 2), ef(0.9, 2), wf(0.9, 2), -1., 1., 5)
+    vgq(rf(0.9, 2), ef(0.9, 2), wf(0.9, 2), -1., 1., 25, atol=1e-13)
+    vgq(rf(0.9, 2), ef(0.9, 2), wf(0.9, 2), -1., 1., 100, atol=3e-13)
+
+    vgq(rf(18.24, 27.3), ef(18.24, 27.3), wf(18.24, 27.3), -1., 1., 5)
+    vgq(rf(18.24, 27.3), ef(18.24, 27.3), wf(18.24, 27.3), -1., 1., 25,
+        atol=1.1e-14)
+    vgq(rf(18.24, 27.3), ef(18.24, 27.3), wf(18.24, 27.3), -1., 1.,
+        100, atol=1e-13)
+
+    vgq(rf(47.1, -0.2), ef(47.1, -0.2), wf(47.1, -0.2), -1., 1., 5, atol=1e-13)
+    vgq(rf(47.1, -0.2), ef(47.1, -0.2), wf(47.1, -0.2), -1., 1., 25, atol=2e-13)
+    vgq(rf(47.1, -0.2), ef(47.1, -0.2), wf(47.1, -0.2), -1., 1.,
+        100, atol=1e-11)
+
+    vgq(rf(1., 658.), ef(1., 658.), wf(1., 658.), -1., 1., 5, atol=2e-13)
+    vgq(rf(1., 658.), ef(1., 658.), wf(1., 658.), -1., 1., 25, atol=1e-12)
+    vgq(rf(1., 658.), ef(1., 658.), wf(1., 658.), -1., 1., 100, atol=1e-11)
+    vgq(rf(1., 658.), ef(1., 658.), wf(1., 658.), -1., 1., 250, atol=1e-11)
+
+    vgq(rf(511., 511.), ef(511., 511.), wf(511., 511.), -1., 1., 5,
+        atol=1e-12)
+    vgq(rf(511., 511.), ef(511., 511.), wf(511., 511.), -1., 1., 25,
+        atol=1e-11)
+    vgq(rf(511., 511.), ef(511., 511.), wf(511., 511.), -1., 1., 100,
+        atol=1e-10)
+
+    vgq(rf(511., 512.), ef(511., 512.), wf(511., 512.), -1., 1., 5,
+        atol=1e-12)
+    vgq(rf(511., 512.), ef(511., 512.), wf(511., 512.), -1., 1., 25,
+        atol=1e-11)
+    vgq(rf(511., 512.), ef(511., 512.), wf(511., 512.), -1., 1., 100,
+        atol=1e-10)
+
+    vgq(rf(1000., 500.), ef(1000., 500.), wf(1000., 500.), -1., 1., 5,
+        atol=1e-12)
+    vgq(rf(1000., 500.), ef(1000., 500.), wf(1000., 500.), -1., 1., 25,
+        atol=1e-11)
+    vgq(rf(1000., 500.), ef(1000., 500.), wf(1000., 500.), -1., 1., 100,
+        atol=1e-10)
+
+    vgq(rf(2.25, 68.9), ef(2.25, 68.9), wf(2.25, 68.9), -1., 1., 5)
+    vgq(rf(2.25, 68.9), ef(2.25, 68.9), wf(2.25, 68.9), -1., 1., 25,
+        atol=1e-13)
+    vgq(rf(2.25, 68.9), ef(2.25, 68.9), wf(2.25, 68.9), -1., 1., 100,
+        atol=1e-13)
+
+    # when alpha == beta == 0, P_n^{a,b}(x) == P_n(x)
+    xj, wj = sc.roots_jacobi(6, 0.0, 0.0)
+    xl, wl = sc.roots_legendre(6)
+    assert_allclose(xj, xl, 1e-14, 1e-14)
+    assert_allclose(wj, wl, 1e-14, 1e-14)
+
+    # when alpha == beta != 0, P_n^{a,b}(x) == C_n^{alpha+0.5}(x)
+    xj, wj = sc.roots_jacobi(6, 4.0, 4.0)
+    xc, wc = sc.roots_gegenbauer(6, 4.5)
+    assert_allclose(xj, xc, 1e-14, 1e-14)
+    assert_allclose(wj, wc, 1e-14, 1e-14)
+
+    x, w = sc.roots_jacobi(5, 2, 3, False)
+    y, v, m = sc.roots_jacobi(5, 2, 3, True)
+    assert_allclose(x, y, 1e-14, 1e-14)
+    assert_allclose(w, v, 1e-14, 1e-14)
+
+    muI, muI_err = integrate.quad(wf(2,3), -1, 1)
+    assert_allclose(m, muI, rtol=muI_err)
+
+    assert_raises(ValueError, sc.roots_jacobi, 0, 1, 1)
+    assert_raises(ValueError, sc.roots_jacobi, 3.3, 1, 1)  # type: ignore[call-overload]
+    assert_raises(ValueError, sc.roots_jacobi, 3, -2, 1)
+    assert_raises(ValueError, sc.roots_jacobi, 3, 1, -2)
+    assert_raises(ValueError, sc.roots_jacobi, 3, -2, -2)
+
+def test_roots_sh_jacobi():
+    def rf(a, b):
+        return lambda n, mu: sc.roots_sh_jacobi(n, a, b, mu)
+    def ef(a, b):
+        return lambda n, x: sc.eval_sh_jacobi(n, a, b, x)
+    def wf(a, b):
+        return lambda x: (1.0 - x) ** (a - b) * x ** (b - 1.0)
+
+    vgq = verify_gauss_quad
+    vgq(rf(-0.5, 0.25), ef(-0.5, 0.25), wf(-0.5, 0.25), 0., 1., 5)
+    vgq(rf(-0.5, 0.25), ef(-0.5, 0.25), wf(-0.5, 0.25), 0., 1.,
+        25, atol=1e-12)
+    vgq(rf(-0.5, 0.25), ef(-0.5, 0.25), wf(-0.5, 0.25), 0., 1.,
+        100, atol=1e-11)
+
+    vgq(rf(0.5, 0.5), ef(0.5, 0.5), wf(0.5, 0.5), 0., 1., 5)
+    vgq(rf(0.5, 0.5), ef(0.5, 0.5), wf(0.5, 0.5), 0., 1., 25, atol=1e-13)
+    vgq(rf(0.5, 0.5), ef(0.5, 0.5), wf(0.5, 0.5), 0., 1., 100, atol=1e-12)
+
+    vgq(rf(1, 0.5), ef(1, 0.5), wf(1, 0.5), 0., 1., 5)
+    vgq(rf(1, 0.5), ef(1, 0.5), wf(1, 0.5), 0., 1., 25, atol=1.5e-13)
+    vgq(rf(1, 0.5), ef(1, 0.5), wf(1, 0.5), 0., 1., 100, atol=2e-12)
+
+    vgq(rf(2, 0.9), ef(2, 0.9), wf(2, 0.9), 0., 1., 5)
+    vgq(rf(2, 0.9), ef(2, 0.9), wf(2, 0.9), 0., 1., 25, atol=1e-13)
+    vgq(rf(2, 0.9), ef(2, 0.9), wf(2, 0.9), 0., 1., 100, atol=1e-12)
+
+    vgq(rf(27.3, 18.24), ef(27.3, 18.24), wf(27.3, 18.24), 0., 1., 5)
+    vgq(rf(27.3, 18.24), ef(27.3, 18.24), wf(27.3, 18.24), 0., 1., 25)
+    vgq(rf(27.3, 18.24), ef(27.3, 18.24), wf(27.3, 18.24), 0., 1.,
+        100, atol=1e-13)
+
+    vgq(rf(47.1, 0.2), ef(47.1, 0.2), wf(47.1, 0.2), 0., 1., 5, atol=1e-12)
+    vgq(rf(47.1, 0.2), ef(47.1, 0.2), wf(47.1, 0.2), 0., 1., 25, atol=1e-11)
+    vgq(rf(47.1, 0.2), ef(47.1, 0.2), wf(47.1, 0.2), 0., 1., 100, atol=1e-10)
+
+    vgq(rf(68.9, 2.25), ef(68.9, 2.25), wf(68.9, 2.25), 0., 1., 5, atol=3.5e-14)
+    vgq(rf(68.9, 2.25), ef(68.9, 2.25), wf(68.9, 2.25), 0., 1., 25, atol=2e-13)
+    vgq(rf(68.9, 2.25), ef(68.9, 2.25), wf(68.9, 2.25), 0., 1.,
+        100, atol=1e-12)
+
+    x, w = sc.roots_sh_jacobi(5, 3, 2, False)
+    y, v, m = sc.roots_sh_jacobi(5, 3, 2, True)
+    assert_allclose(x, y, 1e-14, 1e-14)
+    assert_allclose(w, v, 1e-14, 1e-14)
+
+    muI, muI_err = integrate.quad(wf(3,2), 0, 1)
+    assert_allclose(m, muI, rtol=muI_err)
+
+    assert_raises(ValueError, sc.roots_sh_jacobi, 0, 1, 1)
+    assert_raises(ValueError, sc.roots_sh_jacobi, 3.3, 1, 1)  # type: ignore[call-overload]
+    assert_raises(ValueError, sc.roots_sh_jacobi, 3, 1, 2)    # p - q <= -1
+    assert_raises(ValueError, sc.roots_sh_jacobi, 3, 2, -1)   # q <= 0
+    assert_raises(ValueError, sc.roots_sh_jacobi, 3, -2, -1)  # both
+
+def test_roots_hermite():
+    rootf = sc.roots_hermite
+    evalf = sc.eval_hermite
+    weightf = orth.hermite(5).weight_func
+
+    verify_gauss_quad(rootf, evalf, weightf, -np.inf, np.inf, 5)
+    verify_gauss_quad(rootf, evalf, weightf, -np.inf, np.inf, 25, atol=1e-13)
+    verify_gauss_quad(rootf, evalf, weightf, -np.inf, np.inf, 100, atol=1e-12)
+
+    # Golub-Welsch branch
+    x, w = sc.roots_hermite(5, False)
+    y, v, m = sc.roots_hermite(5, True)
+    assert_allclose(x, y, 1e-14, 1e-14)
+    assert_allclose(w, v, 1e-14, 1e-14)
+
+    muI, muI_err = integrate.quad(weightf, -np.inf, np.inf)
+    assert_allclose(m, muI, rtol=muI_err)
+
+    # Asymptotic branch (switch over at n >= 150)
+    x, w = sc.roots_hermite(200, False)
+    y, v, m = sc.roots_hermite(200, True)
+    assert_allclose(x, y, 1e-14, 1e-14)
+    assert_allclose(w, v, 1e-14, 1e-14)
+    assert_allclose(sum(v), m, 1e-14, 1e-14)
+
+    assert_raises(ValueError, sc.roots_hermite, 0)
+    assert_raises(ValueError, sc.roots_hermite, 3.3)  # type: ignore[call-overload]
+
+def test_roots_hermite_asy():
+    # Recursion for Hermite functions
+    def hermite_recursion(n, nodes):
+        H = np.zeros((n, nodes.size))
+        H[0,:] = np.pi**(-0.25) * np.exp(-0.5*nodes**2)
+        if n > 1:
+            H[1,:] = sqrt(2.0) * nodes * H[0,:]
+            for k in range(2, n):
+                H[k,:] = sqrt(2.0/k) * nodes * H[k-1,:] - sqrt((k-1.0)/k) * H[k-2,:]
+        return H
+
+    # This tests only the nodes
+    def test(N, rtol=1e-15, atol=1e-14):
+        x, w = orth._roots_hermite_asy(N)
+        H = hermite_recursion(N+1, x)
+        assert_allclose(H[-1,:], np.zeros(N), rtol, atol)
+        assert_allclose(sum(w), sqrt(np.pi), rtol, atol)
+
+    test(150, atol=1e-12)
+    test(151, atol=1e-12)
+    test(300, atol=1e-12)
+    test(301, atol=1e-12)
+    test(500, atol=1e-12)
+    test(501, atol=1e-12)
+    test(999, atol=1e-12)
+    test(1000, atol=1e-12)
+    test(2000, atol=1e-12)
+    test(5000, atol=1e-12)
+
+def test_roots_hermitenorm():
+    rootf = sc.roots_hermitenorm
+    evalf = sc.eval_hermitenorm
+    weightf = orth.hermitenorm(5).weight_func
+
+    verify_gauss_quad(rootf, evalf, weightf, -np.inf, np.inf, 5)
+    verify_gauss_quad(rootf, evalf, weightf, -np.inf, np.inf, 25, atol=1e-13)
+    verify_gauss_quad(rootf, evalf, weightf, -np.inf, np.inf, 100, atol=1e-12)
+
+    x, w = sc.roots_hermitenorm(5, False)
+    y, v, m = sc.roots_hermitenorm(5, True)
+    assert_allclose(x, y, 1e-14, 1e-14)
+    assert_allclose(w, v, 1e-14, 1e-14)
+
+    muI, muI_err = integrate.quad(weightf, -np.inf, np.inf)
+    assert_allclose(m, muI, rtol=muI_err)
+
+    assert_raises(ValueError, sc.roots_hermitenorm, 0)
+    assert_raises(ValueError, sc.roots_hermitenorm, 3.3)  # type: ignore[call-overload]
+
+def test_roots_gegenbauer():
+    def rootf(a):
+        return lambda n, mu: sc.roots_gegenbauer(n, a, mu)
+    def evalf(a):
+        return lambda n, x: sc.eval_gegenbauer(n, a, x)
+    def weightf(a):
+        return lambda x: (1 - x ** 2) ** (a - 0.5)
+
+    vgq = verify_gauss_quad
+    vgq(rootf(-0.25), evalf(-0.25), weightf(-0.25), -1., 1., 5)
+    vgq(rootf(-0.25), evalf(-0.25), weightf(-0.25), -1., 1., 25, atol=1e-12)
+    vgq(rootf(-0.25), evalf(-0.25), weightf(-0.25), -1., 1., 100, atol=1e-11)
+
+    vgq(rootf(0.1), evalf(0.1), weightf(0.1), -1., 1., 5)
+    vgq(rootf(0.1), evalf(0.1), weightf(0.1), -1., 1., 25, atol=1e-13)
+    vgq(rootf(0.1), evalf(0.1), weightf(0.1), -1., 1., 100, atol=1e-12)
+
+    vgq(rootf(1), evalf(1), weightf(1), -1., 1., 5)
+    vgq(rootf(1), evalf(1), weightf(1), -1., 1., 25, atol=1e-13)
+    vgq(rootf(1), evalf(1), weightf(1), -1., 1., 100, atol=1e-12)
+
+    vgq(rootf(10), evalf(10), weightf(10), -1., 1., 5)
+    vgq(rootf(10), evalf(10), weightf(10), -1., 1., 25, atol=1e-13)
+    vgq(rootf(10), evalf(10), weightf(10), -1., 1., 100, atol=1e-12)
+
+    vgq(rootf(50), evalf(50), weightf(50), -1., 1., 5, atol=1e-13)
+    vgq(rootf(50), evalf(50), weightf(50), -1., 1., 25, atol=1e-12)
+    vgq(rootf(50), evalf(50), weightf(50), -1., 1., 100, atol=1e-11)
+
+    # Alpha=170 is where the approximation used in roots_gegenbauer changes
+    vgq(rootf(170), evalf(170), weightf(170), -1., 1., 5, atol=1e-13)
+    vgq(rootf(170), evalf(170), weightf(170), -1., 1., 25, atol=1e-12)
+    vgq(rootf(170), evalf(170), weightf(170), -1., 1., 100, atol=1e-11)
+    vgq(rootf(170.5), evalf(170.5), weightf(170.5), -1., 1., 5, atol=1.25e-13)
+    vgq(rootf(170.5), evalf(170.5), weightf(170.5), -1., 1., 25, atol=1e-12)
+    vgq(rootf(170.5), evalf(170.5), weightf(170.5), -1., 1., 100, atol=1e-11)
+
+    # Test for failures, e.g. overflows, resulting from large alphas
+    vgq(rootf(238), evalf(238), weightf(238), -1., 1., 5, atol=1e-13)
+    vgq(rootf(238), evalf(238), weightf(238), -1., 1., 25, atol=1e-12)
+    vgq(rootf(238), evalf(238), weightf(238), -1., 1., 100, atol=1e-11)
+    vgq(rootf(512.5), evalf(512.5), weightf(512.5), -1., 1., 5, atol=1e-12)
+    vgq(rootf(512.5), evalf(512.5), weightf(512.5), -1., 1., 25, atol=1e-11)
+    vgq(rootf(512.5), evalf(512.5), weightf(512.5), -1., 1., 100, atol=1e-10)
+
+    # this is a special case that the old code supported.
+    # when alpha = 0, the gegenbauer polynomial is uniformly 0. but it goes
+    # to a scaled down copy of T_n(x) there.
+    vgq(rootf(0), sc.eval_chebyt, weightf(0), -1., 1., 5)
+    vgq(rootf(0), sc.eval_chebyt, weightf(0), -1., 1., 25)
+    vgq(rootf(0), sc.eval_chebyt, weightf(0), -1., 1., 100, atol=1e-12)
+
+    x, w = sc.roots_gegenbauer(5, 2, False)
+    y, v, m = sc.roots_gegenbauer(5, 2, True)
+    assert_allclose(x, y, 1e-14, 1e-14)
+    assert_allclose(w, v, 1e-14, 1e-14)
+
+    muI, muI_err = integrate.quad(weightf(2), -1, 1)
+    assert_allclose(m, muI, rtol=muI_err)
+
+    assert_raises(ValueError, sc.roots_gegenbauer, 0, 2)
+    assert_raises(ValueError, sc.roots_gegenbauer, 3.3, 2)  # type: ignore[call-overload]
+    assert_raises(ValueError, sc.roots_gegenbauer, 3, -.75)
+
+def test_roots_chebyt():
+    weightf = orth.chebyt(5).weight_func
+    verify_gauss_quad(sc.roots_chebyt, sc.eval_chebyt, weightf, -1., 1., 5)
+    verify_gauss_quad(sc.roots_chebyt, sc.eval_chebyt, weightf, -1., 1., 25)
+    verify_gauss_quad(sc.roots_chebyt, sc.eval_chebyt, weightf, -1., 1., 100,
+                      atol=1e-12)
+
+    x, w = sc.roots_chebyt(5, False)
+    y, v, m = sc.roots_chebyt(5, True)
+    assert_allclose(x, y, 1e-14, 1e-14)
+    assert_allclose(w, v, 1e-14, 1e-14)
+
+    muI, muI_err = integrate.quad(weightf, -1, 1)
+    assert_allclose(m, muI, rtol=muI_err)
+
+    assert_raises(ValueError, sc.roots_chebyt, 0)
+    assert_raises(ValueError, sc.roots_chebyt, 3.3)  # type: ignore[call-overload]
+
+def test_chebyt_symmetry():
+    x, w = sc.roots_chebyt(21)
+    pos, neg = x[:10], x[11:]
+    assert_equal(neg, -pos[::-1])
+    assert_equal(x[10], 0)
+
+def test_roots_chebyu():
+    weightf = orth.chebyu(5).weight_func
+    verify_gauss_quad(sc.roots_chebyu, sc.eval_chebyu, weightf, -1., 1., 5)
+    verify_gauss_quad(sc.roots_chebyu, sc.eval_chebyu, weightf, -1., 1., 25)
+    verify_gauss_quad(sc.roots_chebyu, sc.eval_chebyu, weightf, -1., 1., 100)
+
+    x, w = sc.roots_chebyu(5, False)
+    y, v, m = sc.roots_chebyu(5, True)
+    assert_allclose(x, y, 1e-14, 1e-14)
+    assert_allclose(w, v, 1e-14, 1e-14)
+
+    muI, muI_err = integrate.quad(weightf, -1, 1)
+    assert_allclose(m, muI, rtol=muI_err)
+
+    assert_raises(ValueError, sc.roots_chebyu, 0)
+    assert_raises(ValueError, sc.roots_chebyu, 3.3)  # type: ignore[call-overload]
+
+def test_roots_chebyc():
+    weightf = orth.chebyc(5).weight_func
+    verify_gauss_quad(sc.roots_chebyc, sc.eval_chebyc, weightf, -2., 2., 5)
+    verify_gauss_quad(sc.roots_chebyc, sc.eval_chebyc, weightf, -2., 2., 25)
+    verify_gauss_quad(sc.roots_chebyc, sc.eval_chebyc, weightf, -2., 2., 100,
+                      atol=1e-12)
+
+    x, w = sc.roots_chebyc(5, False)
+    y, v, m = sc.roots_chebyc(5, True)
+    assert_allclose(x, y, 1e-14, 1e-14)
+    assert_allclose(w, v, 1e-14, 1e-14)
+
+    muI, muI_err = integrate.quad(weightf, -2, 2)
+    assert_allclose(m, muI, rtol=muI_err)
+
+    assert_raises(ValueError, sc.roots_chebyc, 0)
+    assert_raises(ValueError, sc.roots_chebyc, 3.3)  # type: ignore[call-overload]
+
+def test_roots_chebys():
+    weightf = orth.chebys(5).weight_func
+    verify_gauss_quad(sc.roots_chebys, sc.eval_chebys, weightf, -2., 2., 5)
+    verify_gauss_quad(sc.roots_chebys, sc.eval_chebys, weightf, -2., 2., 25)
+    verify_gauss_quad(sc.roots_chebys, sc.eval_chebys, weightf, -2., 2., 100)
+
+    x, w = sc.roots_chebys(5, False)
+    y, v, m = sc.roots_chebys(5, True)
+    assert_allclose(x, y, 1e-14, 1e-14)
+    assert_allclose(w, v, 1e-14, 1e-14)
+
+    muI, muI_err = integrate.quad(weightf, -2, 2)
+    assert_allclose(m, muI, rtol=muI_err)
+
+    assert_raises(ValueError, sc.roots_chebys, 0)
+    assert_raises(ValueError, sc.roots_chebys, 3.3)  # type: ignore[call-overload]
+
+def test_roots_sh_chebyt():
+    weightf = orth.sh_chebyt(5).weight_func
+    verify_gauss_quad(sc.roots_sh_chebyt, sc.eval_sh_chebyt, weightf, 0., 1., 5)
+    verify_gauss_quad(sc.roots_sh_chebyt, sc.eval_sh_chebyt, weightf, 0., 1., 25)
+    verify_gauss_quad(sc.roots_sh_chebyt, sc.eval_sh_chebyt, weightf, 0., 1.,
+                      100, atol=1e-13)
+
+    x, w = sc.roots_sh_chebyt(5, False)
+    y, v, m = sc.roots_sh_chebyt(5, True)
+    assert_allclose(x, y, 1e-14, 1e-14)
+    assert_allclose(w, v, 1e-14, 1e-14)
+
+    muI, muI_err = integrate.quad(weightf, 0, 1)
+    assert_allclose(m, muI, rtol=muI_err)
+
+    assert_raises(ValueError, sc.roots_sh_chebyt, 0)
+    assert_raises(ValueError, sc.roots_sh_chebyt, 3.3)  # type: ignore[call-overload]
+
+def test_roots_sh_chebyu():
+    weightf = orth.sh_chebyu(5).weight_func
+    verify_gauss_quad(sc.roots_sh_chebyu, sc.eval_sh_chebyu, weightf, 0., 1., 5)
+    verify_gauss_quad(sc.roots_sh_chebyu, sc.eval_sh_chebyu, weightf, 0., 1., 25)
+    verify_gauss_quad(sc.roots_sh_chebyu, sc.eval_sh_chebyu, weightf, 0., 1.,
+                      100, atol=1e-13)
+
+    x, w = sc.roots_sh_chebyu(5, False)
+    y, v, m = sc.roots_sh_chebyu(5, True)
+    assert_allclose(x, y, 1e-14, 1e-14)
+    assert_allclose(w, v, 1e-14, 1e-14)
+
+    muI, muI_err = integrate.quad(weightf, 0, 1)
+    assert_allclose(m, muI, rtol=muI_err)
+
+    assert_raises(ValueError, sc.roots_sh_chebyu, 0)
+    assert_raises(ValueError, sc.roots_sh_chebyu, 3.3)  # type: ignore[call-overload]
+
+def test_roots_legendre():
+    weightf = orth.legendre(5).weight_func
+    verify_gauss_quad(sc.roots_legendre, sc.eval_legendre, weightf, -1., 1., 5)
+    verify_gauss_quad(sc.roots_legendre, sc.eval_legendre, weightf, -1., 1.,
+                      25, atol=1e-13)
+    verify_gauss_quad(sc.roots_legendre, sc.eval_legendre, weightf, -1., 1.,
+                      100, atol=1e-12)
+
+    x, w = sc.roots_legendre(5, False)
+    y, v, m = sc.roots_legendre(5, True)
+    assert_allclose(x, y, 1e-14, 1e-14)
+    assert_allclose(w, v, 1e-14, 1e-14)
+
+    muI, muI_err = integrate.quad(weightf, -1, 1)
+    assert_allclose(m, muI, rtol=muI_err)
+
+    assert_raises(ValueError, sc.roots_legendre, 0)
+    assert_raises(ValueError, sc.roots_legendre, 3.3)  # type: ignore[call-overload]
+
+def test_roots_sh_legendre():
+    weightf = orth.sh_legendre(5).weight_func
+    verify_gauss_quad(sc.roots_sh_legendre, sc.eval_sh_legendre, weightf, 0., 1., 5)
+    verify_gauss_quad(sc.roots_sh_legendre, sc.eval_sh_legendre, weightf, 0., 1.,
+                      25, atol=1e-13)
+    verify_gauss_quad(sc.roots_sh_legendre, sc.eval_sh_legendre, weightf, 0., 1.,
+                      100, atol=1e-12)
+
+    x, w = sc.roots_sh_legendre(5, False)
+    y, v, m = sc.roots_sh_legendre(5, True)
+    assert_allclose(x, y, 1e-14, 1e-14)
+    assert_allclose(w, v, 1e-14, 1e-14)
+
+    muI, muI_err = integrate.quad(weightf, 0, 1)
+    assert_allclose(m, muI, rtol=muI_err)
+
+    assert_raises(ValueError, sc.roots_sh_legendre, 0)
+    assert_raises(ValueError, sc.roots_sh_legendre, 3.3)  # type: ignore[call-overload]
+
+def test_roots_laguerre():
+    weightf = orth.laguerre(5).weight_func
+    verify_gauss_quad(sc.roots_laguerre, sc.eval_laguerre, weightf, 0., np.inf, 5)
+    verify_gauss_quad(sc.roots_laguerre, sc.eval_laguerre, weightf, 0., np.inf,
+                      25, atol=1e-13)
+    verify_gauss_quad(sc.roots_laguerre, sc.eval_laguerre, weightf, 0., np.inf,
+                      100, atol=1e-12)
+
+    x, w = sc.roots_laguerre(5, False)
+    y, v, m = sc.roots_laguerre(5, True)
+    assert_allclose(x, y, 1e-14, 1e-14)
+    assert_allclose(w, v, 1e-14, 1e-14)
+
+    muI, muI_err = integrate.quad(weightf, 0, np.inf)
+    assert_allclose(m, muI, rtol=muI_err)
+
+    assert_raises(ValueError, sc.roots_laguerre, 0)
+    assert_raises(ValueError, sc.roots_laguerre, 3.3)  # type: ignore[call-overload]
+
+def test_roots_genlaguerre():
+    def rootf(a):
+        return lambda n, mu: sc.roots_genlaguerre(n, a, mu)
+    def evalf(a):
+        return lambda n, x: sc.eval_genlaguerre(n, a, x)
+    def weightf(a):
+        return lambda x: x ** a * np.exp(-x)
+
+    vgq = verify_gauss_quad
+    vgq(rootf(-0.5), evalf(-0.5), weightf(-0.5), 0., np.inf, 5)
+    vgq(rootf(-0.5), evalf(-0.5), weightf(-0.5), 0., np.inf, 25, atol=1e-13)
+    vgq(rootf(-0.5), evalf(-0.5), weightf(-0.5), 0., np.inf, 100, atol=1e-12)
+
+    vgq(rootf(0.1), evalf(0.1), weightf(0.1), 0., np.inf, 5)
+    vgq(rootf(0.1), evalf(0.1), weightf(0.1), 0., np.inf, 25, atol=1e-13)
+    vgq(rootf(0.1), evalf(0.1), weightf(0.1), 0., np.inf, 100, atol=1.6e-13)
+
+    vgq(rootf(1), evalf(1), weightf(1), 0., np.inf, 5)
+    vgq(rootf(1), evalf(1), weightf(1), 0., np.inf, 25, atol=1e-13)
+    vgq(rootf(1), evalf(1), weightf(1), 0., np.inf, 100, atol=1.03e-13)
+
+    vgq(rootf(10), evalf(10), weightf(10), 0., np.inf, 5)
+    vgq(rootf(10), evalf(10), weightf(10), 0., np.inf, 25, atol=1e-13)
+    vgq(rootf(10), evalf(10), weightf(10), 0., np.inf, 100, atol=1e-12)
+
+    vgq(rootf(50), evalf(50), weightf(50), 0., np.inf, 5)
+    vgq(rootf(50), evalf(50), weightf(50), 0., np.inf, 25, atol=1e-13)
+    vgq(rootf(50), evalf(50), weightf(50), 0., np.inf, 100, rtol=1e-14, atol=2e-13)
+
+    x, w = sc.roots_genlaguerre(5, 2, False)
+    y, v, m = sc.roots_genlaguerre(5, 2, True)
+    assert_allclose(x, y, 1e-14, 1e-14)
+    assert_allclose(w, v, 1e-14, 1e-14)
+
+    muI, muI_err = integrate.quad(weightf(2.), 0., np.inf)
+    assert_allclose(m, muI, rtol=muI_err)
+
+    assert_raises(ValueError, sc.roots_genlaguerre, 0, 2)
+    assert_raises(ValueError, sc.roots_genlaguerre, 3.3, 2)  # type: ignore[call-overload]
+    assert_raises(ValueError, sc.roots_genlaguerre, 3, -1.1)
+
+
+def test_gh_6721():
+    # Regression test for gh_6721. This should not raise.
+    sc.chebyt(65)(0.2)

.venv/lib/python3.12/site-packages/scipy/special/tests/test_orthogonal_eval.py

@@ -0,0 +1,383 @@
+import numpy as np
+from numpy.testing import assert_, assert_allclose
+import pytest
+
+from scipy.special import _ufuncs, gammasgn
+import scipy.special._orthogonal as orth
+from scipy.special._testutils import FuncData
+
+
+def test_eval_chebyt():
+    n = np.arange(0, 10000, 7, dtype=np.dtype("long"))
+    x = 2*np.random.rand() - 1
+    v1 = np.cos(n*np.arccos(x))
+    v2 = _ufuncs.eval_chebyt(n, x)
+    assert_(np.allclose(v1, v2, rtol=1e-15))
+
+
+def test_eval_chebyt_gh20129():
+    # https://github.com/scipy/scipy/issues/20129
+    assert _ufuncs.eval_chebyt(7, 2 + 0j) == 5042.0
+
+
+def test_eval_genlaguerre_restriction():
+    # check it returns nan for alpha <= -1
+    assert_(np.isnan(_ufuncs.eval_genlaguerre(0, -1, 0)))
+    assert_(np.isnan(_ufuncs.eval_genlaguerre(0.1, -1, 0)))
+
+
+def test_warnings():
+    # ticket 1334
+    with np.errstate(all='raise'):
+        # these should raise no fp warnings
+        _ufuncs.eval_legendre(1, 0)
+        _ufuncs.eval_laguerre(1, 1)
+        _ufuncs.eval_gegenbauer(1, 1, 0)
+
+
+class TestPolys:
+    """
+    Check that the eval_* functions agree with the constructed polynomials
+
+    """
+
+    def check_poly(self, func, cls, param_ranges=(), x_range=(), nn=10,
+                   nparam=10, nx=10, rtol=1e-8):
+        rng = np.random.RandomState(1234)
+
+        dataset = []
+        for n in np.arange(nn):
+            params = [a + (b-a)*rng.rand(nparam) for a,b in param_ranges]
+            params = np.asarray(params).T
+            if not param_ranges:
+                params = [0]
+            for p in params:
+                if param_ranges:
+                    p = (n,) + tuple(p)
+                else:
+                    p = (n,)
+                x = x_range[0] + (x_range[1] - x_range[0])*rng.rand(nx)
+                x[0] = x_range[0]  # always include domain start point
+                x[1] = x_range[1]  # always include domain end point
+                poly = np.poly1d(cls(*p).coef)
+                z = np.c_[np.tile(p, (nx,1)), x, poly(x)]
+                dataset.append(z)
+
+        dataset = np.concatenate(dataset, axis=0)
+
+        def polyfunc(*p):
+            p = (p[0].astype(np.dtype("long")),) + p[1:]
+            return func(*p)
+
+        with np.errstate(all='raise'):
+            ds = FuncData(polyfunc, dataset, list(range(len(param_ranges)+2)), -1,
+                          rtol=rtol)
+            ds.check()
+
+    def test_jacobi(self):
+        self.check_poly(_ufuncs.eval_jacobi, orth.jacobi,
+                        param_ranges=[(-0.99, 10), (-0.99, 10)],
+                        x_range=[-1, 1], rtol=1e-5)
+
+    def test_sh_jacobi(self):
+        self.check_poly(_ufuncs.eval_sh_jacobi, orth.sh_jacobi,
+                        param_ranges=[(1, 10), (0, 1)], x_range=[0, 1],
+                        rtol=1e-5)
+
+    def test_gegenbauer(self):
+        self.check_poly(_ufuncs.eval_gegenbauer, orth.gegenbauer,
+                        param_ranges=[(-0.499, 10)], x_range=[-1, 1],
+                        rtol=1e-7)
+
+    def test_chebyt(self):
+        self.check_poly(_ufuncs.eval_chebyt, orth.chebyt,
+                        param_ranges=[], x_range=[-1, 1])
+
+    def test_chebyu(self):
+        self.check_poly(_ufuncs.eval_chebyu, orth.chebyu,
+                        param_ranges=[], x_range=[-1, 1])
+
+    def test_chebys(self):
+        self.check_poly(_ufuncs.eval_chebys, orth.chebys,
+                        param_ranges=[], x_range=[-2, 2])
+
+    def test_chebyc(self):
+        self.check_poly(_ufuncs.eval_chebyc, orth.chebyc,
+                        param_ranges=[], x_range=[-2, 2])
+
+    def test_sh_chebyt(self):
+        with np.errstate(all='ignore'):
+            self.check_poly(_ufuncs.eval_sh_chebyt, orth.sh_chebyt,
+                            param_ranges=[], x_range=[0, 1])
+
+    def test_sh_chebyu(self):
+        self.check_poly(_ufuncs.eval_sh_chebyu, orth.sh_chebyu,
+                        param_ranges=[], x_range=[0, 1])
+
+    def test_legendre(self):
+        self.check_poly(_ufuncs.eval_legendre, orth.legendre,
+                        param_ranges=[], x_range=[-1, 1])
+
+    def test_sh_legendre(self):
+        with np.errstate(all='ignore'):
+            self.check_poly(_ufuncs.eval_sh_legendre, orth.sh_legendre,
+                            param_ranges=[], x_range=[0, 1])
+
+    def test_genlaguerre(self):
+        self.check_poly(_ufuncs.eval_genlaguerre, orth.genlaguerre,
+                        param_ranges=[(-0.99, 10)], x_range=[0, 100])
+
+    def test_laguerre(self):
+        self.check_poly(_ufuncs.eval_laguerre, orth.laguerre,
+                        param_ranges=[], x_range=[0, 100])
+
+    def test_hermite(self):
+        self.check_poly(_ufuncs.eval_hermite, orth.hermite,
+                        param_ranges=[], x_range=[-100, 100])
+
+    def test_hermitenorm(self):
+        self.check_poly(_ufuncs.eval_hermitenorm, orth.hermitenorm,
+                        param_ranges=[], x_range=[-100, 100])
+
+
+class TestRecurrence:
+    """
+    Check that the eval_* functions sig='ld->d' and 'dd->d' agree.
+
+    """
+
+    def check_poly(self, func, param_ranges=(), x_range=(), nn=10,
+                   nparam=10, nx=10, rtol=1e-8):
+        rng = np.random.default_rng(1234)
+
+        dataset = []
+        for n in np.arange(nn):
+            params = [a + (b-a)*rng.random(nparam) for a,b in param_ranges]
+            params = np.asarray(params).T
+            if not param_ranges:
+                params = [0]
+            for p in params:
+                if param_ranges:
+                    p = (n,) + tuple(p)
+                else:
+                    p = (n,)
+                x = x_range[0] + (x_range[1] - x_range[0])*rng.random(nx)
+                x[0] = x_range[0]  # always include domain start point
+                x[1] = x_range[1]  # always include domain end point
+                kw = dict(sig=(len(p)+1)*'d'+'->d')
+                z = np.c_[np.tile(p, (nx,1)), x, func(*(p + (x,)), **kw)]
+                dataset.append(z)
+
+        dataset = np.concatenate(dataset, axis=0)
+
+        def polyfunc(*p):
+            p0 = p[0].astype(np.intp)
+            p = (p0,) + p[1:]
+            p0_type_char = p0.dtype.char
+            kw = dict(sig=p0_type_char + (len(p)-1)*'d' + '->d')
+            return func(*p, **kw)
+
+        with np.errstate(all='raise'):
+            ds = FuncData(polyfunc, dataset, list(range(len(param_ranges)+2)), -1,
+                          rtol=rtol)
+            ds.check()
+
+    def test_jacobi(self):
+        self.check_poly(_ufuncs.eval_jacobi,
+                        param_ranges=[(-0.99, 10), (-0.99, 10)],
+                        x_range=[-1, 1])
+
+    def test_sh_jacobi(self):
+        self.check_poly(_ufuncs.eval_sh_jacobi,
+                        param_ranges=[(1, 10), (0, 1)], x_range=[0, 1])
+
+    def test_gegenbauer(self):
+        self.check_poly(_ufuncs.eval_gegenbauer,
+                        param_ranges=[(-0.499, 10)], x_range=[-1, 1])
+
+    def test_chebyt(self):
+        self.check_poly(_ufuncs.eval_chebyt,
+                        param_ranges=[], x_range=[-1, 1])
+
+    def test_chebyu(self):
+        self.check_poly(_ufuncs.eval_chebyu,
+                        param_ranges=[], x_range=[-1, 1])
+
+    def test_chebys(self):
+        self.check_poly(_ufuncs.eval_chebys,
+                        param_ranges=[], x_range=[-2, 2])
+
+    def test_chebyc(self):
+        self.check_poly(_ufuncs.eval_chebyc,
+                        param_ranges=[], x_range=[-2, 2])
+
+    def test_sh_chebyt(self):
+        self.check_poly(_ufuncs.eval_sh_chebyt,
+                        param_ranges=[], x_range=[0, 1])
+
+    def test_sh_chebyu(self):
+        self.check_poly(_ufuncs.eval_sh_chebyu,
+                        param_ranges=[], x_range=[0, 1])
+
+    def test_legendre(self):
+        self.check_poly(_ufuncs.eval_legendre,
+                        param_ranges=[], x_range=[-1, 1])
+
+    def test_sh_legendre(self):
+        self.check_poly(_ufuncs.eval_sh_legendre,
+                        param_ranges=[], x_range=[0, 1])
+
+    def test_genlaguerre(self):
+        self.check_poly(_ufuncs.eval_genlaguerre,
+                        param_ranges=[(-0.99, 10)], x_range=[0, 100])
+
+    def test_laguerre(self):
+        self.check_poly(_ufuncs.eval_laguerre,
+                        param_ranges=[], x_range=[0, 100])
+
+    def test_hermite(self):
+        v = _ufuncs.eval_hermite(70, 1.0)
+        a = -1.457076485701412e60
+        assert_allclose(v, a)
+
+
+def test_hermite_domain():
+    # Regression test for gh-11091.
+    assert np.isnan(_ufuncs.eval_hermite(-1, 1.0))
+    assert np.isnan(_ufuncs.eval_hermitenorm(-1, 1.0))
+
+
+@pytest.mark.parametrize("n", [0, 1, 2])
+@pytest.mark.parametrize("x", [0, 1, np.nan])
+def test_hermite_nan(n, x):
+    # Regression test for gh-11369.
+    assert np.isnan(_ufuncs.eval_hermite(n, x)) == np.any(np.isnan([n, x]))
+    assert np.isnan(_ufuncs.eval_hermitenorm(n, x)) == np.any(np.isnan([n, x]))
+
+
+@pytest.mark.parametrize('n', [0, 1, 2, 3.2])
+@pytest.mark.parametrize('alpha', [1, np.nan])
+@pytest.mark.parametrize('x', [2, np.nan])
+def test_genlaguerre_nan(n, alpha, x):
+    # Regression test for gh-11361.
+    nan_laguerre = np.isnan(_ufuncs.eval_genlaguerre(n, alpha, x))
+    nan_arg = np.any(np.isnan([n, alpha, x]))
+    assert nan_laguerre == nan_arg
+
+
+@pytest.mark.parametrize('n', [0, 1, 2, 3.2, np.nan])
+@pytest.mark.parametrize('alpha', [0.0, 1, np.nan])
+@pytest.mark.parametrize('x', [1e-6, 2, np.nan])
+def test_gegenbauer_nan(n, alpha, x):
+    # Regression test for gh-11370.
+    nan_gegenbauer = np.isnan(_ufuncs.eval_gegenbauer(n, alpha, x))
+    nan_arg = np.any(np.isnan([n, alpha, x]))
+    assert nan_gegenbauer == nan_arg
+
+@pytest.mark.parametrize("n", np.arange(10))
+@pytest.mark.parametrize("alpha", [-0.45, -0.25, -0.125, 0.0, 0.25, 1.0, 2.0])
+@pytest.mark.parametrize("x", [-np.inf, np.inf])
+def test_gegenbauer_infinity(n, alpha, x):
+    # gh-11713 - check correct handling of x = +inf and x = -inf
+    if alpha == 0.0:
+        expected = 0.0
+    elif n == 0.0:
+        expected = 1.0
+    else:
+        # sign of leading coefficient: 2^n * Gamma(n+alpha) / (n! Gamma(alpha))
+        lead_sign = gammasgn(n + alpha) * gammasgn(alpha)
+        expected = lead_sign * (np.sign(x) ** n) * np.inf
+    assert_allclose(_ufuncs.eval_gegenbauer(int(n), alpha, x), expected, rtol=1e-10)
+    assert_allclose(_ufuncs.eval_gegenbauer(float(n), alpha, x), expected, rtol=1e-10)
+
+@pytest.mark.parametrize(
+    "n, expected",
+    [
+        (0, [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]),
+        (1, [-2.0, -1.8, -1.6, -1.4, -1.2, -1.0, -0.8, -0.6, -0.4, -0.2, 0.0]),
+        (2, [3.0, 2.16, 1.44, 0.84, 0.36, 0.0, -0.24, -0.36, -0.36, -0.24, 0.0]),
+        (3, [-4.0, -1.98, -0.64, 0.14, 0.48, 0.5, 0.32, 0.06, -0.16, -0.22, 0.0]),
+        (
+            4,
+            [5.0, 1.332, -0.288, -0.658, -0.408, 0.0, 0.272, 0.282, 0.072, -0.148, 0.0],
+        ),
+        (
+            5,
+            [
+                -6.0,
+                -0.43308,
+                0.79104,
+                0.36876,
+                -0.21312,
+                -0.375,
+                -0.14208,
+                0.15804,
+                0.19776,
+                -0.04812,
+                0.0,
+            ],
+        ),
+    ],
+)
+def test_jacobi_alpha_minus_one_beta_plus_one(n, expected):
+    # gh-7001 - expected values were computed with mathematica
+    x = np.linspace(-1.0, 1.0, 11)
+    a, b = -1, 1  # alpha, beta
+    assert_allclose(_ufuncs.eval_jacobi(n, a, b, x), expected, rtol=1e-10, atol=1e-14)
+    assert_allclose(
+        _ufuncs.eval_jacobi(float(n), a, b, x), expected, rtol=1e-10, atol=1e-14
+    )
+
+
+@pytest.mark.parametrize(
+    "n, expected",
+    [
+        (0, [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]),
+        (1, [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]),
+        (2, [0.0, -0.09, -0.16, -0.21, -0.24, -0.25, -0.24, -0.21, -0.16, -0.09, 0.0]),
+        (
+            3,
+            [0.0, 0.144, 0.192, 0.168, 0.096, 0.0, -0.096, -0.168, -0.192, -0.144, 0.0],
+        ),
+        (
+            4,
+            [
+                0.0,
+                -0.1485,
+                -0.096,
+                0.0315,
+                0.144,
+                0.1875,
+                0.144,
+                0.0315,
+                -0.096,
+                -0.1485,
+                0.0,
+            ],
+        ),
+        (
+            5,
+            [
+                0.0,
+                0.10656,
+                -0.04608,
+                -0.15792,
+                -0.13056,
+                0.0,
+                0.13056,
+                0.15792,
+                0.04608,
+                -0.10656,
+                0.0,
+            ],
+        ),
+    ],
+)
+def test_jacobi_alpha_minus_one_beta_minus_one(n, expected):
+    # gh-7001 - expected values were computed with mathematica
+    x = np.linspace(-1.0, 1.0, 11)
+    a, b = -1, -1  # alpha, beta
+    assert_allclose(_ufuncs.eval_jacobi(n, a, b, x), expected, rtol=1e-10, atol=1e-14)
+    assert_allclose(
+        _ufuncs.eval_jacobi(float(n), a, b, x), expected, rtol=1e-10, atol=1e-14
+    )

.venv/lib/python3.12/site-packages/scipy/special/tests/test_owens_t.py

@@ -0,0 +1,53 @@
+import numpy as np
+from numpy.testing import assert_equal, assert_allclose
+
+import scipy.special as sc
+
+
+def test_symmetries():
+    np.random.seed(1234)
+    a, h = np.random.rand(100), np.random.rand(100)
+    assert_equal(sc.owens_t(h, a), sc.owens_t(-h, a))
+    assert_equal(sc.owens_t(h, a), -sc.owens_t(h, -a))
+
+
+def test_special_cases():
+    assert_equal(sc.owens_t(5, 0), 0)
+    assert_allclose(sc.owens_t(0, 5), 0.5*np.arctan(5)/np.pi,
+                    rtol=5e-14)
+    # Target value is 0.5*Phi(5)*(1 - Phi(5)) for Phi the CDF of the
+    # standard normal distribution
+    assert_allclose(sc.owens_t(5, 1), 1.4332574485503512543e-07,
+                    rtol=5e-14)
+
+
+def test_nans():
+    assert_equal(sc.owens_t(20, np.nan), np.nan)
+    assert_equal(sc.owens_t(np.nan, 20), np.nan)
+    assert_equal(sc.owens_t(np.nan, np.nan), np.nan)
+
+
+def test_infs():
+    h, a = 0, np.inf
+    # T(0, a) = 1/2π * arctan(a)
+    res = 1/(2*np.pi) * np.arctan(a)
+    assert_allclose(sc.owens_t(h, a), res, rtol=5e-14)
+    assert_allclose(sc.owens_t(h, -a), -res, rtol=5e-14)
+
+    h = 1
+    # Refer Owens T function definition in Wikipedia
+    # https://en.wikipedia.org/wiki/Owen%27s_T_function
+    # Value approximated through Numerical Integration
+    # using scipy.integrate.quad
+    # quad(lambda x: 1/(2*pi)*(exp(-0.5*(1*1)*(1+x*x))/(1+x*x)), 0, inf)
+    res = 0.07932762696572854
+    assert_allclose(sc.owens_t(h, np.inf), res, rtol=5e-14)
+    assert_allclose(sc.owens_t(h, -np.inf), -res, rtol=5e-14)
+
+    assert_equal(sc.owens_t(np.inf, 1), 0)
+    assert_equal(sc.owens_t(-np.inf, 1), 0)
+
+    assert_equal(sc.owens_t(np.inf, np.inf), 0)
+    assert_equal(sc.owens_t(-np.inf, np.inf), 0)
+    assert_equal(sc.owens_t(np.inf, -np.inf), -0.0)
+    assert_equal(sc.owens_t(-np.inf, -np.inf), -0.0)

.venv/lib/python3.12/site-packages/scipy/special/tests/test_pcf.py

@@ -0,0 +1,24 @@
+"""Tests for parabolic cylinder functions.
+
+"""
+import numpy as np
+from numpy.testing import assert_allclose, assert_equal
+import scipy.special as sc
+
+
+def test_pbwa_segfault():
+    # Regression test for https://github.com/scipy/scipy/issues/6208.
+    #
+    # Data generated by mpmath.
+    #
+    w = 1.02276567211316867161
+    wp = -0.48887053372346189882
+    assert_allclose(sc.pbwa(0, 0), (w, wp), rtol=1e-13, atol=0)
+
+
+def test_pbwa_nan():
+    # Check that NaN's are returned outside of the range in which the
+    # implementation is accurate.
+    pts = [(-6, -6), (-6, 6), (6, -6), (6, 6)]
+    for p in pts:
+        assert_equal(sc.pbwa(*p), (np.nan, np.nan))

.venv/lib/python3.12/site-packages/scipy/special/tests/test_pdtr.py

@@ -0,0 +1,48 @@
+import numpy as np
+import scipy.special as sc
+from numpy.testing import assert_allclose, assert_array_equal
+
+
+class TestPdtr:
+    def test(self):
+        val = sc.pdtr(0, 1)
+        assert_allclose(val, np.exp(-1), atol=1.5e-7, rtol=0)
+
+    def test_m_zero(self):
+        val = sc.pdtr([0, 1, 2], 0)
+        assert_allclose(val, [1, 1, 1], atol=1.5e-7, rtol=0)
+
+    def test_rounding(self):
+        double_val = sc.pdtr([0.1, 1.1, 2.1], 1.0)
+        int_val = sc.pdtr([0, 1, 2], 1.0)
+        assert_array_equal(double_val, int_val)
+
+    def test_inf(self):
+        val = sc.pdtr(np.inf, 1.0)
+        assert_allclose(val, 1.0, atol=1.5e-7, rtol=0)
+
+    def test_domain(self):
+        val = sc.pdtr(-1.1, 1.0)
+        assert np.isnan(val)
+
+class TestPdtrc:
+    def test_value(self):
+        val = sc.pdtrc(0, 1)
+        assert_allclose(val, 1 - np.exp(-1), atol=1.5e-7, rtol=0)
+
+    def test_m_zero(self):
+        val = sc.pdtrc([0, 1, 2], 0.0)
+        assert_array_equal(val, [0, 0, 0])
+
+    def test_rounding(self):
+        double_val = sc.pdtrc([0.1, 1.1, 2.1], 1.0)
+        int_val = sc.pdtrc([0, 1, 2], 1.0)
+        assert_array_equal(double_val, int_val)
+
+    def test_inf(self):
+        val = sc.pdtrc(np.inf, 1.0)
+        assert_allclose(val, 0.0, atol=1.5e-7, rtol=0)
+
+    def test_domain(self):
+        val = sc.pdtrc(-1.1, 1.0)
+        assert np.isnan(val)

.venv/lib/python3.12/site-packages/scipy/special/tests/test_powm1.py

@@ -0,0 +1,65 @@
+import pytest
+import numpy as np
+from numpy.testing import assert_allclose
+from scipy.special import powm1
+
+
+# Expected values were computed with mpmath, e.g.
+#
+#   >>> import mpmath
+#   >>> mpmath.np.dps = 200
+#   >>> print(float(mpmath.powm1(2.0, 1e-7))
+#   6.931472045825965e-08
+#
+powm1_test_cases = [
+    (1.25, 0.75, 0.18217701125396976, 1e-15),
+    (2.0, 1e-7, 6.931472045825965e-08, 1e-15),
+    (25.0, 5e-11, 1.6094379125636148e-10, 1e-15),
+    (0.99996, 0.75, -3.0000150002530058e-05, 1e-15),
+    (0.9999999999990905, 20, -1.81898940353014e-11, 1e-15),
+    (-1.25, 751.0, -6.017550852453444e+72, 2e-15)
+]
+
+
+@pytest.mark.parametrize('x, y, expected, rtol', powm1_test_cases)
+def test_powm1(x, y, expected, rtol):
+    p = powm1(x, y)
+    assert_allclose(p, expected, rtol=rtol)
+
+
+@pytest.mark.parametrize('x, y, expected',
+                         [(0.0, 0.0, 0.0),
+                          (0.0, -1.5, np.inf),
+                          (0.0, 1.75, -1.0),
+                          (-1.5, 2.0, 1.25),
+                          (-1.5, 3.0, -4.375),
+                          (np.nan, 0.0, 0.0),
+                          (1.0, np.nan, 0.0),
+                          (1.0, np.inf, 0.0),
+                          (1.0, -np.inf, 0.0),
+                          (np.inf, 7.5, np.inf),
+                          (np.inf, -7.5, -1.0),
+                          (3.25, np.inf, np.inf),
+                          (np.inf, np.inf, np.inf),
+                          (np.inf, -np.inf, -1.0),
+                          (np.inf, 0.0, 0.0),
+                          (-np.inf, 0.0, 0.0),
+                          (-np.inf, 2.0, np.inf),
+                          (-np.inf, 3.0, -np.inf),
+                          (-1.0, float(2**53 - 1), -2.0)])
+def test_powm1_exact_cases(x, y, expected):
+    # Test cases where we have an exact expected value.
+    p = powm1(x, y)
+    assert p == expected
+
+
+@pytest.mark.parametrize('x, y',
+                         [(-1.25, 751.03),
+                          (-1.25, np.inf),
+                          (np.nan, np.nan),
+                          (-np.inf, -np.inf),
+                          (-np.inf, 2.5)])
+def test_powm1_return_nan(x, y):
+    # Test cases where the expected return value is nan.
+    p = powm1(x, y)
+    assert np.isnan(p)

.venv/lib/python3.12/site-packages/scipy/special/tests/test_precompute_expn_asy.py

@@ -0,0 +1,24 @@
+from numpy.testing import assert_equal
+
+from scipy.special._testutils import check_version, MissingModule
+from scipy.special._precompute.expn_asy import generate_A
+
+try:
+    import sympy
+    from sympy import Poly
+except ImportError:
+    sympy = MissingModule("sympy")
+
+
+@check_version(sympy, "1.0")
+def test_generate_A():
+    # Data from DLMF 8.20.5
+    x = sympy.symbols('x')
+    Astd = [Poly(1, x),
+            Poly(1, x),
+            Poly(1 - 2*x),
+            Poly(1 - 8*x + 6*x**2)]
+    Ares = generate_A(len(Astd))
+
+    for p, q in zip(Astd, Ares):
+        assert_equal(p, q)

.venv/lib/python3.12/site-packages/scipy/special/tests/test_precompute_gammainc.py

@@ -0,0 +1,112 @@
+import pytest
+
+from scipy.special._testutils import MissingModule, check_version
+from scipy.special._mptestutils import (
+    Arg, IntArg, mp_assert_allclose, assert_mpmath_equal)
+from scipy.special._precompute.gammainc_asy import (
+    compute_g, compute_alpha, compute_d)
+from scipy.special._precompute.gammainc_data import gammainc, gammaincc
+
+try:
+    import sympy
+except ImportError:
+    sympy = MissingModule('sympy')
+
+try:
+    import mpmath as mp
+except ImportError:
+    mp = MissingModule('mpmath')
+
+
+pytestmark = pytest.mark.thread_unsafe(
+    reason=("mpmath gmpy2 backend is not thread-safe, "
+            "see https://github.com/mpmath/mpmath/issues/974"))
+
+@check_version(mp, '0.19')
+def test_g():
+    # Test data for the g_k. See DLMF 5.11.4.
+    with mp.workdps(30):
+        g = [mp.mpf(1), mp.mpf(1)/12, mp.mpf(1)/288,
+             -mp.mpf(139)/51840, -mp.mpf(571)/2488320,
+             mp.mpf(163879)/209018880, mp.mpf(5246819)/75246796800]
+        mp_assert_allclose(compute_g(7), g)
+
+
+@pytest.mark.slow
+@check_version(mp, '0.19')
+@check_version(sympy, '0.7')
+@pytest.mark.xfail_on_32bit("rtol only 2e-11, see gh-6938")
+def test_alpha():
+    # Test data for the alpha_k. See DLMF 8.12.14.
+    with mp.workdps(30):
+        alpha = [mp.mpf(0), mp.mpf(1), mp.mpf(1)/3, mp.mpf(1)/36,
+                 -mp.mpf(1)/270, mp.mpf(1)/4320, mp.mpf(1)/17010,
+                 -mp.mpf(139)/5443200, mp.mpf(1)/204120]
+        mp_assert_allclose(compute_alpha(9), alpha)
+
+
+@pytest.mark.xslow
+@check_version(mp, '0.19')
+@check_version(sympy, '0.7')
+def test_d():
+    # Compare the d_{k, n} to the results in appendix F of [1].
+    #
+    # Sources
+    # -------
+    # [1] DiDonato and Morris, Computation of the Incomplete Gamma
+    #     Function Ratios and their Inverse, ACM Transactions on
+    #     Mathematical Software, 1986.
+
+    with mp.workdps(50):
+        dataset = [(0, 0, -mp.mpf('0.333333333333333333333333333333')),
+                   (0, 12, mp.mpf('0.102618097842403080425739573227e-7')),
+                   (1, 0, -mp.mpf('0.185185185185185185185185185185e-2')),
+                   (1, 12, mp.mpf('0.119516285997781473243076536700e-7')),
+                   (2, 0, mp.mpf('0.413359788359788359788359788360e-2')),
+                   (2, 12, -mp.mpf('0.140925299108675210532930244154e-7')),
+                   (3, 0, mp.mpf('0.649434156378600823045267489712e-3')),
+                   (3, 12, -mp.mpf('0.191111684859736540606728140873e-7')),
+                   (4, 0, -mp.mpf('0.861888290916711698604702719929e-3')),
+                   (4, 12, mp.mpf('0.288658297427087836297341274604e-7')),
+                   (5, 0, -mp.mpf('0.336798553366358150308767592718e-3')),
+                   (5, 12, mp.mpf('0.482409670378941807563762631739e-7')),
+                   (6, 0, mp.mpf('0.531307936463992223165748542978e-3')),
+                   (6, 12, -mp.mpf('0.882860074633048352505085243179e-7')),
+                   (7, 0, mp.mpf('0.344367606892377671254279625109e-3')),
+                   (7, 12, -mp.mpf('0.175629733590604619378669693914e-6')),
+                   (8, 0, -mp.mpf('0.652623918595309418922034919727e-3')),
+                   (8, 12, mp.mpf('0.377358774161109793380344937299e-6')),
+                   (9, 0, -mp.mpf('0.596761290192746250124390067179e-3')),
+                   (9, 12, mp.mpf('0.870823417786464116761231237189e-6'))]
+        d = compute_d(10, 13)
+        res = [d[k][n] for k, n, std in dataset]
+        std = [x[2] for x in dataset]
+        mp_assert_allclose(res, std)
+
+
+@check_version(mp, '0.19')
+def test_gammainc():
+    # Quick check that the gammainc in
+    # special._precompute.gammainc_data agrees with mpmath's
+    # gammainc.
+    assert_mpmath_equal(gammainc,
+                        lambda a, x: mp.gammainc(a, b=x, regularized=True),
+                        [Arg(0, 100, inclusive_a=False), Arg(0, 100)],
+                        nan_ok=False, rtol=1e-17, n=50, dps=50)
+
+
+@pytest.mark.xslow
+@check_version(mp, '0.19')
+def test_gammaincc():
+    # Check that the gammaincc in special._precompute.gammainc_data
+    # agrees with mpmath's gammainc.
+    assert_mpmath_equal(lambda a, x: gammaincc(a, x, dps=1000),
+                        lambda a, x: mp.gammainc(a, a=x, regularized=True),
+                        [Arg(20, 100), Arg(20, 100)],
+                        nan_ok=False, rtol=1e-17, n=50, dps=1000)
+
+    # Test the fast integer path
+    assert_mpmath_equal(gammaincc,
+                        lambda a, x: mp.gammainc(a, a=x, regularized=True),
+                        [IntArg(1, 100), Arg(0, 100)],
+                        nan_ok=False, rtol=1e-17, n=50, dps=50)

.venv/lib/python3.12/site-packages/scipy/special/tests/test_precompute_utils.py

@@ -0,0 +1,36 @@
+import pytest
+
+from scipy.special._testutils import MissingModule, check_version
+from scipy.special._mptestutils import mp_assert_allclose
+from scipy.special._precompute.utils import lagrange_inversion
+
+try:
+    import sympy
+except ImportError:
+    sympy = MissingModule('sympy')
+
+try:
+    import mpmath as mp
+except ImportError:
+    mp = MissingModule('mpmath')
+
+
+@pytest.mark.slow
+@check_version(sympy, '0.7')
+@check_version(mp, '0.19')
+class TestInversion:
+    @pytest.mark.xfail_on_32bit("rtol only 2e-9, see gh-6938")
+    def test_log(self):
+        with mp.workdps(30):
+            logcoeffs = mp.taylor(lambda x: mp.log(1 + x), 0, 10)
+            expcoeffs = mp.taylor(lambda x: mp.exp(x) - 1, 0, 10)
+            invlogcoeffs = lagrange_inversion(logcoeffs)
+            mp_assert_allclose(invlogcoeffs, expcoeffs)
+
+    @pytest.mark.xfail_on_32bit("rtol only 1e-15, see gh-6938")
+    def test_sin(self):
+        with mp.workdps(30):
+            sincoeffs = mp.taylor(mp.sin, 0, 10)
+            asincoeffs = mp.taylor(mp.asin, 0, 10)
+            invsincoeffs = lagrange_inversion(sincoeffs)
+            mp_assert_allclose(invsincoeffs, asincoeffs, atol=1e-30)

.venv/lib/python3.12/site-packages/scipy/special/tests/test_round.py

@@ -0,0 +1,18 @@
+import numpy as np
+import pytest
+
+from scipy.special import _test_internal
+
+
+@pytest.mark.fail_slow(20)
+@pytest.mark.skipif(not _test_internal.have_fenv(), reason="no fenv()")
+def test_add_round_up():
+    rng = np.random.RandomState(1234)
+    _test_internal.test_add_round(10**5, 'up', rng)
+
+
+@pytest.mark.fail_slow(20)
+@pytest.mark.skipif(not _test_internal.have_fenv(), reason="no fenv()")
+def test_add_round_down():
+    rng = np.random.RandomState(1234)
+    _test_internal.test_add_round(10**5, 'down', rng)

.venv/lib/python3.12/site-packages/scipy/special/tests/test_sf_error.py

@@ -0,0 +1,153 @@
+import sys
+import warnings
+
+import numpy as np
+from numpy.testing import assert_, assert_equal, HAS_REFCOUNT
+import pytest
+from pytest import raises as assert_raises
+
+import scipy.special as sc
+from scipy.special._ufuncs import _sf_error_test_function
+
+_sf_error_code_map = {
+    # skip 'ok'
+    'singular': 1,
+    'underflow': 2,
+    'overflow': 3,
+    'slow': 4,
+    'loss': 5,
+    'no_result': 6,
+    'domain': 7,
+    'arg': 8,
+    'other': 9,
+    'memory': 10,
+}
+
+_sf_error_actions = [
+    'ignore',
+    'warn',
+    'raise'
+]
+
+
+def _check_action(fun, args, action):
+    # TODO: special expert should correct
+    # the coercion at the true location?
+    args = np.asarray(args, dtype=np.dtype("long"))
+    if action == 'warn':
+        with pytest.warns(sc.SpecialFunctionWarning):
+            fun(*args)
+    elif action == 'raise':
+        with assert_raises(sc.SpecialFunctionError):
+            fun(*args)
+    else:
+        # action == 'ignore', make sure there are no warnings/exceptions
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
+            fun(*args)
+
+
+def test_geterr():
+    err = sc.geterr()
+    for key, value in err.items():
+        assert_(key in _sf_error_code_map)
+        assert_(value in _sf_error_actions)
+
+
+def test_seterr():
+    entry_err = sc.geterr()
+    try:
+        for category, error_code in _sf_error_code_map.items():
+            for action in _sf_error_actions:
+                geterr_olderr = sc.geterr()
+                seterr_olderr = sc.seterr(**{category: action})
+                assert_(geterr_olderr == seterr_olderr)
+                newerr = sc.geterr()
+                assert_(newerr[category] == action)
+                geterr_olderr.pop(category)
+                newerr.pop(category)
+                assert_(geterr_olderr == newerr)
+                _check_action(_sf_error_test_function, (error_code,), action)
+    finally:
+        sc.seterr(**entry_err)
+
+
+@pytest.mark.thread_unsafe(reason="module refcounts are not stable in multiple threads")
+@pytest.mark.skipif(not HAS_REFCOUNT, reason="Python lacks refcounts")
+def test_sf_error_special_refcount():
+    # Regression test for gh-16233.
+    # Check that the reference count of scipy.special is not increased
+    # when a SpecialFunctionError is raised.
+    refcount_before = sys.getrefcount(sc)
+    with sc.errstate(all='raise'):
+        with pytest.raises(sc.SpecialFunctionError, match='domain error'):
+            sc.ndtri(2.0)
+    refcount_after = sys.getrefcount(sc)
+    assert refcount_after == refcount_before
+
+
+def test_errstate_pyx_basic():
+    olderr = sc.geterr()
+    with sc.errstate(singular='raise'):
+        with assert_raises(sc.SpecialFunctionError):
+            sc.loggamma(0)
+    assert_equal(olderr, sc.geterr())
+
+
+def test_errstate_c_basic():
+    olderr = sc.geterr()
+    with sc.errstate(domain='raise'):
+        with assert_raises(sc.SpecialFunctionError):
+            sc.spence(-1)
+    assert_equal(olderr, sc.geterr())
+
+
+def test_errstate_cpp_basic():
+    olderr = sc.geterr()
+    with sc.errstate(underflow='raise'):
+        with assert_raises(sc.SpecialFunctionError):
+            sc.wrightomega(-1000)
+    assert_equal(olderr, sc.geterr())
+
+
+def test_errstate_cpp_scipy_special():
+    olderr = sc.geterr()
+    with sc.errstate(singular='raise'):
+        with assert_raises(sc.SpecialFunctionError):
+            sc.lambertw(0, 1)
+    assert_equal(olderr, sc.geterr())
+
+
+def test_errstate_cpp_alt_ufunc_machinery():
+    olderr = sc.geterr()
+    with sc.errstate(singular='raise'):
+        with assert_raises(sc.SpecialFunctionError):
+            sc.gammaln(0)
+    assert_equal(olderr, sc.geterr())
+
+
+def test_errstate():
+    for category, error_code in _sf_error_code_map.items():
+        for action in _sf_error_actions:
+            olderr = sc.geterr()
+            with sc.errstate(**{category: action}):
+                _check_action(_sf_error_test_function, (error_code,), action)
+            assert_equal(olderr, sc.geterr())
+
+
+def test_errstate_all_but_one():
+    olderr = sc.geterr()
+    with sc.errstate(all='raise', singular='ignore'):
+        sc.gammaln(0)
+        with assert_raises(sc.SpecialFunctionError):
+            sc.spence(-1.0)
+    assert_equal(olderr, sc.geterr())
+
+
+def test_check_overflow_message():
+    # Regression test for a bug where the overflow and underflow
+    # messages were switched.
+    with pytest.raises(sc.SpecialFunctionError, match="overflow"):
+        with sc.errstate(all='raise'):
+            # This should trigger an overflow:
+            sc.yn(3, 1e-105)

.venv/lib/python3.12/site-packages/scipy/special/tests/test_sici.py

@@ -0,0 +1,36 @@
+import numpy as np
+
+import scipy.special as sc
+from scipy.special._testutils import FuncData
+
+
+def test_sici_consistency():
+    # Make sure the implementation of sici for real arguments agrees
+    # with the implementation of sici for complex arguments.
+
+    # On the negative real axis Cephes drops the imaginary part in ci
+    def sici(x):
+        si, ci = sc.sici(x + 0j)
+        return si.real, ci.real
+    
+    x = np.r_[-np.logspace(8, -30, 200), 0, np.logspace(-30, 8, 200)]
+    si, ci = sc.sici(x)
+    dataset = np.column_stack((x, si, ci))
+    FuncData(sici, dataset, 0, (1, 2), rtol=1e-12).check()
+
+
+def test_shichi_consistency():
+    # Make sure the implementation of shichi for real arguments agrees
+    # with the implementation of shichi for complex arguments.
+
+    # On the negative real axis Cephes drops the imaginary part in chi
+    def shichi(x):
+        shi, chi = sc.shichi(x + 0j)
+        return shi.real, chi.real
+
+    # Overflow happens quickly, so limit range
+    x = np.r_[-np.logspace(np.log10(700), -30, 200), 0,
+              np.logspace(-30, np.log10(700), 200)]
+    shi, chi = sc.shichi(x)
+    dataset = np.column_stack((x, shi, chi))
+    FuncData(shichi, dataset, 0, (1, 2), rtol=1e-14).check()

.venv/lib/python3.12/site-packages/scipy/special/tests/test_specfun.py

@@ -0,0 +1,48 @@
+"""
+Various made-up tests to hit different branches of the code in specfun.c
+"""
+
+import numpy as np
+from numpy.testing import assert_allclose
+from scipy import special
+
+
+def test_cva2_cv0_branches():
+    res, resp = special.mathieu_cem([40, 129], [13, 14], [30, 45])
+    assert_allclose(res, np.array([-0.3741211, 0.74441928]))
+    assert_allclose(resp, np.array([-37.02872758, -86.13549877]))
+
+    res, resp = special.mathieu_sem([40, 129], [13, 14], [30, 45])
+    assert_allclose(res, np.array([0.92955551, 0.66771207]))
+    assert_allclose(resp, np.array([-14.91073448, 96.02954185]))
+
+
+def test_chgm_branches():
+    res = special.eval_genlaguerre(-3.2, 3, 2.5)
+    assert_allclose(res, -0.7077721935779854)
+
+
+def test_hygfz_branches():
+    """(z == 1.0) && (c-a-b > 0.0)"""
+    res = special.hyp2f1(1.5, 2.5, 4.5, 1.+0.j)
+    assert_allclose(res, 10.30835089459151+0j)
+    """(cabs(z+1) < eps) && (fabs(c-a+b - 1.0) < eps)"""
+    res = special.hyp2f1(5+5e-16, 2, 2, -1.0 + 5e-16j)
+    assert_allclose(res, 0.031249999999999986+3.9062499999999994e-17j)
+
+
+def test_pro_rad1():
+    # https://github.com/scipy/scipy/issues/21058
+    # Reference values taken from WolframAlpha
+    # SpheroidalS1(1, 1, 30, 1.1)
+    # SpheroidalS1Prime(1, 1, 30, 1.1)
+    res = special.pro_rad1(1, 1, 30, 1.1)
+    assert_allclose(res, (0.009657872296166435, 3.253369651472877), rtol=2e-5)
+
+def test_pro_rad2():
+    # https://github.com/scipy/scipy/issues/21461
+    # Reference values taken from WolframAlpha
+    # SpheroidalS2(0, 0, 3, 1.02)
+    # SpheroidalS2Prime(0, 0, 3, 1.02)
+    res = special.pro_rad2(0, 0, 3, 1.02)
+    assert_allclose(res, (-0.35089596858528077, 13.652764213480872), rtol=10e-10)

.venv/lib/python3.12/site-packages/scipy/special/tests/test_spence.py

@@ -0,0 +1,32 @@
+import numpy as np
+from numpy import sqrt, log, pi
+from scipy.special._testutils import FuncData
+from scipy.special import spence
+
+
+def test_consistency():
+    # Make sure the implementation of spence for real arguments
+    # agrees with the implementation of spence for imaginary arguments.
+
+    x = np.logspace(-30, 300, 200)
+    dataset = np.vstack((x + 0j, spence(x))).T
+    FuncData(spence, dataset, 0, 1, rtol=1e-14).check()
+
+
+def test_special_points():
+    # Check against known values of Spence's function.
+
+    phi = (1 + sqrt(5))/2
+    dataset = [(1, 0),
+               (2, -pi**2/12),
+               (0.5, pi**2/12 - log(2)**2/2),
+               (0, pi**2/6),
+               (-1, pi**2/4 - 1j*pi*log(2)),
+               ((-1 + sqrt(5))/2, pi**2/15 - log(phi)**2),
+               ((3 - sqrt(5))/2, pi**2/10 - log(phi)**2),
+               (phi, -pi**2/15 + log(phi)**2/2),
+               # Corrected from Zagier, "The Dilogarithm Function"
+               ((3 + sqrt(5))/2, -pi**2/10 - log(phi)**2)]
+
+    dataset = np.asarray(dataset)
+    FuncData(spence, dataset, 0, 1, rtol=1e-14).check()

.venv/lib/python3.12/site-packages/scipy/special/tests/test_spfun_stats.py

@@ -0,0 +1,61 @@
+import numpy as np
+from numpy.testing import (assert_array_equal, assert_array_almost_equal_nulp,
+                           assert_allclose)
+from pytest import raises as assert_raises
+
+from scipy.special import gammaln, multigammaln  # type:ignore[attr-defined]
+
+
+class TestMultiGammaLn:
+
+    def test1(self):
+        # A test of the identity
+        #     Gamma_1(a) = Gamma(a)
+        np.random.seed(1234)
+        a = np.abs(np.random.randn())
+        assert_array_equal(multigammaln(a, 1), gammaln(a))
+
+    def test2(self):
+        # A test of the identity
+        #     Gamma_2(a) = sqrt(pi) * Gamma(a) * Gamma(a - 0.5)
+        a = np.array([2.5, 10.0])
+        result = multigammaln(a, 2)
+        expected = np.log(np.sqrt(np.pi)) + gammaln(a) + gammaln(a - 0.5)
+        assert_allclose(result, expected, atol=1.5e-7, rtol=0)
+
+    def test_bararg(self):
+        assert_raises(ValueError, multigammaln, 0.5, 1.2)
+
+
+def _check_multigammaln_array_result(a, d):
+    # Test that the shape of the array returned by multigammaln
+    # matches the input shape, and that all the values match
+    # the value computed when multigammaln is called with a scalar.
+    result = multigammaln(a, d)
+    assert_array_equal(a.shape, result.shape)
+    a1 = a.ravel()
+    result1 = result.ravel()
+    for i in range(a.size):
+        assert_array_almost_equal_nulp(result1[i], multigammaln(a1[i], d))
+
+
+def test_multigammaln_array_arg():
+    # Check that the array returned by multigammaln has the correct
+    # shape and contains the correct values.  The cases have arrays
+    # with several different shapes.
+    # The cases include a regression test for ticket #1849
+    # (a = np.array([2.0]), an array with a single element).
+    np.random.seed(1234)
+
+    cases = [
+        # a, d
+        (np.abs(np.random.randn(3, 2)) + 5, 5),
+        (np.abs(np.random.randn(1, 2)) + 5, 5),
+        (np.arange(10.0, 18.0).reshape(2, 2, 2), 3),
+        (np.array([2.0]), 3),
+        (np.float64(2.0), 3),
+    ]
+
+    for a, d in cases:
+        _check_multigammaln_array_result(a, d)
+

.venv/lib/python3.12/site-packages/scipy/special/tests/test_sph_harm.py

@@ -0,0 +1,48 @@
+import numpy as np
+import pytest
+
+from numpy.testing import assert_allclose
+import scipy.special as sc
+
+class TestSphHarm:
+    @pytest.mark.slow
+    def test_p(self):
+        m_max = 20
+        n_max = 10
+
+        theta = np.linspace(0, np.pi)
+        phi = np.linspace(0, 2*np.pi)
+        theta, phi = np.meshgrid(theta, phi)
+
+        y, y_jac, y_hess = sc.sph_harm_y_all(n_max, m_max, theta, phi, diff_n=2)
+        p, p_jac, p_hess = sc.sph_legendre_p_all(n_max, m_max, theta, diff_n=2)
+
+        m = np.concatenate([np.arange(m_max + 1), np.arange(-m_max, 0)])
+        m = np.expand_dims(m, axis=(0,)+tuple(range(2,theta.ndim+2)))
+
+        assert_allclose(y, p * np.exp(1j * m * phi))
+
+        assert_allclose(y_jac[..., 0], p_jac * np.exp(1j * m * phi))
+        assert_allclose(y_jac[..., 1], 1j * m * p * np.exp(1j * m * phi))
+
+        assert_allclose(y_hess[..., 0, 0], p_hess * np.exp(1j * m * phi))
+        assert_allclose(y_hess[..., 0, 1], 1j * m * p_jac * np.exp(1j * m * phi))
+        assert_allclose(y_hess[..., 1, 0], y_hess[..., 0, 1])
+        assert_allclose(y_hess[..., 1, 1], -m * m * p * np.exp(1j * m * phi))
+
+    @pytest.mark.parametrize("n_max", [7, 10, 50])
+    @pytest.mark.parametrize("m_max", [1, 4, 5, 9, 14])
+    def test_all(self, n_max, m_max):
+        theta = np.linspace(0, np.pi)
+        phi = np.linspace(0, 2 * np.pi)
+
+        n = np.arange(n_max + 1)
+        n = np.expand_dims(n, axis=tuple(range(1,theta.ndim+2)))
+
+        m = np.concatenate([np.arange(m_max + 1), np.arange(-m_max, 0)])
+        m = np.expand_dims(m, axis=(0,)+tuple(range(2,theta.ndim+2)))
+
+        y_actual = sc.sph_harm_y_all(n_max, m_max, theta, phi)
+        y_desired = sc.sph_harm_y(n, m, theta, phi)
+
+        np.testing.assert_allclose(y_actual, y_desired, rtol=1e-05)