Add files using upload-large-folder tool

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy-1.15.3.dist-info/INSTALLER

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

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy-1.15.3.dist-info/LICENSE.txt

@@ -0,0 +1,934 @@
+Copyright (c) 2001-2002 Enthought, Inc. 2003-2024, 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-Attribution
+  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-Attribution
+  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-with-GCC-exception
+  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

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy-1.15.3.dist-info/METADATA

@@ -0,0 +1,1082 @@
+Metadata-Version: 2.1
+Name: scipy
+Version: 1.15.3
+Summary: Fundamental algorithms for scientific computing in Python
+Maintainer-Email: SciPy Developers <scipy-dev@python.org>
+License: Copyright (c) 2001-2002 Enthought, Inc. 2003-2024, 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-Attribution
+           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-Attribution
+           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-with-GCC-exception
+           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.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+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.10
+Requires-Dist: numpy<2.5,>=1.23.5
+Provides-Extra: test
+Requires-Dist: pytest; 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.1.1,>=2.0; extra == "test"
+Requires-Dist: Cython; extra == "test"
+Requires-Dist: meson; extra == "test"
+Requires-Dist: ninja; sys_platform != "emscripten" and extra == "test"
+Provides-Extra: doc
+Requires-Dist: sphinx<8.0.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; extra == "doc"
+Requires-Dist: pooch; extra == "doc"
+Requires-Dist: jupyterlite-sphinx>=0.19.1; extra == "doc"
+Requires-Dist: jupyterlite-pyodide-kernel; extra == "doc"
+Provides-Extra: dev
+Requires-Dist: mypy==1.10.0; extra == "dev"
+Requires-Dist: typing_extensions; extra == "dev"
+Requires-Dist: types-psutil; extra == "dev"
+Requires-Dist: pycodestyle; extra == "dev"
+Requires-Dist: ruff>=0.0.292; extra == "dev"
+Requires-Dist: cython-lint>=0.12.2; extra == "dev"
+Requires-Dist: rich-click; extra == "dev"
+Requires-Dist: doit>=0.36.0; extra == "dev"
+Requires-Dist: pydevtool; 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
+
+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:** https://tidelift.com/docs/security
+- **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.

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy-1.15.3.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: meson
+Root-Is-Purelib: false
+Tag: cp310-cp310-manylinux_2_17_x86_64
+Tag: cp310-cp310-manylinux2014_x86_64
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/special/xsf/cephes/hyperg.h

@@ -0,0 +1,361 @@
+/* Translated into C++ by SciPy developers in 2024.
+ * Original header with Copyright information appears below.
+ */
+
+/*                                                     hyperg.c
+ *
+ *     Confluent hypergeometric function
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double a, b, x, y, hyperg();
+ *
+ * y = hyperg( a, b, x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Computes the confluent hypergeometric function
+ *
+ *                          1           2
+ *                       a x    a(a+1) x
+ *   F ( a,b;x )  =  1 + ---- + --------- + ...
+ *  1 1                  b 1!   b(b+1) 2!
+ *
+ * Many higher transcendental functions are special cases of
+ * this power series.
+ *
+ * As is evident from the formula, b must not be a negative
+ * integer or zero unless a is an integer with 0 >= a > b.
+ *
+ * The routine attempts both a direct summation of the series
+ * and an asymptotic expansion.  In each case error due to
+ * roundoff, cancellation, and nonconvergence is estimated.
+ * The result with smaller estimated error is returned.
+ *
+ *
+ *
+ * ACCURACY:
+ *
+ * Tested at random points (a, b, x), all three variables
+ * ranging from 0 to 30.
+ *                      Relative error:
+ * arithmetic   domain     # trials      peak         rms
+ *    IEEE      0,30        30000       1.8e-14     1.1e-15
+ *
+ * Larger errors can be observed when b is near a negative
+ * integer or zero.  Certain combinations of arguments yield
+ * serious cancellation error in the power series summation
+ * and also are not in the region of near convergence of the
+ * asymptotic series.  An error message is printed if the
+ * self-estimated relative error is greater than 1.0e-12.
+ *
+ */
+
+/*
+ * Cephes Math Library Release 2.8:  June, 2000
+ * Copyright 1984, 1987, 1988, 2000 by Stephen L. Moshier
+ */
+
+#pragma once
+
+#include "../config.h"
+#include "../error.h"
+
+#include "const.h"
+#include "gamma.h"
+#include "rgamma.h"
+
+namespace xsf {
+namespace cephes {
+
+    namespace detail {
+
+        /* the `type` parameter determines what converging factor to use */
+        XSF_HOST_DEVICE inline double hyp2f0(double a, double b, double x, int type, double *err) {
+            double a0, alast, t, tlast, maxt;
+            double n, an, bn, u, sum, temp;
+
+            an = a;
+            bn = b;
+            a0 = 1.0e0;
+            alast = 1.0e0;
+            sum = 0.0;
+            n = 1.0e0;
+            t = 1.0e0;
+            tlast = 1.0e9;
+            maxt = 0.0;
+
+            do {
+                if (an == 0)
+                    goto pdone;
+                if (bn == 0)
+                    goto pdone;
+
+                u = an * (bn * x / n);
+
+                /* check for blowup */
+                temp = std::abs(u);
+                if ((temp > 1.0) && (maxt > (std::numeric_limits<double>::max() / temp)))
+                    goto error;
+
+                a0 *= u;
+                t = std::abs(a0);
+
+                /* terminating condition for asymptotic series:
+                 * the series is divergent (if a or b is not a negative integer),
+                 * but its leading part can be used as an asymptotic expansion
+                 */
+                if (t > tlast)
+                    goto ndone;
+
+                tlast = t;
+                sum += alast; /* the sum is one term behind */
+                alast = a0;
+
+                if (n > 200)
+                    goto ndone;
+
+                an += 1.0e0;
+                bn += 1.0e0;
+                n += 1.0e0;
+                if (t > maxt)
+                    maxt = t;
+            } while (t > MACHEP);
+
+        pdone: /* series converged! */
+
+            /* estimate error due to roundoff and cancellation */
+            *err = std::abs(MACHEP * (n + maxt));
+
+            alast = a0;
+            goto done;
+
+        ndone: /* series did not converge */
+
+            /* The following "Converging factors" are supposed to improve accuracy,
+             * but do not actually seem to accomplish very much. */
+
+            n -= 1.0;
+            x = 1.0 / x;
+
+            switch (type) { /* "type" given as subroutine argument */
+            case 1:
+                alast *= (0.5 + (0.125 + 0.25 * b - 0.5 * a + 0.25 * x - 0.25 * n) / x);
+                break;
+
+            case 2:
+                alast *= 2.0 / 3.0 - b + 2.0 * a + x - n;
+                break;
+
+            default:;
+            }
+
+            /* estimate error due to roundoff, cancellation, and nonconvergence */
+            *err = MACHEP * (n + maxt) + std::abs(a0);
+
+        done:
+            sum += alast;
+            return (sum);
+
+            /* series blew up: */
+        error:
+            *err = std::numeric_limits<double>::infinity();
+            set_error("hyperg", SF_ERROR_NO_RESULT, NULL);
+            return (sum);
+        }
+
+        /* asymptotic formula for hypergeometric function:
+         *
+         *        (    -a
+         *  --    ( |z|
+         * |  (b) ( -------- 2f0( a, 1+a-b, -1/x )
+         *        (  --
+         *        ( |  (b-a)
+         *
+         *
+         *                                x    a-b                     )
+         *                               e  |x|                        )
+         *                             + -------- 2f0( b-a, 1-a, 1/x ) )
+         *                                --                           )
+         *                               |  (a)                        )
+         */
+
+        XSF_HOST_DEVICE inline double hy1f1a(double a, double b, double x, double *err) {
+            double h1, h2, t, u, temp, acanc, asum, err1, err2;
+
+            if (x == 0) {
+                acanc = 1.0;
+                asum = std::numeric_limits<double>::infinity();
+                goto adone;
+            }
+            temp = std::log(std::abs(x));
+            t = x + temp * (a - b);
+            u = -temp * a;
+
+            if (b > 0) {
+                temp = xsf::cephes::lgam(b);
+                t += temp;
+                u += temp;
+            }
+
+            h1 = hyp2f0(a, a - b + 1, -1.0 / x, 1, &err1);
+
+            temp = std::exp(u) * xsf::cephes::rgamma(b - a);
+            h1 *= temp;
+            err1 *= temp;
+
+            h2 = hyp2f0(b - a, 1.0 - a, 1.0 / x, 2, &err2);
+
+            if (a < 0)
+                temp = std::exp(t) * xsf::cephes::rgamma(a);
+            else
+                temp = std::exp(t - xsf::cephes::lgam(a));
+
+            h2 *= temp;
+            err2 *= temp;
+
+            if (x < 0.0)
+                asum = h1;
+            else
+                asum = h2;
+
+            acanc = std::abs(err1) + std::abs(err2);
+
+            if (b < 0) {
+                temp = xsf::cephes::Gamma(b);
+                asum *= temp;
+                acanc *= std::abs(temp);
+            }
+
+            if (asum != 0.0)
+                acanc /= std::abs(asum);
+
+            if (acanc != acanc)
+                /* nan */
+                acanc = 1.0;
+
+            if (std::isinf(asum))
+                /* infinity */
+                acanc = 0;
+
+            acanc *= 30.0; /* fudge factor, since error of asymptotic formula
+                            * often seems this much larger than advertised */
+        adone:
+            *err = acanc;
+            return (asum);
+        }
+
+        /* Power series summation for confluent hypergeometric function */
+        XSF_HOST_DEVICE inline double hy1f1p(double a, double b, double x, double *err) {
+            double n, a0, sum, t, u, temp, maxn;
+            double an, bn, maxt;
+            double y, c, sumc;
+
+            /* set up for power series summation */
+            an = a;
+            bn = b;
+            a0 = 1.0;
+            sum = 1.0;
+            c = 0.0;
+            n = 1.0;
+            t = 1.0;
+            maxt = 0.0;
+            *err = 1.0;
+
+            maxn = 200.0 + 2 * fabs(a) + 2 * fabs(b);
+
+            while (t > MACHEP) {
+                if (bn == 0) { /* check bn first since if both   */
+                    sf_error("hyperg", SF_ERROR_SINGULAR, NULL);
+                    return (std::numeric_limits<double>::infinity()); /* an and bn are zero it is     */
+                }
+                if (an == 0) /* a singularity            */
+                    return (sum);
+                if (n > maxn) {
+                    /* too many terms; take the last one as error estimate */
+                    c = std::abs(c) + std::abs(t) * 50.0;
+                    goto pdone;
+                }
+                u = x * (an / (bn * n));
+
+                /* check for blowup */
+                temp = std::abs(u);
+                if ((temp > 1.0) && (maxt > (std::numeric_limits<double>::max() / temp))) {
+                    *err = 1.0; /* blowup: estimate 100% error */
+                    return sum;
+                }
+
+                a0 *= u;
+
+                y = a0 - c;
+                sumc = sum + y;
+                c = (sumc - sum) - y;
+                sum = sumc;
+
+                t = std::abs(a0);
+
+                an += 1.0;
+                bn += 1.0;
+                n += 1.0;
+            }
+
+        pdone:
+
+            /* estimate error due to roundoff and cancellation */
+            if (sum != 0.0) {
+                *err = std::abs(c / sum);
+            } else {
+                *err = std::abs(c);
+            }
+
+            if (*err != *err) {
+                /* nan */
+                *err = 1.0;
+            }
+
+            return (sum);
+        }
+
+    } // namespace detail
+
+    XSF_HOST_DEVICE inline double hyperg(double a, double b, double x) {
+        double asum, psum, acanc, pcanc, temp;
+
+        /* See if a Kummer transformation will help */
+        temp = b - a;
+        if (std::abs(temp) < 0.001 * std::abs(a))
+            return (exp(x) * hyperg(temp, b, -x));
+
+        /* Try power & asymptotic series, starting from the one that is likely OK */
+        if (std::abs(x) < 10 + std::abs(a) + std::abs(b)) {
+            psum = detail::hy1f1p(a, b, x, &pcanc);
+            if (pcanc < 1.0e-15)
+                goto done;
+            asum = detail::hy1f1a(a, b, x, &acanc);
+        } else {
+            psum = detail::hy1f1a(a, b, x, &pcanc);
+            if (pcanc < 1.0e-15)
+                goto done;
+            asum = detail::hy1f1p(a, b, x, &acanc);
+        }
+
+        /* Pick the result with less estimated error */
+
+        if (acanc < pcanc) {
+            pcanc = acanc;
+            psum = asum;
+        }
+
+    done:
+        if (pcanc > 1.0e-12)
+            set_error("hyperg", SF_ERROR_LOSS, NULL);
+
+        return (psum);
+    }
+
+} // namespace cephes
+} // namespace xsf

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/special/xsf/cephes/i0.h

@@ -0,0 +1,149 @@
+/* Translated into C++ by SciPy developers in 2024.
+ * Original header with Copyright information appears below.
+ */
+
+/*                                                     i0.c
+ *
+ *     Modified Bessel function of order zero
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, y, i0();
+ *
+ * y = i0( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns modified Bessel function of order zero of the
+ * argument.
+ *
+ * The function is defined as i0(x) = j0( ix ).
+ *
+ * The range is partitioned into the two intervals [0,8] and
+ * (8, infinity).  Chebyshev polynomial expansions are employed
+ * in each interval.
+ *
+ *
+ *
+ * ACCURACY:
+ *
+ *                      Relative error:
+ * arithmetic   domain     # trials      peak         rms
+ *    IEEE      0,30        30000       5.8e-16     1.4e-16
+ *
+ */
+/*							i0e.c
+ *
+ *	Modified Bessel function of order zero,
+ *	exponentially scaled
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, y, i0e();
+ *
+ * y = i0e( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns exponentially scaled modified Bessel function
+ * of order zero of the argument.
+ *
+ * The function is defined as i0e(x) = exp(-|x|) j0( ix ).
+ *
+ *
+ *
+ * ACCURACY:
+ *
+ *                      Relative error:
+ * arithmetic   domain     # trials      peak         rms
+ *    IEEE      0,30        30000       5.4e-16     1.2e-16
+ * See i0().
+ *
+ */
+
+/*                                                     i0.c            */
+
+/*
+ * Cephes Math Library Release 2.8:  June, 2000
+ * Copyright 1984, 1987, 2000 by Stephen L. Moshier
+ */
+#pragma once
+
+#include "../config.h"
+#include "chbevl.h"
+
+namespace xsf {
+namespace cephes {
+
+    namespace detail {
+
+        /* Chebyshev coefficients for exp(-x) I0(x)
+         * in the interval [0,8].
+         *
+         * lim(x->0){ exp(-x) I0(x) } = 1.
+         */
+        constexpr double i0_A[] = {
+            -4.41534164647933937950E-18, 3.33079451882223809783E-17,  -2.43127984654795469359E-16,
+            1.71539128555513303061E-15,  -1.16853328779934516808E-14, 7.67618549860493561688E-14,
+            -4.85644678311192946090E-13, 2.95505266312963983461E-12,  -1.72682629144155570723E-11,
+            9.67580903537323691224E-11,  -5.18979560163526290666E-10, 2.65982372468238665035E-9,
+            -1.30002500998624804212E-8,  6.04699502254191894932E-8,   -2.67079385394061173391E-7,
+            1.11738753912010371815E-6,   -4.41673835845875056359E-6,  1.64484480707288970893E-5,
+            -5.75419501008210370398E-5,  1.88502885095841655729E-4,   -5.76375574538582365885E-4,
+            1.63947561694133579842E-3,   -4.32430999505057594430E-3,  1.05464603945949983183E-2,
+            -2.37374148058994688156E-2,  4.93052842396707084878E-2,   -9.49010970480476444210E-2,
+            1.71620901522208775349E-1,   -3.04682672343198398683E-1,  6.76795274409476084995E-1};
+
+        /* Chebyshev coefficients for exp(-x) sqrt(x) I0(x)
+         * in the inverted interval [8,infinity].
+         *
+         * lim(x->inf){ exp(-x) sqrt(x) I0(x) } = 1/sqrt(2pi).
+         */
+        constexpr double i0_B[] = {
+            -7.23318048787475395456E-18, -4.83050448594418207126E-18, 4.46562142029675999901E-17,
+            3.46122286769746109310E-17,  -2.82762398051658348494E-16, -3.42548561967721913462E-16,
+            1.77256013305652638360E-15,  3.81168066935262242075E-15,  -9.55484669882830764870E-15,
+            -4.15056934728722208663E-14, 1.54008621752140982691E-14,  3.85277838274214270114E-13,
+            7.18012445138366623367E-13,  -1.79417853150680611778E-12, -1.32158118404477131188E-11,
+            -3.14991652796324136454E-11, 1.18891471078464383424E-11,  4.94060238822496958910E-10,
+            3.39623202570838634515E-9,   2.26666899049817806459E-8,   2.04891858946906374183E-7,
+            2.89137052083475648297E-6,   6.88975834691682398426E-5,   3.36911647825569408990E-3,
+            8.04490411014108831608E-1};
+    } // namespace detail
+
+    XSF_HOST_DEVICE inline double i0(double x) {
+        double y;
+
+        if (x < 0)
+            x = -x;
+        if (x <= 8.0) {
+            y = (x / 2.0) - 2.0;
+            return (std::exp(x) * chbevl(y, detail::i0_A, 30));
+        }
+
+        return (std::exp(x) * chbevl(32.0 / x - 2.0, detail::i0_B, 25) / sqrt(x));
+    }
+
+    XSF_HOST_DEVICE inline double i0e(double x) {
+        double y;
+
+        if (x < 0)
+            x = -x;
+        if (x <= 8.0) {
+            y = (x / 2.0) - 2.0;
+            return (chbevl(y, detail::i0_A, 30));
+        }
+
+        return (chbevl(32.0 / x - 2.0, detail::i0_B, 25) / std::sqrt(x));
+    }
+
+} // namespace cephes
+} // namespace xsf

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/special/xsf/cephes/i1.h

@@ -0,0 +1,158 @@
+/* Translated into C++ by SciPy developers in 2024.
+ * Original header with Copyright information appears below.
+ */
+
+/*                                                     i1.c
+ *
+ *     Modified Bessel function of order one
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, y, i1();
+ *
+ * y = i1( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns modified Bessel function of order one of the
+ * argument.
+ *
+ * The function is defined as i1(x) = -i j1( ix ).
+ *
+ * The range is partitioned into the two intervals [0,8] and
+ * (8, infinity).  Chebyshev polynomial expansions are employed
+ * in each interval.
+ *
+ *
+ *
+ * ACCURACY:
+ *
+ *                      Relative error:
+ * arithmetic   domain     # trials      peak         rms
+ *    IEEE      0, 30       30000       1.9e-15     2.1e-16
+ *
+ *
+ */
+/*							i1e.c
+ *
+ *	Modified Bessel function of order one,
+ *	exponentially scaled
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, y, i1e();
+ *
+ * y = i1e( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns exponentially scaled modified Bessel function
+ * of order one of the argument.
+ *
+ * The function is defined as i1(x) = -i exp(-|x|) j1( ix ).
+ *
+ *
+ *
+ * ACCURACY:
+ *
+ *                      Relative error:
+ * arithmetic   domain     # trials      peak         rms
+ *    IEEE      0, 30       30000       2.0e-15     2.0e-16
+ * See i1().
+ *
+ */
+
+/*                                                     i1.c 2          */
+
+/*
+ * Cephes Math Library Release 2.8:  June, 2000
+ * Copyright 1985, 1987, 2000 by Stephen L. Moshier
+ */
+#pragma once
+
+#include "../config.h"
+#include "chbevl.h"
+
+namespace xsf {
+namespace cephes {
+
+    namespace detail {
+
+        /* Chebyshev coefficients for exp(-x) I1(x) / x
+         * in the interval [0,8].
+         *
+         * lim(x->0){ exp(-x) I1(x) / x } = 1/2.
+         */
+
+        constexpr double i1_A[] = {
+            2.77791411276104639959E-18,  -2.11142121435816608115E-17, 1.55363195773620046921E-16,
+            -1.10559694773538630805E-15, 7.60068429473540693410E-15,  -5.04218550472791168711E-14,
+            3.22379336594557470981E-13,  -1.98397439776494371520E-12, 1.17361862988909016308E-11,
+            -6.66348972350202774223E-11, 3.62559028155211703701E-10,  -1.88724975172282928790E-9,
+            9.38153738649577178388E-9,   -4.44505912879632808065E-8,  2.00329475355213526229E-7,
+            -8.56872026469545474066E-7,  3.47025130813767847674E-6,   -1.32731636560394358279E-5,
+            4.78156510755005422638E-5,   -1.61760815825896745588E-4,  5.12285956168575772895E-4,
+            -1.51357245063125314899E-3,  4.15642294431288815669E-3,   -1.05640848946261981558E-2,
+            2.47264490306265168283E-2,   -5.29459812080949914269E-2,  1.02643658689847095384E-1,
+            -1.76416518357834055153E-1,  2.52587186443633654823E-1};
+
+        /* Chebyshev coefficients for exp(-x) sqrt(x) I1(x)
+         * in the inverted interval [8,infinity].
+         *
+         * lim(x->inf){ exp(-x) sqrt(x) I1(x) } = 1/sqrt(2pi).
+         */
+        constexpr double i1_B[] = {
+            7.51729631084210481353E-18,  4.41434832307170791151E-18,  -4.65030536848935832153E-17,
+            -3.20952592199342395980E-17, 2.96262899764595013876E-16,  3.30820231092092828324E-16,
+            -1.88035477551078244854E-15, -3.81440307243700780478E-15, 1.04202769841288027642E-14,
+            4.27244001671195135429E-14,  -2.10154184277266431302E-14, -4.08355111109219731823E-13,
+            -7.19855177624590851209E-13, 2.03562854414708950722E-12,  1.41258074366137813316E-11,
+            3.25260358301548823856E-11,  -1.89749581235054123450E-11, -5.58974346219658380687E-10,
+            -3.83538038596423702205E-9,  -2.63146884688951950684E-8,  -2.51223623787020892529E-7,
+            -3.88256480887769039346E-6,  -1.10588938762623716291E-4,  -9.76109749136146840777E-3,
+            7.78576235018280120474E-1};
+
+    } // namespace detail
+
+    XSF_HOST_DEVICE inline double i1(double x) {
+        double y, z;
+
+        z = std::abs(x);
+        if (z <= 8.0) {
+            y = (z / 2.0) - 2.0;
+            z = chbevl(y, detail::i1_A, 29) * z * std::exp(z);
+        } else {
+            z = std::exp(z) * chbevl(32.0 / z - 2.0, detail::i1_B, 25) / std::sqrt(z);
+        }
+        if (x < 0.0)
+            z = -z;
+        return (z);
+    }
+
+    /*                                                     i1e()   */
+
+    XSF_HOST_DEVICE inline double i1e(double x) {
+        double y, z;
+
+        z = std::abs(x);
+        if (z <= 8.0) {
+            y = (z / 2.0) - 2.0;
+            z = chbevl(y, detail::i1_A, 29) * z;
+        } else {
+            z = chbevl(32.0 / z - 2.0, detail::i1_B, 25) / std::sqrt(z);
+        }
+        if (x < 0.0)
+            z = -z;
+        return (z);
+    }
+
+} // namespace cephes
+} // namespace xsf

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/special/xsf/cephes/igam.h

@@ -0,0 +1,421 @@
+/* Translated into C++ by SciPy developers in 2024.
+ * Original header with Copyright information appears below.
+ */
+
+/*                                                     igam.c
+ *
+ *     Incomplete Gamma integral
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double a, x, y, igam();
+ *
+ * y = igam( a, x );
+ *
+ * DESCRIPTION:
+ *
+ * The function is defined by
+ *
+ *                           x
+ *                            -
+ *                   1       | |  -t  a-1
+ *  igam(a,x)  =   -----     |   e   t   dt.
+ *                  -      | |
+ *                 | (a)    -
+ *                           0
+ *
+ *
+ * In this implementation both arguments must be positive.
+ * The integral is evaluated by either a power series or
+ * continued fraction expansion, depending on the relative
+ * values of a and x.
+ *
+ * ACCURACY:
+ *
+ *                      Relative error:
+ * arithmetic   domain     # trials      peak         rms
+ *    IEEE      0,30       200000       3.6e-14     2.9e-15
+ *    IEEE      0,100      300000       9.9e-14     1.5e-14
+ */
+/*							igamc()
+ *
+ *	Complemented incomplete Gamma integral
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double a, x, y, igamc();
+ *
+ * y = igamc( a, x );
+ *
+ * DESCRIPTION:
+ *
+ * The function is defined by
+ *
+ *
+ *  igamc(a,x)   =   1 - igam(a,x)
+ *
+ *                            inf.
+ *                              -
+ *                     1       | |  -t  a-1
+ *               =   -----     |   e   t   dt.
+ *                    -      | |
+ *                   | (a)    -
+ *                             x
+ *
+ *
+ * In this implementation both arguments must be positive.
+ * The integral is evaluated by either a power series or
+ * continued fraction expansion, depending on the relative
+ * values of a and x.
+ *
+ * ACCURACY:
+ *
+ * Tested at random a, x.
+ *                a         x                      Relative error:
+ * arithmetic   domain   domain     # trials      peak         rms
+ *    IEEE     0.5,100   0,100      200000       1.9e-14     1.7e-15
+ *    IEEE     0.01,0.5  0,100      200000       1.4e-13     1.6e-15
+ */
+
+/*
+ * Cephes Math Library Release 2.0:  April, 1987
+ * Copyright 1985, 1987 by Stephen L. Moshier
+ * Direct inquiries to 30 Frost Street, Cambridge, MA 02140
+ */
+
+/* Sources
+ * [1] "The Digital Library of Mathematical Functions", dlmf.nist.gov
+ * [2] Maddock et. al., "Incomplete Gamma Functions",
+ *     https://www.boost.org/doc/libs/1_61_0/libs/math/doc/html/math_toolkit/sf_gamma/igamma.html
+ */
+
+/* Scipy changes:
+ * - 05-01-2016: added asymptotic expansion for igam to improve the
+ *   a ~ x regime.
+ * - 06-19-2016: additional series expansion added for igamc to
+ *   improve accuracy at small arguments.
+ * - 06-24-2016: better choice of domain for the asymptotic series;
+ *   improvements in accuracy for the asymptotic series when a and x
+ *   are very close.
+ */
+#pragma once
+
+#include "../config.h"
+#include "../error.h"
+
+#include "const.h"
+#include "gamma.h"
+#include "igam_asymp_coeff.h"
+#include "lanczos.h"
+#include "ndtr.h"
+#include "unity.h"
+
+namespace xsf {
+namespace cephes {
+
+    namespace detail {
+
+        constexpr int igam_MAXITER = 2000;
+        constexpr int IGAM = 1;
+        constexpr int IGAMC = 0;
+        constexpr double igam_SMALL = 20;
+        constexpr double igam_LARGE = 200;
+        constexpr double igam_SMALLRATIO = 0.3;
+        constexpr double igam_LARGERATIO = 4.5;
+
+        constexpr double igam_big = 4.503599627370496e15;
+        constexpr double igam_biginv = 2.22044604925031308085e-16;
+
+        /* Compute
+         *
+         * x^a * exp(-x) / gamma(a)
+         *
+         * corrected from (15) and (16) in [2] by replacing exp(x - a) with
+         * exp(a - x).
+         */
+        XSF_HOST_DEVICE inline double igam_fac(double a, double x) {
+            double ax, fac, res, num;
+
+            if (std::abs(a - x) > 0.4 * std::abs(a)) {
+                ax = a * std::log(x) - x - xsf::cephes::lgam(a);
+                if (ax < -MAXLOG) {
+                    set_error("igam", SF_ERROR_UNDERFLOW, NULL);
+                    return 0.0;
+                }
+                return std::exp(ax);
+            }
+
+            fac = a + xsf::cephes::lanczos_g - 0.5;
+            res = std::sqrt(fac / std::exp(1)) / xsf::cephes::lanczos_sum_expg_scaled(a);
+
+            if ((a < 200) && (x < 200)) {
+                res *= std::exp(a - x) * std::pow(x / fac, a);
+            } else {
+                num = x - a - xsf::cephes::lanczos_g + 0.5;
+                res *= std::exp(a * xsf::cephes::log1pmx(num / fac) + x * (0.5 - xsf::cephes::lanczos_g) / fac);
+            }
+
+            return res;
+        }
+
+        /* Compute igamc using DLMF 8.9.2. */
+        XSF_HOST_DEVICE inline double igamc_continued_fraction(double a, double x) {
+            int i;
+            double ans, ax, c, yc, r, t, y, z;
+            double pk, pkm1, pkm2, qk, qkm1, qkm2;
+
+            ax = igam_fac(a, x);
+            if (ax == 0.0) {
+                return 0.0;
+            }
+
+            /* continued fraction */
+            y = 1.0 - a;
+            z = x + y + 1.0;
+            c = 0.0;
+            pkm2 = 1.0;
+            qkm2 = x;
+            pkm1 = x + 1.0;
+            qkm1 = z * x;
+            ans = pkm1 / qkm1;
+
+            for (i = 0; i < igam_MAXITER; i++) {
+                c += 1.0;
+                y += 1.0;
+                z += 2.0;
+                yc = y * c;
+                pk = pkm1 * z - pkm2 * yc;
+                qk = qkm1 * z - qkm2 * yc;
+                if (qk != 0) {
+                    r = pk / qk;
+                    t = std::abs((ans - r) / r);
+                    ans = r;
+                } else
+                    t = 1.0;
+                pkm2 = pkm1;
+                pkm1 = pk;
+                qkm2 = qkm1;
+                qkm1 = qk;
+                if (std::abs(pk) > igam_big) {
+                    pkm2 *= igam_biginv;
+                    pkm1 *= igam_biginv;
+                    qkm2 *= igam_biginv;
+                    qkm1 *= igam_biginv;
+                }
+                if (t <= MACHEP) {
+                    break;
+                }
+            }
+
+            return (ans * ax);
+        }
+
+        /* Compute igam using DLMF 8.11.4. */
+        XSF_HOST_DEVICE inline double igam_series(double a, double x) {
+            int i;
+            double ans, ax, c, r;
+
+            ax = igam_fac(a, x);
+            if (ax == 0.0) {
+                return 0.0;
+            }
+
+            /* power series */
+            r = a;
+            c = 1.0;
+            ans = 1.0;
+
+            for (i = 0; i < igam_MAXITER; i++) {
+                r += 1.0;
+                c *= x / r;
+                ans += c;
+                if (c <= MACHEP * ans) {
+                    break;
+                }
+            }
+
+            return (ans * ax / a);
+        }
+
+        /* Compute igamc using DLMF 8.7.3. This is related to the series in
+         * igam_series but extra care is taken to avoid cancellation.
+         */
+        XSF_HOST_DEVICE inline double igamc_series(double a, double x) {
+            int n;
+            double fac = 1;
+            double sum = 0;
+            double term, logx;
+
+            for (n = 1; n < igam_MAXITER; n++) {
+                fac *= -x / n;
+                term = fac / (a + n);
+                sum += term;
+                if (std::abs(term) <= MACHEP * std::abs(sum)) {
+                    break;
+                }
+            }
+
+            logx = std::log(x);
+            term = -xsf::cephes::expm1(a * logx - xsf::cephes::lgam1p(a));
+            return term - std::exp(a * logx - xsf::cephes::lgam(a)) * sum;
+        }
+
+        /* Compute igam/igamc using DLMF 8.12.3/8.12.4. */
+        XSF_HOST_DEVICE inline double asymptotic_series(double a, double x, int func) {
+            int k, n, sgn;
+            int maxpow = 0;
+            double lambda = x / a;
+            double sigma = (x - a) / a;
+            double eta, res, ck, ckterm, term, absterm;
+            double absoldterm = std::numeric_limits<double>::infinity();
+            double etapow[detail::igam_asymp_coeff_N] = {1};
+            double sum = 0;
+            double afac = 1;
+
+            if (func == detail::IGAM) {
+                sgn = -1;
+            } else {
+                sgn = 1;
+            }
+
+            if (lambda > 1) {
+                eta = std::sqrt(-2 * xsf::cephes::log1pmx(sigma));
+            } else if (lambda < 1) {
+                eta = -std::sqrt(-2 * xsf::cephes::log1pmx(sigma));
+            } else {
+                eta = 0;
+            }
+            res = 0.5 * xsf::cephes::erfc(sgn * eta * std::sqrt(a / 2));
+
+            for (k = 0; k < igam_asymp_coeff_K; k++) {
+                ck = igam_asymp_coeff_d[k][0];
+                for (n = 1; n < igam_asymp_coeff_N; n++) {
+                    if (n > maxpow) {
+                        etapow[n] = eta * etapow[n - 1];
+                        maxpow += 1;
+                    }
+                    ckterm = igam_asymp_coeff_d[k][n] * etapow[n];
+                    ck += ckterm;
+                    if (std::abs(ckterm) < MACHEP * std::abs(ck)) {
+                        break;
+                    }
+                }
+                term = ck * afac;
+                absterm = std::abs(term);
+                if (absterm > absoldterm) {
+                    break;
+                }
+                sum += term;
+                if (absterm < MACHEP * std::abs(sum)) {
+                    break;
+                }
+                absoldterm = absterm;
+                afac /= a;
+            }
+            res += sgn * std::exp(-0.5 * a * eta * eta) * sum / std::sqrt(2 * M_PI * a);
+
+            return res;
+        }
+
+    } // namespace detail
+
+    XSF_HOST_DEVICE inline double igamc(double a, double x);
+
+    XSF_HOST_DEVICE inline double igam(double a, double x) {
+        double absxma_a;
+
+        if (x < 0 || a < 0) {
+            set_error("gammainc", SF_ERROR_DOMAIN, NULL);
+            return std::numeric_limits<double>::quiet_NaN();
+        } else if (a == 0) {
+            if (x > 0) {
+                return 1;
+            } else {
+                return std::numeric_limits<double>::quiet_NaN();
+            }
+        } else if (x == 0) {
+            /* Zero integration limit */
+            return 0;
+        } else if (std::isinf(a)) {
+            if (std::isinf(x)) {
+                return std::numeric_limits<double>::quiet_NaN();
+            }
+            return 0;
+        } else if (std::isinf(x)) {
+            return 1;
+        }
+
+        /* Asymptotic regime where a ~ x; see [2]. */
+        absxma_a = std::abs(x - a) / a;
+        if ((a > detail::igam_SMALL) && (a < detail::igam_LARGE) && (absxma_a < detail::igam_SMALLRATIO)) {
+            return detail::asymptotic_series(a, x, detail::IGAM);
+        } else if ((a > detail::igam_LARGE) && (absxma_a < detail::igam_LARGERATIO / std::sqrt(a))) {
+            return detail::asymptotic_series(a, x, detail::IGAM);
+        }
+
+        if ((x > 1.0) && (x > a)) {
+            return (1.0 - igamc(a, x));
+        }
+
+        return detail::igam_series(a, x);
+    }
+
+    XSF_HOST_DEVICE double igamc(double a, double x) {
+        double absxma_a;
+
+        if (x < 0 || a < 0) {
+            set_error("gammaincc", SF_ERROR_DOMAIN, NULL);
+            return std::numeric_limits<double>::quiet_NaN();
+        } else if (a == 0) {
+            if (x > 0) {
+                return 0;
+            } else {
+                return std::numeric_limits<double>::quiet_NaN();
+            }
+        } else if (x == 0) {
+            return 1;
+        } else if (std::isinf(a)) {
+            if (std::isinf(x)) {
+                return std::numeric_limits<double>::quiet_NaN();
+            }
+            return 1;
+        } else if (std::isinf(x)) {
+            return 0;
+        }
+
+        /* Asymptotic regime where a ~ x; see [2]. */
+        absxma_a = std::abs(x - a) / a;
+        if ((a > detail::igam_SMALL) && (a < detail::igam_LARGE) && (absxma_a < detail::igam_SMALLRATIO)) {
+            return detail::asymptotic_series(a, x, detail::IGAMC);
+        } else if ((a > detail::igam_LARGE) && (absxma_a < detail::igam_LARGERATIO / std::sqrt(a))) {
+            return detail::asymptotic_series(a, x, detail::IGAMC);
+        }
+
+        /* Everywhere else; see [2]. */
+        if (x > 1.1) {
+            if (x < a) {
+                return 1.0 - detail::igam_series(a, x);
+            } else {
+                return detail::igamc_continued_fraction(a, x);
+            }
+        } else if (x <= 0.5) {
+            if (-0.4 / std::log(x) < a) {
+                return 1.0 - detail::igam_series(a, x);
+            } else {
+                return detail::igamc_series(a, x);
+            }
+        } else {
+            if (x * 1.1 < a) {
+                return 1.0 - detail::igam_series(a, x);
+            } else {
+                return detail::igamc_series(a, x);
+            }
+        }
+    }
+
+} // namespace cephes
+} // namespace xsf

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/special/xsf/cephes/igam_asymp_coeff.h

@@ -0,0 +1,195 @@
+/* Translated into C++ by SciPy developers in 2024.  */
+
+/* This file was automatically generated by _precomp/gammainc.py.
+ * Do not edit it manually!
+ */
+#pragma once
+
+namespace xsf {
+namespace cephes {
+
+    namespace detail {
+
+        constexpr int igam_asymp_coeff_K = 25;
+        constexpr int igam_asymp_coeff_N = 25;
+
+        static const double igam_asymp_coeff_d[igam_asymp_coeff_K][igam_asymp_coeff_N] = {
+            {-3.3333333333333333e-1,  8.3333333333333333e-2,   -1.4814814814814815e-2,  1.1574074074074074e-3,
+             3.527336860670194e-4,    -1.7875514403292181e-4,  3.9192631785224378e-5,   -2.1854485106799922e-6,
+             -1.85406221071516e-6,    8.296711340953086e-7,    -1.7665952736826079e-7,  6.7078535434014986e-9,
+             1.0261809784240308e-8,   -4.3820360184533532e-9,  9.1476995822367902e-10,  -2.551419399494625e-11,
+             -5.8307721325504251e-11, 2.4361948020667416e-11,  -5.0276692801141756e-12, 1.1004392031956135e-13,
+             3.3717632624009854e-13,  -1.3923887224181621e-13, 2.8534893807047443e-14,  -5.1391118342425726e-16,
+             -1.9752288294349443e-15},
+            {-1.8518518518518519e-3,  -3.4722222222222222e-3,  2.6455026455026455e-3,   -9.9022633744855967e-4,
+             2.0576131687242798e-4,   -4.0187757201646091e-7,  -1.8098550334489978e-5,  7.6491609160811101e-6,
+             -1.6120900894563446e-6,  4.6471278028074343e-9,   1.378633446915721e-7,    -5.752545603517705e-8,
+             1.1951628599778147e-8,   -1.7543241719747648e-11, -1.0091543710600413e-9,  4.1627929918425826e-10,
+             -8.5639070264929806e-11, 6.0672151016047586e-14,  7.1624989648114854e-12,  -2.9331866437714371e-12,
+             5.9966963656836887e-13,  -2.1671786527323314e-16, -4.9783399723692616e-14, 2.0291628823713425e-14,
+             -4.13125571381061e-15},
+            {4.1335978835978836e-3,   -2.6813271604938272e-3,  7.7160493827160494e-4,  2.0093878600823045e-6,
+             -1.0736653226365161e-4,  5.2923448829120125e-5,   -1.2760635188618728e-5, 3.4235787340961381e-8,
+             1.3721957309062933e-6,   -6.298992138380055e-7,   1.4280614206064242e-7,  -2.0477098421990866e-10,
+             -1.4092529910867521e-8,  6.228974084922022e-9,    -1.3670488396617113e-9, 9.4283561590146782e-13,
+             1.2872252400089318e-10,  -5.5645956134363321e-11, 1.1975935546366981e-11, -4.1689782251838635e-15,
+             -1.0940640427884594e-12, 4.6622399463901357e-13,  -9.905105763906906e-14, 1.8931876768373515e-17,
+             8.8592218725911273e-15},
+            {6.4943415637860082e-4,   2.2947209362139918e-4,   -4.6918949439525571e-4,  2.6772063206283885e-4,
+             -7.5618016718839764e-5,  -2.3965051138672967e-7,  1.1082654115347302e-5,   -5.6749528269915966e-6,
+             1.4230900732435884e-6,   -2.7861080291528142e-11, -1.6958404091930277e-7,  8.0994649053880824e-8,
+             -1.9111168485973654e-8,  2.3928620439808118e-12,  2.0620131815488798e-9,   -9.4604966618551322e-10,
+             2.1541049775774908e-10,  -1.388823336813903e-14,  -2.1894761681963939e-11, 9.7909989511716851e-12,
+             -2.1782191880180962e-12, 6.2088195734079014e-17,  2.126978363279737e-13,   -9.3446887915174333e-14,
+             2.0453671226782849e-14},
+            {-8.618882909167117e-4,   7.8403922172006663e-4,   -2.9907248030319018e-4, -1.4638452578843418e-6,
+             6.6414982154651222e-5,   -3.9683650471794347e-5,  1.1375726970678419e-5,  2.5074972262375328e-10,
+             -1.6954149536558306e-6,  8.9075075322053097e-7,   -2.2929348340008049e-7, 2.956794137544049e-11,
+             2.8865829742708784e-8,   -1.4189739437803219e-8,  3.4463580499464897e-9,  -2.3024517174528067e-13,
+             -3.9409233028046405e-10, 1.8602338968504502e-10,  -4.356323005056618e-11, 1.2786001016296231e-15,
+             4.6792750266579195e-12,  -2.1492464706134829e-12, 4.9088156148096522e-13, -6.3385914848915603e-18,
+             -5.0453320690800944e-14},
+            {-3.3679855336635815e-4,  -6.9728137583658578e-5,  2.7727532449593921e-4,  -1.9932570516188848e-4,
+             6.7977804779372078e-5,   1.419062920643967e-7,    -1.3594048189768693e-5, 8.0184702563342015e-6,
+             -2.2914811765080952e-6,  -3.252473551298454e-10,  3.4652846491085265e-7,  -1.8447187191171343e-7,
+             4.8240967037894181e-8,   -1.7989466721743515e-14, -6.3061945000135234e-9, 3.1624176287745679e-9,
+             -7.8409242536974293e-10, 5.1926791652540407e-15,  9.3589442423067836e-11, -4.5134262161632782e-11,
+             1.0799129993116827e-11,  -3.661886712685252e-17,  -1.210902069055155e-12, 5.6807435849905643e-13,
+             -1.3249659916340829e-13},
+            {5.3130793646399222e-4,   -5.9216643735369388e-4,  2.7087820967180448e-4,   7.9023532326603279e-7,
+             -8.1539693675619688e-5,  5.6116827531062497e-5,   -1.8329116582843376e-5,  -3.0796134506033048e-9,
+             3.4651553688036091e-6,   -2.0291327396058604e-6,  5.7887928631490037e-7,   2.338630673826657e-13,
+             -8.8286007463304835e-8,  4.7435958880408128e-8,   -1.2545415020710382e-8,  8.6496488580102925e-14,
+             1.6846058979264063e-9,   -8.5754928235775947e-10, 2.1598224929232125e-10,  -7.6132305204761539e-16,
+             -2.6639822008536144e-11, 1.3065700536611057e-11,  -3.1799163902367977e-12, 4.7109761213674315e-18,
+             3.6902800842763467e-13},
+            {3.4436760689237767e-4,   5.1717909082605922e-5,   -3.3493161081142236e-4,  2.812695154763237e-4,
+             -1.0976582244684731e-4,  -1.2741009095484485e-7,  2.7744451511563644e-5,   -1.8263488805711333e-5,
+             5.7876949497350524e-6,   4.9387589339362704e-10,  -1.0595367014026043e-6,  6.1667143761104075e-7,
+             -1.7562973359060462e-7,  -1.2974473287015439e-12, 2.695423606288966e-8,    -1.4578352908731271e-8,
+             3.887645959386175e-9,    -3.8810022510194121e-17, -5.3279941738772867e-10, 2.7437977643314845e-10,
+             -6.9957960920705679e-11, 2.5899863874868481e-17,  8.8566890996696381e-12,  -4.403168815871311e-12,
+             1.0865561947091654e-12},
+            {-6.5262391859530942e-4, 8.3949872067208728e-4,   -4.3829709854172101e-4, -6.969091458420552e-7,
+             1.6644846642067548e-4,  -1.2783517679769219e-4,  4.6299532636913043e-5,  4.5579098679227077e-9,
+             -1.0595271125805195e-5, 6.7833429048651666e-6,   -2.1075476666258804e-6, -1.7213731432817145e-11,
+             3.7735877416110979e-7,  -2.1867506700122867e-7,  6.2202288040189269e-8,  6.5977038267330006e-16,
+             -9.5903864974256858e-9, 5.2132144922808078e-9,   -1.3991589583935709e-9, 5.382058999060575e-16,
+             1.9484714275467745e-10, -1.0127287556389682e-10, 2.6077347197254926e-11, -5.0904186999932993e-18,
+             -3.3721464474854592e-12},
+            {-5.9676129019274625e-4, -7.2048954160200106e-5,  6.7823088376673284e-4,   -6.4014752602627585e-4,
+             2.7750107634328704e-4,  1.8197008380465151e-7,   -8.4795071170685032e-5,  6.105192082501531e-5,
+             -2.1073920183404862e-5, -8.8585890141255994e-10, 4.5284535953805377e-6,   -2.8427815022504408e-6,
+             8.7082341778646412e-7,  3.6886101871706965e-12,  -1.5344695190702061e-7,  8.862466778790695e-8,
+             -2.5184812301826817e-8, -1.0225912098215092e-14, 3.8969470758154777e-9,   -2.1267304792235635e-9,
+             5.7370135528051385e-10, -1.887749850169741e-19,  -8.0931538694657866e-11, 4.2382723283449199e-11,
+             -1.1002224534207726e-11},
+            {1.3324454494800656e-3,  -1.9144384985654775e-3, 1.1089369134596637e-3,   9.932404122642299e-7,
+             -5.0874501293093199e-4, 4.2735056665392884e-4,  -1.6858853767910799e-4,  -8.1301893922784998e-9,
+             4.5284402370562147e-5,  -3.127053674781734e-5,  1.044986828530338e-5,    4.8435226265680926e-11,
+             -2.1482565873456258e-6, 1.329369701097492e-6,   -4.0295693092101029e-7,  -1.7567877666323291e-13,
+             7.0145043163668257e-8,  -4.040787734999483e-8,  1.1474026743371963e-8,   3.9642746853563325e-18,
+             -1.7804938269892714e-9, 9.7480262548731646e-10, -2.6405338676507616e-10, 5.794875163403742e-18,
+             3.7647749553543836e-11},
+            {1.579727660730835e-3,   1.6251626278391582e-4,   -2.0633421035543276e-3, 2.1389686185689098e-3,
+             -1.0108559391263003e-3, -3.9912705529919201e-7,  3.6235025084764691e-4,  -2.8143901463712154e-4,
+             1.0449513336495887e-4,  2.1211418491830297e-9,   -2.5779417251947842e-5, 1.7281818956040463e-5,
+             -5.6413773872904282e-6, -1.1024320105776174e-11, 1.1223224418895175e-6,  -6.8693396379526735e-7,
+             2.0653236975414887e-7,  4.6714772409838506e-14,  -3.5609886164949055e-8, 2.0470855345905963e-8,
+             -5.8091738633283358e-9, -1.332821287582869e-16,  9.0354604391335133e-10, -4.9598782517330834e-10,
+             1.3481607129399749e-10},
+            {-4.0725121195140166e-3, 6.4033628338080698e-3,  -4.0410161081676618e-3, -2.183732802866233e-6,
+             2.1740441801254639e-3,  -1.9700440518418892e-3, 8.3595469747962458e-4,  1.9445447567109655e-8,
+             -2.5779387120421696e-4, 1.9009987368139304e-4,  -6.7696499937438965e-5, -1.4440629666426572e-10,
+             1.5712512518742269e-5,  -1.0304008744776893e-5, 3.304517767401387e-6,   7.9829760242325709e-13,
+             -6.4097794149313004e-7, 3.8894624761300056e-7,  -1.1618347644948869e-7, -2.816808630596451e-15,
+             1.9878012911297093e-8,  -1.1407719956357511e-8, 3.2355857064185555e-9,  4.1759468293455945e-20,
+             -5.0423112718105824e-10},
+            {-5.9475779383993003e-3, -5.4016476789260452e-4,  8.7910413550767898e-3,  -9.8576315587856125e-3,
+             5.0134695031021538e-3,  1.2807521786221875e-6,   -2.0626019342754683e-3, 1.7109128573523058e-3,
+             -6.7695312714133799e-4, -6.9011545676562133e-9,  1.8855128143995902e-4,  -1.3395215663491969e-4,
+             4.6263183033528039e-5,  4.0034230613321351e-11,  -1.0255652921494033e-5, 6.612086372797651e-6,
+             -2.0913022027253008e-6, -2.0951775649603837e-13, 3.9756029041993247e-7,  -2.3956211978815887e-7,
+             7.1182883382145864e-8,  8.925574873053455e-16,   -1.2101547235064676e-8, 6.9350618248334386e-9,
+             -1.9661464453856102e-9},
+            {1.7402027787522711e-2,  -2.9527880945699121e-2, 2.0045875571402799e-2,  7.0289515966903407e-6,
+             -1.2375421071343148e-2, 1.1976293444235254e-2,  -5.4156038466518525e-3, -6.3290893396418616e-8,
+             1.8855118129005065e-3,  -1.473473274825001e-3,  5.5515810097708387e-4,  5.2406834412550662e-10,
+             -1.4357913535784836e-4, 9.9181293224943297e-5,  -3.3460834749478311e-5, -3.5755837291098993e-12,
+             7.1560851960630076e-6,  -4.5516802628155526e-6, 1.4236576649271475e-6,  1.8803149082089664e-14,
+             -2.6623403898929211e-7, 1.5950642189595716e-7,  -4.7187514673841102e-8, -6.5107872958755177e-17,
+             7.9795091026746235e-9},
+            {3.0249124160905891e-2,  2.4817436002649977e-3,  -4.9939134373457022e-2, 5.9915643009307869e-2,
+             -3.2483207601623391e-2, -5.7212968652103441e-6, 1.5085251778569354e-2,  -1.3261324005088445e-2,
+             5.5515262632426148e-3,  3.0263182257030016e-8,  -1.7229548406756723e-3, 1.2893570099929637e-3,
+             -4.6845138348319876e-4, -1.830259937893045e-10, 1.1449739014822654e-4,  -7.7378565221244477e-5,
+             2.5625836246985201e-5,  1.0766165333192814e-12, -5.3246809282422621e-6, 3.349634863064464e-6,
+             -1.0381253128684018e-6, -5.608909920621128e-15, 1.9150821930676591e-7,  -1.1418365800203486e-7,
+             3.3654425209171788e-8},
+            {-9.9051020880159045e-2, 1.7954011706123486e-1,  -1.2989606383463778e-1, -3.1478872752284357e-5,
+             9.0510635276848131e-2,  -9.2828824411184397e-2, 4.4412112839877808e-2,  2.7779236316835888e-7,
+             -1.7229543805449697e-2, 1.4182925050891573e-2,  -5.6214161633747336e-3, -2.39598509186381e-9,
+             1.6029634366079908e-3,  -1.1606784674435773e-3, 4.1001337768153873e-4,  1.8365800754090661e-11,
+             -9.5844256563655903e-5, 6.3643062337764708e-5,  -2.076250624489065e-5,  -1.1806020912804483e-13,
+             4.2131808239120649e-6,  -2.6262241337012467e-6, 8.0770620494930662e-7,  6.0125912123632725e-16,
+             -1.4729737374018841e-7},
+            {-1.9994542198219728e-1, -1.5056113040026424e-2,  3.6470239469348489e-1,  -4.6435192311733545e-1,
+             2.6640934719197893e-1,  3.4038266027147191e-5,   -1.3784338709329624e-1, 1.276467178337056e-1,
+             -5.6213828755200985e-2, -1.753150885483011e-7,   1.9235592956768113e-2,  -1.5088821281095315e-2,
+             5.7401854451350123e-3,  1.0622382710310225e-9,   -1.5335082692563998e-3, 1.0819320643228214e-3,
+             -3.7372510193945659e-4, -6.6170909729031985e-12, 8.4263617380909628e-5,  -5.5150706827483479e-5,
+             1.7769536448348069e-5,  3.8827923210205533e-14,  -3.53513697488768e-6,   2.1865832130045269e-6,
+             -6.6812849447625594e-7},
+            {7.2438608504029431e-1,  -1.3918010932653375,    1.0654143352413968,     1.876173868950258e-4,
+             -8.2705501176152696e-1, 8.9352433347828414e-1,  -4.4971003995291339e-1, -1.6107401567546652e-6,
+             1.9235590165271091e-1,  -1.6597702160042609e-1, 6.8882222681814333e-2,  1.3910091724608687e-8,
+             -2.146911561508663e-2,  1.6228980898865892e-2,  -5.9796016172584256e-3, -1.1287469112826745e-10,
+             1.5167451119784857e-3,  -1.0478634293553899e-3, 3.5539072889126421e-4,  8.1704322111801517e-13,
+             -7.7773013442452395e-5, 5.0291413897007722e-5,  -1.6035083867000518e-5, 1.2469354315487605e-14,
+             3.1369106244517615e-6},
+            {1.6668949727276811,     1.165462765994632e-1,   -3.3288393225018906,    4.4692325482864037,
+             -2.6977693045875807,    -2.600667859891061e-4,  1.5389017615694539,     -1.4937962361134612,
+             6.8881964633233148e-1,  1.3077482004552385e-6,  -2.5762963325596288e-1, 2.1097676102125449e-1,
+             -8.3714408359219882e-2, -7.7920428881354753e-9, 2.4267923064833599e-2,  -1.7813678334552311e-2,
+             6.3970330388900056e-3,  4.9430807090480523e-11, -1.5554602758465635e-3, 1.0561196919903214e-3,
+             -3.5277184460472902e-4, 9.3002334645022459e-14, 7.5285855026557172e-5,  -4.8186515569156351e-5,
+             1.5227271505597605e-5},
+            {-6.6188298861372935,    1.3397985455142589e+1,  -1.0789350606845146e+1, -1.4352254537875018e-3,
+             9.2333694596189809,     -1.0456552819547769e+1, 5.5105526029033471,     1.2024439690716742e-5,
+             -2.5762961164755816,    2.3207442745387179,     -1.0045728797216284,    -1.0207833290021914e-7,
+             3.3975092171169466e-1,  -2.6720517450757468e-1, 1.0235252851562706e-1,  8.4329730484871625e-10,
+             -2.7998284958442595e-2, 2.0066274144976813e-2,  -7.0554368915086242e-3, 1.9402238183698188e-12,
+             1.6562888105449611e-3,  -1.1082898580743683e-3, 3.654545161310169e-4,   -5.1290032026971794e-11,
+             -7.6340103696869031e-5},
+            {-1.7112706061976095e+1, -1.1208044642899116,     3.7131966511885444e+1,  -5.2298271025348962e+1,
+             3.3058589696624618e+1,  2.4791298976200222e-3,   -2.061089403411526e+1,  2.088672775145582e+1,
+             -1.0045703956517752e+1, -1.2238783449063012e-5,  4.0770134274221141,     -3.473667358470195,
+             1.4329352617312006,     7.1359914411879712e-8,   -4.4797257159115612e-1, 3.4112666080644461e-1,
+             -1.2699786326594923e-1, -2.8953677269081528e-10, 3.3125776278259863e-2,  -2.3274087021036101e-2,
+             8.0399993503648882e-3,  -1.177805216235265e-9,   -1.8321624891071668e-3, 1.2108282933588665e-3,
+             -3.9479941246822517e-4},
+            {7.389033153567425e+1,   -1.5680141270402273e+2, 1.322177542759164e+2,   1.3692876877324546e-2,
+             -1.2366496885920151e+2, 1.4620689391062729e+2,  -8.0365587724865346e+1, -1.1259851148881298e-4,
+             4.0770132196179938e+1,  -3.8210340013273034e+1, 1.719522294277362e+1,   9.3519707955168356e-7,
+             -6.2716159907747034,    5.1168999071852637,     -2.0319658112299095,    -4.9507215582761543e-9,
+             5.9626397294332597e-1,  -4.4220765337238094e-1, 1.6079998700166273e-1,  -2.4733786203223402e-8,
+             -4.0307574759979762e-2, 2.7849050747097869e-2,  -9.4751858992054221e-3, 6.419922235909132e-6,
+             2.1250180774699461e-3},
+            {2.1216837098382522e+2,  1.3107863022633868e+1,  -4.9698285932871748e+2, 7.3121595266969204e+2,
+             -4.8213821720890847e+2, -2.8817248692894889e-2, 3.2616720302947102e+2,  -3.4389340280087117e+2,
+             1.7195193870816232e+2,  1.4038077378096158e-4,  -7.52594195897599e+1,   6.651969984520934e+1,
+             -2.8447519748152462e+1, -7.613702615875391e-7,  9.5402237105304373,     -7.5175301113311376,
+             2.8943997568871961,     -4.6612194999538201e-7, -8.0615149598794088e-1, 5.8483006570631029e-1,
+             -2.0845408972964956e-1, 1.4765818959305817e-4,  5.1000433863753019e-2,  -3.3066252141883665e-2,
+             1.5109265210467774e-2},
+            {-9.8959643098322368e+2, 2.1925555360905233e+3,  -1.9283586782723356e+3, -1.5925738122215253e-1,
+             1.9569985945919857e+3,  -2.4072514765081556e+3, 1.3756149959336496e+3,  1.2920735237496668e-3,
+             -7.525941715948055e+2,  7.3171668742208716e+2,  -3.4137023466220065e+2, -9.9857390260608043e-6,
+             1.3356313181291573e+2,  -1.1276295161252794e+2, 4.6310396098204458e+1,  -7.9237387133614756e-6,
+             -1.4510726927018646e+1, 1.1111771248100563e+1,  -4.1690817945270892,    3.1008219800117808e-3,
+             1.1220095449981468,     -7.6052379926149916e-1, 3.6262236505085254e-1,  2.216867741940747e-1,
+             4.8683443692930507e-1}};
+
+    } // namespace detail
+} // namespace cephes
+} // namespace xsf

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/special/xsf/cephes/igami.h

@@ -0,0 +1,313 @@
+/* Translated into C++ by SciPy developers in 2024.
+ * Original header with Copyright information appears below.
+ */
+
+/*
+ * (C) Copyright John Maddock 2006.
+ * Use, modification and distribution are subject to the
+ * Boost Software License, Version 1.0. (See accompanying file
+ *  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
+ */
+#pragma once
+
+#include "../config.h"
+#include "../error.h"
+
+#include "const.h"
+#include "gamma.h"
+#include "igam.h"
+#include "polevl.h"
+
+namespace xsf {
+namespace cephes {
+
+    namespace detail {
+
+        XSF_HOST_DEVICE double find_inverse_s(double p, double q) {
+            /*
+             * Computation of the Incomplete Gamma Function Ratios and their Inverse
+             * ARMIDO R. DIDONATO and ALFRED H. MORRIS, JR.
+             * ACM Transactions on Mathematical Software, Vol. 12, No. 4,
+             * December 1986, Pages 377-393.
+             *
+             * See equation 32.
+             */
+            double s, t;
+            constexpr double a[4] = {0.213623493715853, 4.28342155967104, 11.6616720288968, 3.31125922108741};
+            constexpr double b[5] = {0.3611708101884203e-1, 1.27364489782223, 6.40691597760039, 6.61053765625462, 1};
+
+            if (p < 0.5) {
+                t = std::sqrt(-2 * std::log(p));
+            } else {
+                t = std::sqrt(-2 * std::log(q));
+            }
+            s = t - polevl(t, a, 3) / polevl(t, b, 4);
+            if (p < 0.5)
+                s = -s;
+            return s;
+        }
+
+        XSF_HOST_DEVICE inline double didonato_SN(double a, double x, unsigned N, double tolerance) {
+            /*
+             * Computation of the Incomplete Gamma Function Ratios and their Inverse
+             * ARMIDO R. DIDONATO and ALFRED H. MORRIS, JR.
+             * ACM Transactions on Mathematical Software, Vol. 12, No. 4,
+             * December 1986, Pages 377-393.
+             *
+             * See equation 34.
+             */
+            double sum = 1.0;
+
+            if (N >= 1) {
+                unsigned i;
+                double partial = x / (a + 1);
+
+                sum += partial;
+                for (i = 2; i <= N; ++i) {
+                    partial *= x / (a + i);
+                    sum += partial;
+                    if (partial < tolerance) {
+                        break;
+                    }
+                }
+            }
+            return sum;
+        }
+
+        XSF_HOST_DEVICE inline double find_inverse_gamma(double a, double p, double q) {
+            /*
+             * In order to understand what's going on here, you will
+             * need to refer to:
+             *
+             * Computation of the Incomplete Gamma Function Ratios and their Inverse
+             * ARMIDO R. DIDONATO and ALFRED H. MORRIS, JR.
+             * ACM Transactions on Mathematical Software, Vol. 12, No. 4,
+             * December 1986, Pages 377-393.
+             */
+            double result;
+
+            if (a == 1) {
+                if (q > 0.9) {
+                    result = -std::log1p(-p);
+                } else {
+                    result = -std::log(q);
+                }
+            } else if (a < 1) {
+                double g = xsf::cephes::Gamma(a);
+                double b = q * g;
+
+                if ((b > 0.6) || ((b >= 0.45) && (a >= 0.3))) {
+                    /* DiDonato & Morris Eq 21:
+                     *
+                     * There is a slight variation from DiDonato and Morris here:
+                     * the first form given here is unstable when p is close to 1,
+                     * making it impossible to compute the inverse of Q(a,x) for small
+                     * q. Fortunately the second form works perfectly well in this case.
+                     */
+                    double u;
+                    if ((b * q > 1e-8) && (q > 1e-5)) {
+                        u = std::pow(p * g * a, 1 / a);
+                    } else {
+                        u = std::exp((-q / a) - SCIPY_EULER);
+                    }
+                    result = u / (1 - (u / (a + 1)));
+                } else if ((a < 0.3) && (b >= 0.35)) {
+                    /* DiDonato & Morris Eq 22: */
+                    double t = std::exp(-SCIPY_EULER - b);
+                    double u = t * std::exp(t);
+                    result = t * std::exp(u);
+                } else if ((b > 0.15) || (a >= 0.3)) {
+                    /* DiDonato & Morris Eq 23: */
+                    double y = -std::log(b);
+                    double u = y - (1 - a) * std::log(y);
+                    result = y - (1 - a) * std::log(u) - std::log(1 + (1 - a) / (1 + u));
+                } else if (b > 0.1) {
+                    /* DiDonato & Morris Eq 24: */
+                    double y = -std::log(b);
+                    double u = y - (1 - a) * std::log(y);
+                    result = y - (1 - a) * std::log(u) -
+                             std::log((u * u + 2 * (3 - a) * u + (2 - a) * (3 - a)) / (u * u + (5 - a) * u + 2));
+                } else {
+                    /* DiDonato & Morris Eq 25: */
+                    double y = -std::log(b);
+                    double c1 = (a - 1) * std::log(y);
+                    double c1_2 = c1 * c1;
+                    double c1_3 = c1_2 * c1;
+                    double c1_4 = c1_2 * c1_2;
+                    double a_2 = a * a;
+                    double a_3 = a_2 * a;
+
+                    double c2 = (a - 1) * (1 + c1);
+                    double c3 = (a - 1) * (-(c1_2 / 2) + (a - 2) * c1 + (3 * a - 5) / 2);
+                    double c4 = (a - 1) * ((c1_3 / 3) - (3 * a - 5) * c1_2 / 2 + (a_2 - 6 * a + 7) * c1 +
+                                           (11 * a_2 - 46 * a + 47) / 6);
+                    double c5 = (a - 1) * (-(c1_4 / 4) + (11 * a - 17) * c1_3 / 6 + (-3 * a_2 + 13 * a - 13) * c1_2 +
+                                           (2 * a_3 - 25 * a_2 + 72 * a - 61) * c1 / 2 +
+                                           (25 * a_3 - 195 * a_2 + 477 * a - 379) / 12);
+
+                    double y_2 = y * y;
+                    double y_3 = y_2 * y;
+                    double y_4 = y_2 * y_2;
+                    result = y + c1 + (c2 / y) + (c3 / y_2) + (c4 / y_3) + (c5 / y_4);
+                }
+            } else {
+                /* DiDonato and Morris Eq 31: */
+                double s = find_inverse_s(p, q);
+
+                double s_2 = s * s;
+                double s_3 = s_2 * s;
+                double s_4 = s_2 * s_2;
+                double s_5 = s_4 * s;
+                double ra = std::sqrt(a);
+
+                double w = a + s * ra + (s_2 - 1) / 3;
+                w += (s_3 - 7 * s) / (36 * ra);
+                w -= (3 * s_4 + 7 * s_2 - 16) / (810 * a);
+                w += (9 * s_5 + 256 * s_3 - 433 * s) / (38880 * a * ra);
+
+                if ((a >= 500) && (std::abs(1 - w / a) < 1e-6)) {
+                    result = w;
+                } else if (p > 0.5) {
+                    if (w < 3 * a) {
+                        result = w;
+                    } else {
+                        double D = std::fmax(2, a * (a - 1));
+                        double lg = xsf::cephes::lgam(a);
+                        double lb = std::log(q) + lg;
+                        if (lb < -D * 2.3) {
+                            /* DiDonato and Morris Eq 25: */
+                            double y = -lb;
+                            double c1 = (a - 1) * std::log(y);
+                            double c1_2 = c1 * c1;
+                            double c1_3 = c1_2 * c1;
+                            double c1_4 = c1_2 * c1_2;
+                            double a_2 = a * a;
+                            double a_3 = a_2 * a;
+
+                            double c2 = (a - 1) * (1 + c1);
+                            double c3 = (a - 1) * (-(c1_2 / 2) + (a - 2) * c1 + (3 * a - 5) / 2);
+                            double c4 = (a - 1) * ((c1_3 / 3) - (3 * a - 5) * c1_2 / 2 + (a_2 - 6 * a + 7) * c1 +
+                                                   (11 * a_2 - 46 * a + 47) / 6);
+                            double c5 =
+                                (a - 1) * (-(c1_4 / 4) + (11 * a - 17) * c1_3 / 6 + (-3 * a_2 + 13 * a - 13) * c1_2 +
+                                           (2 * a_3 - 25 * a_2 + 72 * a - 61) * c1 / 2 +
+                                           (25 * a_3 - 195 * a_2 + 477 * a - 379) / 12);
+
+                            double y_2 = y * y;
+                            double y_3 = y_2 * y;
+                            double y_4 = y_2 * y_2;
+                            result = y + c1 + (c2 / y) + (c3 / y_2) + (c4 / y_3) + (c5 / y_4);
+                        } else {
+                            /* DiDonato and Morris Eq 33: */
+                            double u = -lb + (a - 1) * std::log(w) - std::log(1 + (1 - a) / (1 + w));
+                            result = -lb + (a - 1) * std::log(u) - std::log(1 + (1 - a) / (1 + u));
+                        }
+                    }
+                } else {
+                    double z = w;
+                    double ap1 = a + 1;
+                    double ap2 = a + 2;
+                    if (w < 0.15 * ap1) {
+                        /* DiDonato and Morris Eq 35: */
+                        double v = std::log(p) + xsf::cephes::lgam(ap1);
+                        z = std::exp((v + w) / a);
+                        s = std::log1p(z / ap1 * (1 + z / ap2));
+                        z = std::exp((v + z - s) / a);
+                        s = std::log1p(z / ap1 * (1 + z / ap2));
+                        z = std::exp((v + z - s) / a);
+                        s = std::log1p(z / ap1 * (1 + z / ap2 * (1 + z / (a + 3))));
+                        z = std::exp((v + z - s) / a);
+                    }
+
+                    if ((z <= 0.01 * ap1) || (z > 0.7 * ap1)) {
+                        result = z;
+                    } else {
+                        /* DiDonato and Morris Eq 36: */
+                        double ls = std::log(didonato_SN(a, z, 100, 1e-4));
+                        double v = std::log(p) + xsf::cephes::lgam(ap1);
+                        z = std::exp((v + z - ls) / a);
+                        result = z * (1 - (a * std::log(z) - z - v + ls) / (a - z));
+                    }
+                }
+            }
+            return result;
+        }
+
+    } // namespace detail
+
+    XSF_HOST_DEVICE inline double igamci(double a, double q);
+
+    XSF_HOST_DEVICE inline double igami(double a, double p) {
+        int i;
+        double x, fac, f_fp, fpp_fp;
+
+        if (std::isnan(a) || std::isnan(p)) {
+            return std::numeric_limits<double>::quiet_NaN();
+            ;
+        } else if ((a < 0) || (p < 0) || (p > 1)) {
+            set_error("gammaincinv", SF_ERROR_DOMAIN, NULL);
+        } else if (p == 0.0) {
+            return 0.0;
+        } else if (p == 1.0) {
+            return std::numeric_limits<double>::infinity();
+        } else if (p > 0.9) {
+            return igamci(a, 1 - p);
+        }
+
+        x = detail::find_inverse_gamma(a, p, 1 - p);
+        /* Halley's method */
+        for (i = 0; i < 3; i++) {
+            fac = detail::igam_fac(a, x);
+            if (fac == 0.0) {
+                return x;
+            }
+            f_fp = (igam(a, x) - p) * x / fac;
+            /* The ratio of the first and second derivatives simplifies */
+            fpp_fp = -1.0 + (a - 1) / x;
+            if (std::isinf(fpp_fp)) {
+                /* Resort to Newton's method in the case of overflow */
+                x = x - f_fp;
+            } else {
+                x = x - f_fp / (1.0 - 0.5 * f_fp * fpp_fp);
+            }
+        }
+
+        return x;
+    }
+
+    XSF_HOST_DEVICE inline double igamci(double a, double q) {
+        int i;
+        double x, fac, f_fp, fpp_fp;
+
+        if (std::isnan(a) || std::isnan(q)) {
+            return std::numeric_limits<double>::quiet_NaN();
+        } else if ((a < 0.0) || (q < 0.0) || (q > 1.0)) {
+            set_error("gammainccinv", SF_ERROR_DOMAIN, NULL);
+        } else if (q == 0.0) {
+            return std::numeric_limits<double>::infinity();
+        } else if (q == 1.0) {
+            return 0.0;
+        } else if (q > 0.9) {
+            return igami(a, 1 - q);
+        }
+
+        x = detail::find_inverse_gamma(a, 1 - q, q);
+        for (i = 0; i < 3; i++) {
+            fac = detail::igam_fac(a, x);
+            if (fac == 0.0) {
+                return x;
+            }
+            f_fp = (igamc(a, x) - q) * x / (-fac);
+            fpp_fp = -1.0 + (a - 1) / x;
+            if (std::isinf(fpp_fp)) {
+                x = x - f_fp;
+            } else {
+                x = x - f_fp / (1.0 - 0.5 * f_fp * fpp_fp);
+            }
+        }
+
+        return x;
+    }
+
+} // namespace cephes
+} // namespace xsf

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/special/xsf/cephes/j0.h

@@ -0,0 +1,225 @@
+/* Translated into C++ by SciPy developers in 2024.
+ * Original header with Copyright information appears below.
+ */
+
+/*                                                     j0.c
+ *
+ *     Bessel function of order zero
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, y, j0();
+ *
+ * y = j0( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns Bessel function of order zero of the argument.
+ *
+ * The domain is divided into the intervals [0, 5] and
+ * (5, infinity). In the first interval the following rational
+ * approximation is used:
+ *
+ *
+ *        2         2
+ * (w - r  ) (w - r  ) P (w) / Q (w)
+ *       1         2    3       8
+ *
+ *            2
+ * where w = x  and the two r's are zeros of the function.
+ *
+ * In the second interval, the Hankel asymptotic expansion
+ * is employed with two rational functions of degree 6/6
+ * and 7/7.
+ *
+ *
+ *
+ * ACCURACY:
+ *
+ *                      Absolute error:
+ * arithmetic   domain     # trials      peak         rms
+ *    IEEE      0, 30       60000       4.2e-16     1.1e-16
+ *
+ */
+/*							y0.c
+ *
+ *	Bessel function of the second kind, order zero
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, y, y0();
+ *
+ * y = y0( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns Bessel function of the second kind, of order
+ * zero, of the argument.
+ *
+ * The domain is divided into the intervals [0, 5] and
+ * (5, infinity). In the first interval a rational approximation
+ * R(x) is employed to compute
+ *   y0(x)  = R(x)  +   2 * log(x) * j0(x) / M_PI.
+ * Thus a call to j0() is required.
+ *
+ * In the second interval, the Hankel asymptotic expansion
+ * is employed with two rational functions of degree 6/6
+ * and 7/7.
+ *
+ *
+ *
+ * ACCURACY:
+ *
+ *  Absolute error, when y0(x) < 1; else relative error:
+ *
+ * arithmetic   domain     # trials      peak         rms
+ *    IEEE      0, 30       30000       1.3e-15     1.6e-16
+ *
+ */
+
+/*
+ * Cephes Math Library Release 2.8:  June, 2000
+ * Copyright 1984, 1987, 1989, 2000 by Stephen L. Moshier
+ */
+
+/* Note: all coefficients satisfy the relative error criterion
+ * except YP, YQ which are designed for absolute error. */
+#pragma once
+
+#include "../config.h"
+#include "../error.h"
+
+#include "const.h"
+#include "polevl.h"
+
+namespace xsf {
+namespace cephes {
+
+    namespace detail {
+
+        constexpr double j0_PP[7] = {
+            7.96936729297347051624E-4, 8.28352392107440799803E-2, 1.23953371646414299388E0,  5.44725003058768775090E0,
+            8.74716500199817011941E0,  5.30324038235394892183E0,  9.99999999999999997821E-1,
+        };
+
+        constexpr double j0_PQ[7] = {
+            9.24408810558863637013E-4, 8.56288474354474431428E-2, 1.25352743901058953537E0, 5.47097740330417105182E0,
+            8.76190883237069594232E0,  5.30605288235394617618E0,  1.00000000000000000218E0,
+        };
+
+        constexpr double j0_QP[8] = {
+            -1.13663838898469149931E-2, -1.28252718670509318512E0, -1.95539544257735972385E1, -9.32060152123768231369E1,
+            -1.77681167980488050595E2,  -1.47077505154951170175E2, -5.14105326766599330220E1, -6.05014350600728481186E0,
+        };
+
+        constexpr double j0_QQ[7] = {
+            /*  1.00000000000000000000E0, */
+            6.43178256118178023184E1, 8.56430025976980587198E2, 3.88240183605401609683E3, 7.24046774195652478189E3,
+            5.93072701187316984827E3, 2.06209331660327847417E3, 2.42005740240291393179E2,
+        };
+
+        constexpr double j0_YP[8] = {
+            1.55924367855235737965E4,   -1.46639295903971606143E7,  5.43526477051876500413E9,
+            -9.82136065717911466409E11, 8.75906394395366999549E13,  -3.46628303384729719441E15,
+            4.42733268572569800351E16,  -1.84950800436986690637E16,
+        };
+
+        constexpr double j0_YQ[7] = {
+            /* 1.00000000000000000000E0, */
+            1.04128353664259848412E3,  6.26107330137134956842E5,  2.68919633393814121987E8,  8.64002487103935000337E10,
+            2.02979612750105546709E13, 3.17157752842975028269E15, 2.50596256172653059228E17,
+        };
+
+        /*  5.783185962946784521175995758455807035071 */
+        constexpr double j0_DR1 = 5.78318596294678452118E0;
+
+        /* 30.47126234366208639907816317502275584842 */
+        constexpr double j0_DR2 = 3.04712623436620863991E1;
+
+        constexpr double j0_RP[4] = {
+            -4.79443220978201773821E9,
+            1.95617491946556577543E12,
+            -2.49248344360967716204E14,
+            9.70862251047306323952E15,
+        };
+
+        constexpr double j0_RQ[8] = {
+            /* 1.00000000000000000000E0, */
+            4.99563147152651017219E2,  1.73785401676374683123E5,  4.84409658339962045305E7,  1.11855537045356834862E10,
+            2.11277520115489217587E12, 3.10518229857422583814E14, 3.18121955943204943306E16, 1.71086294081043136091E18,
+        };
+
+    } // namespace detail
+
+    XSF_HOST_DEVICE inline double j0(double x) {
+        double w, z, p, q, xn;
+
+        if (x < 0) {
+            x = -x;
+        }
+
+        if (x <= 5.0) {
+            z = x * x;
+            if (x < 1.0e-5) {
+                return (1.0 - z / 4.0);
+            }
+
+            p = (z - detail::j0_DR1) * (z - detail::j0_DR2);
+            p = p * polevl(z, detail::j0_RP, 3) / p1evl(z, detail::j0_RQ, 8);
+            return (p);
+        }
+
+        w = 5.0 / x;
+        q = 25.0 / (x * x);
+        p = polevl(q, detail::j0_PP, 6) / polevl(q, detail::j0_PQ, 6);
+        q = polevl(q, detail::j0_QP, 7) / p1evl(q, detail::j0_QQ, 7);
+        xn = x - M_PI_4;
+        p = p * std::cos(xn) - w * q * std::sin(xn);
+        return (p * detail::SQRT2OPI / std::sqrt(x));
+    }
+
+    /*                                                     y0() 2  */
+    /* Bessel function of second kind, order zero  */
+
+    /* Rational approximation coefficients YP[], YQ[] are used here.
+     * The function computed is  y0(x)  -  2 * log(x) * j0(x) / M_PI,
+     * whose value at x = 0 is  2 * ( log(0.5) + EUL ) / M_PI
+     * = 0.073804295108687225.
+     */
+
+    XSF_HOST_DEVICE inline double y0(double x) {
+        double w, z, p, q, xn;
+
+        if (x <= 5.0) {
+            if (x == 0.0) {
+                set_error("y0", SF_ERROR_SINGULAR, NULL);
+                return -std::numeric_limits<double>::infinity();
+            } else if (x < 0.0) {
+                set_error("y0", SF_ERROR_DOMAIN, NULL);
+                return std::numeric_limits<double>::quiet_NaN();
+            }
+            z = x * x;
+            w = polevl(z, detail::j0_YP, 7) / p1evl(z, detail::j0_YQ, 7);
+            w += M_2_PI * std::log(x) * j0(x);
+            return (w);
+        }
+
+        w = 5.0 / x;
+        z = 25.0 / (x * x);
+        p = polevl(z, detail::j0_PP, 6) / polevl(z, detail::j0_PQ, 6);
+        q = polevl(z, detail::j0_QP, 7) / p1evl(z, detail::j0_QQ, 7);
+        xn = x - M_PI_4;
+        p = p * std::sin(xn) + w * q * std::cos(xn);
+        return (p * detail::SQRT2OPI / std::sqrt(x));
+    }
+
+} // namespace cephes
+} // namespace xsf

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/special/xsf/cephes/j1.h

@@ -0,0 +1,198 @@
+/* Translated into C++ by SciPy developers in 2024.
+ * Original header with Copyright information appears below.
+ */
+
+/*                                                     j1.c
+ *
+ *     Bessel function of order one
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, y, j1();
+ *
+ * y = j1( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns Bessel function of order one of the argument.
+ *
+ * The domain is divided into the intervals [0, 8] and
+ * (8, infinity). In the first interval a 24 term Chebyshev
+ * expansion is used. In the second, the asymptotic
+ * trigonometric representation is employed using two
+ * rational functions of degree 5/5.
+ *
+ *
+ *
+ * ACCURACY:
+ *
+ *                      Absolute error:
+ * arithmetic   domain      # trials      peak         rms
+ *    IEEE      0, 30       30000       2.6e-16     1.1e-16
+ *
+ *
+ */
+/*							y1.c
+ *
+ *	Bessel function of second kind of order one
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, y, y1();
+ *
+ * y = y1( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns Bessel function of the second kind of order one
+ * of the argument.
+ *
+ * The domain is divided into the intervals [0, 8] and
+ * (8, infinity). In the first interval a 25 term Chebyshev
+ * expansion is used, and a call to j1() is required.
+ * In the second, the asymptotic trigonometric representation
+ * is employed using two rational functions of degree 5/5.
+ *
+ *
+ *
+ * ACCURACY:
+ *
+ *                      Absolute error:
+ * arithmetic   domain      # trials      peak         rms
+ *    IEEE      0, 30       30000       1.0e-15     1.3e-16
+ *
+ * (error criterion relative when |y1| > 1).
+ *
+ */
+
+/*
+ * Cephes Math Library Release 2.8:  June, 2000
+ * Copyright 1984, 1987, 1989, 2000 by Stephen L. Moshier
+ */
+
+/*
+ * #define PIO4 .78539816339744830962
+ * #define THPIO4 2.35619449019234492885
+ * #define SQ2OPI .79788456080286535588
+ */
+#pragma once
+
+#include "../config.h"
+#include "../error.h"
+
+#include "const.h"
+#include "polevl.h"
+
+namespace xsf {
+namespace cephes {
+
+    namespace detail {
+        constexpr double j1_RP[4] = {
+            -8.99971225705559398224E8,
+            4.52228297998194034323E11,
+            -7.27494245221818276015E13,
+            3.68295732863852883286E15,
+        };
+
+        constexpr double j1_RQ[8] = {
+            /* 1.00000000000000000000E0, */
+            6.20836478118054335476E2,  2.56987256757748830383E5,  8.35146791431949253037E7,  2.21511595479792499675E10,
+            4.74914122079991414898E12, 7.84369607876235854894E14, 8.95222336184627338078E16, 5.32278620332680085395E18,
+        };
+
+        constexpr double j1_PP[7] = {
+            7.62125616208173112003E-4, 7.31397056940917570436E-2, 1.12719608129684925192E0, 5.11207951146807644818E0,
+            8.42404590141772420927E0,  5.21451598682361504063E0,  1.00000000000000000254E0,
+        };
+
+        constexpr double j1_PQ[7] = {
+            5.71323128072548699714E-4, 6.88455908754495404082E-2, 1.10514232634061696926E0,  5.07386386128601488557E0,
+            8.39985554327604159757E0,  5.20982848682361821619E0,  9.99999999999999997461E-1,
+        };
+
+        constexpr double j1_QP[8] = {
+            5.10862594750176621635E-2, 4.98213872951233449420E0, 7.58238284132545283818E1, 3.66779609360150777800E2,
+            7.10856304998926107277E2,  5.97489612400613639965E2, 2.11688757100572135698E2, 2.52070205858023719784E1,
+        };
+
+        constexpr double j1_QQ[7] = {
+            /* 1.00000000000000000000E0, */
+            7.42373277035675149943E1, 1.05644886038262816351E3, 4.98641058337653607651E3, 9.56231892404756170795E3,
+            7.99704160447350683650E3, 2.82619278517639096600E3, 3.36093607810698293419E2,
+        };
+
+        constexpr double j1_YP[6] = {
+            1.26320474790178026440E9,   -6.47355876379160291031E11, 1.14509511541823727583E14,
+            -8.12770255501325109621E15, 2.02439475713594898196E17,  -7.78877196265950026825E17,
+        };
+
+        constexpr double j1_YQ[8] = {
+            /* 1.00000000000000000000E0, */
+            5.94301592346128195359E2,  2.35564092943068577943E5,  7.34811944459721705660E7,  1.87601316108706159478E10,
+            3.88231277496238566008E12, 6.20557727146953693363E14, 6.87141087355300489866E16, 3.97270608116560655612E18,
+        };
+
+        constexpr double j1_Z1 = 1.46819706421238932572E1;
+        constexpr double j1_Z2 = 4.92184563216946036703E1;
+
+    } // namespace detail
+
+    XSF_HOST_DEVICE inline double j1(double x) {
+        double w, z, p, q, xn;
+
+        w = x;
+        if (x < 0) {
+            return -j1(-x);
+        }
+
+        if (w <= 5.0) {
+            z = x * x;
+            w = polevl(z, detail::j1_RP, 3) / p1evl(z, detail::j1_RQ, 8);
+            w = w * x * (z - detail::j1_Z1) * (z - detail::j1_Z2);
+            return (w);
+        }
+
+        w = 5.0 / x;
+        z = w * w;
+        p = polevl(z, detail::j1_PP, 6) / polevl(z, detail::j1_PQ, 6);
+        q = polevl(z, detail::j1_QP, 7) / p1evl(z, detail::j1_QQ, 7);
+        xn = x - detail::THPIO4;
+        p = p * std::cos(xn) - w * q * std::sin(xn);
+        return (p * detail::SQRT2OPI / std::sqrt(x));
+    }
+
+    XSF_HOST_DEVICE inline double y1(double x) {
+        double w, z, p, q, xn;
+
+        if (x <= 5.0) {
+            if (x == 0.0) {
+                set_error("y1", SF_ERROR_SINGULAR, NULL);
+                return -std::numeric_limits<double>::infinity();
+            } else if (x <= 0.0) {
+                set_error("y1", SF_ERROR_DOMAIN, NULL);
+                return std::numeric_limits<double>::quiet_NaN();
+            }
+            z = x * x;
+            w = x * (polevl(z, detail::j1_YP, 5) / p1evl(z, detail::j1_YQ, 8));
+            w += M_2_PI * (j1(x) * std::log(x) - 1.0 / x);
+            return (w);
+        }
+
+        w = 5.0 / x;
+        z = w * w;
+        p = polevl(z, detail::j1_PP, 6) / polevl(z, detail::j1_PQ, 6);
+        q = polevl(z, detail::j1_QP, 7) / p1evl(z, detail::j1_QQ, 7);
+        xn = x - detail::THPIO4;
+        p = p * std::sin(xn) + w * q * std::cos(xn);
+        return (p * detail::SQRT2OPI / std::sqrt(x));
+    }
+} // namespace cephes
+} // namespace xsf

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/special/xsf/cephes/jv.h

@@ -0,0 +1,715 @@
+/* Translated into C++ by SciPy developers in 2024.
+ * Original header with Copyright information appears below.
+ */
+
+/*                                                     jv.c
+ *
+ *     Bessel function of noninteger order
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double v, x, y, jv();
+ *
+ * y = jv( v, x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns Bessel function of order v of the argument,
+ * where v is real.  Negative x is allowed if v is an integer.
+ *
+ * Several expansions are included: the ascending power
+ * series, the Hankel expansion, and two transitional
+ * expansions for large v.  If v is not too large, it
+ * is reduced by recurrence to a region of best accuracy.
+ * The transitional expansions give 12D accuracy for v > 500.
+ *
+ *
+ *
+ * ACCURACY:
+ * Results for integer v are indicated by *, where x and v
+ * both vary from -125 to +125.  Otherwise,
+ * x ranges from 0 to 125, v ranges as indicated by "domain."
+ * Error criterion is absolute, except relative when |jv()| > 1.
+ *
+ * arithmetic  v domain  x domain    # trials      peak       rms
+ *    IEEE      0,125     0,125      100000      4.6e-15    2.2e-16
+ *    IEEE   -125,0       0,125       40000      5.4e-11    3.7e-13
+ *    IEEE      0,500     0,500       20000      4.4e-15    4.0e-16
+ * Integer v:
+ *    IEEE   -125,125   -125,125      50000      3.5e-15*   1.9e-16*
+ *
+ */
+
+/*
+ * Cephes Math Library Release 2.8:  June, 2000
+ * Copyright 1984, 1987, 1989, 1992, 2000 by Stephen L. Moshier
+ */
+#pragma once
+
+#include "../config.h"
+#include "../error.h"
+
+#include "airy.h"
+#include "cbrt.h"
+#include "rgamma.h"
+#include "j0.h"
+#include "j1.h"
+#include "polevl.h"
+
+namespace xsf {
+namespace cephes {
+
+    namespace detail {
+
+        constexpr double jv_BIG = 1.44115188075855872E+17;
+
+        /* Reduce the order by backward recurrence.
+         * AMS55 #9.1.27 and 9.1.73.
+         */
+
+        XSF_HOST_DEVICE inline double jv_recur(double *n, double x, double *newn, int cancel) {
+            double pkm2, pkm1, pk, qkm2, qkm1;
+
+            /* double pkp1; */
+            double k, ans, qk, xk, yk, r, t, kf;
+            constexpr double big = jv_BIG;
+            int nflag, ctr;
+            int miniter, maxiter;
+
+            /* Continued fraction for Jn(x)/Jn-1(x)
+             * AMS 9.1.73
+             *
+             *    x       -x^2      -x^2
+             * ------  ---------  ---------   ...
+             * 2 n +   2(n+1) +   2(n+2) +
+             *
+             * Compute it with the simplest possible algorithm.
+             *
+             * This continued fraction starts to converge when (|n| + m) > |x|.
+             * Hence, at least |x|-|n| iterations are necessary before convergence is
+             * achieved. There is a hard limit set below, m <= 30000, which is chosen
+             * so that no branch in `jv` requires more iterations to converge.
+             * The exact maximum number is (500/3.6)^2 - 500 ~ 19000
+             */
+
+            maxiter = 22000;
+            miniter = std::abs(x) - std::abs(*n);
+            if (miniter < 1) {
+                miniter = 1;
+            }
+
+            if (*n < 0.0) {
+                nflag = 1;
+            } else {
+                nflag = 0;
+            }
+
+        fstart:
+            pkm2 = 0.0;
+            qkm2 = 1.0;
+            pkm1 = x;
+            qkm1 = *n + *n;
+            xk = -x * x;
+            yk = qkm1;
+            ans = 0.0; /* ans=0.0 ensures that t=1.0 in the first iteration */
+            ctr = 0;
+            do {
+                yk += 2.0;
+                pk = pkm1 * yk + pkm2 * xk;
+                qk = qkm1 * yk + qkm2 * xk;
+                pkm2 = pkm1;
+                pkm1 = pk;
+                qkm2 = qkm1;
+                qkm1 = qk;
+
+                /* check convergence */
+                if (qk != 0 && ctr > miniter)
+                    r = pk / qk;
+                else
+                    r = 0.0;
+
+                if (r != 0) {
+                    t = std::abs((ans - r) / r);
+                    ans = r;
+                } else {
+                    t = 1.0;
+                }
+
+                if (++ctr > maxiter) {
+                    set_error("jv", SF_ERROR_UNDERFLOW, NULL);
+                    goto done;
+                }
+                if (t < MACHEP) {
+                    goto done;
+                }
+
+                /* renormalize coefficients */
+                if (std::abs(pk) > big) {
+                    pkm2 /= big;
+                    pkm1 /= big;
+                    qkm2 /= big;
+                    qkm1 /= big;
+                }
+            } while (t > MACHEP);
+
+        done:
+            if (ans == 0)
+                ans = 1.0;
+
+            /* Change n to n-1 if n < 0 and the continued fraction is small */
+            if (nflag > 0) {
+                if (std::abs(ans) < 0.125) {
+                    nflag = -1;
+                    *n = *n - 1.0;
+                    goto fstart;
+                }
+            }
+
+            kf = *newn;
+
+            /* backward recurrence
+             *              2k
+             *  J   (x)  =  --- J (x)  -  J   (x)
+             *   k-1         x   k         k+1
+             */
+
+            pk = 1.0;
+            pkm1 = 1.0 / ans;
+            k = *n - 1.0;
+            r = 2 * k;
+            do {
+                pkm2 = (pkm1 * r - pk * x) / x;
+                /*      pkp1 = pk; */
+                pk = pkm1;
+                pkm1 = pkm2;
+                r -= 2.0;
+                /*
+                 * t = fabs(pkp1) + fabs(pk);
+                 * if( (k > (kf + 2.5)) && (fabs(pkm1) < 0.25*t) )
+                 * {
+                 * k -= 1.0;
+                 * t = x*x;
+                 * pkm2 = ( (r*(r+2.0)-t)*pk - r*x*pkp1 )/t;
+                 * pkp1 = pk;
+                 * pk = pkm1;
+                 * pkm1 = pkm2;
+                 * r -= 2.0;
+                 * }
+                 */
+                k -= 1.0;
+            } while (k > (kf + 0.5));
+
+            /* Take the larger of the last two iterates
+             * on the theory that it may have less cancellation error.
+             */
+
+            if (cancel) {
+                if ((kf >= 0.0) && (std::abs(pk) > std::abs(pkm1))) {
+                    k += 1.0;
+                    pkm2 = pk;
+                }
+            }
+            *newn = k;
+            return (pkm2);
+        }
+
+        /* Ascending power series for Jv(x).
+         * AMS55 #9.1.10.
+         */
+
+        XSF_HOST_DEVICE inline double jv_jvs(double n, double x) {
+            double t, u, y, z, k;
+            int ex, sgngam;
+
+            z = -x * x / 4.0;
+            u = 1.0;
+            y = u;
+            k = 1.0;
+            t = 1.0;
+
+            while (t > MACHEP) {
+                u *= z / (k * (n + k));
+                y += u;
+                k += 1.0;
+                if (y != 0)
+                    t = std::abs(u / y);
+            }
+            t = std::frexp(0.5 * x, &ex);
+            ex = ex * n;
+            if ((ex > -1023) && (ex < 1023) && (n > 0.0) && (n < (MAXGAM - 1.0))) {
+                t = std::pow(0.5 * x, n) * xsf::cephes::rgamma(n + 1.0);
+                y *= t;
+            } else {
+                t = n * std::log(0.5 * x) - lgam_sgn(n + 1.0, &sgngam);
+                if (y < 0) {
+                    sgngam = -sgngam;
+                    y = -y;
+                }
+                t += std::log(y);
+                if (t < -MAXLOG) {
+                    return (0.0);
+                }
+                if (t > MAXLOG) {
+                    set_error("Jv", SF_ERROR_OVERFLOW, NULL);
+                    return (std::numeric_limits<double>::infinity());
+                }
+                y = sgngam * std::exp(t);
+            }
+            return (y);
+        }
+
+        /* Hankel's asymptotic expansion
+         * for large x.
+         * AMS55 #9.2.5.
+         */
+
+        XSF_HOST_DEVICE inline double jv_hankel(double n, double x) {
+            double t, u, z, k, sign, conv;
+            double p, q, j, m, pp, qq;
+            int flag;
+
+            m = 4.0 * n * n;
+            j = 1.0;
+            z = 8.0 * x;
+            k = 1.0;
+            p = 1.0;
+            u = (m - 1.0) / z;
+            q = u;
+            sign = 1.0;
+            conv = 1.0;
+            flag = 0;
+            t = 1.0;
+            pp = 1.0e38;
+            qq = 1.0e38;
+
+            while (t > MACHEP) {
+                k += 2.0;
+                j += 1.0;
+                sign = -sign;
+                u *= (m - k * k) / (j * z);
+                p += sign * u;
+                k += 2.0;
+                j += 1.0;
+                u *= (m - k * k) / (j * z);
+                q += sign * u;
+                t = std::abs(u / p);
+                if (t < conv) {
+                    conv = t;
+                    qq = q;
+                    pp = p;
+                    flag = 1;
+                }
+                /* stop if the terms start getting larger */
+                if ((flag != 0) && (t > conv)) {
+                    goto hank1;
+                }
+            }
+
+        hank1:
+            u = x - (0.5 * n + 0.25) * M_PI;
+            t = std::sqrt(2.0 / (M_PI * x)) * (pp * std::cos(u) - qq * std::sin(u));
+            return (t);
+        }
+
+        /* Asymptotic expansion for transition region,
+         * n large and x close to n.
+         * AMS55 #9.3.23.
+         */
+
+        constexpr double jv_PF2[] = {-9.0000000000000000000e-2, 8.5714285714285714286e-2};
+
+        constexpr double jv_PF3[] = {1.3671428571428571429e-1, -5.4920634920634920635e-2, -4.4444444444444444444e-3};
+
+        constexpr double jv_PF4[] = {1.3500000000000000000e-3, -1.6036054421768707483e-1, 4.2590187590187590188e-2,
+                                     2.7330447330447330447e-3};
+
+        constexpr double jv_PG1[] = {-2.4285714285714285714e-1, 1.4285714285714285714e-2};
+
+        constexpr double jv_PG2[] = {-9.0000000000000000000e-3, 1.9396825396825396825e-1, -1.1746031746031746032e-2};
+
+        constexpr double jv_PG3[] = {1.9607142857142857143e-2, -1.5983694083694083694e-1, 6.3838383838383838384e-3};
+
+        XSF_HOST_DEVICE inline double jv_jnt(double n, double x) {
+            double z, zz, z3;
+            double cbn, n23, cbtwo;
+            double ai, aip, bi, bip; /* Airy functions */
+            double nk, fk, gk, pp, qq;
+            double F[5], G[4];
+            int k;
+
+            cbn = cbrt(n);
+            z = (x - n) / cbn;
+            cbtwo = cbrt(2.0);
+
+            /* Airy function */
+            zz = -cbtwo * z;
+            xsf::cephes::airy(zz, &ai, &aip, &bi, &bip);
+
+            /* polynomials in expansion */
+            zz = z * z;
+            z3 = zz * z;
+            F[0] = 1.0;
+            F[1] = -z / 5.0;
+            F[2] = xsf::cephes::polevl(z3, jv_PF2, 1) * zz;
+            F[3] = xsf::cephes::polevl(z3, jv_PF3, 2);
+            F[4] = xsf::cephes::polevl(z3, jv_PF4, 3) * z;
+            G[0] = 0.3 * zz;
+            G[1] = xsf::cephes::polevl(z3, jv_PG1, 1);
+            G[2] = xsf::cephes::polevl(z3, jv_PG2, 2) * z;
+            G[3] = xsf::cephes::polevl(z3, jv_PG3, 2) * zz;
+
+            pp = 0.0;
+            qq = 0.0;
+            nk = 1.0;
+            n23 = cbrt(n * n);
+
+            for (k = 0; k <= 4; k++) {
+                fk = F[k] * nk;
+                pp += fk;
+                if (k != 4) {
+                    gk = G[k] * nk;
+                    qq += gk;
+                }
+                nk /= n23;
+            }
+
+            fk = cbtwo * ai * pp / cbn + cbrt(4.0) * aip * qq / n;
+            return (fk);
+        }
+
+        /* Asymptotic expansion for large n.
+         * AMS55 #9.3.35.
+         */
+
+        constexpr double jv_lambda[] = {1.0,
+                                        1.041666666666666666666667E-1,
+                                        8.355034722222222222222222E-2,
+                                        1.282265745563271604938272E-1,
+                                        2.918490264641404642489712E-1,
+                                        8.816272674437576524187671E-1,
+                                        3.321408281862767544702647E+0,
+                                        1.499576298686255465867237E+1,
+                                        7.892301301158651813848139E+1,
+                                        4.744515388682643231611949E+2,
+                                        3.207490090890661934704328E+3};
+
+        constexpr double jv_mu[] = {1.0,
+                                    -1.458333333333333333333333E-1,
+                                    -9.874131944444444444444444E-2,
+                                    -1.433120539158950617283951E-1,
+                                    -3.172272026784135480967078E-1,
+                                    -9.424291479571202491373028E-1,
+                                    -3.511203040826354261542798E+0,
+                                    -1.572726362036804512982712E+1,
+                                    -8.228143909718594444224656E+1,
+                                    -4.923553705236705240352022E+2,
+                                    -3.316218568547972508762102E+3};
+
+        constexpr double jv_P1[] = {-2.083333333333333333333333E-1, 1.250000000000000000000000E-1};
+
+        constexpr double jv_P2[] = {3.342013888888888888888889E-1, -4.010416666666666666666667E-1,
+                                    7.031250000000000000000000E-2};
+
+        constexpr double jv_P3[] = {-1.025812596450617283950617E+0, 1.846462673611111111111111E+0,
+                                    -8.912109375000000000000000E-1, 7.324218750000000000000000E-2};
+
+        constexpr double jv_P4[] = {4.669584423426247427983539E+0, -1.120700261622299382716049E+1,
+                                    8.789123535156250000000000E+0, -2.364086914062500000000000E+0,
+                                    1.121520996093750000000000E-1};
+
+        constexpr double jv_P5[] = {-2.8212072558200244877E1, 8.4636217674600734632E1,  -9.1818241543240017361E1,
+                                    4.2534998745388454861E1,  -7.3687943594796316964E0, 2.27108001708984375E-1};
+
+        constexpr double jv_P6[] = {2.1257013003921712286E2,  -7.6525246814118164230E2, 1.0599904525279998779E3,
+                                    -6.9957962737613254123E2, 2.1819051174421159048E2,  -2.6491430486951555525E1,
+                                    5.7250142097473144531E-1};
+
+        constexpr double jv_P7[] = {-1.9194576623184069963E3, 8.0617221817373093845E3,  -1.3586550006434137439E4,
+                                    1.1655393336864533248E4,  -5.3056469786134031084E3, 1.2009029132163524628E3,
+                                    -1.0809091978839465550E2, 1.7277275025844573975E0};
+
+        XSF_HOST_DEVICE inline double jv_jnx(double n, double x) {
+            double zeta, sqz, zz, zp, np;
+            double cbn, n23, t, z, sz;
+            double pp, qq, z32i, zzi;
+            double ak, bk, akl, bkl;
+            int sign, doa, dob, nflg, k, s, tk, tkp1, m;
+            double u[8];
+            double ai, aip, bi, bip;
+
+            /* Test for x very close to n. Use expansion for transition region if so. */
+            cbn = cbrt(n);
+            z = (x - n) / cbn;
+            if (std::abs(z) <= 0.7) {
+                return (jv_jnt(n, x));
+            }
+
+            z = x / n;
+            zz = 1.0 - z * z;
+            if (zz == 0.0) {
+                return (0.0);
+            }
+
+            if (zz > 0.0) {
+                sz = std::sqrt(zz);
+                t = 1.5 * (std::log((1.0 + sz) / z) - sz); /* zeta ** 3/2          */
+                zeta = cbrt(t * t);
+                nflg = 1;
+            } else {
+                sz = std::sqrt(-zz);
+                t = 1.5 * (sz - std::acos(1.0 / z));
+                zeta = -cbrt(t * t);
+                nflg = -1;
+            }
+            z32i = std::abs(1.0 / t);
+            sqz = cbrt(t);
+
+            /* Airy function */
+            n23 = cbrt(n * n);
+            t = n23 * zeta;
+
+            xsf::cephes::airy(t, &ai, &aip, &bi, &bip);
+
+            /* polynomials in expansion */
+            u[0] = 1.0;
+            zzi = 1.0 / zz;
+            u[1] = xsf::cephes::polevl(zzi, jv_P1, 1) / sz;
+            u[2] = xsf::cephes::polevl(zzi, jv_P2, 2) / zz;
+            u[3] = xsf::cephes::polevl(zzi, jv_P3, 3) / (sz * zz);
+            pp = zz * zz;
+            u[4] = xsf::cephes::polevl(zzi, jv_P4, 4) / pp;
+            u[5] = xsf::cephes::polevl(zzi, jv_P5, 5) / (pp * sz);
+            pp *= zz;
+            u[6] = xsf::cephes::polevl(zzi, jv_P6, 6) / pp;
+            u[7] = xsf::cephes::polevl(zzi, jv_P7, 7) / (pp * sz);
+
+            pp = 0.0;
+            qq = 0.0;
+            np = 1.0;
+            /* flags to stop when terms get larger */
+            doa = 1;
+            dob = 1;
+            akl = std::numeric_limits<double>::infinity();
+            bkl = std::numeric_limits<double>::infinity();
+
+            for (k = 0; k <= 3; k++) {
+                tk = 2 * k;
+                tkp1 = tk + 1;
+                zp = 1.0;
+                ak = 0.0;
+                bk = 0.0;
+                for (s = 0; s <= tk; s++) {
+                    if (doa) {
+                        if ((s & 3) > 1)
+                            sign = nflg;
+                        else
+                            sign = 1;
+                        ak += sign * jv_mu[s] * zp * u[tk - s];
+                    }
+
+                    if (dob) {
+                        m = tkp1 - s;
+                        if (((m + 1) & 3) > 1)
+                            sign = nflg;
+                        else
+                            sign = 1;
+                        bk += sign * jv_lambda[s] * zp * u[m];
+                    }
+                    zp *= z32i;
+                }
+
+                if (doa) {
+                    ak *= np;
+                    t = std::abs(ak);
+                    if (t < akl) {
+                        akl = t;
+                        pp += ak;
+                    } else
+                        doa = 0;
+                }
+
+                if (dob) {
+                    bk += jv_lambda[tkp1] * zp * u[0];
+                    bk *= -np / sqz;
+                    t = std::abs(bk);
+                    if (t < bkl) {
+                        bkl = t;
+                        qq += bk;
+                    } else
+                        dob = 0;
+                }
+                if (np < MACHEP)
+                    break;
+                np /= n * n;
+            }
+
+            /* normalizing factor ( 4*zeta/(1 - z**2) )**1/4    */
+            t = 4.0 * zeta / zz;
+            t = sqrt(sqrt(t));
+
+            t *= ai * pp / cbrt(n) + aip * qq / (n23 * n);
+            return (t);
+        }
+
+    } // namespace detail
+
+    XSF_HOST_DEVICE inline double jv(double n, double x) {
+        double k, q, t, y, an;
+        int i, sign, nint;
+
+        nint = 0; /* Flag for integer n */
+        sign = 1; /* Flag for sign inversion */
+        an = std::abs(n);
+        y = std::floor(an);
+        if (y == an) {
+            nint = 1;
+            i = an - 16384.0 * std::floor(an / 16384.0);
+            if (n < 0.0) {
+                if (i & 1)
+                    sign = -sign;
+                n = an;
+            }
+            if (x < 0.0) {
+                if (i & 1)
+                    sign = -sign;
+                x = -x;
+            }
+            if (n == 0.0)
+                return (j0(x));
+            if (n == 1.0)
+                return (sign * j1(x));
+        }
+
+        if ((x < 0.0) && (y != an)) {
+            set_error("Jv", SF_ERROR_DOMAIN, NULL);
+            y = std::numeric_limits<double>::quiet_NaN();
+            goto done;
+        }
+
+        if (x == 0 && n < 0 && !nint) {
+            set_error("Jv", SF_ERROR_OVERFLOW, NULL);
+            return std::numeric_limits<double>::infinity() * rgamma(n + 1);
+        }
+
+        y = std::abs(x);
+
+        if (y * y < std::abs(n + 1) * detail::MACHEP) {
+            return std::pow(0.5 * x, n) * rgamma(n + 1);
+        }
+
+        k = 3.6 * std::sqrt(y);
+        t = 3.6 * std::sqrt(an);
+        if ((y < t) && (an > 21.0)) {
+            return (sign * detail::jv_jvs(n, x));
+        }
+        if ((an < k) && (y > 21.0))
+            return (sign * detail::jv_hankel(n, x));
+
+        if (an < 500.0) {
+            /* Note: if x is too large, the continued fraction will fail; but then the
+             * Hankel expansion can be used. */
+            if (nint != 0) {
+                k = 0.0;
+                q = detail::jv_recur(&n, x, &k, 1);
+                if (k == 0.0) {
+                    y = j0(x) / q;
+                    goto done;
+                }
+                if (k == 1.0) {
+                    y = j1(x) / q;
+                    goto done;
+                }
+            }
+
+            if (an > 2.0 * y)
+                goto rlarger;
+
+            if ((n >= 0.0) && (n < 20.0) && (y > 6.0) && (y < 20.0)) {
+                /* Recur backwards from a larger value of n */
+            rlarger:
+                k = n;
+
+                y = y + an + 1.0;
+                if (y < 30.0)
+                    y = 30.0;
+                y = n + std::floor(y - n);
+                q = detail::jv_recur(&y, x, &k, 0);
+                y = detail::jv_jvs(y, x) * q;
+                goto done;
+            }
+
+            if (k <= 30.0) {
+                k = 2.0;
+            } else if (k < 90.0) {
+                k = (3 * k) / 4;
+            }
+            if (an > (k + 3.0)) {
+                if (n < 0.0) {
+                    k = -k;
+                }
+                q = n - std::floor(n);
+                k = std::floor(k) + q;
+                if (n > 0.0) {
+                    q = detail::jv_recur(&n, x, &k, 1);
+                } else {
+                    t = k;
+                    k = n;
+                    q = detail::jv_recur(&t, x, &k, 1);
+                    k = t;
+                }
+                if (q == 0.0) {
+                    y = 0.0;
+                    goto done;
+                }
+            } else {
+                k = n;
+                q = 1.0;
+            }
+
+            /* boundary between convergence of
+             * power series and Hankel expansion
+             */
+            y = std::abs(k);
+            if (y < 26.0)
+                t = (0.0083 * y + 0.09) * y + 12.9;
+            else
+                t = 0.9 * y;
+
+            if (x > t)
+                y = detail::jv_hankel(k, x);
+            else
+                y = detail::jv_jvs(k, x);
+            if (n > 0.0)
+                y /= q;
+            else
+                y *= q;
+        }
+
+        else {
+            /* For large n, use the uniform expansion or the transitional expansion.
+             * But if x is of the order of n**2, these may blow up, whereas the
+             * Hankel expansion will then work.
+             */
+            if (n < 0.0) {
+                set_error("jv", SF_ERROR_LOSS, NULL);
+                y = std::numeric_limits<double>::quiet_NaN();
+                goto done;
+            }
+            t = x / n;
+            t /= n;
+            if (t > 0.3)
+                y = detail::jv_hankel(n, x);
+            else
+                y = detail::jv_jnx(n, x);
+        }
+
+    done:
+        return (sign * y);
+    }
+
+} // namespace cephes
+} // namespace xsf

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/special/xsf/cephes/k0.h

@@ -0,0 +1,164 @@
+/* Translated into C++ by SciPy developers in 2024.
+ * Original header with Copyright information appears below.
+ */
+
+/*                                                     k0.c
+ *
+ *     Modified Bessel function, third kind, order zero
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, y, k0();
+ *
+ * y = k0( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns modified Bessel function of the third kind
+ * of order zero of the argument.
+ *
+ * The range is partitioned into the two intervals [0,8] and
+ * (8, infinity).  Chebyshev polynomial expansions are employed
+ * in each interval.
+ *
+ *
+ *
+ * ACCURACY:
+ *
+ * Tested at 2000 random points between 0 and 8.  Peak absolute
+ * error (relative when K0 > 1) was 1.46e-14; rms, 4.26e-15.
+ *                      Relative error:
+ * arithmetic   domain     # trials      peak         rms
+ *    IEEE      0, 30       30000       1.2e-15     1.6e-16
+ *
+ * ERROR MESSAGES:
+ *
+ *   message         condition      value returned
+ *  K0 domain          x <= 0          INFINITY
+ *
+ */
+/*							k0e()
+ *
+ *	Modified Bessel function, third kind, order zero,
+ *	exponentially scaled
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, y, k0e();
+ *
+ * y = k0e( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns exponentially scaled modified Bessel function
+ * of the third kind of order zero of the argument.
+ *
+ *
+ *
+ * ACCURACY:
+ *
+ *                      Relative error:
+ * arithmetic   domain     # trials      peak         rms
+ *    IEEE      0, 30       30000       1.4e-15     1.4e-16
+ * See k0().
+ *
+ */
+
+/*
+ * Cephes Math Library Release 2.8:  June, 2000
+ * Copyright 1984, 1987, 2000 by Stephen L. Moshier
+ */
+#pragma once
+
+#include "../config.h"
+#include "../error.h"
+
+#include "chbevl.h"
+#include "i0.h"
+
+namespace xsf {
+namespace cephes {
+
+    namespace detail {
+        /* Chebyshev coefficients for K0(x) + log(x/2) I0(x)
+         * in the interval [0,2].  The odd order coefficients are all
+         * zero; only the even order coefficients are listed.
+         *
+         * lim(x->0){ K0(x) + log(x/2) I0(x) } = -EUL.
+         */
+
+        constexpr double k0_A[] = {1.37446543561352307156E-16, 4.25981614279661018399E-14, 1.03496952576338420167E-11,
+                                   1.90451637722020886025E-9,  2.53479107902614945675E-7,  2.28621210311945178607E-5,
+                                   1.26461541144692592338E-3,  3.59799365153615016266E-2,  3.44289899924628486886E-1,
+                                   -5.35327393233902768720E-1};
+
+        /* Chebyshev coefficients for exp(x) sqrt(x) K0(x)
+         * in the inverted interval [2,infinity].
+         *
+         * lim(x->inf){ exp(x) sqrt(x) K0(x) } = sqrt(pi/2).
+         */
+        constexpr double k0_B[] = {
+            5.30043377268626276149E-18,  -1.64758043015242134646E-17, 5.21039150503902756861E-17,
+            -1.67823109680541210385E-16, 5.51205597852431940784E-16,  -1.84859337734377901440E-15,
+            6.34007647740507060557E-15,  -2.22751332699166985548E-14, 8.03289077536357521100E-14,
+            -2.98009692317273043925E-13, 1.14034058820847496303E-12,  -4.51459788337394416547E-12,
+            1.85594911495471785253E-11,  -7.95748924447710747776E-11, 3.57739728140030116597E-10,
+            -1.69753450938905987466E-9,  8.57403401741422608519E-9,   -4.66048989768794782956E-8,
+            2.76681363944501510342E-7,   -1.83175552271911948767E-6,  1.39498137188764993662E-5,
+            -1.28495495816278026384E-4,  1.56988388573005337491E-3,   -3.14481013119645005427E-2,
+            2.44030308206595545468E0};
+
+    } // namespace detail
+
+    XSF_HOST_DEVICE inline double k0(double x) {
+        double y, z;
+
+        if (x == 0.0) {
+            set_error("k0", SF_ERROR_SINGULAR, NULL);
+            return std::numeric_limits<double>::infinity();
+        } else if (x < 0.0) {
+            set_error("k0", SF_ERROR_DOMAIN, NULL);
+            return std::numeric_limits<double>::quiet_NaN();
+        }
+
+        if (x <= 2.0) {
+            y = x * x - 2.0;
+            y = chbevl(y, detail::k0_A, 10) - std::log(0.5 * x) * i0(x);
+            return (y);
+        }
+        z = 8.0 / x - 2.0;
+        y = std::exp(-x) * chbevl(z, detail::k0_B, 25) / std::sqrt(x);
+        return (y);
+    }
+
+    XSF_HOST_DEVICE double inline k0e(double x) {
+        double y;
+
+        if (x == 0.0) {
+            set_error("k0e", SF_ERROR_SINGULAR, NULL);
+            return std::numeric_limits<double>::infinity();
+        } else if (x < 0.0) {
+            set_error("k0e", SF_ERROR_DOMAIN, NULL);
+            return std::numeric_limits<double>::quiet_NaN();
+        }
+
+        if (x <= 2.0) {
+            y = x * x - 2.0;
+            y = chbevl(y, detail::k0_A, 10) - std::log(0.5 * x) * i0(x);
+            return (y * exp(x));
+        }
+
+        y = chbevl(8.0 / x - 2.0, detail::k0_B, 25) / std::sqrt(x);
+        return (y);
+    }
+
+} // namespace cephes
+} // namespace xsf

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/special/xsf/cephes/k1.h

@@ -0,0 +1,163 @@
+/* Translated into C++ by SciPy developers in 2024.
+ * Original header with Copyright information appears below.
+ */
+
+/*                                                     k1.c
+ *
+ *     Modified Bessel function, third kind, order one
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, y, k1();
+ *
+ * y = k1( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Computes the modified Bessel function of the third kind
+ * of order one of the argument.
+ *
+ * The range is partitioned into the two intervals [0,2] and
+ * (2, infinity).  Chebyshev polynomial expansions are employed
+ * in each interval.
+ *
+ *
+ *
+ * ACCURACY:
+ *
+ *                      Relative error:
+ * arithmetic   domain     # trials      peak         rms
+ *    IEEE      0, 30       30000       1.2e-15     1.6e-16
+ *
+ * ERROR MESSAGES:
+ *
+ *   message         condition      value returned
+ * k1 domain          x <= 0          INFINITY
+ *
+ */
+/*							k1e.c
+ *
+ *	Modified Bessel function, third kind, order one,
+ *	exponentially scaled
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, y, k1e();
+ *
+ * y = k1e( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns exponentially scaled modified Bessel function
+ * of the third kind of order one of the argument:
+ *
+ *      k1e(x) = exp(x) * k1(x).
+ *
+ *
+ *
+ * ACCURACY:
+ *
+ *                      Relative error:
+ * arithmetic   domain     # trials      peak         rms
+ *    IEEE      0, 30       30000       7.8e-16     1.2e-16
+ * See k1().
+ *
+ */
+
+/*
+ * Cephes Math Library Release 2.8:  June, 2000
+ * Copyright 1984, 1987, 2000 by Stephen L. Moshier
+ */
+#pragma once
+
+#include "../config.h"
+#include "../error.h"
+
+#include "chbevl.h"
+#include "const.h"
+
+namespace xsf {
+namespace cephes {
+
+    namespace detail {
+        /* Chebyshev coefficients for x(K1(x) - log(x/2) I1(x))
+         * in the interval [0,2].
+         *
+         * lim(x->0){ x(K1(x) - log(x/2) I1(x)) } = 1.
+         */
+
+        constexpr double k1_A[] = {
+            -7.02386347938628759343E-18, -2.42744985051936593393E-15, -6.66690169419932900609E-13,
+            -1.41148839263352776110E-10, -2.21338763073472585583E-8,  -2.43340614156596823496E-6,
+            -1.73028895751305206302E-4,  -6.97572385963986435018E-3,  -1.22611180822657148235E-1,
+            -3.53155960776544875667E-1,  1.52530022733894777053E0};
+
+        /* Chebyshev coefficients for exp(x) sqrt(x) K1(x)
+         * in the interval [2,infinity].
+         *
+         * lim(x->inf){ exp(x) sqrt(x) K1(x) } = sqrt(pi/2).
+         */
+        constexpr double k1_B[] = {
+            -5.75674448366501715755E-18, 1.79405087314755922667E-17,  -5.68946255844285935196E-17,
+            1.83809354436663880070E-16,  -6.05704724837331885336E-16, 2.03870316562433424052E-15,
+            -7.01983709041831346144E-15, 2.47715442448130437068E-14,  -8.97670518232499435011E-14,
+            3.34841966607842919884E-13,  -1.28917396095102890680E-12, 5.13963967348173025100E-12,
+            -2.12996783842756842877E-11, 9.21831518760500529508E-11,  -4.19035475934189648750E-10,
+            2.01504975519703286596E-9,   -1.03457624656780970260E-8,  5.74108412545004946722E-8,
+            -3.50196060308781257119E-7,  2.40648494783721712015E-6,   -1.93619797416608296024E-5,
+            1.95215518471351631108E-4,   -2.85781685962277938680E-3,  1.03923736576817238437E-1,
+            2.72062619048444266945E0};
+
+    } // namespace detail
+
+    XSF_HOST_DEVICE inline double k1(double x) {
+        double y, z;
+
+        if (x == 0.0) {
+            set_error("k1", SF_ERROR_SINGULAR, NULL);
+            return std::numeric_limits<double>::infinity();
+        } else if (x < 0.0) {
+            set_error("k1", SF_ERROR_DOMAIN, NULL);
+            return std::numeric_limits<double>::quiet_NaN();
+        }
+        z = 0.5 * x;
+
+        if (x <= 2.0) {
+            y = x * x - 2.0;
+            y = std::log(z) * i1(x) + chbevl(y, detail::k1_A, 11) / x;
+            return (y);
+        }
+
+        return (std::exp(-x) * chbevl(8.0 / x - 2.0, detail::k1_B, 25) / std::sqrt(x));
+    }
+
+    XSF_HOST_DEVICE double k1e(double x) {
+        double y;
+
+        if (x == 0.0) {
+            set_error("k1e", SF_ERROR_SINGULAR, NULL);
+            return std::numeric_limits<double>::infinity();
+        } else if (x < 0.0) {
+            set_error("k1e", SF_ERROR_DOMAIN, NULL);
+            return std::numeric_limits<double>::quiet_NaN();
+        }
+
+        if (x <= 2.0) {
+            y = x * x - 2.0;
+            y = std::log(0.5 * x) * i1(x) + chbevl(y, detail::k1_A, 11) / x;
+            return (y * exp(x));
+        }
+
+        return (chbevl(8.0 / x - 2.0, detail::k1_B, 25) / std::sqrt(x));
+    }
+
+} // namespace cephes
+} // namespace xsf

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/special/xsf/cephes/kn.h

@@ -0,0 +1,243 @@
+/* Translated into C++ by SciPy developers in 2024.
+ * Original header with Copyright information appears below.
+ */
+
+/*                                                     kn.c
+ *
+ *     Modified Bessel function, third kind, integer order
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, y, kn();
+ * int n;
+ *
+ * y = kn( n, x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns modified Bessel function of the third kind
+ * of order n of the argument.
+ *
+ * The range is partitioned into the two intervals [0,9.55] and
+ * (9.55, infinity).  An ascending power series is used in the
+ * low range, and an asymptotic expansion in the high range.
+ *
+ *
+ *
+ * ACCURACY:
+ *
+ *                      Relative error:
+ * arithmetic   domain     # trials      peak         rms
+ *    IEEE      0,30        90000       1.8e-8      3.0e-10
+ *
+ *  Error is high only near the crossover point x = 9.55
+ * between the two expansions used.
+ */
+
+/*
+ * Cephes Math Library Release 2.8:  June, 2000
+ * Copyright 1984, 1987, 1988, 2000 by Stephen L. Moshier
+ */
+
+/*
+ * Algorithm for Kn.
+ *                        n-1
+ *                    -n   -  (n-k-1)!    2   k
+ * K (x)  =  0.5 (x/2)     >  -------- (-x /4)
+ *  n                      -     k!
+ *                        k=0
+ *
+ *                     inf.                                   2   k
+ *        n         n   -                                   (x /4)
+ *  + (-1)  0.5(x/2)    >  {p(k+1) + p(n+k+1) - 2log(x/2)} ---------
+ *                      -                                  k! (n+k)!
+ *                     k=0
+ *
+ * where  p(m) is the psi function: p(1) = -EUL and
+ *
+ *                       m-1
+ *                        -
+ *       p(m)  =  -EUL +  >  1/k
+ *                        -
+ *                       k=1
+ *
+ * For large x,
+ *                                          2        2     2
+ *                                       u-1     (u-1 )(u-3 )
+ * K (z)  =  sqrt(pi/2z) exp(-z) { 1 + ------- + ------------ + ...}
+ *  v                                        1            2
+ *                                     1! (8z)     2! (8z)
+ * asymptotically, where
+ *
+ *            2
+ *     u = 4 v .
+ *
+ */
+#pragma once
+
+#include "../config.h"
+#include "../error.h"
+
+#include "const.h"
+
+namespace xsf {
+namespace cephes {
+
+    namespace detail {
+
+        constexpr int kn_MAXFAC = 31;
+
+    }
+
+    XSF_HOST_DEVICE inline double kn(int nn, double x) {
+        double k, kf, nk1f, nkf, zn, t, s, z0, z;
+        double ans, fn, pn, pk, zmn, tlg, tox;
+        int i, n;
+
+        if (nn < 0)
+            n = -nn;
+        else
+            n = nn;
+
+        if (n > detail::kn_MAXFAC) {
+        overf:
+            set_error("kn", SF_ERROR_OVERFLOW, NULL);
+            return (std::numeric_limits<double>::infinity());
+        }
+
+        if (x <= 0.0) {
+            if (x < 0.0) {
+                set_error("kn", SF_ERROR_DOMAIN, NULL);
+                return std::numeric_limits<double>::quiet_NaN();
+            } else {
+                set_error("kn", SF_ERROR_SINGULAR, NULL);
+                return std::numeric_limits<double>::infinity();
+            }
+        }
+
+        if (x > 9.55)
+            goto asymp;
+
+        ans = 0.0;
+        z0 = 0.25 * x * x;
+        fn = 1.0;
+        pn = 0.0;
+        zmn = 1.0;
+        tox = 2.0 / x;
+
+        if (n > 0) {
+            /* compute factorial of n and psi(n) */
+            pn = -detail::SCIPY_EULER;
+            k = 1.0;
+            for (i = 1; i < n; i++) {
+                pn += 1.0 / k;
+                k += 1.0;
+                fn *= k;
+            }
+
+            zmn = tox;
+
+            if (n == 1) {
+                ans = 1.0 / x;
+            } else {
+                nk1f = fn / n;
+                kf = 1.0;
+                s = nk1f;
+                z = -z0;
+                zn = 1.0;
+                for (i = 1; i < n; i++) {
+                    nk1f = nk1f / (n - i);
+                    kf = kf * i;
+                    zn *= z;
+                    t = nk1f * zn / kf;
+                    s += t;
+                    if ((std::numeric_limits<double>::max() - std::abs(t)) < std::abs(s)) {
+                        goto overf;
+                    }
+                    if ((tox > 1.0) && ((std::numeric_limits<double>::max() / tox) < zmn)) {
+                        goto overf;
+                    }
+                    zmn *= tox;
+                }
+                s *= 0.5;
+                t = std::abs(s);
+                if ((zmn > 1.0) && ((std::numeric_limits<double>::max() / zmn) < t)) {
+                    goto overf;
+                }
+                if ((t > 1.0) && ((std::numeric_limits<double>::max() / t) < zmn)) {
+                    goto overf;
+                }
+                ans = s * zmn;
+            }
+        }
+
+        tlg = 2.0 * log(0.5 * x);
+        pk = -detail::SCIPY_EULER;
+        if (n == 0) {
+            pn = pk;
+            t = 1.0;
+        } else {
+            pn = pn + 1.0 / n;
+            t = 1.0 / fn;
+        }
+        s = (pk + pn - tlg) * t;
+        k = 1.0;
+        do {
+            t *= z0 / (k * (k + n));
+            pk += 1.0 / k;
+            pn += 1.0 / (k + n);
+            s += (pk + pn - tlg) * t;
+            k += 1.0;
+        } while (fabs(t / s) > detail::MACHEP);
+
+        s = 0.5 * s / zmn;
+        if (n & 1) {
+            s = -s;
+        }
+        ans += s;
+
+        return (ans);
+
+        /* Asymptotic expansion for Kn(x) */
+        /* Converges to 1.4e-17 for x > 18.4 */
+
+    asymp:
+
+        if (x > detail::MAXLOG) {
+            set_error("kn", SF_ERROR_UNDERFLOW, NULL);
+            return (0.0);
+        }
+        k = n;
+        pn = 4.0 * k * k;
+        pk = 1.0;
+        z0 = 8.0 * x;
+        fn = 1.0;
+        t = 1.0;
+        s = t;
+        nkf = std::numeric_limits<double>::infinity();
+        i = 0;
+        do {
+            z = pn - pk * pk;
+            t = t * z / (fn * z0);
+            nk1f = std::abs(t);
+            if ((i >= n) && (nk1f > nkf)) {
+                goto adone;
+            }
+            nkf = nk1f;
+            s += t;
+            fn += 1.0;
+            pk += 2.0;
+            i += 1;
+        } while (std::abs(t / s) > detail::MACHEP);
+
+    adone:
+        ans = std::exp(-x) * std::sqrt(M_PI / (2.0 * x)) * s;
+        return (ans);
+    }
+
+} // namespace cephes
+} // namespace xsf

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/special/xsf/cephes/lanczos.h

@@ -0,0 +1,112 @@
+/*  (C) Copyright John Maddock 2006.
+ *  Use, modification and distribution are subject to the
+ *  Boost Software License, Version 1.0. (See accompanying file
+ *  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
+ */
+
+/* Both lanczos.h and lanczos.c were formed from Boost's lanczos.hpp
+ *
+ * Scipy changes:
+ * - 06-22-2016: Removed all code not related to double precision and
+ *   ported to c for use in Cephes. Note that the order of the
+ *   coefficients is reversed to match the behavior of polevl.
+ */
+
+/*
+ * Optimal values for G for each N are taken from
+ * https://web.viu.ca/pughg/phdThesis/phdThesis.pdf,
+ * as are the theoretical error bounds.
+ *
+ * Constants calculated using the method described by Godfrey
+ * https://my.fit.edu/~gabdo/gamma.txt and elaborated by Toth at
+ * https://www.rskey.org/gamma.htm using NTL::RR at 1000 bit precision.
+ */
+
+/*
+ * Lanczos Coefficients for N=13 G=6.024680040776729583740234375
+ * Max experimental error (with arbitrary precision arithmetic) 1.196214e-17
+ * Generated with compiler: Microsoft Visual C++ version 8.0 on Win32 at Mar 23 2006
+ *
+ * Use for double precision.
+ */
+
+#pragma once
+
+#include "../config.h"
+#include "polevl.h"
+
+namespace xsf {
+namespace cephes {
+
+    namespace detail {
+
+        constexpr double lanczos_num[] = {
+            2.506628274631000270164908177133837338626, 210.8242777515793458725097339207133627117,
+            8071.672002365816210638002902272250613822, 186056.2653952234950402949897160456992822,
+            2876370.628935372441225409051620849613599, 31426415.58540019438061423162831820536287,
+            248874557.8620541565114603864132294232163, 1439720407.311721673663223072794912393972,
+            6039542586.35202800506429164430729792107,  17921034426.03720969991975575445893111267,
+            35711959237.35566804944018545154716670596, 42919803642.64909876895789904700198885093,
+            23531376880.41075968857200767445163675473};
+
+        constexpr double lanczos_denom[] = {1,        66,        1925,      32670,     357423,   2637558, 13339535,
+                                            45995730, 105258076, 150917976, 120543840, 39916800, 0};
+
+        constexpr double lanczos_sum_expg_scaled_num[] = {
+            0.006061842346248906525783753964555936883222, 0.5098416655656676188125178644804694509993,
+            19.51992788247617482847860966235652136208,    449.9445569063168119446858607650988409623,
+            6955.999602515376140356310115515198987526,    75999.29304014542649875303443598909137092,
+            601859.6171681098786670226533699352302507,    3481712.15498064590882071018964774556468,
+            14605578.08768506808414169982791359218571,    43338889.32467613834773723740590533316085,
+            86363131.28813859145546927288977868422342,    103794043.1163445451906271053616070238554,
+            56906521.91347156388090791033559122686859};
+
+        constexpr double lanczos_sum_expg_scaled_denom[] = {
+            1, 66, 1925, 32670, 357423, 2637558, 13339535, 45995730, 105258076, 150917976, 120543840, 39916800, 0};
+
+        constexpr double lanczos_sum_near_1_d[] = {
+            0.3394643171893132535170101292240837927725e-9,  -0.2499505151487868335680273909354071938387e-8,
+            0.8690926181038057039526127422002498960172e-8,  -0.1933117898880828348692541394841204288047e-7,
+            0.3075580174791348492737947340039992829546e-7,  -0.2752907702903126466004207345038327818713e-7,
+            -0.1515973019871092388943437623825208095123e-5, 0.004785200610085071473880915854204301886437,
+            -0.1993758927614728757314233026257810172008,    1.483082862367253753040442933770164111678,
+            -3.327150580651624233553677113928873034916,     2.208709979316623790862569924861841433016};
+
+        constexpr double lanczos_sum_near_2_d[] = {
+            0.1009141566987569892221439918230042368112e-8,  -0.7430396708998719707642735577238449585822e-8,
+            0.2583592566524439230844378948704262291927e-7,  -0.5746670642147041587497159649318454348117e-7,
+            0.9142922068165324132060550591210267992072e-7,  -0.8183698410724358930823737982119474130069e-7,
+            -0.4506604409707170077136555010018549819192e-5, 0.01422519127192419234315002746252160965831,
+            -0.5926941084905061794445733628891024027949,    4.408830289125943377923077727900630927902,
+            -9.8907772644920670589288081640128194231,       6.565936202082889535528455955485877361223};
+
+        XSF_HOST_DEVICE double lanczos_sum(double x) { return ratevl(x, lanczos_num, 12, lanczos_denom, 12); }
+
+        XSF_HOST_DEVICE double lanczos_sum_near_1(double dx) {
+            double result = 0;
+            unsigned k;
+
+            for (k = 1; k <= 12; ++k) {
+                result += (-lanczos_sum_near_1_d[k - 1] * dx) / (k * dx + k * k);
+            }
+            return result;
+        }
+
+        XSF_HOST_DEVICE double lanczos_sum_near_2(double dx) {
+            double result = 0;
+            double x = dx + 2;
+            unsigned k;
+
+            for (k = 1; k <= 12; ++k) {
+                result += (-lanczos_sum_near_2_d[k - 1] * dx) / (x + k * x + k * k - 1);
+            }
+            return result;
+        }
+    } // namespace detail
+
+    constexpr double lanczos_g = 6.024680040776729583740234375;
+    XSF_HOST_DEVICE double lanczos_sum_expg_scaled(double x) {
+        return ratevl(x, detail::lanczos_sum_expg_scaled_num, 12, detail::lanczos_sum_expg_scaled_denom, 12);
+    }
+} // namespace cephes
+} // namespace xsf

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/special/xsf/cephes/ndtr.h

@@ -0,0 +1,275 @@
+/* Translated into C++ by SciPy developers in 2024.
+ * Original header with Copyright information appears below.
+ */
+
+/*                                                     ndtr.c
+ *
+ *     Normal distribution function
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, y, ndtr();
+ *
+ * y = ndtr( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns the area under the Gaussian probability density
+ * function, integrated from minus infinity to x:
+ *
+ *                            x
+ *                             -
+ *                   1        | |          2
+ *    ndtr(x)  = ---------    |    exp( - t /2 ) dt
+ *               sqrt(2pi)  | |
+ *                           -
+ *                          -inf.
+ *
+ *             =  ( 1 + erf(z) ) / 2
+ *             =  erfc(z) / 2
+ *
+ * where z = x/sqrt(2). Computation is via the functions
+ * erf and erfc.
+ *
+ *
+ * ACCURACY:
+ *
+ *                      Relative error:
+ * arithmetic   domain     # trials      peak         rms
+ *    IEEE     -13,0        30000       3.4e-14     6.7e-15
+ *
+ *
+ * ERROR MESSAGES:
+ *
+ *   message         condition         value returned
+ * erfc underflow    x > 37.519379347       0.0
+ *
+ */
+/*							erf.c
+ *
+ *	Error function
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, y, erf();
+ *
+ * y = erf( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * The integral is
+ *
+ *                           x
+ *                            -
+ *                 2         | |          2
+ *   erf(x)  =  --------     |    exp( - t  ) dt.
+ *              sqrt(pi)   | |
+ *                          -
+ *                           0
+ *
+ * For 0 <= |x| < 1, erf(x) = x * P4(x**2)/Q5(x**2); otherwise
+ * erf(x) = 1 - erfc(x).
+ *
+ *
+ *
+ * ACCURACY:
+ *
+ *                      Relative error:
+ * arithmetic   domain     # trials      peak         rms
+ *    IEEE      0,1         30000       3.7e-16     1.0e-16
+ *
+ */
+/*							erfc.c
+ *
+ *	Complementary error function
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, y, erfc();
+ *
+ * y = erfc( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ *
+ *  1 - erf(x) =
+ *
+ *                           inf.
+ *                             -
+ *                  2         | |          2
+ *   erfc(x)  =  --------     |    exp( - t  ) dt
+ *               sqrt(pi)   | |
+ *                           -
+ *                            x
+ *
+ *
+ * For small x, erfc(x) = 1 - erf(x); otherwise rational
+ * approximations are computed.
+ *
+ *
+ *
+ * ACCURACY:
+ *
+ *                      Relative error:
+ * arithmetic   domain     # trials      peak         rms
+ *    IEEE      0,26.6417   30000       5.7e-14     1.5e-14
+ */
+
+/*
+ * Cephes Math Library Release 2.2:  June, 1992
+ * Copyright 1984, 1987, 1988, 1992 by Stephen L. Moshier
+ * Direct inquiries to 30 Frost Street, Cambridge, MA 02140
+ */
+#pragma once
+
+#include "../config.h"
+
+#include "const.h"
+#include "polevl.h"
+
+namespace xsf {
+namespace cephes {
+
+    namespace detail {
+
+        constexpr double ndtr_P[] = {2.46196981473530512524E-10, 5.64189564831068821977E-1, 7.46321056442269912687E0,
+                                     4.86371970985681366614E1,   1.96520832956077098242E2,  5.26445194995477358631E2,
+                                     9.34528527171957607540E2,   1.02755188689515710272E3,  5.57535335369399327526E2};
+
+        constexpr double ndtr_Q[] = {
+            /* 1.00000000000000000000E0, */
+            1.32281951154744992508E1, 8.67072140885989742329E1, 3.54937778887819891062E2, 9.75708501743205489753E2,
+            1.82390916687909736289E3, 2.24633760818710981792E3, 1.65666309194161350182E3, 5.57535340817727675546E2};
+
+        constexpr double ndtr_R[] = {5.64189583547755073984E-1, 1.27536670759978104416E0, 5.01905042251180477414E0,
+                                     6.16021097993053585195E0,  7.40974269950448939160E0, 2.97886665372100240670E0};
+
+        constexpr double ndtr_S[] = {
+            /* 1.00000000000000000000E0, */
+            2.26052863220117276590E0, 9.39603524938001434673E0, 1.20489539808096656605E1,
+            1.70814450747565897222E1, 9.60896809063285878198E0, 3.36907645100081516050E0};
+
+        constexpr double ndtr_T[] = {9.60497373987051638749E0, 9.00260197203842689217E1, 2.23200534594684319226E3,
+                                     7.00332514112805075473E3, 5.55923013010394962768E4};
+
+        constexpr double ndtr_U[] = {
+            /* 1.00000000000000000000E0, */
+            3.35617141647503099647E1, 5.21357949780152679795E2, 4.59432382970980127987E3, 2.26290000613890934246E4,
+            4.92673942608635921086E4};
+
+        constexpr double ndtri_UTHRESH = 37.519379347;
+
+    } // namespace detail
+
+    XSF_HOST_DEVICE inline double erf(double x);
+
+    XSF_HOST_DEVICE inline double erfc(double a) {
+        double p, q, x, y, z;
+
+        if (std::isnan(a)) {
+            set_error("erfc", SF_ERROR_DOMAIN, NULL);
+            return std::numeric_limits<double>::quiet_NaN();
+        }
+
+        if (a < 0.0) {
+            x = -a;
+        } else {
+            x = a;
+        }
+
+        if (x < 1.0) {
+            return 1.0 - erf(a);
+        }
+
+        z = -a * a;
+
+        if (z < -detail::MAXLOG) {
+            goto under;
+        }
+
+        z = std::exp(z);
+
+        if (x < 8.0) {
+            p = polevl(x, detail::ndtr_P, 8);
+            q = p1evl(x, detail::ndtr_Q, 8);
+        } else {
+            p = polevl(x, detail::ndtr_R, 5);
+            q = p1evl(x, detail::ndtr_S, 6);
+        }
+        y = (z * p) / q;
+
+        if (a < 0) {
+            y = 2.0 - y;
+        }
+
+        if (y != 0.0) {
+            return y;
+        }
+
+    under:
+        set_error("erfc", SF_ERROR_UNDERFLOW, NULL);
+        if (a < 0) {
+            return 2.0;
+        } else {
+            return 0.0;
+        }
+    }
+
+    XSF_HOST_DEVICE inline double erf(double x) {
+        double y, z;
+
+        if (std::isnan(x)) {
+            set_error("erf", SF_ERROR_DOMAIN, NULL);
+            return std::numeric_limits<double>::quiet_NaN();
+        }
+
+        if (x < 0.0) {
+            return -erf(-x);
+        }
+
+        if (std::abs(x) > 1.0) {
+            return (1.0 - erfc(x));
+        }
+        z = x * x;
+
+        y = x * polevl(z, detail::ndtr_T, 4) / p1evl(z, detail::ndtr_U, 5);
+        return y;
+    }
+
+    XSF_HOST_DEVICE inline double ndtr(double a) {
+        double x, y, z;
+
+        if (std::isnan(a)) {
+            set_error("ndtr", SF_ERROR_DOMAIN, NULL);
+            return std::numeric_limits<double>::quiet_NaN();
+        }
+
+        x = a * M_SQRT1_2;
+        z = std::abs(x);
+
+        if (z < 1.0) {
+            y = 0.5 + 0.5 * erf(x);
+        } else {
+            y = 0.5 * erfc(z);
+            if (x > 0) {
+                y = 1.0 - y;
+            }
+        }
+
+        return y;
+    }
+
+} // namespace cephes
+} // namespace xsf

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/special/xsf/cephes/poch.h

@@ -0,0 +1,85 @@
+/*
+ * Pochhammer symbol (a)_m = gamma(a + m) / gamma(a)
+ */
+
+#pragma once
+
+#include "../config.h"
+#include "gamma.h"
+
+namespace xsf {
+namespace cephes {
+
+    namespace detail {
+
+        XSF_HOST_DEVICE inline double is_nonpos_int(double x) {
+            return x <= 0 && x == std::ceil(x) && std::abs(x) < 1e13;
+        }
+    } // namespace detail
+
+    XSF_HOST_DEVICE inline double poch(double a, double m) {
+        double r = 1.0;
+
+        /*
+         * 1. Reduce magnitude of `m` to |m| < 1 by using recurrence relations.
+         *
+         * This may end up in over/underflow, but then the function itself either
+         * diverges or goes to zero. In case the remainder goes to the opposite
+         * direction, we end up returning 0*INF = NAN, which is OK.
+         */
+
+        /* Recurse down */
+        while (m >= 1.0) {
+            if (a + m == 1) {
+                break;
+            }
+            m -= 1.0;
+            r *= (a + m);
+            if (!std::isfinite(r) || r == 0) {
+                break;
+            }
+        }
+
+        /* Recurse up */
+        while (m <= -1.0) {
+            if (a + m == 0) {
+                break;
+            }
+            r /= (a + m);
+            m += 1.0;
+            if (!std::isfinite(r) || r == 0) {
+                break;
+            }
+        }
+
+        /*
+         * 2. Evaluate function with reduced `m`
+         *
+         * Now either `m` is not big, or the `r` product has over/underflown.
+         * If so, the function itself does similarly.
+         */
+
+        if (m == 0) {
+            /* Easy case */
+            return r;
+        } else if (a > 1e4 && std::abs(m) <= 1) {
+            /* Avoid loss of precision */
+            return r * std::pow(a, m) *
+                   (1 + m * (m - 1) / (2 * a) + m * (m - 1) * (m - 2) * (3 * m - 1) / (24 * a * a) +
+                    m * m * (m - 1) * (m - 1) * (m - 2) * (m - 3) / (48 * a * a * a));
+        }
+
+        /* Check for infinity */
+        if (detail::is_nonpos_int(a + m) && !detail::is_nonpos_int(a) && a + m != m) {
+            return std::numeric_limits<double>::infinity();
+        }
+
+        /* Check for zero */
+        if (!detail::is_nonpos_int(a + m) && detail::is_nonpos_int(a)) {
+            return 0;
+        }
+
+        return r * std::exp(lgam(a + m) - lgam(a)) * gammasgn(a + m) * gammasgn(a);
+    }
+} // namespace cephes
+} // namespace xsf

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/special/xsf/cephes/polevl.h

@@ -0,0 +1,167 @@
+/* Translated into C++ by SciPy developers in 2024.
+ * Original header with Copyright information appears below.
+ */
+
+/*                                                     polevl.c
+ *                                                     p1evl.c
+ *
+ *     Evaluate polynomial
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * int N;
+ * double x, y, coef[N+1], polevl[];
+ *
+ * y = polevl( x, coef, N );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Evaluates polynomial of degree N:
+ *
+ *                     2          N
+ * y  =  C  + C x + C x  +...+ C x
+ *        0    1     2          N
+ *
+ * Coefficients are stored in reverse order:
+ *
+ * coef[0] = C  , ..., coef[N] = C  .
+ *            N                   0
+ *
+ * The function p1evl() assumes that c_N = 1.0 so that coefficent
+ * is omitted from the array.  Its calling arguments are
+ * otherwise the same as polevl().
+ *
+ *
+ * SPEED:
+ *
+ * In the interest of speed, there are no checks for out
+ * of bounds arithmetic.  This routine is used by most of
+ * the functions in the library.  Depending on available
+ * equipment features, the user may wish to rewrite the
+ * program in microcode or assembly language.
+ *
+ */
+
+/*
+ * Cephes Math Library Release 2.1:  December, 1988
+ * Copyright 1984, 1987, 1988 by Stephen L. Moshier
+ * Direct inquiries to 30 Frost Street, Cambridge, MA 02140
+ */
+
+/* Sources:
+ * [1] Holin et. al., "Polynomial and Rational Function Evaluation",
+ *     https://www.boost.org/doc/libs/1_61_0/libs/math/doc/html/math_toolkit/roots/rational.html
+ */
+
+/* Scipy changes:
+ * - 06-23-2016: add code for evaluating rational functions
+ */
+
+#pragma once
+
+#include "../config.h"
+
+namespace xsf {
+namespace cephes {
+    XSF_HOST_DEVICE inline double polevl(double x, const double coef[], int N) {
+        double ans;
+        int i;
+        const double *p;
+
+        p = coef;
+        ans = *p++;
+        i = N;
+
+        do {
+            ans = ans * x + *p++;
+        } while (--i);
+
+        return (ans);
+    }
+
+    /*                                                     p1evl() */
+    /*                                          N
+     * Evaluate polynomial when coefficient of x  is 1.0.
+     * That is, C_{N} is assumed to be 1, and that coefficient
+     * is not included in the input array coef.
+     * coef must have length N and contain the polynomial coefficients
+     * stored as
+     *     coef[0] = C_{N-1}
+     *     coef[1] = C_{N-2}
+     *          ...
+     *     coef[N-2] = C_1
+     *     coef[N-1] = C_0
+     * Otherwise same as polevl.
+     */
+
+    XSF_HOST_DEVICE inline double p1evl(double x, const double coef[], int N) {
+        double ans;
+        const double *p;
+        int i;
+
+        p = coef;
+        ans = x + *p++;
+        i = N - 1;
+
+        do
+            ans = ans * x + *p++;
+        while (--i);
+
+        return (ans);
+    }
+
+    /* Evaluate a rational function. See [1]. */
+
+    /* The function ratevl is only used once in cephes/lanczos.h. */
+    XSF_HOST_DEVICE inline double ratevl(double x, const double num[], int M, const double denom[], int N) {
+        int i, dir;
+        double y, num_ans, denom_ans;
+        double absx = std::abs(x);
+        const double *p;
+
+        if (absx > 1) {
+            /* Evaluate as a polynomial in 1/x. */
+            dir = -1;
+            p = num + M;
+            y = 1 / x;
+        } else {
+            dir = 1;
+            p = num;
+            y = x;
+        }
+
+        /* Evaluate the numerator */
+        num_ans = *p;
+        p += dir;
+        for (i = 1; i <= M; i++) {
+            num_ans = num_ans * y + *p;
+            p += dir;
+        }
+
+        /* Evaluate the denominator */
+        if (absx > 1) {
+            p = denom + N;
+        } else {
+            p = denom;
+        }
+
+        denom_ans = *p;
+        p += dir;
+        for (i = 1; i <= N; i++) {
+            denom_ans = denom_ans * y + *p;
+            p += dir;
+        }
+
+        if (absx > 1) {
+            i = M - N;
+            return std::pow(x, i) * num_ans / denom_ans;
+        } else {
+            return num_ans / denom_ans;
+        }
+    }
+} // namespace cephes
+} // namespace xsf

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/special/xsf/cephes/psi.h

@@ -0,0 +1,194 @@
+/* Translated into C++ by SciPy developers in 2024.
+ * Original header with Copyright information appears below.
+ */
+
+/*                                                     psi.c
+ *
+ *     Psi (digamma) function
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, y, psi();
+ *
+ * y = psi( x );
+ *
+ *
+ * DESCRIPTION:
+ *
+ *              d      -
+ *   psi(x)  =  -- ln | (x)
+ *              dx
+ *
+ * is the logarithmic derivative of the gamma function.
+ * For integer x,
+ *                   n-1
+ *                    -
+ * psi(n) = -EUL  +   >  1/k.
+ *                    -
+ *                   k=1
+ *
+ * This formula is used for 0 < n <= 10.  If x is negative, it
+ * is transformed to a positive argument by the reflection
+ * formula  psi(1-x) = psi(x) + pi cot(pi x).
+ * For general positive x, the argument is made greater than 10
+ * using the recurrence  psi(x+1) = psi(x) + 1/x.
+ * Then the following asymptotic expansion is applied:
+ *
+ *                           inf.   B
+ *                            -      2k
+ * psi(x) = log(x) - 1/2x -   >   -------
+ *                            -        2k
+ *                           k=1   2k x
+ *
+ * where the B2k are Bernoulli numbers.
+ *
+ * ACCURACY:
+ *    Relative error (except absolute when |psi| < 1):
+ * arithmetic   domain     # trials      peak         rms
+ *    IEEE      0,30        30000       1.3e-15     1.4e-16
+ *    IEEE      -30,0       40000       1.5e-15     2.2e-16
+ *
+ * ERROR MESSAGES:
+ *     message         condition      value returned
+ * psi singularity    x integer <=0      INFINITY
+ */
+
+/*
+ * Cephes Math Library Release 2.8:  June, 2000
+ * Copyright 1984, 1987, 1992, 2000 by Stephen L. Moshier
+ */
+
+/*
+ * Code for the rational approximation on [1, 2] is:
+ *
+ * (C) Copyright John Maddock 2006.
+ * Use, modification and distribution are subject to the
+ * Boost Software License, Version 1.0. (See accompanying file
+ * LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
+ */
+#pragma once
+
+#include "../config.h"
+#include "../error.h"
+#include "const.h"
+#include "polevl.h"
+
+namespace xsf {
+namespace cephes {
+    namespace detail {
+        constexpr double psi_A[] = {8.33333333333333333333E-2,  -2.10927960927960927961E-2, 7.57575757575757575758E-3,
+                                    -4.16666666666666666667E-3, 3.96825396825396825397E-3,  -8.33333333333333333333E-3,
+                                    8.33333333333333333333E-2};
+
+        constexpr float psi_Y = 0.99558162689208984f;
+
+        constexpr double psi_root1 = 1569415565.0 / 1073741824.0;
+        constexpr double psi_root2 = (381566830.0 / 1073741824.0) / 1073741824.0;
+        constexpr double psi_root3 = 0.9016312093258695918615325266959189453125e-19;
+
+        constexpr double psi_P[] = {-0.0020713321167745952, -0.045251321448739056, -0.28919126444774784,
+                                    -0.65031853770896507,   -0.32555031186804491,  0.25479851061131551};
+        constexpr double psi_Q[] = {-0.55789841321675513e-6,
+                                    0.0021284987017821144,
+                                    0.054151797245674225,
+                                    0.43593529692665969,
+                                    1.4606242909763515,
+                                    2.0767117023730469,
+                                    1.0};
+
+        XSF_HOST_DEVICE double digamma_imp_1_2(double x) {
+            /*
+             * Rational approximation on [1, 2] taken from Boost.
+             *
+             * Now for the approximation, we use the form:
+             *
+             * digamma(x) = (x - root) * (Y + R(x-1))
+             *
+             * Where root is the location of the positive root of digamma,
+             * Y is a constant, and R is optimised for low absolute error
+             * compared to Y.
+             *
+             * Maximum Deviation Found:               1.466e-18
+             * At double precision, max error found:  2.452e-17
+             */
+            double r, g;
+
+            g = x - psi_root1;
+            g -= psi_root2;
+            g -= psi_root3;
+            r = xsf::cephes::polevl(x - 1.0, psi_P, 5) / xsf::cephes::polevl(x - 1.0, psi_Q, 6);
+
+            return g * psi_Y + g * r;
+        }
+
+        XSF_HOST_DEVICE double psi_asy(double x) {
+            double y, z;
+
+            if (x < 1.0e17) {
+                z = 1.0 / (x * x);
+                y = z * xsf::cephes::polevl(z, psi_A, 6);
+            } else {
+                y = 0.0;
+            }
+
+            return std::log(x) - (0.5 / x) - y;
+        }
+    } // namespace detail
+
+    XSF_HOST_DEVICE double psi(double x) {
+        double y = 0.0;
+        double q, r;
+        int i, n;
+
+        if (std::isnan(x)) {
+            return x;
+        } else if (x == std::numeric_limits<double>::infinity()) {
+            return x;
+        } else if (x == -std::numeric_limits<double>::infinity()) {
+            return std::numeric_limits<double>::quiet_NaN();
+        } else if (x == 0) {
+            set_error("psi", SF_ERROR_SINGULAR, NULL);
+            return std::copysign(std::numeric_limits<double>::infinity(), -x);
+        } else if (x < 0.0) {
+            /* argument reduction before evaluating tan(pi * x) */
+            r = std::modf(x, &q);
+            if (r == 0.0) {
+                set_error("psi", SF_ERROR_SINGULAR, NULL);
+                return std::numeric_limits<double>::quiet_NaN();
+            }
+            y = -M_PI / std::tan(M_PI * r);
+            x = 1.0 - x;
+        }
+
+        /* check for positive integer up to 10 */
+        if ((x <= 10.0) && (x == std::floor(x))) {
+            n = static_cast<int>(x);
+            for (i = 1; i < n; i++) {
+                y += 1.0 / i;
+            }
+            y -= detail::SCIPY_EULER;
+            return y;
+        }
+
+        /* use the recurrence relation to move x into [1, 2] */
+        if (x < 1.0) {
+            y -= 1.0 / x;
+            x += 1.0;
+        } else if (x < 10.0) {
+            while (x > 2.0) {
+                x -= 1.0;
+                y += 1.0 / x;
+            }
+        }
+        if ((1.0 <= x) && (x <= 2.0)) {
+            y += detail::digamma_imp_1_2(x);
+            return y;
+        }
+
+        /* x is large, use the asymptotic series */
+        y += detail::psi_asy(x);
+        return y;
+    }
+} // namespace cephes
+} // namespace xsf

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/special/xsf/cephes/rgamma.h

@@ -0,0 +1,111 @@
+/*                                             rgamma.c
+ *
+ *     Reciprocal Gamma function
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, y, rgamma();
+ *
+ * y = rgamma( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns one divided by the Gamma function of the argument.
+ *
+ * The function is approximated by a Chebyshev expansion in
+ * the interval [0,1].  Range reduction is by recurrence
+ * for arguments between -34.034 and +34.84425627277176174.
+ * 0 is returned for positive arguments outside this
+ * range.  For arguments less than -34.034 the cosecant
+ * reflection formula is applied; lograrithms are employed
+ * to avoid unnecessary overflow.
+ *
+ * The reciprocal Gamma function has no singularities,
+ * but overflow and underflow may occur for large arguments.
+ * These conditions return either INFINITY or 0 with
+ * appropriate sign.
+ *
+ * ACCURACY:
+ *
+ *                      Relative error:
+ * arithmetic   domain     # trials      peak         rms
+ *    IEEE     -30,+30      30000       1.1e-15     2.0e-16
+ * For arguments less than -34.034 the peak error is on the
+ * order of 5e-15 (DEC), excepting overflow or underflow.
+ */
+
+/*
+ * Cephes Math Library Release 2.0:  April, 1987
+ * Copyright 1985, 1987 by Stephen L. Moshier
+ * Direct inquiries to 30 Frost Street, Cambridge, MA 02140
+ */
+#pragma once
+
+#include "../config.h"
+#include "../error.h"
+#include "chbevl.h"
+#include "const.h"
+#include "gamma.h"
+#include "trig.h"
+
+namespace xsf {
+namespace cephes {
+
+    namespace detail {
+
+        /* Chebyshev coefficients for reciprocal Gamma function
+         * in interval 0 to 1.  Function is 1/(x Gamma(x)) - 1
+         */
+
+        constexpr double rgamma_R[] = {
+            3.13173458231230000000E-17, -6.70718606477908000000E-16, 2.20039078172259550000E-15,
+            2.47691630348254132600E-13, -6.60074100411295197440E-12, 5.13850186324226978840E-11,
+            1.08965386454418662084E-9,  -3.33964630686836942556E-8,  2.68975996440595483619E-7,
+            2.96001177518801696639E-6,  -8.04814124978471142852E-5,  4.16609138709688864714E-4,
+            5.06579864028608725080E-3,  -6.41925436109158228810E-2,  -4.98558728684003594785E-3,
+            1.27546015610523951063E-1};
+
+    } // namespace detail
+
+    XSF_HOST_DEVICE double rgamma(double x) {
+        double w, y, z;
+
+	if (x == 0) {
+	    // This case is separate from below to get correct sign for zero.
+	    return x;
+	}
+
+	if (x < 0 && x == std::floor(x)) {
+	    // Gamma poles.
+	    return 0.0;
+	}
+
+	if (std::abs(x) > 4.0) {
+	    return 1.0 / Gamma(x);
+	}
+
+        z = 1.0;
+        w = x;
+
+        while (w > 1.0) { /* Downward recurrence */
+            w -= 1.0;
+            z *= w;
+        }
+        while (w < 0.0) { /* Upward recurrence */
+            z /= w;
+            w += 1.0;
+        }
+        if (w == 0.0) /* Nonpositive integer */
+            return (0.0);
+        if (w == 1.0) /* Other integer */
+            return (1.0 / z);
+
+        y = w * (1.0 + chbevl(4.0 * w - 2.0, detail::rgamma_R, 16)) / z;
+        return (y);
+    }
+} // namespace cephes
+} // namespace xsf

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/special/xsf/cephes/scipy_iv.h

@@ -0,0 +1,811 @@
+/* Translated into C++ by SciPy developers in 2024.
+ * Original header with Copyright information appears below.
+ */
+
+/*                                                     iv.c
+ *
+ *     Modified Bessel function of noninteger order
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double v, x, y, iv();
+ *
+ * y = iv( v, x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns modified Bessel function of order v of the
+ * argument.  If x is negative, v must be integer valued.
+ *
+ */
+/*                                                     iv.c    */
+/*     Modified Bessel function of noninteger order            */
+/* If x < 0, then v must be an integer. */
+
+/*
+ * Parts of the code are copyright:
+ *
+ *     Cephes Math Library Release 2.8:  June, 2000
+ *     Copyright 1984, 1987, 1988, 2000 by Stephen L. Moshier
+ *
+ * And other parts:
+ *
+ *     Copyright (c) 2006 Xiaogang Zhang
+ *     Use, modification and distribution are subject to the
+ *     Boost Software License, Version 1.0.
+ *
+ *     Boost Software License - Version 1.0 - August 17th, 2003
+ *
+ *     Permission is hereby granted, free of charge, to any person or
+ *     organization obtaining a copy of the software and accompanying
+ *     documentation covered by this license (the "Software") to use, reproduce,
+ *     display, distribute, execute, and transmit the Software, and to prepare
+ *     derivative works of the Software, and to permit third-parties to whom the
+ *     Software is furnished to do so, all subject to the following:
+ *
+ *     The copyright notices in the Software and this entire statement,
+ *     including the above license grant, this restriction and the following
+ *     disclaimer, must be included in all copies of the Software, in whole or
+ *     in part, and all derivative works of the Software, unless such copies or
+ *     derivative works are solely in the form of machine-executable object code
+ *     generated by a source language processor.
+ *
+ *     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ *     OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *     MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
+ *     NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR ANYONE
+ *     DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY,
+ *     WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ *     CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *     SOFTWARE.
+ *
+ * And the rest are:
+ *
+ *     Copyright (C) 2009 Pauli Virtanen
+ *     Distributed under the same license as Scipy.
+ *
+ */
+#pragma once
+
+#include "../config.h"
+#include "../error.h"
+
+#include "const.h"
+#include "gamma.h"
+#include "trig.h"
+
+namespace xsf {
+namespace cephes {
+
+    namespace detail {
+
+        /*
+         * Compute Iv from (AMS5 9.7.1), asymptotic expansion for large |z|
+         * Iv ~ exp(x)/sqrt(2 pi x) ( 1 + (4*v*v-1)/8x + (4*v*v-1)(4*v*v-9)/8x/2! + ...)
+         */
+        XSF_HOST_DEVICE inline double iv_asymptotic(double v, double x) {
+            double mu;
+            double sum, term, prefactor, factor;
+            int k;
+
+            prefactor = std::exp(x) / std::sqrt(2 * M_PI * x);
+
+            if (prefactor == std::numeric_limits<double>::infinity()) {
+                return prefactor;
+            }
+
+            mu = 4 * v * v;
+            sum = 1.0;
+            term = 1.0;
+            k = 1;
+
+            do {
+                factor = (mu - (2 * k - 1) * (2 * k - 1)) / (8 * x) / k;
+                if (k > 100) {
+                    /* didn't converge */
+                    set_error("iv(iv_asymptotic)", SF_ERROR_NO_RESULT, NULL);
+                    break;
+                }
+                term *= -factor;
+                sum += term;
+                ++k;
+            } while (std::abs(term) > MACHEP * std::abs(sum));
+            return sum * prefactor;
+        }
+
+        /*
+         * Uniform asymptotic expansion factors, (AMS5 9.3.9; AMS5 9.3.10)
+         *
+         * Computed with:
+         * --------------------
+         import numpy as np
+         t = np.poly1d([1,0])
+         def up1(p):
+         return .5*t*t*(1-t*t)*p.deriv() + 1/8. * ((1-5*t*t)*p).integ()
+         us = [np.poly1d([1])]
+         for k in range(10):
+         us.append(up1(us[-1]))
+         n = us[-1].order
+         for p in us:
+         print "{" + ", ".join(["0"]*(n-p.order) + map(repr, p)) + "},"
+         print "N_UFACTORS", len(us)
+         print "N_UFACTOR_TERMS", us[-1].order + 1
+         * --------------------
+         */
+        constexpr int iv_N_UFACTORS = 11;
+        constexpr int iv_N_UFACTOR_TERMS = 31;
+
+        constexpr double iv_asymptotic_ufactors[iv_N_UFACTORS][iv_N_UFACTOR_TERMS] = {
+            {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
+            {0,   0,     0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+             0,   0,     0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0.20833333333333334,
+             0.0, 0.125, 0.0},
+            {0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0.3342013888888889,
+             0.0,
+             -0.40104166666666669,
+             0.0,
+             0.0703125,
+             0.0,
+             0.0},
+            {0,   0,
+             0,   0,
+             0,   0,
+             0,   0,
+             0,   0,
+             0,   0,
+             0,   0,
+             0,   0,
+             0,   0,
+             0,   0,
+             0,   -1.0258125964506173,
+             0.0, 1.8464626736111112,
+             0.0, -0.89121093750000002,
+             0.0, 0.0732421875,
+             0.0, 0.0,
+             0.0},
+            {0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             4.6695844234262474,
+             0.0,
+             -11.207002616222995,
+             0.0,
+             8.78912353515625,
+             0.0,
+             -2.3640869140624998,
+             0.0,
+             0.112152099609375,
+             0.0,
+             0.0,
+             0.0,
+             0.0},
+            {0,   0,
+             0,   0,
+             0,   0,
+             0,   0,
+             0,   0,
+             0,   0,
+             0,   0,
+             0,   -28.212072558200244,
+             0.0, 84.636217674600744,
+             0.0, -91.818241543240035,
+             0.0, 42.534998745388457,
+             0.0, -7.3687943594796312,
+             0.0, 0.22710800170898438,
+             0.0, 0.0,
+             0.0, 0.0,
+             0.0},
+            {0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             212.5701300392171,
+             0.0,
+             -765.25246814118157,
+             0.0,
+             1059.9904525279999,
+             0.0,
+             -699.57962737613275,
+             0.0,
+             218.19051174421159,
+             0.0,
+             -26.491430486951554,
+             0.0,
+             0.57250142097473145,
+             0.0,
+             0.0,
+             0.0,
+             0.0,
+             0.0,
+             0.0},
+            {0,   0,
+             0,   0,
+             0,   0,
+             0,   0,
+             0,   -1919.4576623184068,
+             0.0, 8061.7221817373083,
+             0.0, -13586.550006434136,
+             0.0, 11655.393336864536,
+             0.0, -5305.6469786134048,
+             0.0, 1200.9029132163525,
+             0.0, -108.09091978839464,
+             0.0, 1.7277275025844574,
+             0.0, 0.0,
+             0.0, 0.0,
+             0.0, 0.0,
+             0.0},
+            {0,
+             0,
+             0,
+             0,
+             0,
+             0,
+             20204.291330966149,
+             0.0,
+             -96980.598388637503,
+             0.0,
+             192547.0012325315,
+             0.0,
+             -203400.17728041555,
+             0.0,
+             122200.46498301747,
+             0.0,
+             -41192.654968897557,
+             0.0,
+             7109.5143024893641,
+             0.0,
+             -493.915304773088,
+             0.0,
+             6.074042001273483,
+             0.0,
+             0.0,
+             0.0,
+             0.0,
+             0.0,
+             0.0,
+             0.0,
+             0.0},
+            {0,   0,
+             0,   -242919.18790055133,
+             0.0, 1311763.6146629769,
+             0.0, -2998015.9185381061,
+             0.0, 3763271.2976564039,
+             0.0, -2813563.2265865342,
+             0.0, 1268365.2733216248,
+             0.0, -331645.17248456361,
+             0.0, 45218.768981362737,
+             0.0, -2499.8304818112092,
+             0.0, 24.380529699556064,
+             0.0, 0.0,
+             0.0, 0.0,
+             0.0, 0.0,
+             0.0, 0.0,
+             0.0},
+            {3284469.8530720375,
+             0.0,
+             -19706819.11843222,
+             0.0,
+             50952602.492664628,
+             0.0,
+             -74105148.211532637,
+             0.0,
+             66344512.274729028,
+             0.0,
+             -37567176.660763353,
+             0.0,
+             13288767.166421819,
+             0.0,
+             -2785618.1280864552,
+             0.0,
+             308186.40461266245,
+             0.0,
+             -13886.089753717039,
+             0.0,
+             110.01714026924674,
+             0.0,
+             0.0,
+             0.0,
+             0.0,
+             0.0,
+             0.0,
+             0.0,
+             0.0,
+             0.0,
+             0.0}};
+
+        /*
+         * Compute Iv, Kv from (AMS5 9.7.7 + 9.7.8), asymptotic expansion for large v
+         */
+        XSF_HOST_DEVICE inline void ikv_asymptotic_uniform(double v, double x, double *i_value, double *k_value) {
+            double i_prefactor, k_prefactor;
+            double t, t2, eta, z;
+            double i_sum, k_sum, term, divisor;
+            int k, n;
+            int sign = 1;
+
+            if (v < 0) {
+                /* Negative v; compute I_{-v} and K_{-v} and use (AMS 9.6.2) */
+                sign = -1;
+                v = -v;
+            }
+
+            z = x / v;
+            t = 1 / std::sqrt(1 + z * z);
+            t2 = t * t;
+            eta = std::sqrt(1 + z * z) + std::log(z / (1 + 1 / t));
+
+            i_prefactor = std::sqrt(t / (2 * M_PI * v)) * std::exp(v * eta);
+            i_sum = 1.0;
+
+            k_prefactor = std::sqrt(M_PI * t / (2 * v)) * std::exp(-v * eta);
+            k_sum = 1.0;
+
+            divisor = v;
+            for (n = 1; n < iv_N_UFACTORS; ++n) {
+                /*
+                 * Evaluate u_k(t) with Horner's scheme;
+                 * (using the knowledge about which coefficients are zero)
+                 */
+                term = 0;
+                for (k = iv_N_UFACTOR_TERMS - 1 - 3 * n; k < iv_N_UFACTOR_TERMS - n; k += 2) {
+                    term *= t2;
+                    term += iv_asymptotic_ufactors[n][k];
+                }
+                for (k = 1; k < n; k += 2) {
+                    term *= t2;
+                }
+                if (n % 2 == 1) {
+                    term *= t;
+                }
+
+                /* Sum terms */
+                term /= divisor;
+                i_sum += term;
+                k_sum += (n % 2 == 0) ? term : -term;
+
+                /* Check convergence */
+                if (std::abs(term) < MACHEP) {
+                    break;
+                }
+
+                divisor *= v;
+            }
+
+            if (std::abs(term) > 1e-3 * std::abs(i_sum)) {
+                /* Didn't converge */
+                set_error("ikv_asymptotic_uniform", SF_ERROR_NO_RESULT, NULL);
+            }
+            if (std::abs(term) > MACHEP * std::abs(i_sum)) {
+                /* Some precision lost */
+                set_error("ikv_asymptotic_uniform", SF_ERROR_LOSS, NULL);
+            }
+
+            if (k_value != NULL) {
+                /* symmetric in v */
+                *k_value = k_prefactor * k_sum;
+            }
+
+            if (i_value != NULL) {
+                if (sign == 1) {
+                    *i_value = i_prefactor * i_sum;
+                } else {
+                    /* (AMS 9.6.2) */
+                    *i_value = (i_prefactor * i_sum + (2 / M_PI) * xsf::cephes::sinpi(v) * k_prefactor * k_sum);
+                }
+            }
+        }
+
+        /*
+         * The following code originates from the Boost C++ library,
+         * from file `boost/math/special_functions/detail/bessel_ik.hpp`,
+         * converted from C++ to C.
+         */
+
+        /*
+         * Modified Bessel functions of the first and second kind of fractional order
+         *
+         * Calculate K(v, x) and K(v+1, x) by method analogous to
+         * Temme, Journal of Computational Physics, vol 21, 343 (1976)
+         */
+        XSF_HOST_DEVICE inline int temme_ik_series(double v, double x, double *K, double *K1) {
+            double f, h, p, q, coef, sum, sum1, tolerance;
+            double a, b, c, d, sigma, gamma1, gamma2;
+            std::uint64_t k;
+            double gp;
+            double gm;
+
+            /*
+             * |x| <= 2, Temme series converge rapidly
+             * |x| > 2, the larger the |x|, the slower the convergence
+             */
+            XSF_ASSERT(std::abs(x) <= 2);
+            XSF_ASSERT(std::abs(v) <= 0.5f);
+
+            gp = xsf::cephes::Gamma(v + 1) - 1;
+            gm = xsf::cephes::Gamma(-v + 1) - 1;
+
+            a = std::log(x / 2);
+            b = std::exp(v * a);
+            sigma = -a * v;
+            c = std::abs(v) < MACHEP ? 1 : xsf::cephes::sinpi(v) / (v * M_PI);
+            d = std::abs(sigma) < MACHEP ? 1 : std::sinh(sigma) / sigma;
+            gamma1 = std::abs(v) < MACHEP ? -SCIPY_EULER : (0.5 / v) * (gp - gm) * c;
+            gamma2 = (2 + gp + gm) * c / 2;
+
+            /* initial values */
+            p = (gp + 1) / (2 * b);
+            q = (1 + gm) * b / 2;
+            f = (std::cosh(sigma) * gamma1 + d * (-a) * gamma2) / c;
+            h = p;
+            coef = 1;
+            sum = coef * f;
+            sum1 = coef * h;
+
+            /* series summation */
+            tolerance = MACHEP;
+            for (k = 1; k < MAXITER; k++) {
+                f = (k * f + p + q) / (k * k - v * v);
+                p /= k - v;
+                q /= k + v;
+                h = p - k * f;
+                coef *= x * x / (4 * k);
+                sum += coef * f;
+                sum1 += coef * h;
+                if (std::abs(coef * f) < std::abs(sum) * tolerance) {
+                    break;
+                }
+            }
+            if (k == MAXITER) {
+                set_error("ikv_temme(temme_ik_series)", SF_ERROR_NO_RESULT, NULL);
+            }
+
+            *K = sum;
+            *K1 = 2 * sum1 / x;
+
+            return 0;
+        }
+
+        /* Evaluate continued fraction fv = I_(v+1) / I_v, derived from
+         * Abramowitz and Stegun, Handbook of Mathematical Functions, 1972, 9.1.73 */
+        XSF_HOST_DEVICE inline int CF1_ik(double v, double x, double *fv) {
+            double C, D, f, a, b, delta, tiny, tolerance;
+            std::uint64_t k;
+
+            /*
+             * |x| <= |v|, CF1_ik converges rapidly
+             * |x| > |v|, CF1_ik needs O(|x|) iterations to converge
+             */
+
+            /*
+             * modified Lentz's method, see
+             * Lentz, Applied Optics, vol 15, 668 (1976)
+             */
+            tolerance = 2 * MACHEP;
+            tiny = 1 / std::sqrt(std::numeric_limits<double>::max());
+            C = f = tiny; /* b0 = 0, replace with tiny */
+            D = 0;
+            for (k = 1; k < MAXITER; k++) {
+                a = 1;
+                b = 2 * (v + k) / x;
+                C = b + a / C;
+                D = b + a * D;
+                if (C == 0) {
+                    C = tiny;
+                }
+                if (D == 0) {
+                    D = tiny;
+                }
+                D = 1 / D;
+                delta = C * D;
+                f *= delta;
+                if (std::abs(delta - 1) <= tolerance) {
+                    break;
+                }
+            }
+            if (k == MAXITER) {
+                set_error("ikv_temme(CF1_ik)", SF_ERROR_NO_RESULT, NULL);
+            }
+
+            *fv = f;
+
+            return 0;
+        }
+
+        /*
+         * Calculate K(v, x) and K(v+1, x) by evaluating continued fraction
+         * z1 / z0 = U(v+1.5, 2v+1, 2x) / U(v+0.5, 2v+1, 2x), see
+         * Thompson and Barnett, Computer Physics Communications, vol 47, 245 (1987)
+         */
+        XSF_HOST_DEVICE inline int CF2_ik(double v, double x, double *Kv, double *Kv1) {
+
+            double S, C, Q, D, f, a, b, q, delta, tolerance, current, prev;
+            std::uint64_t k;
+
+            /*
+             * |x| >= |v|, CF2_ik converges rapidly
+             * |x| -> 0, CF2_ik fails to converge
+             */
+
+            XSF_ASSERT(std::abs(x) > 1);
+
+            /*
+             * Steed's algorithm, see Thompson and Barnett,
+             * Journal of Computational Physics, vol 64, 490 (1986)
+             */
+            tolerance = MACHEP;
+            a = v * v - 0.25;
+            b = 2 * (x + 1);                /* b1 */
+            D = 1 / b;                      /* D1 = 1 / b1 */
+            f = delta = D;                  /* f1 = delta1 = D1, coincidence */
+            prev = 0;                       /* q0 */
+            current = 1;                    /* q1 */
+            Q = C = -a;                     /* Q1 = C1 because q1 = 1 */
+            S = 1 + Q * delta;              /* S1 */
+            for (k = 2; k < MAXITER; k++) { /* starting from 2 */
+                /* continued fraction f = z1 / z0 */
+                a -= 2 * (k - 1);
+                b += 2;
+                D = 1 / (b + a * D);
+                delta *= b * D - 1;
+                f += delta;
+
+                /* series summation S = 1 + \sum_{n=1}^{\infty} C_n * z_n / z_0 */
+                q = (prev - (b - 2) * current) / a;
+                prev = current;
+                current = q; /* forward recurrence for q */
+                C *= -a / k;
+                Q += C * q;
+                S += Q * delta;
+
+                /* S converges slower than f */
+                if (std::abs(Q * delta) < std::abs(S) * tolerance) {
+                    break;
+                }
+            }
+            if (k == MAXITER) {
+                set_error("ikv_temme(CF2_ik)", SF_ERROR_NO_RESULT, NULL);
+            }
+
+            *Kv = std::sqrt(M_PI / (2 * x)) * std::exp(-x) / S;
+            *Kv1 = *Kv * (0.5 + v + x + (v * v - 0.25) * f) / x;
+
+            return 0;
+        }
+
+        /* Flags for what to compute */
+        enum { ikv_temme_need_i = 0x1, ikv_temme_need_k = 0x2 };
+
+        /*
+         * Compute I(v, x) and K(v, x) simultaneously by Temme's method, see
+         * Temme, Journal of Computational Physics, vol 19, 324 (1975)
+         */
+        XSF_HOST_DEVICE inline void ikv_temme(double v, double x, double *Iv_p, double *Kv_p) {
+            /* Kv1 = K_(v+1), fv = I_(v+1) / I_v */
+            /* Ku1 = K_(u+1), fu = I_(u+1) / I_u */
+            double u, Iv, Kv, Kv1, Ku, Ku1, fv;
+            double W, current, prev, next;
+            int reflect = 0;
+            unsigned n, k;
+            int kind;
+
+            kind = 0;
+            if (Iv_p != NULL) {
+                kind |= ikv_temme_need_i;
+            }
+            if (Kv_p != NULL) {
+                kind |= ikv_temme_need_k;
+            }
+
+            if (v < 0) {
+                reflect = 1;
+                v = -v; /* v is non-negative from here */
+                kind |= ikv_temme_need_k;
+            }
+            n = std::round(v);
+            u = v - n; /* -1/2 <= u < 1/2 */
+
+            if (x < 0) {
+                if (Iv_p != NULL)
+                    *Iv_p = std::numeric_limits<double>::quiet_NaN();
+                if (Kv_p != NULL)
+                    *Kv_p = std::numeric_limits<double>::quiet_NaN();
+                set_error("ikv_temme", SF_ERROR_DOMAIN, NULL);
+                return;
+            }
+            if (x == 0) {
+                Iv = (v == 0) ? 1 : 0;
+                if (kind & ikv_temme_need_k) {
+                    set_error("ikv_temme", SF_ERROR_OVERFLOW, NULL);
+                    Kv = std::numeric_limits<double>::infinity();
+                } else {
+                    Kv = std::numeric_limits<double>::quiet_NaN(); /* any value will do */
+                }
+
+                if (reflect && (kind & ikv_temme_need_i)) {
+                    double z = (u + n % 2);
+
+                    Iv = xsf::cephes::sinpi(z) == 0 ? Iv : std::numeric_limits<double>::infinity();
+                    if (std::isinf(Iv)) {
+                        set_error("ikv_temme", SF_ERROR_OVERFLOW, NULL);
+                    }
+                }
+
+                if (Iv_p != NULL) {
+                    *Iv_p = Iv;
+                }
+                if (Kv_p != NULL) {
+                    *Kv_p = Kv;
+                }
+                return;
+            }
+            /* x is positive until reflection */
+            W = 1 / x;                            /* Wronskian */
+            if (x <= 2) {                         /* x in (0, 2] */
+                temme_ik_series(u, x, &Ku, &Ku1); /* Temme series */
+            } else {                              /* x in (2, \infty) */
+                CF2_ik(u, x, &Ku, &Ku1);          /* continued fraction CF2_ik */
+            }
+            prev = Ku;
+            current = Ku1;
+            for (k = 1; k <= n; k++) { /* forward recurrence for K */
+                next = 2 * (u + k) * current / x + prev;
+                prev = current;
+                current = next;
+            }
+            Kv = prev;
+            Kv1 = current;
+            if (kind & ikv_temme_need_i) {
+                double lim = (4 * v * v + 10) / (8 * x);
+
+                lim *= lim;
+                lim *= lim;
+                lim /= 24;
+                if ((lim < MACHEP * 10) && (x > 100)) {
+                    /*
+                     * x is huge compared to v, CF1 may be very slow
+                     * to converge so use asymptotic expansion for large
+                     * x case instead.  Note that the asymptotic expansion
+                     * isn't very accurate - so it's deliberately very hard
+                     * to get here - probably we're going to overflow:
+                     */
+                    Iv = iv_asymptotic(v, x);
+                } else {
+                    CF1_ik(v, x, &fv);        /* continued fraction CF1_ik */
+                    Iv = W / (Kv * fv + Kv1); /* Wronskian relation */
+                }
+            } else {
+                Iv = std::numeric_limits<double>::quiet_NaN(); /* any value will do */
+            }
+
+            if (reflect) {
+                double z = (u + n % 2);
+
+                if (Iv_p != NULL) {
+                    *Iv_p = Iv + (2 / M_PI) * xsf::cephes::sinpi(z) * Kv; /* reflection formula */
+                }
+                if (Kv_p != NULL) {
+                    *Kv_p = Kv;
+                }
+            } else {
+                if (Iv_p != NULL) {
+                    *Iv_p = Iv;
+                }
+                if (Kv_p != NULL) {
+                    *Kv_p = Kv;
+                }
+            }
+            return;
+        }
+
+    } // namespace detail
+
+    XSF_HOST_DEVICE inline double iv(double v, double x) {
+        int sign;
+        double t, ax, res;
+
+        if (std::isnan(v) || std::isnan(x)) {
+            return std::numeric_limits<double>::quiet_NaN();
+        }
+
+        /* If v is a negative integer, invoke symmetry */
+        t = std::floor(v);
+        if (v < 0.0) {
+            if (t == v) {
+                v = -v; /* symmetry */
+                t = -t;
+            }
+        }
+        /* If x is negative, require v to be an integer */
+        sign = 1;
+        if (x < 0.0) {
+            if (t != v) {
+                set_error("iv", SF_ERROR_DOMAIN, NULL);
+                return (std::numeric_limits<double>::quiet_NaN());
+            }
+            if (v != 2.0 * std::floor(v / 2.0)) {
+                sign = -1;
+            }
+        }
+
+        /* Avoid logarithm singularity */
+        if (x == 0.0) {
+            if (v == 0.0) {
+                return 1.0;
+            }
+            if (v < 0.0) {
+                set_error("iv", SF_ERROR_OVERFLOW, NULL);
+                return std::numeric_limits<double>::infinity();
+            } else
+                return 0.0;
+        }
+
+        ax = std::abs(x);
+        if (std::abs(v) > 50) {
+            /*
+             * Uniform asymptotic expansion for large orders.
+             *
+             * This appears to overflow slightly later than the Boost
+             * implementation of Temme's method.
+             */
+            detail::ikv_asymptotic_uniform(v, ax, &res, NULL);
+        } else {
+            /* Otherwise: Temme's method */
+            detail::ikv_temme(v, ax, &res, NULL);
+        }
+        res *= sign;
+        return res;
+    }
+
+} // namespace cephes
+} // namespace xsf

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/special/xsf/cephes/shichi.h

@@ -0,0 +1,248 @@
+/* Translated into C++ by SciPy developers in 2024.
+ * Original header with Copyright information appears below.
+ */
+
+/*                                                     shichi.c
+ *
+ *     Hyperbolic sine and cosine integrals
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, Chi, Shi, shichi();
+ *
+ * shichi( x, &Chi, &Shi );
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Approximates the integrals
+ *
+ *                            x
+ *                            -
+ *                           | |   cosh t - 1
+ *   Chi(x) = eul + ln x +   |    -----------  dt,
+ *                         | |          t
+ *                          -
+ *                          0
+ *
+ *               x
+ *               -
+ *              | |  sinh t
+ *   Shi(x) =   |    ------  dt
+ *            | |       t
+ *             -
+ *             0
+ *
+ * where eul = 0.57721566490153286061 is Euler's constant.
+ * The integrals are evaluated by power series for x < 8
+ * and by Chebyshev expansions for x between 8 and 88.
+ * For large x, both functions approach exp(x)/2x.
+ * Arguments greater than 88 in magnitude return INFINITY.
+ *
+ *
+ * ACCURACY:
+ *
+ * Test interval 0 to 88.
+ *                      Relative error:
+ * arithmetic   function  # trials      peak         rms
+ *    IEEE         Shi      30000       6.9e-16     1.6e-16
+ *        Absolute error, except relative when |Chi| > 1:
+ *    IEEE         Chi      30000       8.4e-16     1.4e-16
+ */
+
+/*
+ * Cephes Math Library Release 2.0:  April, 1987
+ * Copyright 1984, 1987 by Stephen L. Moshier
+ * Direct inquiries to 30 Frost Street, Cambridge, MA 02140
+ */
+#pragma once
+
+#include "../config.h"
+
+#include "chbevl.h"
+#include "const.h"
+
+namespace xsf {
+namespace cephes {
+
+    namespace detail {
+
+        /* x exp(-x) shi(x), inverted interval 8 to 18 */
+        constexpr double shichi_S1[] = {
+            1.83889230173399459482E-17,  -9.55485532279655569575E-17, 2.04326105980879882648E-16,
+            1.09896949074905343022E-15,  -1.31313534344092599234E-14, 5.93976226264314278932E-14,
+            -3.47197010497749154755E-14, -1.40059764613117131000E-12, 9.49044626224223543299E-12,
+            -1.61596181145435454033E-11, -1.77899784436430310321E-10, 1.35455469767246947469E-9,
+            -1.03257121792819495123E-9,  -3.56699611114982536845E-8,  1.44818877384267342057E-7,
+            7.82018215184051295296E-7,   -5.39919118403805073710E-6,  -3.12458202168959833422E-5,
+            8.90136741950727517826E-5,   2.02558474743846862168E-3,   2.96064440855633256972E-2,
+            1.11847751047257036625E0};
+
+        /* x exp(-x) shi(x), inverted interval 18 to 88 */
+        constexpr double shichi_S2[] = {
+            -1.05311574154850938805E-17, 2.62446095596355225821E-17,  8.82090135625368160657E-17,
+            -3.38459811878103047136E-16, -8.30608026366935789136E-16, 3.93397875437050071776E-15,
+            1.01765565969729044505E-14,  -4.21128170307640802703E-14, -1.60818204519802480035E-13,
+            3.34714954175994481761E-13,  2.72600352129153073807E-12,  1.66894954752839083608E-12,
+            -3.49278141024730899554E-11, -1.58580661666482709598E-10, -1.79289437183355633342E-10,
+            1.76281629144264523277E-9,   1.69050228879421288846E-8,   1.25391771228487041649E-7,
+            1.16229947068677338732E-6,   1.61038260117376323993E-5,   3.49810375601053973070E-4,
+            1.28478065259647610779E-2,   1.03665722588798326712E0};
+
+        /* x exp(-x) chin(x), inverted interval 8 to 18 */
+        constexpr double shichi_C1[] = {
+            -8.12435385225864036372E-18, 2.17586413290339214377E-17, 5.22624394924072204667E-17,
+            -9.48812110591690559363E-16, 5.35546311647465209166E-15, -1.21009970113732918701E-14,
+            -6.00865178553447437951E-14, 7.16339649156028587775E-13, -2.93496072607599856104E-12,
+            -1.40359438136491256904E-12, 8.76302288609054966081E-11, -4.40092476213282340617E-10,
+            -1.87992075640569295479E-10, 1.31458150989474594064E-8,  -4.75513930924765465590E-8,
+            -2.21775018801848880741E-7,  1.94635531373272490962E-6,  4.33505889257316408893E-6,
+            -6.13387001076494349496E-5,  -3.13085477492997465138E-4, 4.97164789823116062801E-4,
+            2.64347496031374526641E-2,   1.11446150876699213025E0};
+
+        /* x exp(-x) chin(x), inverted interval 18 to 88 */
+        constexpr double shichi_C2[] = {
+            8.06913408255155572081E-18,  -2.08074168180148170312E-17, -5.98111329658272336816E-17,
+            2.68533951085945765591E-16,  4.52313941698904694774E-16,  -3.10734917335299464535E-15,
+            -4.42823207332531972288E-15, 3.49639695410806959872E-14,  6.63406731718911586609E-14,
+            -3.71902448093119218395E-13, -1.27135418132338309016E-12, 2.74851141935315395333E-12,
+            2.33781843985453438400E-11,  2.71436006377612442764E-11,  -2.56600180000355990529E-10,
+            -1.61021375163803438552E-9,  -4.72543064876271773512E-9,  -3.00095178028681682282E-9,
+            7.79387474390914922337E-8,   1.06942765566401507066E-6,   1.59503164802313196374E-5,
+            3.49592575153777996871E-4,   1.28475387530065247392E-2,   1.03665693917934275131E0};
+
+        /*
+         * Evaluate 3F0(a1, a2, a3; z)
+         *
+         * The series is only asymptotic, so this requires z large enough.
+         */
+        XSF_HOST_DEVICE inline double hyp3f0(double a1, double a2, double a3, double z) {
+            int n, maxiter;
+            double err, sum, term, m;
+
+            m = std::pow(z, -1.0 / 3);
+            if (m < 50) {
+                maxiter = m;
+            } else {
+                maxiter = 50;
+            }
+
+            term = 1.0;
+            sum = term;
+            for (n = 0; n < maxiter; ++n) {
+                term *= (a1 + n) * (a2 + n) * (a3 + n) * z / (n + 1);
+                sum += term;
+                if (std::abs(term) < 1e-13 * std::abs(sum) || term == 0) {
+                    break;
+                }
+            }
+
+            err = std::abs(term);
+
+            if (err > 1e-13 * std::abs(sum)) {
+                return std::numeric_limits<double>::quiet_NaN();
+            }
+
+            return sum;
+        }
+
+    } // namespace detail
+
+    /* Sine and cosine integrals */
+    XSF_HOST_DEVICE inline int shichi(double x, double *si, double *ci) {
+        double k, z, c, s, a, b;
+        short sign;
+
+        if (x < 0.0) {
+            sign = -1;
+            x = -x;
+        } else {
+            sign = 0;
+        }
+
+        if (x == 0.0) {
+            *si = 0.0;
+            *ci = -std::numeric_limits<double>::infinity();
+            return (0);
+        }
+
+        if (x >= 8.0) {
+            goto chb;
+        }
+
+        if (x >= 88.0) {
+            goto asymp;
+        }
+
+        z = x * x;
+
+        /*     Direct power series expansion   */
+        a = 1.0;
+        s = 1.0;
+        c = 0.0;
+        k = 2.0;
+
+        do {
+            a *= z / k;
+            c += a / k;
+            k += 1.0;
+            a /= k;
+            s += a / k;
+            k += 1.0;
+        } while (std::abs(a / s) > detail::MACHEP);
+
+        s *= x;
+        goto done;
+
+    chb:
+        /* Chebyshev series expansions */
+        if (x < 18.0) {
+            a = (576.0 / x - 52.0) / 10.0;
+            k = std::exp(x) / x;
+            s = k * chbevl(a, detail::shichi_S1, 22);
+            c = k * chbevl(a, detail::shichi_C1, 23);
+            goto done;
+        }
+
+        if (x <= 88.0) {
+            a = (6336.0 / x - 212.0) / 70.0;
+            k = std::exp(x) / x;
+            s = k * chbevl(a, detail::shichi_S2, 23);
+            c = k * chbevl(a, detail::shichi_C2, 24);
+            goto done;
+        }
+
+    asymp:
+        if (x > 1000) {
+            *si = std::numeric_limits<double>::infinity();
+            *ci = std::numeric_limits<double>::infinity();
+        } else {
+            /* Asymptotic expansions
+             * http://functions.wolfram.com/GammaBetaErf/CoshIntegral/06/02/
+             * http://functions.wolfram.com/GammaBetaErf/SinhIntegral/06/02/0001/
+             */
+            a = detail::hyp3f0(0.5, 1, 1, 4.0 / (x * x));
+            b = detail::hyp3f0(1, 1, 1.5, 4.0 / (x * x));
+            *si = std::cosh(x) / x * a + std::sinh(x) / (x * x) * b;
+            *ci = std::sinh(x) / x * a + std::cosh(x) / (x * x) * b;
+        }
+        if (sign) {
+            *si = -*si;
+        }
+        return 0;
+
+    done:
+        if (sign) {
+            s = -s;
+        }
+
+        *si = s;
+
+        *ci = detail::SCIPY_EULER + std::log(x) + c;
+        return (0);
+    }
+
+} // namespace cephes
+} // namespace xsf

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/special/xsf/cephes/sici.h

@@ -0,0 +1,224 @@
+/* Translated into C++ by SciPy developers in 2024.
+ * Original header with Copyright information appears below.
+ */
+
+/*                                                     sici.c
+ *
+ *     Sine and cosine integrals
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, Ci, Si, sici();
+ *
+ * sici( x, &Si, &Ci );
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Evaluates the integrals
+ *
+ *                          x
+ *                          -
+ *                         |  cos t - 1
+ *   Ci(x) = eul + ln x +  |  --------- dt,
+ *                         |      t
+ *                        -
+ *                         0
+ *             x
+ *             -
+ *            |  sin t
+ *   Si(x) =  |  ----- dt
+ *            |    t
+ *           -
+ *            0
+ *
+ * where eul = 0.57721566490153286061 is Euler's constant.
+ * The integrals are approximated by rational functions.
+ * For x > 8 auxiliary functions f(x) and g(x) are employed
+ * such that
+ *
+ * Ci(x) = f(x) sin(x) - g(x) cos(x)
+ * Si(x) = pi/2 - f(x) cos(x) - g(x) sin(x)
+ *
+ *
+ * ACCURACY:
+ *    Test interval = [0,50].
+ * Absolute error, except relative when > 1:
+ * arithmetic   function   # trials      peak         rms
+ *    IEEE        Si        30000       4.4e-16     7.3e-17
+ *    IEEE        Ci        30000       6.9e-16     5.1e-17
+ */
+
+/*
+ * Cephes Math Library Release 2.1:  January, 1989
+ * Copyright 1984, 1987, 1989 by Stephen L. Moshier
+ * Direct inquiries to 30 Frost Street, Cambridge, MA 02140
+ */
+#pragma once
+
+#include "../config.h"
+
+#include "const.h"
+#include "polevl.h"
+
+namespace xsf {
+namespace cephes {
+
+    namespace detail {
+
+        constexpr double sici_SN[] = {
+            -8.39167827910303881427E-11, 4.62591714427012837309E-8,  -9.75759303843632795789E-6,
+            9.76945438170435310816E-4,   -4.13470316229406538752E-2, 1.00000000000000000302E0,
+        };
+
+        constexpr double sici_SD[] = {
+            2.03269266195951942049E-12, 1.27997891179943299903E-9, 4.41827842801218905784E-7,
+            9.96412122043875552487E-5,  1.42085239326149893930E-2, 9.99999999999999996984E-1,
+        };
+
+        constexpr double sici_CN[] = {
+            2.02524002389102268789E-11, -1.35249504915790756375E-8, 3.59325051419993077021E-6,
+            -4.74007206873407909465E-4, 2.89159652607555242092E-2,  -1.00000000000000000080E0,
+        };
+
+        constexpr double sici_CD[] = {
+            4.07746040061880559506E-12, 3.06780997581887812692E-9, 1.23210355685883423679E-6,
+            3.17442024775032769882E-4,  5.10028056236446052392E-2, 4.00000000000000000080E0,
+        };
+
+        constexpr double sici_FN4[] = {
+            4.23612862892216586994E0,  5.45937717161812843388E0,  1.62083287701538329132E0,  1.67006611831323023771E-1,
+            6.81020132472518137426E-3, 1.08936580650328664411E-4, 5.48900223421373614008E-7,
+        };
+
+        constexpr double sici_FD4[] = {
+            /*  1.00000000000000000000E0, */
+            8.16496634205391016773E0,  7.30828822505564552187E0,  1.86792257950184183883E0,  1.78792052963149907262E-1,
+            7.01710668322789753610E-3, 1.10034357153915731354E-4, 5.48900252756255700982E-7,
+        };
+
+        constexpr double sici_FN8[] = {
+            4.55880873470465315206E-1, 7.13715274100146711374E-1,  1.60300158222319456320E-1,
+            1.16064229408124407915E-2, 3.49556442447859055605E-4,  4.86215430826454749482E-6,
+            3.20092790091004902806E-8, 9.41779576128512936592E-11, 9.70507110881952024631E-14,
+        };
+
+        constexpr double sici_FD8[] = {
+            /*  1.00000000000000000000E0, */
+            9.17463611873684053703E-1,  1.78685545332074536321E-1,  1.22253594771971293032E-2,
+            3.58696481881851580297E-4,  4.92435064317881464393E-6,  3.21956939101046018377E-8,
+            9.43720590350276732376E-11, 9.70507110881952025725E-14,
+        };
+
+        constexpr double sici_GN4[] = {
+            8.71001698973114191777E-2, 6.11379109952219284151E-1, 3.97180296392337498885E-1, 7.48527737628469092119E-2,
+            5.38868681462177273157E-3, 1.61999794598934024525E-4, 1.97963874140963632189E-6, 7.82579040744090311069E-9,
+        };
+
+        constexpr double sici_GD4[] = {
+            /*  1.00000000000000000000E0, */
+            1.64402202413355338886E0,  6.66296701268987968381E-1, 9.88771761277688796203E-2, 6.22396345441768420760E-3,
+            1.73221081474177119497E-4, 2.02659182086343991969E-6, 7.82579218933534490868E-9,
+        };
+
+        constexpr double sici_GN8[] = {
+            6.97359953443276214934E-1, 3.30410979305632063225E-1,  3.84878767649974295920E-2,
+            1.71718239052347903558E-3, 3.48941165502279436777E-5,  3.47131167084116673800E-7,
+            1.70404452782044526189E-9, 3.85945925430276600453E-12, 3.14040098946363334640E-15,
+        };
+
+        constexpr double sici_GD8[] = {
+            /*  1.00000000000000000000E0, */
+            1.68548898811011640017E0,  4.87852258695304967486E-1,  4.67913194259625806320E-2,
+            1.90284426674399523638E-3, 3.68475504442561108162E-5,  3.57043223443740838771E-7,
+            1.72693748966316146736E-9, 3.87830166023954706752E-12, 3.14040098946363335242E-15,
+        };
+
+    } // namespace detail
+
+    XSF_HOST_DEVICE inline int sici(double x, double *si, double *ci) {
+        double z, c, s, f, g;
+        short sign;
+
+        if (x < 0.0) {
+            sign = -1;
+            x = -x;
+        } else {
+            sign = 0;
+        }
+
+        if (x == 0.0) {
+            *si = 0.0;
+            *ci = -std::numeric_limits<double>::infinity();
+            return (0);
+        }
+
+        if (x > 1.0e9) {
+            if (std::isinf(x)) {
+                if (sign == -1) {
+                    *si = -M_PI_2;
+                    *ci = std::numeric_limits<double>::quiet_NaN();
+                } else {
+                    *si = M_PI_2;
+                    *ci = 0;
+                }
+                return 0;
+            }
+            *si = M_PI_2 - std::cos(x) / x;
+            *ci = std::sin(x) / x;
+        }
+
+        if (x > 4.0) {
+            goto asympt;
+        }
+
+        z = x * x;
+        s = x * polevl(z, detail::sici_SN, 5) / polevl(z, detail::sici_SD, 5);
+        c = z * polevl(z, detail::sici_CN, 5) / polevl(z, detail::sici_CD, 5);
+
+        if (sign) {
+            s = -s;
+        }
+        *si = s;
+        *ci = detail::SCIPY_EULER + std::log(x) + c; /* real part if x < 0 */
+        return (0);
+
+        /* The auxiliary functions are:
+         *
+         *
+         * *si = *si - M_PI_2;
+         * c = cos(x);
+         * s = sin(x);
+         *
+         * t = *ci * s - *si * c;
+         * a = *ci * c + *si * s;
+         *
+         * *si = t;
+         * *ci = -a;
+         */
+
+    asympt:
+
+        s = std::sin(x);
+        c = std::cos(x);
+        z = 1.0 / (x * x);
+        if (x < 8.0) {
+            f = polevl(z, detail::sici_FN4, 6) / (x * p1evl(z, detail::sici_FD4, 7));
+            g = z * polevl(z, detail::sici_GN4, 7) / p1evl(z, detail::sici_GD4, 7);
+        } else {
+            f = polevl(z, detail::sici_FN8, 8) / (x * p1evl(z, detail::sici_FD8, 8));
+            g = z * polevl(z, detail::sici_GN8, 8) / p1evl(z, detail::sici_GD8, 9);
+        }
+        *si = M_PI_2 - f * c - g * s;
+        if (sign) {
+            *si = -(*si);
+        }
+        *ci = f * s - g * c;
+
+        return (0);
+    }
+
+} // namespace cephes
+} // namespace xsf

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/special/xsf/cephes/sindg.h

@@ -0,0 +1,221 @@
+/* Translated into C++ by SciPy developers in 2024.
+ * Original header with Copyright information appears below.
+ */
+
+/*                                                     sindg.c
+ *
+ *     Circular sine of angle in degrees
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, y, sindg();
+ *
+ * y = sindg( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Range reduction is into intervals of 45 degrees.
+ *
+ * Two polynomial approximating functions are employed.
+ * Between 0 and pi/4 the sine is approximated by
+ *      x  +  x**3 P(x**2).
+ * Between pi/4 and pi/2 the cosine is represented as
+ *      1  -  x**2 P(x**2).
+ *
+ *
+ *
+ * ACCURACY:
+ *
+ *                      Relative error:
+ * arithmetic   domain      # trials      peak         rms
+ *    IEEE      +-1000       30000      2.3e-16      5.6e-17
+ *
+ * ERROR MESSAGES:
+ *
+ *   message           condition        value returned
+ * sindg total loss   x > 1.0e14 (IEEE)     0.0
+ *
+ */
+/*							cosdg.c
+ *
+ *	Circular cosine of angle in degrees
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, y, cosdg();
+ *
+ * y = cosdg( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Range reduction is into intervals of 45 degrees.
+ *
+ * Two polynomial approximating functions are employed.
+ * Between 0 and pi/4 the cosine is approximated by
+ *      1  -  x**2 P(x**2).
+ * Between pi/4 and pi/2 the sine is represented as
+ *      x  +  x**3 P(x**2).
+ *
+ *
+ * ACCURACY:
+ *
+ *                      Relative error:
+ * arithmetic   domain      # trials      peak         rms
+ *    IEEE     +-1000        30000       2.1e-16     5.7e-17
+ *  See also sin().
+ *
+ */
+
+/* Cephes Math Library Release 2.0:  April, 1987
+ * Copyright 1985, 1987 by Stephen L. Moshier
+ * Direct inquiries to 30 Frost Street, Cambridge, MA 02140 */
+#pragma once
+
+#include "../config.h"
+#include "../error.h"
+
+#include "const.h"
+#include "polevl.h"
+
+namespace xsf {
+namespace cephes {
+
+    namespace detail {
+
+        constexpr double sincof[] = {1.58962301572218447952E-10, -2.50507477628503540135E-8,
+                                     2.75573136213856773549E-6,  -1.98412698295895384658E-4,
+                                     8.33333333332211858862E-3,  -1.66666666666666307295E-1};
+
+        constexpr double coscof[] = {1.13678171382044553091E-11, -2.08758833757683644217E-9, 2.75573155429816611547E-7,
+                                     -2.48015872936186303776E-5, 1.38888888888806666760E-3,  -4.16666666666666348141E-2,
+                                     4.99999999999999999798E-1};
+
+        constexpr double sindg_lossth = 1.0e14;
+
+    } // namespace detail
+
+    XSF_HOST_DEVICE inline double sindg(double x) {
+        double y, z, zz;
+        int j, sign;
+
+        /* make argument positive but save the sign */
+        sign = 1;
+        if (x < 0) {
+            x = -x;
+            sign = -1;
+        }
+
+        if (x > detail::sindg_lossth) {
+            set_error("sindg", SF_ERROR_NO_RESULT, NULL);
+            return (0.0);
+        }
+
+        y = std::floor(x / 45.0); /* integer part of x/M_PI_4 */
+
+        /* strip high bits of integer part to prevent integer overflow */
+        z = std::ldexp(y, -4);
+        z = std::floor(z);        /* integer part of y/8 */
+        z = y - std::ldexp(z, 4); /* y - 16 * (y/16) */
+
+        j = z; /* convert to integer for tests on the phase angle */
+        /* map zeros to origin */
+        if (j & 1) {
+            j += 1;
+            y += 1.0;
+        }
+        j = j & 07; /* octant modulo 360 degrees */
+        /* reflect in x axis */
+        if (j > 3) {
+            sign = -sign;
+            j -= 4;
+        }
+
+        z = x - y * 45.0;   /* x mod 45 degrees */
+        z *= detail::PI180; /* multiply by pi/180 to convert to radians */
+        zz = z * z;
+
+        if ((j == 1) || (j == 2)) {
+            y = 1.0 - zz * polevl(zz, detail::coscof, 6);
+        } else {
+            y = z + z * (zz * polevl(zz, detail::sincof, 5));
+        }
+
+        if (sign < 0)
+            y = -y;
+
+        return (y);
+    }
+
+    XSF_HOST_DEVICE inline double cosdg(double x) {
+        double y, z, zz;
+        int j, sign;
+
+        /* make argument positive */
+        sign = 1;
+        if (x < 0)
+            x = -x;
+
+        if (x > detail::sindg_lossth) {
+            set_error("cosdg", SF_ERROR_NO_RESULT, NULL);
+            return (0.0);
+        }
+
+        y = std::floor(x / 45.0);
+        z = std::ldexp(y, -4);
+        z = std::floor(z);        /* integer part of y/8 */
+        z = y - std::ldexp(z, 4); /* y - 16 * (y/16) */
+
+        /* integer and fractional part modulo one octant */
+        j = z;
+        if (j & 1) { /* map zeros to origin */
+            j += 1;
+            y += 1.0;
+        }
+        j = j & 07;
+        if (j > 3) {
+            j -= 4;
+            sign = -sign;
+        }
+
+        if (j > 1)
+            sign = -sign;
+
+        z = x - y * 45.0;   /* x mod 45 degrees */
+        z *= detail::PI180; /* multiply by pi/180 to convert to radians */
+
+        zz = z * z;
+
+        if ((j == 1) || (j == 2)) {
+            y = z + z * (zz * polevl(zz, detail::sincof, 5));
+        } else {
+            y = 1.0 - zz * polevl(zz, detail::coscof, 6);
+        }
+
+        if (sign < 0)
+            y = -y;
+
+        return (y);
+    }
+
+    /* Degrees, minutes, seconds to radians: */
+
+    /* 1 arc second, in radians = 4.848136811095359935899141023579479759563533023727e-6 */
+
+    namespace detail {
+        constexpr double sindg_P64800 = 4.848136811095359935899141023579479759563533023727e-6;
+    }
+
+    XSF_HOST_DEVICE inline double radian(double d, double m, double s) {
+        return (((d * 60.0 + m) * 60.0 + s) * detail::sindg_P64800);
+    }
+
+} // namespace cephes
+} // namespace xsf

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/special/xsf/cephes/tandg.h

@@ -0,0 +1,139 @@
+/* Translated into C++ by SciPy developers in 2024.
+ * Original header with Copyright information appears below.
+ */
+
+/*                                                     tandg.c
+ *
+ *     Circular tangent of argument in degrees
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, y, tandg();
+ *
+ * y = tandg( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns the circular tangent of the argument x in degrees.
+ *
+ * Range reduction is modulo pi/4.  A rational function
+ *       x + x**3 P(x**2)/Q(x**2)
+ * is employed in the basic interval [0, pi/4].
+ *
+ *
+ *
+ * ACCURACY:
+ *
+ *                      Relative error:
+ * arithmetic   domain     # trials      peak         rms
+ *    IEEE     0,10         30000      3.2e-16      8.4e-17
+ *
+ * ERROR MESSAGES:
+ *
+ *   message         condition          value returned
+ * tandg total loss   x > 1.0e14 (IEEE)     0.0
+ * tandg singularity  x = 180 k  +  90     INFINITY
+ */
+/*							cotdg.c
+ *
+ *	Circular cotangent of argument in degrees
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, y, cotdg();
+ *
+ * y = cotdg( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns the circular cotangent of the argument x in degrees.
+ *
+ * Range reduction is modulo pi/4.  A rational function
+ *       x + x**3 P(x**2)/Q(x**2)
+ * is employed in the basic interval [0, pi/4].
+ *
+ *
+ * ERROR MESSAGES:
+ *
+ *   message         condition          value returned
+ * cotdg total loss   x > 1.0e14 (IEEE)     0.0
+ * cotdg singularity  x = 180 k            INFINITY
+ */
+
+/*
+ * Cephes Math Library Release 2.0:  April, 1987
+ * Copyright 1984, 1987 by Stephen L. Moshier
+ * Direct inquiries to 30 Frost Street, Cambridge, MA 02140
+ */
+#pragma once
+
+#include "../config.h"
+#include "../error.h"
+
+namespace xsf {
+namespace cephes {
+
+    namespace detail {
+        constexpr double tandg_lossth = 1.0e14;
+
+        XSF_HOST_DEVICE inline double tancot(double xx, int cotflg) {
+            double x;
+            int sign;
+
+            /* make argument positive but save the sign */
+            if (xx < 0) {
+                x = -xx;
+                sign = -1;
+            } else {
+                x = xx;
+                sign = 1;
+            }
+
+            if (x > detail::tandg_lossth) {
+                set_error("tandg", SF_ERROR_NO_RESULT, NULL);
+                return 0.0;
+            }
+
+            /* modulo 180 */
+            x = x - 180.0 * std::floor(x / 180.0);
+            if (cotflg) {
+                if (x <= 90.0) {
+                    x = 90.0 - x;
+                } else {
+                    x = x - 90.0;
+                    sign *= -1;
+                }
+            } else {
+                if (x > 90.0) {
+                    x = 180.0 - x;
+                    sign *= -1;
+                }
+            }
+            if (x == 0.0) {
+                return 0.0;
+            } else if (x == 45.0) {
+                return sign * 1.0;
+            } else if (x == 90.0) {
+                set_error((cotflg ? "cotdg" : "tandg"), SF_ERROR_SINGULAR, NULL);
+                return std::numeric_limits<double>::infinity();
+            }
+            /* x is now transformed into [0, 90) */
+            return sign * std::tan(x * detail::PI180);
+        }
+
+    } // namespace detail
+
+    XSF_HOST_DEVICE inline double tandg(double x) { return (detail::tancot(x, 0)); }
+
+    XSF_HOST_DEVICE inline double cotdg(double x) { return (detail::tancot(x, 1)); }
+
+} // namespace cephes
+} // namespace xsf

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/special/xsf/cephes/trig.h

@@ -0,0 +1,58 @@
+/* Translated into C++ by SciPy developers in 2024.
+ *
+ * Original author: Josh Wilson, 2020.
+ */
+
+/*
+ * Implement sin(pi * x) and cos(pi * x) for real x. Since the periods
+ * of these functions are integral (and thus representable in double
+ * precision), it's possible to compute them with greater accuracy
+ * than sin(x) and cos(x).
+ */
+#pragma once
+
+#include "../config.h"
+
+namespace xsf {
+namespace cephes {
+
+    /* Compute sin(pi * x). */
+    template <typename T>
+    XSF_HOST_DEVICE T sinpi(T x) {
+        T s = 1.0;
+
+        if (x < 0.0) {
+            x = -x;
+            s = -1.0;
+        }
+
+        T r = std::fmod(x, 2.0);
+        if (r < 0.5) {
+            return s * std::sin(M_PI * r);
+        } else if (r > 1.5) {
+            return s * std::sin(M_PI * (r - 2.0));
+        } else {
+            return -s * std::sin(M_PI * (r - 1.0));
+        }
+    }
+
+    /* Compute cos(pi * x) */
+    template <typename T>
+    XSF_HOST_DEVICE T cospi(T x) {
+        if (x < 0.0) {
+            x = -x;
+        }
+
+        T r = std::fmod(x, 2.0);
+        if (r == 0.5) {
+            // We don't want to return -0.0
+            return 0.0;
+        }
+        if (r < 1.0) {
+            return -std::sin(M_PI * (r - 0.5));
+        } else {
+            return std::sin(M_PI * (r - 1.5));
+        }
+    }
+} // namespace cephes
+} // namespace xsf

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/special/xsf/cephes/unity.h

@@ -0,0 +1,186 @@
+/* Translated into C++ by SciPy developers in 2024. */
+
+/*                                                     unity.c
+ *
+ * Relative error approximations for function arguments near
+ * unity.
+ *
+ *    log1p(x) = log(1+x)
+ *    expm1(x) = exp(x) - 1
+ *    cosm1(x) = cos(x) - 1
+ *    lgam1p(x) = lgam(1+x)
+ *
+ */
+
+/* Scipy changes:
+ * - 06-10-2016: added lgam1p
+ */
+#pragma once
+
+#include "../config.h"
+
+#include "const.h"
+#include "gamma.h"
+#include "polevl.h"
+#include "zeta.h"
+
+namespace xsf {
+namespace cephes {
+
+    namespace detail {
+
+        /* log1p(x) = log(1 + x)  */
+
+        /* Coefficients for log(1+x) = x - x**2/2 + x**3 P(x)/Q(x)
+         * 1/sqrt(2) <= x < sqrt(2)
+         * Theoretical peak relative error = 2.32e-20
+         */
+
+        constexpr double unity_LP[] = {
+            4.5270000862445199635215E-5, 4.9854102823193375972212E-1, 6.5787325942061044846969E0,
+            2.9911919328553073277375E1,  6.0949667980987787057556E1,  5.7112963590585538103336E1,
+            2.0039553499201281259648E1,
+        };
+
+        constexpr double unity_LQ[] = {
+            /* 1.0000000000000000000000E0, */
+            1.5062909083469192043167E1, 8.3047565967967209469434E1, 2.2176239823732856465394E2,
+            3.0909872225312059774938E2, 2.1642788614495947685003E2, 6.0118660497603843919306E1,
+        };
+
+    } // namespace detail
+
+    XSF_HOST_DEVICE inline double log1p(double x) {
+        double z;
+
+        z = 1.0 + x;
+        if ((z < M_SQRT1_2) || (z > M_SQRT2))
+            return (std::log(z));
+        z = x * x;
+        z = -0.5 * z + x * (z * polevl(x, detail::unity_LP, 6) / p1evl(x, detail::unity_LQ, 6));
+        return (x + z);
+    }
+
+    /* log(1 + x) - x */
+    XSF_HOST_DEVICE inline double log1pmx(double x) {
+        if (std::abs(x) < 0.5) {
+            uint64_t n;
+            double xfac = x;
+            double term;
+            double res = 0;
+
+            for (n = 2; n < detail::MAXITER; n++) {
+                xfac *= -x;
+                term = xfac / n;
+                res += term;
+                if (std::abs(term) < detail::MACHEP * std::abs(res)) {
+                    break;
+                }
+            }
+            return res;
+        } else {
+            return log1p(x) - x;
+        }
+    }
+
+    /* expm1(x) = exp(x) - 1  */
+
+    /*  e^x =  1 + 2x P(x^2)/( Q(x^2) - P(x^2) )
+     * -0.5 <= x <= 0.5
+     */
+
+    namespace detail {
+
+        constexpr double unity_EP[3] = {
+            1.2617719307481059087798E-4,
+            3.0299440770744196129956E-2,
+            9.9999999999999999991025E-1,
+        };
+
+        constexpr double unity_EQ[4] = {
+            3.0019850513866445504159E-6,
+            2.5244834034968410419224E-3,
+            2.2726554820815502876593E-1,
+            2.0000000000000000000897E0,
+        };
+
+    } // namespace detail
+
+    XSF_HOST_DEVICE inline double expm1(double x) {
+        double r, xx;
+
+        if (!std::isfinite(x)) {
+            if (std::isnan(x)) {
+                return x;
+            } else if (x > 0) {
+                return x;
+            } else {
+                return -1.0;
+            }
+        }
+        if ((x < -0.5) || (x > 0.5))
+            return (std::exp(x) - 1.0);
+        xx = x * x;
+        r = x * polevl(xx, detail::unity_EP, 2);
+        r = r / (polevl(xx, detail::unity_EQ, 3) - r);
+        return (r + r);
+    }
+
+    /* cosm1(x) = cos(x) - 1  */
+
+    namespace detail {
+        constexpr double unity_coscof[7] = {
+            4.7377507964246204691685E-14, -1.1470284843425359765671E-11, 2.0876754287081521758361E-9,
+            -2.7557319214999787979814E-7, 2.4801587301570552304991E-5,   -1.3888888888888872993737E-3,
+            4.1666666666666666609054E-2,
+        };
+
+    }
+
+    XSF_HOST_DEVICE inline double cosm1(double x) {
+        double xx;
+
+        if ((x < -M_PI_4) || (x > M_PI_4))
+            return (std::cos(x) - 1.0);
+        xx = x * x;
+        xx = -0.5 * xx + xx * xx * polevl(xx, detail::unity_coscof, 6);
+        return xx;
+    }
+
+    namespace detail {
+        /* Compute lgam(x + 1) around x = 0 using its Taylor series. */
+        XSF_HOST_DEVICE inline double lgam1p_taylor(double x) {
+            int n;
+            double xfac, coeff, res;
+
+            if (x == 0) {
+                return 0;
+            }
+            res = -SCIPY_EULER * x;
+            xfac = -x;
+            for (n = 2; n < 42; n++) {
+                xfac *= -x;
+                coeff = xsf::cephes::zeta(n, 1) * xfac / n;
+                res += coeff;
+                if (std::abs(coeff) < detail::MACHEP * std::abs(res)) {
+                    break;
+                }
+            }
+
+            return res;
+        }
+    } // namespace detail
+
+    /* Compute lgam(x + 1). */
+    XSF_HOST_DEVICE inline double lgam1p(double x) {
+        if (std::abs(x) <= 0.5) {
+            return detail::lgam1p_taylor(x);
+        } else if (std::abs(x - 1) < 0.5) {
+            return std::log(x) + detail::lgam1p_taylor(x - 1);
+        } else {
+            return lgam(x + 1);
+        }
+    }
+
+} // namespace cephes
+} // namespace xsf

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/special/xsf/cephes/zeta.h

@@ -0,0 +1,172 @@
+/* Translated into C++ by SciPy developers in 2024.
+ * Original header with Copyright information appears below.
+ */
+
+/*                                                     zeta.c
+ *
+ *     Riemann zeta function of two arguments
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, q, y, zeta();
+ *
+ * y = zeta( x, q );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ *
+ *
+ *                 inf.
+ *                  -        -x
+ *   zeta(x,q)  =   >   (k+q)
+ *                  -
+ *                 k=0
+ *
+ * where x > 1 and q is not a negative integer or zero.
+ * The Euler-Maclaurin summation formula is used to obtain
+ * the expansion
+ *
+ *                n
+ *                -       -x
+ * zeta(x,q)  =   >  (k+q)
+ *                -
+ *               k=1
+ *
+ *           1-x                 inf.  B   x(x+1)...(x+2j)
+ *      (n+q)           1         -     2j
+ *  +  ---------  -  -------  +   >    --------------------
+ *        x-1              x      -                   x+2j+1
+ *                   2(n+q)      j=1       (2j)! (n+q)
+ *
+ * where the B2j are Bernoulli numbers.  Note that (see zetac.c)
+ * zeta(x,1) = zetac(x) + 1.
+ *
+ *
+ *
+ * ACCURACY:
+ *
+ *
+ *
+ * REFERENCE:
+ *
+ * Gradshteyn, I. S., and I. M. Ryzhik, Tables of Integrals,
+ * Series, and Products, p. 1073; Academic Press, 1980.
+ *
+ */
+
+/*
+ * Cephes Math Library Release 2.0:  April, 1987
+ * Copyright 1984, 1987 by Stephen L. Moshier
+ * Direct inquiries to 30 Frost Street, Cambridge, MA 02140
+ */
+#pragma once
+
+#include "../config.h"
+#include "../error.h"
+#include "const.h"
+
+namespace xsf {
+namespace cephes {
+
+    namespace detail {
+        /* Expansion coefficients
+         * for Euler-Maclaurin summation formula
+         * (2k)! / B2k
+         * where B2k are Bernoulli numbers
+         */
+        constexpr double zeta_A[] = {
+            12.0,
+            -720.0,
+            30240.0,
+            -1209600.0,
+            47900160.0,
+            -1.8924375803183791606e9, /*1.307674368e12/691 */
+            7.47242496e10,
+            -2.950130727918164224e12,  /*1.067062284288e16/3617 */
+            1.1646782814350067249e14,  /*5.109094217170944e18/43867 */
+            -4.5979787224074726105e15, /*8.028576626982912e20/174611 */
+            1.8152105401943546773e17,  /*1.5511210043330985984e23/854513 */
+            -7.1661652561756670113e18  /*1.6938241367317436694528e27/236364091 */
+        };
+
+        /* 30 Nov 86 -- error in third coefficient fixed */
+    } // namespace detail
+
+    XSF_HOST_DEVICE double inline zeta(double x, double q) {
+        int i;
+        double a, b, k, s, t, w;
+
+        if (x == 1.0)
+            goto retinf;
+
+        if (x < 1.0) {
+        domerr:
+            set_error("zeta", SF_ERROR_DOMAIN, NULL);
+            return (std::numeric_limits<double>::quiet_NaN());
+        }
+
+        if (q <= 0.0) {
+            if (q == floor(q)) {
+                set_error("zeta", SF_ERROR_SINGULAR, NULL);
+            retinf:
+                return (std::numeric_limits<double>::infinity());
+            }
+            if (x != std::floor(x))
+                goto domerr; /* because q^-x not defined */
+        }
+
+        /* Asymptotic expansion
+         * https://dlmf.nist.gov/25.11#E43
+         */
+        if (q > 1e8) {
+            return (1 / (x - 1) + 1 / (2 * q)) * std::pow(q, 1 - x);
+        }
+
+        /* Euler-Maclaurin summation formula */
+
+        /* Permit negative q but continue sum until n+q > +9 .
+         * This case should be handled by a reflection formula.
+         * If q<0 and x is an integer, there is a relation to
+         * the polyGamma function.
+         */
+        s = std::pow(q, -x);
+        a = q;
+        i = 0;
+        b = 0.0;
+        while ((i < 9) || (a <= 9.0)) {
+            i += 1;
+            a += 1.0;
+            b = std::pow(a, -x);
+            s += b;
+            if (std::abs(b / s) < detail::MACHEP)
+                goto done;
+        }
+
+        w = a;
+        s += b * w / (x - 1.0);
+        s -= 0.5 * b;
+        a = 1.0;
+        k = 0.0;
+        for (i = 0; i < 12; i++) {
+            a *= x + k;
+            b /= w;
+            t = a * b / detail::zeta_A[i];
+            s = s + t;
+            t = std::abs(t / s);
+            if (t < detail::MACHEP)
+                goto done;
+            k += 1.0;
+            a *= x + k;
+            b /= w;
+            k += 1.0;
+        }
+    done:
+        return (s);
+    }
+
+} // namespace cephes
+} // namespace xsf

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/stats/__init__.py

@@ -0,0 +1,667 @@
+"""
+.. _statsrefmanual:
+
+==========================================
+Statistical functions (:mod:`scipy.stats`)
+==========================================
+
+.. currentmodule:: scipy.stats
+
+This module contains a large number of probability distributions,
+summary and frequency statistics, correlation functions and statistical
+tests, masked statistics, kernel density estimation, quasi-Monte Carlo
+functionality, and more.
+
+Statistics is a very large area, and there are topics that are out of scope
+for SciPy and are covered by other packages. Some of the most important ones
+are:
+
+- `statsmodels <https://www.statsmodels.org/stable/index.html>`__:
+  regression, linear models, time series analysis, extensions to topics
+  also covered by ``scipy.stats``.
+- `Pandas <https://pandas.pydata.org/>`__: tabular data, time series
+  functionality, interfaces to other statistical languages.
+- `PyMC <https://docs.pymc.io/>`__: Bayesian statistical
+  modeling, probabilistic machine learning.
+- `scikit-learn <https://scikit-learn.org/>`__: classification, regression,
+  model selection.
+- `Seaborn <https://seaborn.pydata.org/>`__: statistical data visualization.
+- `rpy2 <https://rpy2.github.io/>`__: Python to R bridge.
+
+
+Probability distributions
+=========================
+
+Each univariate distribution is an instance of a subclass of `rv_continuous`
+(`rv_discrete` for discrete distributions):
+
+.. autosummary::
+   :toctree: generated/
+
+   rv_continuous
+   rv_discrete
+   rv_histogram
+
+Continuous distributions
+------------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   alpha             -- Alpha
+   anglit            -- Anglit
+   arcsine           -- Arcsine
+   argus             -- Argus
+   beta              -- Beta
+   betaprime         -- Beta Prime
+   bradford          -- Bradford
+   burr              -- Burr (Type III)
+   burr12            -- Burr (Type XII)
+   cauchy            -- Cauchy
+   chi               -- Chi
+   chi2              -- Chi-squared
+   cosine            -- Cosine
+   crystalball       -- Crystalball
+   dgamma            -- Double Gamma
+   dpareto_lognorm   -- Double Pareto Lognormal
+   dweibull          -- Double Weibull
+   erlang            -- Erlang
+   expon             -- Exponential
+   exponnorm         -- Exponentially Modified Normal
+   exponweib         -- Exponentiated Weibull
+   exponpow          -- Exponential Power
+   f                 -- F (Snecdor F)
+   fatiguelife       -- Fatigue Life (Birnbaum-Saunders)
+   fisk              -- Fisk
+   foldcauchy        -- Folded Cauchy
+   foldnorm          -- Folded Normal
+   genlogistic       -- Generalized Logistic
+   gennorm           -- Generalized normal
+   genpareto         -- Generalized Pareto
+   genexpon          -- Generalized Exponential
+   genextreme        -- Generalized Extreme Value
+   gausshyper        -- Gauss Hypergeometric
+   gamma             -- Gamma
+   gengamma          -- Generalized gamma
+   genhalflogistic   -- Generalized Half Logistic
+   genhyperbolic     -- Generalized Hyperbolic
+   geninvgauss       -- Generalized Inverse Gaussian
+   gibrat            -- Gibrat
+   gompertz          -- Gompertz (Truncated Gumbel)
+   gumbel_r          -- Right Sided Gumbel, Log-Weibull, Fisher-Tippett, Extreme Value Type I
+   gumbel_l          -- Left Sided Gumbel, etc.
+   halfcauchy        -- Half Cauchy
+   halflogistic      -- Half Logistic
+   halfnorm          -- Half Normal
+   halfgennorm       -- Generalized Half Normal
+   hypsecant         -- Hyperbolic Secant
+   invgamma          -- Inverse Gamma
+   invgauss          -- Inverse Gaussian
+   invweibull        -- Inverse Weibull
+   irwinhall         -- Irwin-Hall
+   jf_skew_t         -- Jones and Faddy Skew-T
+   johnsonsb         -- Johnson SB
+   johnsonsu         -- Johnson SU
+   kappa4            -- Kappa 4 parameter
+   kappa3            -- Kappa 3 parameter
+   ksone             -- Distribution of Kolmogorov-Smirnov one-sided test statistic
+   kstwo             -- Distribution of Kolmogorov-Smirnov two-sided test statistic
+   kstwobign         -- Limiting Distribution of scaled Kolmogorov-Smirnov two-sided test statistic.
+   landau            -- Landau
+   laplace           -- Laplace
+   laplace_asymmetric    -- Asymmetric Laplace
+   levy              -- Levy
+   levy_l
+   levy_stable
+   logistic          -- Logistic
+   loggamma          -- Log-Gamma
+   loglaplace        -- Log-Laplace (Log Double Exponential)
+   lognorm           -- Log-Normal
+   loguniform        -- Log-Uniform
+   lomax             -- Lomax (Pareto of the second kind)
+   maxwell           -- Maxwell
+   mielke            -- Mielke's Beta-Kappa
+   moyal             -- Moyal
+   nakagami          -- Nakagami
+   ncx2              -- Non-central chi-squared
+   ncf               -- Non-central F
+   nct               -- Non-central Student's T
+   norm              -- Normal (Gaussian)
+   norminvgauss      -- Normal Inverse Gaussian
+   pareto            -- Pareto
+   pearson3          -- Pearson type III
+   powerlaw          -- Power-function
+   powerlognorm      -- Power log normal
+   powernorm         -- Power normal
+   rdist             -- R-distribution
+   rayleigh          -- Rayleigh
+   rel_breitwigner   -- Relativistic Breit-Wigner
+   rice              -- Rice
+   recipinvgauss     -- Reciprocal Inverse Gaussian
+   semicircular      -- Semicircular
+   skewcauchy        -- Skew Cauchy
+   skewnorm          -- Skew normal
+   studentized_range    -- Studentized Range
+   t                 -- Student's T
+   trapezoid         -- Trapezoidal
+   triang            -- Triangular
+   truncexpon        -- Truncated Exponential
+   truncnorm         -- Truncated Normal
+   truncpareto       -- Truncated Pareto
+   truncweibull_min  -- Truncated minimum Weibull distribution
+   tukeylambda       -- Tukey-Lambda
+   uniform           -- Uniform
+   vonmises          -- Von-Mises (Circular)
+   vonmises_line     -- Von-Mises (Line)
+   wald              -- Wald
+   weibull_min       -- Minimum Weibull (see Frechet)
+   weibull_max       -- Maximum Weibull (see Frechet)
+   wrapcauchy        -- Wrapped Cauchy
+
+The ``fit`` method of the univariate continuous distributions uses
+maximum likelihood estimation to fit the distribution to a data set.
+The ``fit`` method can accept regular data or *censored data*.
+Censored data is represented with instances of the `CensoredData`
+class.
+
+.. autosummary::
+   :toctree: generated/
+
+   CensoredData
+
+
+Multivariate distributions
+--------------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   multivariate_normal    -- Multivariate normal distribution
+   matrix_normal          -- Matrix normal distribution
+   dirichlet              -- Dirichlet
+   dirichlet_multinomial  -- Dirichlet multinomial distribution
+   wishart                -- Wishart
+   invwishart             -- Inverse Wishart
+   multinomial            -- Multinomial distribution
+   special_ortho_group    -- SO(N) group
+   ortho_group            -- O(N) group
+   unitary_group          -- U(N) group
+   random_correlation     -- random correlation matrices
+   multivariate_t         -- Multivariate t-distribution
+   multivariate_hypergeom -- Multivariate hypergeometric distribution
+   normal_inverse_gamma   -- Normal-inverse-gamma distribution
+   random_table           -- Distribution of random tables with given marginals
+   uniform_direction      -- Uniform distribution on S(N-1)
+   vonmises_fisher        -- Von Mises-Fisher distribution
+
+`scipy.stats.multivariate_normal` methods accept instances
+of the following class to represent the covariance.
+
+.. autosummary::
+   :toctree: generated/
+
+   Covariance             -- Representation of a covariance matrix
+
+
+Discrete distributions
+----------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   bernoulli                -- Bernoulli
+   betabinom                -- Beta-Binomial
+   betanbinom               -- Beta-Negative Binomial
+   binom                    -- Binomial
+   boltzmann                -- Boltzmann (Truncated Discrete Exponential)
+   dlaplace                 -- Discrete Laplacian
+   geom                     -- Geometric
+   hypergeom                -- Hypergeometric
+   logser                   -- Logarithmic (Log-Series, Series)
+   nbinom                   -- Negative Binomial
+   nchypergeom_fisher       -- Fisher's Noncentral Hypergeometric
+   nchypergeom_wallenius    -- Wallenius's Noncentral Hypergeometric
+   nhypergeom               -- Negative Hypergeometric
+   planck                   -- Planck (Discrete Exponential)
+   poisson                  -- Poisson
+   poisson_binom            -- Poisson Binomial
+   randint                  -- Discrete Uniform
+   skellam                  -- Skellam
+   yulesimon                -- Yule-Simon
+   zipf                     -- Zipf (Zeta)
+   zipfian                  -- Zipfian
+
+
+An overview of statistical functions is given below.  Many of these functions
+have a similar version in `scipy.stats.mstats` which work for masked arrays.
+
+Summary statistics
+==================
+
+.. autosummary::
+   :toctree: generated/
+
+   describe          -- Descriptive statistics
+   gmean             -- Geometric mean
+   hmean             -- Harmonic mean
+   pmean             -- Power mean
+   kurtosis          -- Fisher or Pearson kurtosis
+   mode              -- Modal value
+   moment            -- Central moment
+   lmoment
+   expectile         -- Expectile
+   skew              -- Skewness
+   kstat             --
+   kstatvar          --
+   tmean             -- Truncated arithmetic mean
+   tvar              -- Truncated variance
+   tmin              --
+   tmax              --
+   tstd              --
+   tsem              --
+   variation         -- Coefficient of variation
+   find_repeats
+   rankdata
+   tiecorrect
+   trim_mean
+   gstd              -- Geometric Standard Deviation
+   iqr
+   sem
+   bayes_mvs
+   mvsdist
+   entropy
+   differential_entropy
+   median_abs_deviation
+
+Frequency statistics
+====================
+
+.. autosummary::
+   :toctree: generated/
+
+   cumfreq
+   percentileofscore
+   scoreatpercentile
+   relfreq
+
+.. autosummary::
+   :toctree: generated/
+
+   binned_statistic     -- Compute a binned statistic for a set of data.
+   binned_statistic_2d  -- Compute a 2-D binned statistic for a set of data.
+   binned_statistic_dd  -- Compute a d-D binned statistic for a set of data.
+
+.. _hypotests:
+
+Hypothesis Tests and related functions
+======================================
+SciPy has many functions for performing hypothesis tests that return a
+test statistic and a p-value, and several of them return confidence intervals
+and/or other related information.
+
+The headings below are based on common uses of the functions within, but due to
+the wide variety of statistical procedures, any attempt at coarse-grained
+categorization will be imperfect. Also, note that tests within the same heading
+are not interchangeable in general (e.g. many have different distributional
+assumptions).
+
+One Sample Tests / Paired Sample Tests
+--------------------------------------
+One sample tests are typically used to assess whether a single sample was
+drawn from a specified distribution or a distribution with specified properties
+(e.g. zero mean).
+
+.. autosummary::
+   :toctree: generated/
+
+   ttest_1samp
+   binomtest
+   quantile_test
+   skewtest
+   kurtosistest
+   normaltest
+   jarque_bera
+   shapiro
+   anderson
+   cramervonmises
+   ks_1samp
+   goodness_of_fit
+   chisquare
+   power_divergence
+
+Paired sample tests are often used to assess whether two samples were drawn
+from the same distribution; they differ from the independent sample tests below
+in that each observation in one sample is treated as paired with a
+closely-related observation in the other sample (e.g. when environmental
+factors are controlled between observations within a pair but not among pairs).
+They can also be interpreted or used as one-sample tests (e.g. tests on the
+mean or median of *differences* between paired observations).
+
+.. autosummary::
+   :toctree: generated/
+
+   ttest_rel
+   wilcoxon
+
+Association/Correlation Tests
+-----------------------------
+
+These tests are often used to assess whether there is a relationship (e.g.
+linear) between paired observations in multiple samples or among the
+coordinates of multivariate observations.
+
+.. autosummary::
+   :toctree: generated/
+
+   linregress
+   pearsonr
+   spearmanr
+   pointbiserialr
+   kendalltau
+   chatterjeexi
+   weightedtau
+   somersd
+   siegelslopes
+   theilslopes
+   page_trend_test
+   multiscale_graphcorr
+
+These association tests and are to work with samples in the form of contingency
+tables. Supporting functions are available in `scipy.stats.contingency`.
+
+.. autosummary::
+   :toctree: generated/
+
+   chi2_contingency
+   fisher_exact
+   barnard_exact
+   boschloo_exact
+
+Independent Sample Tests
+------------------------
+Independent sample tests are typically used to assess whether multiple samples
+were independently drawn from the same distribution or different distributions
+with a shared property (e.g. equal means).
+
+Some tests are specifically for comparing two samples.
+
+.. autosummary::
+   :toctree: generated/
+
+   ttest_ind_from_stats
+   poisson_means_test
+   ttest_ind
+   mannwhitneyu
+   bws_test
+   ranksums
+   brunnermunzel
+   mood
+   ansari
+   cramervonmises_2samp
+   epps_singleton_2samp
+   ks_2samp
+   kstest
+
+Others are generalized to multiple samples.
+
+.. autosummary::
+   :toctree: generated/
+
+   f_oneway
+   tukey_hsd
+   dunnett
+   kruskal
+   alexandergovern
+   fligner
+   levene
+   bartlett
+   median_test
+   friedmanchisquare
+   anderson_ksamp
+
+Resampling and Monte Carlo Methods
+----------------------------------
+The following functions can reproduce the p-value and confidence interval
+results of most of the functions above, and often produce accurate results in a
+wider variety of conditions. They can also be used to perform hypothesis tests
+and generate confidence intervals for custom statistics. This flexibility comes
+at the cost of greater computational requirements and stochastic results.
+
+.. autosummary::
+   :toctree: generated/
+
+   monte_carlo_test
+   permutation_test
+   bootstrap
+   power
+
+Instances of the following object can be passed into some hypothesis test
+functions to perform a resampling or Monte Carlo version of the hypothesis
+test.
+
+.. autosummary::
+   :toctree: generated/
+
+   MonteCarloMethod
+   PermutationMethod
+   BootstrapMethod
+
+Multiple Hypothesis Testing and Meta-Analysis
+---------------------------------------------
+These functions are for assessing the results of individual tests as a whole.
+Functions for performing specific multiple hypothesis tests (e.g. post hoc
+tests) are listed above.
+
+.. autosummary::
+   :toctree: generated/
+
+   combine_pvalues
+   false_discovery_control
+
+
+The following functions are related to the tests above but do not belong in the
+above categories.
+
+Random Variables
+================
+
+.. autosummary::
+   :toctree: generated/
+
+   make_distribution
+   Normal
+   Uniform
+   Mixture
+   order_statistic
+   truncate
+   abs
+   exp
+   log
+
+Quasi-Monte Carlo
+=================
+
+.. toctree::
+   :maxdepth: 4
+
+   stats.qmc
+
+Contingency Tables
+==================
+
+.. toctree::
+   :maxdepth: 4
+
+   stats.contingency
+
+Masked statistics functions
+===========================
+
+.. toctree::
+
+   stats.mstats
+
+
+Other statistical functionality
+===============================
+
+Transformations
+---------------
+
+.. autosummary::
+   :toctree: generated/
+
+   boxcox
+   boxcox_normmax
+   boxcox_llf
+   yeojohnson
+   yeojohnson_normmax
+   yeojohnson_llf
+   obrientransform
+   sigmaclip
+   trimboth
+   trim1
+   zmap
+   zscore
+   gzscore
+
+Statistical distances
+---------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   wasserstein_distance
+   wasserstein_distance_nd
+   energy_distance
+
+Sampling
+--------
+
+.. toctree::
+   :maxdepth: 4
+
+   stats.sampling
+
+Fitting / Survival Analysis
+---------------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   fit
+   ecdf
+   logrank
+
+Directional statistical functions
+---------------------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   directional_stats
+   circmean
+   circvar
+   circstd
+
+Sensitivity Analysis
+--------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   sobol_indices
+
+Plot-tests
+----------
+
+.. autosummary::
+   :toctree: generated/
+
+   ppcc_max
+   ppcc_plot
+   probplot
+   boxcox_normplot
+   yeojohnson_normplot
+
+Univariate and multivariate kernel density estimation
+-----------------------------------------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   gaussian_kde
+
+Warnings / Errors used in :mod:`scipy.stats`
+--------------------------------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   DegenerateDataWarning
+   ConstantInputWarning
+   NearConstantInputWarning
+   FitError
+
+Result classes used in :mod:`scipy.stats`
+-----------------------------------------
+
+.. warning::
+
+    These classes are private, but they are included here because instances
+    of them are returned by other statistical functions. User import and
+    instantiation is not supported.
+
+.. toctree::
+   :maxdepth: 2
+
+   stats._result_classes
+
+"""  # noqa: E501
+
+from ._warnings_errors import (ConstantInputWarning, NearConstantInputWarning,
+                               DegenerateDataWarning, FitError)
+from ._stats_py import *
+from ._variation import variation
+from .distributions import *
+from ._morestats import *
+from ._multicomp import *
+from ._binomtest import binomtest
+from ._binned_statistic import *
+from ._kde import gaussian_kde
+from . import mstats
+from . import qmc
+from ._multivariate import *
+from . import contingency
+from .contingency import chi2_contingency
+from ._censored_data import CensoredData
+from ._resampling import (bootstrap, monte_carlo_test, permutation_test, power,
+                          MonteCarloMethod, PermutationMethod, BootstrapMethod)
+from ._entropy import *
+from ._hypotests import *
+from ._page_trend_test import page_trend_test
+from ._mannwhitneyu import mannwhitneyu
+from ._bws_test import bws_test
+from ._fit import fit, goodness_of_fit
+from ._covariance import Covariance
+from ._sensitivity_analysis import *
+from ._survival import *
+from ._distribution_infrastructure import (
+    make_distribution, Mixture, order_statistic, truncate, exp, log, abs
+)
+from ._new_distributions import Normal, Uniform
+from ._mgc import multiscale_graphcorr
+from ._correlation import chatterjeexi
+
+
+# Deprecated namespaces, to be removed in v2.0.0
+from . import (
+    biasedurn, kde, morestats, mstats_basic, mstats_extras, mvn, stats
+)
+
+
+__all__ = [s for s in dir() if not s.startswith("_")]  # Remove dunders.
+
+from scipy._lib._testutils import PytestTester
+test = PytestTester(__name__)
+del PytestTester

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/stats/_axis_nan_policy.py

@@ -0,0 +1,699 @@
+# Many scipy.stats functions support `axis` and `nan_policy` parameters.
+# When the two are combined, it can be tricky to get all the behavior just
+# right. This file contains utility functions useful for scipy.stats functions
+# that support `axis` and `nan_policy`, including a decorator that
+# automatically adds `axis` and `nan_policy` arguments to a function.
+
+import warnings
+import numpy as np
+from functools import wraps
+from scipy._lib._docscrape import FunctionDoc, Parameter
+from scipy._lib._util import _contains_nan, AxisError, _get_nan
+from scipy._lib._array_api import array_namespace, is_numpy
+
+import inspect
+
+too_small_1d_not_omit = (
+    "One or more sample arguments is too small; all "
+    "returned values will be NaN. "
+    "See documentation for sample size requirements.")
+
+too_small_1d_omit = (
+    "After omitting NaNs, one or more sample arguments "
+    "is too small; all returned values will be NaN. "
+    "See documentation for sample size requirements.")
+
+too_small_nd_not_omit = (
+    "All axis-slices of one or more sample arguments are "
+    "too small; all elements of returned arrays will be NaN. "
+    "See documentation for sample size requirements.")
+
+too_small_nd_omit = (
+    "After omitting NaNs, one or more axis-slices of one "
+    "or more sample arguments is too small; corresponding "
+    "elements of returned arrays will be NaN. "
+    "See documentation for sample size requirements.")
+
+class SmallSampleWarning(RuntimeWarning):
+    pass
+
+
+def _broadcast_arrays(arrays, axis=None, xp=None):
+    """
+    Broadcast shapes of arrays, ignoring incompatibility of specified axes
+    """
+    if not arrays:
+        return arrays
+    xp = array_namespace(*arrays) if xp is None else xp
+    arrays = [xp.asarray(arr) for arr in arrays]
+    shapes = [arr.shape for arr in arrays]
+    new_shapes = _broadcast_shapes(shapes, axis)
+    if axis is None:
+        new_shapes = [new_shapes]*len(arrays)
+    return [xp.broadcast_to(array, new_shape)
+            for array, new_shape in zip(arrays, new_shapes)]
+
+
+def _broadcast_shapes(shapes, axis=None):
+    """
+    Broadcast shapes, ignoring incompatibility of specified axes
+    """
+    if not shapes:
+        return shapes
+
+    # input validation
+    if axis is not None:
+        axis = np.atleast_1d(axis)
+        message = '`axis` must be an integer, a tuple of integers, or `None`.'
+        try:
+            with np.errstate(invalid='ignore'):
+                axis_int = axis.astype(int)
+        except ValueError as e:
+            raise AxisError(message) from e
+        if not np.array_equal(axis_int, axis):
+            raise AxisError(message)
+        axis = axis_int
+
+    # First, ensure all shapes have same number of dimensions by prepending 1s.
+    n_dims = max([len(shape) for shape in shapes])
+    new_shapes = np.ones((len(shapes), n_dims), dtype=int)
+    for row, shape in zip(new_shapes, shapes):
+        row[len(row)-len(shape):] = shape  # can't use negative indices (-0:)
+
+    # Remove the shape elements of the axes to be ignored, but remember them.
+    if axis is not None:
+        axis[axis < 0] = n_dims + axis[axis < 0]
+        axis = np.sort(axis)
+        if axis[-1] >= n_dims or axis[0] < 0:
+            message = (f"`axis` is out of bounds "
+                       f"for array of dimension {n_dims}")
+            raise AxisError(message)
+
+        if len(np.unique(axis)) != len(axis):
+            raise AxisError("`axis` must contain only distinct elements")
+
+        removed_shapes = new_shapes[:, axis]
+        new_shapes = np.delete(new_shapes, axis, axis=1)
+
+    # If arrays are broadcastable, shape elements that are 1 may be replaced
+    # with a corresponding non-1 shape element. Assuming arrays are
+    # broadcastable, that final shape element can be found with:
+    new_shape = np.max(new_shapes, axis=0)
+    # except in case of an empty array:
+    new_shape *= new_shapes.all(axis=0)
+
+    # Among all arrays, there can only be one unique non-1 shape element.
+    # Therefore, if any non-1 shape element does not match what we found
+    # above, the arrays must not be broadcastable after all.
+    if np.any(~((new_shapes == 1) | (new_shapes == new_shape))):
+        raise ValueError("Array shapes are incompatible for broadcasting.")
+
+    if axis is not None:
+        # Add back the shape elements that were ignored
+        new_axis = axis - np.arange(len(axis))
+        new_shapes = [tuple(np.insert(new_shape, new_axis, removed_shape))
+                      for removed_shape in removed_shapes]
+        return new_shapes
+    else:
+        return tuple(new_shape)
+
+
+def _broadcast_array_shapes_remove_axis(arrays, axis=None):
+    """
+    Broadcast shapes of arrays, dropping specified axes
+
+    Given a sequence of arrays `arrays` and an integer or tuple `axis`, find
+    the shape of the broadcast result after consuming/dropping `axis`.
+    In other words, return output shape of a typical hypothesis test on
+    `arrays` vectorized along `axis`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy.stats._axis_nan_policy import _broadcast_array_shapes_remove_axis
+    >>> a = np.zeros((5, 2, 1))
+    >>> b = np.zeros((9, 3))
+    >>> _broadcast_array_shapes_remove_axis((a, b), 1)
+    (5, 3)
+    """
+    # Note that here, `axis=None` means do not consume/drop any axes - _not_
+    # ravel arrays before broadcasting.
+    shapes = [arr.shape for arr in arrays]
+    return _broadcast_shapes_remove_axis(shapes, axis)
+
+
+def _broadcast_shapes_remove_axis(shapes, axis=None):
+    """
+    Broadcast shapes, dropping specified axes
+
+    Same as _broadcast_array_shapes_remove_axis, but given a sequence
+    of array shapes `shapes` instead of the arrays themselves.
+    """
+    shapes = _broadcast_shapes(shapes, axis)
+    shape = shapes[0]
+    if axis is not None:
+        shape = np.delete(shape, axis)
+    return tuple(shape)
+
+
+def _broadcast_concatenate(arrays, axis, paired=False):
+    """Concatenate arrays along an axis with broadcasting."""
+    arrays = _broadcast_arrays(arrays, axis if not paired else None)
+    res = np.concatenate(arrays, axis=axis)
+    return res
+
+
+# TODO: add support for `axis` tuples
+def _remove_nans(samples, paired):
+    "Remove nans from paired or unpaired 1D samples"
+    # potential optimization: don't copy arrays that don't contain nans
+    if not paired:
+        return [sample[~np.isnan(sample)] for sample in samples]
+
+    # for paired samples, we need to remove the whole pair when any part
+    # has a nan
+    nans = np.isnan(samples[0])
+    for sample in samples[1:]:
+        nans = nans | np.isnan(sample)
+    not_nans = ~nans
+    return [sample[not_nans] for sample in samples]
+
+
+def _remove_sentinel(samples, paired, sentinel):
+    "Remove sentinel values from paired or unpaired 1D samples"
+    # could consolidate with `_remove_nans`, but it's not quite as simple as
+    # passing `sentinel=np.nan` because `(np.nan == np.nan) is False`
+
+    # potential optimization: don't copy arrays that don't contain sentinel
+    if not paired:
+        return [sample[sample != sentinel] for sample in samples]
+
+    # for paired samples, we need to remove the whole pair when any part
+    # has a nan
+    sentinels = (samples[0] == sentinel)
+    for sample in samples[1:]:
+        sentinels = sentinels | (sample == sentinel)
+    not_sentinels = ~sentinels
+    return [sample[not_sentinels] for sample in samples]
+
+
+def _masked_arrays_2_sentinel_arrays(samples):
+    # masked arrays in `samples` are converted to regular arrays, and values
+    # corresponding with masked elements are replaced with a sentinel value
+
+    # return without modifying arrays if none have a mask
+    has_mask = False
+    for sample in samples:
+        mask = getattr(sample, 'mask', False)
+        has_mask = has_mask or np.any(mask)
+    if not has_mask:
+        return samples, None  # None means there is no sentinel value
+
+    # Choose a sentinel value. We can't use `np.nan`, because sentinel (masked)
+    # values are always omitted, but there are different nan policies.
+    dtype = np.result_type(*samples)
+    dtype = dtype if np.issubdtype(dtype, np.number) else np.float64
+    for i in range(len(samples)):
+        # Things get more complicated if the arrays are of different types.
+        # We could have different sentinel values for each array, but
+        # the purpose of this code is convenience, not efficiency.
+        samples[i] = samples[i].astype(dtype, copy=False)
+
+    inexact = np.issubdtype(dtype, np.inexact)
+    info = np.finfo if inexact else np.iinfo
+    max_possible, min_possible = info(dtype).max, info(dtype).min
+    nextafter = np.nextafter if inexact else (lambda x, _: x - 1)
+
+    sentinel = max_possible
+    # For simplicity, min_possible/np.infs are not candidate sentinel values
+    while sentinel > min_possible:
+        for sample in samples:
+            if np.any(sample == sentinel):  # choose a new sentinel value
+                sentinel = nextafter(sentinel, -np.inf)
+                break
+        else:  # when sentinel value is OK, break the while loop
+            break
+    else:
+        message = ("This function replaces masked elements with sentinel "
+                   "values, but the data contains all distinct values of this "
+                   "data type. Consider promoting the dtype to `np.float64`.")
+        raise ValueError(message)
+
+    # replace masked elements with sentinel value
+    out_samples = []
+    for sample in samples:
+        mask = getattr(sample, 'mask', None)
+        if mask is not None:  # turn all masked arrays into sentinel arrays
+            mask = np.broadcast_to(mask, sample.shape)
+            sample = sample.data.copy() if np.any(mask) else sample.data
+            sample = np.asarray(sample)  # `sample.data` could be a memoryview?
+            sample[mask] = sentinel
+        out_samples.append(sample)
+
+    return out_samples, sentinel
+
+
+def _check_empty_inputs(samples, axis):
+    """
+    Check for empty sample; return appropriate output for a vectorized hypotest
+    """
+    # if none of the samples are empty, we need to perform the test
+    if not any(sample.size == 0 for sample in samples):
+        return None
+    # otherwise, the statistic and p-value will be either empty arrays or
+    # arrays with NaNs. Produce the appropriate array and return it.
+    output_shape = _broadcast_array_shapes_remove_axis(samples, axis)
+    output = np.ones(output_shape) * _get_nan(*samples)
+    return output
+
+
+def _add_reduced_axes(res, reduced_axes, keepdims):
+    """
+    Add reduced axes back to all the arrays in the result object
+    if keepdims = True.
+    """
+    return ([np.expand_dims(output, reduced_axes) 
+             if not isinstance(output, int) else output for output in res]
+            if keepdims else res)
+
+
+# Standard docstring / signature entries for `axis`, `nan_policy`, `keepdims`
+_name = 'axis'
+_desc = (
+    """If an int, the axis of the input along which to compute the statistic.
+The statistic of each axis-slice (e.g. row) of the input will appear in a
+corresponding element of the output.
+If ``None``, the input will be raveled before computing the statistic."""
+    .split('\n'))
+
+
+def _get_axis_params(default_axis=0, _name=_name, _desc=_desc):  # bind NOW
+    _type = f"int or None, default: {default_axis}"
+    _axis_parameter_doc = Parameter(_name, _type, _desc)
+    _axis_parameter = inspect.Parameter(_name,
+                                        inspect.Parameter.KEYWORD_ONLY,
+                                        default=default_axis)
+    return _axis_parameter_doc, _axis_parameter
+
+
+_name = 'nan_policy'
+_type = "{'propagate', 'omit', 'raise'}"
+_desc = (
+    """Defines how to handle input NaNs.
+
+- ``propagate``: if a NaN is present in the axis slice (e.g. row) along
+  which the  statistic is computed, the corresponding entry of the output
+  will be NaN.
+- ``omit``: NaNs will be omitted when performing the calculation.
+  If insufficient data remains in the axis slice along which the
+  statistic is computed, the corresponding entry of the output will be
+  NaN.
+- ``raise``: if a NaN is present, a ``ValueError`` will be raised."""
+    .split('\n'))
+_nan_policy_parameter_doc = Parameter(_name, _type, _desc)
+_nan_policy_parameter = inspect.Parameter(_name,
+                                          inspect.Parameter.KEYWORD_ONLY,
+                                          default='propagate')
+
+_name = 'keepdims'
+_type = "bool, default: False"
+_desc = (
+    """If this is set to True, the axes which are reduced are left
+in the result as dimensions with size one. With this option,
+the result will broadcast correctly against the input array."""
+    .split('\n'))
+_keepdims_parameter_doc = Parameter(_name, _type, _desc)
+_keepdims_parameter = inspect.Parameter(_name,
+                                        inspect.Parameter.KEYWORD_ONLY,
+                                        default=False)
+
+_standard_note_addition = (
+    """\nBeginning in SciPy 1.9, ``np.matrix`` inputs (not recommended for new
+code) are converted to ``np.ndarray`` before the calculation is performed. In
+this case, the output will be a scalar or ``np.ndarray`` of appropriate shape
+rather than a 2D ``np.matrix``. Similarly, while masked elements of masked
+arrays are ignored, the output will be a scalar or ``np.ndarray`` rather than a
+masked array with ``mask=False``.""").split('\n')
+
+
+def _axis_nan_policy_factory(tuple_to_result, default_axis=0,
+                             n_samples=1, paired=False,
+                             result_to_tuple=None, too_small=0,
+                             n_outputs=2, kwd_samples=(), override=None):
+    """Factory for a wrapper that adds axis/nan_policy params to a function.
+
+    Parameters
+    ----------
+    tuple_to_result : callable
+        Callable that returns an object of the type returned by the function
+        being wrapped (e.g. the namedtuple or dataclass returned by a
+        statistical test) provided the separate components (e.g. statistic,
+        pvalue).
+    default_axis : int, default: 0
+        The default value of the axis argument. Standard is 0 except when
+        backwards compatibility demands otherwise (e.g. `None`).
+    n_samples : int or callable, default: 1
+        The number of data samples accepted by the function
+        (e.g. `mannwhitneyu`), a callable that accepts a dictionary of
+        parameters passed into the function and returns the number of data
+        samples (e.g. `wilcoxon`), or `None` to indicate an arbitrary number
+        of samples (e.g. `kruskal`).
+    paired : {False, True}
+        Whether the function being wrapped treats the samples as paired (i.e.
+        corresponding elements of each sample should be considered as different
+        components of the same sample.)
+    result_to_tuple : callable, optional
+        Function that unpacks the results of the function being wrapped into
+        a tuple. This is essentially the inverse of `tuple_to_result`. Default
+        is `None`, which is appropriate for statistical tests that return a
+        statistic, pvalue tuple (rather than, e.g., a non-iterable datalass).
+    too_small : int or callable, default: 0
+        The largest unnacceptably small sample for the function being wrapped.
+        For example, some functions require samples of size two or more or they
+        raise an error. This argument prevents the error from being raised when
+        input is not 1D and instead places a NaN in the corresponding element
+        of the result. If callable, it must accept a list of samples, axis,
+        and a dictionary of keyword arguments passed to the wrapper function as
+        arguments and return a bool indicating weather the samples passed are
+        too small.
+    n_outputs : int or callable, default: 2
+        The number of outputs produced by the function given 1d sample(s). For
+        example, hypothesis tests that return a namedtuple or result object
+        with attributes ``statistic`` and ``pvalue`` use the default
+        ``n_outputs=2``; summary statistics with scalar output use
+        ``n_outputs=1``. Alternatively, may be a callable that accepts a
+        dictionary of arguments passed into the wrapped function and returns
+        the number of outputs corresponding with those arguments.
+    kwd_samples : sequence, default: ()
+        The names of keyword parameters that should be treated as samples. For
+        example, `gmean` accepts as its first argument a sample `a` but
+        also `weights` as a fourth, optional keyword argument. In this case, we
+        use `n_samples=1` and kwd_samples=['weights'].
+    override : dict, default: {'vectorization': False, 'nan_propagation': True}
+        Pass a dictionary with ``'vectorization': True`` to ensure that the
+        decorator overrides the function's behavior for multimensional input.
+        Use ``'nan_propagation': False`` to ensure that the decorator does not
+        override the function's behavior for ``nan_policy='propagate'``.
+    """
+    # Specify which existing behaviors the decorator must override
+    temp = override or {}
+    override = {'vectorization': False,
+                'nan_propagation': True}
+    override.update(temp)
+
+    if result_to_tuple is None:
+        def result_to_tuple(res):
+            return res
+
+    # The only `result_to_tuple` that needs the second argument (number of
+    # outputs) is the one for `moment`, and this was realized very late.
+    # Rather than changing all `result_to_tuple` definitions, we wrap them
+    # here to accept a second argument if they don't already.
+    if len(inspect.signature(result_to_tuple).parameters) == 1:
+        def result_to_tuple(res, _, f=result_to_tuple):
+            return f(res)
+
+    if not callable(too_small):
+        def is_too_small(samples, *ts_args, axis=-1, **ts_kwargs):
+            for sample in samples:
+                if sample.shape[axis] <= too_small:
+                    return True
+            return False
+    else:
+        is_too_small = too_small
+
+    def axis_nan_policy_decorator(hypotest_fun_in):
+        @wraps(hypotest_fun_in)
+        def axis_nan_policy_wrapper(*args, _no_deco=False, **kwds):
+
+            if _no_deco:  # for testing, decorator does nothing
+                return hypotest_fun_in(*args, **kwds)
+
+            # For now, skip the decorator entirely if using array API. In the future,
+            # we'll probably want to use it for `keepdims`, `axis` tuples, etc.
+            if len(args) == 0:  # extract sample from `kwds` if there are no `args`
+                used_kwd_samples = list(set(kwds).intersection(set(kwd_samples)))
+                temp = used_kwd_samples[:1]
+            else:
+                temp = args[0]
+
+            if not is_numpy(array_namespace(temp)):
+                msg = ("Use of `nan_policy` and `keepdims` "
+                       "is incompatible with non-NumPy arrays.")
+                if 'nan_policy' in kwds or 'keepdims' in kwds:
+                    raise NotImplementedError(msg)
+                return hypotest_fun_in(*args, **kwds)
+
+            # We need to be flexible about whether position or keyword
+            # arguments are used, but we need to make sure users don't pass
+            # both for the same parameter. To complicate matters, some
+            # functions accept samples with *args, and some functions already
+            # accept `axis` and `nan_policy` as positional arguments.
+            # The strategy is to make sure that there is no duplication
+            # between `args` and `kwds`, combine the two into `kwds`, then
+            # the samples, `nan_policy`, and `axis` from `kwds`, as they are
+            # dealt with separately.
+
+            # Check for intersection between positional and keyword args
+            params = list(inspect.signature(hypotest_fun_in).parameters)
+            if n_samples is None:
+                # Give unique names to each positional sample argument
+                # Note that *args can't be provided as a keyword argument
+                params = [f"arg{i}" for i in range(len(args))] + params[1:]
+
+            # raise if there are too many positional args
+            maxarg = (np.inf if inspect.getfullargspec(hypotest_fun_in).varargs
+                      else len(inspect.getfullargspec(hypotest_fun_in).args))
+            if len(args) > maxarg:  # let the function raise the right error
+                hypotest_fun_in(*args, **kwds)
+
+            # raise if multiple values passed for same parameter
+            d_args = dict(zip(params, args))
+            intersection = set(d_args) & set(kwds)
+            if intersection:  # let the function raise the right error
+                hypotest_fun_in(*args, **kwds)
+
+            # Consolidate other positional and keyword args into `kwds`
+            kwds.update(d_args)
+
+            # rename avoids UnboundLocalError
+            if callable(n_samples):
+                # Future refactoring idea: no need for callable n_samples.
+                # Just replace `n_samples` and `kwd_samples` with a single
+                # list of the names of all samples, and treat all of them
+                # as `kwd_samples` are treated below.
+                n_samp = n_samples(kwds)
+            else:
+                n_samp = n_samples or len(args)
+
+            # get the number of outputs
+            n_out = n_outputs  # rename to avoid UnboundLocalError
+            if callable(n_out):
+                n_out = n_out(kwds)
+
+            # If necessary, rearrange function signature: accept other samples
+            # as positional args right after the first n_samp args
+            kwd_samp = [name for name in kwd_samples
+                        if kwds.get(name, None) is not None]
+            n_kwd_samp = len(kwd_samp)
+            if not kwd_samp:
+                hypotest_fun_out = hypotest_fun_in
+            else:
+                def hypotest_fun_out(*samples, **kwds):
+                    new_kwds = dict(zip(kwd_samp, samples[n_samp:]))
+                    kwds.update(new_kwds)
+                    return hypotest_fun_in(*samples[:n_samp], **kwds)
+
+            # Extract the things we need here
+            try:  # if something is missing
+                samples = [np.atleast_1d(kwds.pop(param))
+                           for param in (params[:n_samp] + kwd_samp)]
+            except KeyError:  # let the function raise the right error
+                # might need to revisit this if required arg is not a "sample"
+                hypotest_fun_in(*args, **kwds)
+            vectorized = True if 'axis' in params else False
+            vectorized = vectorized and not override['vectorization']
+            axis = kwds.pop('axis', default_axis)
+            nan_policy = kwds.pop('nan_policy', 'propagate')
+            keepdims = kwds.pop("keepdims", False)
+            del args  # avoid the possibility of passing both `args` and `kwds`
+
+            # convert masked arrays to regular arrays with sentinel values
+            samples, sentinel = _masked_arrays_2_sentinel_arrays(samples)
+
+            # standardize to always work along last axis
+            reduced_axes = axis
+            if axis is None:
+                if samples:
+                    # when axis=None, take the maximum of all dimensions since
+                    # all the dimensions are reduced.
+                    n_dims = np.max([sample.ndim for sample in samples])
+                    reduced_axes = tuple(range(n_dims))
+                samples = [np.asarray(sample.ravel()) for sample in samples]
+            else:
+                # don't ignore any axes when broadcasting if paired
+                samples = _broadcast_arrays(samples, axis=axis if not paired else None)
+                axis = np.atleast_1d(axis)
+                n_axes = len(axis)
+                # move all axes in `axis` to the end to be raveled
+                samples = [np.moveaxis(sample, axis, range(-len(axis), 0))
+                           for sample in samples]
+                shapes = [sample.shape for sample in samples]
+                # New shape is unchanged for all axes _not_ in `axis`
+                # At the end, we append the product of the shapes of the axes
+                # in `axis`. Appending -1 doesn't work for zero-size arrays!
+                new_shapes = [shape[:-n_axes] + (np.prod(shape[-n_axes:]),)
+                              for shape in shapes]
+                samples = [sample.reshape(new_shape)
+                           for sample, new_shape in zip(samples, new_shapes)]
+            axis = -1  # work over the last axis
+            NaN = _get_nan(*samples) if samples else np.nan
+
+            # if axis is not needed, just handle nan_policy and return
+            ndims = np.array([sample.ndim for sample in samples])
+            if np.all(ndims <= 1):
+                # Addresses nan_policy == "raise"
+                if nan_policy != 'propagate' or override['nan_propagation']:
+                    contains_nan = [_contains_nan(sample, nan_policy)[0]
+                                    for sample in samples]
+                else:
+                    # Behave as though there are no NaNs (even if there are)
+                    contains_nan = [False]*len(samples)
+
+                # Addresses nan_policy == "propagate"
+                if any(contains_nan) and (nan_policy == 'propagate'
+                                          and override['nan_propagation']):
+                    res = np.full(n_out, NaN)
+                    res = _add_reduced_axes(res, reduced_axes, keepdims)
+                    return tuple_to_result(*res)
+
+                # Addresses nan_policy == "omit"
+                too_small_msg = too_small_1d_not_omit
+                if any(contains_nan) and nan_policy == 'omit':
+                    # consider passing in contains_nan
+                    samples = _remove_nans(samples, paired)
+                    too_small_msg = too_small_1d_omit
+
+                if sentinel:
+                    samples = _remove_sentinel(samples, paired, sentinel)
+
+                if is_too_small(samples, kwds):
+                    warnings.warn(too_small_msg, SmallSampleWarning, stacklevel=2)
+                    res = np.full(n_out, NaN)
+                    res = _add_reduced_axes(res, reduced_axes, keepdims)
+                    return tuple_to_result(*res)
+
+                res = hypotest_fun_out(*samples, **kwds)
+                res = result_to_tuple(res, n_out)
+                res = _add_reduced_axes(res, reduced_axes, keepdims)
+                return tuple_to_result(*res)
+
+            # check for empty input
+            empty_output = _check_empty_inputs(samples, axis)
+            # only return empty output if zero sized input is too small.
+            if (
+                empty_output is not None
+                and (is_too_small(samples, kwds) or empty_output.size == 0)
+            ):
+                if is_too_small(samples, kwds) and empty_output.size != 0:
+                    warnings.warn(too_small_nd_not_omit, SmallSampleWarning,
+                                  stacklevel=2)
+                res = [empty_output.copy() for i in range(n_out)]
+                res = _add_reduced_axes(res, reduced_axes, keepdims)
+                return tuple_to_result(*res)
+
+            # otherwise, concatenate all samples along axis, remembering where
+            # each separate sample begins
+            lengths = np.array([sample.shape[axis] for sample in samples])
+            split_indices = np.cumsum(lengths)
+            x = _broadcast_concatenate(samples, axis, paired=paired)
+
+            # Addresses nan_policy == "raise"
+            if nan_policy != 'propagate' or override['nan_propagation']:
+                contains_nan, _ = _contains_nan(x, nan_policy)
+            else:
+                contains_nan = False  # behave like there are no NaNs
+
+            if vectorized and not contains_nan and not sentinel:
+                res = hypotest_fun_out(*samples, axis=axis, **kwds)
+                res = result_to_tuple(res, n_out)
+                res = _add_reduced_axes(res, reduced_axes, keepdims)
+                return tuple_to_result(*res)
+
+            # Addresses nan_policy == "omit"
+            if contains_nan and nan_policy == 'omit':
+                def hypotest_fun(x):
+                    samples = np.split(x, split_indices)[:n_samp+n_kwd_samp]
+                    samples = _remove_nans(samples, paired)
+                    if sentinel:
+                        samples = _remove_sentinel(samples, paired, sentinel)
+                    if is_too_small(samples, kwds):
+                        warnings.warn(too_small_nd_omit, SmallSampleWarning,
+                                      stacklevel=4)
+                        return np.full(n_out, NaN)
+                    return result_to_tuple(hypotest_fun_out(*samples, **kwds), n_out)
+
+            # Addresses nan_policy == "propagate"
+            elif (contains_nan and nan_policy == 'propagate'
+                  and override['nan_propagation']):
+                def hypotest_fun(x):
+                    if np.isnan(x).any():
+                        return np.full(n_out, NaN)
+
+                    samples = np.split(x, split_indices)[:n_samp+n_kwd_samp]
+                    if sentinel:
+                        samples = _remove_sentinel(samples, paired, sentinel)
+                    if is_too_small(samples, kwds):
+                        return np.full(n_out, NaN)
+                    return result_to_tuple(hypotest_fun_out(*samples, **kwds), n_out)
+
+            else:
+                def hypotest_fun(x):
+                    samples = np.split(x, split_indices)[:n_samp+n_kwd_samp]
+                    if sentinel:
+                        samples = _remove_sentinel(samples, paired, sentinel)
+                    if is_too_small(samples, kwds):
+                        return np.full(n_out, NaN)
+                    return result_to_tuple(hypotest_fun_out(*samples, **kwds), n_out)
+
+            x = np.moveaxis(x, axis, 0)
+            res = np.apply_along_axis(hypotest_fun, axis=0, arr=x)
+            res = _add_reduced_axes(res, reduced_axes, keepdims)
+            return tuple_to_result(*res)
+
+        _axis_parameter_doc, _axis_parameter = _get_axis_params(default_axis)
+        doc = FunctionDoc(axis_nan_policy_wrapper)
+        parameter_names = [param.name for param in doc['Parameters']]
+        if 'axis' in parameter_names:
+            doc['Parameters'][parameter_names.index('axis')] = (
+                _axis_parameter_doc)
+        else:
+            doc['Parameters'].append(_axis_parameter_doc)
+        if 'nan_policy' in parameter_names:
+            doc['Parameters'][parameter_names.index('nan_policy')] = (
+                _nan_policy_parameter_doc)
+        else:
+            doc['Parameters'].append(_nan_policy_parameter_doc)
+        if 'keepdims' in parameter_names:
+            doc['Parameters'][parameter_names.index('keepdims')] = (
+                _keepdims_parameter_doc)
+        else:
+            doc['Parameters'].append(_keepdims_parameter_doc)
+        doc['Notes'] += _standard_note_addition
+        doc = str(doc).split("\n", 1)[1]  # remove signature
+        axis_nan_policy_wrapper.__doc__ = str(doc)
+
+        sig = inspect.signature(axis_nan_policy_wrapper)
+        parameters = sig.parameters
+        parameter_list = list(parameters.values())
+        if 'axis' not in parameters:
+            parameter_list.append(_axis_parameter)
+        if 'nan_policy' not in parameters:
+            parameter_list.append(_nan_policy_parameter)
+        if 'keepdims' not in parameters:
+            parameter_list.append(_keepdims_parameter)
+        sig = sig.replace(parameters=parameter_list)
+        axis_nan_policy_wrapper.__signature__ = sig
+
+        return axis_nan_policy_wrapper
+    return axis_nan_policy_decorator

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/stats/_biasedurn.pxd

@@ -0,0 +1,27 @@
+# Declare the class with cdef
+cdef extern from "biasedurn/stocc.h" nogil:
+    cdef cppclass CFishersNCHypergeometric:
+        CFishersNCHypergeometric(int, int, int, double, double) except +
+        int mode()
+        double mean()
+        double variance()
+        double probability(int x)
+        double moments(double * mean, double * var)
+
+    cdef cppclass CWalleniusNCHypergeometric:
+        CWalleniusNCHypergeometric() except +
+        CWalleniusNCHypergeometric(int, int, int, double, double) except +
+        int mode()
+        double mean()
+        double variance()
+        double probability(int x)
+        double moments(double * mean, double * var)
+
+    cdef cppclass StochasticLib3:
+        StochasticLib3(int seed) except +
+        double Random() except +
+        void SetAccuracy(double accur)
+        int FishersNCHyp (int n, int m, int N, double odds) except +
+        int WalleniusNCHyp (int n, int m, int N, double odds) except +
+        double(*next_double)()
+        double(*next_normal)(const double m, const double s)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/stats/_binned_statistic.py

@@ -0,0 +1,795 @@
+import builtins
+from warnings import catch_warnings, simplefilter
+import numpy as np
+from operator import index
+from collections import namedtuple
+
+__all__ = ['binned_statistic',
+           'binned_statistic_2d',
+           'binned_statistic_dd']
+
+
+BinnedStatisticResult = namedtuple('BinnedStatisticResult',
+                                   ('statistic', 'bin_edges', 'binnumber'))
+
+
+def binned_statistic(x, values, statistic='mean',
+                     bins=10, range=None):
+    """
+    Compute a binned statistic for one or more sets of data.
+
+    This is a generalization of a histogram function.  A histogram divides
+    the space into bins, and returns the count of the number of points in
+    each bin.  This function allows the computation of the sum, mean, median,
+    or other statistic of the values (or set of values) within each bin.
+
+    Parameters
+    ----------
+    x : (N,) array_like
+        A sequence of values to be binned.
+    values : (N,) array_like or list of (N,) array_like
+        The data on which the statistic will be computed.  This must be
+        the same shape as `x`, or a set of sequences - each the same shape as
+        `x`.  If `values` is a set of sequences, the statistic will be computed
+        on each independently.
+    statistic : string or callable, optional
+        The statistic to compute (default is 'mean').
+        The following statistics are available:
+
+          * 'mean' : compute the mean of values for points within each bin.
+            Empty bins will be represented by NaN.
+          * 'std' : compute the standard deviation within each bin. This
+            is implicitly calculated with ddof=0.
+          * 'median' : compute the median of values for points within each
+            bin. Empty bins will be represented by NaN.
+          * 'count' : compute the count of points within each bin.  This is
+            identical to an unweighted histogram.  `values` array is not
+            referenced.
+          * 'sum' : compute the sum of values for points within each bin.
+            This is identical to a weighted histogram.
+          * 'min' : compute the minimum of values for points within each bin.
+            Empty bins will be represented by NaN.
+          * 'max' : compute the maximum of values for point within each bin.
+            Empty bins will be represented by NaN.
+          * function : a user-defined function which takes a 1D array of
+            values, and outputs a single numerical statistic. This function
+            will be called on the values in each bin.  Empty bins will be
+            represented by function([]), or NaN if this returns an error.
+
+    bins : int or sequence of scalars, optional
+        If `bins` is an int, it defines the number of equal-width bins in the
+        given range (10 by default).  If `bins` is a sequence, it defines the
+        bin edges, including the rightmost edge, allowing for non-uniform bin
+        widths.  Values in `x` that are smaller than lowest bin edge are
+        assigned to bin number 0, values beyond the highest bin are assigned to
+        ``bins[-1]``.  If the bin edges are specified, the number of bins will
+        be, (nx = len(bins)-1).
+    range : (float, float) or [(float, float)], optional
+        The lower and upper range of the bins.  If not provided, range
+        is simply ``(x.min(), x.max())``.  Values outside the range are
+        ignored.
+
+    Returns
+    -------
+    statistic : array
+        The values of the selected statistic in each bin.
+    bin_edges : array of dtype float
+        Return the bin edges ``(length(statistic)+1)``.
+    binnumber: 1-D ndarray of ints
+        Indices of the bins (corresponding to `bin_edges`) in which each value
+        of `x` belongs.  Same length as `values`.  A binnumber of `i` means the
+        corresponding value is between (bin_edges[i-1], bin_edges[i]).
+
+    See Also
+    --------
+    numpy.digitize, numpy.histogram, binned_statistic_2d, binned_statistic_dd
+
+    Notes
+    -----
+    All but the last (righthand-most) bin is half-open.  In other words, if
+    `bins` is ``[1, 2, 3, 4]``, then the first bin is ``[1, 2)`` (including 1,
+    but excluding 2) and the second ``[2, 3)``.  The last bin, however, is
+    ``[3, 4]``, which *includes* 4.
+
+    .. versionadded:: 0.11.0
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy import stats
+    >>> import matplotlib.pyplot as plt
+
+    First some basic examples:
+
+    Create two evenly spaced bins in the range of the given sample, and sum the
+    corresponding values in each of those bins:
+
+    >>> values = [1.0, 1.0, 2.0, 1.5, 3.0]
+    >>> stats.binned_statistic([1, 1, 2, 5, 7], values, 'sum', bins=2)
+    BinnedStatisticResult(statistic=array([4. , 4.5]),
+            bin_edges=array([1., 4., 7.]), binnumber=array([1, 1, 1, 2, 2]))
+
+    Multiple arrays of values can also be passed.  The statistic is calculated
+    on each set independently:
+
+    >>> values = [[1.0, 1.0, 2.0, 1.5, 3.0], [2.0, 2.0, 4.0, 3.0, 6.0]]
+    >>> stats.binned_statistic([1, 1, 2, 5, 7], values, 'sum', bins=2)
+    BinnedStatisticResult(statistic=array([[4. , 4.5],
+           [8. , 9. ]]), bin_edges=array([1., 4., 7.]),
+           binnumber=array([1, 1, 1, 2, 2]))
+
+    >>> stats.binned_statistic([1, 2, 1, 2, 4], np.arange(5), statistic='mean',
+    ...                        bins=3)
+    BinnedStatisticResult(statistic=array([1., 2., 4.]),
+            bin_edges=array([1., 2., 3., 4.]),
+            binnumber=array([1, 2, 1, 2, 3]))
+
+    As a second example, we now generate some random data of sailing boat speed
+    as a function of wind speed, and then determine how fast our boat is for
+    certain wind speeds:
+
+    >>> rng = np.random.default_rng()
+    >>> windspeed = 8 * rng.random(500)
+    >>> boatspeed = .3 * windspeed**.5 + .2 * rng.random(500)
+    >>> bin_means, bin_edges, binnumber = stats.binned_statistic(windspeed,
+    ...                 boatspeed, statistic='median', bins=[1,2,3,4,5,6,7])
+    >>> plt.figure()
+    >>> plt.plot(windspeed, boatspeed, 'b.', label='raw data')
+    >>> plt.hlines(bin_means, bin_edges[:-1], bin_edges[1:], colors='g', lw=5,
+    ...            label='binned statistic of data')
+    >>> plt.legend()
+
+    Now we can use ``binnumber`` to select all datapoints with a windspeed
+    below 1:
+
+    >>> low_boatspeed = boatspeed[binnumber == 0]
+
+    As a final example, we will use ``bin_edges`` and ``binnumber`` to make a
+    plot of a distribution that shows the mean and distribution around that
+    mean per bin, on top of a regular histogram and the probability
+    distribution function:
+
+    >>> x = np.linspace(0, 5, num=500)
+    >>> x_pdf = stats.maxwell.pdf(x)
+    >>> samples = stats.maxwell.rvs(size=10000)
+
+    >>> bin_means, bin_edges, binnumber = stats.binned_statistic(x, x_pdf,
+    ...         statistic='mean', bins=25)
+    >>> bin_width = (bin_edges[1] - bin_edges[0])
+    >>> bin_centers = bin_edges[1:] - bin_width/2
+
+    >>> plt.figure()
+    >>> plt.hist(samples, bins=50, density=True, histtype='stepfilled',
+    ...          alpha=0.2, label='histogram of data')
+    >>> plt.plot(x, x_pdf, 'r-', label='analytical pdf')
+    >>> plt.hlines(bin_means, bin_edges[:-1], bin_edges[1:], colors='g', lw=2,
+    ...            label='binned statistic of data')
+    >>> plt.plot((binnumber - 0.5) * bin_width, x_pdf, 'g.', alpha=0.5)
+    >>> plt.legend(fontsize=10)
+    >>> plt.show()
+
+    """
+    try:
+        N = len(bins)
+    except TypeError:
+        N = 1
+
+    if N != 1:
+        bins = [np.asarray(bins, float)]
+
+    if range is not None:
+        if len(range) == 2:
+            range = [range]
+
+    medians, edges, binnumbers = binned_statistic_dd(
+        [x], values, statistic, bins, range)
+
+    return BinnedStatisticResult(medians, edges[0], binnumbers)
+
+
+BinnedStatistic2dResult = namedtuple('BinnedStatistic2dResult',
+                                     ('statistic', 'x_edge', 'y_edge',
+                                      'binnumber'))
+
+
+def binned_statistic_2d(x, y, values, statistic='mean',
+                        bins=10, range=None, expand_binnumbers=False):
+    """
+    Compute a bidimensional binned statistic for one or more sets of data.
+
+    This is a generalization of a histogram2d function.  A histogram divides
+    the space into bins, and returns the count of the number of points in
+    each bin.  This function allows the computation of the sum, mean, median,
+    or other statistic of the values (or set of values) within each bin.
+
+    Parameters
+    ----------
+    x : (N,) array_like
+        A sequence of values to be binned along the first dimension.
+    y : (N,) array_like
+        A sequence of values to be binned along the second dimension.
+    values : (N,) array_like or list of (N,) array_like
+        The data on which the statistic will be computed.  This must be
+        the same shape as `x`, or a list of sequences - each with the same
+        shape as `x`.  If `values` is such a list, the statistic will be
+        computed on each independently.
+    statistic : string or callable, optional
+        The statistic to compute (default is 'mean').
+        The following statistics are available:
+
+          * 'mean' : compute the mean of values for points within each bin.
+            Empty bins will be represented by NaN.
+          * 'std' : compute the standard deviation within each bin. This
+            is implicitly calculated with ddof=0.
+          * 'median' : compute the median of values for points within each
+            bin. Empty bins will be represented by NaN.
+          * 'count' : compute the count of points within each bin.  This is
+            identical to an unweighted histogram.  `values` array is not
+            referenced.
+          * 'sum' : compute the sum of values for points within each bin.
+            This is identical to a weighted histogram.
+          * 'min' : compute the minimum of values for points within each bin.
+            Empty bins will be represented by NaN.
+          * 'max' : compute the maximum of values for point within each bin.
+            Empty bins will be represented by NaN.
+          * function : a user-defined function which takes a 1D array of
+            values, and outputs a single numerical statistic. This function
+            will be called on the values in each bin.  Empty bins will be
+            represented by function([]), or NaN if this returns an error.
+
+    bins : int or [int, int] or array_like or [array, array], optional
+        The bin specification:
+
+          * the number of bins for the two dimensions (nx = ny = bins),
+          * the number of bins in each dimension (nx, ny = bins),
+          * the bin edges for the two dimensions (x_edge = y_edge = bins),
+          * the bin edges in each dimension (x_edge, y_edge = bins).
+
+        If the bin edges are specified, the number of bins will be,
+        (nx = len(x_edge)-1, ny = len(y_edge)-1).
+
+    range : (2,2) array_like, optional
+        The leftmost and rightmost edges of the bins along each dimension
+        (if not specified explicitly in the `bins` parameters):
+        [[xmin, xmax], [ymin, ymax]]. All values outside of this range will be
+        considered outliers and not tallied in the histogram.
+    expand_binnumbers : bool, optional
+        'False' (default): the returned `binnumber` is a shape (N,) array of
+        linearized bin indices.
+        'True': the returned `binnumber` is 'unraveled' into a shape (2,N)
+        ndarray, where each row gives the bin numbers in the corresponding
+        dimension.
+        See the `binnumber` returned value, and the `Examples` section.
+
+        .. versionadded:: 0.17.0
+
+    Returns
+    -------
+    statistic : (nx, ny) ndarray
+        The values of the selected statistic in each two-dimensional bin.
+    x_edge : (nx + 1) ndarray
+        The bin edges along the first dimension.
+    y_edge : (ny + 1) ndarray
+        The bin edges along the second dimension.
+    binnumber : (N,) array of ints or (2,N) ndarray of ints
+        This assigns to each element of `sample` an integer that represents the
+        bin in which this observation falls.  The representation depends on the
+        `expand_binnumbers` argument.  See `Notes` for details.
+
+
+    See Also
+    --------
+    numpy.digitize, numpy.histogram2d, binned_statistic, binned_statistic_dd
+
+    Notes
+    -----
+    Binedges:
+    All but the last (righthand-most) bin is half-open.  In other words, if
+    `bins` is ``[1, 2, 3, 4]``, then the first bin is ``[1, 2)`` (including 1,
+    but excluding 2) and the second ``[2, 3)``.  The last bin, however, is
+    ``[3, 4]``, which *includes* 4.
+
+    `binnumber`:
+    This returned argument assigns to each element of `sample` an integer that
+    represents the bin in which it belongs.  The representation depends on the
+    `expand_binnumbers` argument. If 'False' (default): The returned
+    `binnumber` is a shape (N,) array of linearized indices mapping each
+    element of `sample` to its corresponding bin (using row-major ordering).
+    Note that the returned linearized bin indices are used for an array with
+    extra bins on the outer binedges to capture values outside of the defined
+    bin bounds.
+    If 'True': The returned `binnumber` is a shape (2,N) ndarray where
+    each row indicates bin placements for each dimension respectively.  In each
+    dimension, a binnumber of `i` means the corresponding value is between
+    (D_edge[i-1], D_edge[i]), where 'D' is either 'x' or 'y'.
+
+    .. versionadded:: 0.11.0
+
+    Examples
+    --------
+    >>> from scipy import stats
+
+    Calculate the counts with explicit bin-edges:
+
+    >>> x = [0.1, 0.1, 0.1, 0.6]
+    >>> y = [2.1, 2.6, 2.1, 2.1]
+    >>> binx = [0.0, 0.5, 1.0]
+    >>> biny = [2.0, 2.5, 3.0]
+    >>> ret = stats.binned_statistic_2d(x, y, None, 'count', bins=[binx, biny])
+    >>> ret.statistic
+    array([[2., 1.],
+           [1., 0.]])
+
+    The bin in which each sample is placed is given by the `binnumber`
+    returned parameter.  By default, these are the linearized bin indices:
+
+    >>> ret.binnumber
+    array([5, 6, 5, 9])
+
+    The bin indices can also be expanded into separate entries for each
+    dimension using the `expand_binnumbers` parameter:
+
+    >>> ret = stats.binned_statistic_2d(x, y, None, 'count', bins=[binx, biny],
+    ...                                 expand_binnumbers=True)
+    >>> ret.binnumber
+    array([[1, 1, 1, 2],
+           [1, 2, 1, 1]])
+
+    Which shows that the first three elements belong in the xbin 1, and the
+    fourth into xbin 2; and so on for y.
+
+    """
+
+    # This code is based on np.histogram2d
+    try:
+        N = len(bins)
+    except TypeError:
+        N = 1
+
+    if N != 1 and N != 2:
+        xedges = yedges = np.asarray(bins, float)
+        bins = [xedges, yedges]
+
+    medians, edges, binnumbers = binned_statistic_dd(
+        [x, y], values, statistic, bins, range,
+        expand_binnumbers=expand_binnumbers)
+
+    return BinnedStatistic2dResult(medians, edges[0], edges[1], binnumbers)
+
+
+BinnedStatisticddResult = namedtuple('BinnedStatisticddResult',
+                                     ('statistic', 'bin_edges',
+                                      'binnumber'))
+
+
+def _bincount(x, weights):
+    if np.iscomplexobj(weights):
+        a = np.bincount(x, np.real(weights))
+        b = np.bincount(x, np.imag(weights))
+        z = a + b*1j
+
+    else:
+        z = np.bincount(x, weights)
+    return z
+
+
+def binned_statistic_dd(sample, values, statistic='mean',
+                        bins=10, range=None, expand_binnumbers=False,
+                        binned_statistic_result=None):
+    """
+    Compute a multidimensional binned statistic for a set of data.
+
+    This is a generalization of a histogramdd function.  A histogram divides
+    the space into bins, and returns the count of the number of points in
+    each bin.  This function allows the computation of the sum, mean, median,
+    or other statistic of the values within each bin.
+
+    Parameters
+    ----------
+    sample : array_like
+        Data to histogram passed as a sequence of N arrays of length D, or
+        as an (N,D) array.
+    values : (N,) array_like or list of (N,) array_like
+        The data on which the statistic will be computed.  This must be
+        the same shape as `sample`, or a list of sequences - each with the
+        same shape as `sample`.  If `values` is such a list, the statistic
+        will be computed on each independently.
+    statistic : string or callable, optional
+        The statistic to compute (default is 'mean').
+        The following statistics are available:
+
+          * 'mean' : compute the mean of values for points within each bin.
+            Empty bins will be represented by NaN.
+          * 'median' : compute the median of values for points within each
+            bin. Empty bins will be represented by NaN.
+          * 'count' : compute the count of points within each bin.  This is
+            identical to an unweighted histogram.  `values` array is not
+            referenced.
+          * 'sum' : compute the sum of values for points within each bin.
+            This is identical to a weighted histogram.
+          * 'std' : compute the standard deviation within each bin. This
+            is implicitly calculated with ddof=0. If the number of values
+            within a given bin is 0 or 1, the computed standard deviation value
+            will be 0 for the bin.
+          * 'min' : compute the minimum of values for points within each bin.
+            Empty bins will be represented by NaN.
+          * 'max' : compute the maximum of values for point within each bin.
+            Empty bins will be represented by NaN.
+          * function : a user-defined function which takes a 1D array of
+            values, and outputs a single numerical statistic. This function
+            will be called on the values in each bin.  Empty bins will be
+            represented by function([]), or NaN if this returns an error.
+
+    bins : sequence or positive int, optional
+        The bin specification must be in one of the following forms:
+
+          * A sequence of arrays describing the bin edges along each dimension.
+          * The number of bins for each dimension (nx, ny, ... = bins).
+          * The number of bins for all dimensions (nx = ny = ... = bins).
+    range : sequence, optional
+        A sequence of lower and upper bin edges to be used if the edges are
+        not given explicitly in `bins`. Defaults to the minimum and maximum
+        values along each dimension.
+    expand_binnumbers : bool, optional
+        'False' (default): the returned `binnumber` is a shape (N,) array of
+        linearized bin indices.
+        'True': the returned `binnumber` is 'unraveled' into a shape (D,N)
+        ndarray, where each row gives the bin numbers in the corresponding
+        dimension.
+        See the `binnumber` returned value, and the `Examples` section of
+        `binned_statistic_2d`.
+    binned_statistic_result : binnedStatisticddResult
+        Result of a previous call to the function in order to reuse bin edges
+        and bin numbers with new values and/or a different statistic.
+        To reuse bin numbers, `expand_binnumbers` must have been set to False
+        (the default)
+
+        .. versionadded:: 0.17.0
+
+    Returns
+    -------
+    statistic : ndarray, shape(nx1, nx2, nx3,...)
+        The values of the selected statistic in each two-dimensional bin.
+    bin_edges : list of ndarrays
+        A list of D arrays describing the (nxi + 1) bin edges for each
+        dimension.
+    binnumber : (N,) array of ints or (D,N) ndarray of ints
+        This assigns to each element of `sample` an integer that represents the
+        bin in which this observation falls.  The representation depends on the
+        `expand_binnumbers` argument.  See `Notes` for details.
+
+
+    See Also
+    --------
+    numpy.digitize, numpy.histogramdd, binned_statistic, binned_statistic_2d
+
+    Notes
+    -----
+    Binedges:
+    All but the last (righthand-most) bin is half-open in each dimension.  In
+    other words, if `bins` is ``[1, 2, 3, 4]``, then the first bin is
+    ``[1, 2)`` (including 1, but excluding 2) and the second ``[2, 3)``.  The
+    last bin, however, is ``[3, 4]``, which *includes* 4.
+
+    `binnumber`:
+    This returned argument assigns to each element of `sample` an integer that
+    represents the bin in which it belongs.  The representation depends on the
+    `expand_binnumbers` argument. If 'False' (default): The returned
+    `binnumber` is a shape (N,) array of linearized indices mapping each
+    element of `sample` to its corresponding bin (using row-major ordering).
+    If 'True': The returned `binnumber` is a shape (D,N) ndarray where
+    each row indicates bin placements for each dimension respectively.  In each
+    dimension, a binnumber of `i` means the corresponding value is between
+    (bin_edges[D][i-1], bin_edges[D][i]), for each dimension 'D'.
+
+    .. versionadded:: 0.11.0
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy import stats
+    >>> import matplotlib.pyplot as plt
+    >>> from mpl_toolkits.mplot3d import Axes3D
+
+    Take an array of 600 (x, y) coordinates as an example.
+    `binned_statistic_dd` can handle arrays of higher dimension `D`. But a plot
+    of dimension `D+1` is required.
+
+    >>> mu = np.array([0., 1.])
+    >>> sigma = np.array([[1., -0.5],[-0.5, 1.5]])
+    >>> multinormal = stats.multivariate_normal(mu, sigma)
+    >>> data = multinormal.rvs(size=600, random_state=235412)
+    >>> data.shape
+    (600, 2)
+
+    Create bins and count how many arrays fall in each bin:
+
+    >>> N = 60
+    >>> x = np.linspace(-3, 3, N)
+    >>> y = np.linspace(-3, 4, N)
+    >>> ret = stats.binned_statistic_dd(data, np.arange(600), bins=[x, y],
+    ...                                 statistic='count')
+    >>> bincounts = ret.statistic
+
+    Set the volume and the location of bars:
+
+    >>> dx = x[1] - x[0]
+    >>> dy = y[1] - y[0]
+    >>> x, y = np.meshgrid(x[:-1]+dx/2, y[:-1]+dy/2)
+    >>> z = 0
+
+    >>> bincounts = bincounts.ravel()
+    >>> x = x.ravel()
+    >>> y = y.ravel()
+
+    >>> fig = plt.figure()
+    >>> ax = fig.add_subplot(111, projection='3d')
+    >>> with np.errstate(divide='ignore'):   # silence random axes3d warning
+    ...     ax.bar3d(x, y, z, dx, dy, bincounts)
+
+    Reuse bin numbers and bin edges with new values:
+
+    >>> ret2 = stats.binned_statistic_dd(data, -np.arange(600),
+    ...                                  binned_statistic_result=ret,
+    ...                                  statistic='mean')
+    """
+    known_stats = ['mean', 'median', 'count', 'sum', 'std', 'min', 'max']
+    if not callable(statistic) and statistic not in known_stats:
+        raise ValueError(f'invalid statistic {statistic!r}')
+
+    try:
+        bins = index(bins)
+    except TypeError:
+        # bins is not an integer
+        pass
+    # If bins was an integer-like object, now it is an actual Python int.
+
+    # NOTE: for _bin_edges(), see e.g. gh-11365
+    if isinstance(bins, int) and not np.isfinite(sample).all():
+        raise ValueError(f'{sample!r} contains non-finite values.')
+
+    # `Ndim` is the number of dimensions (e.g. `2` for `binned_statistic_2d`)
+    # `Dlen` is the length of elements along each dimension.
+    # This code is based on np.histogramdd
+    try:
+        # `sample` is an ND-array.
+        Dlen, Ndim = sample.shape
+    except (AttributeError, ValueError):
+        # `sample` is a sequence of 1D arrays.
+        sample = np.atleast_2d(sample).T
+        Dlen, Ndim = sample.shape
+
+    # Store initial shape of `values` to preserve it in the output
+    values = np.asarray(values)
+    input_shape = list(values.shape)
+    # Make sure that `values` is 2D to iterate over rows
+    values = np.atleast_2d(values)
+    Vdim, Vlen = values.shape
+
+    # Make sure `values` match `sample`
+    if statistic != 'count' and Vlen != Dlen:
+        raise AttributeError('The number of `values` elements must match the '
+                             'length of each `sample` dimension.')
+
+    try:
+        M = len(bins)
+        if M != Ndim:
+            raise AttributeError('The dimension of bins must be equal '
+                                 'to the dimension of the sample x.')
+    except TypeError:
+        bins = Ndim * [bins]
+
+    if binned_statistic_result is None:
+        nbin, edges, dedges = _bin_edges(sample, bins, range)
+        binnumbers = _bin_numbers(sample, nbin, edges, dedges)
+    else:
+        edges = binned_statistic_result.bin_edges
+        nbin = np.array([len(edges[i]) + 1 for i in builtins.range(Ndim)])
+        # +1 for outlier bins
+        dedges = [np.diff(edges[i]) for i in builtins.range(Ndim)]
+        binnumbers = binned_statistic_result.binnumber
+
+    # Avoid overflow with double precision. Complex `values` -> `complex128`.
+    result_type = np.result_type(values, np.float64)
+    result = np.empty([Vdim, nbin.prod()], dtype=result_type)
+
+    if statistic in {'mean', np.mean}:
+        result.fill(np.nan)
+        flatcount = _bincount(binnumbers, None)
+        a = flatcount.nonzero()
+        for vv in builtins.range(Vdim):
+            flatsum = _bincount(binnumbers, values[vv])
+            result[vv, a] = flatsum[a] / flatcount[a]
+    elif statistic in {'std', np.std}:
+        result.fill(np.nan)
+        flatcount = _bincount(binnumbers, None)
+        a = flatcount.nonzero()
+        for vv in builtins.range(Vdim):
+            flatsum = _bincount(binnumbers, values[vv])
+            delta = values[vv] - flatsum[binnumbers] / flatcount[binnumbers]
+            std = np.sqrt(
+                _bincount(binnumbers, delta*np.conj(delta))[a] / flatcount[a]
+            )
+            result[vv, a] = std
+        result = np.real(result)
+    elif statistic == 'count':
+        result = np.empty([Vdim, nbin.prod()], dtype=np.float64)
+        result.fill(0)
+        flatcount = _bincount(binnumbers, None)
+        a = np.arange(len(flatcount))
+        result[:, a] = flatcount[np.newaxis, :]
+    elif statistic in {'sum', np.sum}:
+        result.fill(0)
+        for vv in builtins.range(Vdim):
+            flatsum = _bincount(binnumbers, values[vv])
+            a = np.arange(len(flatsum))
+            result[vv, a] = flatsum
+    elif statistic in {'median', np.median}:
+        result.fill(np.nan)
+        for vv in builtins.range(Vdim):
+            i = np.lexsort((values[vv], binnumbers))
+            _, j, counts = np.unique(binnumbers[i],
+                                     return_index=True, return_counts=True)
+            mid = j + (counts - 1) / 2
+            mid_a = values[vv, i][np.floor(mid).astype(int)]
+            mid_b = values[vv, i][np.ceil(mid).astype(int)]
+            medians = (mid_a + mid_b) / 2
+            result[vv, binnumbers[i][j]] = medians
+    elif statistic in {'min', np.min}:
+        result.fill(np.nan)
+        for vv in builtins.range(Vdim):
+            i = np.argsort(values[vv])[::-1]  # Reversed so the min is last
+            result[vv, binnumbers[i]] = values[vv, i]
+    elif statistic in {'max', np.max}:
+        result.fill(np.nan)
+        for vv in builtins.range(Vdim):
+            i = np.argsort(values[vv])
+            result[vv, binnumbers[i]] = values[vv, i]
+    elif callable(statistic):
+        with np.errstate(invalid='ignore'), catch_warnings():
+            simplefilter("ignore", RuntimeWarning)
+            try:
+                null = statistic([])
+            except Exception:
+                null = np.nan
+        if np.iscomplexobj(null):
+            result = result.astype(np.complex128)
+        result.fill(null)
+        try:
+            _calc_binned_statistic(
+                Vdim, binnumbers, result, values, statistic
+            )
+        except ValueError:
+            result = result.astype(np.complex128)
+            _calc_binned_statistic(
+                Vdim, binnumbers, result, values, statistic
+            )
+
+    # Shape into a proper matrix
+    result = result.reshape(np.append(Vdim, nbin))
+
+    # Remove outliers (indices 0 and -1 for each bin-dimension).
+    core = tuple([slice(None)] + Ndim * [slice(1, -1)])
+    result = result[core]
+
+    # Unravel binnumbers into an ndarray, each row the bins for each dimension
+    if expand_binnumbers and Ndim > 1:
+        binnumbers = np.asarray(np.unravel_index(binnumbers, nbin))
+
+    if np.any(result.shape[1:] != nbin - 2):
+        raise RuntimeError('Internal Shape Error')
+
+    # Reshape to have output (`result`) match input (`values`) shape
+    result = result.reshape(input_shape[:-1] + list(nbin-2))
+
+    return BinnedStatisticddResult(result, edges, binnumbers)
+
+
+def _calc_binned_statistic(Vdim, bin_numbers, result, values, stat_func):
+    unique_bin_numbers = np.unique(bin_numbers)
+    for vv in builtins.range(Vdim):
+        bin_map = _create_binned_data(bin_numbers, unique_bin_numbers,
+                                      values, vv)
+        for i in unique_bin_numbers:
+            stat = stat_func(np.array(bin_map[i]))
+            if np.iscomplexobj(stat) and not np.iscomplexobj(result):
+                raise ValueError("The statistic function returns complex ")
+            result[vv, i] = stat
+
+
+def _create_binned_data(bin_numbers, unique_bin_numbers, values, vv):
+    """ Create hashmap of bin ids to values in bins
+    key: bin number
+    value: list of binned data
+    """
+    bin_map = dict()
+    for i in unique_bin_numbers:
+        bin_map[i] = []
+    for i in builtins.range(len(bin_numbers)):
+        bin_map[bin_numbers[i]].append(values[vv, i])
+    return bin_map
+
+
+def _bin_edges(sample, bins=None, range=None):
+    """ Create edge arrays
+    """
+    Dlen, Ndim = sample.shape
+
+    nbin = np.empty(Ndim, int)    # Number of bins in each dimension
+    edges = Ndim * [None]         # Bin edges for each dim (will be 2D array)
+    dedges = Ndim * [None]        # Spacing between edges (will be 2D array)
+
+    # Select range for each dimension
+    # Used only if number of bins is given.
+    if range is None:
+        smin = np.atleast_1d(np.array(sample.min(axis=0), float))
+        smax = np.atleast_1d(np.array(sample.max(axis=0), float))
+    else:
+        if len(range) != Ndim:
+            raise ValueError(
+                f"range given for {len(range)} dimensions; {Ndim} required")
+        smin = np.empty(Ndim)
+        smax = np.empty(Ndim)
+        for i in builtins.range(Ndim):
+            if range[i][1] < range[i][0]:
+                raise ValueError(
+                    f"In {f'dimension {i + 1} of ' if Ndim > 1 else ''}range,"
+                    " start must be <= stop")
+            smin[i], smax[i] = range[i]
+
+    # Make sure the bins have a finite width.
+    for i in builtins.range(len(smin)):
+        if smin[i] == smax[i]:
+            smin[i] = smin[i] - .5
+            smax[i] = smax[i] + .5
+
+    # Preserve sample floating point precision in bin edges
+    edges_dtype = (sample.dtype if np.issubdtype(sample.dtype, np.floating)
+                   else float)
+
+    # Create edge arrays
+    for i in builtins.range(Ndim):
+        if np.isscalar(bins[i]):
+            nbin[i] = bins[i] + 2  # +2 for outlier bins
+            edges[i] = np.linspace(smin[i], smax[i], nbin[i] - 1,
+                                   dtype=edges_dtype)
+        else:
+            edges[i] = np.asarray(bins[i], edges_dtype)
+            nbin[i] = len(edges[i]) + 1  # +1 for outlier bins
+        dedges[i] = np.diff(edges[i])
+
+    nbin = np.asarray(nbin)
+
+    return nbin, edges, dedges
+
+
+def _bin_numbers(sample, nbin, edges, dedges):
+    """Compute the bin number each sample falls into, in each dimension
+    """
+    Dlen, Ndim = sample.shape
+
+    sampBin = [
+        np.digitize(sample[:, i], edges[i])
+        for i in range(Ndim)
+    ]
+
+    # Using `digitize`, values that fall on an edge are put in the right bin.
+    # For the rightmost bin, we want values equal to the right
+    # edge to be counted in the last bin, and not as an outlier.
+    for i in range(Ndim):
+        # Find the rounding precision
+        dedges_min = dedges[i].min()
+        if dedges_min == 0:
+            raise ValueError('The smallest edge difference is numerically 0.')
+        decimal = int(-np.log10(dedges_min)) + 6
+        # Find which points are on the rightmost edge.
+        on_edge = np.where((sample[:, i] >= edges[i][-1]) &
+                           (np.around(sample[:, i], decimal) ==
+                            np.around(edges[i][-1], decimal)))[0]
+        # Shift these points one bin to the left.
+        sampBin[i][on_edge] -= 1
+
+    # Compute the sample indices in the flattened statistic matrix.
+    binnumbers = np.ravel_multi_index(sampBin, nbin)
+
+    return binnumbers

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/stats/_binomtest.py

@@ -0,0 +1,375 @@
+from math import sqrt
+import numpy as np
+from scipy._lib._util import _validate_int
+from scipy.optimize import brentq
+from scipy.special import ndtri
+from ._discrete_distns import binom
+from ._common import ConfidenceInterval
+
+
+class BinomTestResult:
+    """
+    Result of `scipy.stats.binomtest`.
+
+    Attributes
+    ----------
+    k : int
+        The number of successes (copied from `binomtest` input).
+    n : int
+        The number of trials (copied from `binomtest` input).
+    alternative : str
+        Indicates the alternative hypothesis specified in the input
+        to `binomtest`.  It will be one of ``'two-sided'``, ``'greater'``,
+        or ``'less'``.
+    statistic: float
+        The estimate of the proportion of successes.
+    pvalue : float
+        The p-value of the hypothesis test.
+
+    """
+    def __init__(self, k, n, alternative, statistic, pvalue):
+        self.k = k
+        self.n = n
+        self.alternative = alternative
+        self.statistic = statistic
+        self.pvalue = pvalue
+
+        # add alias for backward compatibility
+        self.proportion_estimate = statistic
+
+    def __repr__(self):
+        s = ("BinomTestResult("
+             f"k={self.k}, "
+             f"n={self.n}, "
+             f"alternative={self.alternative!r}, "
+             f"statistic={self.statistic}, "
+             f"pvalue={self.pvalue})")
+        return s
+
+    def proportion_ci(self, confidence_level=0.95, method='exact'):
+        """
+        Compute the confidence interval for ``statistic``.
+
+        Parameters
+        ----------
+        confidence_level : float, optional
+            Confidence level for the computed confidence interval
+            of the estimated proportion. Default is 0.95.
+        method : {'exact', 'wilson', 'wilsoncc'}, optional
+            Selects the method used to compute the confidence interval
+            for the estimate of the proportion:
+
+            'exact' :
+                Use the Clopper-Pearson exact method [1]_.
+            'wilson' :
+                Wilson's method, without continuity correction ([2]_, [3]_).
+            'wilsoncc' :
+                Wilson's method, with continuity correction ([2]_, [3]_).
+
+            Default is ``'exact'``.
+
+        Returns
+        -------
+        ci : ``ConfidenceInterval`` object
+            The object has attributes ``low`` and ``high`` that hold the
+            lower and upper bounds of the confidence interval.
+
+        References
+        ----------
+        .. [1] C. J. Clopper and E. S. Pearson, The use of confidence or
+               fiducial limits illustrated in the case of the binomial,
+               Biometrika, Vol. 26, No. 4, pp 404-413 (Dec. 1934).
+        .. [2] E. B. Wilson, Probable inference, the law of succession, and
+               statistical inference, J. Amer. Stat. Assoc., 22, pp 209-212
+               (1927).
+        .. [3] Robert G. Newcombe, Two-sided confidence intervals for the
+               single proportion: comparison of seven methods, Statistics
+               in Medicine, 17, pp 857-872 (1998).
+
+        Examples
+        --------
+        >>> from scipy.stats import binomtest
+        >>> result = binomtest(k=7, n=50, p=0.1)
+        >>> result.statistic
+        0.14
+        >>> result.proportion_ci()
+        ConfidenceInterval(low=0.05819170033997342, high=0.26739600249700846)
+        """
+        if method not in ('exact', 'wilson', 'wilsoncc'):
+            raise ValueError(f"method ('{method}') must be one of 'exact', "
+                             "'wilson' or 'wilsoncc'.")
+        if not (0 <= confidence_level <= 1):
+            raise ValueError(f'confidence_level ({confidence_level}) must be in '
+                             'the interval [0, 1].')
+        if method == 'exact':
+            low, high = _binom_exact_conf_int(self.k, self.n,
+                                              confidence_level,
+                                              self.alternative)
+        else:
+            # method is 'wilson' or 'wilsoncc'
+            low, high = _binom_wilson_conf_int(self.k, self.n,
+                                               confidence_level,
+                                               self.alternative,
+                                               correction=method == 'wilsoncc')
+        return ConfidenceInterval(low=low, high=high)
+
+
+def _findp(func):
+    try:
+        p = brentq(func, 0, 1)
+    except RuntimeError:
+        raise RuntimeError('numerical solver failed to converge when '
+                           'computing the confidence limits') from None
+    except ValueError as exc:
+        raise ValueError('brentq raised a ValueError; report this to the '
+                         'SciPy developers') from exc
+    return p
+
+
+def _binom_exact_conf_int(k, n, confidence_level, alternative):
+    """
+    Compute the estimate and confidence interval for the binomial test.
+
+    Returns proportion, prop_low, prop_high
+    """
+    if alternative == 'two-sided':
+        alpha = (1 - confidence_level) / 2
+        if k == 0:
+            plow = 0.0
+        else:
+            plow = _findp(lambda p: binom.sf(k-1, n, p) - alpha)
+        if k == n:
+            phigh = 1.0
+        else:
+            phigh = _findp(lambda p: binom.cdf(k, n, p) - alpha)
+    elif alternative == 'less':
+        alpha = 1 - confidence_level
+        plow = 0.0
+        if k == n:
+            phigh = 1.0
+        else:
+            phigh = _findp(lambda p: binom.cdf(k, n, p) - alpha)
+    elif alternative == 'greater':
+        alpha = 1 - confidence_level
+        if k == 0:
+            plow = 0.0
+        else:
+            plow = _findp(lambda p: binom.sf(k-1, n, p) - alpha)
+        phigh = 1.0
+    return plow, phigh
+
+
+def _binom_wilson_conf_int(k, n, confidence_level, alternative, correction):
+    # This function assumes that the arguments have already been validated.
+    # In particular, `alternative` must be one of 'two-sided', 'less' or
+    # 'greater'.
+    p = k / n
+    if alternative == 'two-sided':
+        z = ndtri(0.5 + 0.5*confidence_level)
+    else:
+        z = ndtri(confidence_level)
+
+    # For reference, the formulas implemented here are from
+    # Newcombe (1998) (ref. [3] in the proportion_ci docstring).
+    denom = 2*(n + z**2)
+    center = (2*n*p + z**2)/denom
+    q = 1 - p
+    if correction:
+        if alternative == 'less' or k == 0:
+            lo = 0.0
+        else:
+            dlo = (1 + z*sqrt(z**2 - 2 - 1/n + 4*p*(n*q + 1))) / denom
+            lo = center - dlo
+        if alternative == 'greater' or k == n:
+            hi = 1.0
+        else:
+            dhi = (1 + z*sqrt(z**2 + 2 - 1/n + 4*p*(n*q - 1))) / denom
+            hi = center + dhi
+    else:
+        delta = z/denom * sqrt(4*n*p*q + z**2)
+        if alternative == 'less' or k == 0:
+            lo = 0.0
+        else:
+            lo = center - delta
+        if alternative == 'greater' or k == n:
+            hi = 1.0
+        else:
+            hi = center + delta
+
+    return lo, hi
+
+
+def binomtest(k, n, p=0.5, alternative='two-sided'):
+    """
+    Perform a test that the probability of success is p.
+
+    The binomial test [1]_ is a test of the null hypothesis that the
+    probability of success in a Bernoulli experiment is `p`.
+
+    Details of the test can be found in many texts on statistics, such
+    as section 24.5 of [2]_.
+
+    Parameters
+    ----------
+    k : int
+        The number of successes.
+    n : int
+        The number of trials.
+    p : float, optional
+        The hypothesized probability of success, i.e. the expected
+        proportion of successes.  The value must be in the interval
+        ``0 <= p <= 1``. The default value is ``p = 0.5``.
+    alternative : {'two-sided', 'greater', 'less'}, optional
+        Indicates the alternative hypothesis. The default value is
+        'two-sided'.
+
+    Returns
+    -------
+    result : `~scipy.stats._result_classes.BinomTestResult` instance
+        The return value is an object with the following attributes:
+
+        k : int
+            The number of successes (copied from `binomtest` input).
+        n : int
+            The number of trials (copied from `binomtest` input).
+        alternative : str
+            Indicates the alternative hypothesis specified in the input
+            to `binomtest`.  It will be one of ``'two-sided'``, ``'greater'``,
+            or ``'less'``.
+        statistic : float
+            The estimate of the proportion of successes.
+        pvalue : float
+            The p-value of the hypothesis test.
+
+        The object has the following methods:
+
+        proportion_ci(confidence_level=0.95, method='exact') :
+            Compute the confidence interval for ``statistic``.
+
+    Notes
+    -----
+    .. versionadded:: 1.7.0
+
+    References
+    ----------
+    .. [1] Binomial test, https://en.wikipedia.org/wiki/Binomial_test
+    .. [2] Jerrold H. Zar, Biostatistical Analysis (fifth edition),
+           Prentice Hall, Upper Saddle River, New Jersey USA (2010)
+
+    Examples
+    --------
+    >>> from scipy.stats import binomtest
+
+    A car manufacturer claims that no more than 10% of their cars are unsafe.
+    15 cars are inspected for safety, 3 were found to be unsafe. Test the
+    manufacturer's claim:
+
+    >>> result = binomtest(3, n=15, p=0.1, alternative='greater')
+    >>> result.pvalue
+    0.18406106910639114
+
+    The null hypothesis cannot be rejected at the 5% level of significance
+    because the returned p-value is greater than the critical value of 5%.
+
+    The test statistic is equal to the estimated proportion, which is simply
+    ``3/15``:
+
+    >>> result.statistic
+    0.2
+
+    We can use the `proportion_ci()` method of the result to compute the
+    confidence interval of the estimate:
+
+    >>> result.proportion_ci(confidence_level=0.95)
+    ConfidenceInterval(low=0.05684686759024681, high=1.0)
+
+    """
+    k = _validate_int(k, 'k', minimum=0)
+    n = _validate_int(n, 'n', minimum=1)
+    if k > n:
+        raise ValueError(f'k ({k}) must not be greater than n ({n}).')
+
+    if not (0 <= p <= 1):
+        raise ValueError(f"p ({p}) must be in range [0,1]")
+
+    if alternative not in ('two-sided', 'less', 'greater'):
+        raise ValueError(f"alternative ('{alternative}') not recognized; \n"
+                         "must be 'two-sided', 'less' or 'greater'")
+    if alternative == 'less':
+        pval = binom.cdf(k, n, p)
+    elif alternative == 'greater':
+        pval = binom.sf(k-1, n, p)
+    else:
+        # alternative is 'two-sided'
+        d = binom.pmf(k, n, p)
+        rerr = 1 + 1e-7
+        if k == p * n:
+            # special case as shortcut, would also be handled by `else` below
+            pval = 1.
+        elif k < p * n:
+            ix = _binary_search_for_binom_tst(lambda x1: -binom.pmf(x1, n, p),
+                                              -d*rerr, np.ceil(p * n), n)
+            # y is the number of terms between mode and n that are <= d*rerr.
+            # ix gave us the first term where a(ix) <= d*rerr < a(ix-1)
+            # if the first equality doesn't hold, y=n-ix. Otherwise, we
+            # need to include ix as well as the equality holds. Note that
+            # the equality will hold in very very rare situations due to rerr.
+            y = n - ix + int(d*rerr == binom.pmf(ix, n, p))
+            pval = binom.cdf(k, n, p) + binom.sf(n - y, n, p)
+        else:
+            ix = _binary_search_for_binom_tst(lambda x1: binom.pmf(x1, n, p),
+                                              d*rerr, 0, np.floor(p * n))
+            # y is the number of terms between 0 and mode that are <= d*rerr.
+            # we need to add a 1 to account for the 0 index.
+            # For comparing this with old behavior, see
+            # tst_binary_srch_for_binom_tst method in test_morestats.
+            y = ix + 1
+            pval = binom.cdf(y-1, n, p) + binom.sf(k-1, n, p)
+
+        pval = min(1.0, pval)
+
+    result = BinomTestResult(k=k, n=n, alternative=alternative,
+                             statistic=k/n, pvalue=pval)
+    return result
+
+
+def _binary_search_for_binom_tst(a, d, lo, hi):
+    """
+    Conducts an implicit binary search on a function specified by `a`.
+
+    Meant to be used on the binomial PMF for the case of two-sided tests
+    to obtain the value on the other side of the mode where the tail
+    probability should be computed. The values on either side of
+    the mode are always in order, meaning binary search is applicable.
+
+    Parameters
+    ----------
+    a : callable
+      The function over which to perform binary search. Its values
+      for inputs lo and hi should be in ascending order.
+    d : float
+      The value to search.
+    lo : int
+      The lower end of range to search.
+    hi : int
+      The higher end of the range to search.
+
+    Returns
+    -------
+    int
+      The index, i between lo and hi
+      such that a(i)<=d<a(i+1)
+    """
+    while lo < hi:
+        mid = lo + (hi-lo)//2
+        midval = a(mid)
+        if midval < d:
+            lo = mid+1
+        elif midval > d:
+            hi = mid-1
+        else:
+            return mid
+    if a(lo) <= d:
+        return lo
+    else:
+        return lo-1

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/stats/_bws_test.py

@@ -0,0 +1,177 @@
+import numpy as np
+from functools import partial
+from scipy import stats
+
+
+def _bws_input_validation(x, y, alternative, method):
+    ''' Input validation and standardization for bws test'''
+    x, y = np.atleast_1d(x, y)
+    if x.ndim > 1 or y.ndim > 1:
+        raise ValueError('`x` and `y` must be exactly one-dimensional.')
+    if np.isnan(x).any() or np.isnan(y).any():
+        raise ValueError('`x` and `y` must not contain NaNs.')
+    if np.size(x) == 0 or np.size(y) == 0:
+        raise ValueError('`x` and `y` must be of nonzero size.')
+
+    z = stats.rankdata(np.concatenate((x, y)))
+    x, y = z[:len(x)], z[len(x):]
+
+    alternatives = {'two-sided', 'less', 'greater'}
+    alternative = alternative.lower()
+    if alternative not in alternatives:
+        raise ValueError(f'`alternative` must be one of {alternatives}.')
+
+    method = stats.PermutationMethod() if method is None else method
+    if not isinstance(method, stats.PermutationMethod):
+        raise ValueError('`method` must be an instance of '
+                         '`scipy.stats.PermutationMethod`')
+
+    return x, y, alternative, method
+
+
+def _bws_statistic(x, y, alternative, axis):
+    '''Compute the BWS test statistic for two independent samples'''
+    # Public function currently does not accept `axis`, but `permutation_test`
+    # uses `axis` to make vectorized call.
+
+    Ri, Hj = np.sort(x, axis=axis), np.sort(y, axis=axis)
+    n, m = Ri.shape[axis], Hj.shape[axis]
+    i, j = np.arange(1, n+1), np.arange(1, m+1)
+
+    Bx_num = Ri - (m + n)/n * i
+    By_num = Hj - (m + n)/m * j
+
+    if alternative == 'two-sided':
+        Bx_num *= Bx_num
+        By_num *= By_num
+    else:
+        Bx_num *= np.abs(Bx_num)
+        By_num *= np.abs(By_num)
+
+    Bx_den = i/(n+1) * (1 - i/(n+1)) * m*(m+n)/n
+    By_den = j/(m+1) * (1 - j/(m+1)) * n*(m+n)/m
+
+    Bx = 1/n * np.sum(Bx_num/Bx_den, axis=axis)
+    By = 1/m * np.sum(By_num/By_den, axis=axis)
+
+    B = (Bx + By) / 2 if alternative == 'two-sided' else (Bx - By) / 2
+
+    return B
+
+
+def bws_test(x, y, *, alternative="two-sided", method=None):
+    r'''Perform the Baumgartner-Weiss-Schindler test on two independent samples.
+
+    The Baumgartner-Weiss-Schindler (BWS) test is a nonparametric test of 
+    the null hypothesis that the distribution underlying sample `x` 
+    is the same as the distribution underlying sample `y`. Unlike 
+    the Kolmogorov-Smirnov, Wilcoxon, and Cramer-Von Mises tests, 
+    the BWS test weights the integral by the variance of the difference
+    in cumulative distribution functions (CDFs), emphasizing the tails of the
+    distributions, which increases the power of the test in many applications.
+
+    Parameters
+    ----------
+    x, y : array-like
+        1-d arrays of samples.
+    alternative : {'two-sided', 'less', 'greater'}, optional
+        Defines the alternative hypothesis. Default is 'two-sided'.
+        Let *F(u)* and *G(u)* be the cumulative distribution functions of the
+        distributions underlying `x` and `y`, respectively. Then the following
+        alternative hypotheses are available:
+
+        * 'two-sided': the distributions are not equal, i.e. *F(u) ≠ G(u)* for
+          at least one *u*.
+        * 'less': the distribution underlying `x` is stochastically less than
+          the distribution underlying `y`, i.e. *F(u) >= G(u)* for all *u*.
+        * 'greater': the distribution underlying `x` is stochastically greater
+          than the distribution underlying `y`, i.e. *F(u) <= G(u)* for all
+          *u*.
+
+        Under a more restrictive set of assumptions, the alternative hypotheses
+        can be expressed in terms of the locations of the distributions;
+        see [2] section 5.1.
+    method : PermutationMethod, optional
+        Configures the method used to compute the p-value. The default is
+        the default `PermutationMethod` object.
+
+    Returns
+    -------
+    res : PermutationTestResult
+    An object with attributes:
+
+    statistic : float
+        The observed test statistic of the data.
+    pvalue : float
+        The p-value for the given alternative.
+    null_distribution : ndarray
+        The values of the test statistic generated under the null hypothesis.
+
+    See also
+    --------
+    scipy.stats.wilcoxon, scipy.stats.mannwhitneyu, scipy.stats.ttest_ind
+
+    Notes
+    -----
+    When ``alternative=='two-sided'``, the statistic is defined by the
+    equations given in [1]_ Section 2. This statistic is not appropriate for
+    one-sided alternatives; in that case, the statistic is the *negative* of
+    that given by the equations in [1]_ Section 2. Consequently, when the
+    distribution of the first sample is stochastically greater than that of the
+    second sample, the statistic will tend to be positive.
+
+    References
+    ----------
+    .. [1] Neuhäuser, M. (2005). Exact Tests Based on the
+           Baumgartner-Weiss-Schindler Statistic: A Survey. Statistical Papers,
+           46(1), 1-29.
+    .. [2] Fay, M. P., & Proschan, M. A. (2010). Wilcoxon-Mann-Whitney or t-test?
+           On assumptions for hypothesis tests and multiple interpretations of 
+           decision rules. Statistics surveys, 4, 1.
+
+    Examples
+    --------
+    We follow the example of table 3 in [1]_: Fourteen children were divided
+    randomly into two groups. Their ranks at performing a specific tests are
+    as follows.
+
+    >>> import numpy as np
+    >>> x = [1, 2, 3, 4, 6, 7, 8]
+    >>> y = [5, 9, 10, 11, 12, 13, 14]
+
+    We use the BWS test to assess whether there is a statistically significant
+    difference between the two groups.
+    The null hypothesis is that there is no difference in the distributions of
+    performance between the two groups. We decide that a significance level of
+    1% is required to reject the null hypothesis in favor of the alternative
+    that the distributions are different.
+    Since the number of samples is very small, we can compare the observed test
+    statistic against the *exact* distribution of the test statistic under the
+    null hypothesis.
+
+    >>> from scipy.stats import bws_test
+    >>> res = bws_test(x, y)
+    >>> print(res.statistic)
+    5.132167152575315
+
+    This agrees with :math:`B = 5.132` reported in [1]_. The *p*-value produced
+    by `bws_test` also agrees with :math:`p = 0.0029` reported in [1]_.
+
+    >>> print(res.pvalue)
+    0.002913752913752914
+
+    Because the p-value is below our threshold of 1%, we take this as evidence
+    against the null hypothesis in favor of the alternative that there is a
+    difference in performance between the two groups.
+    '''
+
+    x, y, alternative, method = _bws_input_validation(x, y, alternative,
+                                                      method)
+    bws_statistic = partial(_bws_statistic, alternative=alternative)
+
+    permutation_alternative = 'less' if alternative == 'less' else 'greater'
+    res = stats.permutation_test((x, y), bws_statistic,
+                                 alternative=permutation_alternative,
+                                 **method._asdict())
+
+    return res

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/stats/_censored_data.py

@@ -0,0 +1,459 @@
+import numpy as np
+
+
+def _validate_1d(a, name, allow_inf=False):
+    if np.ndim(a) != 1:
+        raise ValueError(f'`{name}` must be a one-dimensional sequence.')
+    if np.isnan(a).any():
+        raise ValueError(f'`{name}` must not contain nan.')
+    if not allow_inf and np.isinf(a).any():
+        raise ValueError(f'`{name}` must contain only finite values.')
+
+
+def _validate_interval(interval):
+    interval = np.asarray(interval)
+    if interval.shape == (0,):
+        # The input was a sequence with length 0.
+        interval = interval.reshape((0, 2))
+    if interval.ndim != 2 or interval.shape[-1] != 2:
+        raise ValueError('`interval` must be a two-dimensional array with '
+                         'shape (m, 2), where m is the number of '
+                         'interval-censored values, but got shape '
+                         f'{interval.shape}')
+
+    if np.isnan(interval).any():
+        raise ValueError('`interval` must not contain nan.')
+    if np.isinf(interval).all(axis=1).any():
+        raise ValueError('In each row in `interval`, both values must not'
+                         ' be infinite.')
+    if (interval[:, 0] > interval[:, 1]).any():
+        raise ValueError('In each row of `interval`, the left value must not'
+                         ' exceed the right value.')
+
+    uncensored_mask = interval[:, 0] == interval[:, 1]
+    left_mask = np.isinf(interval[:, 0])
+    right_mask = np.isinf(interval[:, 1])
+    interval_mask = np.isfinite(interval).all(axis=1) & ~uncensored_mask
+
+    uncensored2 = interval[uncensored_mask, 0]
+    left2 = interval[left_mask, 1]
+    right2 = interval[right_mask, 0]
+    interval2 = interval[interval_mask]
+
+    return uncensored2, left2, right2, interval2
+
+
+def _validate_x_censored(x, censored):
+    x = np.asarray(x)
+    if x.ndim != 1:
+        raise ValueError('`x` must be one-dimensional.')
+    censored = np.asarray(censored)
+    if censored.ndim != 1:
+        raise ValueError('`censored` must be one-dimensional.')
+    if (~np.isfinite(x)).any():
+        raise ValueError('`x` must not contain nan or inf.')
+    if censored.size != x.size:
+        raise ValueError('`x` and `censored` must have the same length.')
+    return x, censored.astype(bool)
+
+
+class CensoredData:
+    """
+    Instances of this class represent censored data.
+
+    Instances may be passed to the ``fit`` method of continuous
+    univariate SciPy distributions for maximum likelihood estimation.
+    The *only* method of the univariate continuous distributions that
+    understands `CensoredData` is the ``fit`` method.  An instance of
+    `CensoredData` can not be passed to methods such as ``pdf`` and
+    ``cdf``.
+
+    An observation is said to be *censored* when the precise value is unknown,
+    but it has a known upper and/or lower bound.  The conventional terminology
+    is:
+
+    * left-censored: an observation is below a certain value but it is
+      unknown by how much.
+    * right-censored: an observation is above a certain value but it is
+      unknown by how much.
+    * interval-censored: an observation lies somewhere on an interval between
+      two values.
+
+    Left-, right-, and interval-censored data can be represented by
+    `CensoredData`.
+
+    For convenience, the class methods ``left_censored`` and
+    ``right_censored`` are provided to create a `CensoredData`
+    instance from a single one-dimensional array of measurements
+    and a corresponding boolean array to indicate which measurements
+    are censored.  The class method ``interval_censored`` accepts two
+    one-dimensional arrays that hold the lower and upper bounds of the
+    intervals.
+
+    Parameters
+    ----------
+    uncensored : array_like, 1D
+        Uncensored observations.
+    left : array_like, 1D
+        Left-censored observations.
+    right : array_like, 1D
+        Right-censored observations.
+    interval : array_like, 2D, with shape (m, 2)
+        Interval-censored observations.  Each row ``interval[k, :]``
+        represents the interval for the kth interval-censored observation.
+
+    Notes
+    -----
+    In the input array `interval`, the lower bound of the interval may
+    be ``-inf``, and the upper bound may be ``inf``, but at least one must be
+    finite. When the lower bound is ``-inf``, the row represents a left-
+    censored observation, and when the upper bound is ``inf``, the row
+    represents a right-censored observation.  If the length of an interval
+    is 0 (i.e. ``interval[k, 0] == interval[k, 1]``, the observation is
+    treated as uncensored.  So one can represent all the types of censored
+    and uncensored data in ``interval``, but it is generally more convenient
+    to use `uncensored`, `left` and `right` for uncensored, left-censored and
+    right-censored observations, respectively.
+
+    Examples
+    --------
+    In the most general case, a censored data set may contain values that
+    are left-censored, right-censored, interval-censored, and uncensored.
+    For example, here we create a data set with five observations.  Two
+    are uncensored (values 1 and 1.5), one is a left-censored observation
+    of 0, one is a right-censored observation of 10 and one is
+    interval-censored in the interval [2, 3].
+
+    >>> import numpy as np
+    >>> from scipy.stats import CensoredData
+    >>> data = CensoredData(uncensored=[1, 1.5], left=[0], right=[10],
+    ...                     interval=[[2, 3]])
+    >>> print(data)
+    CensoredData(5 values: 2 not censored, 1 left-censored,
+    1 right-censored, 1 interval-censored)
+
+    Equivalently,
+
+    >>> data = CensoredData(interval=[[1, 1],
+    ...                               [1.5, 1.5],
+    ...                               [-np.inf, 0],
+    ...                               [10, np.inf],
+    ...                               [2, 3]])
+    >>> print(data)
+    CensoredData(5 values: 2 not censored, 1 left-censored,
+    1 right-censored, 1 interval-censored)
+
+    A common case is to have a mix of uncensored observations and censored
+    observations that are all right-censored (or all left-censored). For
+    example, consider an experiment in which six devices are started at
+    various times and left running until they fail.  Assume that time is
+    measured in hours, and the experiment is stopped after 30 hours, even
+    if all the devices have not failed by that time.  We might end up with
+    data such as this::
+
+        Device  Start-time  Fail-time  Time-to-failure
+           1         0         13           13
+           2         2         24           22
+           3         5         22           17
+           4         8         23           15
+           5        10        ***          >20
+           6        12        ***          >18
+
+    Two of the devices had not failed when the experiment was stopped;
+    the observations of the time-to-failure for these two devices are
+    right-censored.  We can represent this data with
+
+    >>> data = CensoredData(uncensored=[13, 22, 17, 15], right=[20, 18])
+    >>> print(data)
+    CensoredData(6 values: 4 not censored, 2 right-censored)
+
+    Alternatively, we can use the method `CensoredData.right_censored` to
+    create a representation of this data.  The time-to-failure observations
+    are put the list ``ttf``.  The ``censored`` list indicates which values
+    in ``ttf`` are censored.
+
+    >>> ttf = [13, 22, 17, 15, 20, 18]
+    >>> censored = [False, False, False, False, True, True]
+
+    Pass these lists to `CensoredData.right_censored` to create an
+    instance of `CensoredData`.
+
+    >>> data = CensoredData.right_censored(ttf, censored)
+    >>> print(data)
+    CensoredData(6 values: 4 not censored, 2 right-censored)
+
+    If the input data is interval censored and already stored in two
+    arrays, one holding the low end of the intervals and another
+    holding the high ends, the class method ``interval_censored`` can
+    be used to create the `CensoredData` instance.
+
+    This example creates an instance with four interval-censored values.
+    The intervals are [10, 11], [0.5, 1], [2, 3], and [12.5, 13.5].
+
+    >>> a = [10, 0.5, 2, 12.5]  # Low ends of the intervals
+    >>> b = [11, 1.0, 3, 13.5]  # High ends of the intervals
+    >>> data = CensoredData.interval_censored(low=a, high=b)
+    >>> print(data)
+    CensoredData(4 values: 0 not censored, 4 interval-censored)
+
+    Finally, we create and censor some data from the `weibull_min`
+    distribution, and then fit `weibull_min` to that data. We'll assume
+    that the location parameter is known to be 0.
+
+    >>> from scipy.stats import weibull_min
+    >>> rng = np.random.default_rng()
+
+    Create the random data set.
+
+    >>> x = weibull_min.rvs(2.5, loc=0, scale=30, size=250, random_state=rng)
+    >>> x[x > 40] = 40  # Right-censor values greater or equal to 40.
+
+    Create the `CensoredData` instance with the `right_censored` method.
+    The censored values are those where the value is 40.
+
+    >>> data = CensoredData.right_censored(x, x == 40)
+    >>> print(data)
+    CensoredData(250 values: 215 not censored, 35 right-censored)
+
+    35 values have been right-censored.
+
+    Fit `weibull_min` to the censored data.  We expect to shape and scale
+    to be approximately 2.5 and 30, respectively.
+
+    >>> weibull_min.fit(data, floc=0)
+    (2.3575922823897315, 0, 30.40650074451254)
+
+    """
+
+    def __init__(self, uncensored=None, *, left=None, right=None,
+                 interval=None):
+        if uncensored is None:
+            uncensored = []
+        if left is None:
+            left = []
+        if right is None:
+            right = []
+        if interval is None:
+            interval = np.empty((0, 2))
+
+        _validate_1d(uncensored, 'uncensored')
+        _validate_1d(left, 'left')
+        _validate_1d(right, 'right')
+        uncensored2, left2, right2, interval2 = _validate_interval(interval)
+
+        self._uncensored = np.concatenate((uncensored, uncensored2))
+        self._left = np.concatenate((left, left2))
+        self._right = np.concatenate((right, right2))
+        # Note that by construction, the private attribute _interval
+        # will be a 2D array that contains only finite values representing
+        # intervals with nonzero but finite length.
+        self._interval = interval2
+
+    def __repr__(self):
+        uncensored_str = " ".join(np.array_repr(self._uncensored).split())
+        left_str = " ".join(np.array_repr(self._left).split())
+        right_str = " ".join(np.array_repr(self._right).split())
+        interval_str = " ".join(np.array_repr(self._interval).split())
+        return (f"CensoredData(uncensored={uncensored_str}, left={left_str}, "
+                f"right={right_str}, interval={interval_str})")
+
+    def __str__(self):
+        num_nc = len(self._uncensored)
+        num_lc = len(self._left)
+        num_rc = len(self._right)
+        num_ic = len(self._interval)
+        n = num_nc + num_lc + num_rc + num_ic
+        parts = [f'{num_nc} not censored']
+        if num_lc > 0:
+            parts.append(f'{num_lc} left-censored')
+        if num_rc > 0:
+            parts.append(f'{num_rc} right-censored')
+        if num_ic > 0:
+            parts.append(f'{num_ic} interval-censored')
+        return f'CensoredData({n} values: ' + ', '.join(parts) + ')'
+
+    # This is not a complete implementation of the arithmetic operators.
+    # All we need is subtracting a scalar and dividing by a scalar.
+
+    def __sub__(self, other):
+        return CensoredData(uncensored=self._uncensored - other,
+                            left=self._left - other,
+                            right=self._right - other,
+                            interval=self._interval - other)
+
+    def __truediv__(self, other):
+        return CensoredData(uncensored=self._uncensored / other,
+                            left=self._left / other,
+                            right=self._right / other,
+                            interval=self._interval / other)
+
+    def __len__(self):
+        """
+        The number of values (censored and not censored).
+        """
+        return (len(self._uncensored) + len(self._left) + len(self._right)
+                + len(self._interval))
+
+    def num_censored(self):
+        """
+        Number of censored values.
+        """
+        return len(self._left) + len(self._right) + len(self._interval)
+
+    @classmethod
+    def right_censored(cls, x, censored):
+        """
+        Create a `CensoredData` instance of right-censored data.
+
+        Parameters
+        ----------
+        x : array_like
+            `x` is the array of observed data or measurements.
+            `x` must be a one-dimensional sequence of finite numbers.
+        censored : array_like of bool
+            `censored` must be a one-dimensional sequence of boolean
+            values.  If ``censored[k]`` is True, the corresponding value
+            in `x` is right-censored.  That is, the value ``x[k]``
+            is the lower bound of the true (but unknown) value.
+
+        Returns
+        -------
+        data : `CensoredData`
+            An instance of `CensoredData` that represents the
+            collection of uncensored and right-censored values.
+
+        Examples
+        --------
+        >>> from scipy.stats import CensoredData
+
+        Two uncensored values (4 and 10) and two right-censored values
+        (24 and 25).
+
+        >>> data = CensoredData.right_censored([4, 10, 24, 25],
+        ...                                    [False, False, True, True])
+        >>> data
+        CensoredData(uncensored=array([ 4., 10.]),
+        left=array([], dtype=float64), right=array([24., 25.]),
+        interval=array([], shape=(0, 2), dtype=float64))
+        >>> print(data)
+        CensoredData(4 values: 2 not censored, 2 right-censored)
+        """
+        x, censored = _validate_x_censored(x, censored)
+        return cls(uncensored=x[~censored], right=x[censored])
+
+    @classmethod
+    def left_censored(cls, x, censored):
+        """
+        Create a `CensoredData` instance of left-censored data.
+
+        Parameters
+        ----------
+        x : array_like
+            `x` is the array of observed data or measurements.
+            `x` must be a one-dimensional sequence of finite numbers.
+        censored : array_like of bool
+            `censored` must be a one-dimensional sequence of boolean
+            values.  If ``censored[k]`` is True, the corresponding value
+            in `x` is left-censored.  That is, the value ``x[k]``
+            is the upper bound of the true (but unknown) value.
+
+        Returns
+        -------
+        data : `CensoredData`
+            An instance of `CensoredData` that represents the
+            collection of uncensored and left-censored values.
+
+        Examples
+        --------
+        >>> from scipy.stats import CensoredData
+
+        Two uncensored values (0.12 and 0.033) and two left-censored values
+        (both 1e-3).
+
+        >>> data = CensoredData.left_censored([0.12, 0.033, 1e-3, 1e-3],
+        ...                                   [False, False, True, True])
+        >>> data
+        CensoredData(uncensored=array([0.12 , 0.033]),
+        left=array([0.001, 0.001]), right=array([], dtype=float64),
+        interval=array([], shape=(0, 2), dtype=float64))
+        >>> print(data)
+        CensoredData(4 values: 2 not censored, 2 left-censored)
+        """
+        x, censored = _validate_x_censored(x, censored)
+        return cls(uncensored=x[~censored], left=x[censored])
+
+    @classmethod
+    def interval_censored(cls, low, high):
+        """
+        Create a `CensoredData` instance of interval-censored data.
+
+        This method is useful when all the data is interval-censored, and
+        the low and high ends of the intervals are already stored in
+        separate one-dimensional arrays.
+
+        Parameters
+        ----------
+        low : array_like
+            The one-dimensional array containing the low ends of the
+            intervals.
+        high : array_like
+            The one-dimensional array containing the high ends of the
+            intervals.
+
+        Returns
+        -------
+        data : `CensoredData`
+            An instance of `CensoredData` that represents the
+            collection of censored values.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> from scipy.stats import CensoredData
+
+        ``a`` and ``b`` are the low and high ends of a collection of
+        interval-censored values.
+
+        >>> a = [0.5, 2.0, 3.0, 5.5]
+        >>> b = [1.0, 2.5, 3.5, 7.0]
+        >>> data = CensoredData.interval_censored(low=a, high=b)
+        >>> print(data)
+        CensoredData(4 values: 0 not censored, 4 interval-censored)
+        """
+        _validate_1d(low, 'low', allow_inf=True)
+        _validate_1d(high, 'high', allow_inf=True)
+        if len(low) != len(high):
+            raise ValueError('`low` and `high` must have the same length.')
+        interval = np.column_stack((low, high))
+        uncensored, left, right, interval = _validate_interval(interval)
+        return cls(uncensored=uncensored, left=left, right=right,
+                   interval=interval)
+
+    def _uncensor(self):
+        """
+        This function is used when a non-censored version of the data
+        is needed to create a rough estimate of the parameters of a
+        distribution via the method of moments or some similar method.
+        The data is "uncensored" by taking the given endpoints as the
+        data for the left- or right-censored data, and the mean for the
+        interval-censored data.
+        """
+        data = np.concatenate((self._uncensored, self._left, self._right,
+                               self._interval.mean(axis=1)))
+        return data
+
+    def _supported(self, a, b):
+        """
+        Return a subset of self containing the values that are in
+        (or overlap with) the interval (a, b).
+        """
+        uncensored = self._uncensored
+        uncensored = uncensored[(a < uncensored) & (uncensored < b)]
+        left = self._left
+        left = left[a < left]
+        right = self._right
+        right = right[right < b]
+        interval = self._interval
+        interval = interval[(a < interval[:, 1]) & (interval[:, 0] < b)]
+        return CensoredData(uncensored, left=left, right=right,
+                            interval=interval)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/stats/_common.py

@@ -0,0 +1,5 @@
+from collections import namedtuple
+
+
+ConfidenceInterval = namedtuple("ConfidenceInterval", ["low", "high"])
+ConfidenceInterval. __doc__ = "Class for confidence intervals."

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/stats/_constants.py

@@ -0,0 +1,42 @@
+"""
+Statistics-related constants.
+
+"""
+import numpy as np
+
+
+# The smallest representable positive number such that 1.0 + _EPS != 1.0.
+_EPS = np.finfo(float).eps
+
+# The largest [in magnitude] usable floating value.
+_XMAX = np.finfo(float).max
+
+# The log of the largest usable floating value; useful for knowing
+# when exp(something) will overflow
+_LOGXMAX = np.log(_XMAX)
+
+# The smallest [in magnitude] usable (i.e. not subnormal) double precision
+# floating value.
+_XMIN = np.finfo(float).tiny
+
+# The log of the smallest [in magnitude] usable (i.e not subnormal)
+# double precision floating value.
+_LOGXMIN = np.log(_XMIN)
+
+# -special.psi(1)
+_EULER = 0.577215664901532860606512090082402431042
+
+# special.zeta(3, 1)  Apery's constant
+_ZETA3 = 1.202056903159594285399738161511449990765
+
+# sqrt(pi)
+_SQRT_PI = 1.772453850905516027298167483341145182798
+
+# sqrt(2/pi)
+_SQRT_2_OVER_PI = 0.7978845608028654
+
+# log(pi)
+_LOG_PI = 1.1447298858494002
+
+# log(sqrt(2/pi))
+_LOG_SQRT_2_OVER_PI = -0.22579135264472744

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/stats/_correlation.py

@@ -0,0 +1,210 @@
+import numpy as np
+from scipy import stats
+from scipy.stats._stats_py import _SimpleNormal, SignificanceResult, _get_pvalue
+from scipy.stats._axis_nan_policy import _axis_nan_policy_factory
+
+
+__all__ = ['chatterjeexi']
+
+
+# TODO:
+# - Adjust to respect dtype
+
+
+def _xi_statistic(x, y, y_continuous):
+    # Compute xi correlation statistic
+
+    # `axis=-1` is guaranteed by _axis_nan_policy decorator
+    n = x.shape[-1]
+
+    # "Rearrange the data as (X(1), Y(1)), . . . ,(X(n), Y(n))
+    # such that X(1) ≤ ··· ≤ X(n)"
+    j = np.argsort(x, axis=-1)
+    j, y = np.broadcast_arrays(j, y)
+    y = np.take_along_axis(y, j, axis=-1)
+
+    # "Let ri be the rank of Y(i), that is, the number of j such that Y(j) ≤ Y(i)"
+    r = stats.rankdata(y, method='max', axis=-1)
+    # " additionally define li to be the number of j such that Y(j) ≥ Y(i)"
+    # Could probably compute this from r, but that can be an enhancement
+    l = stats.rankdata(-y, method='max', axis=-1)
+
+    num = np.sum(np.abs(np.diff(r, axis=-1)), axis=-1)
+    if y_continuous:  # [1] Eq. 1.1
+        statistic = 1 - 3 * num / (n ** 2 - 1)
+    else:  # [1] Eq. 1.2
+        den = 2 * np.sum((n - l) * l, axis=-1)
+        statistic = 1 - n * num / den
+
+    return statistic, r, l
+
+
+def _xi_std(r, l, y_continuous):
+    # Compute asymptotic standard deviation of xi under null hypothesis of independence
+
+    # `axis=-1` is guaranteed by _axis_nan_policy decorator
+    n = np.float64(r.shape[-1])
+
+    # "Suppose that X and Y are independent and Y is continuous. Then
+    # √n·ξn(X, Y) → N(0, 2/5) in distribution as n → ∞"
+    if y_continuous:  # [1] Theorem 2.1
+        return np.sqrt(2 / 5) / np.sqrt(n)
+
+    # "Suppose that X and Y are independent. Then √n·ξn(X, Y)
+    # converges to N(0, τ²) in distribution as n → ∞
+    # [1] Eq. 2.2 and surrounding math
+    i = np.arange(1, n + 1)
+    u = np.sort(r, axis=-1)
+    v = np.cumsum(u, axis=-1)
+    an = 1 / n**4 * np.sum((2*n - 2*i + 1) * u**2, axis=-1)
+    bn = 1 / n**5 * np.sum((v + (n - i)*u)**2, axis=-1)
+    cn = 1 / n**3 * np.sum((2*n - 2*i + 1) * u, axis=-1)
+    dn = 1 / n**3 * np.sum((l * (n - l)), axis=-1)
+    tau2 = (an - 2*bn + cn**2) / dn**2
+
+    return np.sqrt(tau2) / np.sqrt(n)
+
+
+def _chatterjeexi_iv(y_continuous, method):
+    # Input validation for `chatterjeexi`
+    # x, y, `axis` input validation taken care of by decorator
+
+    if y_continuous not in {True, False}:
+        raise ValueError('`y_continuous` must be boolean.')
+
+    if not isinstance(method, stats.PermutationMethod):
+        method = method.lower()
+        message = "`method` must be 'asymptotic' or a `PermutationMethod` instance."
+        if method != 'asymptotic':
+            raise ValueError(message)
+
+    return y_continuous, method
+
+
+def _unpack(res):
+    return res.statistic, res.pvalue
+
+
+@_axis_nan_policy_factory(SignificanceResult, paired=True, n_samples=2,
+                          result_to_tuple=_unpack, n_outputs=2, too_small=1)
+def chatterjeexi(x, y, *, axis=0, y_continuous=False, method='asymptotic'):
+    r"""Compute the xi correlation and perform a test of independence
+
+    The xi correlation coefficient is a measure of association between two
+    variables; the value tends to be close to zero when the variables are
+    independent and close to 1 when there is a strong association. Unlike
+    other correlation coefficients, the xi correlation is effective even
+    when the association is not monotonic.
+
+    Parameters
+    ----------
+    x, y : array-like
+        The samples: corresponding observations of the independent and
+        dependent variable. The (N-d) arrays must be broadcastable.
+    axis : int, default: 0
+        Axis along which to perform the test.
+    method : 'asymptotic' or `PermutationMethod` instance, optional
+        Selects the method used to calculate the *p*-value.
+        Default is 'asymptotic'. The following options are available.
+
+        * ``'asymptotic'``: compares the standardized test statistic
+          against the normal distribution.
+        * `PermutationMethod` instance. In this case, the p-value
+          is computed using `permutation_test` with the provided
+          configuration options and other appropriate settings.
+
+    y_continuous : bool, default: False
+        Whether `y` is assumed to be drawn from a continuous distribution.
+        If `y` is drawn from a continuous distribution, results are valid
+        whether this is assumed or not, but enabling this assumption will
+        result in faster computation and typically produce similar results.
+
+    Returns
+    -------
+    res : SignificanceResult
+        An object containing attributes:
+
+        statistic : float
+            The xi correlation statistic.
+        pvalue : float
+            The associated *p*-value: the probability of a statistic at least as
+            high as the observed value under the null hypothesis of independence.
+
+    See Also
+    --------
+    scipy.stats.pearsonr, scipy.stats.spearmanr, scipy.stats.kendalltau
+
+    Notes
+    -----
+    There is currently no special handling of ties in `x`; they are broken arbitrarily
+    by the implementation.
+
+    [1]_ notes that the statistic is not symmetric in `x` and `y` *by design*:
+    "...we may want to understand if :math:`Y` is a function :math:`X`, and not just
+    if one of the variables is a function of the other." See [1]_ Remark 1.
+
+    References
+    ----------
+    .. [1] Chatterjee, Sourav. "A new coefficient of correlation." Journal of
+           the American Statistical Association 116.536 (2021): 2009-2022.
+           :doi:`10.1080/01621459.2020.1758115`.
+
+    Examples
+    --------
+    Generate perfectly correlated data, and observe that the xi correlation is
+    nearly 1.0.
+
+    >>> import numpy as np
+    >>> from scipy import stats
+    >>> rng = np.random.default_rng(348932549825235)
+    >>> x = rng.uniform(0, 10, size=100)
+    >>> y = np.sin(x)
+    >>> res = stats.chatterjeexi(x, y)
+    >>> res.statistic
+    np.float64(0.9012901290129013)
+
+    The probability of observing such a high value of the statistic under the
+    null hypothesis of independence is very low.
+
+    >>> res.pvalue
+    np.float64(2.2206974648177804e-46)
+
+    As noise is introduced, the correlation coefficient decreases.
+
+    >>> noise = rng.normal(scale=[[0.1], [0.5], [1]], size=(3, 100))
+    >>> res = stats.chatterjeexi(x, y + noise, axis=-1)
+    >>> res.statistic
+    array([0.79507951, 0.41824182, 0.16651665])
+
+    Because the distribution of `y` is continuous, it is valid to pass
+    ``y_continuous=True``. The statistic is identical, and the p-value
+    (not shown) is only slightly different.
+
+    >>> stats.chatterjeexi(x, y + noise, y_continuous=True, axis=-1).statistic
+    array([0.79507951, 0.41824182, 0.16651665])
+
+    """
+    # x, y, `axis` input validation taken care of by decorator
+    # In fact, `axis` is guaranteed to be -1
+    y_continuous, method = _chatterjeexi_iv(y_continuous, method)
+
+    # A highly negative statistic is possible, e.g.
+    # x = np.arange(100.), y = (x % 2 == 0)
+    # Unclear whether we should expose `alternative`, though.
+    alternative = 'greater'
+
+    if method == 'asymptotic':
+        xi, r, l = _xi_statistic(x, y, y_continuous)
+        std = _xi_std(r, l, y_continuous)
+        norm = _SimpleNormal()
+        pvalue = _get_pvalue(xi / std, norm, alternative=alternative)
+    elif isinstance(method, stats.PermutationMethod):
+        res = stats.permutation_test(
+            # Could be faster if we just permuted the ranks; for now, keep it simple.
+            data=(y,), statistic=lambda y, axis: _xi_statistic(x, y, y_continuous)[0],
+            alternative=alternative, permutation_type='pairings', **method._asdict(),
+            axis=-1)  # `axis=-1` is guaranteed by _axis_nan_policy decorator
+
+        xi, pvalue = res.statistic, res.pvalue
+
+    return SignificanceResult(xi, pvalue)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/stats/_covariance.py

@@ -0,0 +1,633 @@
+from functools import cached_property
+
+import numpy as np
+from scipy import linalg
+from scipy.stats import _multivariate
+
+
+__all__ = ["Covariance"]
+
+
+class Covariance:
+    """
+    Representation of a covariance matrix
+
+    Calculations involving covariance matrices (e.g. data whitening,
+    multivariate normal function evaluation) are often performed more
+    efficiently using a decomposition of the covariance matrix instead of the
+    covariance matrix itself. This class allows the user to construct an
+    object representing a covariance matrix using any of several
+    decompositions and perform calculations using a common interface.
+
+    .. note::
+
+        The `Covariance` class cannot be instantiated directly. Instead, use
+        one of the factory methods (e.g. `Covariance.from_diagonal`).
+
+    Examples
+    --------
+    The `Covariance` class is used by calling one of its
+    factory methods to create a `Covariance` object, then pass that
+    representation of the `Covariance` matrix as a shape parameter of a
+    multivariate distribution.
+
+    For instance, the multivariate normal distribution can accept an array
+    representing a covariance matrix:
+
+    >>> from scipy import stats
+    >>> import numpy as np
+    >>> d = [1, 2, 3]
+    >>> A = np.diag(d)  # a diagonal covariance matrix
+    >>> x = [4, -2, 5]  # a point of interest
+    >>> dist = stats.multivariate_normal(mean=[0, 0, 0], cov=A)
+    >>> dist.pdf(x)
+    4.9595685102808205e-08
+
+    but the calculations are performed in a very generic way that does not
+    take advantage of any special properties of the covariance matrix. Because
+    our covariance matrix is diagonal, we can use ``Covariance.from_diagonal``
+    to create an object representing the covariance matrix, and
+    `multivariate_normal` can use this to compute the probability density
+    function more efficiently.
+
+    >>> cov = stats.Covariance.from_diagonal(d)
+    >>> dist = stats.multivariate_normal(mean=[0, 0, 0], cov=cov)
+    >>> dist.pdf(x)
+    4.9595685102808205e-08
+
+    """
+    def __init__(self):
+        message = ("The `Covariance` class cannot be instantiated directly. "
+                   "Please use one of the factory methods "
+                   "(e.g. `Covariance.from_diagonal`).")
+        raise NotImplementedError(message)
+
+    @staticmethod
+    def from_diagonal(diagonal):
+        r"""
+        Return a representation of a covariance matrix from its diagonal.
+
+        Parameters
+        ----------
+        diagonal : array_like
+            The diagonal elements of a diagonal matrix.
+
+        Notes
+        -----
+        Let the diagonal elements of a diagonal covariance matrix :math:`D` be
+        stored in the vector :math:`d`.
+
+        When all elements of :math:`d` are strictly positive, whitening of a
+        data point :math:`x` is performed by computing
+        :math:`x \cdot d^{-1/2}`, where the inverse square root can be taken
+        element-wise.
+        :math:`\log\det{D}` is calculated as :math:`-2 \sum(\log{d})`,
+        where the :math:`\log` operation is performed element-wise.
+
+        This `Covariance` class supports singular covariance matrices. When
+        computing ``_log_pdet``, non-positive elements of :math:`d` are
+        ignored. Whitening is not well defined when the point to be whitened
+        does not lie in the span of the columns of the covariance matrix. The
+        convention taken here is to treat the inverse square root of
+        non-positive elements of :math:`d` as zeros.
+
+        Examples
+        --------
+        Prepare a symmetric positive definite covariance matrix ``A`` and a
+        data point ``x``.
+
+        >>> import numpy as np
+        >>> from scipy import stats
+        >>> rng = np.random.default_rng()
+        >>> n = 5
+        >>> A = np.diag(rng.random(n))
+        >>> x = rng.random(size=n)
+
+        Extract the diagonal from ``A`` and create the `Covariance` object.
+
+        >>> d = np.diag(A)
+        >>> cov = stats.Covariance.from_diagonal(d)
+
+        Compare the functionality of the `Covariance` object against a
+        reference implementations.
+
+        >>> res = cov.whiten(x)
+        >>> ref = np.diag(d**-0.5) @ x
+        >>> np.allclose(res, ref)
+        True
+        >>> res = cov.log_pdet
+        >>> ref = np.linalg.slogdet(A)[-1]
+        >>> np.allclose(res, ref)
+        True
+
+        """
+        return CovViaDiagonal(diagonal)
+
+    @staticmethod
+    def from_precision(precision, covariance=None):
+        r"""
+        Return a representation of a covariance from its precision matrix.
+
+        Parameters
+        ----------
+        precision : array_like
+            The precision matrix; that is, the inverse of a square, symmetric,
+            positive definite covariance matrix.
+        covariance : array_like, optional
+            The square, symmetric, positive definite covariance matrix. If not
+            provided, this may need to be calculated (e.g. to evaluate the
+            cumulative distribution function of
+            `scipy.stats.multivariate_normal`) by inverting `precision`.
+
+        Notes
+        -----
+        Let the covariance matrix be :math:`A`, its precision matrix be
+        :math:`P = A^{-1}`, and :math:`L` be the lower Cholesky factor such
+        that :math:`L L^T = P`.
+        Whitening of a data point :math:`x` is performed by computing
+        :math:`x^T L`. :math:`\log\det{A}` is calculated as
+        :math:`-2tr(\log{L})`, where the :math:`\log` operation is performed
+        element-wise.
+
+        This `Covariance` class does not support singular covariance matrices
+        because the precision matrix does not exist for a singular covariance
+        matrix.
+
+        Examples
+        --------
+        Prepare a symmetric positive definite precision matrix ``P`` and a
+        data point ``x``. (If the precision matrix is not already available,
+        consider the other factory methods of the `Covariance` class.)
+
+        >>> import numpy as np
+        >>> from scipy import stats
+        >>> rng = np.random.default_rng()
+        >>> n = 5
+        >>> P = rng.random(size=(n, n))
+        >>> P = P @ P.T  # a precision matrix must be positive definite
+        >>> x = rng.random(size=n)
+
+        Create the `Covariance` object.
+
+        >>> cov = stats.Covariance.from_precision(P)
+
+        Compare the functionality of the `Covariance` object against
+        reference implementations.
+
+        >>> res = cov.whiten(x)
+        >>> ref = x @ np.linalg.cholesky(P)
+        >>> np.allclose(res, ref)
+        True
+        >>> res = cov.log_pdet
+        >>> ref = -np.linalg.slogdet(P)[-1]
+        >>> np.allclose(res, ref)
+        True
+
+        """
+        return CovViaPrecision(precision, covariance)
+
+    @staticmethod
+    def from_cholesky(cholesky):
+        r"""
+        Representation of a covariance provided via the (lower) Cholesky factor
+
+        Parameters
+        ----------
+        cholesky : array_like
+            The lower triangular Cholesky factor of the covariance matrix.
+
+        Notes
+        -----
+        Let the covariance matrix be :math:`A` and :math:`L` be the lower
+        Cholesky factor such that :math:`L L^T = A`.
+        Whitening of a data point :math:`x` is performed by computing
+        :math:`L^{-1} x`. :math:`\log\det{A}` is calculated as
+        :math:`2tr(\log{L})`, where the :math:`\log` operation is performed
+        element-wise.
+
+        This `Covariance` class does not support singular covariance matrices
+        because the Cholesky decomposition does not exist for a singular
+        covariance matrix.
+
+        Examples
+        --------
+        Prepare a symmetric positive definite covariance matrix ``A`` and a
+        data point ``x``.
+
+        >>> import numpy as np
+        >>> from scipy import stats
+        >>> rng = np.random.default_rng()
+        >>> n = 5
+        >>> A = rng.random(size=(n, n))
+        >>> A = A @ A.T  # make the covariance symmetric positive definite
+        >>> x = rng.random(size=n)
+
+        Perform the Cholesky decomposition of ``A`` and create the
+        `Covariance` object.
+
+        >>> L = np.linalg.cholesky(A)
+        >>> cov = stats.Covariance.from_cholesky(L)
+
+        Compare the functionality of the `Covariance` object against
+        reference implementation.
+
+        >>> from scipy.linalg import solve_triangular
+        >>> res = cov.whiten(x)
+        >>> ref = solve_triangular(L, x, lower=True)
+        >>> np.allclose(res, ref)
+        True
+        >>> res = cov.log_pdet
+        >>> ref = np.linalg.slogdet(A)[-1]
+        >>> np.allclose(res, ref)
+        True
+
+        """
+        return CovViaCholesky(cholesky)
+
+    @staticmethod
+    def from_eigendecomposition(eigendecomposition):
+        r"""
+        Representation of a covariance provided via eigendecomposition
+
+        Parameters
+        ----------
+        eigendecomposition : sequence
+            A sequence (nominally a tuple) containing the eigenvalue and
+            eigenvector arrays as computed by `scipy.linalg.eigh` or
+            `numpy.linalg.eigh`.
+
+        Notes
+        -----
+        Let the covariance matrix be :math:`A`, let :math:`V` be matrix of
+        eigenvectors, and let :math:`W` be the diagonal matrix of eigenvalues
+        such that `V W V^T = A`.
+
+        When all of the eigenvalues are strictly positive, whitening of a
+        data point :math:`x` is performed by computing
+        :math:`x^T (V W^{-1/2})`, where the inverse square root can be taken
+        element-wise.
+        :math:`\log\det{A}` is calculated as  :math:`tr(\log{W})`,
+        where the :math:`\log` operation is performed element-wise.
+
+        This `Covariance` class supports singular covariance matrices. When
+        computing ``_log_pdet``, non-positive eigenvalues are ignored.
+        Whitening is not well defined when the point to be whitened
+        does not lie in the span of the columns of the covariance matrix. The
+        convention taken here is to treat the inverse square root of
+        non-positive eigenvalues as zeros.
+
+        Examples
+        --------
+        Prepare a symmetric positive definite covariance matrix ``A`` and a
+        data point ``x``.
+
+        >>> import numpy as np
+        >>> from scipy import stats
+        >>> rng = np.random.default_rng()
+        >>> n = 5
+        >>> A = rng.random(size=(n, n))
+        >>> A = A @ A.T  # make the covariance symmetric positive definite
+        >>> x = rng.random(size=n)
+
+        Perform the eigendecomposition of ``A`` and create the `Covariance`
+        object.
+
+        >>> w, v = np.linalg.eigh(A)
+        >>> cov = stats.Covariance.from_eigendecomposition((w, v))
+
+        Compare the functionality of the `Covariance` object against
+        reference implementations.
+
+        >>> res = cov.whiten(x)
+        >>> ref = x @ (v @ np.diag(w**-0.5))
+        >>> np.allclose(res, ref)
+        True
+        >>> res = cov.log_pdet
+        >>> ref = np.linalg.slogdet(A)[-1]
+        >>> np.allclose(res, ref)
+        True
+
+        """
+        return CovViaEigendecomposition(eigendecomposition)
+
+    def whiten(self, x):
+        """
+        Perform a whitening transformation on data.
+
+        "Whitening" ("white" as in "white noise", in which each frequency has
+        equal magnitude) transforms a set of random variables into a new set of
+        random variables with unit-diagonal covariance. When a whitening
+        transform is applied to a sample of points distributed according to
+        a multivariate normal distribution with zero mean, the covariance of
+        the transformed sample is approximately the identity matrix.
+
+        Parameters
+        ----------
+        x : array_like
+            An array of points. The last dimension must correspond with the
+            dimensionality of the space, i.e., the number of columns in the
+            covariance matrix.
+
+        Returns
+        -------
+        x_ : array_like
+            The transformed array of points.
+
+        References
+        ----------
+        .. [1] "Whitening Transformation". Wikipedia.
+               https://en.wikipedia.org/wiki/Whitening_transformation
+        .. [2] Novak, Lukas, and Miroslav Vorechovsky. "Generalization of
+               coloring linear transformation". Transactions of VSB 18.2
+               (2018): 31-35. :doi:`10.31490/tces-2018-0013`
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> from scipy import stats
+        >>> rng = np.random.default_rng()
+        >>> n = 3
+        >>> A = rng.random(size=(n, n))
+        >>> cov_array = A @ A.T  # make matrix symmetric positive definite
+        >>> precision = np.linalg.inv(cov_array)
+        >>> cov_object = stats.Covariance.from_precision(precision)
+        >>> x = rng.multivariate_normal(np.zeros(n), cov_array, size=(10000))
+        >>> x_ = cov_object.whiten(x)
+        >>> np.cov(x_, rowvar=False)  # near-identity covariance
+        array([[0.97862122, 0.00893147, 0.02430451],
+               [0.00893147, 0.96719062, 0.02201312],
+               [0.02430451, 0.02201312, 0.99206881]])
+
+        """
+        return self._whiten(np.asarray(x))
+
+    def colorize(self, x):
+        """
+        Perform a colorizing transformation on data.
+
+        "Colorizing" ("color" as in "colored noise", in which different
+        frequencies may have different magnitudes) transforms a set of
+        uncorrelated random variables into a new set of random variables with
+        the desired covariance. When a coloring transform is applied to a
+        sample of points distributed according to a multivariate normal
+        distribution with identity covariance and zero mean, the covariance of
+        the transformed sample is approximately the covariance matrix used
+        in the coloring transform.
+
+        Parameters
+        ----------
+        x : array_like
+            An array of points. The last dimension must correspond with the
+            dimensionality of the space, i.e., the number of columns in the
+            covariance matrix.
+
+        Returns
+        -------
+        x_ : array_like
+            The transformed array of points.
+
+        References
+        ----------
+        .. [1] "Whitening Transformation". Wikipedia.
+               https://en.wikipedia.org/wiki/Whitening_transformation
+        .. [2] Novak, Lukas, and Miroslav Vorechovsky. "Generalization of
+               coloring linear transformation". Transactions of VSB 18.2
+               (2018): 31-35. :doi:`10.31490/tces-2018-0013`
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> from scipy import stats
+        >>> rng = np.random.default_rng(1638083107694713882823079058616272161)
+        >>> n = 3
+        >>> A = rng.random(size=(n, n))
+        >>> cov_array = A @ A.T  # make matrix symmetric positive definite
+        >>> cholesky = np.linalg.cholesky(cov_array)
+        >>> cov_object = stats.Covariance.from_cholesky(cholesky)
+        >>> x = rng.multivariate_normal(np.zeros(n), np.eye(n), size=(10000))
+        >>> x_ = cov_object.colorize(x)
+        >>> cov_data = np.cov(x_, rowvar=False)
+        >>> np.allclose(cov_data, cov_array, rtol=3e-2)
+        True
+        """
+        return self._colorize(np.asarray(x))
+
+    @property
+    def log_pdet(self):
+        """
+        Log of the pseudo-determinant of the covariance matrix
+        """
+        return np.array(self._log_pdet, dtype=float)[()]
+
+    @property
+    def rank(self):
+        """
+        Rank of the covariance matrix
+        """
+        return np.array(self._rank, dtype=int)[()]
+
+    @property
+    def covariance(self):
+        """
+        Explicit representation of the covariance matrix
+        """
+        return self._covariance
+
+    @property
+    def shape(self):
+        """
+        Shape of the covariance array
+        """
+        return self._shape
+
+    def _validate_matrix(self, A, name):
+        A = np.atleast_2d(A)
+        m, n = A.shape[-2:]
+        if m != n or A.ndim != 2 or not (np.issubdtype(A.dtype, np.integer) or
+                                         np.issubdtype(A.dtype, np.floating)):
+            message = (f"The input `{name}` must be a square, "
+                       "two-dimensional array of real numbers.")
+            raise ValueError(message)
+        return A
+
+    def _validate_vector(self, A, name):
+        A = np.atleast_1d(A)
+        if A.ndim != 1 or not (np.issubdtype(A.dtype, np.integer) or
+                               np.issubdtype(A.dtype, np.floating)):
+            message = (f"The input `{name}` must be a one-dimensional array "
+                       "of real numbers.")
+            raise ValueError(message)
+        return A
+
+
+class CovViaPrecision(Covariance):
+
+    def __init__(self, precision, covariance=None):
+        precision = self._validate_matrix(precision, 'precision')
+        if covariance is not None:
+            covariance = self._validate_matrix(covariance, 'covariance')
+            message = "`precision.shape` must equal `covariance.shape`."
+            if precision.shape != covariance.shape:
+                raise ValueError(message)
+
+        self._chol_P = np.linalg.cholesky(precision)
+        self._log_pdet = -2*np.log(np.diag(self._chol_P)).sum(axis=-1)
+        self._rank = precision.shape[-1]  # must be full rank if invertible
+        self._precision = precision
+        self._cov_matrix = covariance
+        self._shape = precision.shape
+        self._allow_singular = False
+
+    def _whiten(self, x):
+        return x @ self._chol_P
+
+    @cached_property
+    def _covariance(self):
+        n = self._shape[-1]
+        return (linalg.cho_solve((self._chol_P, True), np.eye(n))
+                if self._cov_matrix is None else self._cov_matrix)
+
+    def _colorize(self, x):
+        return linalg.solve_triangular(self._chol_P.T, x.T, lower=False).T
+
+
+def _dot_diag(x, d):
+    # If d were a full diagonal matrix, x @ d would always do what we want.
+    # Special treatment is needed for n-dimensional `d` in which each row
+    # includes only the diagonal elements of a covariance matrix.
+    return x * d if x.ndim < 2 else x * np.expand_dims(d, -2)
+
+
+class CovViaDiagonal(Covariance):
+
+    def __init__(self, diagonal):
+        diagonal = self._validate_vector(diagonal, 'diagonal')
+
+        i_zero = diagonal <= 0
+        positive_diagonal = np.array(diagonal, dtype=np.float64)
+
+        positive_diagonal[i_zero] = 1  # ones don't affect determinant
+        self._log_pdet = np.sum(np.log(positive_diagonal), axis=-1)
+
+        psuedo_reciprocals = 1 / np.sqrt(positive_diagonal)
+        psuedo_reciprocals[i_zero] = 0
+
+        self._sqrt_diagonal = np.sqrt(diagonal)
+        self._LP = psuedo_reciprocals
+        self._rank = positive_diagonal.shape[-1] - i_zero.sum(axis=-1)
+        self._covariance = np.apply_along_axis(np.diag, -1, diagonal)
+        self._i_zero = i_zero
+        self._shape = self._covariance.shape
+        self._allow_singular = True
+
+    def _whiten(self, x):
+        return _dot_diag(x, self._LP)
+
+    def _colorize(self, x):
+        return _dot_diag(x, self._sqrt_diagonal)
+
+    def _support_mask(self, x):
+        """
+        Check whether x lies in the support of the distribution.
+        """
+        return ~np.any(_dot_diag(x, self._i_zero), axis=-1)
+
+
+class CovViaCholesky(Covariance):
+
+    def __init__(self, cholesky):
+        L = self._validate_matrix(cholesky, 'cholesky')
+
+        self._factor = L
+        self._log_pdet = 2*np.log(np.diag(self._factor)).sum(axis=-1)
+        self._rank = L.shape[-1]  # must be full rank for cholesky
+        self._shape = L.shape
+        self._allow_singular = False
+
+    @cached_property
+    def _covariance(self):
+        return self._factor @ self._factor.T
+
+    def _whiten(self, x):
+        res = linalg.solve_triangular(self._factor, x.T, lower=True).T
+        return res
+
+    def _colorize(self, x):
+        return x @ self._factor.T
+
+
+class CovViaEigendecomposition(Covariance):
+
+    def __init__(self, eigendecomposition):
+        eigenvalues, eigenvectors = eigendecomposition
+        eigenvalues = self._validate_vector(eigenvalues, 'eigenvalues')
+        eigenvectors = self._validate_matrix(eigenvectors, 'eigenvectors')
+        message = ("The shapes of `eigenvalues` and `eigenvectors` "
+                   "must be compatible.")
+        try:
+            eigenvalues = np.expand_dims(eigenvalues, -2)
+            eigenvectors, eigenvalues = np.broadcast_arrays(eigenvectors,
+                                                            eigenvalues)
+            eigenvalues = eigenvalues[..., 0, :]
+        except ValueError:
+            raise ValueError(message)
+
+        i_zero = eigenvalues <= 0
+        positive_eigenvalues = np.array(eigenvalues, dtype=np.float64)
+
+        positive_eigenvalues[i_zero] = 1  # ones don't affect determinant
+        self._log_pdet = np.sum(np.log(positive_eigenvalues), axis=-1)
+
+        psuedo_reciprocals = 1 / np.sqrt(positive_eigenvalues)
+        psuedo_reciprocals[i_zero] = 0
+
+        self._LP = eigenvectors * psuedo_reciprocals
+        self._LA = eigenvectors * np.sqrt(eigenvalues)
+        self._rank = positive_eigenvalues.shape[-1] - i_zero.sum(axis=-1)
+        self._w = eigenvalues
+        self._v = eigenvectors
+        self._shape = eigenvectors.shape
+        self._null_basis = eigenvectors * i_zero
+        # This is only used for `_support_mask`, not to decide whether
+        # the covariance is singular or not.
+        self._eps = _multivariate._eigvalsh_to_eps(eigenvalues) * 10**3
+        self._allow_singular = True
+
+    def _whiten(self, x):
+        return x @ self._LP
+
+    def _colorize(self, x):
+        return x @ self._LA.T
+
+    @cached_property
+    def _covariance(self):
+        return (self._v * self._w) @ self._v.T
+
+    def _support_mask(self, x):
+        """
+        Check whether x lies in the support of the distribution.
+        """
+        residual = np.linalg.norm(x @ self._null_basis, axis=-1)
+        in_support = residual < self._eps
+        return in_support
+
+
+class CovViaPSD(Covariance):
+    """
+    Representation of a covariance provided via an instance of _PSD
+    """
+
+    def __init__(self, psd):
+        self._LP = psd.U
+        self._log_pdet = psd.log_pdet
+        self._rank = psd.rank
+        self._covariance = psd._M
+        self._shape = psd._M.shape
+        self._psd = psd
+        self._allow_singular = False  # by default
+
+    def _whiten(self, x):
+        return x @ self._LP
+
+    def _support_mask(self, x):
+        return self._psd._support_mask(x)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/stats/_crosstab.py

@@ -0,0 +1,204 @@
+import numpy as np
+from scipy.sparse import coo_matrix
+from scipy._lib._bunch import _make_tuple_bunch
+
+
+CrosstabResult = _make_tuple_bunch(
+    "CrosstabResult", ["elements", "count"]
+)
+
+
+def crosstab(*args, levels=None, sparse=False):
+    """
+    Return table of counts for each possible unique combination in ``*args``.
+
+    When ``len(args) > 1``, the array computed by this function is
+    often referred to as a *contingency table* [1]_.
+
+    The arguments must be sequences with the same length.  The second return
+    value, `count`, is an integer array with ``len(args)`` dimensions.  If
+    `levels` is None, the shape of `count` is ``(n0, n1, ...)``, where ``nk``
+    is the number of unique elements in ``args[k]``.
+
+    Parameters
+    ----------
+    *args : sequences
+        A sequence of sequences whose unique aligned elements are to be
+        counted.  The sequences in args must all be the same length.
+    levels : sequence, optional
+        If `levels` is given, it must be a sequence that is the same length as
+        `args`.  Each element in `levels` is either a sequence or None.  If it
+        is a sequence, it gives the values in the corresponding sequence in
+        `args` that are to be counted.  If any value in the sequences in `args`
+        does not occur in the corresponding sequence in `levels`, that value
+        is ignored and not counted in the returned array `count`.  The default
+        value of `levels` for ``args[i]`` is ``np.unique(args[i])``
+    sparse : bool, optional
+        If True, return a sparse matrix.  The matrix will be an instance of
+        the `scipy.sparse.coo_matrix` class.  Because SciPy's sparse matrices
+        must be 2-d, only two input sequences are allowed when `sparse` is
+        True.  Default is False.
+
+    Returns
+    -------
+    res : CrosstabResult
+        An object containing the following attributes:
+
+        elements : tuple of numpy.ndarrays.
+            Tuple of length ``len(args)`` containing the arrays of elements
+            that are counted in `count`.  These can be interpreted as the
+            labels of the corresponding dimensions of `count`. If `levels` was
+            given, then if ``levels[i]`` is not None, ``elements[i]`` will
+            hold the values given in ``levels[i]``.
+        count : numpy.ndarray or scipy.sparse.coo_matrix
+            Counts of the unique elements in ``zip(*args)``, stored in an
+            array. Also known as a *contingency table* when ``len(args) > 1``.
+
+    See Also
+    --------
+    numpy.unique
+
+    Notes
+    -----
+    .. versionadded:: 1.7.0
+
+    References
+    ----------
+    .. [1] "Contingency table", http://en.wikipedia.org/wiki/Contingency_table
+
+    Examples
+    --------
+    >>> from scipy.stats.contingency import crosstab
+
+    Given the lists `a` and `x`, create a contingency table that counts the
+    frequencies of the corresponding pairs.
+
+    >>> a = ['A', 'B', 'A', 'A', 'B', 'B', 'A', 'A', 'B', 'B']
+    >>> x = ['X', 'X', 'X', 'Y', 'Z', 'Z', 'Y', 'Y', 'Z', 'Z']
+    >>> res = crosstab(a, x)
+    >>> avals, xvals = res.elements
+    >>> avals
+    array(['A', 'B'], dtype='<U1')
+    >>> xvals
+    array(['X', 'Y', 'Z'], dtype='<U1')
+    >>> res.count
+    array([[2, 3, 0],
+           [1, 0, 4]])
+
+    So ``('A', 'X')`` occurs twice, ``('A', 'Y')`` occurs three times, etc.
+
+    Higher dimensional contingency tables can be created.
+
+    >>> p = [0, 0, 0, 0, 1, 1, 1, 0, 0, 1]
+    >>> res = crosstab(a, x, p)
+    >>> res.count
+    array([[[2, 0],
+            [2, 1],
+            [0, 0]],
+           [[1, 0],
+            [0, 0],
+            [1, 3]]])
+    >>> res.count.shape
+    (2, 3, 2)
+
+    The values to be counted can be set by using the `levels` argument.
+    It allows the elements of interest in each input sequence to be
+    given explicitly instead finding the unique elements of the sequence.
+
+    For example, suppose one of the arguments is an array containing the
+    answers to a survey question, with integer values 1 to 4.  Even if the
+    value 1 does not occur in the data, we want an entry for it in the table.
+
+    >>> q1 = [2, 3, 3, 2, 4, 4, 2, 3, 4, 4, 4, 3, 3, 3, 4]  # 1 does not occur.
+    >>> q2 = [4, 4, 2, 2, 2, 4, 1, 1, 2, 2, 4, 2, 2, 2, 4]  # 3 does not occur.
+    >>> options = [1, 2, 3, 4]
+    >>> res = crosstab(q1, q2, levels=(options, options))
+    >>> res.count
+    array([[0, 0, 0, 0],
+           [1, 1, 0, 1],
+           [1, 4, 0, 1],
+           [0, 3, 0, 3]])
+
+    If `levels` is given, but an element of `levels` is None, the unique values
+    of the corresponding argument are used. For example,
+
+    >>> res = crosstab(q1, q2, levels=(None, options))
+    >>> res.elements
+    [array([2, 3, 4]), [1, 2, 3, 4]]
+    >>> res.count
+    array([[1, 1, 0, 1],
+           [1, 4, 0, 1],
+           [0, 3, 0, 3]])
+
+    If we want to ignore the pairs where 4 occurs in ``q2``, we can
+    give just the values [1, 2] to `levels`, and the 4 will be ignored:
+
+    >>> res = crosstab(q1, q2, levels=(None, [1, 2]))
+    >>> res.elements
+    [array([2, 3, 4]), [1, 2]]
+    >>> res.count
+    array([[1, 1],
+           [1, 4],
+           [0, 3]])
+
+    Finally, let's repeat the first example, but return a sparse matrix:
+
+    >>> res = crosstab(a, x, sparse=True)
+    >>> res.count
+    <COOrdinate sparse matrix of dtype 'int64'
+        with 4 stored elements and shape (2, 3)>
+    >>> res.count.toarray()
+    array([[2, 3, 0],
+           [1, 0, 4]])
+
+    """
+    nargs = len(args)
+    if nargs == 0:
+        raise TypeError("At least one input sequence is required.")
+
+    len0 = len(args[0])
+    if not all(len(a) == len0 for a in args[1:]):
+        raise ValueError("All input sequences must have the same length.")
+
+    if sparse and nargs != 2:
+        raise ValueError("When `sparse` is True, only two input sequences "
+                         "are allowed.")
+
+    if levels is None:
+        # Call np.unique with return_inverse=True on each argument.
+        actual_levels, indices = zip(*[np.unique(a, return_inverse=True)
+                                       for a in args])
+    else:
+        # `levels` is not None...
+        if len(levels) != nargs:
+            raise ValueError('len(levels) must equal the number of input '
+                             'sequences')
+
+        args = [np.asarray(arg) for arg in args]
+        mask = np.zeros((nargs, len0), dtype=np.bool_)
+        inv = np.zeros((nargs, len0), dtype=np.intp)
+        actual_levels = []
+        for k, (levels_list, arg) in enumerate(zip(levels, args)):
+            if levels_list is None:
+                levels_list, inv[k, :] = np.unique(arg, return_inverse=True)
+                mask[k, :] = True
+            else:
+                q = arg == np.asarray(levels_list).reshape(-1, 1)
+                mask[k, :] = np.any(q, axis=0)
+                qnz = q.T.nonzero()
+                inv[k, qnz[0]] = qnz[1]
+            actual_levels.append(levels_list)
+
+        mask_all = mask.all(axis=0)
+        indices = tuple(inv[:, mask_all])
+
+    if sparse:
+        count = coo_matrix((np.ones(len(indices[0]), dtype=int),
+                            (indices[0], indices[1])))
+        count.sum_duplicates()
+    else:
+        shape = [len(u) for u in actual_levels]
+        count = np.zeros(shape, dtype=int)
+        np.add.at(count, indices, 1)
+
+    return CrosstabResult(actual_levels, count)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/stats/_discrete_distns.py

@@ -0,0 +1,2091 @@
+#
+# Author:  Travis Oliphant  2002-2011 with contributions from
+#          SciPy Developers 2004-2011
+#
+from functools import partial
+
+from scipy import special
+from scipy.special import entr, logsumexp, betaln, gammaln as gamln, zeta
+from scipy._lib._util import _lazywhere, rng_integers
+from scipy.interpolate import interp1d
+
+from numpy import floor, ceil, log, exp, sqrt, log1p, expm1, tanh, cosh, sinh
+
+import numpy as np
+
+from ._distn_infrastructure import (rv_discrete, get_distribution_names,
+                                    _vectorize_rvs_over_shapes,
+                                    _ShapeInfo, _isintegral,
+                                    rv_discrete_frozen)
+from ._biasedurn import (_PyFishersNCHypergeometric,
+                         _PyWalleniusNCHypergeometric,
+                         _PyStochasticLib3)
+from ._stats_pythran import _poisson_binom
+
+import scipy.special._ufuncs as scu
+
+
+
+class binom_gen(rv_discrete):
+    r"""A binomial discrete random variable.
+
+    %(before_notes)s
+
+    Notes
+    -----
+    The probability mass function for `binom` is:
+
+    .. math::
+
+       f(k) = \binom{n}{k} p^k (1-p)^{n-k}
+
+    for :math:`k \in \{0, 1, \dots, n\}`, :math:`0 \leq p \leq 1`
+
+    `binom` takes :math:`n` and :math:`p` as shape parameters,
+    where :math:`p` is the probability of a single success
+    and :math:`1-p` is the probability of a single failure.
+
+    This distribution uses routines from the Boost Math C++ library for
+    the computation of the ``pmf``, ``cdf``, ``sf``, ``ppf`` and ``isf``
+    methods. [1]_
+
+    %(after_notes)s
+
+    References
+    ----------
+    .. [1] The Boost Developers. "Boost C++ Libraries". https://www.boost.org/.
+
+    %(example)s
+
+    See Also
+    --------
+    hypergeom, nbinom, nhypergeom
+
+    """
+    def _shape_info(self):
+        return [_ShapeInfo("n", True, (0, np.inf), (True, False)),
+                _ShapeInfo("p", False, (0, 1), (True, True))]
+
+    def _rvs(self, n, p, size=None, random_state=None):
+        return random_state.binomial(n, p, size)
+
+    def _argcheck(self, n, p):
+        return (n >= 0) & _isintegral(n) & (p >= 0) & (p <= 1)
+
+    def _get_support(self, n, p):
+        return self.a, n
+
+    def _logpmf(self, x, n, p):
+        k = floor(x)
+        combiln = (gamln(n+1) - (gamln(k+1) + gamln(n-k+1)))
+        return combiln + special.xlogy(k, p) + special.xlog1py(n-k, -p)
+
+    def _pmf(self, x, n, p):
+        # binom.pmf(k) = choose(n, k) * p**k * (1-p)**(n-k)
+        return scu._binom_pmf(x, n, p)
+
+    def _cdf(self, x, n, p):
+        k = floor(x)
+        return scu._binom_cdf(k, n, p)
+
+    def _sf(self, x, n, p):
+        k = floor(x)
+        return scu._binom_sf(k, n, p)
+
+    def _isf(self, x, n, p):
+        return scu._binom_isf(x, n, p)
+
+    def _ppf(self, q, n, p):
+        return scu._binom_ppf(q, n, p)
+
+    def _stats(self, n, p, moments='mv'):
+        mu = n * p
+        var = mu - n * np.square(p)
+        g1, g2 = None, None
+        if 's' in moments:
+            pq = p - np.square(p)
+            npq_sqrt = np.sqrt(n * pq)
+            t1 = np.reciprocal(npq_sqrt)
+            t2 = (2.0 * p) / npq_sqrt
+            g1 = t1 - t2
+        if 'k' in moments:
+            pq = p - np.square(p)
+            npq = n * pq
+            t1 = np.reciprocal(npq)
+            t2 = 6.0/n
+            g2 = t1 - t2
+        return mu, var, g1, g2
+
+    def _entropy(self, n, p):
+        k = np.r_[0:n + 1]
+        vals = self._pmf(k, n, p)
+        return np.sum(entr(vals), axis=0)
+
+
+binom = binom_gen(name='binom')
+
+
+class bernoulli_gen(binom_gen):
+    r"""A Bernoulli discrete random variable.
+
+    %(before_notes)s
+
+    Notes
+    -----
+    The probability mass function for `bernoulli` is:
+
+    .. math::
+
+       f(k) = \begin{cases}1-p  &\text{if } k = 0\\
+                           p    &\text{if } k = 1\end{cases}
+
+    for :math:`k` in :math:`\{0, 1\}`, :math:`0 \leq p \leq 1`
+
+    `bernoulli` takes :math:`p` as shape parameter,
+    where :math:`p` is the probability of a single success
+    and :math:`1-p` is the probability of a single failure.
+
+    %(after_notes)s
+
+    %(example)s
+
+    """
+    def _shape_info(self):
+        return [_ShapeInfo("p", False, (0, 1), (True, True))]
+
+    def _rvs(self, p, size=None, random_state=None):
+        return binom_gen._rvs(self, 1, p, size=size, random_state=random_state)
+
+    def _argcheck(self, p):
+        return (p >= 0) & (p <= 1)
+
+    def _get_support(self, p):
+        # Overrides binom_gen._get_support!x
+        return self.a, self.b
+
+    def _logpmf(self, x, p):
+        return binom._logpmf(x, 1, p)
+
+    def _pmf(self, x, p):
+        # bernoulli.pmf(k) = 1-p  if k = 0
+        #                  = p    if k = 1
+        return binom._pmf(x, 1, p)
+
+    def _cdf(self, x, p):
+        return binom._cdf(x, 1, p)
+
+    def _sf(self, x, p):
+        return binom._sf(x, 1, p)
+
+    def _isf(self, x, p):
+        return binom._isf(x, 1, p)
+
+    def _ppf(self, q, p):
+        return binom._ppf(q, 1, p)
+
+    def _stats(self, p):
+        return binom._stats(1, p)
+
+    def _entropy(self, p):
+        return entr(p) + entr(1-p)
+
+
+bernoulli = bernoulli_gen(b=1, name='bernoulli')
+
+
+class betabinom_gen(rv_discrete):
+    r"""A beta-binomial discrete random variable.
+
+    %(before_notes)s
+
+    Notes
+    -----
+    The beta-binomial distribution is a binomial distribution with a
+    probability of success `p` that follows a beta distribution.
+
+    The probability mass function for `betabinom` is:
+
+    .. math::
+
+       f(k) = \binom{n}{k} \frac{B(k + a, n - k + b)}{B(a, b)}
+
+    for :math:`k \in \{0, 1, \dots, n\}`, :math:`n \geq 0`, :math:`a > 0`,
+    :math:`b > 0`, where :math:`B(a, b)` is the beta function.
+
+    `betabinom` takes :math:`n`, :math:`a`, and :math:`b` as shape parameters.
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Beta-binomial_distribution
+
+    %(after_notes)s
+
+    .. versionadded:: 1.4.0
+
+    See Also
+    --------
+    beta, binom
+
+    %(example)s
+
+    """
+    def _shape_info(self):
+        return [_ShapeInfo("n", True, (0, np.inf), (True, False)),
+                _ShapeInfo("a", False, (0, np.inf), (False, False)),
+                _ShapeInfo("b", False, (0, np.inf), (False, False))]
+
+    def _rvs(self, n, a, b, size=None, random_state=None):
+        p = random_state.beta(a, b, size)
+        return random_state.binomial(n, p, size)
+
+    def _get_support(self, n, a, b):
+        return 0, n
+
+    def _argcheck(self, n, a, b):
+        return (n >= 0) & _isintegral(n) & (a > 0) & (b > 0)
+
+    def _logpmf(self, x, n, a, b):
+        k = floor(x)
+        combiln = -log(n + 1) - betaln(n - k + 1, k + 1)
+        return combiln + betaln(k + a, n - k + b) - betaln(a, b)
+
+    def _pmf(self, x, n, a, b):
+        return exp(self._logpmf(x, n, a, b))
+
+    def _stats(self, n, a, b, moments='mv'):
+        e_p = a / (a + b)
+        e_q = 1 - e_p
+        mu = n * e_p
+        var = n * (a + b + n) * e_p * e_q / (a + b + 1)
+        g1, g2 = None, None
+        if 's' in moments:
+            g1 = 1.0 / sqrt(var)
+            g1 *= (a + b + 2 * n) * (b - a)
+            g1 /= (a + b + 2) * (a + b)
+        if 'k' in moments:
+            g2 = (a + b).astype(e_p.dtype)
+            g2 *= (a + b - 1 + 6 * n)
+            g2 += 3 * a * b * (n - 2)
+            g2 += 6 * n ** 2
+            g2 -= 3 * e_p * b * n * (6 - n)
+            g2 -= 18 * e_p * e_q * n ** 2
+            g2 *= (a + b) ** 2 * (1 + a + b)
+            g2 /= (n * a * b * (a + b + 2) * (a + b + 3) * (a + b + n))
+            g2 -= 3
+        return mu, var, g1, g2
+
+
+betabinom = betabinom_gen(name='betabinom')
+
+
+class nbinom_gen(rv_discrete):
+    r"""A negative binomial discrete random variable.
+
+    %(before_notes)s
+
+    Notes
+    -----
+    Negative binomial distribution describes a sequence of i.i.d. Bernoulli
+    trials, repeated until a predefined, non-random number of successes occurs.
+
+    The probability mass function of the number of failures for `nbinom` is:
+
+    .. math::
+
+       f(k) = \binom{k+n-1}{n-1} p^n (1-p)^k
+
+    for :math:`k \ge 0`, :math:`0 < p \leq 1`
+
+    `nbinom` takes :math:`n` and :math:`p` as shape parameters where :math:`n`
+    is the number of successes, :math:`p` is the probability of a single
+    success, and :math:`1-p` is the probability of a single failure.
+
+    Another common parameterization of the negative binomial distribution is
+    in terms of the mean number of failures :math:`\mu` to achieve :math:`n`
+    successes. The mean :math:`\mu` is related to the probability of success
+    as
+
+    .. math::
+
+       p = \frac{n}{n + \mu}
+
+    The number of successes :math:`n` may also be specified in terms of a
+    "dispersion", "heterogeneity", or "aggregation" parameter :math:`\alpha`,
+    which relates the mean :math:`\mu` to the variance :math:`\sigma^2`,
+    e.g. :math:`\sigma^2 = \mu + \alpha \mu^2`. Regardless of the convention
+    used for :math:`\alpha`,
+
+    .. math::
+
+       p &= \frac{\mu}{\sigma^2} \\
+       n &= \frac{\mu^2}{\sigma^2 - \mu}
+
+    This distribution uses routines from the Boost Math C++ library for
+    the computation of the ``pmf``, ``cdf``, ``sf``, ``ppf``, ``isf``
+    and ``stats`` methods. [1]_
+
+    %(after_notes)s
+
+    References
+    ----------
+    .. [1] The Boost Developers. "Boost C++ Libraries". https://www.boost.org/.
+
+    %(example)s
+
+    See Also
+    --------
+    hypergeom, binom, nhypergeom
+
+    """
+    def _shape_info(self):
+        return [_ShapeInfo("n", True, (0, np.inf), (True, False)),
+                _ShapeInfo("p", False, (0, 1), (True, True))]
+
+    def _rvs(self, n, p, size=None, random_state=None):
+        return random_state.negative_binomial(n, p, size)
+
+    def _argcheck(self, n, p):
+        return (n > 0) & (p > 0) & (p <= 1)
+
+    def _pmf(self, x, n, p):
+        # nbinom.pmf(k) = choose(k+n-1, n-1) * p**n * (1-p)**k
+        return scu._nbinom_pmf(x, n, p)
+
+    def _logpmf(self, x, n, p):
+        coeff = gamln(n+x) - gamln(x+1) - gamln(n)
+        return coeff + n*log(p) + special.xlog1py(x, -p)
+
+    def _cdf(self, x, n, p):
+        k = floor(x)
+        return scu._nbinom_cdf(k, n, p)
+
+    def _logcdf(self, x, n, p):
+        k = floor(x)
+        k, n, p = np.broadcast_arrays(k, n, p)
+        cdf = self._cdf(k, n, p)
+        cond = cdf > 0.5
+        def f1(k, n, p):
+            return np.log1p(-special.betainc(k + 1, n, 1 - p))
+
+        # do calc in place
+        logcdf = cdf
+        with np.errstate(divide='ignore'):
+            logcdf[cond] = f1(k[cond], n[cond], p[cond])
+            logcdf[~cond] = np.log(cdf[~cond])
+        return logcdf
+
+    def _sf(self, x, n, p):
+        k = floor(x)
+        return scu._nbinom_sf(k, n, p)
+
+    def _isf(self, x, n, p):
+        with np.errstate(over='ignore'):  # see gh-17432
+            return scu._nbinom_isf(x, n, p)
+
+    def _ppf(self, q, n, p):
+        with np.errstate(over='ignore'):  # see gh-17432
+            return scu._nbinom_ppf(q, n, p)
+
+    def _stats(self, n, p):
+        return (
+            scu._nbinom_mean(n, p),
+            scu._nbinom_variance(n, p),
+            scu._nbinom_skewness(n, p),
+            scu._nbinom_kurtosis_excess(n, p),
+        )
+
+
+nbinom = nbinom_gen(name='nbinom')
+
+
+class betanbinom_gen(rv_discrete):
+    r"""A beta-negative-binomial discrete random variable.
+
+    %(before_notes)s
+
+    Notes
+    -----
+    The beta-negative-binomial distribution is a negative binomial
+    distribution with a probability of success `p` that follows a
+    beta distribution.
+
+    The probability mass function for `betanbinom` is:
+
+    .. math::
+
+       f(k) = \binom{n + k - 1}{k} \frac{B(a + n, b + k)}{B(a, b)}
+
+    for :math:`k \ge 0`, :math:`n \geq 0`, :math:`a > 0`,
+    :math:`b > 0`, where :math:`B(a, b)` is the beta function.
+
+    `betanbinom` takes :math:`n`, :math:`a`, and :math:`b` as shape parameters.
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Beta_negative_binomial_distribution
+
+    %(after_notes)s
+
+    .. versionadded:: 1.12.0
+
+    See Also
+    --------
+    betabinom : Beta binomial distribution
+
+    %(example)s
+
+    """
+    def _shape_info(self):
+        return [_ShapeInfo("n", True, (0, np.inf), (True, False)),
+                _ShapeInfo("a", False, (0, np.inf), (False, False)),
+                _ShapeInfo("b", False, (0, np.inf), (False, False))]
+
+    def _rvs(self, n, a, b, size=None, random_state=None):
+        p = random_state.beta(a, b, size)
+        return random_state.negative_binomial(n, p, size)
+
+    def _argcheck(self, n, a, b):
+        return (n >= 0) & _isintegral(n) & (a > 0) & (b > 0)
+
+    def _logpmf(self, x, n, a, b):
+        k = floor(x)
+        combiln = -np.log(n + k) - betaln(n, k + 1)
+        return combiln + betaln(a + n, b + k) - betaln(a, b)
+
+    def _pmf(self, x, n, a, b):
+        return exp(self._logpmf(x, n, a, b))
+
+    def _stats(self, n, a, b, moments='mv'):
+        # reference: Wolfram Alpha input
+        # BetaNegativeBinomialDistribution[a, b, n]
+        def mean(n, a, b):
+            return n * b / (a - 1.)
+        mu = _lazywhere(a > 1, (n, a, b), f=mean, fillvalue=np.inf)
+        def var(n, a, b):
+            return (n * b * (n + a - 1.) * (a + b - 1.)
+                    / ((a - 2.) * (a - 1.)**2.))
+        var = _lazywhere(a > 2, (n, a, b), f=var, fillvalue=np.inf)
+        g1, g2 = None, None
+        def skew(n, a, b):
+            return ((2 * n + a - 1.) * (2 * b + a - 1.)
+                    / (a - 3.) / sqrt(n * b * (n + a - 1.) * (b + a - 1.)
+                    / (a - 2.)))
+        if 's' in moments:
+            g1 = _lazywhere(a > 3, (n, a, b), f=skew, fillvalue=np.inf)
+        def kurtosis(n, a, b):
+            term = (a - 2.)
+            term_2 = ((a - 1.)**2. * (a**2. + a * (6 * b - 1.)
+                      + 6. * (b - 1.) * b)
+                      + 3. * n**2. * ((a + 5.) * b**2. + (a + 5.)
+                      * (a - 1.) * b + 2. * (a - 1.)**2)
+                      + 3 * (a - 1.) * n
+                      * ((a + 5.) * b**2. + (a + 5.) * (a - 1.) * b
+                      + 2. * (a - 1.)**2.))
+            denominator = ((a - 4.) * (a - 3.) * b * n
+                           * (a + b - 1.) * (a + n - 1.))
+            # Wolfram Alpha uses Pearson kurtosis, so we subtract 3 to get
+            # scipy's Fisher kurtosis
+            return term * term_2 / denominator - 3.
+        if 'k' in moments:
+            g2 = _lazywhere(a > 4, (n, a, b), f=kurtosis, fillvalue=np.inf)
+        return mu, var, g1, g2
+
+
+betanbinom = betanbinom_gen(name='betanbinom')
+
+
+class geom_gen(rv_discrete):
+    r"""A geometric discrete random variable.
+
+    %(before_notes)s
+
+    Notes
+    -----
+    The probability mass function for `geom` is:
+
+    .. math::
+
+        f(k) = (1-p)^{k-1} p
+
+    for :math:`k \ge 1`, :math:`0 < p \leq 1`
+
+    `geom` takes :math:`p` as shape parameter,
+    where :math:`p` is the probability of a single success
+    and :math:`1-p` is the probability of a single failure.
+
+    Note that when drawing random samples, the probability of observations that exceed
+    ``np.iinfo(np.int64).max`` increases rapidly as $p$ decreases below $10^{-17}$. For
+    $p < 10^{-20}$, almost all observations would exceed the maximum ``int64``; however,
+    the output dtype is always ``int64``, so these values are clipped to the maximum.
+
+    %(after_notes)s
+
+    See Also
+    --------
+    planck
+
+    %(example)s
+
+    """
+
+    def _shape_info(self):
+        return [_ShapeInfo("p", False, (0, 1), (True, True))]
+
+    def _rvs(self, p, size=None, random_state=None):
+        res = random_state.geometric(p, size=size)
+        # RandomState.geometric can wrap around to negative values; make behavior
+        # consistent with Generator.geometric by replacing with maximum integer.
+        max_int = np.iinfo(res.dtype).max
+        return np.where(res < 0, max_int, res)
+
+    def _argcheck(self, p):
+        return (p <= 1) & (p > 0)
+
+    def _pmf(self, k, p):
+        return np.power(1-p, k-1) * p
+
+    def _logpmf(self, k, p):
+        return special.xlog1py(k - 1, -p) + log(p)
+
+    def _cdf(self, x, p):
+        k = floor(x)
+        return -expm1(log1p(-p)*k)
+
+    def _sf(self, x, p):
+        return np.exp(self._logsf(x, p))
+
+    def _logsf(self, x, p):
+        k = floor(x)
+        return k*log1p(-p)
+
+    def _ppf(self, q, p):
+        vals = ceil(log1p(-q) / log1p(-p))
+        temp = self._cdf(vals-1, p)
+        return np.where((temp >= q) & (vals > 0), vals-1, vals)
+
+    def _stats(self, p):
+        mu = 1.0/p
+        qr = 1.0-p
+        var = qr / p / p
+        g1 = (2.0-p) / sqrt(qr)
+        g2 = np.polyval([1, -6, 6], p)/(1.0-p)
+        return mu, var, g1, g2
+
+    def _entropy(self, p):
+        return -np.log(p) - np.log1p(-p) * (1.0-p) / p
+
+
+geom = geom_gen(a=1, name='geom', longname="A geometric")
+
+
+class hypergeom_gen(rv_discrete):
+    r"""A hypergeometric discrete random variable.
+
+    The hypergeometric distribution models drawing objects from a bin.
+    `M` is the total number of objects, `n` is total number of Type I objects.
+    The random variate represents the number of Type I objects in `N` drawn
+    without replacement from the total population.
+
+    %(before_notes)s
+
+    Notes
+    -----
+    The symbols used to denote the shape parameters (`M`, `n`, and `N`) are not
+    universally accepted.  See the Examples for a clarification of the
+    definitions used here.
+
+    The probability mass function is defined as,
+
+    .. math:: p(k, M, n, N) = \frac{\binom{n}{k} \binom{M - n}{N - k}}
+                                   {\binom{M}{N}}
+
+    for :math:`k \in [\max(0, N - M + n), \min(n, N)]`, where the binomial
+    coefficients are defined as,
+
+    .. math:: \binom{n}{k} \equiv \frac{n!}{k! (n - k)!}.
+
+    This distribution uses routines from the Boost Math C++ library for
+    the computation of the ``pmf``, ``cdf``, ``sf`` and ``stats`` methods. [1]_
+
+    %(after_notes)s
+
+    References
+    ----------
+    .. [1] The Boost Developers. "Boost C++ Libraries". https://www.boost.org/.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy.stats import hypergeom
+    >>> import matplotlib.pyplot as plt
+
+    Suppose we have a collection of 20 animals, of which 7 are dogs.  Then if
+    we want to know the probability of finding a given number of dogs if we
+    choose at random 12 of the 20 animals, we can initialize a frozen
+    distribution and plot the probability mass function:
+
+    >>> [M, n, N] = [20, 7, 12]
+    >>> rv = hypergeom(M, n, N)
+    >>> x = np.arange(0, n+1)
+    >>> pmf_dogs = rv.pmf(x)
+
+    >>> fig = plt.figure()
+    >>> ax = fig.add_subplot(111)
+    >>> ax.plot(x, pmf_dogs, 'bo')
+    >>> ax.vlines(x, 0, pmf_dogs, lw=2)
+    >>> ax.set_xlabel('# of dogs in our group of chosen animals')
+    >>> ax.set_ylabel('hypergeom PMF')
+    >>> plt.show()
+
+    Instead of using a frozen distribution we can also use `hypergeom`
+    methods directly.  To for example obtain the cumulative distribution
+    function, use:
+
+    >>> prb = hypergeom.cdf(x, M, n, N)
+
+    And to generate random numbers:
+
+    >>> R = hypergeom.rvs(M, n, N, size=10)
+
+    See Also
+    --------
+    nhypergeom, binom, nbinom
+
+    """
+    def _shape_info(self):
+        return [_ShapeInfo("M", True, (0, np.inf), (True, False)),
+                _ShapeInfo("n", True, (0, np.inf), (True, False)),
+                _ShapeInfo("N", True, (0, np.inf), (True, False))]
+
+    def _rvs(self, M, n, N, size=None, random_state=None):
+        return random_state.hypergeometric(n, M-n, N, size=size)
+
+    def _get_support(self, M, n, N):
+        return np.maximum(N-(M-n), 0), np.minimum(n, N)
+
+    def _argcheck(self, M, n, N):
+        cond = (M > 0) & (n >= 0) & (N >= 0)
+        cond &= (n <= M) & (N <= M)
+        cond &= _isintegral(M) & _isintegral(n) & _isintegral(N)
+        return cond
+
+    def _logpmf(self, k, M, n, N):
+        tot, good = M, n
+        bad = tot - good
+        result = (betaln(good+1, 1) + betaln(bad+1, 1) + betaln(tot-N+1, N+1) -
+                  betaln(k+1, good-k+1) - betaln(N-k+1, bad-N+k+1) -
+                  betaln(tot+1, 1))
+        return result
+
+    def _pmf(self, k, M, n, N):
+        return scu._hypergeom_pmf(k, n, N, M)
+
+    def _cdf(self, k, M, n, N):
+        return scu._hypergeom_cdf(k, n, N, M)
+
+    def _stats(self, M, n, N):
+        M, n, N = 1. * M, 1. * n, 1. * N
+        m = M - n
+
+        # Boost kurtosis_excess doesn't return the same as the value
+        # computed here.
+        g2 = M * (M + 1) - 6. * N * (M - N) - 6. * n * m
+        g2 *= (M - 1) * M * M
+        g2 += 6. * n * N * (M - N) * m * (5. * M - 6)
+        g2 /= n * N * (M - N) * m * (M - 2.) * (M - 3.)
+        return (
+            scu._hypergeom_mean(n, N, M),
+            scu._hypergeom_variance(n, N, M),
+            scu._hypergeom_skewness(n, N, M),
+            g2,
+        )
+
+    def _entropy(self, M, n, N):
+        k = np.r_[N - (M - n):min(n, N) + 1]
+        vals = self.pmf(k, M, n, N)
+        return np.sum(entr(vals), axis=0)
+
+    def _sf(self, k, M, n, N):
+        return scu._hypergeom_sf(k, n, N, M)
+
+    def _logsf(self, k, M, n, N):
+        res = []
+        for quant, tot, good, draw in zip(*np.broadcast_arrays(k, M, n, N)):
+            if (quant + 0.5) * (tot + 0.5) < (good - 0.5) * (draw - 0.5):
+                # Less terms to sum if we calculate log(1-cdf)
+                res.append(log1p(-exp(self.logcdf(quant, tot, good, draw))))
+            else:
+                # Integration over probability mass function using logsumexp
+                k2 = np.arange(quant + 1, draw + 1)
+                res.append(logsumexp(self._logpmf(k2, tot, good, draw)))
+        return np.asarray(res)
+
+    def _logcdf(self, k, M, n, N):
+        res = []
+        for quant, tot, good, draw in zip(*np.broadcast_arrays(k, M, n, N)):
+            if (quant + 0.5) * (tot + 0.5) > (good - 0.5) * (draw - 0.5):
+                # Less terms to sum if we calculate log(1-sf)
+                res.append(log1p(-exp(self.logsf(quant, tot, good, draw))))
+            else:
+                # Integration over probability mass function using logsumexp
+                k2 = np.arange(0, quant + 1)
+                res.append(logsumexp(self._logpmf(k2, tot, good, draw)))
+        return np.asarray(res)
+
+
+hypergeom = hypergeom_gen(name='hypergeom')
+
+
+class nhypergeom_gen(rv_discrete):
+    r"""A negative hypergeometric discrete random variable.
+
+    Consider a box containing :math:`M` balls:, :math:`n` red and
+    :math:`M-n` blue. We randomly sample balls from the box, one
+    at a time and *without* replacement, until we have picked :math:`r`
+    blue balls. `nhypergeom` is the distribution of the number of
+    red balls :math:`k` we have picked.
+
+    %(before_notes)s
+
+    Notes
+    -----
+    The symbols used to denote the shape parameters (`M`, `n`, and `r`) are not
+    universally accepted. See the Examples for a clarification of the
+    definitions used here.
+
+    The probability mass function is defined as,
+
+    .. math:: f(k; M, n, r) = \frac{{{k+r-1}\choose{k}}{{M-r-k}\choose{n-k}}}
+                                   {{M \choose n}}
+
+    for :math:`k \in [0, n]`, :math:`n \in [0, M]`, :math:`r \in [0, M-n]`,
+    and the binomial coefficient is:
+
+    .. math:: \binom{n}{k} \equiv \frac{n!}{k! (n - k)!}.
+
+    It is equivalent to observing :math:`k` successes in :math:`k+r-1`
+    samples with :math:`k+r`'th sample being a failure. The former
+    can be modelled as a hypergeometric distribution. The probability
+    of the latter is simply the number of failures remaining
+    :math:`M-n-(r-1)` divided by the size of the remaining population
+    :math:`M-(k+r-1)`. This relationship can be shown as:
+
+    .. math:: NHG(k;M,n,r) = HG(k;M,n,k+r-1)\frac{(M-n-(r-1))}{(M-(k+r-1))}
+
+    where :math:`NHG` is probability mass function (PMF) of the
+    negative hypergeometric distribution and :math:`HG` is the
+    PMF of the hypergeometric distribution.
+
+    %(after_notes)s
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy.stats import nhypergeom
+    >>> import matplotlib.pyplot as plt
+
+    Suppose we have a collection of 20 animals, of which 7 are dogs.
+    Then if we want to know the probability of finding a given number
+    of dogs (successes) in a sample with exactly 12 animals that
+    aren't dogs (failures), we can initialize a frozen distribution
+    and plot the probability mass function:
+
+    >>> M, n, r = [20, 7, 12]
+    >>> rv = nhypergeom(M, n, r)
+    >>> x = np.arange(0, n+2)
+    >>> pmf_dogs = rv.pmf(x)
+
+    >>> fig = plt.figure()
+    >>> ax = fig.add_subplot(111)
+    >>> ax.plot(x, pmf_dogs, 'bo')
+    >>> ax.vlines(x, 0, pmf_dogs, lw=2)
+    >>> ax.set_xlabel('# of dogs in our group with given 12 failures')
+    >>> ax.set_ylabel('nhypergeom PMF')
+    >>> plt.show()
+
+    Instead of using a frozen distribution we can also use `nhypergeom`
+    methods directly.  To for example obtain the probability mass
+    function, use:
+
+    >>> prb = nhypergeom.pmf(x, M, n, r)
+
+    And to generate random numbers:
+
+    >>> R = nhypergeom.rvs(M, n, r, size=10)
+
+    To verify the relationship between `hypergeom` and `nhypergeom`, use:
+
+    >>> from scipy.stats import hypergeom, nhypergeom
+    >>> M, n, r = 45, 13, 8
+    >>> k = 6
+    >>> nhypergeom.pmf(k, M, n, r)
+    0.06180776620271643
+    >>> hypergeom.pmf(k, M, n, k+r-1) * (M - n - (r-1)) / (M - (k+r-1))
+    0.06180776620271644
+
+    See Also
+    --------
+    hypergeom, binom, nbinom
+
+    References
+    ----------
+    .. [1] Negative Hypergeometric Distribution on Wikipedia
+           https://en.wikipedia.org/wiki/Negative_hypergeometric_distribution
+
+    .. [2] Negative Hypergeometric Distribution from
+           http://www.math.wm.edu/~leemis/chart/UDR/PDFs/Negativehypergeometric.pdf
+
+    """
+
+    def _shape_info(self):
+        return [_ShapeInfo("M", True, (0, np.inf), (True, False)),
+                _ShapeInfo("n", True, (0, np.inf), (True, False)),
+                _ShapeInfo("r", True, (0, np.inf), (True, False))]
+
+    def _get_support(self, M, n, r):
+        return 0, n
+
+    def _argcheck(self, M, n, r):
+        cond = (n >= 0) & (n <= M) & (r >= 0) & (r <= M-n)
+        cond &= _isintegral(M) & _isintegral(n) & _isintegral(r)
+        return cond
+
+    def _rvs(self, M, n, r, size=None, random_state=None):
+
+        @_vectorize_rvs_over_shapes
+        def _rvs1(M, n, r, size, random_state):
+            # invert cdf by calculating all values in support, scalar M, n, r
+            a, b = self.support(M, n, r)
+            ks = np.arange(a, b+1)
+            cdf = self.cdf(ks, M, n, r)
+            ppf = interp1d(cdf, ks, kind='next', fill_value='extrapolate')
+            rvs = ppf(random_state.uniform(size=size)).astype(int)
+            if size is None:
+                return rvs.item()
+            return rvs
+
+        return _rvs1(M, n, r, size=size, random_state=random_state)
+
+    def _logpmf(self, k, M, n, r):
+        cond = ((r == 0) & (k == 0))
+        result = _lazywhere(~cond, (k, M, n, r),
+                            lambda k, M, n, r:
+                                (-betaln(k+1, r) + betaln(k+r, 1) -
+                                 betaln(n-k+1, M-r-n+1) + betaln(M-r-k+1, 1) +
+                                 betaln(n+1, M-n+1) - betaln(M+1, 1)),
+                            fillvalue=0.0)
+        return result
+
+    def _pmf(self, k, M, n, r):
+        # same as the following but numerically more precise
+        # return comb(k+r-1, k) * comb(M-r-k, n-k) / comb(M, n)
+        return exp(self._logpmf(k, M, n, r))
+
+    def _stats(self, M, n, r):
+        # Promote the datatype to at least float
+        # mu = rn / (M-n+1)
+        M, n, r = 1.*M, 1.*n, 1.*r
+        mu = r*n / (M-n+1)
+
+        var = r*(M+1)*n / ((M-n+1)*(M-n+2)) * (1 - r / (M-n+1))
+
+        # The skew and kurtosis are mathematically
+        # intractable so return `None`. See [2]_.
+        g1, g2 = None, None
+        return mu, var, g1, g2
+
+
+nhypergeom = nhypergeom_gen(name='nhypergeom')
+
+
+# FIXME: Fails _cdfvec
+class logser_gen(rv_discrete):
+    r"""A Logarithmic (Log-Series, Series) discrete random variable.
+
+    %(before_notes)s
+
+    Notes
+    -----
+    The probability mass function for `logser` is:
+
+    .. math::
+
+        f(k) = - \frac{p^k}{k \log(1-p)}
+
+    for :math:`k \ge 1`, :math:`0 < p < 1`
+
+    `logser` takes :math:`p` as shape parameter,
+    where :math:`p` is the probability of a single success
+    and :math:`1-p` is the probability of a single failure.
+
+    %(after_notes)s
+
+    %(example)s
+
+    """
+
+    def _shape_info(self):
+        return [_ShapeInfo("p", False, (0, 1), (True, True))]
+
+    def _rvs(self, p, size=None, random_state=None):
+        # looks wrong for p>0.5, too few k=1
+        # trying to use generic is worse, no k=1 at all
+        return random_state.logseries(p, size=size)
+
+    def _argcheck(self, p):
+        return (p > 0) & (p < 1)
+
+    def _pmf(self, k, p):
+        # logser.pmf(k) = - p**k / (k*log(1-p))
+        return -np.power(p, k) * 1.0 / k / special.log1p(-p)
+
+    def _stats(self, p):
+        r = special.log1p(-p)
+        mu = p / (p - 1.0) / r
+        mu2p = -p / r / (p - 1.0)**2
+        var = mu2p - mu*mu
+        mu3p = -p / r * (1.0+p) / (1.0 - p)**3
+        mu3 = mu3p - 3*mu*mu2p + 2*mu**3
+        g1 = mu3 / np.power(var, 1.5)
+
+        mu4p = -p / r * (
+            1.0 / (p-1)**2 - 6*p / (p - 1)**3 + 6*p*p / (p-1)**4)
+        mu4 = mu4p - 4*mu3p*mu + 6*mu2p*mu*mu - 3*mu**4
+        g2 = mu4 / var**2 - 3.0
+        return mu, var, g1, g2
+
+
+logser = logser_gen(a=1, name='logser', longname='A logarithmic')
+
+
+class poisson_gen(rv_discrete):
+    r"""A Poisson discrete random variable.
+
+    %(before_notes)s
+
+    Notes
+    -----
+    The probability mass function for `poisson` is:
+
+    .. math::
+
+        f(k) = \exp(-\mu) \frac{\mu^k}{k!}
+
+    for :math:`k \ge 0`.
+
+    `poisson` takes :math:`\mu \geq 0` as shape parameter.
+    When :math:`\mu = 0`, the ``pmf`` method
+    returns ``1.0`` at quantile :math:`k = 0`.
+
+    %(after_notes)s
+
+    %(example)s
+
+    """
+
+    def _shape_info(self):
+        return [_ShapeInfo("mu", False, (0, np.inf), (True, False))]
+
+    # Override rv_discrete._argcheck to allow mu=0.
+    def _argcheck(self, mu):
+        return mu >= 0
+
+    def _rvs(self, mu, size=None, random_state=None):
+        return random_state.poisson(mu, size)
+
+    def _logpmf(self, k, mu):
+        Pk = special.xlogy(k, mu) - gamln(k + 1) - mu
+        return Pk
+
+    def _pmf(self, k, mu):
+        # poisson.pmf(k) = exp(-mu) * mu**k / k!
+        return exp(self._logpmf(k, mu))
+
+    def _cdf(self, x, mu):
+        k = floor(x)
+        return special.pdtr(k, mu)
+
+    def _sf(self, x, mu):
+        k = floor(x)
+        return special.pdtrc(k, mu)
+
+    def _ppf(self, q, mu):
+        vals = ceil(special.pdtrik(q, mu))
+        vals1 = np.maximum(vals - 1, 0)
+        temp = special.pdtr(vals1, mu)
+        return np.where(temp >= q, vals1, vals)
+
+    def _stats(self, mu):
+        var = mu
+        tmp = np.asarray(mu)
+        mu_nonzero = tmp > 0
+        g1 = _lazywhere(mu_nonzero, (tmp,), lambda x: sqrt(1.0/x), np.inf)
+        g2 = _lazywhere(mu_nonzero, (tmp,), lambda x: 1.0/x, np.inf)
+        return mu, var, g1, g2
+
+
+poisson = poisson_gen(name="poisson", longname='A Poisson')
+
+
+class planck_gen(rv_discrete):
+    r"""A Planck discrete exponential random variable.
+
+    %(before_notes)s
+
+    Notes
+    -----
+    The probability mass function for `planck` is:
+
+    .. math::
+
+        f(k) = (1-\exp(-\lambda)) \exp(-\lambda k)
+
+    for :math:`k \ge 0` and :math:`\lambda > 0`.
+
+    `planck` takes :math:`\lambda` as shape parameter. The Planck distribution
+    can be written as a geometric distribution (`geom`) with
+    :math:`p = 1 - \exp(-\lambda)` shifted by ``loc = -1``.
+
+    %(after_notes)s
+
+    See Also
+    --------
+    geom
+
+    %(example)s
+
+    """
+    def _shape_info(self):
+        return [_ShapeInfo("lambda", False, (0, np.inf), (False, False))]
+
+    def _argcheck(self, lambda_):
+        return lambda_ > 0
+
+    def _pmf(self, k, lambda_):
+        return -expm1(-lambda_)*exp(-lambda_*k)
+
+    def _cdf(self, x, lambda_):
+        k = floor(x)
+        return -expm1(-lambda_*(k+1))
+
+    def _sf(self, x, lambda_):
+        return exp(self._logsf(x, lambda_))
+
+    def _logsf(self, x, lambda_):
+        k = floor(x)
+        return -lambda_*(k+1)
+
+    def _ppf(self, q, lambda_):
+        vals = ceil(-1.0/lambda_ * log1p(-q)-1)
+        vals1 = (vals-1).clip(*(self._get_support(lambda_)))
+        temp = self._cdf(vals1, lambda_)
+        return np.where(temp >= q, vals1, vals)
+
+    def _rvs(self, lambda_, size=None, random_state=None):
+        # use relation to geometric distribution for sampling
+        p = -expm1(-lambda_)
+        return random_state.geometric(p, size=size) - 1.0
+
+    def _stats(self, lambda_):
+        mu = 1/expm1(lambda_)
+        var = exp(-lambda_)/(expm1(-lambda_))**2
+        g1 = 2*cosh(lambda_/2.0)
+        g2 = 4+2*cosh(lambda_)
+        return mu, var, g1, g2
+
+    def _entropy(self, lambda_):
+        C = -expm1(-lambda_)
+        return lambda_*exp(-lambda_)/C - log(C)
+
+
+planck = planck_gen(a=0, name='planck', longname='A discrete exponential ')
+
+
+class boltzmann_gen(rv_discrete):
+    r"""A Boltzmann (Truncated Discrete Exponential) random variable.
+
+    %(before_notes)s
+
+    Notes
+    -----
+    The probability mass function for `boltzmann` is:
+
+    .. math::
+
+        f(k) = (1-\exp(-\lambda)) \exp(-\lambda k) / (1-\exp(-\lambda N))
+
+    for :math:`k = 0,..., N-1`.
+
+    `boltzmann` takes :math:`\lambda > 0` and :math:`N > 0` as shape parameters.
+
+    %(after_notes)s
+
+    %(example)s
+
+    """
+    def _shape_info(self):
+        return [_ShapeInfo("lambda_", False, (0, np.inf), (False, False)),
+                _ShapeInfo("N", True, (0, np.inf), (False, False))]
+
+    def _argcheck(self, lambda_, N):
+        return (lambda_ > 0) & (N > 0) & _isintegral(N)
+
+    def _get_support(self, lambda_, N):
+        return self.a, N - 1
+
+    def _pmf(self, k, lambda_, N):
+        # boltzmann.pmf(k) =
+        #               (1-exp(-lambda_)*exp(-lambda_*k)/(1-exp(-lambda_*N))
+        fact = (1-exp(-lambda_))/(1-exp(-lambda_*N))
+        return fact*exp(-lambda_*k)
+
+    def _cdf(self, x, lambda_, N):
+        k = floor(x)
+        return (1-exp(-lambda_*(k+1)))/(1-exp(-lambda_*N))
+
+    def _ppf(self, q, lambda_, N):
+        qnew = q*(1-exp(-lambda_*N))
+        vals = ceil(-1.0/lambda_ * log(1-qnew)-1)
+        vals1 = (vals-1).clip(0.0, np.inf)
+        temp = self._cdf(vals1, lambda_, N)
+        return np.where(temp >= q, vals1, vals)
+
+    def _stats(self, lambda_, N):
+        z = exp(-lambda_)
+        zN = exp(-lambda_*N)
+        mu = z/(1.0-z)-N*zN/(1-zN)
+        var = z/(1.0-z)**2 - N*N*zN/(1-zN)**2
+        trm = (1-zN)/(1-z)
+        trm2 = (z*trm**2 - N*N*zN)
+        g1 = z*(1+z)*trm**3 - N**3*zN*(1+zN)
+        g1 = g1 / trm2**(1.5)
+        g2 = z*(1+4*z+z*z)*trm**4 - N**4 * zN*(1+4*zN+zN*zN)
+        g2 = g2 / trm2 / trm2
+        return mu, var, g1, g2
+
+
+boltzmann = boltzmann_gen(name='boltzmann', a=0,
+                          longname='A truncated discrete exponential ')
+
+
+class randint_gen(rv_discrete):
+    r"""A uniform discrete random variable.
+
+    %(before_notes)s
+
+    Notes
+    -----
+    The probability mass function for `randint` is:
+
+    .. math::
+
+        f(k) = \frac{1}{\texttt{high} - \texttt{low}}
+
+    for :math:`k \in \{\texttt{low}, \dots, \texttt{high} - 1\}`.
+
+    `randint` takes :math:`\texttt{low}` and :math:`\texttt{high}` as shape
+    parameters.
+
+    %(after_notes)s
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy.stats import randint
+    >>> import matplotlib.pyplot as plt
+    >>> fig, ax = plt.subplots(1, 1)
+
+    Calculate the first four moments:
+
+    >>> low, high = 7, 31
+    >>> mean, var, skew, kurt = randint.stats(low, high, moments='mvsk')
+
+    Display the probability mass function (``pmf``):
+
+    >>> x = np.arange(low - 5, high + 5)
+    >>> ax.plot(x, randint.pmf(x, low, high), 'bo', ms=8, label='randint pmf')
+    >>> ax.vlines(x, 0, randint.pmf(x, low, high), colors='b', lw=5, alpha=0.5)
+
+    Alternatively, the distribution object can be called (as a function) to
+    fix the shape and location. This returns a "frozen" RV object holding the
+    given parameters fixed.
+
+    Freeze the distribution and display the frozen ``pmf``:
+
+    >>> rv = randint(low, high)
+    >>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-',
+    ...           lw=1, label='frozen pmf')
+    >>> ax.legend(loc='lower center')
+    >>> plt.show()
+
+    Check the relationship between the cumulative distribution function
+    (``cdf``) and its inverse, the percent point function (``ppf``):
+
+    >>> q = np.arange(low, high)
+    >>> p = randint.cdf(q, low, high)
+    >>> np.allclose(q, randint.ppf(p, low, high))
+    True
+
+    Generate random numbers:
+
+    >>> r = randint.rvs(low, high, size=1000)
+
+    """
+
+    def _shape_info(self):
+        return [_ShapeInfo("low", True, (-np.inf, np.inf), (False, False)),
+                _ShapeInfo("high", True, (-np.inf, np.inf), (False, False))]
+
+    def _argcheck(self, low, high):
+        return (high > low) & _isintegral(low) & _isintegral(high)
+
+    def _get_support(self, low, high):
+        return low, high-1
+
+    def _pmf(self, k, low, high):
+        # randint.pmf(k) = 1./(high - low)
+        p = np.ones_like(k) / (np.asarray(high, dtype=np.int64) - low)
+        return np.where((k >= low) & (k < high), p, 0.)
+
+    def _cdf(self, x, low, high):
+        k = floor(x)
+        return (k - low + 1.) / (high - low)
+
+    def _ppf(self, q, low, high):
+        vals = ceil(q * (high - low) + low) - 1
+        vals1 = (vals - 1).clip(low, high)
+        temp = self._cdf(vals1, low, high)
+        return np.where(temp >= q, vals1, vals)
+
+    def _stats(self, low, high):
+        m2, m1 = np.asarray(high), np.asarray(low)
+        mu = (m2 + m1 - 1.0) / 2
+        d = m2 - m1
+        var = (d*d - 1) / 12.0
+        g1 = 0.0
+        g2 = -6.0/5.0 * (d*d + 1.0) / (d*d - 1.0)
+        return mu, var, g1, g2
+
+    def _rvs(self, low, high, size=None, random_state=None):
+        """An array of *size* random integers >= ``low`` and < ``high``."""
+        if np.asarray(low).size == 1 and np.asarray(high).size == 1:
+            # no need to vectorize in that case
+            return rng_integers(random_state, low, high, size=size)
+
+        if size is not None:
+            # NumPy's RandomState.randint() doesn't broadcast its arguments.
+            # Use `broadcast_to()` to extend the shapes of low and high
+            # up to size.  Then we can use the numpy.vectorize'd
+            # randint without needing to pass it a `size` argument.
+            low = np.broadcast_to(low, size)
+            high = np.broadcast_to(high, size)
+        randint = np.vectorize(partial(rng_integers, random_state),
+                               otypes=[np.dtype(int)])
+        return randint(low, high)
+
+    def _entropy(self, low, high):
+        return log(high - low)
+
+
+randint = randint_gen(name='randint', longname='A discrete uniform '
+                      '(random integer)')
+
+
+# FIXME: problems sampling.
+class zipf_gen(rv_discrete):
+    r"""A Zipf (Zeta) discrete random variable.
+
+    %(before_notes)s
+
+    See Also
+    --------
+    zipfian
+
+    Notes
+    -----
+    The probability mass function for `zipf` is:
+
+    .. math::
+
+        f(k, a) = \frac{1}{\zeta(a) k^a}
+
+    for :math:`k \ge 1`, :math:`a > 1`.
+
+    `zipf` takes :math:`a > 1` as shape parameter. :math:`\zeta` is the
+    Riemann zeta function (`scipy.special.zeta`)
+
+    The Zipf distribution is also known as the zeta distribution, which is
+    a special case of the Zipfian distribution (`zipfian`).
+
+    %(after_notes)s
+
+    References
+    ----------
+    .. [1] "Zeta Distribution", Wikipedia,
+           https://en.wikipedia.org/wiki/Zeta_distribution
+
+    %(example)s
+
+    Confirm that `zipf` is the large `n` limit of `zipfian`.
+
+    >>> import numpy as np
+    >>> from scipy.stats import zipf, zipfian
+    >>> k = np.arange(11)
+    >>> np.allclose(zipf.pmf(k, a), zipfian.pmf(k, a, n=10000000))
+    True
+
+    """
+
+    def _shape_info(self):
+        return [_ShapeInfo("a", False, (1, np.inf), (False, False))]
+
+    def _rvs(self, a, size=None, random_state=None):
+        return random_state.zipf(a, size=size)
+
+    def _argcheck(self, a):
+        return a > 1
+
+    def _pmf(self, k, a):
+        k = k.astype(np.float64)
+        # zipf.pmf(k, a) = 1/(zeta(a) * k**a)
+        Pk = 1.0 / special.zeta(a, 1) * k**-a
+        return Pk
+
+    def _munp(self, n, a):
+        return _lazywhere(
+            a > n + 1, (a, n),
+            lambda a, n: special.zeta(a - n, 1) / special.zeta(a, 1),
+            np.inf)
+
+
+zipf = zipf_gen(a=1, name='zipf', longname='A Zipf')
+
+
+def _gen_harmonic_gt1(n, a):
+    """Generalized harmonic number, a > 1"""
+    # See https://en.wikipedia.org/wiki/Harmonic_number; search for "hurwitz"
+    return zeta(a, 1) - zeta(a, n+1)
+
+
+def _gen_harmonic_leq1(n, a):
+    """Generalized harmonic number, a <= 1"""
+    if not np.size(n):
+        return n
+    n_max = np.max(n)  # loop starts at maximum of all n
+    out = np.zeros_like(a, dtype=float)
+    # add terms of harmonic series; starting from smallest to avoid roundoff
+    for i in np.arange(n_max, 0, -1, dtype=float):
+        mask = i <= n  # don't add terms after nth
+        out[mask] += 1/i**a[mask]
+    return out
+
+
+def _gen_harmonic(n, a):
+    """Generalized harmonic number"""
+    n, a = np.broadcast_arrays(n, a)
+    return _lazywhere(a > 1, (n, a),
+                      f=_gen_harmonic_gt1, f2=_gen_harmonic_leq1)
+
+
+class zipfian_gen(rv_discrete):
+    r"""A Zipfian discrete random variable.
+
+    %(before_notes)s
+
+    See Also
+    --------
+    zipf
+
+    Notes
+    -----
+    The probability mass function for `zipfian` is:
+
+    .. math::
+
+        f(k, a, n) = \frac{1}{H_{n,a} k^a}
+
+    for :math:`k \in \{1, 2, \dots, n-1, n\}`, :math:`a \ge 0`,
+    :math:`n \in \{1, 2, 3, \dots\}`.
+
+    `zipfian` takes :math:`a` and :math:`n` as shape parameters.
+    :math:`H_{n,a}` is the :math:`n`:sup:`th` generalized harmonic
+    number of order :math:`a`.
+
+    The Zipfian distribution reduces to the Zipf (zeta) distribution as
+    :math:`n \rightarrow \infty`.
+
+    %(after_notes)s
+
+    References
+    ----------
+    .. [1] "Zipf's Law", Wikipedia, https://en.wikipedia.org/wiki/Zipf's_law
+    .. [2] Larry Leemis, "Zipf Distribution", Univariate Distribution
+           Relationships. http://www.math.wm.edu/~leemis/chart/UDR/PDFs/Zipf.pdf
+
+    %(example)s
+
+    Confirm that `zipfian` reduces to `zipf` for large `n`, ``a > 1``.
+
+    >>> import numpy as np
+    >>> from scipy.stats import zipf, zipfian
+    >>> k = np.arange(11)
+    >>> np.allclose(zipfian.pmf(k, a=3.5, n=10000000), zipf.pmf(k, a=3.5))
+    True
+
+    """
+
+    def _shape_info(self):
+        return [_ShapeInfo("a", False, (0, np.inf), (True, False)),
+                _ShapeInfo("n", True, (0, np.inf), (False, False))]
+
+    def _argcheck(self, a, n):
+        # we need np.asarray here because moment (maybe others) don't convert
+        return (a >= 0) & (n > 0) & (n == np.asarray(n, dtype=int))
+
+    def _get_support(self, a, n):
+        return 1, n
+
+    def _pmf(self, k, a, n):
+        k = k.astype(np.float64)
+        return 1.0 / _gen_harmonic(n, a) * k**-a
+
+    def _cdf(self, k, a, n):
+        return _gen_harmonic(k, a) / _gen_harmonic(n, a)
+
+    def _sf(self, k, a, n):
+        k = k + 1  # # to match SciPy convention
+        # see http://www.math.wm.edu/~leemis/chart/UDR/PDFs/Zipf.pdf
+        return ((k**a*(_gen_harmonic(n, a) - _gen_harmonic(k, a)) + 1)
+                / (k**a*_gen_harmonic(n, a)))
+
+    def _stats(self, a, n):
+        # see # see http://www.math.wm.edu/~leemis/chart/UDR/PDFs/Zipf.pdf
+        Hna = _gen_harmonic(n, a)
+        Hna1 = _gen_harmonic(n, a-1)
+        Hna2 = _gen_harmonic(n, a-2)
+        Hna3 = _gen_harmonic(n, a-3)
+        Hna4 = _gen_harmonic(n, a-4)
+        mu1 = Hna1/Hna
+        mu2n = (Hna2*Hna - Hna1**2)
+        mu2d = Hna**2
+        mu2 = mu2n / mu2d
+        g1 = (Hna3/Hna - 3*Hna1*Hna2/Hna**2 + 2*Hna1**3/Hna**3)/mu2**(3/2)
+        g2 = (Hna**3*Hna4 - 4*Hna**2*Hna1*Hna3 + 6*Hna*Hna1**2*Hna2
+              - 3*Hna1**4) / mu2n**2
+        g2 -= 3
+        return mu1, mu2, g1, g2
+
+
+zipfian = zipfian_gen(a=1, name='zipfian', longname='A Zipfian')
+
+
+class dlaplace_gen(rv_discrete):
+    r"""A  Laplacian discrete random variable.
+
+    %(before_notes)s
+
+    Notes
+    -----
+    The probability mass function for `dlaplace` is:
+
+    .. math::
+
+        f(k) = \tanh(a/2) \exp(-a |k|)
+
+    for integers :math:`k` and :math:`a > 0`.
+
+    `dlaplace` takes :math:`a` as shape parameter.
+
+    %(after_notes)s
+
+    %(example)s
+
+    """
+
+    def _shape_info(self):
+        return [_ShapeInfo("a", False, (0, np.inf), (False, False))]
+
+    def _pmf(self, k, a):
+        # dlaplace.pmf(k) = tanh(a/2) * exp(-a*abs(k))
+        return tanh(a/2.0) * exp(-a * abs(k))
+
+    def _cdf(self, x, a):
+        k = floor(x)
+
+        def f(k, a):
+            return 1.0 - exp(-a * k) / (exp(a) + 1)
+
+        def f2(k, a):
+            return exp(a * (k + 1)) / (exp(a) + 1)
+
+        return _lazywhere(k >= 0, (k, a), f=f, f2=f2)
+
+    def _ppf(self, q, a):
+        const = 1 + exp(a)
+        vals = ceil(np.where(q < 1.0 / (1 + exp(-a)),
+                             log(q*const) / a - 1,
+                             -log((1-q) * const) / a))
+        vals1 = vals - 1
+        return np.where(self._cdf(vals1, a) >= q, vals1, vals)
+
+    def _stats(self, a):
+        ea = exp(a)
+        mu2 = 2.*ea/(ea-1.)**2
+        mu4 = 2.*ea*(ea**2+10.*ea+1.) / (ea-1.)**4
+        return 0., mu2, 0., mu4/mu2**2 - 3.
+
+    def _entropy(self, a):
+        return a / sinh(a) - log(tanh(a/2.0))
+
+    def _rvs(self, a, size=None, random_state=None):
+        # The discrete Laplace is equivalent to the two-sided geometric
+        # distribution with PMF:
+        #   f(k) = (1 - alpha)/(1 + alpha) * alpha^abs(k)
+        #   Reference:
+        #     https://www.sciencedirect.com/science/
+        #     article/abs/pii/S0378375804003519
+        # Furthermore, the two-sided geometric distribution is
+        # equivalent to the difference between two iid geometric
+        # distributions.
+        #   Reference (page 179):
+        #     https://pdfs.semanticscholar.org/61b3/
+        #     b99f466815808fd0d03f5d2791eea8b541a1.pdf
+        # Thus, we can leverage the following:
+        #   1) alpha = e^-a
+        #   2) probability_of_success = 1 - alpha (Bernoulli trial)
+        probOfSuccess = -np.expm1(-np.asarray(a))
+        x = random_state.geometric(probOfSuccess, size=size)
+        y = random_state.geometric(probOfSuccess, size=size)
+        return x - y
+
+
+dlaplace = dlaplace_gen(a=-np.inf,
+                        name='dlaplace', longname='A discrete Laplacian')
+
+
+class poisson_binom_gen(rv_discrete):
+    r"""A Poisson Binomial discrete random variable.
+
+    %(before_notes)s
+
+    See Also
+    --------
+    binom
+
+    Notes
+    -----
+    The probability mass function for `poisson_binom` is:
+
+    .. math::
+
+     f(k; p_1, p_2, ..., p_n) = \sum_{A \in F_k} \prod_{i \in A} p_i \prod_{j \in A^C} 1 - p_j
+
+    where :math:`k \in \{0, 1, \dots, n-1, n\}`, :math:`F_k` is the set of all
+    subsets of :math:`k` integers that can be selected :math:`\{0, 1, \dots, n-1, n\}`,
+    and :math:`A^C` is the complement of a set :math:`A`.
+
+    `poisson_binom` accepts a single array argument ``p`` for shape parameters
+    :math:`0 ≤ p_i ≤ 1`, where the last axis corresponds with the index :math:`i` and
+    any others are for batch dimensions. Broadcasting behaves according to the usual
+    rules except that the last axis of ``p`` is ignored. Instances of this class do
+    not support serialization/unserialization.
+
+    %(after_notes)s
+
+    References
+    ----------
+    .. [1] "Poisson binomial distribution", Wikipedia,
+           https://en.wikipedia.org/wiki/Poisson_binomial_distribution
+    .. [2] Biscarri, William, Sihai Dave Zhao, and Robert J. Brunner. "A simple and
+           fast method for computing the Poisson binomial distribution function".
+           Computational Statistics & Data Analysis 122 (2018) 92-100.
+           :doi:`10.1016/j.csda.2018.01.007`
+
+    %(example)s
+
+    """  # noqa: E501
+    def _shape_info(self):
+        # message = 'Fitting is not implemented for this distribution."
+        # raise NotImplementedError(message)
+        return []
+
+    def _argcheck(self, *args):
+        p = np.stack(args, axis=0)
+        conds = (0 <= p) & (p <= 1)
+        return np.all(conds, axis=0)
+
+    def _rvs(self, *args, size=None, random_state=None):
+        # convenient to work along the last axis here to avoid interference with `size`
+        p = np.stack(args, axis=-1)
+        # Size passed by the user is the *shape of the returned array*, so it won't
+        # contain the length of the last axis of p.
+        size = (p.shape if size is None else
+                (size, 1) if np.isscalar(size) else tuple(size) + (1,))
+        size = np.broadcast_shapes(p.shape, size)
+        return bernoulli._rvs(p, size=size, random_state=random_state).sum(axis=-1)
+
+    def _get_support(self, *args):
+        return 0, len(args)
+
+    def _pmf(self, k, *args):
+        k = np.atleast_1d(k).astype(np.int64)
+        k, *args = np.broadcast_arrays(k, *args)
+        args = np.asarray(args, dtype=np.float64)
+        return _poisson_binom(k, args, 'pmf')
+
+    def _cdf(self, k, *args):
+        k = np.atleast_1d(k).astype(np.int64)
+        k, *args = np.broadcast_arrays(k, *args)
+        args = np.asarray(args, dtype=np.float64)
+        return _poisson_binom(k, args, 'cdf')
+
+    def _stats(self, *args, **kwds):
+        p = np.stack(args, axis=0)
+        mean = np.sum(p, axis=0)
+        var = np.sum(p * (1-p), axis=0)
+        return (mean, var, None, None)
+
+    def __call__(self, *args, **kwds):
+        return poisson_binomial_frozen(self, *args, **kwds)
+
+
+poisson_binom = poisson_binom_gen(name='poisson_binom', longname='A Poisson binomial',
+                                  shapes='p')
+
+# The _parse_args methods don't work with vector-valued shape parameters, so we rewrite
+# them. Note that `p` is accepted as an array with the index `i` of `p_i` corresponding
+# with the last axis; we return it as a tuple (p_1, p_2, ..., p_n) so that it looks
+# like `n` scalar (or arrays of scalar-valued) shape parameters to the infrastructure.
+
+def _parse_args_rvs(self, p, loc=0, size=None):
+    return tuple(np.moveaxis(p, -1, 0)), loc, 1.0, size
+
+def _parse_args_stats(self, p, loc=0, moments='mv'):
+    return tuple(np.moveaxis(p, -1, 0)), loc, 1.0, moments
+
+def _parse_args(self, p, loc=0):
+    return tuple(np.moveaxis(p, -1, 0)), loc, 1.0
+
+# The infrastructure manually binds these methods to the instance, so
+# we can only override them by manually binding them, too.
+_pb_obj, _pb_cls = poisson_binom, poisson_binom_gen  # shorter names (for PEP8)
+poisson_binom._parse_args_rvs = _parse_args_rvs.__get__(_pb_obj, _pb_cls)
+poisson_binom._parse_args_stats = _parse_args_stats.__get__(_pb_obj, _pb_cls)
+poisson_binom._parse_args = _parse_args.__get__(_pb_obj, _pb_cls)
+
+class poisson_binomial_frozen(rv_discrete_frozen):
+    # copied from rv_frozen; we just need to bind the `_parse_args` methods
+    def __init__(self, dist, *args, **kwds):                        # verbatim
+        self.args = args                                            # verbatim
+        self.kwds = kwds                                            # verbatim
+
+        # create a new instance                                     # verbatim
+        self.dist = dist.__class__(**dist._updated_ctor_param())    # verbatim
+
+        # Here is the only modification
+        self.dist._parse_args_rvs = _parse_args_rvs.__get__(_pb_obj, _pb_cls)
+        self.dist._parse_args_stats = _parse_args_stats.__get__(_pb_obj, _pb_cls)
+        self.dist._parse_args = _parse_args.__get__(_pb_obj, _pb_cls)
+
+        shapes, _, _ = self.dist._parse_args(*args, **kwds)         # verbatim
+        self.a, self.b = self.dist._get_support(*shapes)            # verbatim
+
+    def expect(self, func=None, lb=None, ub=None, conditional=False, **kwds):
+        a, loc, scale = self.dist._parse_args(*self.args, **self.kwds)
+        # Here's the modification: we pass all args (including `loc`) into the `args`
+        # parameter of `expect` so the shape only goes through `_parse_args` once.
+        return self.dist.expect(func, self.args, loc, lb, ub, conditional, **kwds)
+
+
+class skellam_gen(rv_discrete):
+    r"""A  Skellam discrete random variable.
+
+    %(before_notes)s
+
+    Notes
+    -----
+    Probability distribution of the difference of two correlated or
+    uncorrelated Poisson random variables.
+
+    Let :math:`k_1` and :math:`k_2` be two Poisson-distributed r.v. with
+    expected values :math:`\lambda_1` and :math:`\lambda_2`. Then,
+    :math:`k_1 - k_2` follows a Skellam distribution with parameters
+    :math:`\mu_1 = \lambda_1 - \rho \sqrt{\lambda_1 \lambda_2}` and
+    :math:`\mu_2 = \lambda_2 - \rho \sqrt{\lambda_1 \lambda_2}`, where
+    :math:`\rho` is the correlation coefficient between :math:`k_1` and
+    :math:`k_2`. If the two Poisson-distributed r.v. are independent then
+    :math:`\rho = 0`.
+
+    Parameters :math:`\mu_1` and :math:`\mu_2` must be strictly positive.
+
+    For details see: https://en.wikipedia.org/wiki/Skellam_distribution
+
+    `skellam` takes :math:`\mu_1` and :math:`\mu_2` as shape parameters.
+
+    %(after_notes)s
+
+    %(example)s
+
+    """
+    def _shape_info(self):
+        return [_ShapeInfo("mu1", False, (0, np.inf), (False, False)),
+                _ShapeInfo("mu2", False, (0, np.inf), (False, False))]
+
+    def _rvs(self, mu1, mu2, size=None, random_state=None):
+        n = size
+        return (random_state.poisson(mu1, n) -
+                random_state.poisson(mu2, n))
+
+    def _pmf(self, x, mu1, mu2):
+        with np.errstate(over='ignore'):  # see gh-17432
+            px = np.where(x < 0,
+                          scu._ncx2_pdf(2*mu2, 2*(1-x), 2*mu1)*2,
+                          scu._ncx2_pdf(2*mu1, 2*(1+x), 2*mu2)*2)
+            # ncx2.pdf() returns nan's for extremely low probabilities
+        return px
+
+    def _cdf(self, x, mu1, mu2):
+        x = floor(x)
+        with np.errstate(over='ignore'):  # see gh-17432
+            px = np.where(x < 0,
+                          scu._ncx2_cdf(2*mu2, -2*x, 2*mu1),
+                          1 - scu._ncx2_cdf(2*mu1, 2*(x+1), 2*mu2))
+        return px
+
+    def _stats(self, mu1, mu2):
+        mean = mu1 - mu2
+        var = mu1 + mu2
+        g1 = mean / sqrt((var)**3)
+        g2 = 1 / var
+        return mean, var, g1, g2
+
+
+skellam = skellam_gen(a=-np.inf, name="skellam", longname='A Skellam')
+
+
+class yulesimon_gen(rv_discrete):
+    r"""A Yule-Simon discrete random variable.
+
+    %(before_notes)s
+
+    Notes
+    -----
+
+    The probability mass function for the `yulesimon` is:
+
+    .. math::
+
+        f(k) =  \alpha B(k, \alpha+1)
+
+    for :math:`k=1,2,3,...`, where :math:`\alpha>0`.
+    Here :math:`B` refers to the `scipy.special.beta` function.
+
+    The sampling of random variates is based on pg 553, Section 6.3 of [1]_.
+    Our notation maps to the referenced logic via :math:`\alpha=a-1`.
+
+    For details see the wikipedia entry [2]_.
+
+    References
+    ----------
+    .. [1] Devroye, Luc. "Non-uniform Random Variate Generation",
+         (1986) Springer, New York.
+
+    .. [2] https://en.wikipedia.org/wiki/Yule-Simon_distribution
+
+    %(after_notes)s
+
+    %(example)s
+
+    """
+    def _shape_info(self):
+        return [_ShapeInfo("alpha", False, (0, np.inf), (False, False))]
+
+    def _rvs(self, alpha, size=None, random_state=None):
+        E1 = random_state.standard_exponential(size)
+        E2 = random_state.standard_exponential(size)
+        ans = ceil(-E1 / log1p(-exp(-E2 / alpha)))
+        return ans
+
+    def _pmf(self, x, alpha):
+        return alpha * special.beta(x, alpha + 1)
+
+    def _argcheck(self, alpha):
+        return (alpha > 0)
+
+    def _logpmf(self, x, alpha):
+        return log(alpha) + special.betaln(x, alpha + 1)
+
+    def _cdf(self, x, alpha):
+        return 1 - x * special.beta(x, alpha + 1)
+
+    def _sf(self, x, alpha):
+        return x * special.beta(x, alpha + 1)
+
+    def _logsf(self, x, alpha):
+        return log(x) + special.betaln(x, alpha + 1)
+
+    def _stats(self, alpha):
+        mu = np.where(alpha <= 1, np.inf, alpha / (alpha - 1))
+        mu2 = np.where(alpha > 2,
+                       alpha**2 / ((alpha - 2.0) * (alpha - 1)**2),
+                       np.inf)
+        mu2 = np.where(alpha <= 1, np.nan, mu2)
+        g1 = np.where(alpha > 3,
+                      sqrt(alpha - 2) * (alpha + 1)**2 / (alpha * (alpha - 3)),
+                      np.inf)
+        g1 = np.where(alpha <= 2, np.nan, g1)
+        g2 = np.where(alpha > 4,
+                      alpha + 3 + ((11 * alpha**3 - 49 * alpha - 22) /
+                                   (alpha * (alpha - 4) * (alpha - 3))),
+                      np.inf)
+        g2 = np.where(alpha <= 2, np.nan, g2)
+        return mu, mu2, g1, g2
+
+
+yulesimon = yulesimon_gen(name='yulesimon', a=1)
+
+
+class _nchypergeom_gen(rv_discrete):
+    r"""A noncentral hypergeometric discrete random variable.
+
+    For subclassing by nchypergeom_fisher_gen and nchypergeom_wallenius_gen.
+
+    """
+
+    rvs_name = None
+    dist = None
+
+    def _shape_info(self):
+        return [_ShapeInfo("M", True, (0, np.inf), (True, False)),
+                _ShapeInfo("n", True, (0, np.inf), (True, False)),
+                _ShapeInfo("N", True, (0, np.inf), (True, False)),
+                _ShapeInfo("odds", False, (0, np.inf), (False, False))]
+
+    def _get_support(self, M, n, N, odds):
+        N, m1, n = M, n, N  # follow Wikipedia notation
+        m2 = N - m1
+        x_min = np.maximum(0, n - m2)
+        x_max = np.minimum(n, m1)
+        return x_min, x_max
+
+    def _argcheck(self, M, n, N, odds):
+        M, n = np.asarray(M), np.asarray(n),
+        N, odds = np.asarray(N), np.asarray(odds)
+        cond1 = (M.astype(int) == M) & (M >= 0)
+        cond2 = (n.astype(int) == n) & (n >= 0)
+        cond3 = (N.astype(int) == N) & (N >= 0)
+        cond4 = odds > 0
+        cond5 = N <= M
+        cond6 = n <= M
+        return cond1 & cond2 & cond3 & cond4 & cond5 & cond6
+
+    def _rvs(self, M, n, N, odds, size=None, random_state=None):
+
+        @_vectorize_rvs_over_shapes
+        def _rvs1(M, n, N, odds, size, random_state):
+            length = np.prod(size)
+            urn = _PyStochasticLib3()
+            rv_gen = getattr(urn, self.rvs_name)
+            rvs = rv_gen(N, n, M, odds, length, random_state)
+            rvs = rvs.reshape(size)
+            return rvs
+
+        return _rvs1(M, n, N, odds, size=size, random_state=random_state)
+
+    def _pmf(self, x, M, n, N, odds):
+
+        x, M, n, N, odds = np.broadcast_arrays(x, M, n, N, odds)
+        if x.size == 0:  # np.vectorize doesn't work with zero size input
+            return np.empty_like(x)
+
+        @np.vectorize
+        def _pmf1(x, M, n, N, odds):
+            urn = self.dist(N, n, M, odds, 1e-12)
+            return urn.probability(x)
+
+        return _pmf1(x, M, n, N, odds)
+
+    def _stats(self, M, n, N, odds, moments):
+
+        @np.vectorize
+        def _moments1(M, n, N, odds):
+            urn = self.dist(N, n, M, odds, 1e-12)
+            return urn.moments()
+
+        m, v = (_moments1(M, n, N, odds) if ("m" in moments or "v" in moments)
+                else (None, None))
+        s, k = None, None
+        return m, v, s, k
+
+
+class nchypergeom_fisher_gen(_nchypergeom_gen):
+    r"""A Fisher's noncentral hypergeometric discrete random variable.
+
+    Fisher's noncentral hypergeometric distribution models drawing objects of
+    two types from a bin. `M` is the total number of objects, `n` is the
+    number of Type I objects, and `odds` is the odds ratio: the odds of
+    selecting a Type I object rather than a Type II object when there is only
+    one object of each type.
+    The random variate represents the number of Type I objects drawn if we
+    take a handful of objects from the bin at once and find out afterwards
+    that we took `N` objects.
+
+    %(before_notes)s
+
+    See Also
+    --------
+    nchypergeom_wallenius, hypergeom, nhypergeom
+
+    Notes
+    -----
+    Let mathematical symbols :math:`N`, :math:`n`, and :math:`M` correspond
+    with parameters `N`, `n`, and `M` (respectively) as defined above.
+
+    The probability mass function is defined as
+
+    .. math::
+
+        p(x; M, n, N, \omega) =
+        \frac{\binom{n}{x}\binom{M - n}{N-x}\omega^x}{P_0},
+
+    for
+    :math:`x \in [x_l, x_u]`,
+    :math:`M \in {\mathbb N}`,
+    :math:`n \in [0, M]`,
+    :math:`N \in [0, M]`,
+    :math:`\omega > 0`,
+    where
+    :math:`x_l = \max(0, N - (M - n))`,
+    :math:`x_u = \min(N, n)`,
+
+    .. math::
+
+        P_0 = \sum_{y=x_l}^{x_u} \binom{n}{y}\binom{M - n}{N-y}\omega^y,
+
+    and the binomial coefficients are defined as
+
+    .. math:: \binom{n}{k} \equiv \frac{n!}{k! (n - k)!}.
+
+    `nchypergeom_fisher` uses the BiasedUrn package by Agner Fog with
+    permission for it to be distributed under SciPy's license.
+
+    The symbols used to denote the shape parameters (`N`, `n`, and `M`) are not
+    universally accepted; they are chosen for consistency with `hypergeom`.
+
+    Note that Fisher's noncentral hypergeometric distribution is distinct
+    from Wallenius' noncentral hypergeometric distribution, which models
+    drawing a pre-determined `N` objects from a bin one by one.
+    When the odds ratio is unity, however, both distributions reduce to the
+    ordinary hypergeometric distribution.
+
+    %(after_notes)s
+
+    References
+    ----------
+    .. [1] Agner Fog, "Biased Urn Theory".
+           https://cran.r-project.org/web/packages/BiasedUrn/vignettes/UrnTheory.pdf
+
+    .. [2] "Fisher's noncentral hypergeometric distribution", Wikipedia,
+           https://en.wikipedia.org/wiki/Fisher's_noncentral_hypergeometric_distribution
+
+    %(example)s
+
+    """
+
+    rvs_name = "rvs_fisher"
+    dist = _PyFishersNCHypergeometric
+
+
+nchypergeom_fisher = nchypergeom_fisher_gen(
+    name='nchypergeom_fisher',
+    longname="A Fisher's noncentral hypergeometric")
+
+
+class nchypergeom_wallenius_gen(_nchypergeom_gen):
+    r"""A Wallenius' noncentral hypergeometric discrete random variable.
+
+    Wallenius' noncentral hypergeometric distribution models drawing objects of
+    two types from a bin. `M` is the total number of objects, `n` is the
+    number of Type I objects, and `odds` is the odds ratio: the odds of
+    selecting a Type I object rather than a Type II object when there is only
+    one object of each type.
+    The random variate represents the number of Type I objects drawn if we
+    draw a pre-determined `N` objects from a bin one by one.
+
+    %(before_notes)s
+
+    See Also
+    --------
+    nchypergeom_fisher, hypergeom, nhypergeom
+
+    Notes
+    -----
+    Let mathematical symbols :math:`N`, :math:`n`, and :math:`M` correspond
+    with parameters `N`, `n`, and `M` (respectively) as defined above.
+
+    The probability mass function is defined as
+
+    .. math::
+
+        p(x; N, n, M) = \binom{n}{x} \binom{M - n}{N-x}
+        \int_0^1 \left(1-t^{\omega/D}\right)^x\left(1-t^{1/D}\right)^{N-x} dt
+
+    for
+    :math:`x \in [x_l, x_u]`,
+    :math:`M \in {\mathbb N}`,
+    :math:`n \in [0, M]`,
+    :math:`N \in [0, M]`,
+    :math:`\omega > 0`,
+    where
+    :math:`x_l = \max(0, N - (M - n))`,
+    :math:`x_u = \min(N, n)`,
+
+    .. math::
+
+        D = \omega(n - x) + ((M - n)-(N-x)),
+
+    and the binomial coefficients are defined as
+
+    .. math:: \binom{n}{k} \equiv \frac{n!}{k! (n - k)!}.
+
+    `nchypergeom_wallenius` uses the BiasedUrn package by Agner Fog with
+    permission for it to be distributed under SciPy's license.
+
+    The symbols used to denote the shape parameters (`N`, `n`, and `M`) are not
+    universally accepted; they are chosen for consistency with `hypergeom`.
+
+    Note that Wallenius' noncentral hypergeometric distribution is distinct
+    from Fisher's noncentral hypergeometric distribution, which models
+    take a handful of objects from the bin at once, finding out afterwards
+    that `N` objects were taken.
+    When the odds ratio is unity, however, both distributions reduce to the
+    ordinary hypergeometric distribution.
+
+    %(after_notes)s
+
+    References
+    ----------
+    .. [1] Agner Fog, "Biased Urn Theory".
+           https://cran.r-project.org/web/packages/BiasedUrn/vignettes/UrnTheory.pdf
+
+    .. [2] "Wallenius' noncentral hypergeometric distribution", Wikipedia,
+           https://en.wikipedia.org/wiki/Wallenius'_noncentral_hypergeometric_distribution
+
+    %(example)s
+
+    """
+
+    rvs_name = "rvs_wallenius"
+    dist = _PyWalleniusNCHypergeometric
+
+
+nchypergeom_wallenius = nchypergeom_wallenius_gen(
+    name='nchypergeom_wallenius',
+    longname="A Wallenius' noncentral hypergeometric")
+
+
+# Collect names of classes and objects in this module.
+pairs = list(globals().copy().items())
+_distn_names, _distn_gen_names = get_distribution_names(pairs, rv_discrete)
+
+__all__ = _distn_names + _distn_gen_names

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/stats/_distr_params.py

@@ -0,0 +1,299 @@
+"""
+Sane parameters for stats.distributions.
+"""
+import numpy as np
+
+distcont = [
+    ['alpha', (3.5704770516650459,)],
+    ['anglit', ()],
+    ['arcsine', ()],
+    ['argus', (1.0,)],
+    ['beta', (2.3098496451481823, 0.62687954300963677)],
+    ['betaprime', (5, 6)],
+    ['bradford', (0.29891359763170633,)],
+    ['burr', (10.5, 4.3)],
+    ['burr12', (10, 4)],
+    ['cauchy', ()],
+    ['chi', (78,)],
+    ['chi2', (55,)],
+    ['cosine', ()],
+    ['crystalball', (2.0, 3.0)],
+    ['dgamma', (1.1023326088288166,)],
+    ['dpareto_lognorm', (3, 1.2, 1.5, 2)],
+    ['dweibull', (2.0685080649914673,)],
+    ['erlang', (10,)],
+    ['expon', ()],
+    ['exponnorm', (1.5,)],
+    ['exponpow', (2.697119160358469,)],
+    ['exponweib', (2.8923945291034436, 1.9505288745913174)],
+    ['f', (29, 18)],
+    ['fatiguelife', (29,)],   # correction numargs = 1
+    ['fisk', (3.0857548622253179,)],
+    ['foldcauchy', (4.7164673455831894,)],
+    ['foldnorm', (1.9521253373555869,)],
+    ['gamma', (1.9932305483800778,)],
+    ['gausshyper', (13.763771604130699, 3.1189636648681431,
+                    2.5145980350183019, 5.1811649903971615)],  # veryslow
+    ['genexpon', (9.1325976465418908, 16.231956600590632, 3.2819552690843983)],
+    ['genextreme', (-0.1,)],
+    ['gengamma', (4.4162385429431925, 3.1193091679242761)],
+    ['gengamma', (4.4162385429431925, -3.1193091679242761)],
+    ['genhalflogistic', (0.77274727809929322,)],
+    ['genhyperbolic', (0.5, 1.5, -0.5,)],
+    ['geninvgauss', (2.3, 1.5)],
+    ['genlogistic', (0.41192440799679475,)],
+    ['gennorm', (1.2988442399460265,)],
+    ['halfgennorm', (0.6748054997000371,)],
+    ['genpareto', (0.1,)],   # use case with finite moments
+    ['gibrat', ()],
+    ['gompertz', (0.94743713075105251,)],
+    ['gumbel_l', ()],
+    ['gumbel_r', ()],
+    ['halfcauchy', ()],
+    ['halflogistic', ()],
+    ['halfnorm', ()],
+    ['hypsecant', ()],
+    ['invgamma', (4.0668996136993067,)],
+    ['invgauss', (0.14546264555347513,)],
+    ['invweibull', (10.58,)],
+    ['irwinhall', (10,)],
+    ['jf_skew_t', (8, 4)],
+    ['johnsonsb', (4.3172675099141058, 3.1837781130785063)],
+    ['johnsonsu', (2.554395574161155, 2.2482281679651965)],
+    ['kappa4', (0.0, 0.0)],
+    ['kappa4', (-0.1, 0.1)],
+    ['kappa4', (0.0, 0.1)],
+    ['kappa4', (0.1, 0.0)],
+    ['kappa3', (1.0,)],
+    ['ksone', (1000,)],  # replace 22 by 100 to avoid failing range, ticket 956
+    ['kstwo', (10,)],
+    ['kstwobign', ()],
+    ['landau', ()],
+    ['laplace', ()],
+    ['laplace_asymmetric', (2,)],
+    ['levy', ()],
+    ['levy_l', ()],
+    ['levy_stable', (1.8, -0.5)],
+    ['loggamma', (0.41411931826052117,)],
+    ['logistic', ()],
+    ['loglaplace', (3.2505926592051435,)],
+    ['lognorm', (0.95368226960575331,)],
+    ['loguniform', (0.01, 1.25)],
+    ['lomax', (1.8771398388773268,)],
+    ['maxwell', ()],
+    ['mielke', (10.4, 4.6)],
+    ['moyal', ()],
+    ['nakagami', (4.9673794866666237,)],
+    ['ncf', (27, 27, 0.41578441799226107)],
+    ['nct', (14, 0.24045031331198066)],
+    ['ncx2', (21, 1.0560465975116415)],
+    ['norm', ()],
+    ['norminvgauss', (1.25, 0.5)],
+    ['pareto', (2.621716532144454,)],
+    ['pearson3', (0.1,)],
+    ['pearson3', (-2,)],
+    ['powerlaw', (1.6591133289905851,)],
+    ['powerlaw', (0.6591133289905851,)],
+    ['powerlognorm', (2.1413923530064087, 0.44639540782048337)],
+    ['powernorm', (4.4453652254590779,)],
+    ['rayleigh', ()],
+    ['rdist', (1.6,)],
+    ['recipinvgauss', (0.63004267809369119,)],
+    ['reciprocal', (0.01, 1.25)],
+    ['rel_breitwigner', (36.545206797050334, )],
+    ['rice', (0.7749725210111873,)],
+    ['semicircular', ()],
+    ['skewcauchy', (0.5,)],
+    ['skewnorm', (4.0,)],
+    ['studentized_range', (3.0, 10.0)],
+    ['t', (2.7433514990818093,)],
+    ['trapezoid', (0.2, 0.8)],
+    ['triang', (0.15785029824528218,)],
+    ['truncexpon', (4.6907725456810478,)],
+    ['truncnorm', (-1.0978730080013919, 2.7306754109031979)],
+    ['truncnorm', (0.1, 2.)],
+    ['truncpareto', (1.8, 5.3)],
+    ['truncpareto', (2, 5)],
+    ['truncweibull_min', (2.5, 0.25, 1.75)],
+    ['tukeylambda', (3.1321477856738267,)],
+    ['uniform', ()],
+    ['vonmises', (3.9939042581071398,)],
+    ['vonmises_line', (3.9939042581071398,)],
+    ['wald', ()],
+    ['weibull_max', (2.8687961709100187,)],
+    ['weibull_min', (1.7866166930421596,)],
+    ['wrapcauchy', (0.031071279018614728,)]
+]
+
+
+distdiscrete = [
+    ['bernoulli',(0.3,)],
+    ['betabinom', (5, 2.3, 0.63)],
+    ['betanbinom', (5, 9.3, 1)],
+    ['binom', (5, 0.4)],
+    ['boltzmann',(1.4, 19)],
+    ['dlaplace', (0.8,)],  # 0.5
+    ['geom', (0.5,)],
+    ['hypergeom',(30, 12, 6)],
+    ['hypergeom',(21,3,12)],  # numpy.random (3,18,12) numpy ticket:921
+    ['hypergeom',(21,18,11)],  # numpy.random (18,3,11) numpy ticket:921
+    ['nchypergeom_fisher', (140, 80, 60, 0.5)],
+    ['nchypergeom_wallenius', (140, 80, 60, 0.5)],
+    ['logser', (0.6,)],  # re-enabled, numpy ticket:921
+    ['nbinom', (0.4, 0.4)],  # from tickets: 583
+    ['nbinom', (5, 0.5)],
+    ['planck', (0.51,)],   # 4.1
+    ['poisson', (0.6,)],
+    ['poisson_binom', ([0.1, 0.6, 0.7, 0.8],)],
+    ['randint', (7, 31)],
+    ['skellam', (15, 8)],
+    ['zipf', (6.6,)],
+    ['zipfian', (0.75, 15)],
+    ['zipfian', (1.25, 10)],
+    ['yulesimon', (11.0,)],
+    ['nhypergeom', (20, 7, 1)]
+]
+
+
+invdistdiscrete = [
+    # In each of the following, at least one shape parameter is invalid
+    ['hypergeom', (3, 3, 4)],
+    ['nhypergeom', (5, 2, 8)],
+    ['nchypergeom_fisher', (3, 3, 4, 1)],
+    ['nchypergeom_wallenius', (3, 3, 4, 1)],
+    ['bernoulli', (1.5, )],
+    ['binom', (10, 1.5)],
+    ['betabinom', (10, -0.4, -0.5)],
+    ['betanbinom', (10, -0.4, -0.5)],
+    ['boltzmann', (-1, 4)],
+    ['dlaplace', (-0.5, )],
+    ['geom', (1.5, )],
+    ['logser', (1.5, )],
+    ['nbinom', (10, 1.5)],
+    ['planck', (-0.5, )],
+    ['poisson', (-0.5, )],
+    ['poisson_binom', ([-1, 2, 0.5],)],
+    ['randint', (5, 2)],
+    ['skellam', (-5, -2)],
+    ['zipf', (-2, )],
+    ['yulesimon', (-2, )],
+    ['zipfian', (-0.75, 15)]
+]
+
+
+invdistcont = [
+    # In each of the following, at least one shape parameter is invalid
+    ['alpha', (-1, )],
+    ['anglit', ()],
+    ['arcsine', ()],
+    ['argus', (-1, )],
+    ['beta', (-2, 2)],
+    ['betaprime', (-2, 2)],
+    ['bradford', (-1, )],
+    ['burr', (-1, 1)],
+    ['burr12', (-1, 1)],
+    ['cauchy', ()],
+    ['chi', (-1, )],
+    ['chi2', (-1, )],
+    ['cosine', ()],
+    ['crystalball', (-1, 2)],
+    ['dgamma', (-1, )],
+    ['dpareto_lognorm', (3, -1.2, 1.5, 2)],
+    ['dweibull', (-1, )],
+    ['erlang', (-1, )],
+    ['expon', ()],
+    ['exponnorm', (-1, )],
+    ['exponweib', (1, -1)],
+    ['exponpow', (-1, )],
+    ['f', (10, -10)],
+    ['fatiguelife', (-1, )],
+    ['fisk', (-1, )],
+    ['foldcauchy', (-1, )],
+    ['foldnorm', (-1, )],
+    ['genlogistic', (-1, )],
+    ['gennorm', (-1, )],
+    ['genpareto', (np.inf, )],
+    ['genexpon', (1, 2, -3)],
+    ['genextreme', (np.inf, )],
+    ['genhyperbolic', (0.5, -0.5, -1.5,)],
+    ['gausshyper', (1, 2, 3, -4)],
+    ['gamma', (-1, )],
+    ['gengamma', (-1, 0)],
+    ['genhalflogistic', (-1, )],
+    ['geninvgauss', (1, 0)],
+    ['gibrat', ()],
+    ['gompertz', (-1, )],
+    ['gumbel_r', ()],
+    ['gumbel_l', ()],
+    ['halfcauchy', ()],
+    ['halflogistic', ()],
+    ['halfnorm', ()],
+    ['halfgennorm', (-1, )],
+    ['hypsecant', ()],
+    ['invgamma', (-1, )],
+    ['invgauss', (-1, )],
+    ['invweibull', (-1, )],
+    ['irwinhall', (-1,)],
+    ['irwinhall', (0,)],
+    ['irwinhall', (2.5,)],
+    ['jf_skew_t', (-1, 0)],
+    ['johnsonsb', (1, -2)],
+    ['johnsonsu', (1, -2)],
+    ['kappa4', (np.nan, 0)],
+    ['kappa3', (-1, )],
+    ['ksone', (-1, )],
+    ['kstwo', (-1, )],
+    ['kstwobign', ()],
+    ['landau', ()],
+    ['laplace', ()],
+    ['laplace_asymmetric', (-1, )],
+    ['levy', ()],
+    ['levy_l', ()],
+    ['levy_stable', (-1, 1)],
+    ['logistic', ()],
+    ['loggamma', (-1, )],
+    ['loglaplace', (-1, )],
+    ['lognorm', (-1, )],
+    ['loguniform', (10, 5)],
+    ['lomax', (-1, )],
+    ['maxwell', ()],
+    ['mielke', (1, -2)],
+    ['moyal', ()],
+    ['nakagami', (-1, )],
+    ['ncx2', (-1, 2)],
+    ['ncf', (10, 20, -1)],
+    ['nct', (-1, 2)],
+    ['norm', ()],
+    ['norminvgauss', (5, -10)],
+    ['pareto', (-1, )],
+    ['pearson3', (np.nan, )],
+    ['powerlaw', (-1, )],
+    ['powerlognorm', (1, -2)],
+    ['powernorm', (-1, )],
+    ['rdist', (-1, )],
+    ['rayleigh', ()],
+    ['rice', (-1, )],
+    ['recipinvgauss', (-1, )],
+    ['semicircular', ()],
+    ['skewnorm', (np.inf, )],
+    ['studentized_range', (-1, 1)],
+    ['rel_breitwigner', (-2, )],
+    ['t', (-1, )],
+    ['trapezoid', (0, 2)],
+    ['triang', (2, )],
+    ['truncexpon', (-1, )],
+    ['truncnorm', (10, 5)],
+    ['truncpareto', (-1, 5)],
+    ['truncpareto', (1.8, .5)],
+    ['truncweibull_min', (-2.5, 0.25, 1.75)],
+    ['tukeylambda', (np.nan, )],
+    ['uniform', ()],
+    ['vonmises', (-1, )],
+    ['vonmises_line', (-1, )],
+    ['wald', ()],
+    ['weibull_min', (-1, )],
+    ['weibull_max', (-1, )],
+    ['wrapcauchy', (2, )],
+    ['reciprocal', (15, 10)],
+    ['skewcauchy', (2, )]
+]

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/stats/_entropy.py

@@ -0,0 +1,429 @@
+"""
+Created on Fri Apr  2 09:06:05 2021
+
+@author: matth
+"""
+
+import math
+import numpy as np
+from scipy import special
+from ._axis_nan_policy import _axis_nan_policy_factory, _broadcast_arrays
+from scipy._lib._array_api import array_namespace, xp_moveaxis_to_end
+
+__all__ = ['entropy', 'differential_entropy']
+
+
+@_axis_nan_policy_factory(
+    lambda x: x,
+    n_samples=lambda kwgs: (
+        2 if ("qk" in kwgs and kwgs["qk"] is not None)
+        else 1
+    ),
+    n_outputs=1, result_to_tuple=lambda x: (x,), paired=True,
+    too_small=-1  # entropy doesn't have too small inputs
+)
+def entropy(pk: np.typing.ArrayLike,
+            qk: np.typing.ArrayLike | None = None,
+            base: float | None = None,
+            axis: int = 0
+            ) -> np.number | np.ndarray:
+    """
+    Calculate the Shannon entropy/relative entropy of given distribution(s).
+
+    If only probabilities `pk` are given, the Shannon entropy is calculated as
+    ``H = -sum(pk * log(pk))``.
+
+    If `qk` is not None, then compute the relative entropy
+    ``D = sum(pk * log(pk / qk))``. This quantity is also known
+    as the Kullback-Leibler divergence.
+
+    This routine will normalize `pk` and `qk` if they don't sum to 1.
+
+    Parameters
+    ----------
+    pk : array_like
+        Defines the (discrete) distribution. Along each axis-slice of ``pk``,
+        element ``i`` is the  (possibly unnormalized) probability of event
+        ``i``.
+    qk : array_like, optional
+        Sequence against which the relative entropy is computed. Should be in
+        the same format as `pk`.
+    base : float, optional
+        The logarithmic base to use, defaults to ``e`` (natural logarithm).
+    axis : int, optional
+        The axis along which the entropy is calculated. Default is 0.
+
+    Returns
+    -------
+    S : {float, array_like}
+        The calculated entropy.
+
+    Notes
+    -----
+    Informally, the Shannon entropy quantifies the expected uncertainty
+    inherent in the possible outcomes of a discrete random variable.
+    For example,
+    if messages consisting of sequences of symbols from a set are to be
+    encoded and transmitted over a noiseless channel, then the Shannon entropy
+    ``H(pk)`` gives a tight lower bound for the average number of units of
+    information needed per symbol if the symbols occur with frequencies
+    governed by the discrete distribution `pk` [1]_. The choice of base
+    determines the choice of units; e.g., ``e`` for nats, ``2`` for bits, etc.
+
+    The relative entropy, ``D(pk|qk)``, quantifies the increase in the average
+    number of units of information needed per symbol if the encoding is
+    optimized for the probability distribution `qk` instead of the true
+    distribution `pk`. Informally, the relative entropy quantifies the expected
+    excess in surprise experienced if one believes the true distribution is
+    `qk` when it is actually `pk`.
+
+    A related quantity, the cross entropy ``CE(pk, qk)``, satisfies the
+    equation ``CE(pk, qk) = H(pk) + D(pk|qk)`` and can also be calculated with
+    the formula ``CE = -sum(pk * log(qk))``. It gives the average
+    number of units of information needed per symbol if an encoding is
+    optimized for the probability distribution `qk` when the true distribution
+    is `pk`. It is not computed directly by `entropy`, but it can be computed
+    using two calls to the function (see Examples).
+
+    See [2]_ for more information.
+
+    References
+    ----------
+    .. [1] Shannon, C.E. (1948), A Mathematical Theory of Communication.
+           Bell System Technical Journal, 27: 379-423.
+           https://doi.org/10.1002/j.1538-7305.1948.tb01338.x
+    .. [2] Thomas M. Cover and Joy A. Thomas. 2006. Elements of Information
+           Theory (Wiley Series in Telecommunications and Signal Processing).
+           Wiley-Interscience, USA.
+
+
+    Examples
+    --------
+    The outcome of a fair coin is the most uncertain:
+
+    >>> import numpy as np
+    >>> from scipy.stats import entropy
+    >>> base = 2  # work in units of bits
+    >>> pk = np.array([1/2, 1/2])  # fair coin
+    >>> H = entropy(pk, base=base)
+    >>> H
+    1.0
+    >>> H == -np.sum(pk * np.log(pk)) / np.log(base)
+    True
+
+    The outcome of a biased coin is less uncertain:
+
+    >>> qk = np.array([9/10, 1/10])  # biased coin
+    >>> entropy(qk, base=base)
+    0.46899559358928117
+
+    The relative entropy between the fair coin and biased coin is calculated
+    as:
+
+    >>> D = entropy(pk, qk, base=base)
+    >>> D
+    0.7369655941662062
+    >>> np.isclose(D, np.sum(pk * np.log(pk/qk)) / np.log(base), rtol=4e-16, atol=0)
+    True
+
+    The cross entropy can be calculated as the sum of the entropy and
+    relative entropy`:
+
+    >>> CE = entropy(pk, base=base) + entropy(pk, qk, base=base)
+    >>> CE
+    1.736965594166206
+    >>> CE == -np.sum(pk * np.log(qk)) / np.log(base)
+    True
+
+    """
+    if base is not None and base <= 0:
+        raise ValueError("`base` must be a positive number or `None`.")
+
+    xp = array_namespace(pk) if qk is None else array_namespace(pk, qk)
+
+    pk = xp.asarray(pk)
+    with np.errstate(invalid='ignore'):
+        pk = 1.0*pk / xp.sum(pk, axis=axis, keepdims=True)  # type: ignore[operator]
+    if qk is None:
+        vec = special.entr(pk)
+    else:
+        qk = xp.asarray(qk)
+        pk, qk = _broadcast_arrays((pk, qk), axis=None, xp=xp)  # don't ignore any axes
+        sum_kwargs = dict(axis=axis, keepdims=True)
+        qk = 1.0*qk / xp.sum(qk, **sum_kwargs)  # type: ignore[operator, call-overload]
+        vec = special.rel_entr(pk, qk)
+    S = xp.sum(vec, axis=axis)
+    if base is not None:
+        S /= math.log(base)
+    return S
+
+
+def _differential_entropy_is_too_small(samples, kwargs, axis=-1):
+    values = samples[0]
+    n = values.shape[axis]
+    window_length = kwargs.get("window_length",
+                               math.floor(math.sqrt(n) + 0.5))
+    if not 2 <= 2 * window_length < n:
+        return True
+    return False
+
+
+@_axis_nan_policy_factory(
+    lambda x: x, n_outputs=1, result_to_tuple=lambda x: (x,),
+    too_small=_differential_entropy_is_too_small
+)
+def differential_entropy(
+    values: np.typing.ArrayLike,
+    *,
+    window_length: int | None = None,
+    base: float | None = None,
+    axis: int = 0,
+    method: str = "auto",
+) -> np.number | np.ndarray:
+    r"""Given a sample of a distribution, estimate the differential entropy.
+
+    Several estimation methods are available using the `method` parameter. By
+    default, a method is selected based the size of the sample.
+
+    Parameters
+    ----------
+    values : sequence
+        Sample from a continuous distribution.
+    window_length : int, optional
+        Window length for computing Vasicek estimate. Must be an integer
+        between 1 and half of the sample size. If ``None`` (the default), it
+        uses the heuristic value
+
+        .. math::
+            \left \lfloor \sqrt{n} + 0.5 \right \rfloor
+
+        where :math:`n` is the sample size. This heuristic was originally
+        proposed in [2]_ and has become common in the literature.
+    base : float, optional
+        The logarithmic base to use, defaults to ``e`` (natural logarithm).
+    axis : int, optional
+        The axis along which the differential entropy is calculated.
+        Default is 0.
+    method : {'vasicek', 'van es', 'ebrahimi', 'correa', 'auto'}, optional
+        The method used to estimate the differential entropy from the sample.
+        Default is ``'auto'``.  See Notes for more information.
+
+    Returns
+    -------
+    entropy : float
+        The calculated differential entropy.
+
+    Notes
+    -----
+    This function will converge to the true differential entropy in the limit
+
+    .. math::
+        n \to \infty, \quad m \to \infty, \quad \frac{m}{n} \to 0
+
+    The optimal choice of ``window_length`` for a given sample size depends on
+    the (unknown) distribution. Typically, the smoother the density of the
+    distribution, the larger the optimal value of ``window_length`` [1]_.
+
+    The following options are available for the `method` parameter.
+
+    * ``'vasicek'`` uses the estimator presented in [1]_. This is
+      one of the first and most influential estimators of differential entropy.
+    * ``'van es'`` uses the bias-corrected estimator presented in [3]_, which
+      is not only consistent but, under some conditions, asymptotically normal.
+    * ``'ebrahimi'`` uses an estimator presented in [4]_, which was shown
+      in simulation to have smaller bias and mean squared error than
+      the Vasicek estimator.
+    * ``'correa'`` uses the estimator presented in [5]_ based on local linear
+      regression. In a simulation study, it had consistently smaller mean
+      square error than the Vasiceck estimator, but it is more expensive to
+      compute.
+    * ``'auto'`` selects the method automatically (default). Currently,
+      this selects ``'van es'`` for very small samples (<10), ``'ebrahimi'``
+      for moderate sample sizes (11-1000), and ``'vasicek'`` for larger
+      samples, but this behavior is subject to change in future versions.
+
+    All estimators are implemented as described in [6]_.
+
+    References
+    ----------
+    .. [1] Vasicek, O. (1976). A test for normality based on sample entropy.
+           Journal of the Royal Statistical Society:
+           Series B (Methodological), 38(1), 54-59.
+    .. [2] Crzcgorzewski, P., & Wirczorkowski, R. (1999). Entropy-based
+           goodness-of-fit test for exponentiality. Communications in
+           Statistics-Theory and Methods, 28(5), 1183-1202.
+    .. [3] Van Es, B. (1992). Estimating functionals related to a density by a
+           class of statistics based on spacings. Scandinavian Journal of
+           Statistics, 61-72.
+    .. [4] Ebrahimi, N., Pflughoeft, K., & Soofi, E. S. (1994). Two measures
+           of sample entropy. Statistics & Probability Letters, 20(3), 225-234.
+    .. [5] Correa, J. C. (1995). A new estimator of entropy. Communications
+           in Statistics-Theory and Methods, 24(10), 2439-2449.
+    .. [6] Noughabi, H. A. (2015). Entropy Estimation Using Numerical Methods.
+           Annals of Data Science, 2(2), 231-241.
+           https://link.springer.com/article/10.1007/s40745-015-0045-9
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy.stats import differential_entropy, norm
+
+    Entropy of a standard normal distribution:
+
+    >>> rng = np.random.default_rng()
+    >>> values = rng.standard_normal(100)
+    >>> differential_entropy(values)
+    1.3407817436640392
+
+    Compare with the true entropy:
+
+    >>> float(norm.entropy())
+    1.4189385332046727
+
+    For several sample sizes between 5 and 1000, compare the accuracy of
+    the ``'vasicek'``, ``'van es'``, and ``'ebrahimi'`` methods. Specifically,
+    compare the root mean squared error (over 1000 trials) between the estimate
+    and the true differential entropy of the distribution.
+
+    >>> from scipy import stats
+    >>> import matplotlib.pyplot as plt
+    >>>
+    >>>
+    >>> def rmse(res, expected):
+    ...     '''Root mean squared error'''
+    ...     return np.sqrt(np.mean((res - expected)**2))
+    >>>
+    >>>
+    >>> a, b = np.log10(5), np.log10(1000)
+    >>> ns = np.round(np.logspace(a, b, 10)).astype(int)
+    >>> reps = 1000  # number of repetitions for each sample size
+    >>> expected = stats.expon.entropy()
+    >>>
+    >>> method_errors = {'vasicek': [], 'van es': [], 'ebrahimi': []}
+    >>> for method in method_errors:
+    ...     for n in ns:
+    ...        rvs = stats.expon.rvs(size=(reps, n), random_state=rng)
+    ...        res = stats.differential_entropy(rvs, method=method, axis=-1)
+    ...        error = rmse(res, expected)
+    ...        method_errors[method].append(error)
+    >>>
+    >>> for method, errors in method_errors.items():
+    ...     plt.loglog(ns, errors, label=method)
+    >>>
+    >>> plt.legend()
+    >>> plt.xlabel('sample size')
+    >>> plt.ylabel('RMSE (1000 trials)')
+    >>> plt.title('Entropy Estimator Error (Exponential Distribution)')
+
+    """
+    xp = array_namespace(values)
+    values = xp.asarray(values)
+    if xp.isdtype(values.dtype, "integral"):  # type: ignore[union-attr]
+        values = xp.astype(values, xp.asarray(1.).dtype)
+    values = xp_moveaxis_to_end(values, axis, xp=xp)
+    n = values.shape[-1]  # type: ignore[union-attr]
+
+    if window_length is None:
+        window_length = math.floor(math.sqrt(n) + 0.5)
+
+    if not 2 <= 2 * window_length < n:
+        raise ValueError(
+            f"Window length ({window_length}) must be positive and less "
+            f"than half the sample size ({n}).",
+        )
+
+    if base is not None and base <= 0:
+        raise ValueError("`base` must be a positive number or `None`.")
+
+    sorted_data = xp.sort(values, axis=-1)
+
+    methods = {"vasicek": _vasicek_entropy,
+               "van es": _van_es_entropy,
+               "correa": _correa_entropy,
+               "ebrahimi": _ebrahimi_entropy,
+               "auto": _vasicek_entropy}
+    method = method.lower()
+    if method not in methods:
+        message = f"`method` must be one of {set(methods)}"
+        raise ValueError(message)
+
+    if method == "auto":
+        if n <= 10:
+            method = 'van es'
+        elif n <= 1000:
+            method = 'ebrahimi'
+        else:
+            method = 'vasicek'
+
+    res = methods[method](sorted_data, window_length, xp=xp)
+
+    if base is not None:
+        res /= math.log(base)
+
+    # avoid dtype changes due to data-apis/array-api-compat#152
+    # can be removed when data-apis/array-api-compat#152 is resolved
+    return xp.astype(res, values.dtype)  # type: ignore[union-attr]
+
+
+def _pad_along_last_axis(X, m, *, xp):
+    """Pad the data for computing the rolling window difference."""
+    # scales a  bit better than method in _vasicek_like_entropy
+    shape = X.shape[:-1] + (m,)
+    Xl = xp.broadcast_to(X[..., :1], shape)  # :1 vs 0 to maintain shape
+    Xr = xp.broadcast_to(X[..., -1:], shape)
+    return xp.concat((Xl, X, Xr), axis=-1)
+
+
+def _vasicek_entropy(X, m, *, xp):
+    """Compute the Vasicek estimator as described in [6] Eq. 1.3."""
+    n = X.shape[-1]
+    X = _pad_along_last_axis(X, m, xp=xp)
+    differences = X[..., 2 * m:] - X[..., : -2 * m:]
+    logs = xp.log(n/(2*m) * differences)
+    return xp.mean(logs, axis=-1)
+
+
+def _van_es_entropy(X, m, *, xp):
+    """Compute the van Es estimator as described in [6]."""
+    # No equation number, but referred to as HVE_mn.
+    # Typo: there should be a log within the summation.
+    n = X.shape[-1]
+    difference = X[..., m:] - X[..., :-m]
+    term1 = 1/(n-m) * xp.sum(xp.log((n+1)/m * difference), axis=-1)
+    k = xp.arange(m, n+1, dtype=term1.dtype)
+    return term1 + xp.sum(1/k) + math.log(m) - math.log(n+1)
+
+
+def _ebrahimi_entropy(X, m, *, xp):
+    """Compute the Ebrahimi estimator as described in [6]."""
+    # No equation number, but referred to as HE_mn
+    n = X.shape[-1]
+    X = _pad_along_last_axis(X, m, xp=xp)
+
+    differences = X[..., 2 * m:] - X[..., : -2 * m:]
+
+    i = xp.arange(1, n+1, dtype=X.dtype)
+    ci = xp.ones_like(i)*2
+    ci[i <= m] = 1 + (i[i <= m] - 1)/m
+    ci[i >= n - m + 1] = 1 + (n - i[i >= n-m+1])/m
+
+    logs = xp.log(n * differences / (ci * m))
+    return xp.mean(logs, axis=-1)
+
+
+def _correa_entropy(X, m, *, xp):
+    """Compute the Correa estimator as described in [6]."""
+    # No equation number, but referred to as HC_mn
+    n = X.shape[-1]
+    X = _pad_along_last_axis(X, m, xp=xp)
+
+    i = xp.arange(1, n+1)
+    dj = xp.arange(-m, m+1)[:, None]
+    j = i + dj
+    j0 = j + m - 1  # 0-indexed version of j
+
+    Xibar = xp.mean(X[..., j0], axis=-2, keepdims=True)
+    difference = X[..., j0] - Xibar
+    num = xp.sum(difference*dj, axis=-2)  # dj is d-i
+    den = n*xp.sum(difference**2, axis=-2)
+    return -xp.mean(xp.log(num/den), axis=-1)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/scipy/stats/_fit.py

@@ -0,0 +1,1351 @@
+import warnings
+from collections import namedtuple
+import numpy as np
+from scipy import optimize, stats
+from scipy._lib._util import check_random_state, _transition_to_rng
+
+
+def _combine_bounds(name, user_bounds, shape_domain, integral):
+    """Intersection of user-defined bounds and distribution PDF/PMF domain"""
+
+    user_bounds = np.atleast_1d(user_bounds)
+
+    if user_bounds[0] > user_bounds[1]:
+        message = (f"There are no values for `{name}` on the interval "
+                   f"{list(user_bounds)}.")
+        raise ValueError(message)
+
+    bounds = (max(user_bounds[0], shape_domain[0]),
+              min(user_bounds[1], shape_domain[1]))
+
+    if integral and (np.ceil(bounds[0]) > np.floor(bounds[1])):
+        message = (f"There are no integer values for `{name}` on the interval "
+                   f"defined by the user-provided bounds and the domain "
+                   "of the distribution.")
+        raise ValueError(message)
+    elif not integral and (bounds[0] > bounds[1]):
+        message = (f"There are no values for `{name}` on the interval "
+                   f"defined by the user-provided bounds and the domain "
+                   "of the distribution.")
+        raise ValueError(message)
+
+    if not np.all(np.isfinite(bounds)):
+        message = (f"The intersection of user-provided bounds for `{name}` "
+                   f"and the domain of the distribution is not finite. Please "
+                   f"provide finite bounds for shape `{name}` in `bounds`.")
+        raise ValueError(message)
+
+    return bounds
+
+
+class FitResult:
+    r"""Result of fitting a discrete or continuous distribution to data
+
+    Attributes
+    ----------
+    params : namedtuple
+        A namedtuple containing the maximum likelihood estimates of the
+        shape parameters, location, and (if applicable) scale of the
+        distribution.
+    success : bool or None
+        Whether the optimizer considered the optimization to terminate
+        successfully or not.
+    message : str or None
+        Any status message provided by the optimizer.
+
+    """
+
+    def __init__(self, dist, data, discrete, res):
+        self._dist = dist
+        self._data = data
+        self.discrete = discrete
+        self.pxf = getattr(dist, "pmf", None) or getattr(dist, "pdf", None)
+
+        shape_names = [] if dist.shapes is None else dist.shapes.split(", ")
+        if not discrete:
+            FitParams = namedtuple('FitParams', shape_names + ['loc', 'scale'])
+        else:
+            FitParams = namedtuple('FitParams', shape_names + ['loc'])
+
+        self.params = FitParams(*res.x)
+
+        # Optimizer can report success even when nllf is infinite
+        if res.success and not np.isfinite(self.nllf()):
+            res.success = False
+            res.message = ("Optimization converged to parameter values that "
+                           "are inconsistent with the data.")
+        self.success = getattr(res, "success", None)
+        self.message = getattr(res, "message", None)
+
+    def __repr__(self):
+        keys = ["params", "success", "message"]
+        m = max(map(len, keys)) + 1
+        return '\n'.join([key.rjust(m) + ': ' + repr(getattr(self, key))
+                          for key in keys if getattr(self, key) is not None])
+
+    def nllf(self, params=None, data=None):
+        """Negative log-likelihood function
+
+        Evaluates the negative of the log-likelihood function of the provided
+        data at the provided parameters.
+
+        Parameters
+        ----------
+        params : tuple, optional
+            The shape parameters, location, and (if applicable) scale of the
+            distribution as a single tuple. Default is the maximum likelihood
+            estimates (``self.params``).
+        data : array_like, optional
+            The data for which the log-likelihood function is to be evaluated.
+            Default is the data to which the distribution was fit.
+
+        Returns
+        -------
+        nllf : float
+            The negative of the log-likelihood function.
+
+        """
+        params = params if params is not None else self.params
+        data = data if data is not None else self._data
+        return self._dist.nnlf(theta=params, x=data)
+
+    def plot(self, ax=None, *, plot_type="hist"):
+        """Visually compare the data against the fitted distribution.
+
+        Available only if `matplotlib` is installed.
+
+        Parameters
+        ----------
+        ax : `matplotlib.axes.Axes`
+            Axes object to draw the plot onto, otherwise uses the current Axes.
+        plot_type : {"hist", "qq", "pp", "cdf"}
+            Type of plot to draw. Options include:
+
+            - "hist": Superposes the PDF/PMF of the fitted distribution
+              over a normalized histogram of the data.
+            - "qq": Scatter plot of theoretical quantiles against the
+              empirical quantiles. Specifically, the x-coordinates are the
+              values of the fitted distribution PPF evaluated at the
+              percentiles ``(np.arange(1, n) - 0.5)/n``, where ``n`` is the
+              number of data points, and the y-coordinates are the sorted
+              data points.
+            - "pp": Scatter plot of theoretical percentiles against the
+              observed percentiles. Specifically, the x-coordinates are the
+              percentiles ``(np.arange(1, n) - 0.5)/n``, where ``n`` is
+              the number of data points, and the y-coordinates are the values
+              of the fitted distribution CDF evaluated at the sorted
+              data points.
+            - "cdf": Superposes the CDF of the fitted distribution over the
+              empirical CDF. Specifically, the x-coordinates of the empirical
+              CDF are the sorted data points, and the y-coordinates are the
+              percentiles ``(np.arange(1, n) - 0.5)/n``, where ``n`` is
+              the number of data points.
+
+        Returns
+        -------
+        ax : `matplotlib.axes.Axes`
+            The matplotlib Axes object on which the plot was drawn.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> from scipy import stats
+        >>> import matplotlib.pyplot as plt  # matplotlib must be installed
+        >>> rng = np.random.default_rng()
+        >>> data = stats.nbinom(5, 0.5).rvs(size=1000, random_state=rng)
+        >>> bounds = [(0, 30), (0, 1)]
+        >>> res = stats.fit(stats.nbinom, data, bounds)
+        >>> ax = res.plot()  # save matplotlib Axes object
+
+        The `matplotlib.axes.Axes` object can be used to customize the plot.
+        See `matplotlib.axes.Axes` documentation for details.
+
+        >>> ax.set_xlabel('number of trials')  # customize axis label
+        >>> ax.get_children()[0].set_linewidth(5)  # customize line widths
+        >>> ax.legend()
+        >>> plt.show()
+        """
+        try:
+            import matplotlib  # noqa: F401
+        except ModuleNotFoundError as exc:
+            message = "matplotlib must be installed to use method `plot`."
+            raise ModuleNotFoundError(message) from exc
+
+        plots = {'histogram': self._hist_plot, 'qq': self._qq_plot,
+                 'pp': self._pp_plot, 'cdf': self._cdf_plot,
+                 'hist': self._hist_plot}
+        if plot_type.lower() not in plots:
+            message = f"`plot_type` must be one of {set(plots.keys())}"
+            raise ValueError(message)
+        plot = plots[plot_type.lower()]
+
+        if ax is None:
+            import matplotlib.pyplot as plt
+            ax = plt.gca()
+
+        fit_params = np.atleast_1d(self.params)
+
+        return plot(ax=ax, fit_params=fit_params)
+
+    def _hist_plot(self, ax, fit_params):
+        from matplotlib.ticker import MaxNLocator
+
+        support = self._dist.support(*fit_params)
+        lb = support[0] if np.isfinite(support[0]) else min(self._data)
+        ub = support[1] if np.isfinite(support[1]) else max(self._data)
+        pxf = "PMF" if self.discrete else "PDF"
+
+        if self.discrete:
+            x = np.arange(lb, ub + 2)
+            y = self.pxf(x, *fit_params)
+            ax.vlines(x[:-1], 0, y[:-1], label='Fitted Distribution PMF',
+                      color='C0')
+            options = dict(density=True, bins=x, align='left', color='C1')
+            ax.xaxis.set_major_locator(MaxNLocator(integer=True))
+            ax.set_xlabel('k')
+            ax.set_ylabel('PMF')
+        else:
+            x = np.linspace(lb, ub, 200)
+            y = self.pxf(x, *fit_params)
+            ax.plot(x, y, '--', label='Fitted Distribution PDF', color='C0')
+            options = dict(density=True, bins=50, align='mid', color='C1')
+            ax.set_xlabel('x')
+            ax.set_ylabel('PDF')
+
+        if len(self._data) > 50 or self.discrete:
+            ax.hist(self._data, label="Histogram of Data", **options)
+        else:
+            ax.plot(self._data, np.zeros_like(self._data), "*",
+                    label='Data', color='C1')
+
+        ax.set_title(rf"Fitted $\tt {self._dist.name}$ {pxf} and Histogram")
+        ax.legend(*ax.get_legend_handles_labels())
+        return ax
+
+    def _qp_plot(self, ax, fit_params, qq):
+        data = np.sort(self._data)
+        ps = self._plotting_positions(len(self._data))
+
+        if qq:
+            qp = "Quantiles"
+            plot_type = 'Q-Q'
+            x = self._dist.ppf(ps, *fit_params)
+            y = data
+        else:
+            qp = "Percentiles"
+            plot_type = 'P-P'
+            x = ps
+            y = self._dist.cdf(data, *fit_params)
+
+        ax.plot(x, y, '.', label=f'Fitted Distribution {plot_type}',
+                color='C0', zorder=1)
+        xlim = ax.get_xlim()
+        ylim = ax.get_ylim()
+        lim = [min(xlim[0], ylim[0]), max(xlim[1], ylim[1])]
+        if not qq:
+            lim = max(lim[0], 0), min(lim[1], 1)
+
+        if self.discrete and qq:
+            q_min, q_max = int(lim[0]), int(lim[1]+1)
+            q_ideal = np.arange(q_min, q_max)
+            # q_ideal = np.unique(self._dist.ppf(ps, *fit_params))
+            ax.plot(q_ideal, q_ideal, 'o', label='Reference', color='k',
+                    alpha=0.25, markerfacecolor='none', clip_on=True)
+        elif self.discrete and not qq:
+            # The intent of this is to match the plot that would be produced
+            # if x were continuous on [0, 1] and y were cdf(ppf(x)).
+            # It can be approximated by letting x = np.linspace(0, 1, 1000),
+            # but this might not look great when zooming in. The vertical
+            # portions are included to indicate where the transition occurs
+            # where the data completely obscures the horizontal portions.
+            p_min, p_max = lim
+            a, b = self._dist.support(*fit_params)
+            p_min = max(p_min, 0 if np.isfinite(a) else 1e-3)
+            p_max = min(p_max, 1 if np.isfinite(b) else 1-1e-3)
+            q_min, q_max = self._dist.ppf([p_min, p_max], *fit_params)
+            qs = np.arange(q_min-1, q_max+1)
+            ps = self._dist.cdf(qs, *fit_params)
+            ax.step(ps, ps, '-', label='Reference', color='k', alpha=0.25,
+                    clip_on=True)
+        else:
+            ax.plot(lim, lim, '-', label='Reference', color='k', alpha=0.25,
+                    clip_on=True)
+
+        ax.set_xlim(lim)
+        ax.set_ylim(lim)
+        ax.set_xlabel(rf"Fitted $\tt {self._dist.name}$ Theoretical {qp}")
+        ax.set_ylabel(f"Data {qp}")
+        ax.set_title(rf"Fitted $\tt {self._dist.name}$ {plot_type} Plot")
+        ax.legend(*ax.get_legend_handles_labels())
+        ax.set_aspect('equal')
+        return ax
+
+    def _qq_plot(self, **kwargs):
+        return self._qp_plot(qq=True, **kwargs)
+
+    def _pp_plot(self, **kwargs):
+        return self._qp_plot(qq=False, **kwargs)
+
+    def _plotting_positions(self, n, a=.5):
+        # See https://en.wikipedia.org/wiki/Q%E2%80%93Q_plot#Plotting_positions
+        k = np.arange(1, n+1)
+        return (k-a) / (n + 1 - 2*a)
+
+    def _cdf_plot(self, ax, fit_params):
+        data = np.sort(self._data)
+        ecdf = self._plotting_positions(len(self._data))
+        ls = '--' if len(np.unique(data)) < 30 else '.'
+        xlabel = 'k' if self.discrete else 'x'
+        ax.step(data, ecdf, ls, label='Empirical CDF', color='C1', zorder=0)
+
+        xlim = ax.get_xlim()
+        q = np.linspace(*xlim, 300)
+        tcdf = self._dist.cdf(q, *fit_params)
+
+        ax.plot(q, tcdf, label='Fitted Distribution CDF', color='C0', zorder=1)
+        ax.set_xlim(xlim)
+        ax.set_ylim(0, 1)
+        ax.set_xlabel(xlabel)
+        ax.set_ylabel("CDF")
+        ax.set_title(rf"Fitted $\tt {self._dist.name}$ and Empirical CDF")
+        handles, labels = ax.get_legend_handles_labels()
+        ax.legend(handles[::-1], labels[::-1])
+        return ax
+
+
+def fit(dist, data, bounds=None, *, guess=None, method='mle',
+        optimizer=optimize.differential_evolution):
+    r"""Fit a discrete or continuous distribution to data
+
+    Given a distribution, data, and bounds on the parameters of the
+    distribution, return maximum likelihood estimates of the parameters.
+
+    Parameters
+    ----------
+    dist : `scipy.stats.rv_continuous` or `scipy.stats.rv_discrete`
+        The object representing the distribution to be fit to the data.
+    data : 1D array_like
+        The data to which the distribution is to be fit. If the data contain
+        any of ``np.nan``, ``np.inf``, or -``np.inf``, the fit method will
+        raise a ``ValueError``.
+    bounds : dict or sequence of tuples, optional
+        If a dictionary, each key is the name of a parameter of the
+        distribution, and the corresponding value is a tuple containing the
+        lower and upper bound on that parameter.  If the distribution is
+        defined only for a finite range of values of that parameter, no entry
+        for that parameter is required; e.g., some distributions have
+        parameters which must be on the interval [0, 1]. Bounds for parameters
+        location (``loc``) and scale (``scale``) are optional; by default,
+        they are fixed to 0 and 1, respectively.
+
+        If a sequence, element *i* is a tuple containing the lower and upper
+        bound on the *i*\ th parameter of the distribution. In this case,
+        bounds for *all* distribution shape parameters must be provided.
+        Optionally, bounds for location and scale may follow the
+        distribution shape parameters.
+
+        If a shape is to be held fixed (e.g. if it is known), the
+        lower and upper bounds may be equal. If a user-provided lower or upper
+        bound is beyond a bound of the domain for which the distribution is
+        defined, the bound of the distribution's domain will replace the
+        user-provided value. Similarly, parameters which must be integral
+        will be constrained to integral values within the user-provided bounds.
+    guess : dict or array_like, optional
+        If a dictionary, each key is the name of a parameter of the
+        distribution, and the corresponding value is a guess for the value
+        of the parameter.
+
+        If a sequence, element *i* is a guess for the *i*\ th parameter of the
+        distribution. In this case, guesses for *all* distribution shape
+        parameters must be provided.
+
+        If `guess` is not provided, guesses for the decision variables will
+        not be passed to the optimizer. If `guess` is provided, guesses for
+        any missing parameters will be set at the mean of the lower and
+        upper bounds. Guesses for parameters which must be integral will be
+        rounded to integral values, and guesses that lie outside the
+        intersection of the user-provided bounds and the domain of the
+        distribution will be clipped.
+    method : {'mle', 'mse'}
+        With ``method="mle"`` (default), the fit is computed by minimizing
+        the negative log-likelihood function. A large, finite penalty
+        (rather than infinite negative log-likelihood) is applied for
+        observations beyond the support of the distribution.
+        With ``method="mse"``, the fit is computed by minimizing
+        the negative log-product spacing function. The same penalty is applied
+        for observations beyond the support. We follow the approach of [1]_,
+        which is generalized for samples with repeated observations.
+    optimizer : callable, optional
+        `optimizer` is a callable that accepts the following positional
+        argument.
+
+        fun : callable
+            The objective function to be optimized. `fun` accepts one argument
+            ``x``, candidate shape parameters of the distribution, and returns
+            the objective function value given ``x``, `dist`, and the provided
+            `data`.
+            The job of `optimizer` is to find values of the decision variables
+            that minimizes `fun`.
+
+        `optimizer` must also accept the following keyword argument.
+
+        bounds : sequence of tuples
+            The bounds on values of the decision variables; each element will
+            be a tuple containing the lower and upper bound on a decision
+            variable.
+
+        If `guess` is provided, `optimizer` must also accept the following
+        keyword argument.
+
+        x0 : array_like
+            The guesses for each decision variable.
+
+        If the distribution has any shape parameters that must be integral or
+        if the distribution is discrete and the location parameter is not
+        fixed, `optimizer` must also accept the following keyword argument.
+
+        integrality : array_like of bools
+            For each decision variable, True if the decision variable
+            must be constrained to integer values and False if the decision
+            variable is continuous.
+
+        `optimizer` must return an object, such as an instance of
+        `scipy.optimize.OptimizeResult`, which holds the optimal values of
+        the decision variables in an attribute ``x``. If attributes
+        ``fun``, ``status``, or ``message`` are provided, they will be
+        included in the result object returned by `fit`.
+
+    Returns
+    -------
+    result : `~scipy.stats._result_classes.FitResult`
+        An object with the following fields.
+
+        params : namedtuple
+            A namedtuple containing the maximum likelihood estimates of the
+            shape parameters, location, and (if applicable) scale of the
+            distribution.
+        success : bool or None
+            Whether the optimizer considered the optimization to terminate
+            successfully or not.
+        message : str or None
+            Any status message provided by the optimizer.
+
+        The object has the following method:
+
+        nllf(params=None, data=None)
+            By default, the negative log-likelihood function at the fitted
+            `params` for the given `data`. Accepts a tuple containing
+            alternative shapes, location, and scale of the distribution and
+            an array of alternative data.
+
+        plot(ax=None)
+            Superposes the PDF/PMF of the fitted distribution over a normalized
+            histogram of the data.
+
+    See Also
+    --------
+    rv_continuous,  rv_discrete
+
+    Notes
+    -----
+    Optimization is more likely to converge to the maximum likelihood estimate
+    when the user provides tight bounds containing the maximum likelihood
+    estimate. For example, when fitting a binomial distribution to data, the
+    number of experiments underlying each sample may be known, in which case
+    the corresponding shape parameter ``n`` can be fixed.
+
+    References
+    ----------
+    .. [1] Shao, Yongzhao, and Marjorie G. Hahn. "Maximum product of spacings
+           method: a unified formulation with illustration of strong
+           consistency." Illinois Journal of Mathematics 43.3 (1999): 489-499.
+
+    Examples
+    --------
+    Suppose we wish to fit a distribution to the following data.
+
+    >>> import numpy as np
+    >>> from scipy import stats
+    >>> rng = np.random.default_rng()
+    >>> dist = stats.nbinom
+    >>> shapes = (5, 0.5)
+    >>> data = dist.rvs(*shapes, size=1000, random_state=rng)
+
+    Suppose we do not know how the data were generated, but we suspect that
+    it follows a negative binomial distribution with parameters *n* and *p*\.
+    (See `scipy.stats.nbinom`.) We believe that the parameter *n* was fewer
+    than 30, and we know that the parameter *p* must lie on the interval
+    [0, 1]. We record this information in a variable `bounds` and pass
+    this information to `fit`.
+
+    >>> bounds = [(0, 30), (0, 1)]
+    >>> res = stats.fit(dist, data, bounds)
+
+    `fit` searches within the user-specified `bounds` for the
+    values that best match the data (in the sense of maximum likelihood
+    estimation). In this case, it found shape values similar to those
+    from which the data were actually generated.
+
+    >>> res.params
+    FitParams(n=5.0, p=0.5028157644634368, loc=0.0)  # may vary
+
+    We can visualize the results by superposing the probability mass function
+    of the distribution (with the shapes fit to the data) over a normalized
+    histogram of the data.
+
+    >>> import matplotlib.pyplot as plt  # matplotlib must be installed to plot
+    >>> res.plot()
+    >>> plt.show()
+
+    Note that the estimate for *n* was exactly integral; this is because
+    the domain of the `nbinom` PMF includes only integral *n*, and the `nbinom`
+    object "knows" that. `nbinom` also knows that the shape *p* must be a
+    value between 0 and 1. In such a case - when the domain of the distribution
+    with respect to a parameter is finite - we are not required to specify
+    bounds for the parameter.
+
+    >>> bounds = {'n': (0, 30)}  # omit parameter p using a `dict`
+    >>> res2 = stats.fit(dist, data, bounds)
+    >>> res2.params
+    FitParams(n=5.0, p=0.5016492009232932, loc=0.0)  # may vary
+
+    If we wish to force the distribution to be fit with *n* fixed at 6, we can
+    set both the lower and upper bounds on *n* to 6. Note, however, that the
+    value of the objective function being optimized is typically worse (higher)
+    in this case.
+
+    >>> bounds = {'n': (6, 6)}  # fix parameter `n`
+    >>> res3 = stats.fit(dist, data, bounds)
+    >>> res3.params
+    FitParams(n=6.0, p=0.5486556076755706, loc=0.0)  # may vary
+    >>> res3.nllf() > res.nllf()
+    True  # may vary
+
+    Note that the numerical results of the previous examples are typical, but
+    they may vary because the default optimizer used by `fit`,
+    `scipy.optimize.differential_evolution`, is stochastic. However, we can
+    customize the settings used by the optimizer to ensure reproducibility -
+    or even use a different optimizer entirely - using the `optimizer`
+    parameter.
+
+    >>> from scipy.optimize import differential_evolution
+    >>> rng = np.random.default_rng(767585560716548)
+    >>> def optimizer(fun, bounds, *, integrality):
+    ...     return differential_evolution(fun, bounds, strategy='best2bin',
+    ...                                   rng=rng, integrality=integrality)
+    >>> bounds = [(0, 30), (0, 1)]
+    >>> res4 = stats.fit(dist, data, bounds, optimizer=optimizer)
+    >>> res4.params
+    FitParams(n=5.0, p=0.5015183149259951, loc=0.0)
+
+    """
+    # --- Input Validation / Standardization --- #
+    user_bounds = bounds
+    user_guess = guess
+
+    # distribution input validation and information collection
+    if hasattr(dist, "pdf"):  # can't use isinstance for types
+        default_bounds = {'loc': (0, 0), 'scale': (1, 1)}
+        discrete = False
+    elif hasattr(dist, "pmf"):
+        default_bounds = {'loc': (0, 0)}
+        discrete = True
+    else:
+        message = ("`dist` must be an instance of `rv_continuous` "
+                   "or `rv_discrete.`")
+        raise ValueError(message)
+
+    try:
+        param_info = dist._param_info()
+    except AttributeError as e:
+        message = (f"Distribution `{dist.name}` is not yet supported by "
+                   "`scipy.stats.fit` because shape information has "
+                   "not been defined.")
+        raise ValueError(message) from e
+
+    # data input validation
+    data = np.asarray(data)
+    if data.ndim != 1:
+        message = "`data` must be exactly one-dimensional."
+        raise ValueError(message)
+    if not (np.issubdtype(data.dtype, np.number)
+            and np.all(np.isfinite(data))):
+        message = "All elements of `data` must be finite numbers."
+        raise ValueError(message)
+
+    # bounds input validation and information collection
+    n_params = len(param_info)
+    n_shapes = n_params - (1 if discrete else 2)
+    param_list = [param.name for param in param_info]
+    param_names = ", ".join(param_list)
+    shape_names = ", ".join(param_list[:n_shapes])
+
+    if user_bounds is None:
+        user_bounds = {}
+
+    if isinstance(user_bounds, dict):
+        default_bounds.update(user_bounds)
+        user_bounds = default_bounds
+        user_bounds_array = np.empty((n_params, 2))
+        for i in range(n_params):
+            param_name = param_info[i].name
+            user_bound = user_bounds.pop(param_name, None)
+            if user_bound is None:
+                user_bound = param_info[i].domain
+            user_bounds_array[i] = user_bound
+        if user_bounds:
+            message = ("Bounds provided for the following unrecognized "
+                       f"parameters will be ignored: {set(user_bounds)}")
+            warnings.warn(message, RuntimeWarning, stacklevel=2)
+
+    else:
+        try:
+            user_bounds = np.asarray(user_bounds, dtype=float)
+            if user_bounds.size == 0:
+                user_bounds = np.empty((0, 2))
+        except ValueError as e:
+            message = ("Each element of a `bounds` sequence must be a tuple "
+                       "containing two elements: the lower and upper bound of "
+                       "a distribution parameter.")
+            raise ValueError(message) from e
+        if (user_bounds.ndim != 2 or user_bounds.shape[1] != 2):
+            message = ("Each element of `bounds` must be a tuple specifying "
+                       "the lower and upper bounds of a shape parameter")
+            raise ValueError(message)
+        if user_bounds.shape[0] < n_shapes:
+            message = (f"A `bounds` sequence must contain at least {n_shapes} "
+                       "elements: tuples specifying the lower and upper "
+                       f"bounds of all shape parameters {shape_names}.")
+            raise ValueError(message)
+        if user_bounds.shape[0] > n_params:
+            message = ("A `bounds` sequence may not contain more than "
+                       f"{n_params} elements: tuples specifying the lower and "
+                       "upper bounds of distribution parameters "
+                       f"{param_names}.")
+            raise ValueError(message)
+
+        user_bounds_array = np.empty((n_params, 2))
+        user_bounds_array[n_shapes:] = list(default_bounds.values())
+        user_bounds_array[:len(user_bounds)] = user_bounds
+
+    user_bounds = user_bounds_array
+    validated_bounds = []
+    for i in range(n_params):
+        name = param_info[i].name
+        user_bound = user_bounds_array[i]
+        param_domain = param_info[i].domain
+        integral = param_info[i].integrality
+        combined = _combine_bounds(name, user_bound, param_domain, integral)
+        validated_bounds.append(combined)
+
+    bounds = np.asarray(validated_bounds)
+    integrality = [param.integrality for param in param_info]
+
+    # guess input validation
+
+    if user_guess is None:
+        guess_array = None
+    elif isinstance(user_guess, dict):
+        default_guess = {param.name: np.mean(bound)
+                         for param, bound in zip(param_info, bounds)}
+        unrecognized = set(user_guess) - set(default_guess)
+        if unrecognized:
+            message = ("Guesses provided for the following unrecognized "
+                       f"parameters will be ignored: {unrecognized}")
+            warnings.warn(message, RuntimeWarning, stacklevel=2)
+        default_guess.update(user_guess)
+
+        message = ("Each element of `guess` must be a scalar "
+                   "guess for a distribution parameter.")
+        try:
+            guess_array = np.asarray([default_guess[param.name]
+                                      for param in param_info], dtype=float)
+        except ValueError as e:
+            raise ValueError(message) from e
+
+    else:
+        message = ("Each element of `guess` must be a scalar "
+                   "guess for a distribution parameter.")
+        try:
+            user_guess = np.asarray(user_guess, dtype=float)
+        except ValueError as e:
+            raise ValueError(message) from e
+        if user_guess.ndim != 1:
+            raise ValueError(message)
+        if user_guess.shape[0] < n_shapes:
+            message = (f"A `guess` sequence must contain at least {n_shapes} "
+                       "elements: scalar guesses for the distribution shape "
+                       f"parameters {shape_names}.")
+            raise ValueError(message)
+        if user_guess.shape[0] > n_params:
+            message = ("A `guess` sequence may not contain more than "
+                       f"{n_params} elements: scalar guesses for the "
+                       f"distribution parameters {param_names}.")
+            raise ValueError(message)
+
+        guess_array = np.mean(bounds, axis=1)
+        guess_array[:len(user_guess)] = user_guess
+
+    if guess_array is not None:
+        guess_rounded = guess_array.copy()
+
+        guess_rounded[integrality] = np.round(guess_rounded[integrality])
+        rounded = np.where(guess_rounded != guess_array)[0]
+        for i in rounded:
+            message = (f"Guess for parameter `{param_info[i].name}` "
+                       f"rounded from {guess_array[i]} to {guess_rounded[i]}.")
+            warnings.warn(message, RuntimeWarning, stacklevel=2)
+
+        guess_clipped = np.clip(guess_rounded, bounds[:, 0], bounds[:, 1])
+        clipped = np.where(guess_clipped != guess_rounded)[0]
+        for i in clipped:
+            message = (f"Guess for parameter `{param_info[i].name}` "
+                       f"clipped from {guess_rounded[i]} to "
+                       f"{guess_clipped[i]}.")
+            warnings.warn(message, RuntimeWarning, stacklevel=2)
+
+        guess = guess_clipped
+    else:
+        guess = None
+
+    # --- Fitting --- #
+    def nllf(free_params, data=data):  # bind data NOW
+        with np.errstate(invalid='ignore', divide='ignore'):
+            return dist._penalized_nnlf(free_params, data)
+
+    def nlpsf(free_params, data=data):  # bind data NOW
+        with np.errstate(invalid='ignore', divide='ignore'):
+            return dist._penalized_nlpsf(free_params, data)
+
+    methods = {'mle': nllf, 'mse': nlpsf}
+    objective = methods[method.lower()]
+
+    with np.errstate(invalid='ignore', divide='ignore'):
+        kwds = {}
+        if bounds is not None:
+            kwds['bounds'] = bounds
+        if np.any(integrality):
+            kwds['integrality'] = integrality
+        if guess is not None:
+            kwds['x0'] = guess
+        res = optimizer(objective, **kwds)
+
+    return FitResult(dist, data, discrete, res)
+
+
+GoodnessOfFitResult = namedtuple('GoodnessOfFitResult',
+                                 ('fit_result', 'statistic', 'pvalue',
+                                  'null_distribution'))
+
+
+@_transition_to_rng('random_state')
+def goodness_of_fit(dist, data, *, known_params=None, fit_params=None,
+                    guessed_params=None, statistic='ad', n_mc_samples=9999,
+                    rng=None):
+    r"""
+    Perform a goodness of fit test comparing data to a distribution family.
+
+    Given a distribution family and data, perform a test of the null hypothesis
+    that the data were drawn from a distribution in that family. Any known
+    parameters of the distribution may be specified. Remaining parameters of
+    the distribution will be fit to the data, and the p-value of the test
+    is computed accordingly. Several statistics for comparing the distribution
+    to data are available.
+
+    Parameters
+    ----------
+    dist : `scipy.stats.rv_continuous`
+        The object representing the distribution family under the null
+        hypothesis.
+    data : 1D array_like
+        Finite, uncensored data to be tested.
+    known_params : dict, optional
+        A dictionary containing name-value pairs of known distribution
+        parameters. Monte Carlo samples are randomly drawn from the
+        null-hypothesized distribution with these values of the parameters.
+        Before the statistic is evaluated for the observed `data` and each
+        Monte Carlo sample, only remaining unknown parameters of the
+        null-hypothesized distribution family are fit to the samples; the
+        known parameters are held fixed. If all parameters of the distribution
+        family are known, then the step of fitting the distribution family to
+        each sample is omitted.
+    fit_params : dict, optional
+        A dictionary containing name-value pairs of distribution parameters
+        that have already been fit to the data, e.g. using `scipy.stats.fit`
+        or the ``fit`` method of `dist`. Monte Carlo samples are drawn from the
+        null-hypothesized distribution with these specified values of the
+        parameter. However, these and all other unknown parameters of the
+        null-hypothesized distribution family are always fit to the sample,
+        whether that is the observed `data` or a Monte Carlo sample, before
+        the statistic is evaluated.
+    guessed_params : dict, optional
+        A dictionary containing name-value pairs of distribution parameters
+        which have been guessed. These parameters are always considered as
+        free parameters and are fit both to the provided `data` as well as
+        to the Monte Carlo samples drawn from the null-hypothesized
+        distribution. The purpose of these `guessed_params` is to be used as
+        initial values for the numerical fitting procedure.
+    statistic : {"ad", "ks", "cvm", "filliben"} or callable, optional
+        The statistic used to compare data to a distribution after fitting
+        unknown parameters of the distribution family to the data. The
+        Anderson-Darling ("ad") [1]_, Kolmogorov-Smirnov ("ks") [1]_,
+        Cramer-von Mises ("cvm") [1]_, and Filliben ("filliben") [7]_
+        statistics are available.  Alternatively, a callable with signature
+        ``(dist, data, axis)`` may be supplied to compute the statistic. Here
+        ``dist`` is a frozen distribution object (potentially with array
+        parameters), ``data`` is an array of Monte Carlo samples (of
+        compatible shape), and ``axis`` is the axis of ``data`` along which
+        the statistic must be computed.
+    n_mc_samples : int, default: 9999
+        The number of Monte Carlo samples drawn from the null hypothesized
+        distribution to form the null distribution of the statistic. The
+        sample size of each is the same as the given `data`.
+    rng : `numpy.random.Generator`, optional
+        Pseudorandom number generator state. When `rng` is None, a new
+        `numpy.random.Generator` is created using entropy from the
+        operating system. Types other than `numpy.random.Generator` are
+        passed to `numpy.random.default_rng` to instantiate a ``Generator``.
+
+    Returns
+    -------
+    res : GoodnessOfFitResult
+        An object with the following attributes.
+
+        fit_result : `~scipy.stats._result_classes.FitResult`
+            An object representing the fit of the provided `dist` to `data`.
+            This  object includes the values of distribution family parameters
+            that fully define the null-hypothesized distribution, that is,
+            the distribution from which Monte Carlo samples are drawn.
+        statistic : float
+            The value of the statistic comparing provided `data` to the
+            null-hypothesized distribution.
+        pvalue : float
+            The proportion of elements in the null distribution with
+            statistic values at least as extreme as the statistic value of the
+            provided `data`.
+        null_distribution : ndarray
+            The value of the statistic for each Monte Carlo sample
+            drawn from the null-hypothesized distribution.
+
+    Notes
+    -----
+    This is a generalized Monte Carlo goodness-of-fit procedure, special cases
+    of which correspond with various Anderson-Darling tests, Lilliefors' test,
+    etc. The test is described in [2]_, [3]_, and [4]_ as a parametric
+    bootstrap test. This is a Monte Carlo test in which parameters that
+    specify the distribution from which samples are drawn have been estimated
+    from the data. We describe the test using "Monte Carlo" rather than
+    "parametric bootstrap" throughout to avoid confusion with the more familiar
+    nonparametric bootstrap, and describe how the test is performed below.
+
+    *Traditional goodness of fit tests*
+
+    Traditionally, critical values corresponding with a fixed set of
+    significance levels are pre-calculated using Monte Carlo methods. Users
+    perform the test by calculating the value of the test statistic only for
+    their observed `data` and comparing this value to tabulated critical
+    values. This practice is not very flexible, as tables are not available for
+    all distributions and combinations of known and unknown parameter values.
+    Also, results can be inaccurate when critical values are interpolated from
+    limited tabulated data to correspond with the user's sample size and
+    fitted parameter values. To overcome these shortcomings, this function
+    allows the user to perform the Monte Carlo trials adapted to their
+    particular data.
+
+    *Algorithmic overview*
+
+    In brief, this routine executes the following steps:
+
+      1. Fit unknown parameters to the given `data`, thereby forming the
+         "null-hypothesized" distribution, and compute the statistic of
+         this pair of data and distribution.
+      2. Draw random samples from this null-hypothesized distribution.
+      3. Fit the unknown parameters to each random sample.
+      4. Calculate the statistic between each sample and the distribution that
+         has been fit to the sample.
+      5. Compare the value of the statistic corresponding with `data` from (1)
+         against the values of the statistic corresponding with the random
+         samples from (4). The p-value is the proportion of samples with a
+         statistic value greater than or equal to the statistic of the observed
+         data.
+
+    In more detail, the steps are as follows.
+
+    First, any unknown parameters of the distribution family specified by
+    `dist` are fit to the provided `data` using maximum likelihood estimation.
+    (One exception is the normal distribution with unknown location and scale:
+    we use the bias-corrected standard deviation ``np.std(data, ddof=1)`` for
+    the scale as recommended in [1]_.)
+    These values of the parameters specify a particular member of the
+    distribution family referred to as the "null-hypothesized distribution",
+    that is, the distribution from which the data were sampled under the null
+    hypothesis. The `statistic`, which compares data to a distribution, is
+    computed between `data` and the null-hypothesized distribution.
+
+    Next, many (specifically `n_mc_samples`) new samples, each containing the
+    same number of observations as `data`, are drawn from the
+    null-hypothesized distribution. All unknown parameters of the distribution
+    family `dist` are fit to *each resample*, and the `statistic` is computed
+    between each sample and its corresponding fitted distribution. These
+    values of the statistic form the Monte Carlo null distribution (not to be
+    confused with the "null-hypothesized distribution" above).
+
+    The p-value of the test is the proportion of statistic values in the Monte
+    Carlo null distribution that are at least as extreme as the statistic value
+    of the provided `data`. More precisely, the p-value is given by
+
+    .. math::
+
+        p = \frac{b + 1}
+                 {m + 1}
+
+    where :math:`b` is the number of statistic values in the Monte Carlo null
+    distribution that are greater than or equal to the statistic value
+    calculated for `data`, and :math:`m` is the number of elements in the
+    Monte Carlo null distribution (`n_mc_samples`). The addition of :math:`1`
+    to the numerator and denominator can be thought of as including the
+    value of the statistic corresponding with `data` in the null distribution,
+    but a more formal explanation is given in [5]_.
+
+    *Limitations*
+
+    The test can be very slow for some distribution families because unknown
+    parameters of the distribution family must be fit to each of the Monte
+    Carlo samples, and for most distributions in SciPy, distribution fitting
+    performed via numerical optimization.
+
+    *Anti-Pattern*
+
+    For this reason, it may be tempting
+    to treat parameters of the distribution pre-fit to `data` (by the user)
+    as though they were `known_params`, as specification of all parameters of
+    the distribution precludes the need to fit the distribution to each Monte
+    Carlo sample. (This is essentially how the original Kilmogorov-Smirnov
+    test is performed.) Although such a test can provide evidence against the
+    null hypothesis, the test is conservative in the sense that small p-values
+    will tend to (greatly) *overestimate* the probability of making a type I
+    error (that is, rejecting the null hypothesis although it is true), and the
+    power of the test is low (that is, it is less likely to reject the null
+    hypothesis even when the null hypothesis is false).
+    This is because the Monte Carlo samples are less likely to agree with the
+    null-hypothesized distribution as well as `data`. This tends to increase
+    the values of the statistic recorded in the null distribution, so that a
+    larger number of them exceed the value of statistic for `data`, thereby
+    inflating the p-value.
+
+    References
+    ----------
+    .. [1] M. A. Stephens (1974). "EDF Statistics for Goodness of Fit and
+           Some Comparisons." Journal of the American Statistical Association,
+           Vol. 69, pp. 730-737.
+    .. [2] W. Stute, W. G. Manteiga, and M. P. Quindimil (1993).
+           "Bootstrap based goodness-of-fit-tests." Metrika 40.1: 243-256.
+    .. [3] C. Genest, & B Rémillard. (2008). "Validity of the parametric
+           bootstrap for goodness-of-fit testing in semiparametric models."
+           Annales de l'IHP Probabilités et statistiques. Vol. 44. No. 6.
+    .. [4] I. Kojadinovic and J. Yan (2012). "Goodness-of-fit testing based on
+           a weighted bootstrap: A fast large-sample alternative to the
+           parametric bootstrap." Canadian Journal of Statistics 40.3: 480-500.
+    .. [5] B. Phipson and G. K. Smyth (2010). "Permutation P-values Should
+           Never Be Zero: Calculating Exact P-values When Permutations Are
+           Randomly Drawn." Statistical Applications in Genetics and Molecular
+           Biology 9.1.
+    .. [6] H. W. Lilliefors (1967). "On the Kolmogorov-Smirnov test for
+           normality with mean and variance unknown." Journal of the American
+           statistical Association 62.318: 399-402.
+    .. [7] Filliben, James J. "The probability plot correlation coefficient
+           test for normality." Technometrics 17.1 (1975): 111-117.
+
+    Examples
+    --------
+    A well-known test of the null hypothesis that data were drawn from a
+    given distribution is the Kolmogorov-Smirnov (KS) test, available in SciPy
+    as `scipy.stats.ks_1samp`. Suppose we wish to test whether the following
+    data:
+
+    >>> import numpy as np
+    >>> from scipy import stats
+    >>> rng = np.random.default_rng()
+    >>> x = stats.uniform.rvs(size=75, random_state=rng)
+
+    were sampled from a normal distribution. To perform a KS test, the
+    empirical distribution function of the observed data will be compared
+    against the (theoretical) cumulative distribution function of a normal
+    distribution. Of course, to do this, the normal distribution under the null
+    hypothesis must be fully specified. This is commonly done by first fitting
+    the ``loc`` and ``scale`` parameters of the distribution to the observed
+    data, then performing the test.
+
+    >>> loc, scale = np.mean(x), np.std(x, ddof=1)
+    >>> cdf = stats.norm(loc, scale).cdf
+    >>> stats.ks_1samp(x, cdf)
+    KstestResult(statistic=0.1119257570456813,
+                 pvalue=0.2827756409939257,
+                 statistic_location=0.7751845155861765,
+                 statistic_sign=-1)
+
+    An advantage of the KS-test is that the p-value - the probability of
+    obtaining a value of the test statistic under the null hypothesis as
+    extreme as the value obtained from the observed data - can be calculated
+    exactly and efficiently. `goodness_of_fit` can only approximate these
+    results.
+
+    >>> known_params = {'loc': loc, 'scale': scale}
+    >>> res = stats.goodness_of_fit(stats.norm, x, known_params=known_params,
+    ...                             statistic='ks', rng=rng)
+    >>> res.statistic, res.pvalue
+    (0.1119257570456813, 0.2788)
+
+    The statistic matches exactly, but the p-value is estimated by forming
+    a "Monte Carlo null distribution", that is, by explicitly drawing random
+    samples from `scipy.stats.norm` with the provided parameters and
+    calculating the stastic for each. The fraction of these statistic values
+    at least as extreme as ``res.statistic`` approximates the exact p-value
+    calculated by `scipy.stats.ks_1samp`.
+
+    However, in many cases, we would prefer to test only that the data were
+    sampled from one of *any* member of the normal distribution family, not
+    specifically from the normal distribution with the location and scale
+    fitted to the observed sample. In this case, Lilliefors [6]_ argued that
+    the KS test is far too conservative (that is, the p-value overstates
+    the actual probability of rejecting a true null hypothesis) and thus lacks
+    power - the ability to reject the null hypothesis when the null hypothesis
+    is actually false.
+    Indeed, our p-value above is approximately 0.28, which is far too large
+    to reject the null hypothesis at any common significance level.
+
+    Consider why this might be. Note that in the KS test above, the statistic
+    always compares data against the CDF of a normal distribution fitted to the
+    *observed data*. This tends to reduce the value of the statistic for the
+    observed data, but it is "unfair" when computing the statistic for other
+    samples, such as those we randomly draw to form the Monte Carlo null
+    distribution. It is easy to correct for this: whenever we compute the KS
+    statistic of a sample, we use the CDF of a normal distribution fitted
+    to *that sample*. The null distribution in this case has not been
+    calculated exactly and is tyically approximated using Monte Carlo methods
+    as described above. This is where `goodness_of_fit` excels.
+
+    >>> res = stats.goodness_of_fit(stats.norm, x, statistic='ks',
+    ...                             rng=rng)
+    >>> res.statistic, res.pvalue
+    (0.1119257570456813, 0.0196)
+
+    Indeed, this p-value is much smaller, and small enough to (correctly)
+    reject the null hypothesis at common significance levels, including 5% and
+    2.5%.
+
+    However, the KS statistic is not very sensitive to all deviations from
+    normality. The original advantage of the KS statistic was the ability
+    to compute the null distribution theoretically, but a more sensitive
+    statistic - resulting in a higher test power - can be used now that we can
+    approximate the null distribution
+    computationally. The Anderson-Darling statistic [1]_ tends to be more
+    sensitive, and critical values of the this statistic have been tabulated
+    for various significance levels and sample sizes using Monte Carlo methods.
+
+    >>> res = stats.anderson(x, 'norm')
+    >>> print(res.statistic)
+    1.2139573337497467
+    >>> print(res.critical_values)
+    [0.549 0.625 0.75  0.875 1.041]
+    >>> print(res.significance_level)
+    [15.  10.   5.   2.5  1. ]
+
+    Here, the observed value of the statistic exceeds the critical value
+    corresponding with a 1% significance level. This tells us that the p-value
+    of the observed data is less than 1%, but what is it? We could interpolate
+    from these (already-interpolated) values, but `goodness_of_fit` can
+    estimate it directly.
+
+    >>> res = stats.goodness_of_fit(stats.norm, x, statistic='ad',
+    ...                             rng=rng)
+    >>> res.statistic, res.pvalue
+    (1.2139573337497467, 0.0034)
+
+    A further advantage is that use of `goodness_of_fit` is not limited to
+    a particular set of distributions or conditions on which parameters
+    are known versus which must be estimated from data. Instead,
+    `goodness_of_fit` can estimate p-values relatively quickly for any
+    distribution with a sufficiently fast and reliable ``fit`` method. For
+    instance, here we perform a goodness of fit test using the Cramer-von Mises
+    statistic against the Rayleigh distribution with known location and unknown
+    scale.
+
+    >>> rng = np.random.default_rng()
+    >>> x = stats.chi(df=2.2, loc=0, scale=2).rvs(size=1000, random_state=rng)
+    >>> res = stats.goodness_of_fit(stats.rayleigh, x, statistic='cvm',
+    ...                             known_params={'loc': 0}, rng=rng)
+
+    This executes fairly quickly, but to check the reliability of the ``fit``
+    method, we should inspect the fit result.
+
+    >>> res.fit_result  # location is as specified, and scale is reasonable
+      params: FitParams(loc=0.0, scale=2.1026719844231243)
+     success: True
+     message: 'The fit was performed successfully.'
+    >>> import matplotlib.pyplot as plt  # matplotlib must be installed to plot
+    >>> res.fit_result.plot()
+    >>> plt.show()
+
+    If the distribution is not fit to the observed data as well as possible,
+    the test may not control the type I error rate, that is, the chance of
+    rejecting the null hypothesis even when it is true.
+
+    We should also look for extreme outliers in the null distribution that
+    may be caused by unreliable fitting. These do not necessarily invalidate
+    the result, but they tend to reduce the test's power.
+
+    >>> _, ax = plt.subplots()
+    >>> ax.hist(np.log10(res.null_distribution))
+    >>> ax.set_xlabel("log10 of CVM statistic under the null hypothesis")
+    >>> ax.set_ylabel("Frequency")
+    >>> ax.set_title("Histogram of the Monte Carlo null distribution")
+    >>> plt.show()
+
+    This plot seems reassuring.
+
+    If ``fit`` method is working reliably, and if the distribution of the test
+    statistic is not particularly sensitive to the values of the fitted
+    parameters, then the p-value provided by `goodness_of_fit` is expected to
+    be a good approximation.
+
+    >>> res.statistic, res.pvalue
+    (0.2231991510248692, 0.0525)
+
+    """
+    args = _gof_iv(dist, data, known_params, fit_params, guessed_params,
+                   statistic, n_mc_samples, rng)
+    (dist, data, fixed_nhd_params, fixed_rfd_params, guessed_nhd_params,
+     guessed_rfd_params, statistic, n_mc_samples_int, rng) = args
+
+    # Fit null hypothesis distribution to data
+    nhd_fit_fun = _get_fit_fun(dist, data, guessed_nhd_params,
+                               fixed_nhd_params)
+    nhd_vals = nhd_fit_fun(data)
+    nhd_dist = dist(*nhd_vals)
+
+    def rvs(size):
+        return nhd_dist.rvs(size=size, random_state=rng)
+
+    # Define statistic
+    fit_fun = _get_fit_fun(dist, data, guessed_rfd_params, fixed_rfd_params)
+    if callable(statistic):
+        compare_fun = statistic
+    else:
+        compare_fun = _compare_dict[statistic]
+    alternative = getattr(compare_fun, 'alternative', 'greater')
+
+    def statistic_fun(data, axis):
+        # Make things simple by always working along the last axis.
+        data = np.moveaxis(data, axis, -1)
+        rfd_vals = fit_fun(data)
+        rfd_dist = dist(*rfd_vals)
+        return compare_fun(rfd_dist, data, axis=-1)
+
+    res = stats.monte_carlo_test(data, rvs, statistic_fun, vectorized=True,
+                                 n_resamples=n_mc_samples, axis=-1,
+                                 alternative=alternative)
+    opt_res = optimize.OptimizeResult()
+    opt_res.success = True
+    opt_res.message = "The fit was performed successfully."
+    opt_res.x = nhd_vals
+    # Only continuous distributions for now, hence discrete=False
+    # There's no fundamental limitation; it's just that we're not using
+    # stats.fit, discrete distributions don't have `fit` method, and
+    # we haven't written any vectorized fit functions for a discrete
+    # distribution yet.
+    return GoodnessOfFitResult(FitResult(dist, data, False, opt_res),
+                               res.statistic, res.pvalue,
+                               res.null_distribution)
+
+
+def _get_fit_fun(dist, data, guessed_params, fixed_params):
+
+    shape_names = [] if dist.shapes is None else dist.shapes.split(", ")
+    param_names = shape_names + ['loc', 'scale']
+    fparam_names = ['f'+name for name in param_names]
+    all_fixed = not set(fparam_names).difference(fixed_params)
+    guessed_shapes = [guessed_params.pop(x, None)
+                      for x in shape_names if x in guessed_params]
+
+    if all_fixed:
+        def fit_fun(data):
+            return [fixed_params[name] for name in fparam_names]
+    # Define statistic, including fitting distribution to data
+    elif dist in _fit_funs:
+        def fit_fun(data):
+            params = _fit_funs[dist](data, **fixed_params)
+            params = np.asarray(np.broadcast_arrays(*params))
+            if params.ndim > 1:
+                params = params[..., np.newaxis]
+            return params
+    else:
+        def fit_fun_1d(data):
+            return dist.fit(data, *guessed_shapes, **guessed_params,
+                            **fixed_params)
+
+        def fit_fun(data):
+            params = np.apply_along_axis(fit_fun_1d, axis=-1, arr=data)
+            if params.ndim > 1:
+                params = params.T[..., np.newaxis]
+            return params
+
+    return fit_fun
+
+
+# Vectorized fitting functions. These are to accept ND `data` in which each
+# row (slice along last axis) is a sample to fit and scalar fixed parameters.
+# They return a tuple of shape parameter arrays, each of shape data.shape[:-1].
+def _fit_norm(data, floc=None, fscale=None):
+    loc = floc
+    scale = fscale
+    if loc is None and scale is None:
+        loc = np.mean(data, axis=-1)
+        scale = np.std(data, ddof=1, axis=-1)
+    elif loc is None:
+        loc = np.mean(data, axis=-1)
+    elif scale is None:
+        scale = np.sqrt(((data - loc)**2).mean(axis=-1))
+    return loc, scale
+
+
+_fit_funs = {stats.norm: _fit_norm}  # type: ignore[attr-defined]
+
+
+# Vectorized goodness of fit statistic functions. These accept a frozen
+# distribution object and `data` in which each row (slice along last axis) is
+# a sample.
+
+
+def _anderson_darling(dist, data, axis):
+    x = np.sort(data, axis=-1)
+    n = data.shape[-1]
+    i = np.arange(1, n+1)
+    Si = (2*i - 1)/n * (dist.logcdf(x) + dist.logsf(x[..., ::-1]))
+    S = np.sum(Si, axis=-1)
+    return -n - S
+
+
+def _compute_dplus(cdfvals):  # adapted from _stats_py before gh-17062
+    n = cdfvals.shape[-1]
+    return (np.arange(1.0, n + 1) / n - cdfvals).max(axis=-1)
+
+
+def _compute_dminus(cdfvals):
+    n = cdfvals.shape[-1]
+    return (cdfvals - np.arange(0.0, n)/n).max(axis=-1)
+
+
+def _kolmogorov_smirnov(dist, data, axis=-1):
+    x = np.sort(data, axis=axis)
+    cdfvals = dist.cdf(x)
+    cdfvals = np.moveaxis(cdfvals, axis, -1)
+    Dplus = _compute_dplus(cdfvals)  # always works along last axis
+    Dminus = _compute_dminus(cdfvals)
+    return np.maximum(Dplus, Dminus)
+
+
+def _corr(X, M):
+    # Correlation coefficient r, simplified and vectorized as we need it.
+    # See [7] Equation (2). Lemma 1/2 are only for distributions symmetric
+    # about 0.
+    Xm = X.mean(axis=-1, keepdims=True)
+    Mm = M.mean(axis=-1, keepdims=True)
+    num = np.sum((X - Xm) * (M - Mm), axis=-1)
+    den = np.sqrt(np.sum((X - Xm)**2, axis=-1) * np.sum((M - Mm)**2, axis=-1))
+    return num/den
+
+
+def _filliben(dist, data, axis):
+    # [7] Section 8 # 1
+    X = np.sort(data, axis=-1)
+
+    # [7] Section 8 # 2
+    n = data.shape[-1]
+    k = np.arange(1, n+1)
+    # Filliben used an approximation for the uniform distribution order
+    # statistic medians.
+    # m = (k - .3175)/(n + 0.365)
+    # m[-1] = 0.5**(1/n)
+    # m[0] = 1 - m[-1]
+    # We can just as easily use the (theoretically) exact values. See e.g.
+    # https://en.wikipedia.org/wiki/Order_statistic
+    # "Order statistics sampled from a uniform distribution"
+    m = stats.beta(k, n + 1 - k).median()
+
+    # [7] Section 8 # 3
+    M = dist.ppf(m)
+
+    # [7] Section 8 # 4
+    return _corr(X, M)
+_filliben.alternative = 'less'  # type: ignore[attr-defined]
+
+
+def _cramer_von_mises(dist, data, axis):
+    x = np.sort(data, axis=-1)
+    n = data.shape[-1]
+    cdfvals = dist.cdf(x)
+    u = (2*np.arange(1, n+1) - 1)/(2*n)
+    w = 1 / (12*n) + np.sum((u - cdfvals)**2, axis=-1)
+    return w
+
+
+_compare_dict = {"ad": _anderson_darling, "ks": _kolmogorov_smirnov,
+                 "cvm": _cramer_von_mises, "filliben": _filliben}
+
+
+def _gof_iv(dist, data, known_params, fit_params, guessed_params, statistic,
+            n_mc_samples, rng):
+
+    if not isinstance(dist, stats.rv_continuous):
+        message = ("`dist` must be a (non-frozen) instance of "
+                   "`stats.rv_continuous`.")
+        raise TypeError(message)
+
+    data = np.asarray(data, dtype=float)
+    if not data.ndim == 1:
+        message = "`data` must be a one-dimensional array of numbers."
+        raise ValueError(message)
+
+    # Leave validation of these key/value pairs to the `fit` method,
+    # but collect these into dictionaries that will be used
+    known_params = known_params or dict()
+    fit_params = fit_params or dict()
+    guessed_params = guessed_params or dict()
+
+    known_params_f = {("f"+key): val for key, val in known_params.items()}
+    fit_params_f = {("f"+key): val for key, val in fit_params.items()}
+
+    # These are the values of parameters of the null distribution family
+    # with which resamples are drawn
+    fixed_nhd_params = known_params_f.copy()
+    fixed_nhd_params.update(fit_params_f)
+
+    # These are fixed when fitting the distribution family to resamples
+    fixed_rfd_params = known_params_f.copy()
+
+    # These are used as guesses when fitting the distribution family to
+    # the original data
+    guessed_nhd_params = guessed_params.copy()
+
+    # These are used as guesses when fitting the distribution family to
+    # resamples
+    guessed_rfd_params = fit_params.copy()
+    guessed_rfd_params.update(guessed_params)
+
+    if not callable(statistic):
+        statistic = statistic.lower()
+        statistics = {'ad', 'ks', 'cvm', 'filliben'}
+        if statistic not in statistics:
+            message = f"`statistic` must be one of {statistics}."
+            raise ValueError(message)
+
+    n_mc_samples_int = int(n_mc_samples)
+    if n_mc_samples_int != n_mc_samples:
+        message = "`n_mc_samples` must be an integer."
+        raise TypeError(message)
+
+    rng = check_random_state(rng)
+
+    return (dist, data, fixed_nhd_params, fixed_rfd_params, guessed_nhd_params,
+            guessed_rfd_params, statistic, n_mc_samples_int, rng)