Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2026-03-27 02:38
📄 LICENSE.txt Copyright (c) 2005-2023, NumPy 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: * 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 in the documentation and/or other materials provided with the distribution. * Neither the name of the NumPy Developers nor the names of any 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 NumPy also bundles the following software: Name: OpenBLAS Files: .libs/libopenb.so Description: bundled as a dynamically linked library Availability: https://github.com/xianyi/OpenBLAS/ License: 3-clause BSD 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: .libs/libopenb.so Description: bundled in OpenBLAS Availability: https://github.com/xianyi/OpenBLAS/ License 3-clause BSD 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: .libs/libgfortran*.so Description: dynamically linked to files compiled with gcc Availability: https://gcc.gnu.org/viewcvs/gcc/ License: GPLv3 + runtime 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>.	44.62 KB	2026-01-20 12:58
📄 __config__.py # This file is generated by numpy's setup.py # It contains system_info results at the time of building this package. __all__ = ["get_info","show"] import os import sys extra_dll_dir = os.path.join(os.path.dirname(__file__), '.libs') if sys.platform == 'win32' and os.path.isdir(extra_dll_dir): os.add_dll_directory(extra_dll_dir) openblas64__info={'libraries': ['openblas64_', 'openblas64_'], 'library_dirs': ['/usr/local/lib'], 'language': 'c', 'define_macros': [('HAVE_CBLAS', None), ('BLAS_SYMBOL_SUFFIX', '64_'), ('HAVE_BLAS_ILP64', None)], 'runtime_library_dirs': ['/usr/local/lib']} blas_ilp64_opt_info={'libraries': ['openblas64_', 'openblas64_'], 'library_dirs': ['/usr/local/lib'], 'language': 'c', 'define_macros': [('HAVE_CBLAS', None), ('BLAS_SYMBOL_SUFFIX', '64_'), ('HAVE_BLAS_ILP64', None)], 'runtime_library_dirs': ['/usr/local/lib']} openblas64__lapack_info={'libraries': ['openblas64_', 'openblas64_'], 'library_dirs': ['/usr/local/lib'], 'language': 'c', 'define_macros': [('HAVE_CBLAS', None), ('BLAS_SYMBOL_SUFFIX', '64_'), ('HAVE_BLAS_ILP64', None), ('HAVE_LAPACKE', None)], 'runtime_library_dirs': ['/usr/local/lib']} lapack_ilp64_opt_info={'libraries': ['openblas64_', 'openblas64_'], 'library_dirs': ['/usr/local/lib'], 'language': 'c', 'define_macros': [('HAVE_CBLAS', None), ('BLAS_SYMBOL_SUFFIX', '64_'), ('HAVE_BLAS_ILP64', None), ('HAVE_LAPACKE', None)], 'runtime_library_dirs': ['/usr/local/lib']} def get_info(name): g = globals() return g.get(name, g.get(name + "_info", {})) def show(): """ Show libraries in the system on which NumPy was built. Print information about various resources (libraries, library directories, include directories, etc.) in the system on which NumPy was built. See Also -------- get_include : Returns the directory containing NumPy C header files. Notes ----- 1. Classes specifying the information to be printed are defined in the `numpy.distutils.system_info` module. Information may include: * ``language``: language used to write the libraries (mostly C or f77) * ``libraries``: names of libraries found in the system * ``library_dirs``: directories containing the libraries * ``include_dirs``: directories containing library header files * ``src_dirs``: directories containing library source files * ``define_macros``: preprocessor macros used by ``distutils.setup`` * ``baseline``: minimum CPU features required * ``found``: dispatched features supported in the system * ``not found``: dispatched features that are not supported in the system 2. NumPy BLAS/LAPACK Installation Notes Installing a numpy wheel (``pip install numpy`` or force it via ``pip install numpy --only-binary :numpy: numpy``) includes an OpenBLAS implementation of the BLAS and LAPACK linear algebra APIs. In this case, ``library_dirs`` reports the original build time configuration as compiled with gcc/gfortran; at run time the OpenBLAS library is in ``site-packages/numpy.libs/`` (linux), or ``site-packages/numpy/.dylibs/`` (macOS), or ``site-packages/numpy/.libs/`` (windows). Installing numpy from source (``pip install numpy --no-binary numpy``) searches for BLAS and LAPACK dynamic link libraries at build time as influenced by environment variables NPY_BLAS_LIBS, NPY_CBLAS_LIBS, and NPY_LAPACK_LIBS; or NPY_BLAS_ORDER and NPY_LAPACK_ORDER; or the optional file ``~/.numpy-site.cfg``. NumPy remembers those locations and expects to load the same libraries at run-time. In NumPy 1.21+ on macOS, 'accelerate' (Apple's Accelerate BLAS library) is in the default build-time search order after 'openblas'. Examples -------- >>> import numpy as np >>> np.show_config() blas_opt_info: language = c define_macros = [('HAVE_CBLAS', None)] libraries = ['openblas', 'openblas'] library_dirs = ['/usr/local/lib'] """ from numpy.core._multiarray_umath import ( __cpu_features__, __cpu_baseline__, __cpu_dispatch__ ) for name,info_dict in globals().items(): if name[0] == "_" or type(info_dict) is not type({}): continue print(name + ":") if not info_dict: print(" NOT AVAILABLE") for k,v in info_dict.items(): v = str(v) if k == "sources" and len(v) > 200: v = v[:60] + " ...\n... " + v[-60:] print(" %s = %s" % (k,v)) features_found, features_not_found = [], [] for feature in __cpu_dispatch__: if __cpu_features__[feature]: features_found.append(feature) else: features_not_found.append(feature) print("Supported SIMD extensions in this NumPy install:") print(" baseline = %s" % (','.join(__cpu_baseline__))) print(" found = %s" % (','.join(features_found))) print(" not found = %s" % (','.join(features_not_found)))	5.02 KB	2026-01-20 12:58
📄 __init__.cython-30.pxd # NumPy static imports for Cython >= 3.0 # # If any of the PyArray_* functions are called, import_array must be # called first. This is done automatically by Cython 3.0+ if a call # is not detected inside of the module. # # Author: Dag Sverre Seljebotn # from cpython.ref cimport Py_INCREF from cpython.object cimport PyObject, PyTypeObject, PyObject_TypeCheck cimport libc.stdio as stdio cdef extern from : # Leave a marker that the NumPy declarations came from NumPy itself and not from Cython. # See https://github.com/cython/cython/issues/3573 """ / Using NumPy API declarations from "numpy/__init__.cython-30.pxd" / """ cdef extern from "Python.h": ctypedef Py_ssize_t Py_intptr_t cdef extern from "numpy/arrayobject.h": ctypedef Py_intptr_t npy_intp ctypedef size_t npy_uintp cdef enum NPY_TYPES: NPY_BOOL NPY_BYTE NPY_UBYTE NPY_SHORT NPY_USHORT NPY_INT NPY_UINT NPY_LONG NPY_ULONG NPY_LONGLONG NPY_ULONGLONG NPY_FLOAT NPY_DOUBLE NPY_LONGDOUBLE NPY_CFLOAT NPY_CDOUBLE NPY_CLONGDOUBLE NPY_OBJECT NPY_STRING NPY_UNICODE NPY_VOID NPY_DATETIME NPY_TIMEDELTA NPY_NTYPES NPY_NOTYPE NPY_INT8 NPY_INT16 NPY_INT32 NPY_INT64 NPY_INT128 NPY_INT256 NPY_UINT8 NPY_UINT16 NPY_UINT32 NPY_UINT64 NPY_UINT128 NPY_UINT256 NPY_FLOAT16 NPY_FLOAT32 NPY_FLOAT64 NPY_FLOAT80 NPY_FLOAT96 NPY_FLOAT128 NPY_FLOAT256 NPY_COMPLEX32 NPY_COMPLEX64 NPY_COMPLEX128 NPY_COMPLEX160 NPY_COMPLEX192 NPY_COMPLEX256 NPY_COMPLEX512 NPY_INTP ctypedef enum NPY_ORDER: NPY_ANYORDER NPY_CORDER NPY_FORTRANORDER NPY_KEEPORDER ctypedef enum NPY_CASTING: NPY_NO_CASTING NPY_EQUIV_CASTING NPY_SAFE_CASTING NPY_SAME_KIND_CASTING NPY_UNSAFE_CASTING ctypedef enum NPY_CLIPMODE: NPY_CLIP NPY_WRAP NPY_RAISE ctypedef enum NPY_SCALARKIND: NPY_NOSCALAR, NPY_BOOL_SCALAR, NPY_INTPOS_SCALAR, NPY_INTNEG_SCALAR, NPY_FLOAT_SCALAR, NPY_COMPLEX_SCALAR, NPY_OBJECT_SCALAR ctypedef enum NPY_SORTKIND: NPY_QUICKSORT NPY_HEAPSORT NPY_MERGESORT ctypedef enum NPY_SEARCHSIDE: NPY_SEARCHLEFT NPY_SEARCHRIGHT enum: # DEPRECATED since NumPy 1.7 ! Do not use in new code! NPY_C_CONTIGUOUS NPY_F_CONTIGUOUS NPY_CONTIGUOUS NPY_FORTRAN NPY_OWNDATA NPY_FORCECAST NPY_ENSURECOPY NPY_ENSUREARRAY NPY_ELEMENTSTRIDES NPY_ALIGNED NPY_NOTSWAPPED NPY_WRITEABLE NPY_ARR_HAS_DESCR NPY_BEHAVED NPY_BEHAVED_NS NPY_CARRAY NPY_CARRAY_RO NPY_FARRAY NPY_FARRAY_RO NPY_DEFAULT NPY_IN_ARRAY NPY_OUT_ARRAY NPY_INOUT_ARRAY NPY_IN_FARRAY NPY_OUT_FARRAY NPY_INOUT_FARRAY NPY_UPDATE_ALL enum: # Added in NumPy 1.7 to replace the deprecated enums above. NPY_ARRAY_C_CONTIGUOUS NPY_ARRAY_F_CONTIGUOUS NPY_ARRAY_OWNDATA NPY_ARRAY_FORCECAST NPY_ARRAY_ENSURECOPY NPY_ARRAY_ENSUREARRAY NPY_ARRAY_ELEMENTSTRIDES NPY_ARRAY_ALIGNED NPY_ARRAY_NOTSWAPPED NPY_ARRAY_WRITEABLE NPY_ARRAY_WRITEBACKIFCOPY NPY_ARRAY_BEHAVED NPY_ARRAY_BEHAVED_NS NPY_ARRAY_CARRAY NPY_ARRAY_CARRAY_RO NPY_ARRAY_FARRAY NPY_ARRAY_FARRAY_RO NPY_ARRAY_DEFAULT NPY_ARRAY_IN_ARRAY NPY_ARRAY_OUT_ARRAY NPY_ARRAY_INOUT_ARRAY NPY_ARRAY_IN_FARRAY NPY_ARRAY_OUT_FARRAY NPY_ARRAY_INOUT_FARRAY NPY_ARRAY_UPDATE_ALL cdef enum: NPY_MAXDIMS npy_intp NPY_MAX_ELSIZE ctypedef void (PyArray_VectorUnaryFunc)(void , void , npy_intp, void , void ) ctypedef struct PyArray_ArrayDescr: # shape is a tuple, but Cython doesn't support "tuple shape" # inside a non-PyObject declaration, so we have to declare it # as just a PyObject. PyObject shape ctypedef struct PyArray_Descr: pass ctypedef class numpy.dtype [object PyArray_Descr, check_size ignore]: # Use PyDataType_* macros when possible, however there are no macros # for accessing some of the fields, so some are defined. cdef PyTypeObject* typeobj cdef char kind cdef char type # Numpy sometimes mutates this without warning (e.g. it'll # sometimes change "\|" to "<" in shared dtype objects on # little-endian machines). If this matters to you, use # PyArray_IsNativeByteOrder(dtype.byteorder) instead of # directly accessing this field. cdef char byteorder cdef char flags cdef int type_num cdef int itemsize "elsize" cdef int alignment cdef object fields cdef tuple names # Use PyDataType_HASSUBARRAY to test whether this field is # valid (the pointer can be NULL). Most users should access # this field via the inline helper method PyDataType_SHAPE. cdef PyArray_ArrayDescr* subarray ctypedef class numpy.flatiter [object PyArrayIterObject, check_size ignore]: # Use through macros pass ctypedef class numpy.broadcast [object PyArrayMultiIterObject, check_size ignore]: # Use through macros pass ctypedef struct PyArrayObject: # For use in situations where ndarray can't replace PyArrayObject, # like PyArrayObject. pass ctypedef class numpy.ndarray [object PyArrayObject, check_size ignore]: cdef __cythonbufferdefaults__ = {"mode": "strided"} # NOTE: no field declarations since direct access is deprecated since NumPy 1.7 # Instead, we use properties that map to the corresponding C-API functions. @property cdef inline PyObject base(self) nogil: """Returns a borrowed reference to the object owning the data/memory. """ return PyArray_BASE(self) @property cdef inline dtype descr(self): """Returns an owned reference to the dtype of the array. """ return <dtype>PyArray_DESCR(self) @property cdef inline int ndim(self) nogil: """Returns the number of dimensions in the array. """ return PyArray_NDIM(self) @property cdef inline npy_intp shape(self) nogil: """Returns a pointer to the dimensions/shape of the array. The number of elements matches the number of dimensions of the array (ndim). Can return NULL for 0-dimensional arrays. """ return PyArray_DIMS(self) @property cdef inline npy_intp strides(self) nogil: """Returns a pointer to the strides of the array. The number of elements matches the number of dimensions of the array (ndim). """ return PyArray_STRIDES(self) @property cdef inline npy_intp size(self) nogil: """Returns the total size (in number of elements) of the array. """ return PyArray_SIZE(self) @property cdef inline char* data(self) nogil: """The pointer to the data buffer as a char. This is provided for legacy reasons to avoid direct struct field access. For new code that needs this access, you probably want to cast the result of `PyArray_DATA()` instead, which returns a 'void'. """ return PyArray_BYTES(self) ctypedef unsigned char npy_bool ctypedef signed char npy_byte ctypedef signed short npy_short ctypedef signed int npy_int ctypedef signed long npy_long ctypedef signed long long npy_longlong ctypedef unsigned char npy_ubyte ctypedef unsigned short npy_ushort ctypedef unsigned int npy_uint ctypedef unsigned long npy_ulong ctypedef unsigned long long npy_ulonglong ctypedef float npy_float ctypedef double npy_double ctypedef long double npy_longdouble ctypedef signed char npy_int8 ctypedef signed short npy_int16 ctypedef signed int npy_int32 ctypedef signed long long npy_int64 ctypedef signed long long npy_int96 ctypedef signed long long npy_int128 ctypedef unsigned char npy_uint8 ctypedef unsigned short npy_uint16 ctypedef unsigned int npy_uint32 ctypedef unsigned long long npy_uint64 ctypedef unsigned long long npy_uint96 ctypedef unsigned long long npy_uint128 ctypedef float npy_float32 ctypedef double npy_float64 ctypedef long double npy_float80 ctypedef long double npy_float96 ctypedef long double npy_float128 ctypedef struct npy_cfloat: float real float imag ctypedef struct npy_cdouble: double real double imag ctypedef struct npy_clongdouble: long double real long double imag ctypedef struct npy_complex64: float real float imag ctypedef struct npy_complex128: double real double imag ctypedef struct npy_complex160: long double real long double imag ctypedef struct npy_complex192: long double real long double imag ctypedef struct npy_complex256: long double real long double imag ctypedef struct PyArray_Dims: npy_intp ptr int len int _import_array() except -1 # A second definition so _import_array isn't marked as used when we use it here. # Do not use - subject to change any time. int __pyx_import_array "_import_array"() except -1 # # Macros from ndarrayobject.h # bint PyArray_CHKFLAGS(ndarray m, int flags) nogil bint PyArray_IS_C_CONTIGUOUS(ndarray arr) nogil bint PyArray_IS_F_CONTIGUOUS(ndarray arr) nogil bint PyArray_ISCONTIGUOUS(ndarray m) nogil bint PyArray_ISWRITEABLE(ndarray m) nogil bint PyArray_ISALIGNED(ndarray m) nogil int PyArray_NDIM(ndarray) nogil bint PyArray_ISONESEGMENT(ndarray) nogil bint PyArray_ISFORTRAN(ndarray) nogil int PyArray_FORTRANIF(ndarray) nogil void PyArray_DATA(ndarray) nogil char* PyArray_BYTES(ndarray) nogil npy_intp* PyArray_DIMS(ndarray) nogil npy_intp* PyArray_STRIDES(ndarray) nogil npy_intp PyArray_DIM(ndarray, size_t) nogil npy_intp PyArray_STRIDE(ndarray, size_t) nogil PyObject PyArray_BASE(ndarray) nogil # returns borrowed reference! PyArray_Descr PyArray_DESCR(ndarray) nogil # returns borrowed reference to dtype! PyArray_Descr PyArray_DTYPE(ndarray) nogil # returns borrowed reference to dtype! NP 1.7+ alias for descr. int PyArray_FLAGS(ndarray) nogil void PyArray_CLEARFLAGS(ndarray, int flags) nogil # Added in NumPy 1.7 void PyArray_ENABLEFLAGS(ndarray, int flags) nogil # Added in NumPy 1.7 npy_intp PyArray_ITEMSIZE(ndarray) nogil int PyArray_TYPE(ndarray arr) nogil object PyArray_GETITEM(ndarray arr, void itemptr) int PyArray_SETITEM(ndarray arr, void itemptr, object obj) except -1 bint PyTypeNum_ISBOOL(int) nogil bint PyTypeNum_ISUNSIGNED(int) nogil bint PyTypeNum_ISSIGNED(int) nogil bint PyTypeNum_ISINTEGER(int) nogil bint PyTypeNum_ISFLOAT(int) nogil bint PyTypeNum_ISNUMBER(int) nogil bint PyTypeNum_ISSTRING(int) nogil bint PyTypeNum_ISCOMPLEX(int) nogil bint PyTypeNum_ISPYTHON(int) nogil bint PyTypeNum_ISFLEXIBLE(int) nogil bint PyTypeNum_ISUSERDEF(int) nogil bint PyTypeNum_ISEXTENDED(int) nogil bint PyTypeNum_ISOBJECT(int) nogil bint PyDataType_ISBOOL(dtype) nogil bint PyDataType_ISUNSIGNED(dtype) nogil bint PyDataType_ISSIGNED(dtype) nogil bint PyDataType_ISINTEGER(dtype) nogil bint PyDataType_ISFLOAT(dtype) nogil bint PyDataType_ISNUMBER(dtype) nogil bint PyDataType_ISSTRING(dtype) nogil bint PyDataType_ISCOMPLEX(dtype) nogil bint PyDataType_ISPYTHON(dtype) nogil bint PyDataType_ISFLEXIBLE(dtype) nogil bint PyDataType_ISUSERDEF(dtype) nogil bint PyDataType_ISEXTENDED(dtype) nogil bint PyDataType_ISOBJECT(dtype) nogil bint PyDataType_HASFIELDS(dtype) nogil bint PyDataType_HASSUBARRAY(dtype) nogil bint PyArray_ISBOOL(ndarray) nogil bint PyArray_ISUNSIGNED(ndarray) nogil bint PyArray_ISSIGNED(ndarray) nogil bint PyArray_ISINTEGER(ndarray) nogil bint PyArray_ISFLOAT(ndarray) nogil bint PyArray_ISNUMBER(ndarray) nogil bint PyArray_ISSTRING(ndarray) nogil bint PyArray_ISCOMPLEX(ndarray) nogil bint PyArray_ISPYTHON(ndarray) nogil bint PyArray_ISFLEXIBLE(ndarray) nogil bint PyArray_ISUSERDEF(ndarray) nogil bint PyArray_ISEXTENDED(ndarray) nogil bint PyArray_ISOBJECT(ndarray) nogil bint PyArray_HASFIELDS(ndarray) nogil bint PyArray_ISVARIABLE(ndarray) nogil bint PyArray_SAFEALIGNEDCOPY(ndarray) nogil bint PyArray_ISNBO(char) nogil # works on ndarray.byteorder bint PyArray_IsNativeByteOrder(char) nogil # works on ndarray.byteorder bint PyArray_ISNOTSWAPPED(ndarray) nogil bint PyArray_ISBYTESWAPPED(ndarray) nogil bint PyArray_FLAGSWAP(ndarray, int) nogil bint PyArray_ISCARRAY(ndarray) nogil bint PyArray_ISCARRAY_RO(ndarray) nogil bint PyArray_ISFARRAY(ndarray) nogil bint PyArray_ISFARRAY_RO(ndarray) nogil bint PyArray_ISBEHAVED(ndarray) nogil bint PyArray_ISBEHAVED_RO(ndarray) nogil bint PyDataType_ISNOTSWAPPED(dtype) nogil bint PyDataType_ISBYTESWAPPED(dtype) nogil bint PyArray_DescrCheck(object) bint PyArray_Check(object) bint PyArray_CheckExact(object) # Cannot be supported due to out arg: # bint PyArray_HasArrayInterfaceType(object, dtype, object, object&) # bint PyArray_HasArrayInterface(op, out) bint PyArray_IsZeroDim(object) # Cannot be supported due to ## ## in macro: # bint PyArray_IsScalar(object, verbatim work) bint PyArray_CheckScalar(object) bint PyArray_IsPythonNumber(object) bint PyArray_IsPythonScalar(object) bint PyArray_IsAnyScalar(object) bint PyArray_CheckAnyScalar(object) ndarray PyArray_GETCONTIGUOUS(ndarray) bint PyArray_SAMESHAPE(ndarray, ndarray) nogil npy_intp PyArray_SIZE(ndarray) nogil npy_intp PyArray_NBYTES(ndarray) nogil object PyArray_FROM_O(object) object PyArray_FROM_OF(object m, int flags) object PyArray_FROM_OT(object m, int type) object PyArray_FROM_OTF(object m, int type, int flags) object PyArray_FROMANY(object m, int type, int min, int max, int flags) object PyArray_ZEROS(int nd, npy_intp dims, int type, int fortran) object PyArray_EMPTY(int nd, npy_intp* dims, int type, int fortran) void PyArray_FILLWBYTE(object, int val) npy_intp PyArray_REFCOUNT(object) object PyArray_ContiguousFromAny(op, int, int min_depth, int max_depth) unsigned char PyArray_EquivArrTypes(ndarray a1, ndarray a2) bint PyArray_EquivByteorders(int b1, int b2) nogil object PyArray_SimpleNew(int nd, npy_intp* dims, int typenum) object PyArray_SimpleNewFromData(int nd, npy_intp* dims, int typenum, void* data) #object PyArray_SimpleNewFromDescr(int nd, npy_intp* dims, dtype descr) object PyArray_ToScalar(void* data, ndarray arr) void* PyArray_GETPTR1(ndarray m, npy_intp i) nogil void* PyArray_GETPTR2(ndarray m, npy_intp i, npy_intp j) nogil void* PyArray_GETPTR3(ndarray m, npy_intp i, npy_intp j, npy_intp k) nogil void* PyArray_GETPTR4(ndarray m, npy_intp i, npy_intp j, npy_intp k, npy_intp l) nogil # Cannot be supported due to out arg # void PyArray_DESCR_REPLACE(descr) object PyArray_Copy(ndarray) object PyArray_FromObject(object op, int type, int min_depth, int max_depth) object PyArray_ContiguousFromObject(object op, int type, int min_depth, int max_depth) object PyArray_CopyFromObject(object op, int type, int min_depth, int max_depth) object PyArray_Cast(ndarray mp, int type_num) object PyArray_Take(ndarray ap, object items, int axis) object PyArray_Put(ndarray ap, object items, object values) void PyArray_ITER_RESET(flatiter it) nogil void PyArray_ITER_NEXT(flatiter it) nogil void PyArray_ITER_GOTO(flatiter it, npy_intp* destination) nogil void PyArray_ITER_GOTO1D(flatiter it, npy_intp ind) nogil void* PyArray_ITER_DATA(flatiter it) nogil bint PyArray_ITER_NOTDONE(flatiter it) nogil void PyArray_MultiIter_RESET(broadcast multi) nogil void PyArray_MultiIter_NEXT(broadcast multi) nogil void PyArray_MultiIter_GOTO(broadcast multi, npy_intp dest) nogil void PyArray_MultiIter_GOTO1D(broadcast multi, npy_intp ind) nogil void* PyArray_MultiIter_DATA(broadcast multi, npy_intp i) nogil void PyArray_MultiIter_NEXTi(broadcast multi, npy_intp i) nogil bint PyArray_MultiIter_NOTDONE(broadcast multi) nogil # Functions from __multiarray_api.h # Functions taking dtype and returning object/ndarray are disabled # for now as they steal dtype references. I'm conservative and disable # more than is probably needed until it can be checked further. int PyArray_SetNumericOps (object) except -1 object PyArray_GetNumericOps () int PyArray_INCREF (ndarray) except * # uses PyArray_Item_INCREF... int PyArray_XDECREF (ndarray) except * # uses PyArray_Item_DECREF... void PyArray_SetStringFunction (object, int) dtype PyArray_DescrFromType (int) object PyArray_TypeObjectFromType (int) char * PyArray_Zero (ndarray) char * PyArray_One (ndarray) #object PyArray_CastToType (ndarray, dtype, int) int PyArray_CastTo (ndarray, ndarray) except -1 int PyArray_CastAnyTo (ndarray, ndarray) except -1 int PyArray_CanCastSafely (int, int) # writes errors npy_bool PyArray_CanCastTo (dtype, dtype) # writes errors int PyArray_ObjectType (object, int) except 0 dtype PyArray_DescrFromObject (object, dtype) #ndarray* PyArray_ConvertToCommonType (object, int ) dtype PyArray_DescrFromScalar (object) dtype PyArray_DescrFromTypeObject (object) npy_intp PyArray_Size (object) #object PyArray_Scalar (void , dtype, object) #object PyArray_FromScalar (object, dtype) void PyArray_ScalarAsCtype (object, void ) #int PyArray_CastScalarToCtype (object, void , dtype) #int PyArray_CastScalarDirect (object, dtype, void , int) object PyArray_ScalarFromObject (object) #PyArray_VectorUnaryFunc PyArray_GetCastFunc (dtype, int) object PyArray_FromDims (int, int , int) #object PyArray_FromDimsAndDataAndDescr (int, int , dtype, char ) #object PyArray_FromAny (object, dtype, int, int, int, object) object PyArray_EnsureArray (object) object PyArray_EnsureAnyArray (object) #object PyArray_FromFile (stdio.FILE , dtype, npy_intp, char ) #object PyArray_FromString (char , npy_intp, dtype, npy_intp, char ) #object PyArray_FromBuffer (object, dtype, npy_intp, npy_intp) #object PyArray_FromIter (object, dtype, npy_intp) object PyArray_Return (ndarray) #object PyArray_GetField (ndarray, dtype, int) #int PyArray_SetField (ndarray, dtype, int, object) except -1 object PyArray_Byteswap (ndarray, npy_bool) object PyArray_Resize (ndarray, PyArray_Dims , int, NPY_ORDER) int PyArray_MoveInto (ndarray, ndarray) except -1 int PyArray_CopyInto (ndarray, ndarray) except -1 int PyArray_CopyAnyInto (ndarray, ndarray) except -1 int PyArray_CopyObject (ndarray, object) except -1 object PyArray_NewCopy (ndarray, NPY_ORDER) object PyArray_ToList (ndarray) object PyArray_ToString (ndarray, NPY_ORDER) int PyArray_ToFile (ndarray, stdio.FILE , char , char ) except -1 int PyArray_Dump (object, object, int) except -1 object PyArray_Dumps (object, int) int PyArray_ValidType (int) # Cannot error void PyArray_UpdateFlags (ndarray, int) object PyArray_New (type, int, npy_intp , int, npy_intp , void , int, int, object) #object PyArray_NewFromDescr (type, dtype, int, npy_intp , npy_intp , void , int, object) #dtype PyArray_DescrNew (dtype) dtype PyArray_DescrNewFromType (int) double PyArray_GetPriority (object, double) # clears errors as of 1.25 object PyArray_IterNew (object) object PyArray_MultiIterNew (int, ...) int PyArray_PyIntAsInt (object) except? -1 npy_intp PyArray_PyIntAsIntp (object) int PyArray_Broadcast (broadcast) except -1 void PyArray_FillObjectArray (ndarray, object) except int PyArray_FillWithScalar (ndarray, object) except -1 npy_bool PyArray_CheckStrides (int, int, npy_intp, npy_intp, npy_intp , npy_intp ) dtype PyArray_DescrNewByteorder (dtype, char) object PyArray_IterAllButAxis (object, int ) #object PyArray_CheckFromAny (object, dtype, int, int, int, object) #object PyArray_FromArray (ndarray, dtype, int) object PyArray_FromInterface (object) object PyArray_FromStructInterface (object) #object PyArray_FromArrayAttr (object, dtype, object) #NPY_SCALARKIND PyArray_ScalarKind (int, ndarray) int PyArray_CanCoerceScalar (int, int, NPY_SCALARKIND) object PyArray_NewFlagsObject (object) npy_bool PyArray_CanCastScalar (type, type) #int PyArray_CompareUCS4 (npy_ucs4 , npy_ucs4 , register size_t) int PyArray_RemoveSmallest (broadcast) except -1 int PyArray_ElementStrides (object) void PyArray_Item_INCREF (char , dtype) except void PyArray_Item_XDECREF (char , dtype) except object PyArray_FieldNames (object) object PyArray_Transpose (ndarray, PyArray_Dims ) object PyArray_TakeFrom (ndarray, object, int, ndarray, NPY_CLIPMODE) object PyArray_PutTo (ndarray, object, object, NPY_CLIPMODE) object PyArray_PutMask (ndarray, object, object) object PyArray_Repeat (ndarray, object, int) object PyArray_Choose (ndarray, object, ndarray, NPY_CLIPMODE) int PyArray_Sort (ndarray, int, NPY_SORTKIND) except -1 object PyArray_ArgSort (ndarray, int, NPY_SORTKIND) object PyArray_SearchSorted (ndarray, object, NPY_SEARCHSIDE, PyObject ) object PyArray_ArgMax (ndarray, int, ndarray) object PyArray_ArgMin (ndarray, int, ndarray) object PyArray_Reshape (ndarray, object) object PyArray_Newshape (ndarray, PyArray_Dims , NPY_ORDER) object PyArray_Squeeze (ndarray) #object PyArray_View (ndarray, dtype, type) object PyArray_SwapAxes (ndarray, int, int) object PyArray_Max (ndarray, int, ndarray) object PyArray_Min (ndarray, int, ndarray) object PyArray_Ptp (ndarray, int, ndarray) object PyArray_Mean (ndarray, int, int, ndarray) object PyArray_Trace (ndarray, int, int, int, int, ndarray) object PyArray_Diagonal (ndarray, int, int, int) object PyArray_Clip (ndarray, object, object, ndarray) object PyArray_Conjugate (ndarray, ndarray) object PyArray_Nonzero (ndarray) object PyArray_Std (ndarray, int, int, ndarray, int) object PyArray_Sum (ndarray, int, int, ndarray) object PyArray_CumSum (ndarray, int, int, ndarray) object PyArray_Prod (ndarray, int, int, ndarray) object PyArray_CumProd (ndarray, int, int, ndarray) object PyArray_All (ndarray, int, ndarray) object PyArray_Any (ndarray, int, ndarray) object PyArray_Compress (ndarray, object, int, ndarray) object PyArray_Flatten (ndarray, NPY_ORDER) object PyArray_Ravel (ndarray, NPY_ORDER) npy_intp PyArray_MultiplyList (npy_intp , int) int PyArray_MultiplyIntList (int , int) void PyArray_GetPtr (ndarray, npy_intp) int PyArray_CompareLists (npy_intp , npy_intp , int) #int PyArray_AsCArray (object, void , npy_intp , int, dtype) #int PyArray_As1D (object, char , int , int) #int PyArray_As2D (object, char *, int , int , int) int PyArray_Free (object, void ) #int PyArray_Converter (object, object) int PyArray_IntpFromSequence (object, npy_intp , int) except -1 object PyArray_Concatenate (object, int) object PyArray_InnerProduct (object, object) object PyArray_MatrixProduct (object, object) object PyArray_CopyAndTranspose (object) object PyArray_Correlate (object, object, int) int PyArray_TypestrConvert (int, int) #int PyArray_DescrConverter (object, dtype) except 0 #int PyArray_DescrConverter2 (object, dtype) except 0 int PyArray_IntpConverter (object, PyArray_Dims ) except 0 #int PyArray_BufferConverter (object, chunk) except 0 int PyArray_AxisConverter (object, int ) except 0 int PyArray_BoolConverter (object, npy_bool ) except 0 int PyArray_ByteorderConverter (object, char ) except 0 int PyArray_OrderConverter (object, NPY_ORDER ) except 0 unsigned char PyArray_EquivTypes (dtype, dtype) # clears errors #object PyArray_Zeros (int, npy_intp , dtype, int) #object PyArray_Empty (int, npy_intp , dtype, int) object PyArray_Where (object, object, object) object PyArray_Arange (double, double, double, int) #object PyArray_ArangeObj (object, object, object, dtype) int PyArray_SortkindConverter (object, NPY_SORTKIND ) except 0 object PyArray_LexSort (object, int) object PyArray_Round (ndarray, int, ndarray) unsigned char PyArray_EquivTypenums (int, int) int PyArray_RegisterDataType (dtype) except -1 int PyArray_RegisterCastFunc (dtype, int, PyArray_VectorUnaryFunc ) except -1 int PyArray_RegisterCanCast (dtype, int, NPY_SCALARKIND) except -1 #void PyArray_InitArrFuncs (PyArray_ArrFuncs ) object PyArray_IntTupleFromIntp (int, npy_intp ) int PyArray_TypeNumFromName (char ) int PyArray_ClipmodeConverter (object, NPY_CLIPMODE ) except 0 #int PyArray_OutputConverter (object, ndarray) except 0 object PyArray_BroadcastToShape (object, npy_intp , int) void _PyArray_SigintHandler (int) void _PyArray_GetSigintBuf () #int PyArray_DescrAlignConverter (object, dtype) except 0 #int PyArray_DescrAlignConverter2 (object, dtype) except 0 int PyArray_SearchsideConverter (object, void ) except 0 object PyArray_CheckAxis (ndarray, int , int) npy_intp PyArray_OverflowMultiplyList (npy_intp , int) int PyArray_CompareString (char , char , size_t) int PyArray_SetBaseObject(ndarray, base) except -1 # NOTE: steals a reference to base! Use "set_array_base()" instead. # Typedefs that matches the runtime dtype objects in # the numpy module. # The ones that are commented out needs an IFDEF function # in Cython to enable them only on the right systems. ctypedef npy_int8 int8_t ctypedef npy_int16 int16_t ctypedef npy_int32 int32_t ctypedef npy_int64 int64_t #ctypedef npy_int96 int96_t #ctypedef npy_int128 int128_t ctypedef npy_uint8 uint8_t ctypedef npy_uint16 uint16_t ctypedef npy_uint32 uint32_t ctypedef npy_uint64 uint64_t #ctypedef npy_uint96 uint96_t #ctypedef npy_uint128 uint128_t ctypedef npy_float32 float32_t ctypedef npy_float64 float64_t #ctypedef npy_float80 float80_t #ctypedef npy_float128 float128_t ctypedef float complex complex64_t ctypedef double complex complex128_t # The int types are mapped a bit surprising -- # numpy.int corresponds to 'l' and numpy.long to 'q' ctypedef npy_long int_t ctypedef npy_longlong longlong_t ctypedef npy_ulong uint_t ctypedef npy_ulonglong ulonglong_t ctypedef npy_intp intp_t ctypedef npy_uintp uintp_t ctypedef npy_double float_t ctypedef npy_double double_t ctypedef npy_longdouble longdouble_t ctypedef npy_cfloat cfloat_t ctypedef npy_cdouble cdouble_t ctypedef npy_clongdouble clongdouble_t ctypedef npy_cdouble complex_t cdef inline object PyArray_MultiIterNew1(a): return PyArray_MultiIterNew(1, <void>a) cdef inline object PyArray_MultiIterNew2(a, b): return PyArray_MultiIterNew(2, <void>a, <void>b) cdef inline object PyArray_MultiIterNew3(a, b, c): return PyArray_MultiIterNew(3, <void>a, <void>b, <void> c) cdef inline object PyArray_MultiIterNew4(a, b, c, d): return PyArray_MultiIterNew(4, <void>a, <void>b, <void>c, <void> d) cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): return PyArray_MultiIterNew(5, <void>a, <void>b, <void>c, <void> d, <void> e) cdef inline tuple PyDataType_SHAPE(dtype d): if PyDataType_HASSUBARRAY(d): return <tuple>d.subarray.shape else: return () cdef extern from "numpy/ndarrayobject.h": PyTypeObject PyTimedeltaArrType_Type PyTypeObject PyDatetimeArrType_Type ctypedef int64_t npy_timedelta ctypedef int64_t npy_datetime cdef extern from "numpy/ndarraytypes.h": ctypedef struct PyArray_DatetimeMetaData: NPY_DATETIMEUNIT base int64_t num cdef extern from "numpy/arrayscalars.h": # abstract types ctypedef class numpy.generic [object PyObject]: pass ctypedef class numpy.number [object PyObject]: pass ctypedef class numpy.integer [object PyObject]: pass ctypedef class numpy.signedinteger [object PyObject]: pass ctypedef class numpy.unsignedinteger [object PyObject]: pass ctypedef class numpy.inexact [object PyObject]: pass ctypedef class numpy.floating [object PyObject]: pass ctypedef class numpy.complexfloating [object PyObject]: pass ctypedef class numpy.flexible [object PyObject]: pass ctypedef class numpy.character [object PyObject]: pass ctypedef struct PyDatetimeScalarObject: # PyObject_HEAD npy_datetime obval PyArray_DatetimeMetaData obmeta ctypedef struct PyTimedeltaScalarObject: # PyObject_HEAD npy_timedelta obval PyArray_DatetimeMetaData obmeta ctypedef enum NPY_DATETIMEUNIT: NPY_FR_Y NPY_FR_M NPY_FR_W NPY_FR_D NPY_FR_B NPY_FR_h NPY_FR_m NPY_FR_s NPY_FR_ms NPY_FR_us NPY_FR_ns NPY_FR_ps NPY_FR_fs NPY_FR_as # # ufunc API # cdef extern from "numpy/ufuncobject.h": ctypedef void (PyUFuncGenericFunction) (char , npy_intp , npy_intp , void ) ctypedef class numpy.ufunc [object PyUFuncObject, check_size ignore]: cdef: int nin, nout, nargs int identity PyUFuncGenericFunction functions void data int ntypes int check_return char name char types char doc void ptr PyObject obj PyObject userloops cdef enum: PyUFunc_Zero PyUFunc_One PyUFunc_None UFUNC_ERR_IGNORE UFUNC_ERR_WARN UFUNC_ERR_RAISE UFUNC_ERR_CALL UFUNC_ERR_PRINT UFUNC_ERR_LOG UFUNC_MASK_DIVIDEBYZERO UFUNC_MASK_OVERFLOW UFUNC_MASK_UNDERFLOW UFUNC_MASK_INVALID UFUNC_SHIFT_DIVIDEBYZERO UFUNC_SHIFT_OVERFLOW UFUNC_SHIFT_UNDERFLOW UFUNC_SHIFT_INVALID UFUNC_FPE_DIVIDEBYZERO UFUNC_FPE_OVERFLOW UFUNC_FPE_UNDERFLOW UFUNC_FPE_INVALID UFUNC_ERR_DEFAULT UFUNC_ERR_DEFAULT2 object PyUFunc_FromFuncAndData(PyUFuncGenericFunction , void *, char , int, int, int, int, char , char , int) int PyUFunc_RegisterLoopForType(ufunc, int, PyUFuncGenericFunction, int , void ) except -1 void PyUFunc_f_f_As_d_d \ (char *, npy_intp , npy_intp , void ) void PyUFunc_d_d \ (char *, npy_intp , npy_intp , void ) void PyUFunc_f_f \ (char *, npy_intp , npy_intp , void ) void PyUFunc_g_g \ (char *, npy_intp , npy_intp , void ) void PyUFunc_F_F_As_D_D \ (char *, npy_intp , npy_intp , void ) void PyUFunc_F_F \ (char *, npy_intp , npy_intp , void ) void PyUFunc_D_D \ (char *, npy_intp , npy_intp , void ) void PyUFunc_G_G \ (char *, npy_intp , npy_intp , void ) void PyUFunc_O_O \ (char *, npy_intp , npy_intp , void ) void PyUFunc_ff_f_As_dd_d \ (char *, npy_intp , npy_intp , void ) void PyUFunc_ff_f \ (char *, npy_intp , npy_intp , void ) void PyUFunc_dd_d \ (char *, npy_intp , npy_intp , void ) void PyUFunc_gg_g \ (char *, npy_intp , npy_intp , void ) void PyUFunc_FF_F_As_DD_D \ (char *, npy_intp , npy_intp , void ) void PyUFunc_DD_D \ (char *, npy_intp , npy_intp , void ) void PyUFunc_FF_F \ (char *, npy_intp , npy_intp , void ) void PyUFunc_GG_G \ (char *, npy_intp , npy_intp , void ) void PyUFunc_OO_O \ (char *, npy_intp , npy_intp , void ) void PyUFunc_O_O_method \ (char *, npy_intp , npy_intp , void ) void PyUFunc_OO_O_method \ (char *, npy_intp , npy_intp , void ) void PyUFunc_On_Om \ (char *, npy_intp , npy_intp , void ) int PyUFunc_GetPyValues \ (char , int , int , PyObject ) int PyUFunc_checkfperr \ (int, PyObject , int ) void PyUFunc_clearfperr() int PyUFunc_getfperr() int PyUFunc_handlefperr \ (int, PyObject , int, int ) except -1 int PyUFunc_ReplaceLoopBySignature \ (ufunc, PyUFuncGenericFunction, int , PyUFuncGenericFunction ) object PyUFunc_FromFuncAndDataAndSignature \ (PyUFuncGenericFunction , void *, char , int, int, int, int, char , char , int, char ) int _import_umath() except -1 cdef inline void set_array_base(ndarray arr, object base): Py_INCREF(base) # important to do this before stealing the reference below! PyArray_SetBaseObject(arr, base) cdef inline object get_array_base(ndarray arr): base = PyArray_BASE(arr) if base is NULL: return None return <object>base # Versions of the import_ functions which are more suitable for # Cython code. cdef inline int import_array() except -1: try: __pyx_import_array() except Exception: raise ImportError("numpy.core.multiarray failed to import") cdef inline int import_umath() except -1: try: _import_umath() except Exception: raise ImportError("numpy.core.umath failed to import") cdef inline int import_ufunc() except -1: try: _import_umath() except Exception: raise ImportError("numpy.core.umath failed to import") cdef inline bint is_timedelta64_object(object obj): """ Cython equivalent of `isinstance(obj, np.timedelta64)` Parameters ---------- obj : object Returns ------- bool """ return PyObject_TypeCheck(obj, &PyTimedeltaArrType_Type) cdef inline bint is_datetime64_object(object obj): """ Cython equivalent of `isinstance(obj, np.datetime64)` Parameters ---------- obj : object Returns ------- bool """ return PyObject_TypeCheck(obj, &PyDatetimeArrType_Type) cdef inline npy_datetime get_datetime64_value(object obj) nogil: """ returns the int64 value underlying scalar numpy datetime64 object Note that to interpret this as a datetime, the corresponding unit is also needed. That can be found using `get_datetime64_unit`. """ return (<PyDatetimeScalarObject>obj).obval cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: """ returns the int64 value underlying scalar numpy timedelta64 object """ return (<PyTimedeltaScalarObject>obj).obval cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: """ returns the unit part of the dtype for a numpy datetime64 object. """ return <NPY_DATETIMEUNIT>(<PyDatetimeScalarObject*>obj).obmeta.base	35.81 KB	2026-01-20 12:58
📄 __init__.pxd # NumPy static imports for Cython < 3.0 # # If any of the PyArray_* functions are called, import_array must be # called first. # # Author: Dag Sverre Seljebotn # DEF _buffer_format_string_len = 255 cimport cpython.buffer as pybuf from cpython.ref cimport Py_INCREF from cpython.mem cimport PyObject_Malloc, PyObject_Free from cpython.object cimport PyObject, PyTypeObject from cpython.buffer cimport PyObject_GetBuffer from cpython.type cimport type cimport libc.stdio as stdio cdef extern from "Python.h": ctypedef int Py_intptr_t bint PyObject_TypeCheck(object obj, PyTypeObject* type) cdef extern from "numpy/arrayobject.h": ctypedef Py_intptr_t npy_intp ctypedef size_t npy_uintp cdef enum NPY_TYPES: NPY_BOOL NPY_BYTE NPY_UBYTE NPY_SHORT NPY_USHORT NPY_INT NPY_UINT NPY_LONG NPY_ULONG NPY_LONGLONG NPY_ULONGLONG NPY_FLOAT NPY_DOUBLE NPY_LONGDOUBLE NPY_CFLOAT NPY_CDOUBLE NPY_CLONGDOUBLE NPY_OBJECT NPY_STRING NPY_UNICODE NPY_VOID NPY_DATETIME NPY_TIMEDELTA NPY_NTYPES NPY_NOTYPE NPY_INT8 NPY_INT16 NPY_INT32 NPY_INT64 NPY_INT128 NPY_INT256 NPY_UINT8 NPY_UINT16 NPY_UINT32 NPY_UINT64 NPY_UINT128 NPY_UINT256 NPY_FLOAT16 NPY_FLOAT32 NPY_FLOAT64 NPY_FLOAT80 NPY_FLOAT96 NPY_FLOAT128 NPY_FLOAT256 NPY_COMPLEX32 NPY_COMPLEX64 NPY_COMPLEX128 NPY_COMPLEX160 NPY_COMPLEX192 NPY_COMPLEX256 NPY_COMPLEX512 NPY_INTP ctypedef enum NPY_ORDER: NPY_ANYORDER NPY_CORDER NPY_FORTRANORDER NPY_KEEPORDER ctypedef enum NPY_CASTING: NPY_NO_CASTING NPY_EQUIV_CASTING NPY_SAFE_CASTING NPY_SAME_KIND_CASTING NPY_UNSAFE_CASTING ctypedef enum NPY_CLIPMODE: NPY_CLIP NPY_WRAP NPY_RAISE ctypedef enum NPY_SCALARKIND: NPY_NOSCALAR, NPY_BOOL_SCALAR, NPY_INTPOS_SCALAR, NPY_INTNEG_SCALAR, NPY_FLOAT_SCALAR, NPY_COMPLEX_SCALAR, NPY_OBJECT_SCALAR ctypedef enum NPY_SORTKIND: NPY_QUICKSORT NPY_HEAPSORT NPY_MERGESORT ctypedef enum NPY_SEARCHSIDE: NPY_SEARCHLEFT NPY_SEARCHRIGHT enum: # DEPRECATED since NumPy 1.7 ! Do not use in new code! NPY_C_CONTIGUOUS NPY_F_CONTIGUOUS NPY_CONTIGUOUS NPY_FORTRAN NPY_OWNDATA NPY_FORCECAST NPY_ENSURECOPY NPY_ENSUREARRAY NPY_ELEMENTSTRIDES NPY_ALIGNED NPY_NOTSWAPPED NPY_WRITEABLE NPY_ARR_HAS_DESCR NPY_BEHAVED NPY_BEHAVED_NS NPY_CARRAY NPY_CARRAY_RO NPY_FARRAY NPY_FARRAY_RO NPY_DEFAULT NPY_IN_ARRAY NPY_OUT_ARRAY NPY_INOUT_ARRAY NPY_IN_FARRAY NPY_OUT_FARRAY NPY_INOUT_FARRAY NPY_UPDATE_ALL enum: # Added in NumPy 1.7 to replace the deprecated enums above. NPY_ARRAY_C_CONTIGUOUS NPY_ARRAY_F_CONTIGUOUS NPY_ARRAY_OWNDATA NPY_ARRAY_FORCECAST NPY_ARRAY_ENSURECOPY NPY_ARRAY_ENSUREARRAY NPY_ARRAY_ELEMENTSTRIDES NPY_ARRAY_ALIGNED NPY_ARRAY_NOTSWAPPED NPY_ARRAY_WRITEABLE NPY_ARRAY_WRITEBACKIFCOPY NPY_ARRAY_BEHAVED NPY_ARRAY_BEHAVED_NS NPY_ARRAY_CARRAY NPY_ARRAY_CARRAY_RO NPY_ARRAY_FARRAY NPY_ARRAY_FARRAY_RO NPY_ARRAY_DEFAULT NPY_ARRAY_IN_ARRAY NPY_ARRAY_OUT_ARRAY NPY_ARRAY_INOUT_ARRAY NPY_ARRAY_IN_FARRAY NPY_ARRAY_OUT_FARRAY NPY_ARRAY_INOUT_FARRAY NPY_ARRAY_UPDATE_ALL cdef enum: NPY_MAXDIMS npy_intp NPY_MAX_ELSIZE ctypedef void (PyArray_VectorUnaryFunc)(void , void , npy_intp, void , void ) ctypedef struct PyArray_ArrayDescr: # shape is a tuple, but Cython doesn't support "tuple shape" # inside a non-PyObject declaration, so we have to declare it # as just a PyObject. PyObject* shape ctypedef struct PyArray_Descr: pass ctypedef class numpy.dtype [object PyArray_Descr, check_size ignore]: # Use PyDataType_* macros when possible, however there are no macros # for accessing some of the fields, so some are defined. cdef PyTypeObject* typeobj cdef char kind cdef char type # Numpy sometimes mutates this without warning (e.g. it'll # sometimes change "\|" to "<" in shared dtype objects on # little-endian machines). If this matters to you, use # PyArray_IsNativeByteOrder(dtype.byteorder) instead of # directly accessing this field. cdef char byteorder cdef char flags cdef int type_num cdef int itemsize "elsize" cdef int alignment cdef object fields cdef tuple names # Use PyDataType_HASSUBARRAY to test whether this field is # valid (the pointer can be NULL). Most users should access # this field via the inline helper method PyDataType_SHAPE. cdef PyArray_ArrayDescr* subarray ctypedef class numpy.flatiter [object PyArrayIterObject, check_size ignore]: # Use through macros pass ctypedef class numpy.broadcast [object PyArrayMultiIterObject, check_size ignore]: cdef int numiter cdef npy_intp size, index cdef int nd cdef npy_intp dimensions cdef void iters ctypedef struct PyArrayObject: # For use in situations where ndarray can't replace PyArrayObject, # like PyArrayObject*. pass ctypedef class numpy.ndarray [object PyArrayObject, check_size ignore]: cdef __cythonbufferdefaults__ = {"mode": "strided"} cdef: # Only taking a few of the most commonly used and stable fields. # One should use PyArray_ macros instead to access the C fields. char data int ndim "nd" npy_intp shape "dimensions" npy_intp strides dtype descr # deprecated since NumPy 1.7 ! PyObject base # NOT PUBLIC, DO NOT USE ! ctypedef unsigned char npy_bool ctypedef signed char npy_byte ctypedef signed short npy_short ctypedef signed int npy_int ctypedef signed long npy_long ctypedef signed long long npy_longlong ctypedef unsigned char npy_ubyte ctypedef unsigned short npy_ushort ctypedef unsigned int npy_uint ctypedef unsigned long npy_ulong ctypedef unsigned long long npy_ulonglong ctypedef float npy_float ctypedef double npy_double ctypedef long double npy_longdouble ctypedef signed char npy_int8 ctypedef signed short npy_int16 ctypedef signed int npy_int32 ctypedef signed long long npy_int64 ctypedef signed long long npy_int96 ctypedef signed long long npy_int128 ctypedef unsigned char npy_uint8 ctypedef unsigned short npy_uint16 ctypedef unsigned int npy_uint32 ctypedef unsigned long long npy_uint64 ctypedef unsigned long long npy_uint96 ctypedef unsigned long long npy_uint128 ctypedef float npy_float32 ctypedef double npy_float64 ctypedef long double npy_float80 ctypedef long double npy_float96 ctypedef long double npy_float128 ctypedef struct npy_cfloat: float real float imag ctypedef struct npy_cdouble: double real double imag ctypedef struct npy_clongdouble: long double real long double imag ctypedef struct npy_complex64: float real float imag ctypedef struct npy_complex128: double real double imag ctypedef struct npy_complex160: long double real long double imag ctypedef struct npy_complex192: long double real long double imag ctypedef struct npy_complex256: long double real long double imag ctypedef struct PyArray_Dims: npy_intp ptr int len int _import_array() except -1 # A second definition so _import_array isn't marked as used when we use it here. # Do not use - subject to change any time. int __pyx_import_array "_import_array"() except -1 # # Macros from ndarrayobject.h # bint PyArray_CHKFLAGS(ndarray m, int flags) nogil bint PyArray_IS_C_CONTIGUOUS(ndarray arr) nogil bint PyArray_IS_F_CONTIGUOUS(ndarray arr) nogil bint PyArray_ISCONTIGUOUS(ndarray m) nogil bint PyArray_ISWRITEABLE(ndarray m) nogil bint PyArray_ISALIGNED(ndarray m) nogil int PyArray_NDIM(ndarray) nogil bint PyArray_ISONESEGMENT(ndarray) nogil bint PyArray_ISFORTRAN(ndarray) nogil int PyArray_FORTRANIF(ndarray) nogil void PyArray_DATA(ndarray) nogil char* PyArray_BYTES(ndarray) nogil npy_intp* PyArray_DIMS(ndarray) nogil npy_intp* PyArray_STRIDES(ndarray) nogil npy_intp PyArray_DIM(ndarray, size_t) nogil npy_intp PyArray_STRIDE(ndarray, size_t) nogil PyObject PyArray_BASE(ndarray) nogil # returns borrowed reference! PyArray_Descr PyArray_DESCR(ndarray) nogil # returns borrowed reference to dtype! int PyArray_FLAGS(ndarray) nogil npy_intp PyArray_ITEMSIZE(ndarray) nogil int PyArray_TYPE(ndarray arr) nogil object PyArray_GETITEM(ndarray arr, void itemptr) int PyArray_SETITEM(ndarray arr, void itemptr, object obj) except -1 bint PyTypeNum_ISBOOL(int) nogil bint PyTypeNum_ISUNSIGNED(int) nogil bint PyTypeNum_ISSIGNED(int) nogil bint PyTypeNum_ISINTEGER(int) nogil bint PyTypeNum_ISFLOAT(int) nogil bint PyTypeNum_ISNUMBER(int) nogil bint PyTypeNum_ISSTRING(int) nogil bint PyTypeNum_ISCOMPLEX(int) nogil bint PyTypeNum_ISPYTHON(int) nogil bint PyTypeNum_ISFLEXIBLE(int) nogil bint PyTypeNum_ISUSERDEF(int) nogil bint PyTypeNum_ISEXTENDED(int) nogil bint PyTypeNum_ISOBJECT(int) nogil bint PyDataType_ISBOOL(dtype) nogil bint PyDataType_ISUNSIGNED(dtype) nogil bint PyDataType_ISSIGNED(dtype) nogil bint PyDataType_ISINTEGER(dtype) nogil bint PyDataType_ISFLOAT(dtype) nogil bint PyDataType_ISNUMBER(dtype) nogil bint PyDataType_ISSTRING(dtype) nogil bint PyDataType_ISCOMPLEX(dtype) nogil bint PyDataType_ISPYTHON(dtype) nogil bint PyDataType_ISFLEXIBLE(dtype) nogil bint PyDataType_ISUSERDEF(dtype) nogil bint PyDataType_ISEXTENDED(dtype) nogil bint PyDataType_ISOBJECT(dtype) nogil bint PyDataType_HASFIELDS(dtype) nogil bint PyDataType_HASSUBARRAY(dtype) nogil bint PyArray_ISBOOL(ndarray) nogil bint PyArray_ISUNSIGNED(ndarray) nogil bint PyArray_ISSIGNED(ndarray) nogil bint PyArray_ISINTEGER(ndarray) nogil bint PyArray_ISFLOAT(ndarray) nogil bint PyArray_ISNUMBER(ndarray) nogil bint PyArray_ISSTRING(ndarray) nogil bint PyArray_ISCOMPLEX(ndarray) nogil bint PyArray_ISPYTHON(ndarray) nogil bint PyArray_ISFLEXIBLE(ndarray) nogil bint PyArray_ISUSERDEF(ndarray) nogil bint PyArray_ISEXTENDED(ndarray) nogil bint PyArray_ISOBJECT(ndarray) nogil bint PyArray_HASFIELDS(ndarray) nogil bint PyArray_ISVARIABLE(ndarray) nogil bint PyArray_SAFEALIGNEDCOPY(ndarray) nogil bint PyArray_ISNBO(char) nogil # works on ndarray.byteorder bint PyArray_IsNativeByteOrder(char) nogil # works on ndarray.byteorder bint PyArray_ISNOTSWAPPED(ndarray) nogil bint PyArray_ISBYTESWAPPED(ndarray) nogil bint PyArray_FLAGSWAP(ndarray, int) nogil bint PyArray_ISCARRAY(ndarray) nogil bint PyArray_ISCARRAY_RO(ndarray) nogil bint PyArray_ISFARRAY(ndarray) nogil bint PyArray_ISFARRAY_RO(ndarray) nogil bint PyArray_ISBEHAVED(ndarray) nogil bint PyArray_ISBEHAVED_RO(ndarray) nogil bint PyDataType_ISNOTSWAPPED(dtype) nogil bint PyDataType_ISBYTESWAPPED(dtype) nogil bint PyArray_DescrCheck(object) bint PyArray_Check(object) bint PyArray_CheckExact(object) # Cannot be supported due to out arg: # bint PyArray_HasArrayInterfaceType(object, dtype, object, object&) # bint PyArray_HasArrayInterface(op, out) bint PyArray_IsZeroDim(object) # Cannot be supported due to ## ## in macro: # bint PyArray_IsScalar(object, verbatim work) bint PyArray_CheckScalar(object) bint PyArray_IsPythonNumber(object) bint PyArray_IsPythonScalar(object) bint PyArray_IsAnyScalar(object) bint PyArray_CheckAnyScalar(object) ndarray PyArray_GETCONTIGUOUS(ndarray) bint PyArray_SAMESHAPE(ndarray, ndarray) nogil npy_intp PyArray_SIZE(ndarray) nogil npy_intp PyArray_NBYTES(ndarray) nogil object PyArray_FROM_O(object) object PyArray_FROM_OF(object m, int flags) object PyArray_FROM_OT(object m, int type) object PyArray_FROM_OTF(object m, int type, int flags) object PyArray_FROMANY(object m, int type, int min, int max, int flags) object PyArray_ZEROS(int nd, npy_intp* dims, int type, int fortran) object PyArray_EMPTY(int nd, npy_intp* dims, int type, int fortran) void PyArray_FILLWBYTE(object, int val) npy_intp PyArray_REFCOUNT(object) object PyArray_ContiguousFromAny(op, int, int min_depth, int max_depth) unsigned char PyArray_EquivArrTypes(ndarray a1, ndarray a2) bint PyArray_EquivByteorders(int b1, int b2) nogil object PyArray_SimpleNew(int nd, npy_intp* dims, int typenum) object PyArray_SimpleNewFromData(int nd, npy_intp* dims, int typenum, void* data) #object PyArray_SimpleNewFromDescr(int nd, npy_intp* dims, dtype descr) object PyArray_ToScalar(void* data, ndarray arr) void* PyArray_GETPTR1(ndarray m, npy_intp i) nogil void* PyArray_GETPTR2(ndarray m, npy_intp i, npy_intp j) nogil void* PyArray_GETPTR3(ndarray m, npy_intp i, npy_intp j, npy_intp k) nogil void* PyArray_GETPTR4(ndarray m, npy_intp i, npy_intp j, npy_intp k, npy_intp l) nogil # Cannot be supported due to out arg # void PyArray_DESCR_REPLACE(descr) object PyArray_Copy(ndarray) object PyArray_FromObject(object op, int type, int min_depth, int max_depth) object PyArray_ContiguousFromObject(object op, int type, int min_depth, int max_depth) object PyArray_CopyFromObject(object op, int type, int min_depth, int max_depth) object PyArray_Cast(ndarray mp, int type_num) object PyArray_Take(ndarray ap, object items, int axis) object PyArray_Put(ndarray ap, object items, object values) void PyArray_ITER_RESET(flatiter it) nogil void PyArray_ITER_NEXT(flatiter it) nogil void PyArray_ITER_GOTO(flatiter it, npy_intp* destination) nogil void PyArray_ITER_GOTO1D(flatiter it, npy_intp ind) nogil void* PyArray_ITER_DATA(flatiter it) nogil bint PyArray_ITER_NOTDONE(flatiter it) nogil void PyArray_MultiIter_RESET(broadcast multi) nogil void PyArray_MultiIter_NEXT(broadcast multi) nogil void PyArray_MultiIter_GOTO(broadcast multi, npy_intp dest) nogil void PyArray_MultiIter_GOTO1D(broadcast multi, npy_intp ind) nogil void* PyArray_MultiIter_DATA(broadcast multi, npy_intp i) nogil void PyArray_MultiIter_NEXTi(broadcast multi, npy_intp i) nogil bint PyArray_MultiIter_NOTDONE(broadcast multi) nogil # Functions from __multiarray_api.h # Functions taking dtype and returning object/ndarray are disabled # for now as they steal dtype references. I'm conservative and disable # more than is probably needed until it can be checked further. int PyArray_SetNumericOps (object) except -1 object PyArray_GetNumericOps () int PyArray_INCREF (ndarray) except * # uses PyArray_Item_INCREF... int PyArray_XDECREF (ndarray) except * # uses PyArray_Item_DECREF... void PyArray_SetStringFunction (object, int) dtype PyArray_DescrFromType (int) object PyArray_TypeObjectFromType (int) char * PyArray_Zero (ndarray) char * PyArray_One (ndarray) #object PyArray_CastToType (ndarray, dtype, int) int PyArray_CastTo (ndarray, ndarray) except -1 int PyArray_CastAnyTo (ndarray, ndarray) except -1 int PyArray_CanCastSafely (int, int) # writes errors npy_bool PyArray_CanCastTo (dtype, dtype) # writes errors int PyArray_ObjectType (object, int) except 0 dtype PyArray_DescrFromObject (object, dtype) #ndarray* PyArray_ConvertToCommonType (object, int ) dtype PyArray_DescrFromScalar (object) dtype PyArray_DescrFromTypeObject (object) npy_intp PyArray_Size (object) #object PyArray_Scalar (void , dtype, object) #object PyArray_FromScalar (object, dtype) void PyArray_ScalarAsCtype (object, void ) #int PyArray_CastScalarToCtype (object, void , dtype) #int PyArray_CastScalarDirect (object, dtype, void , int) object PyArray_ScalarFromObject (object) #PyArray_VectorUnaryFunc PyArray_GetCastFunc (dtype, int) object PyArray_FromDims (int, int , int) #object PyArray_FromDimsAndDataAndDescr (int, int , dtype, char ) #object PyArray_FromAny (object, dtype, int, int, int, object) object PyArray_EnsureArray (object) object PyArray_EnsureAnyArray (object) #object PyArray_FromFile (stdio.FILE , dtype, npy_intp, char ) #object PyArray_FromString (char , npy_intp, dtype, npy_intp, char ) #object PyArray_FromBuffer (object, dtype, npy_intp, npy_intp) #object PyArray_FromIter (object, dtype, npy_intp) object PyArray_Return (ndarray) #object PyArray_GetField (ndarray, dtype, int) #int PyArray_SetField (ndarray, dtype, int, object) except -1 object PyArray_Byteswap (ndarray, npy_bool) object PyArray_Resize (ndarray, PyArray_Dims , int, NPY_ORDER) int PyArray_MoveInto (ndarray, ndarray) except -1 int PyArray_CopyInto (ndarray, ndarray) except -1 int PyArray_CopyAnyInto (ndarray, ndarray) except -1 int PyArray_CopyObject (ndarray, object) except -1 object PyArray_NewCopy (ndarray, NPY_ORDER) object PyArray_ToList (ndarray) object PyArray_ToString (ndarray, NPY_ORDER) int PyArray_ToFile (ndarray, stdio.FILE , char , char ) except -1 int PyArray_Dump (object, object, int) except -1 object PyArray_Dumps (object, int) int PyArray_ValidType (int) # Cannot error void PyArray_UpdateFlags (ndarray, int) object PyArray_New (type, int, npy_intp , int, npy_intp , void , int, int, object) #object PyArray_NewFromDescr (type, dtype, int, npy_intp , npy_intp , void , int, object) #dtype PyArray_DescrNew (dtype) dtype PyArray_DescrNewFromType (int) double PyArray_GetPriority (object, double) # clears errors as of 1.25 object PyArray_IterNew (object) object PyArray_MultiIterNew (int, ...) int PyArray_PyIntAsInt (object) except? -1 npy_intp PyArray_PyIntAsIntp (object) int PyArray_Broadcast (broadcast) except -1 void PyArray_FillObjectArray (ndarray, object) except int PyArray_FillWithScalar (ndarray, object) except -1 npy_bool PyArray_CheckStrides (int, int, npy_intp, npy_intp, npy_intp , npy_intp ) dtype PyArray_DescrNewByteorder (dtype, char) object PyArray_IterAllButAxis (object, int ) #object PyArray_CheckFromAny (object, dtype, int, int, int, object) #object PyArray_FromArray (ndarray, dtype, int) object PyArray_FromInterface (object) object PyArray_FromStructInterface (object) #object PyArray_FromArrayAttr (object, dtype, object) #NPY_SCALARKIND PyArray_ScalarKind (int, ndarray) int PyArray_CanCoerceScalar (int, int, NPY_SCALARKIND) object PyArray_NewFlagsObject (object) npy_bool PyArray_CanCastScalar (type, type) #int PyArray_CompareUCS4 (npy_ucs4 , npy_ucs4 , register size_t) int PyArray_RemoveSmallest (broadcast) except -1 int PyArray_ElementStrides (object) void PyArray_Item_INCREF (char , dtype) except void PyArray_Item_XDECREF (char , dtype) except object PyArray_FieldNames (object) object PyArray_Transpose (ndarray, PyArray_Dims ) object PyArray_TakeFrom (ndarray, object, int, ndarray, NPY_CLIPMODE) object PyArray_PutTo (ndarray, object, object, NPY_CLIPMODE) object PyArray_PutMask (ndarray, object, object) object PyArray_Repeat (ndarray, object, int) object PyArray_Choose (ndarray, object, ndarray, NPY_CLIPMODE) int PyArray_Sort (ndarray, int, NPY_SORTKIND) except -1 object PyArray_ArgSort (ndarray, int, NPY_SORTKIND) object PyArray_SearchSorted (ndarray, object, NPY_SEARCHSIDE, PyObject ) object PyArray_ArgMax (ndarray, int, ndarray) object PyArray_ArgMin (ndarray, int, ndarray) object PyArray_Reshape (ndarray, object) object PyArray_Newshape (ndarray, PyArray_Dims , NPY_ORDER) object PyArray_Squeeze (ndarray) #object PyArray_View (ndarray, dtype, type) object PyArray_SwapAxes (ndarray, int, int) object PyArray_Max (ndarray, int, ndarray) object PyArray_Min (ndarray, int, ndarray) object PyArray_Ptp (ndarray, int, ndarray) object PyArray_Mean (ndarray, int, int, ndarray) object PyArray_Trace (ndarray, int, int, int, int, ndarray) object PyArray_Diagonal (ndarray, int, int, int) object PyArray_Clip (ndarray, object, object, ndarray) object PyArray_Conjugate (ndarray, ndarray) object PyArray_Nonzero (ndarray) object PyArray_Std (ndarray, int, int, ndarray, int) object PyArray_Sum (ndarray, int, int, ndarray) object PyArray_CumSum (ndarray, int, int, ndarray) object PyArray_Prod (ndarray, int, int, ndarray) object PyArray_CumProd (ndarray, int, int, ndarray) object PyArray_All (ndarray, int, ndarray) object PyArray_Any (ndarray, int, ndarray) object PyArray_Compress (ndarray, object, int, ndarray) object PyArray_Flatten (ndarray, NPY_ORDER) object PyArray_Ravel (ndarray, NPY_ORDER) npy_intp PyArray_MultiplyList (npy_intp , int) int PyArray_MultiplyIntList (int , int) void PyArray_GetPtr (ndarray, npy_intp) int PyArray_CompareLists (npy_intp , npy_intp , int) #int PyArray_AsCArray (object, void , npy_intp , int, dtype) #int PyArray_As1D (object, char , int , int) #int PyArray_As2D (object, char *, int , int , int) int PyArray_Free (object, void ) #int PyArray_Converter (object, object) int PyArray_IntpFromSequence (object, npy_intp , int) except -1 object PyArray_Concatenate (object, int) object PyArray_InnerProduct (object, object) object PyArray_MatrixProduct (object, object) object PyArray_CopyAndTranspose (object) object PyArray_Correlate (object, object, int) int PyArray_TypestrConvert (int, int) #int PyArray_DescrConverter (object, dtype) except 0 #int PyArray_DescrConverter2 (object, dtype) except 0 int PyArray_IntpConverter (object, PyArray_Dims ) except 0 #int PyArray_BufferConverter (object, chunk) except 0 int PyArray_AxisConverter (object, int ) except 0 int PyArray_BoolConverter (object, npy_bool ) except 0 int PyArray_ByteorderConverter (object, char ) except 0 int PyArray_OrderConverter (object, NPY_ORDER ) except 0 unsigned char PyArray_EquivTypes (dtype, dtype) # clears errors #object PyArray_Zeros (int, npy_intp , dtype, int) #object PyArray_Empty (int, npy_intp , dtype, int) object PyArray_Where (object, object, object) object PyArray_Arange (double, double, double, int) #object PyArray_ArangeObj (object, object, object, dtype) int PyArray_SortkindConverter (object, NPY_SORTKIND ) except 0 object PyArray_LexSort (object, int) object PyArray_Round (ndarray, int, ndarray) unsigned char PyArray_EquivTypenums (int, int) int PyArray_RegisterDataType (dtype) except -1 int PyArray_RegisterCastFunc (dtype, int, PyArray_VectorUnaryFunc ) except -1 int PyArray_RegisterCanCast (dtype, int, NPY_SCALARKIND) except -1 #void PyArray_InitArrFuncs (PyArray_ArrFuncs ) object PyArray_IntTupleFromIntp (int, npy_intp ) int PyArray_TypeNumFromName (char ) int PyArray_ClipmodeConverter (object, NPY_CLIPMODE ) except 0 #int PyArray_OutputConverter (object, ndarray) except 0 object PyArray_BroadcastToShape (object, npy_intp , int) void _PyArray_SigintHandler (int) void _PyArray_GetSigintBuf () #int PyArray_DescrAlignConverter (object, dtype) except 0 #int PyArray_DescrAlignConverter2 (object, dtype) except 0 int PyArray_SearchsideConverter (object, void ) except 0 object PyArray_CheckAxis (ndarray, int , int) npy_intp PyArray_OverflowMultiplyList (npy_intp , int) int PyArray_CompareString (char , char , size_t) int PyArray_SetBaseObject(ndarray, base) except -1 # NOTE: steals a reference to base! Use "set_array_base()" instead. # Typedefs that matches the runtime dtype objects in # the numpy module. # The ones that are commented out needs an IFDEF function # in Cython to enable them only on the right systems. ctypedef npy_int8 int8_t ctypedef npy_int16 int16_t ctypedef npy_int32 int32_t ctypedef npy_int64 int64_t #ctypedef npy_int96 int96_t #ctypedef npy_int128 int128_t ctypedef npy_uint8 uint8_t ctypedef npy_uint16 uint16_t ctypedef npy_uint32 uint32_t ctypedef npy_uint64 uint64_t #ctypedef npy_uint96 uint96_t #ctypedef npy_uint128 uint128_t ctypedef npy_float32 float32_t ctypedef npy_float64 float64_t #ctypedef npy_float80 float80_t #ctypedef npy_float128 float128_t ctypedef float complex complex64_t ctypedef double complex complex128_t # The int types are mapped a bit surprising -- # numpy.int corresponds to 'l' and numpy.long to 'q' ctypedef npy_long int_t ctypedef npy_longlong longlong_t ctypedef npy_ulong uint_t ctypedef npy_ulonglong ulonglong_t ctypedef npy_intp intp_t ctypedef npy_uintp uintp_t ctypedef npy_double float_t ctypedef npy_double double_t ctypedef npy_longdouble longdouble_t ctypedef npy_cfloat cfloat_t ctypedef npy_cdouble cdouble_t ctypedef npy_clongdouble clongdouble_t ctypedef npy_cdouble complex_t cdef inline object PyArray_MultiIterNew1(a): return PyArray_MultiIterNew(1, <void>a) cdef inline object PyArray_MultiIterNew2(a, b): return PyArray_MultiIterNew(2, <void>a, <void>b) cdef inline object PyArray_MultiIterNew3(a, b, c): return PyArray_MultiIterNew(3, <void>a, <void>b, <void> c) cdef inline object PyArray_MultiIterNew4(a, b, c, d): return PyArray_MultiIterNew(4, <void>a, <void>b, <void>c, <void> d) cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): return PyArray_MultiIterNew(5, <void>a, <void>b, <void>c, <void> d, <void> e) cdef inline tuple PyDataType_SHAPE(dtype d): if PyDataType_HASSUBARRAY(d): return <tuple>d.subarray.shape else: return () cdef extern from "numpy/ndarrayobject.h": PyTypeObject PyTimedeltaArrType_Type PyTypeObject PyDatetimeArrType_Type ctypedef int64_t npy_timedelta ctypedef int64_t npy_datetime cdef extern from "numpy/ndarraytypes.h": ctypedef struct PyArray_DatetimeMetaData: NPY_DATETIMEUNIT base int64_t num cdef extern from "numpy/arrayscalars.h": # abstract types ctypedef class numpy.generic [object PyObject]: pass ctypedef class numpy.number [object PyObject]: pass ctypedef class numpy.integer [object PyObject]: pass ctypedef class numpy.signedinteger [object PyObject]: pass ctypedef class numpy.unsignedinteger [object PyObject]: pass ctypedef class numpy.inexact [object PyObject]: pass ctypedef class numpy.floating [object PyObject]: pass ctypedef class numpy.complexfloating [object PyObject]: pass ctypedef class numpy.flexible [object PyObject]: pass ctypedef class numpy.character [object PyObject]: pass ctypedef struct PyDatetimeScalarObject: # PyObject_HEAD npy_datetime obval PyArray_DatetimeMetaData obmeta ctypedef struct PyTimedeltaScalarObject: # PyObject_HEAD npy_timedelta obval PyArray_DatetimeMetaData obmeta ctypedef enum NPY_DATETIMEUNIT: NPY_FR_Y NPY_FR_M NPY_FR_W NPY_FR_D NPY_FR_B NPY_FR_h NPY_FR_m NPY_FR_s NPY_FR_ms NPY_FR_us NPY_FR_ns NPY_FR_ps NPY_FR_fs NPY_FR_as # # ufunc API # cdef extern from "numpy/ufuncobject.h": ctypedef void (PyUFuncGenericFunction) (char , npy_intp , npy_intp , void ) ctypedef class numpy.ufunc [object PyUFuncObject, check_size ignore]: cdef: int nin, nout, nargs int identity PyUFuncGenericFunction functions void data int ntypes int check_return char name char types char doc void ptr PyObject obj PyObject userloops cdef enum: PyUFunc_Zero PyUFunc_One PyUFunc_None UFUNC_ERR_IGNORE UFUNC_ERR_WARN UFUNC_ERR_RAISE UFUNC_ERR_CALL UFUNC_ERR_PRINT UFUNC_ERR_LOG UFUNC_MASK_DIVIDEBYZERO UFUNC_MASK_OVERFLOW UFUNC_MASK_UNDERFLOW UFUNC_MASK_INVALID UFUNC_SHIFT_DIVIDEBYZERO UFUNC_SHIFT_OVERFLOW UFUNC_SHIFT_UNDERFLOW UFUNC_SHIFT_INVALID UFUNC_FPE_DIVIDEBYZERO UFUNC_FPE_OVERFLOW UFUNC_FPE_UNDERFLOW UFUNC_FPE_INVALID UFUNC_ERR_DEFAULT UFUNC_ERR_DEFAULT2 object PyUFunc_FromFuncAndData(PyUFuncGenericFunction , void *, char , int, int, int, int, char , char , int) int PyUFunc_RegisterLoopForType(ufunc, int, PyUFuncGenericFunction, int , void ) except -1 void PyUFunc_f_f_As_d_d \ (char *, npy_intp , npy_intp , void ) void PyUFunc_d_d \ (char *, npy_intp , npy_intp , void ) void PyUFunc_f_f \ (char *, npy_intp , npy_intp , void ) void PyUFunc_g_g \ (char *, npy_intp , npy_intp , void ) void PyUFunc_F_F_As_D_D \ (char *, npy_intp , npy_intp , void ) void PyUFunc_F_F \ (char *, npy_intp , npy_intp , void ) void PyUFunc_D_D \ (char *, npy_intp , npy_intp , void ) void PyUFunc_G_G \ (char *, npy_intp , npy_intp , void ) void PyUFunc_O_O \ (char *, npy_intp , npy_intp , void ) void PyUFunc_ff_f_As_dd_d \ (char *, npy_intp , npy_intp , void ) void PyUFunc_ff_f \ (char *, npy_intp , npy_intp , void ) void PyUFunc_dd_d \ (char *, npy_intp , npy_intp , void ) void PyUFunc_gg_g \ (char *, npy_intp , npy_intp , void ) void PyUFunc_FF_F_As_DD_D \ (char *, npy_intp , npy_intp , void ) void PyUFunc_DD_D \ (char *, npy_intp , npy_intp , void ) void PyUFunc_FF_F \ (char *, npy_intp , npy_intp , void ) void PyUFunc_GG_G \ (char *, npy_intp , npy_intp , void ) void PyUFunc_OO_O \ (char *, npy_intp , npy_intp , void ) void PyUFunc_O_O_method \ (char *, npy_intp , npy_intp , void ) void PyUFunc_OO_O_method \ (char *, npy_intp , npy_intp , void ) void PyUFunc_On_Om \ (char *, npy_intp , npy_intp , void ) int PyUFunc_GetPyValues \ (char , int , int , PyObject ) int PyUFunc_checkfperr \ (int, PyObject , int ) void PyUFunc_clearfperr() int PyUFunc_getfperr() int PyUFunc_handlefperr \ (int, PyObject , int, int ) except -1 int PyUFunc_ReplaceLoopBySignature \ (ufunc, PyUFuncGenericFunction, int , PyUFuncGenericFunction ) object PyUFunc_FromFuncAndDataAndSignature \ (PyUFuncGenericFunction , void *, char , int, int, int, int, char , char , int, char ) int _import_umath() except -1 cdef inline void set_array_base(ndarray arr, object base): Py_INCREF(base) # important to do this before stealing the reference below! PyArray_SetBaseObject(arr, base) cdef inline object get_array_base(ndarray arr): base = PyArray_BASE(arr) if base is NULL: return None return <object>base # Versions of the import_ functions which are more suitable for # Cython code. cdef inline int import_array() except -1: try: __pyx_import_array() except Exception: raise ImportError("numpy.core.multiarray failed to import") cdef inline int import_umath() except -1: try: _import_umath() except Exception: raise ImportError("numpy.core.umath failed to import") cdef inline int import_ufunc() except -1: try: _import_umath() except Exception: raise ImportError("numpy.core.umath failed to import") cdef extern from : # Leave a marker that the NumPy declarations came from this file # See https://github.com/cython/cython/issues/3573 """ / NumPy API declarations from "numpy/__init__.pxd" / """ cdef inline bint is_timedelta64_object(object obj): """ Cython equivalent of `isinstance(obj, np.timedelta64)` Parameters ---------- obj : object Returns ------- bool """ return PyObject_TypeCheck(obj, &PyTimedeltaArrType_Type) cdef inline bint is_datetime64_object(object obj): """ Cython equivalent of `isinstance(obj, np.datetime64)` Parameters ---------- obj : object Returns ------- bool """ return PyObject_TypeCheck(obj, &PyDatetimeArrType_Type) cdef inline npy_datetime get_datetime64_value(object obj) nogil: """ returns the int64 value underlying scalar numpy datetime64 object Note that to interpret this as a datetime, the corresponding unit is also needed. That can be found using `get_datetime64_unit`. """ return (<PyDatetimeScalarObject>obj).obval cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: """ returns the int64 value underlying scalar numpy timedelta64 object """ return (<PyTimedeltaScalarObject>obj).obval cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: """ returns the unit part of the dtype for a numpy datetime64 object. """ return <NPY_DATETIMEUNIT>(<PyDatetimeScalarObject>obj).obmeta.base	34.22 KB	2026-01-20 12:58
📄 __init__.py """ NumPy ===== Provides 1. An array object of arbitrary homogeneous items 2. Fast mathematical operations over arrays 3. Linear Algebra, Fourier Transforms, Random Number Generation How to use the documentation ---------------------------- Documentation is available in two forms: docstrings provided with the code, and a loose standing reference guide, available from `the NumPy homepage <https://numpy.org>`_. We recommend exploring the docstrings using `IPython <https://ipython.org>`_, an advanced Python shell with TAB-completion and introspection capabilities. See below for further instructions. The docstring examples assume that `numpy` has been imported as ``np``:: >>> import numpy as np Code snippets are indicated by three greater-than signs:: >>> x = 42 >>> x = x + 1 Use the built-in ``help`` function to view a function's docstring:: >>> help(np.sort) ... # doctest: +SKIP For some objects, ``np.info(obj)`` may provide additional help. This is particularly true if you see the line "Help on ufunc object:" at the top of the help() page. Ufuncs are implemented in C, not Python, for speed. The native Python help() does not know how to view their help, but our np.info() function does. To search for documents containing a keyword, do:: >>> np.lookfor('keyword') ... # doctest: +SKIP General-purpose documents like a glossary and help on the basic concepts of numpy are available under the ``doc`` sub-module:: >>> from numpy import doc >>> help(doc) ... # doctest: +SKIP Available subpackages --------------------- lib Basic functions used by several sub-packages. random Core Random Tools linalg Core Linear Algebra Tools fft Core FFT routines polynomial Polynomial tools testing NumPy testing tools distutils Enhancements to distutils with support for Fortran compilers support and more. Utilities --------- test Run numpy unittests show_config Show numpy build configuration matlib Make everything matrices. __version__ NumPy version string Viewing documentation using IPython ----------------------------------- Start IPython and import `numpy` usually under the alias ``np``: `import numpy as np`. Then, directly past or use the ``%cpaste`` magic to paste examples into the shell. To see which functions are available in `numpy`, type ``np.<TAB>`` (where ``<TAB>`` refers to the TAB key), or use ``np.cos?<ENTER>`` (where ``<ENTER>`` refers to the ENTER key) to narrow down the list. To view the docstring for a function, use ``np.cos?<ENTER>`` (to view the docstring) and ``np.cos??<ENTER>`` (to view the source code). Copies vs. in-place operation ----------------------------- Most of the functions in `numpy` return a copy of the array argument (e.g., `np.sort`). In-place versions of these functions are often available as array methods, i.e. ``x = np.array([1,2,3]); x.sort()``. Exceptions to this rule are documented. """ import sys import warnings from ._globals import _NoValue, _CopyMode # These exceptions were moved in 1.25 and are hidden from __dir__() from .exceptions import ( ComplexWarning, ModuleDeprecationWarning, VisibleDeprecationWarning, TooHardError, AxisError) # We first need to detect if we're being called as part of the numpy setup # procedure itself in a reliable manner. try: __NUMPY_SETUP__ except NameError: __NUMPY_SETUP__ = False if __NUMPY_SETUP__: sys.stderr.write('Running from numpy source directory.\n') else: # Allow distributors to run custom init code before importing numpy.core from . import _distributor_init try: from numpy.__config__ import show as show_config except ImportError as e: msg = """Error importing numpy: you should not try to import numpy from its source directory; please exit the numpy source tree, and relaunch your python interpreter from there.""" raise ImportError(msg) from e __all__ = [ 'exceptions', 'ModuleDeprecationWarning', 'VisibleDeprecationWarning', 'ComplexWarning', 'TooHardError', 'AxisError'] # mapping of {name: (value, deprecation_msg)} __deprecated_attrs__ = {} from . import core from .core import * from . import compat from . import exceptions from . import dtypes from . import lib # NOTE: to be revisited following future namespace cleanup. # See gh-14454 and gh-15672 for discussion. from .lib import * from . import linalg from . import fft from . import polynomial from . import random from . import ctypeslib from . import ma from . import matrixlib as _mat from .matrixlib import * # Deprecations introduced in NumPy 1.20.0, 2020-06-06 import builtins as _builtins _msg = ( "module 'numpy' has no attribute '{n}'.\n" "`np.{n}` was a deprecated alias for the builtin `{n}`. " "To avoid this error in existing code, use `{n}` by itself. " "Doing this will not modify any behavior and is safe. {extended_msg}\n" "The aliases was originally deprecated in NumPy 1.20; for more " "details and guidance see the original release note at:\n" " https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations") _specific_msg = ( "If you specifically wanted the numpy scalar type, use `np.{}` here.") _int_extended_msg = ( "When replacing `np.{}`, you may wish to use e.g. `np.int64` " "or `np.int32` to specify the precision. If you wish to review " "your current use, check the release note link for " "additional information.") _type_info = [ ("object", ""), # The NumPy scalar only exists by name. ("bool", _specific_msg.format("bool_")), ("float", _specific_msg.format("float64")), ("complex", _specific_msg.format("complex128")), ("str", _specific_msg.format("str_")), ("int", _int_extended_msg.format("int"))] __former_attrs__ = { n: _msg.format(n=n, extended_msg=extended_msg) for n, extended_msg in _type_info } # Future warning introduced in NumPy 1.24.0, 2022-11-17 _msg = ( "`np.{n}` is a deprecated alias for `{an}`. (Deprecated NumPy 1.24)") # Some of these are awkward (since `np.str` may be preferable in the long # term), but overall the names ending in 0 seem undesirable _type_info = [ ("bool8", bool_, "np.bool_"), ("int0", intp, "np.intp"), ("uint0", uintp, "np.uintp"), ("str0", str_, "np.str_"), ("bytes0", bytes_, "np.bytes_"), ("void0", void, "np.void"), ("object0", object_, "`np.object0` is a deprecated alias for `np.object_`. " "`object` can be used instead. (Deprecated NumPy 1.24)")] # Some of these could be defined right away, but most were aliases to # the Python objects and only removed in NumPy 1.24. Defining them should # probably wait for NumPy 1.26 or 2.0. # When defined, these should possibly not be added to `__all__` to avoid # import with `from numpy import `. __future_scalars__ = {"bool", "long", "ulong", "str", "bytes", "object"} __deprecated_attrs__.update({ n: (alias, _msg.format(n=n, an=an)) for n, alias, an in _type_info}) import math __deprecated_attrs__['math'] = (math, "`np.math` is a deprecated alias for the standard library `math` " "module (Deprecated Numpy 1.25). Replace usages of `np.math` with " "`math`") del math, _msg, _type_info from .core import abs # now that numpy modules are imported, can initialize limits core.getlimits._register_known_types() __all__.extend(['__version__', 'show_config']) __all__.extend(core.__all__) __all__.extend(_mat.__all__) __all__.extend(lib.__all__) __all__.extend(['linalg', 'fft', 'random', 'ctypeslib', 'ma']) # Remove one of the two occurrences of `issubdtype`, which is exposed as # both `numpy.core.issubdtype` and `numpy.lib.issubdtype`. __all__.remove('issubdtype') # These are exported by np.core, but are replaced by the builtins below # remove them to ensure that we don't end up with `np.long == np.int_`, # which would be a breaking change. del long, unicode __all__.remove('long') __all__.remove('unicode') # Remove things that are in the numpy.lib but not in the numpy namespace # Note that there is a test (numpy/tests/test_public_api.py:test_numpy_namespace) # that prevents adding more things to the main namespace by accident. # The list below will grow until the `from .lib import ` fixme above is # taken care of __all__.remove('Arrayterator') del Arrayterator # These names were removed in NumPy 1.20. For at least one release, # attempts to access these names in the numpy namespace will trigger # a warning, and calling the function will raise an exception. _financial_names = ['fv', 'ipmt', 'irr', 'mirr', 'nper', 'npv', 'pmt', 'ppmt', 'pv', 'rate'] __expired_functions__ = { name: (f'In accordance with NEP 32, the function {name} was removed ' 'from NumPy version 1.20. A replacement for this function ' 'is available in the numpy_financial library: ' 'https://pypi.org/project/numpy-financial') for name in _financial_names} # Filter out Cython harmless warnings warnings.filterwarnings("ignore", message="numpy.dtype size changed") warnings.filterwarnings("ignore", message="numpy.ufunc size changed") warnings.filterwarnings("ignore", message="numpy.ndarray size changed") # oldnumeric and numarray were removed in 1.9. In case some packages import # but do not use them, we define them here for backward compatibility. oldnumeric = 'removed' numarray = 'removed' def __getattr__(attr): # Warn for expired attributes, and return a dummy function # that always raises an exception. import warnings import math try: msg = __expired_functions__[attr] except KeyError: pass else: warnings.warn(msg, DeprecationWarning, stacklevel=2) def _expired(args, *kwds): raise RuntimeError(msg) return _expired # Emit warnings for deprecated attributes try: val, msg = __deprecated_attrs__[attr] except KeyError: pass else: warnings.warn(msg, DeprecationWarning, stacklevel=2) return val if attr in __future_scalars__: # And future warnings for those that will change, but also give # the AttributeError warnings.warn( f"In the future `np.{attr}` will be defined as the " "corresponding NumPy scalar.", FutureWarning, stacklevel=2) if attr in __former_attrs__: raise AttributeError(__former_attrs__[attr]) if attr == 'testing': import numpy.testing as testing return testing elif attr == 'Tester': "Removed in NumPy 1.25.0" raise RuntimeError("Tester was removed in NumPy 1.25.") raise AttributeError("module {!r} has no attribute " "{!r}".format(__name__, attr)) def __dir__(): public_symbols = globals().keys() \| {'testing'} public_symbols -= { "core", "matrixlib", # These were moved in 1.25 and may be deprecated eventually: "ModuleDeprecationWarning", "VisibleDeprecationWarning", "ComplexWarning", "TooHardError", "AxisError" } return list(public_symbols) # Pytest testing from numpy._pytesttester import PytestTester test = PytestTester(__name__) del PytestTester def _sanity_check(): """ Quick sanity checks for common bugs caused by environment. There are some cases e.g. with wrong BLAS ABI that cause wrong results under specific runtime conditions that are not necessarily achieved during test suite runs, and it is useful to catch those early. See https://github.com/numpy/numpy/issues/8577 and other similar bug reports. """ try: x = ones(2, dtype=float32) if not abs(x.dot(x) - float32(2.0)) < 1e-5: raise AssertionError() except AssertionError: msg = ("The current Numpy installation ({!r}) fails to " "pass simple sanity checks. This can be caused for example " "by incorrect BLAS library being linked in, or by mixing " "package managers (pip, conda, apt, ...). Search closed " "numpy issues for similar problems.") raise RuntimeError(msg.format(__file__)) from None _sanity_check() del _sanity_check def _mac_os_check(): """ Quick Sanity check for Mac OS look for accelerate build bugs. Testing numpy polyfit calls init_dgelsd(LAPACK) """ try: c = array([3., 2., 1.]) x = linspace(0, 2, 5) y = polyval(c, x) _ = polyfit(x, y, 2, cov=True) except ValueError: pass if sys.platform == "darwin": with warnings.catch_warnings(record=True) as w: _mac_os_check() # Throw runtime error, if the test failed Check for warning and error_message error_message = "" if len(w) > 0: error_message = "{}: {}".format(w[-1].category.__name__, str(w[-1].message)) msg = ( "Polyfit sanity test emitted a warning, most likely due " "to using a buggy Accelerate backend." "\nIf you compiled yourself, more information is available at:" "\nhttps://numpy.org/doc/stable/user/building.html#accelerated-blas-lapack-libraries" "\nOtherwise report this to the vendor " "that provided NumPy.\n{}\n".format(error_message)) raise RuntimeError(msg) del _mac_os_check # We usually use madvise hugepages support, but on some old kernels it # is slow and thus better avoided. # Specifically kernel version 4.6 had a bug fix which probably fixed this: # https://github.com/torvalds/linux/commit/7cf91a98e607c2f935dbcc177d70011e95b8faff import os use_hugepage = os.environ.get("NUMPY_MADVISE_HUGEPAGE", None) if sys.platform == "linux" and use_hugepage is None: # If there is an issue with parsing the kernel version, # set use_hugepages to 0. Usage of LooseVersion will handle # the kernel version parsing better, but avoided since it # will increase the import time. See: #16679 for related discussion. try: use_hugepage = 1 kernel_version = os.uname().release.split(".")[:2] kernel_version = tuple(int(v) for v in kernel_version) if kernel_version < (4, 6): use_hugepage = 0 except ValueError: use_hugepages = 0 elif use_hugepage is None: # This is not Linux, so it should not matter, just enable anyway use_hugepage = 1 else: use_hugepage = int(use_hugepage) # Note that this will currently only make a difference on Linux core.multiarray._set_madvise_hugepage(use_hugepage) del use_hugepage # Give a warning if NumPy is reloaded or imported on a sub-interpreter # We do this from python, since the C-module may not be reloaded and # it is tidier organized. core.multiarray._multiarray_umath._reload_guard() # default to "weak" promotion for "NumPy 2". core._set_promotion_state( os.environ.get("NPY_PROMOTION_STATE", "weak" if _using_numpy2_behavior() else "legacy")) # Tell PyInstaller where to find hook-numpy.py def _pyinstaller_hooks_dir(): from pathlib import Path return [str(Path(__file__).with_name("_pyinstaller").resolve())] # Remove symbols imported for internal use del os # get the version using versioneer from .version import __version__, git_revision as __git_version__ # Remove symbols imported for internal use del sys, warnings	16.1 KB	2026-01-20 12:58
📄 __init__.pyi import builtins import os import mmap import ctypes as ct import array as _array import datetime as dt import enum from abc import abstractmethod from types import TracebackType, MappingProxyType, GenericAlias from contextlib import ContextDecorator from contextlib import contextmanager from numpy._pytesttester import PytestTester from numpy.core._internal import _ctypes from numpy._typing import ( # Arrays ArrayLike, NDArray, _SupportsArray, _NestedSequence, _FiniteNestedSequence, _SupportsArray, _ArrayLikeBool_co, _ArrayLikeUInt_co, _ArrayLikeInt_co, _ArrayLikeFloat_co, _ArrayLikeComplex_co, _ArrayLikeNumber_co, _ArrayLikeTD64_co, _ArrayLikeDT64_co, _ArrayLikeObject_co, _ArrayLikeStr_co, _ArrayLikeBytes_co, _ArrayLikeUnknown, _UnknownType, # DTypes DTypeLike, _DTypeLike, _DTypeLikeVoid, _SupportsDType, _VoidDTypeLike, # Shapes _Shape, _ShapeLike, # Scalars _CharLike_co, _BoolLike_co, _IntLike_co, _FloatLike_co, _ComplexLike_co, _TD64Like_co, _NumberLike_co, _ScalarLike_co, # `number` precision NBitBase, _256Bit, _128Bit, _96Bit, _80Bit, _64Bit, _32Bit, _16Bit, _8Bit, _NBitByte, _NBitShort, _NBitIntC, _NBitIntP, _NBitInt, _NBitLongLong, _NBitHalf, _NBitSingle, _NBitDouble, _NBitLongDouble, # Character codes _BoolCodes, _UInt8Codes, _UInt16Codes, _UInt32Codes, _UInt64Codes, _Int8Codes, _Int16Codes, _Int32Codes, _Int64Codes, _Float16Codes, _Float32Codes, _Float64Codes, _Complex64Codes, _Complex128Codes, _ByteCodes, _ShortCodes, _IntCCodes, _IntPCodes, _IntCodes, _LongLongCodes, _UByteCodes, _UShortCodes, _UIntCCodes, _UIntPCodes, _UIntCodes, _ULongLongCodes, _HalfCodes, _SingleCodes, _DoubleCodes, _LongDoubleCodes, _CSingleCodes, _CDoubleCodes, _CLongDoubleCodes, _DT64Codes, _TD64Codes, _StrCodes, _BytesCodes, _VoidCodes, _ObjectCodes, # Ufuncs _UFunc_Nin1_Nout1, _UFunc_Nin2_Nout1, _UFunc_Nin1_Nout2, _UFunc_Nin2_Nout2, _GUFunc_Nin2_Nout1, ) from numpy._typing._callable import ( _BoolOp, _BoolBitOp, _BoolSub, _BoolTrueDiv, _BoolMod, _BoolDivMod, _TD64Div, _IntTrueDiv, _UnsignedIntOp, _UnsignedIntBitOp, _UnsignedIntMod, _UnsignedIntDivMod, _SignedIntOp, _SignedIntBitOp, _SignedIntMod, _SignedIntDivMod, _FloatOp, _FloatMod, _FloatDivMod, _ComplexOp, _NumberOp, _ComparisonOp, ) # NOTE: Numpy's mypy plugin is used for removing the types unavailable # to the specific platform from numpy._typing._extended_precision import ( uint128 as uint128, uint256 as uint256, int128 as int128, int256 as int256, float80 as float80, float96 as float96, float128 as float128, float256 as float256, complex160 as complex160, complex192 as complex192, complex256 as complex256, complex512 as complex512, ) from collections.abc import ( Callable, Container, Iterable, Iterator, Mapping, Sequence, Sized, ) from typing import ( Literal as L, Any, Generator, Generic, IO, NoReturn, overload, SupportsComplex, SupportsFloat, SupportsInt, TypeVar, Union, Protocol, SupportsIndex, Final, final, ClassVar, ) # Ensures that the stubs are picked up from numpy import ( ctypeslib as ctypeslib, exceptions as exceptions, fft as fft, lib as lib, linalg as linalg, ma as ma, polynomial as polynomial, random as random, testing as testing, version as version, exceptions as exceptions, dtypes as dtypes, ) from numpy.core import defchararray, records char = defchararray rec = records from numpy.core.function_base import ( linspace as linspace, logspace as logspace, geomspace as geomspace, ) from numpy.core.fromnumeric import ( take as take, reshape as reshape, choose as choose, repeat as repeat, put as put, swapaxes as swapaxes, transpose as transpose, partition as partition, argpartition as argpartition, sort as sort, argsort as argsort, argmax as argmax, argmin as argmin, searchsorted as searchsorted, resize as resize, squeeze as squeeze, diagonal as diagonal, trace as trace, ravel as ravel, nonzero as nonzero, shape as shape, compress as compress, clip as clip, sum as sum, all as all, any as any, cumsum as cumsum, ptp as ptp, max as max, min as min, amax as amax, amin as amin, prod as prod, cumprod as cumprod, ndim as ndim, size as size, around as around, round as round, mean as mean, std as std, var as var, ) from numpy.core._asarray import ( require as require, ) from numpy.core._type_aliases import ( sctypes as sctypes, sctypeDict as sctypeDict, ) from numpy.core._ufunc_config import ( seterr as seterr, geterr as geterr, setbufsize as setbufsize, getbufsize as getbufsize, seterrcall as seterrcall, geterrcall as geterrcall, _ErrKind, _ErrFunc, _ErrDictOptional, ) from numpy.core.arrayprint import ( set_printoptions as set_printoptions, get_printoptions as get_printoptions, array2string as array2string, format_float_scientific as format_float_scientific, format_float_positional as format_float_positional, array_repr as array_repr, array_str as array_str, set_string_function as set_string_function, printoptions as printoptions, ) from numpy.core.einsumfunc import ( einsum as einsum, einsum_path as einsum_path, ) from numpy.core.multiarray import ( ALLOW_THREADS as ALLOW_THREADS, BUFSIZE as BUFSIZE, CLIP as CLIP, MAXDIMS as MAXDIMS, MAY_SHARE_BOUNDS as MAY_SHARE_BOUNDS, MAY_SHARE_EXACT as MAY_SHARE_EXACT, RAISE as RAISE, WRAP as WRAP, tracemalloc_domain as tracemalloc_domain, array as array, empty_like as empty_like, empty as empty, zeros as zeros, concatenate as concatenate, inner as inner, where as where, lexsort as lexsort, can_cast as can_cast, min_scalar_type as min_scalar_type, result_type as result_type, dot as dot, vdot as vdot, bincount as bincount, copyto as copyto, putmask as putmask, packbits as packbits, unpackbits as unpackbits, shares_memory as shares_memory, may_share_memory as may_share_memory, asarray as asarray, asanyarray as asanyarray, ascontiguousarray as ascontiguousarray, asfortranarray as asfortranarray, arange as arange, busday_count as busday_count, busday_offset as busday_offset, compare_chararrays as compare_chararrays, datetime_as_string as datetime_as_string, datetime_data as datetime_data, frombuffer as frombuffer, fromfile as fromfile, fromiter as fromiter, is_busday as is_busday, promote_types as promote_types, seterrobj as seterrobj, geterrobj as geterrobj, fromstring as fromstring, frompyfunc as frompyfunc, nested_iters as nested_iters, flagsobj, ) from numpy.core.numeric import ( zeros_like as zeros_like, ones as ones, ones_like as ones_like, full as full, full_like as full_like, count_nonzero as count_nonzero, isfortran as isfortran, argwhere as argwhere, flatnonzero as flatnonzero, correlate as correlate, convolve as convolve, outer as outer, tensordot as tensordot, roll as roll, rollaxis as rollaxis, moveaxis as moveaxis, cross as cross, indices as indices, fromfunction as fromfunction, isscalar as isscalar, binary_repr as binary_repr, base_repr as base_repr, identity as identity, allclose as allclose, isclose as isclose, array_equal as array_equal, array_equiv as array_equiv, ) from numpy.core.numerictypes import ( maximum_sctype as maximum_sctype, issctype as issctype, obj2sctype as obj2sctype, issubclass_ as issubclass_, issubsctype as issubsctype, issubdtype as issubdtype, sctype2char as sctype2char, nbytes as nbytes, cast as cast, ScalarType as ScalarType, typecodes as typecodes, ) from numpy.core.shape_base import ( atleast_1d as atleast_1d, atleast_2d as atleast_2d, atleast_3d as atleast_3d, block as block, hstack as hstack, stack as stack, vstack as vstack, ) from numpy.exceptions import ( ComplexWarning as ComplexWarning, ModuleDeprecationWarning as ModuleDeprecationWarning, VisibleDeprecationWarning as VisibleDeprecationWarning, TooHardError as TooHardError, DTypePromotionError as DTypePromotionError, AxisError as AxisError, ) from numpy.lib import ( emath as emath, ) from numpy.lib.arraypad import ( pad as pad, ) from numpy.lib.arraysetops import ( ediff1d as ediff1d, intersect1d as intersect1d, setxor1d as setxor1d, union1d as union1d, setdiff1d as setdiff1d, unique as unique, in1d as in1d, isin as isin, ) from numpy.lib.arrayterator import ( Arrayterator as Arrayterator, ) from numpy.lib.function_base import ( select as select, piecewise as piecewise, trim_zeros as trim_zeros, copy as copy, iterable as iterable, percentile as percentile, diff as diff, gradient as gradient, angle as angle, unwrap as unwrap, sort_complex as sort_complex, disp as disp, flip as flip, rot90 as rot90, extract as extract, place as place, asarray_chkfinite as asarray_chkfinite, average as average, bincount as bincount, digitize as digitize, cov as cov, corrcoef as corrcoef, median as median, sinc as sinc, hamming as hamming, hanning as hanning, bartlett as bartlett, blackman as blackman, kaiser as kaiser, trapz as trapz, i0 as i0, add_newdoc as add_newdoc, add_docstring as add_docstring, meshgrid as meshgrid, delete as delete, insert as insert, append as append, interp as interp, add_newdoc_ufunc as add_newdoc_ufunc, quantile as quantile, ) from numpy.lib.histograms import ( histogram_bin_edges as histogram_bin_edges, histogram as histogram, histogramdd as histogramdd, ) from numpy.lib.index_tricks import ( ravel_multi_index as ravel_multi_index, unravel_index as unravel_index, mgrid as mgrid, ogrid as ogrid, r_ as r_, c_ as c_, s_ as s_, index_exp as index_exp, ix_ as ix_, fill_diagonal as fill_diagonal, diag_indices as diag_indices, diag_indices_from as diag_indices_from, ) from numpy.lib.nanfunctions import ( nansum as nansum, nanmax as nanmax, nanmin as nanmin, nanargmax as nanargmax, nanargmin as nanargmin, nanmean as nanmean, nanmedian as nanmedian, nanpercentile as nanpercentile, nanvar as nanvar, nanstd as nanstd, nanprod as nanprod, nancumsum as nancumsum, nancumprod as nancumprod, nanquantile as nanquantile, ) from numpy.lib.npyio import ( savetxt as savetxt, loadtxt as loadtxt, genfromtxt as genfromtxt, recfromtxt as recfromtxt, recfromcsv as recfromcsv, load as load, save as save, savez as savez, savez_compressed as savez_compressed, packbits as packbits, unpackbits as unpackbits, fromregex as fromregex, ) from numpy.lib.polynomial import ( poly as poly, roots as roots, polyint as polyint, polyder as polyder, polyadd as polyadd, polysub as polysub, polymul as polymul, polydiv as polydiv, polyval as polyval, polyfit as polyfit, ) from numpy.lib.shape_base import ( column_stack as column_stack, row_stack as row_stack, dstack as dstack, array_split as array_split, split as split, hsplit as hsplit, vsplit as vsplit, dsplit as dsplit, apply_over_axes as apply_over_axes, expand_dims as expand_dims, apply_along_axis as apply_along_axis, kron as kron, tile as tile, get_array_wrap as get_array_wrap, take_along_axis as take_along_axis, put_along_axis as put_along_axis, ) from numpy.lib.stride_tricks import ( broadcast_to as broadcast_to, broadcast_arrays as broadcast_arrays, broadcast_shapes as broadcast_shapes, ) from numpy.lib.twodim_base import ( diag as diag, diagflat as diagflat, eye as eye, fliplr as fliplr, flipud as flipud, tri as tri, triu as triu, tril as tril, vander as vander, histogram2d as histogram2d, mask_indices as mask_indices, tril_indices as tril_indices, tril_indices_from as tril_indices_from, triu_indices as triu_indices, triu_indices_from as triu_indices_from, ) from numpy.lib.type_check import ( mintypecode as mintypecode, asfarray as asfarray, real as real, imag as imag, iscomplex as iscomplex, isreal as isreal, iscomplexobj as iscomplexobj, isrealobj as isrealobj, nan_to_num as nan_to_num, real_if_close as real_if_close, typename as typename, common_type as common_type, ) from numpy.lib.ufunclike import ( fix as fix, isposinf as isposinf, isneginf as isneginf, ) from numpy.lib.utils import ( issubclass_ as issubclass_, issubsctype as issubsctype, issubdtype as issubdtype, deprecate as deprecate, deprecate_with_doc as deprecate_with_doc, get_include as get_include, info as info, source as source, who as who, lookfor as lookfor, byte_bounds as byte_bounds, safe_eval as safe_eval, show_runtime as show_runtime, ) from numpy.matrixlib import ( asmatrix as asmatrix, mat as mat, bmat as bmat, ) _AnyStr_contra = TypeVar("_AnyStr_contra", str, bytes, contravariant=True) # Protocol for representing file-like-objects accepted # by `ndarray.tofile` and `fromfile` class _IOProtocol(Protocol): def flush(self) -> object: ... def fileno(self) -> int: ... def tell(self) -> SupportsIndex: ... def seek(self, offset: int, whence: int, /) -> object: ... # NOTE: `seek`, `write` and `flush` are technically only required # for `readwrite`/`write` modes class _MemMapIOProtocol(Protocol): def flush(self) -> object: ... def fileno(self) -> SupportsIndex: ... def tell(self) -> int: ... def seek(self, offset: int, whence: int, /) -> object: ... def write(self, s: bytes, /) -> object: ... @property def read(self) -> object: ... class _SupportsWrite(Protocol[_AnyStr_contra]): def write(self, s: _AnyStr_contra, /) -> object: ... __all__: list[str] __path__: list[str] __version__: str __git_version__: str test: PytestTester # TODO: Move placeholders to their respective module once # their annotations are properly implemented # # Placeholders for classes def show_config() -> None: ... _NdArraySubClass = TypeVar("_NdArraySubClass", bound=ndarray[Any, Any]) _DTypeScalar_co = TypeVar("_DTypeScalar_co", covariant=True, bound=generic) _ByteOrder = L["S", "<", ">", "=", "\|", "L", "B", "N", "I"] @final class dtype(Generic[_DTypeScalar_co]): names: None \| tuple[builtins.str, ...] # Overload for subclass of generic @overload def __new__( cls, dtype: type[_DTypeScalar_co], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ..., ) -> dtype[_DTypeScalar_co]: ... # Overloads for string aliases, Python types, and some assorted # other special cases. Order is sometimes important because of the # subtype relationships # # bool < int < float < complex < object # # so we have to make sure the overloads for the narrowest type is # first. # Builtin types @overload def __new__(cls, dtype: type[bool], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[bool_]: ... @overload def __new__(cls, dtype: type[int], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[int_]: ... @overload def __new__(cls, dtype: None \| type[float], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[float_]: ... @overload def __new__(cls, dtype: type[complex], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[complex_]: ... @overload def __new__(cls, dtype: type[builtins.str], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[str_]: ... @overload def __new__(cls, dtype: type[bytes], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[bytes_]: ... # `unsignedinteger` string-based representations and ctypes @overload def __new__(cls, dtype: _UInt8Codes \| type[ct.c_uint8], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[uint8]: ... @overload def __new__(cls, dtype: _UInt16Codes \| type[ct.c_uint16], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[uint16]: ... @overload def __new__(cls, dtype: _UInt32Codes \| type[ct.c_uint32], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[uint32]: ... @overload def __new__(cls, dtype: _UInt64Codes \| type[ct.c_uint64], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[uint64]: ... @overload def __new__(cls, dtype: _UByteCodes \| type[ct.c_ubyte], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[ubyte]: ... @overload def __new__(cls, dtype: _UShortCodes \| type[ct.c_ushort], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[ushort]: ... @overload def __new__(cls, dtype: _UIntCCodes \| type[ct.c_uint], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[uintc]: ... # NOTE: We're assuming here that `uint_ptr_t == size_t`, # an assumption that does not hold in rare cases (same for `ssize_t`) @overload def __new__(cls, dtype: _UIntPCodes \| type[ct.c_void_p] \| type[ct.c_size_t], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[uintp]: ... @overload def __new__(cls, dtype: _UIntCodes \| type[ct.c_ulong], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[uint]: ... @overload def __new__(cls, dtype: _ULongLongCodes \| type[ct.c_ulonglong], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[ulonglong]: ... # `signedinteger` string-based representations and ctypes @overload def __new__(cls, dtype: _Int8Codes \| type[ct.c_int8], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[int8]: ... @overload def __new__(cls, dtype: _Int16Codes \| type[ct.c_int16], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[int16]: ... @overload def __new__(cls, dtype: _Int32Codes \| type[ct.c_int32], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[int32]: ... @overload def __new__(cls, dtype: _Int64Codes \| type[ct.c_int64], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[int64]: ... @overload def __new__(cls, dtype: _ByteCodes \| type[ct.c_byte], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[byte]: ... @overload def __new__(cls, dtype: _ShortCodes \| type[ct.c_short], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[short]: ... @overload def __new__(cls, dtype: _IntCCodes \| type[ct.c_int], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[intc]: ... @overload def __new__(cls, dtype: _IntPCodes \| type[ct.c_ssize_t], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[intp]: ... @overload def __new__(cls, dtype: _IntCodes \| type[ct.c_long], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[int_]: ... @overload def __new__(cls, dtype: _LongLongCodes \| type[ct.c_longlong], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[longlong]: ... # `floating` string-based representations and ctypes @overload def __new__(cls, dtype: _Float16Codes, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[float16]: ... @overload def __new__(cls, dtype: _Float32Codes, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[float32]: ... @overload def __new__(cls, dtype: _Float64Codes, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[float64]: ... @overload def __new__(cls, dtype: _HalfCodes, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[half]: ... @overload def __new__(cls, dtype: _SingleCodes \| type[ct.c_float], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[single]: ... @overload def __new__(cls, dtype: _DoubleCodes \| type[ct.c_double], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[double]: ... @overload def __new__(cls, dtype: _LongDoubleCodes \| type[ct.c_longdouble], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[longdouble]: ... # `complexfloating` string-based representations @overload def __new__(cls, dtype: _Complex64Codes, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[complex64]: ... @overload def __new__(cls, dtype: _Complex128Codes, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[complex128]: ... @overload def __new__(cls, dtype: _CSingleCodes, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[csingle]: ... @overload def __new__(cls, dtype: _CDoubleCodes, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[cdouble]: ... @overload def __new__(cls, dtype: _CLongDoubleCodes, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[clongdouble]: ... # Miscellaneous string-based representations and ctypes @overload def __new__(cls, dtype: _BoolCodes \| type[ct.c_bool], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[bool_]: ... @overload def __new__(cls, dtype: _TD64Codes, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[timedelta64]: ... @overload def __new__(cls, dtype: _DT64Codes, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[datetime64]: ... @overload def __new__(cls, dtype: _StrCodes, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[str_]: ... @overload def __new__(cls, dtype: _BytesCodes \| type[ct.c_char], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[bytes_]: ... @overload def __new__(cls, dtype: _VoidCodes, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[void]: ... @overload def __new__(cls, dtype: _ObjectCodes \| type[ct.py_object[Any]], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[object_]: ... # dtype of a dtype is the same dtype @overload def __new__( cls, dtype: dtype[_DTypeScalar_co], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ..., ) -> dtype[_DTypeScalar_co]: ... @overload def __new__( cls, dtype: _SupportsDType[dtype[_DTypeScalar_co]], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ..., ) -> dtype[_DTypeScalar_co]: ... # Handle strings that can't be expressed as literals; i.e. s1, s2, ... @overload def __new__( cls, dtype: builtins.str, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ..., ) -> dtype[Any]: ... # Catchall overload for void-likes @overload def __new__( cls, dtype: _VoidDTypeLike, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ..., ) -> dtype[void]: ... # Catchall overload for object-likes @overload def __new__( cls, dtype: type[object], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ..., ) -> dtype[object_]: ... def __class_getitem__(self, item: Any) -> GenericAlias: ... @overload def __getitem__(self: dtype[void], key: list[builtins.str]) -> dtype[void]: ... @overload def __getitem__(self: dtype[void], key: builtins.str \| SupportsIndex) -> dtype[Any]: ... # NOTE: In the future 1-based multiplications will also yield `flexible` dtypes @overload def __mul__(self: _DType, value: L[1]) -> _DType: ... @overload def __mul__(self: _FlexDType, value: SupportsIndex) -> _FlexDType: ... @overload def __mul__(self, value: SupportsIndex) -> dtype[void]: ... # NOTE: `__rmul__` seems to be broken when used in combination with # literals as of mypy 0.902. Set the return-type to `dtype[Any]` for # now for non-flexible dtypes. @overload def __rmul__(self: _FlexDType, value: SupportsIndex) -> _FlexDType: ... @overload def __rmul__(self, value: SupportsIndex) -> dtype[Any]: ... def __gt__(self, other: DTypeLike) -> bool: ... def __ge__(self, other: DTypeLike) -> bool: ... def __lt__(self, other: DTypeLike) -> bool: ... def __le__(self, other: DTypeLike) -> bool: ... # Explicitly defined `__eq__` and `__ne__` to get around mypy's # `strict_equality` option; even though their signatures are # identical to their `object`-based counterpart def __eq__(self, other: Any) -> bool: ... def __ne__(self, other: Any) -> bool: ... @property def alignment(self) -> int: ... @property def base(self) -> dtype[Any]: ... @property def byteorder(self) -> builtins.str: ... @property def char(self) -> builtins.str: ... @property def descr(self) -> list[tuple[builtins.str, builtins.str] \| tuple[builtins.str, builtins.str, _Shape]]: ... @property def fields( self, ) -> None \| MappingProxyType[builtins.str, tuple[dtype[Any], int] \| tuple[dtype[Any], int, Any]]: ... @property def flags(self) -> int: ... @property def hasobject(self) -> bool: ... @property def isbuiltin(self) -> int: ... @property def isnative(self) -> bool: ... @property def isalignedstruct(self) -> bool: ... @property def itemsize(self) -> int: ... @property def kind(self) -> builtins.str: ... @property def metadata(self) -> None \| MappingProxyType[builtins.str, Any]: ... @property def name(self) -> builtins.str: ... @property def num(self) -> int: ... @property def shape(self) -> _Shape: ... @property def ndim(self) -> int: ... @property def subdtype(self) -> None \| tuple[dtype[Any], _Shape]: ... def newbyteorder(self: _DType, __new_order: _ByteOrder = ...) -> _DType: ... @property def str(self) -> builtins.str: ... @property def type(self) -> type[_DTypeScalar_co]: ... _ArrayLikeInt = Union[ int, integer[Any], Sequence[Union[int, integer[Any]]], Sequence[Sequence[Any]], # TODO: wait for support for recursive types ndarray[Any, Any] ] _FlatIterSelf = TypeVar("_FlatIterSelf", bound=flatiter[Any]) @final class flatiter(Generic[_NdArraySubClass]): __hash__: ClassVar[None] @property def base(self) -> _NdArraySubClass: ... @property def coords(self) -> _Shape: ... @property def index(self) -> int: ... def copy(self) -> _NdArraySubClass: ... def __iter__(self: _FlatIterSelf) -> _FlatIterSelf: ... def __next__(self: flatiter[ndarray[Any, dtype[_ScalarType]]]) -> _ScalarType: ... def __len__(self) -> int: ... @overload def __getitem__( self: flatiter[ndarray[Any, dtype[_ScalarType]]], key: int \| integer[Any] \| tuple[int \| integer[Any]], ) -> _ScalarType: ... @overload def __getitem__( self, key: _ArrayLikeInt \| slice \| ellipsis \| tuple[_ArrayLikeInt \| slice \| ellipsis], ) -> _NdArraySubClass: ... # TODO: `__setitem__` operates via `unsafe` casting rules, and can # thus accept any type accepted by the relevant underlying `np.generic` # constructor. # This means that `value` must in reality be a supertype of `npt.ArrayLike`. def __setitem__( self, key: _ArrayLikeInt \| slice \| ellipsis \| tuple[_ArrayLikeInt \| slice \| ellipsis], value: Any, ) -> None: ... @overload def __array__(self: flatiter[ndarray[Any, _DType]], dtype: None = ..., /) -> ndarray[Any, _DType]: ... @overload def __array__(self, dtype: _DType, /) -> ndarray[Any, _DType]: ... _OrderKACF = L[None, "K", "A", "C", "F"] _OrderACF = L[None, "A", "C", "F"] _OrderCF = L[None, "C", "F"] _ModeKind = L["raise", "wrap", "clip"] _PartitionKind = L["introselect"] _SortKind = L["quicksort", "mergesort", "heapsort", "stable"] _SortSide = L["left", "right"] _ArraySelf = TypeVar("_ArraySelf", bound=_ArrayOrScalarCommon) class _ArrayOrScalarCommon: @property def T(self: _ArraySelf) -> _ArraySelf: ... @property def data(self) -> memoryview: ... @property def flags(self) -> flagsobj: ... @property def itemsize(self) -> int: ... @property def nbytes(self) -> int: ... def __bool__(self) -> bool: ... def __bytes__(self) -> bytes: ... def __str__(self) -> str: ... def __repr__(self) -> str: ... def __copy__(self: _ArraySelf) -> _ArraySelf: ... def __deepcopy__(self: _ArraySelf, memo: None \| dict[int, Any], /) -> _ArraySelf: ... # TODO: How to deal with the non-commutative nature of `==` and `!=`? # xref numpy/numpy#17368 def __eq__(self, other: Any) -> Any: ... def __ne__(self, other: Any) -> Any: ... def copy(self: _ArraySelf, order: _OrderKACF = ...) -> _ArraySelf: ... def dump(self, file: str \| bytes \| os.PathLike[str] \| os.PathLike[bytes] \| _SupportsWrite[bytes]) -> None: ... def dumps(self) -> bytes: ... def tobytes(self, order: _OrderKACF = ...) -> bytes: ... # NOTE: `tostring()` is deprecated and therefore excluded # def tostring(self, order=...): ... def tofile( self, fid: str \| bytes \| os.PathLike[str] \| os.PathLike[bytes] \| _IOProtocol, sep: str = ..., format: str = ..., ) -> None: ... # generics and 0d arrays return builtin scalars def tolist(self) -> Any: ... @property def __array_interface__(self) -> dict[str, Any]: ... @property def __array_priority__(self) -> float: ... @property def __array_struct__(self) -> Any: ... # builtins.PyCapsule def __setstate__(self, state: tuple[ SupportsIndex, # version _ShapeLike, # Shape _DType_co, # DType bool, # F-continuous bytes \| list[Any], # Data ], /) -> None: ... # a `bool_` is returned when `keepdims=True` and `self` is a 0d array @overload def all( self, axis: None = ..., out: None = ..., keepdims: L[False] = ..., , where: _ArrayLikeBool_co = ..., ) -> bool_: ... @overload def all( self, axis: None \| _ShapeLike = ..., out: None = ..., keepdims: bool = ..., , where: _ArrayLikeBool_co = ..., ) -> Any: ... @overload def all( self, axis: None \| _ShapeLike = ..., out: _NdArraySubClass = ..., keepdims: bool = ..., , where: _ArrayLikeBool_co = ..., ) -> _NdArraySubClass: ... @overload def any( self, axis: None = ..., out: None = ..., keepdims: L[False] = ..., , where: _ArrayLikeBool_co = ..., ) -> bool_: ... @overload def any( self, axis: None \| _ShapeLike = ..., out: None = ..., keepdims: bool = ..., , where: _ArrayLikeBool_co = ..., ) -> Any: ... @overload def any( self, axis: None \| _ShapeLike = ..., out: _NdArraySubClass = ..., keepdims: bool = ..., , where: _ArrayLikeBool_co = ..., ) -> _NdArraySubClass: ... @overload def argmax( self, axis: None = ..., out: None = ..., , keepdims: L[False] = ..., ) -> intp: ... @overload def argmax( self, axis: SupportsIndex = ..., out: None = ..., , keepdims: bool = ..., ) -> Any: ... @overload def argmax( self, axis: None \| SupportsIndex = ..., out: _NdArraySubClass = ..., , keepdims: bool = ..., ) -> _NdArraySubClass: ... @overload def argmin( self, axis: None = ..., out: None = ..., , keepdims: L[False] = ..., ) -> intp: ... @overload def argmin( self, axis: SupportsIndex = ..., out: None = ..., , keepdims: bool = ..., ) -> Any: ... @overload def argmin( self, axis: None \| SupportsIndex = ..., out: _NdArraySubClass = ..., , keepdims: bool = ..., ) -> _NdArraySubClass: ... def argsort( self, axis: None \| SupportsIndex = ..., kind: None \| _SortKind = ..., order: None \| str \| Sequence[str] = ..., ) -> ndarray[Any, Any]: ... @overload def choose( self, choices: ArrayLike, out: None = ..., mode: _ModeKind = ..., ) -> ndarray[Any, Any]: ... @overload def choose( self, choices: ArrayLike, out: _NdArraySubClass = ..., mode: _ModeKind = ..., ) -> _NdArraySubClass: ... @overload def clip( self, min: ArrayLike = ..., max: None \| ArrayLike = ..., out: None = ..., kwargs: Any, ) -> ndarray[Any, Any]: ... @overload def clip( self, min: None = ..., max: ArrayLike = ..., out: None = ..., kwargs: Any, ) -> ndarray[Any, Any]: ... @overload def clip( self, min: ArrayLike = ..., max: None \| ArrayLike = ..., out: _NdArraySubClass = ..., kwargs: Any, ) -> _NdArraySubClass: ... @overload def clip( self, min: None = ..., max: ArrayLike = ..., out: _NdArraySubClass = ..., kwargs: Any, ) -> _NdArraySubClass: ... @overload def compress( self, a: ArrayLike, axis: None \| SupportsIndex = ..., out: None = ..., ) -> ndarray[Any, Any]: ... @overload def compress( self, a: ArrayLike, axis: None \| SupportsIndex = ..., out: _NdArraySubClass = ..., ) -> _NdArraySubClass: ... def conj(self: _ArraySelf) -> _ArraySelf: ... def conjugate(self: _ArraySelf) -> _ArraySelf: ... @overload def cumprod( self, axis: None \| SupportsIndex = ..., dtype: DTypeLike = ..., out: None = ..., ) -> ndarray[Any, Any]: ... @overload def cumprod( self, axis: None \| SupportsIndex = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., ) -> _NdArraySubClass: ... @overload def cumsum( self, axis: None \| SupportsIndex = ..., dtype: DTypeLike = ..., out: None = ..., ) -> ndarray[Any, Any]: ... @overload def cumsum( self, axis: None \| SupportsIndex = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., ) -> _NdArraySubClass: ... @overload def max( self, axis: None \| _ShapeLike = ..., out: None = ..., keepdims: bool = ..., initial: _NumberLike_co = ..., where: _ArrayLikeBool_co = ..., ) -> Any: ... @overload def max( self, axis: None \| _ShapeLike = ..., out: _NdArraySubClass = ..., keepdims: bool = ..., initial: _NumberLike_co = ..., where: _ArrayLikeBool_co = ..., ) -> _NdArraySubClass: ... @overload def mean( self, axis: None \| _ShapeLike = ..., dtype: DTypeLike = ..., out: None = ..., keepdims: bool = ..., , where: _ArrayLikeBool_co = ..., ) -> Any: ... @overload def mean( self, axis: None \| _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., keepdims: bool = ..., , where: _ArrayLikeBool_co = ..., ) -> _NdArraySubClass: ... @overload def min( self, axis: None \| _ShapeLike = ..., out: None = ..., keepdims: bool = ..., initial: _NumberLike_co = ..., where: _ArrayLikeBool_co = ..., ) -> Any: ... @overload def min( self, axis: None \| _ShapeLike = ..., out: _NdArraySubClass = ..., keepdims: bool = ..., initial: _NumberLike_co = ..., where: _ArrayLikeBool_co = ..., ) -> _NdArraySubClass: ... def newbyteorder( self: _ArraySelf, __new_order: _ByteOrder = ..., ) -> _ArraySelf: ... @overload def prod( self, axis: None \| _ShapeLike = ..., dtype: DTypeLike = ..., out: None = ..., keepdims: bool = ..., initial: _NumberLike_co = ..., where: _ArrayLikeBool_co = ..., ) -> Any: ... @overload def prod( self, axis: None \| _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., keepdims: bool = ..., initial: _NumberLike_co = ..., where: _ArrayLikeBool_co = ..., ) -> _NdArraySubClass: ... @overload def ptp( self, axis: None \| _ShapeLike = ..., out: None = ..., keepdims: bool = ..., ) -> Any: ... @overload def ptp( self, axis: None \| _ShapeLike = ..., out: _NdArraySubClass = ..., keepdims: bool = ..., ) -> _NdArraySubClass: ... @overload def round( self: _ArraySelf, decimals: SupportsIndex = ..., out: None = ..., ) -> _ArraySelf: ... @overload def round( self, decimals: SupportsIndex = ..., out: _NdArraySubClass = ..., ) -> _NdArraySubClass: ... @overload def std( self, axis: None \| _ShapeLike = ..., dtype: DTypeLike = ..., out: None = ..., ddof: float = ..., keepdims: bool = ..., , where: _ArrayLikeBool_co = ..., ) -> Any: ... @overload def std( self, axis: None \| _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., ddof: float = ..., keepdims: bool = ..., , where: _ArrayLikeBool_co = ..., ) -> _NdArraySubClass: ... @overload def sum( self, axis: None \| _ShapeLike = ..., dtype: DTypeLike = ..., out: None = ..., keepdims: bool = ..., initial: _NumberLike_co = ..., where: _ArrayLikeBool_co = ..., ) -> Any: ... @overload def sum( self, axis: None \| _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., keepdims: bool = ..., initial: _NumberLike_co = ..., where: _ArrayLikeBool_co = ..., ) -> _NdArraySubClass: ... @overload def var( self, axis: None \| _ShapeLike = ..., dtype: DTypeLike = ..., out: None = ..., ddof: float = ..., keepdims: bool = ..., , where: _ArrayLikeBool_co = ..., ) -> Any: ... @overload def var( self, axis: None \| _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., ddof: float = ..., keepdims: bool = ..., , where: _ArrayLikeBool_co = ..., ) -> _NdArraySubClass: ... _DType = TypeVar("_DType", bound=dtype[Any]) _DType_co = TypeVar("_DType_co", covariant=True, bound=dtype[Any]) _FlexDType = TypeVar("_FlexDType", bound=dtype[flexible]) # TODO: Set the `bound` to something more suitable once we # have proper shape support _ShapeType = TypeVar("_ShapeType", bound=Any) _ShapeType2 = TypeVar("_ShapeType2", bound=Any) _NumberType = TypeVar("_NumberType", bound=number[Any]) # There is currently no exhaustive way to type the buffer protocol, # as it is implemented exclusively in the C API (python/typing#593) _SupportsBuffer = Union[ bytes, bytearray, memoryview, _array.array[Any], mmap.mmap, NDArray[Any], generic, ] _T = TypeVar("_T") _T_co = TypeVar("_T_co", covariant=True) _T_contra = TypeVar("_T_contra", contravariant=True) _2Tuple = tuple[_T, _T] _CastingKind = L["no", "equiv", "safe", "same_kind", "unsafe"] _ArrayUInt_co = NDArray[Union[bool_, unsignedinteger[Any]]] _ArrayInt_co = NDArray[Union[bool_, integer[Any]]] _ArrayFloat_co = NDArray[Union[bool_, integer[Any], floating[Any]]] _ArrayComplex_co = NDArray[Union[bool_, integer[Any], floating[Any], complexfloating[Any, Any]]] _ArrayNumber_co = NDArray[Union[bool_, number[Any]]] _ArrayTD64_co = NDArray[Union[bool_, integer[Any], timedelta64]] # Introduce an alias for `dtype` to avoid naming conflicts. _dtype = dtype # `builtins.PyCapsule` unfortunately lacks annotations as of the moment; # use `Any` as a stopgap measure _PyCapsule = Any class _SupportsItem(Protocol[_T_co]): def item(self, args: Any, /) -> _T_co: ... class _SupportsReal(Protocol[_T_co]): @property def real(self) -> _T_co: ... class _SupportsImag(Protocol[_T_co]): @property def imag(self) -> _T_co: ... class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): __hash__: ClassVar[None] @property def base(self) -> None \| ndarray[Any, Any]: ... @property def ndim(self) -> int: ... @property def size(self) -> int: ... @property def real( self: ndarray[_ShapeType, dtype[_SupportsReal[_ScalarType]]], # type: ignore[type-var] ) -> ndarray[_ShapeType, _dtype[_ScalarType]]: ... @real.setter def real(self, value: ArrayLike) -> None: ... @property def imag( self: ndarray[_ShapeType, dtype[_SupportsImag[_ScalarType]]], # type: ignore[type-var] ) -> ndarray[_ShapeType, _dtype[_ScalarType]]: ... @imag.setter def imag(self, value: ArrayLike) -> None: ... def __new__( cls: type[_ArraySelf], shape: _ShapeLike, dtype: DTypeLike = ..., buffer: None \| _SupportsBuffer = ..., offset: SupportsIndex = ..., strides: None \| _ShapeLike = ..., order: _OrderKACF = ..., ) -> _ArraySelf: ... def __class_getitem__(self, item: Any) -> GenericAlias: ... @overload def __array__(self, dtype: None = ..., /) -> ndarray[Any, _DType_co]: ... @overload def __array__(self, dtype: _DType, /) -> ndarray[Any, _DType]: ... def __array_ufunc__( self, ufunc: ufunc, method: L["__call__", "reduce", "reduceat", "accumulate", "outer", "inner"], inputs: Any, kwargs: Any, ) -> Any: ... def __array_function__( self, func: Callable[..., Any], types: Iterable[type], args: Iterable[Any], kwargs: Mapping[str, Any], ) -> Any: ... # NOTE: In practice any object is accepted by `obj`, but as `__array_finalize__` # is a pseudo-abstract method the type has been narrowed down in order to # grant subclasses a bit more flexibility def __array_finalize__(self, obj: None \| NDArray[Any], /) -> None: ... def __array_wrap__( self, array: ndarray[_ShapeType2, _DType], context: None \| tuple[ufunc, tuple[Any, ...], int] = ..., /, ) -> ndarray[_ShapeType2, _DType]: ... def __array_prepare__( self, array: ndarray[_ShapeType2, _DType], context: None \| tuple[ufunc, tuple[Any, ...], int] = ..., /, ) -> ndarray[_ShapeType2, _DType]: ... @overload def __getitem__(self, key: ( NDArray[integer[Any]] \| NDArray[bool_] \| tuple[NDArray[integer[Any]] \| NDArray[bool_], ...] )) -> ndarray[Any, _DType_co]: ... @overload def __getitem__(self, key: SupportsIndex \| tuple[SupportsIndex, ...]) -> Any: ... @overload def __getitem__(self, key: ( None \| slice \| ellipsis \| SupportsIndex \| _ArrayLikeInt_co \| tuple[None \| slice \| ellipsis \| _ArrayLikeInt_co \| SupportsIndex, ...] )) -> ndarray[Any, _DType_co]: ... @overload def __getitem__(self: NDArray[void], key: str) -> NDArray[Any]: ... @overload def __getitem__(self: NDArray[void], key: list[str]) -> ndarray[_ShapeType, _dtype[void]]: ... @property def ctypes(self) -> _ctypes[int]: ... @property def shape(self) -> _Shape: ... @shape.setter def shape(self, value: _ShapeLike) -> None: ... @property def strides(self) -> _Shape: ... @strides.setter def strides(self, value: _ShapeLike) -> None: ... def byteswap(self: _ArraySelf, inplace: bool = ...) -> _ArraySelf: ... def fill(self, value: Any) -> None: ... @property def flat(self: _NdArraySubClass) -> flatiter[_NdArraySubClass]: ... # Use the same output type as that of the underlying `generic` @overload def item( self: ndarray[Any, _dtype[_SupportsItem[_T]]], # type: ignore[type-var] args: SupportsIndex, ) -> _T: ... @overload def item( self: ndarray[Any, _dtype[_SupportsItem[_T]]], # type: ignore[type-var] args: tuple[SupportsIndex, ...], /, ) -> _T: ... @overload def itemset(self, value: Any, /) -> None: ... @overload def itemset(self, item: _ShapeLike, value: Any, /) -> None: ... @overload def resize(self, new_shape: _ShapeLike, /, , refcheck: bool = ...) -> None: ... @overload def resize(self, new_shape: SupportsIndex, refcheck: bool = ...) -> None: ... def setflags( self, write: bool = ..., align: bool = ..., uic: bool = ... ) -> None: ... def squeeze( self, axis: None \| SupportsIndex \| tuple[SupportsIndex, ...] = ..., ) -> ndarray[Any, _DType_co]: ... def swapaxes( self, axis1: SupportsIndex, axis2: SupportsIndex, ) -> ndarray[Any, _DType_co]: ... @overload def transpose(self: _ArraySelf, axes: None \| _ShapeLike, /) -> _ArraySelf: ... @overload def transpose(self: _ArraySelf, axes: SupportsIndex) -> _ArraySelf: ... def argpartition( self, kth: _ArrayLikeInt_co, axis: None \| SupportsIndex = ..., kind: _PartitionKind = ..., order: None \| str \| Sequence[str] = ..., ) -> ndarray[Any, _dtype[intp]]: ... def diagonal( self, offset: SupportsIndex = ..., axis1: SupportsIndex = ..., axis2: SupportsIndex = ..., ) -> ndarray[Any, _DType_co]: ... # 1D + 1D returns a scalar; # all other with at least 1 non-0D array return an ndarray. @overload def dot(self, b: _ScalarLike_co, out: None = ...) -> ndarray[Any, Any]: ... @overload def dot(self, b: ArrayLike, out: None = ...) -> Any: ... # type: ignore[misc] @overload def dot(self, b: ArrayLike, out: _NdArraySubClass) -> _NdArraySubClass: ... # `nonzero()` is deprecated for 0d arrays/generics def nonzero(self) -> tuple[ndarray[Any, _dtype[intp]], ...]: ... def partition( self, kth: _ArrayLikeInt_co, axis: SupportsIndex = ..., kind: _PartitionKind = ..., order: None \| str \| Sequence[str] = ..., ) -> None: ... # `put` is technically available to `generic`, # but is pointless as `generic`s are immutable def put( self, ind: _ArrayLikeInt_co, v: ArrayLike, mode: _ModeKind = ..., ) -> None: ... @overload def searchsorted( # type: ignore[misc] self, # >= 1D array v: _ScalarLike_co, # 0D array-like side: _SortSide = ..., sorter: None \| _ArrayLikeInt_co = ..., ) -> intp: ... @overload def searchsorted( self, # >= 1D array v: ArrayLike, side: _SortSide = ..., sorter: None \| _ArrayLikeInt_co = ..., ) -> ndarray[Any, _dtype[intp]]: ... def setfield( self, val: ArrayLike, dtype: DTypeLike, offset: SupportsIndex = ..., ) -> None: ... def sort( self, axis: SupportsIndex = ..., kind: None \| _SortKind = ..., order: None \| str \| Sequence[str] = ..., ) -> None: ... @overload def trace( self, # >= 2D array offset: SupportsIndex = ..., axis1: SupportsIndex = ..., axis2: SupportsIndex = ..., dtype: DTypeLike = ..., out: None = ..., ) -> Any: ... @overload def trace( self, # >= 2D array offset: SupportsIndex = ..., axis1: SupportsIndex = ..., axis2: SupportsIndex = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., ) -> _NdArraySubClass: ... @overload def take( # type: ignore[misc] self: ndarray[Any, _dtype[_ScalarType]], indices: _IntLike_co, axis: None \| SupportsIndex = ..., out: None = ..., mode: _ModeKind = ..., ) -> _ScalarType: ... @overload def take( # type: ignore[misc] self, indices: _ArrayLikeInt_co, axis: None \| SupportsIndex = ..., out: None = ..., mode: _ModeKind = ..., ) -> ndarray[Any, _DType_co]: ... @overload def take( self, indices: _ArrayLikeInt_co, axis: None \| SupportsIndex = ..., out: _NdArraySubClass = ..., mode: _ModeKind = ..., ) -> _NdArraySubClass: ... def repeat( self, repeats: _ArrayLikeInt_co, axis: None \| SupportsIndex = ..., ) -> ndarray[Any, _DType_co]: ... def flatten( self, order: _OrderKACF = ..., ) -> ndarray[Any, _DType_co]: ... def ravel( self, order: _OrderKACF = ..., ) -> ndarray[Any, _DType_co]: ... @overload def reshape( self, shape: _ShapeLike, /, , order: _OrderACF = ... ) -> ndarray[Any, _DType_co]: ... @overload def reshape( self, shape: SupportsIndex, order: _OrderACF = ... ) -> ndarray[Any, _DType_co]: ... @overload def astype( self, dtype: _DTypeLike[_ScalarType], order: _OrderKACF = ..., casting: _CastingKind = ..., subok: bool = ..., copy: bool \| _CopyMode = ..., ) -> NDArray[_ScalarType]: ... @overload def astype( self, dtype: DTypeLike, order: _OrderKACF = ..., casting: _CastingKind = ..., subok: bool = ..., copy: bool \| _CopyMode = ..., ) -> NDArray[Any]: ... @overload def view(self: _ArraySelf) -> _ArraySelf: ... @overload def view(self, type: type[_NdArraySubClass]) -> _NdArraySubClass: ... @overload def view(self, dtype: _DTypeLike[_ScalarType]) -> NDArray[_ScalarType]: ... @overload def view(self, dtype: DTypeLike) -> NDArray[Any]: ... @overload def view( self, dtype: DTypeLike, type: type[_NdArraySubClass], ) -> _NdArraySubClass: ... @overload def getfield( self, dtype: _DTypeLike[_ScalarType], offset: SupportsIndex = ... ) -> NDArray[_ScalarType]: ... @overload def getfield( self, dtype: DTypeLike, offset: SupportsIndex = ... ) -> NDArray[Any]: ... # Dispatch to the underlying `generic` via protocols def __int__( self: ndarray[Any, _dtype[SupportsInt]], # type: ignore[type-var] ) -> int: ... def __float__( self: ndarray[Any, _dtype[SupportsFloat]], # type: ignore[type-var] ) -> float: ... def __complex__( self: ndarray[Any, _dtype[SupportsComplex]], # type: ignore[type-var] ) -> complex: ... def __index__( self: ndarray[Any, _dtype[SupportsIndex]], # type: ignore[type-var] ) -> int: ... def __len__(self) -> int: ... def __setitem__(self, key, value): ... def __iter__(self) -> Any: ... def __contains__(self, key) -> bool: ... # The last overload is for catching recursive objects whose # nesting is too deep. # The first overload is for catching `bytes` (as they are a subtype of # `Sequence[int]`) and `str`. As `str` is a recursive sequence of # strings, it will pass through the final overload otherwise @overload def __lt__(self: _ArrayNumber_co, other: _ArrayLikeNumber_co) -> NDArray[bool_]: ... @overload def __lt__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co) -> NDArray[bool_]: ... @overload def __lt__(self: NDArray[datetime64], other: _ArrayLikeDT64_co) -> NDArray[bool_]: ... @overload def __lt__(self: NDArray[object_], other: Any) -> NDArray[bool_]: ... @overload def __lt__(self: NDArray[Any], other: _ArrayLikeObject_co) -> NDArray[bool_]: ... @overload def __le__(self: _ArrayNumber_co, other: _ArrayLikeNumber_co) -> NDArray[bool_]: ... @overload def __le__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co) -> NDArray[bool_]: ... @overload def __le__(self: NDArray[datetime64], other: _ArrayLikeDT64_co) -> NDArray[bool_]: ... @overload def __le__(self: NDArray[object_], other: Any) -> NDArray[bool_]: ... @overload def __le__(self: NDArray[Any], other: _ArrayLikeObject_co) -> NDArray[bool_]: ... @overload def __gt__(self: _ArrayNumber_co, other: _ArrayLikeNumber_co) -> NDArray[bool_]: ... @overload def __gt__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co) -> NDArray[bool_]: ... @overload def __gt__(self: NDArray[datetime64], other: _ArrayLikeDT64_co) -> NDArray[bool_]: ... @overload def __gt__(self: NDArray[object_], other: Any) -> NDArray[bool_]: ... @overload def __gt__(self: NDArray[Any], other: _ArrayLikeObject_co) -> NDArray[bool_]: ... @overload def __ge__(self: _ArrayNumber_co, other: _ArrayLikeNumber_co) -> NDArray[bool_]: ... @overload def __ge__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co) -> NDArray[bool_]: ... @overload def __ge__(self: NDArray[datetime64], other: _ArrayLikeDT64_co) -> NDArray[bool_]: ... @overload def __ge__(self: NDArray[object_], other: Any) -> NDArray[bool_]: ... @overload def __ge__(self: NDArray[Any], other: _ArrayLikeObject_co) -> NDArray[bool_]: ... # Unary ops @overload def __abs__(self: NDArray[bool_]) -> NDArray[bool_]: ... @overload def __abs__(self: NDArray[complexfloating[_NBit1, _NBit1]]) -> NDArray[floating[_NBit1]]: ... @overload def __abs__(self: NDArray[_NumberType]) -> NDArray[_NumberType]: ... @overload def __abs__(self: NDArray[timedelta64]) -> NDArray[timedelta64]: ... @overload def __abs__(self: NDArray[object_]) -> Any: ... @overload def __invert__(self: NDArray[bool_]) -> NDArray[bool_]: ... @overload def __invert__(self: NDArray[_IntType]) -> NDArray[_IntType]: ... @overload def __invert__(self: NDArray[object_]) -> Any: ... @overload def __pos__(self: NDArray[_NumberType]) -> NDArray[_NumberType]: ... @overload def __pos__(self: NDArray[timedelta64]) -> NDArray[timedelta64]: ... @overload def __pos__(self: NDArray[object_]) -> Any: ... @overload def __neg__(self: NDArray[_NumberType]) -> NDArray[_NumberType]: ... @overload def __neg__(self: NDArray[timedelta64]) -> NDArray[timedelta64]: ... @overload def __neg__(self: NDArray[object_]) -> Any: ... # Binary ops @overload def __matmul__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... # type: ignore[misc] @overload def __matmul__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __matmul__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __matmul__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __matmul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... @overload def __matmul__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... @overload def __matmul__(self: NDArray[object_], other: Any) -> Any: ... @overload def __matmul__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @overload def __rmatmul__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... # type: ignore[misc] @overload def __rmatmul__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __rmatmul__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __rmatmul__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __rmatmul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... @overload def __rmatmul__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... @overload def __rmatmul__(self: NDArray[object_], other: Any) -> Any: ... @overload def __rmatmul__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @overload def __mod__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[int8]: ... # type: ignore[misc] @overload def __mod__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __mod__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __mod__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __mod__(self: _ArrayTD64_co, other: _SupportsArray[_dtype[timedelta64]] \| _NestedSequence[_SupportsArray[_dtype[timedelta64]]]) -> NDArray[timedelta64]: ... @overload def __mod__(self: NDArray[object_], other: Any) -> Any: ... @overload def __mod__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @overload def __rmod__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[int8]: ... # type: ignore[misc] @overload def __rmod__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __rmod__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __rmod__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __rmod__(self: _ArrayTD64_co, other: _SupportsArray[_dtype[timedelta64]] \| _NestedSequence[_SupportsArray[_dtype[timedelta64]]]) -> NDArray[timedelta64]: ... @overload def __rmod__(self: NDArray[object_], other: Any) -> Any: ... @overload def __rmod__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @overload def __divmod__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> _2Tuple[NDArray[int8]]: ... # type: ignore[misc] @overload def __divmod__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> _2Tuple[NDArray[unsignedinteger[Any]]]: ... # type: ignore[misc] @overload def __divmod__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> _2Tuple[NDArray[signedinteger[Any]]]: ... # type: ignore[misc] @overload def __divmod__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> _2Tuple[NDArray[floating[Any]]]: ... # type: ignore[misc] @overload def __divmod__(self: _ArrayTD64_co, other: _SupportsArray[_dtype[timedelta64]] \| _NestedSequence[_SupportsArray[_dtype[timedelta64]]]) -> tuple[NDArray[int64], NDArray[timedelta64]]: ... @overload def __rdivmod__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> _2Tuple[NDArray[int8]]: ... # type: ignore[misc] @overload def __rdivmod__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> _2Tuple[NDArray[unsignedinteger[Any]]]: ... # type: ignore[misc] @overload def __rdivmod__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> _2Tuple[NDArray[signedinteger[Any]]]: ... # type: ignore[misc] @overload def __rdivmod__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> _2Tuple[NDArray[floating[Any]]]: ... # type: ignore[misc] @overload def __rdivmod__(self: _ArrayTD64_co, other: _SupportsArray[_dtype[timedelta64]] \| _NestedSequence[_SupportsArray[_dtype[timedelta64]]]) -> tuple[NDArray[int64], NDArray[timedelta64]]: ... @overload def __add__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... # type: ignore[misc] @overload def __add__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __add__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __add__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __add__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] @overload def __add__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... @overload def __add__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co) -> NDArray[timedelta64]: ... # type: ignore[misc] @overload def __add__(self: _ArrayTD64_co, other: _ArrayLikeDT64_co) -> NDArray[datetime64]: ... @overload def __add__(self: NDArray[datetime64], other: _ArrayLikeTD64_co) -> NDArray[datetime64]: ... @overload def __add__(self: NDArray[object_], other: Any) -> Any: ... @overload def __add__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @overload def __radd__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... # type: ignore[misc] @overload def __radd__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __radd__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __radd__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __radd__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] @overload def __radd__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... @overload def __radd__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co) -> NDArray[timedelta64]: ... # type: ignore[misc] @overload def __radd__(self: _ArrayTD64_co, other: _ArrayLikeDT64_co) -> NDArray[datetime64]: ... @overload def __radd__(self: NDArray[datetime64], other: _ArrayLikeTD64_co) -> NDArray[datetime64]: ... @overload def __radd__(self: NDArray[object_], other: Any) -> Any: ... @overload def __radd__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @overload def __sub__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown) -> NDArray[Any]: ... @overload def __sub__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NoReturn: ... @overload def __sub__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __sub__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __sub__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __sub__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] @overload def __sub__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... @overload def __sub__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co) -> NDArray[timedelta64]: ... # type: ignore[misc] @overload def __sub__(self: NDArray[datetime64], other: _ArrayLikeTD64_co) -> NDArray[datetime64]: ... @overload def __sub__(self: NDArray[datetime64], other: _ArrayLikeDT64_co) -> NDArray[timedelta64]: ... @overload def __sub__(self: NDArray[object_], other: Any) -> Any: ... @overload def __sub__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @overload def __rsub__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown) -> NDArray[Any]: ... @overload def __rsub__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NoReturn: ... @overload def __rsub__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __rsub__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __rsub__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __rsub__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] @overload def __rsub__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... @overload def __rsub__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co) -> NDArray[timedelta64]: ... # type: ignore[misc] @overload def __rsub__(self: _ArrayTD64_co, other: _ArrayLikeDT64_co) -> NDArray[datetime64]: ... # type: ignore[misc] @overload def __rsub__(self: NDArray[datetime64], other: _ArrayLikeDT64_co) -> NDArray[timedelta64]: ... @overload def __rsub__(self: NDArray[object_], other: Any) -> Any: ... @overload def __rsub__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @overload def __mul__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... # type: ignore[misc] @overload def __mul__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __mul__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __mul__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __mul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] @overload def __mul__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... @overload def __mul__(self: _ArrayTD64_co, other: _ArrayLikeFloat_co) -> NDArray[timedelta64]: ... @overload def __mul__(self: _ArrayFloat_co, other: _ArrayLikeTD64_co) -> NDArray[timedelta64]: ... @overload def __mul__(self: NDArray[object_], other: Any) -> Any: ... @overload def __mul__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @overload def __rmul__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... # type: ignore[misc] @overload def __rmul__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __rmul__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __rmul__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __rmul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] @overload def __rmul__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... @overload def __rmul__(self: _ArrayTD64_co, other: _ArrayLikeFloat_co) -> NDArray[timedelta64]: ... @overload def __rmul__(self: _ArrayFloat_co, other: _ArrayLikeTD64_co) -> NDArray[timedelta64]: ... @overload def __rmul__(self: NDArray[object_], other: Any) -> Any: ... @overload def __rmul__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @overload def __floordiv__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[int8]: ... # type: ignore[misc] @overload def __floordiv__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __floordiv__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __floordiv__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __floordiv__(self: NDArray[timedelta64], other: _SupportsArray[_dtype[timedelta64]] \| _NestedSequence[_SupportsArray[_dtype[timedelta64]]]) -> NDArray[int64]: ... @overload def __floordiv__(self: NDArray[timedelta64], other: _ArrayLikeBool_co) -> NoReturn: ... @overload def __floordiv__(self: NDArray[timedelta64], other: _ArrayLikeFloat_co) -> NDArray[timedelta64]: ... @overload def __floordiv__(self: NDArray[object_], other: Any) -> Any: ... @overload def __floordiv__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @overload def __rfloordiv__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[int8]: ... # type: ignore[misc] @overload def __rfloordiv__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __rfloordiv__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __rfloordiv__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __rfloordiv__(self: NDArray[timedelta64], other: _SupportsArray[_dtype[timedelta64]] \| _NestedSequence[_SupportsArray[_dtype[timedelta64]]]) -> NDArray[int64]: ... @overload def __rfloordiv__(self: NDArray[bool_], other: _ArrayLikeTD64_co) -> NoReturn: ... @overload def __rfloordiv__(self: _ArrayFloat_co, other: _ArrayLikeTD64_co) -> NDArray[timedelta64]: ... @overload def __rfloordiv__(self: NDArray[object_], other: Any) -> Any: ... @overload def __rfloordiv__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @overload def __pow__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[int8]: ... # type: ignore[misc] @overload def __pow__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __pow__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __pow__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __pow__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... @overload def __pow__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... @overload def __pow__(self: NDArray[object_], other: Any) -> Any: ... @overload def __pow__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @overload def __rpow__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[int8]: ... # type: ignore[misc] @overload def __rpow__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __rpow__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __rpow__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __rpow__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... @overload def __rpow__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... @overload def __rpow__(self: NDArray[object_], other: Any) -> Any: ... @overload def __rpow__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @overload def __truediv__(self: _ArrayInt_co, other: _ArrayInt_co) -> NDArray[float64]: ... # type: ignore[misc] @overload def __truediv__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __truediv__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] @overload def __truediv__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... @overload def __truediv__(self: NDArray[timedelta64], other: _SupportsArray[_dtype[timedelta64]] \| _NestedSequence[_SupportsArray[_dtype[timedelta64]]]) -> NDArray[float64]: ... @overload def __truediv__(self: NDArray[timedelta64], other: _ArrayLikeBool_co) -> NoReturn: ... @overload def __truediv__(self: NDArray[timedelta64], other: _ArrayLikeFloat_co) -> NDArray[timedelta64]: ... @overload def __truediv__(self: NDArray[object_], other: Any) -> Any: ... @overload def __truediv__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @overload def __rtruediv__(self: _ArrayInt_co, other: _ArrayInt_co) -> NDArray[float64]: ... # type: ignore[misc] @overload def __rtruediv__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __rtruediv__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] @overload def __rtruediv__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... @overload def __rtruediv__(self: NDArray[timedelta64], other: _SupportsArray[_dtype[timedelta64]] \| _NestedSequence[_SupportsArray[_dtype[timedelta64]]]) -> NDArray[float64]: ... @overload def __rtruediv__(self: NDArray[bool_], other: _ArrayLikeTD64_co) -> NoReturn: ... @overload def __rtruediv__(self: _ArrayFloat_co, other: _ArrayLikeTD64_co) -> NDArray[timedelta64]: ... @overload def __rtruediv__(self: NDArray[object_], other: Any) -> Any: ... @overload def __rtruediv__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @overload def __lshift__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[int8]: ... # type: ignore[misc] @overload def __lshift__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __lshift__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... @overload def __lshift__(self: NDArray[object_], other: Any) -> Any: ... @overload def __lshift__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @overload def __rlshift__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[int8]: ... # type: ignore[misc] @overload def __rlshift__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __rlshift__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... @overload def __rlshift__(self: NDArray[object_], other: Any) -> Any: ... @overload def __rlshift__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @overload def __rshift__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[int8]: ... # type: ignore[misc] @overload def __rshift__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __rshift__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... @overload def __rshift__(self: NDArray[object_], other: Any) -> Any: ... @overload def __rshift__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @overload def __rrshift__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[int8]: ... # type: ignore[misc] @overload def __rrshift__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __rrshift__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... @overload def __rrshift__(self: NDArray[object_], other: Any) -> Any: ... @overload def __rrshift__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @overload def __and__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... # type: ignore[misc] @overload def __and__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __and__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... @overload def __and__(self: NDArray[object_], other: Any) -> Any: ... @overload def __and__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @overload def __rand__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... # type: ignore[misc] @overload def __rand__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __rand__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... @overload def __rand__(self: NDArray[object_], other: Any) -> Any: ... @overload def __rand__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @overload def __xor__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... # type: ignore[misc] @overload def __xor__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __xor__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... @overload def __xor__(self: NDArray[object_], other: Any) -> Any: ... @overload def __xor__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @overload def __rxor__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... # type: ignore[misc] @overload def __rxor__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __rxor__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... @overload def __rxor__(self: NDArray[object_], other: Any) -> Any: ... @overload def __rxor__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @overload def __or__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... # type: ignore[misc] @overload def __or__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __or__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... @overload def __or__(self: NDArray[object_], other: Any) -> Any: ... @overload def __or__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... @overload def __ror__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... # type: ignore[misc] @overload def __ror__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __ror__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... @overload def __ror__(self: NDArray[object_], other: Any) -> Any: ... @overload def __ror__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... # `np.generic` does not support inplace operations # NOTE: Inplace ops generally use "same_kind" casting w.r.t. to the left # operand. An exception to this rule are unsigned integers though, which # also accepts a signed integer for the right operand as long it is a 0D # object and its value is >= 0 @overload def __iadd__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... @overload def __iadd__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co \| _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __iadd__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... @overload def __iadd__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co) -> NDArray[floating[_NBit1]]: ... @overload def __iadd__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... @overload def __iadd__(self: NDArray[timedelta64], other: _ArrayLikeTD64_co) -> NDArray[timedelta64]: ... @overload def __iadd__(self: NDArray[datetime64], other: _ArrayLikeTD64_co) -> NDArray[datetime64]: ... @overload def __iadd__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... @overload def __isub__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co \| _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __isub__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... @overload def __isub__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co) -> NDArray[floating[_NBit1]]: ... @overload def __isub__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... @overload def __isub__(self: NDArray[timedelta64], other: _ArrayLikeTD64_co) -> NDArray[timedelta64]: ... @overload def __isub__(self: NDArray[datetime64], other: _ArrayLikeTD64_co) -> NDArray[datetime64]: ... @overload def __isub__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... @overload def __imul__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... @overload def __imul__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co \| _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __imul__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... @overload def __imul__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co) -> NDArray[floating[_NBit1]]: ... @overload def __imul__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... @overload def __imul__(self: NDArray[timedelta64], other: _ArrayLikeFloat_co) -> NDArray[timedelta64]: ... @overload def __imul__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... @overload def __itruediv__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co) -> NDArray[floating[_NBit1]]: ... @overload def __itruediv__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... @overload def __itruediv__(self: NDArray[timedelta64], other: _ArrayLikeBool_co) -> NoReturn: ... @overload def __itruediv__(self: NDArray[timedelta64], other: _ArrayLikeInt_co) -> NDArray[timedelta64]: ... @overload def __itruediv__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... @overload def __ifloordiv__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co \| _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __ifloordiv__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... @overload def __ifloordiv__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co) -> NDArray[floating[_NBit1]]: ... @overload def __ifloordiv__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... @overload def __ifloordiv__(self: NDArray[timedelta64], other: _ArrayLikeBool_co) -> NoReturn: ... @overload def __ifloordiv__(self: NDArray[timedelta64], other: _ArrayLikeInt_co) -> NDArray[timedelta64]: ... @overload def __ifloordiv__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... @overload def __ipow__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co \| _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __ipow__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... @overload def __ipow__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co) -> NDArray[floating[_NBit1]]: ... @overload def __ipow__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... @overload def __ipow__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... @overload def __imod__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co \| _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __imod__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... @overload def __imod__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co) -> NDArray[floating[_NBit1]]: ... @overload def __imod__(self: NDArray[timedelta64], other: _SupportsArray[_dtype[timedelta64]] \| _NestedSequence[_SupportsArray[_dtype[timedelta64]]]) -> NDArray[timedelta64]: ... @overload def __imod__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... @overload def __ilshift__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co \| _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __ilshift__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... @overload def __ilshift__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... @overload def __irshift__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co \| _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __irshift__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... @overload def __irshift__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... @overload def __iand__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... @overload def __iand__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co \| _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __iand__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... @overload def __iand__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... @overload def __ixor__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... @overload def __ixor__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co \| _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __ixor__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... @overload def __ixor__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... @overload def __ior__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... @overload def __ior__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co \| _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __ior__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... @overload def __ior__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... @overload def __imatmul__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... @overload def __imatmul__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __imatmul__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... @overload def __imatmul__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co) -> NDArray[floating[_NBit1]]: ... @overload def __imatmul__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... @overload def __imatmul__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... def __dlpack__(self: NDArray[number[Any]], , stream: None = ...) -> _PyCapsule: ... def __dlpack_device__(self) -> tuple[int, L[0]]: ... # Keep `dtype` at the bottom to avoid name conflicts with `np.dtype` @property def dtype(self) -> _DType_co: ... # NOTE: while `np.generic` is not technically an instance of `ABCMeta`, # the `@abstractmethod` decorator is herein used to (forcefully) deny # the creation of `np.generic` instances. # The `# type: ignore` comments are necessary to silence mypy errors regarding # the missing `ABCMeta` metaclass. # See https://github.com/numpy/numpy-stubs/pull/80 for more details. _ScalarType = TypeVar("_ScalarType", bound=generic) _NBit1 = TypeVar("_NBit1", bound=NBitBase) _NBit2 = TypeVar("_NBit2", bound=NBitBase) class generic(_ArrayOrScalarCommon): @abstractmethod def __init__(self, args: Any, kwargs: Any) -> None: ... @overload def __array__(self: _ScalarType, dtype: None = ..., /) -> ndarray[Any, _dtype[_ScalarType]]: ... @overload def __array__(self, dtype: _DType, /) -> ndarray[Any, _DType]: ... @property def base(self) -> None: ... @property def ndim(self) -> L[0]: ... @property def size(self) -> L[1]: ... @property def shape(self) -> tuple[()]: ... @property def strides(self) -> tuple[()]: ... def byteswap(self: _ScalarType, inplace: L[False] = ...) -> _ScalarType: ... @property def flat(self: _ScalarType) -> flatiter[ndarray[Any, _dtype[_ScalarType]]]: ... @overload def astype( self, dtype: _DTypeLike[_ScalarType], order: _OrderKACF = ..., casting: _CastingKind = ..., subok: bool = ..., copy: bool \| _CopyMode = ..., ) -> _ScalarType: ... @overload def astype( self, dtype: DTypeLike, order: _OrderKACF = ..., casting: _CastingKind = ..., subok: bool = ..., copy: bool \| _CopyMode = ..., ) -> Any: ... # NOTE: `view` will perform a 0D->scalar cast, # thus the array `type` is irrelevant to the output type @overload def view( self: _ScalarType, type: type[ndarray[Any, Any]] = ..., ) -> _ScalarType: ... @overload def view( self, dtype: _DTypeLike[_ScalarType], type: type[ndarray[Any, Any]] = ..., ) -> _ScalarType: ... @overload def view( self, dtype: DTypeLike, type: type[ndarray[Any, Any]] = ..., ) -> Any: ... @overload def getfield( self, dtype: _DTypeLike[_ScalarType], offset: SupportsIndex = ... ) -> _ScalarType: ... @overload def getfield( self, dtype: DTypeLike, offset: SupportsIndex = ... ) -> Any: ... def item( self, args: L[0] \| tuple[()] \| tuple[L[0]] = ..., /, ) -> Any: ... @overload def take( # type: ignore[misc] self: _ScalarType, indices: _IntLike_co, axis: None \| SupportsIndex = ..., out: None = ..., mode: _ModeKind = ..., ) -> _ScalarType: ... @overload def take( # type: ignore[misc] self: _ScalarType, indices: _ArrayLikeInt_co, axis: None \| SupportsIndex = ..., out: None = ..., mode: _ModeKind = ..., ) -> ndarray[Any, _dtype[_ScalarType]]: ... @overload def take( self, indices: _ArrayLikeInt_co, axis: None \| SupportsIndex = ..., out: _NdArraySubClass = ..., mode: _ModeKind = ..., ) -> _NdArraySubClass: ... def repeat( self: _ScalarType, repeats: _ArrayLikeInt_co, axis: None \| SupportsIndex = ..., ) -> ndarray[Any, _dtype[_ScalarType]]: ... def flatten( self: _ScalarType, order: _OrderKACF = ..., ) -> ndarray[Any, _dtype[_ScalarType]]: ... def ravel( self: _ScalarType, order: _OrderKACF = ..., ) -> ndarray[Any, _dtype[_ScalarType]]: ... @overload def reshape( self: _ScalarType, shape: _ShapeLike, /, , order: _OrderACF = ... ) -> ndarray[Any, _dtype[_ScalarType]]: ... @overload def reshape( self: _ScalarType, shape: SupportsIndex, order: _OrderACF = ... ) -> ndarray[Any, _dtype[_ScalarType]]: ... def squeeze( self: _ScalarType, axis: None \| L[0] \| tuple[()] = ... ) -> _ScalarType: ... def transpose(self: _ScalarType, axes: None \| tuple[()] = ..., /) -> _ScalarType: ... # Keep `dtype` at the bottom to avoid name conflicts with `np.dtype` @property def dtype(self: _ScalarType) -> _dtype[_ScalarType]: ... class number(generic, Generic[_NBit1]): # type: ignore @property def real(self: _ArraySelf) -> _ArraySelf: ... @property def imag(self: _ArraySelf) -> _ArraySelf: ... def __class_getitem__(self, item: Any) -> GenericAlias: ... def __int__(self) -> int: ... def __float__(self) -> float: ... def __complex__(self) -> complex: ... def __neg__(self: _ArraySelf) -> _ArraySelf: ... def __pos__(self: _ArraySelf) -> _ArraySelf: ... def __abs__(self: _ArraySelf) -> _ArraySelf: ... # Ensure that objects annotated as `number` support arithmetic operations __add__: _NumberOp __radd__: _NumberOp __sub__: _NumberOp __rsub__: _NumberOp __mul__: _NumberOp __rmul__: _NumberOp __floordiv__: _NumberOp __rfloordiv__: _NumberOp __pow__: _NumberOp __rpow__: _NumberOp __truediv__: _NumberOp __rtruediv__: _NumberOp __lt__: _ComparisonOp[_NumberLike_co, _ArrayLikeNumber_co] __le__: _ComparisonOp[_NumberLike_co, _ArrayLikeNumber_co] __gt__: _ComparisonOp[_NumberLike_co, _ArrayLikeNumber_co] __ge__: _ComparisonOp[_NumberLike_co, _ArrayLikeNumber_co] class bool_(generic): def __init__(self, value: object = ..., /) -> None: ... def item( self, args: L[0] \| tuple[()] \| tuple[L[0]] = ..., /, ) -> bool: ... def tolist(self) -> bool: ... @property def real(self: _ArraySelf) -> _ArraySelf: ... @property def imag(self: _ArraySelf) -> _ArraySelf: ... def __int__(self) -> int: ... def __float__(self) -> float: ... def __complex__(self) -> complex: ... def __abs__(self: _ArraySelf) -> _ArraySelf: ... __add__: _BoolOp[bool_] __radd__: _BoolOp[bool_] __sub__: _BoolSub __rsub__: _BoolSub __mul__: _BoolOp[bool_] __rmul__: _BoolOp[bool_] __floordiv__: _BoolOp[int8] __rfloordiv__: _BoolOp[int8] __pow__: _BoolOp[int8] __rpow__: _BoolOp[int8] __truediv__: _BoolTrueDiv __rtruediv__: _BoolTrueDiv def __invert__(self) -> bool_: ... __lshift__: _BoolBitOp[int8] __rlshift__: _BoolBitOp[int8] __rshift__: _BoolBitOp[int8] __rrshift__: _BoolBitOp[int8] __and__: _BoolBitOp[bool_] __rand__: _BoolBitOp[bool_] __xor__: _BoolBitOp[bool_] __rxor__: _BoolBitOp[bool_] __or__: _BoolBitOp[bool_] __ror__: _BoolBitOp[bool_] __mod__: _BoolMod __rmod__: _BoolMod __divmod__: _BoolDivMod __rdivmod__: _BoolDivMod __lt__: _ComparisonOp[_NumberLike_co, _ArrayLikeNumber_co] __le__: _ComparisonOp[_NumberLike_co, _ArrayLikeNumber_co] __gt__: _ComparisonOp[_NumberLike_co, _ArrayLikeNumber_co] __ge__: _ComparisonOp[_NumberLike_co, _ArrayLikeNumber_co] class object_(generic): def __init__(self, value: object = ..., /) -> None: ... @property def real(self: _ArraySelf) -> _ArraySelf: ... @property def imag(self: _ArraySelf) -> _ArraySelf: ... # The 3 protocols below may or may not raise, # depending on the underlying object def __int__(self) -> int: ... def __float__(self) -> float: ... def __complex__(self) -> complex: ... # The `datetime64` constructors requires an object with the three attributes below, # and thus supports datetime duck typing class _DatetimeScalar(Protocol): @property def day(self) -> int: ... @property def month(self) -> int: ... @property def year(self) -> int: ... # TODO: `item`/`tolist` returns either `dt.date`, `dt.datetime` or `int` # depending on the unit class datetime64(generic): @overload def __init__( self, value: None \| datetime64 \| _CharLike_co \| _DatetimeScalar = ..., format: _CharLike_co \| tuple[_CharLike_co, _IntLike_co] = ..., /, ) -> None: ... @overload def __init__( self, value: int, format: _CharLike_co \| tuple[_CharLike_co, _IntLike_co], /, ) -> None: ... def __add__(self, other: _TD64Like_co) -> datetime64: ... def __radd__(self, other: _TD64Like_co) -> datetime64: ... @overload def __sub__(self, other: datetime64) -> timedelta64: ... @overload def __sub__(self, other: _TD64Like_co) -> datetime64: ... def __rsub__(self, other: datetime64) -> timedelta64: ... __lt__: _ComparisonOp[datetime64, _ArrayLikeDT64_co] __le__: _ComparisonOp[datetime64, _ArrayLikeDT64_co] __gt__: _ComparisonOp[datetime64, _ArrayLikeDT64_co] __ge__: _ComparisonOp[datetime64, _ArrayLikeDT64_co] _IntValue = Union[SupportsInt, _CharLike_co, SupportsIndex] _FloatValue = Union[None, _CharLike_co, SupportsFloat, SupportsIndex] _ComplexValue = Union[ None, _CharLike_co, SupportsFloat, SupportsComplex, SupportsIndex, complex, # `complex` is not a subtype of `SupportsComplex` ] class integer(number[_NBit1]): # type: ignore @property def numerator(self: _ScalarType) -> _ScalarType: ... @property def denominator(self) -> L[1]: ... @overload def __round__(self, ndigits: None = ...) -> int: ... @overload def __round__(self: _ScalarType, ndigits: SupportsIndex) -> _ScalarType: ... # NOTE: `__index__` is technically defined in the bottom-most # sub-classes (`int64`, `uint32`, etc) def item( self, args: L[0] \| tuple[()] \| tuple[L[0]] = ..., /, ) -> int: ... def tolist(self) -> int: ... def is_integer(self) -> L[True]: ... def bit_count(self: _ScalarType) -> int: ... def __index__(self) -> int: ... __truediv__: _IntTrueDiv[_NBit1] __rtruediv__: _IntTrueDiv[_NBit1] def __mod__(self, value: _IntLike_co) -> integer[Any]: ... def __rmod__(self, value: _IntLike_co) -> integer[Any]: ... def __invert__(self: _IntType) -> _IntType: ... # Ensure that objects annotated as `integer` support bit-wise operations def __lshift__(self, other: _IntLike_co) -> integer[Any]: ... def __rlshift__(self, other: _IntLike_co) -> integer[Any]: ... def __rshift__(self, other: _IntLike_co) -> integer[Any]: ... def __rrshift__(self, other: _IntLike_co) -> integer[Any]: ... def __and__(self, other: _IntLike_co) -> integer[Any]: ... def __rand__(self, other: _IntLike_co) -> integer[Any]: ... def __or__(self, other: _IntLike_co) -> integer[Any]: ... def __ror__(self, other: _IntLike_co) -> integer[Any]: ... def __xor__(self, other: _IntLike_co) -> integer[Any]: ... def __rxor__(self, other: _IntLike_co) -> integer[Any]: ... class signedinteger(integer[_NBit1]): def __init__(self, value: _IntValue = ..., /) -> None: ... __add__: _SignedIntOp[_NBit1] __radd__: _SignedIntOp[_NBit1] __sub__: _SignedIntOp[_NBit1] __rsub__: _SignedIntOp[_NBit1] __mul__: _SignedIntOp[_NBit1] __rmul__: _SignedIntOp[_NBit1] __floordiv__: _SignedIntOp[_NBit1] __rfloordiv__: _SignedIntOp[_NBit1] __pow__: _SignedIntOp[_NBit1] __rpow__: _SignedIntOp[_NBit1] __lshift__: _SignedIntBitOp[_NBit1] __rlshift__: _SignedIntBitOp[_NBit1] __rshift__: _SignedIntBitOp[_NBit1] __rrshift__: _SignedIntBitOp[_NBit1] __and__: _SignedIntBitOp[_NBit1] __rand__: _SignedIntBitOp[_NBit1] __xor__: _SignedIntBitOp[_NBit1] __rxor__: _SignedIntBitOp[_NBit1] __or__: _SignedIntBitOp[_NBit1] __ror__: _SignedIntBitOp[_NBit1] __mod__: _SignedIntMod[_NBit1] __rmod__: _SignedIntMod[_NBit1] __divmod__: _SignedIntDivMod[_NBit1] __rdivmod__: _SignedIntDivMod[_NBit1] int8 = signedinteger[_8Bit] int16 = signedinteger[_16Bit] int32 = signedinteger[_32Bit] int64 = signedinteger[_64Bit] byte = signedinteger[_NBitByte] short = signedinteger[_NBitShort] intc = signedinteger[_NBitIntC] intp = signedinteger[_NBitIntP] int_ = signedinteger[_NBitInt] longlong = signedinteger[_NBitLongLong] # TODO: `item`/`tolist` returns either `dt.timedelta` or `int` # depending on the unit class timedelta64(generic): def __init__( self, value: None \| int \| _CharLike_co \| dt.timedelta \| timedelta64 = ..., format: _CharLike_co \| tuple[_CharLike_co, _IntLike_co] = ..., /, ) -> None: ... @property def numerator(self: _ScalarType) -> _ScalarType: ... @property def denominator(self) -> L[1]: ... # NOTE: Only a limited number of units support conversion # to builtin scalar types: `Y`, `M`, `ns`, `ps`, `fs`, `as` def __int__(self) -> int: ... def __float__(self) -> float: ... def __complex__(self) -> complex: ... def __neg__(self: _ArraySelf) -> _ArraySelf: ... def __pos__(self: _ArraySelf) -> _ArraySelf: ... def __abs__(self: _ArraySelf) -> _ArraySelf: ... def __add__(self, other: _TD64Like_co) -> timedelta64: ... def __radd__(self, other: _TD64Like_co) -> timedelta64: ... def __sub__(self, other: _TD64Like_co) -> timedelta64: ... def __rsub__(self, other: _TD64Like_co) -> timedelta64: ... def __mul__(self, other: _FloatLike_co) -> timedelta64: ... def __rmul__(self, other: _FloatLike_co) -> timedelta64: ... __truediv__: _TD64Div[float64] __floordiv__: _TD64Div[int64] def __rtruediv__(self, other: timedelta64) -> float64: ... def __rfloordiv__(self, other: timedelta64) -> int64: ... def __mod__(self, other: timedelta64) -> timedelta64: ... def __rmod__(self, other: timedelta64) -> timedelta64: ... def __divmod__(self, other: timedelta64) -> tuple[int64, timedelta64]: ... def __rdivmod__(self, other: timedelta64) -> tuple[int64, timedelta64]: ... __lt__: _ComparisonOp[_TD64Like_co, _ArrayLikeTD64_co] __le__: _ComparisonOp[_TD64Like_co, _ArrayLikeTD64_co] __gt__: _ComparisonOp[_TD64Like_co, _ArrayLikeTD64_co] __ge__: _ComparisonOp[_TD64Like_co, _ArrayLikeTD64_co] class unsignedinteger(integer[_NBit1]): # NOTE: `uint64 + signedinteger -> float64` def __init__(self, value: _IntValue = ..., /) -> None: ... __add__: _UnsignedIntOp[_NBit1] __radd__: _UnsignedIntOp[_NBit1] __sub__: _UnsignedIntOp[_NBit1] __rsub__: _UnsignedIntOp[_NBit1] __mul__: _UnsignedIntOp[_NBit1] __rmul__: _UnsignedIntOp[_NBit1] __floordiv__: _UnsignedIntOp[_NBit1] __rfloordiv__: _UnsignedIntOp[_NBit1] __pow__: _UnsignedIntOp[_NBit1] __rpow__: _UnsignedIntOp[_NBit1] __lshift__: _UnsignedIntBitOp[_NBit1] __rlshift__: _UnsignedIntBitOp[_NBit1] __rshift__: _UnsignedIntBitOp[_NBit1] __rrshift__: _UnsignedIntBitOp[_NBit1] __and__: _UnsignedIntBitOp[_NBit1] __rand__: _UnsignedIntBitOp[_NBit1] __xor__: _UnsignedIntBitOp[_NBit1] __rxor__: _UnsignedIntBitOp[_NBit1] __or__: _UnsignedIntBitOp[_NBit1] __ror__: _UnsignedIntBitOp[_NBit1] __mod__: _UnsignedIntMod[_NBit1] __rmod__: _UnsignedIntMod[_NBit1] __divmod__: _UnsignedIntDivMod[_NBit1] __rdivmod__: _UnsignedIntDivMod[_NBit1] uint8 = unsignedinteger[_8Bit] uint16 = unsignedinteger[_16Bit] uint32 = unsignedinteger[_32Bit] uint64 = unsignedinteger[_64Bit] ubyte = unsignedinteger[_NBitByte] ushort = unsignedinteger[_NBitShort] uintc = unsignedinteger[_NBitIntC] uintp = unsignedinteger[_NBitIntP] uint = unsignedinteger[_NBitInt] ulonglong = unsignedinteger[_NBitLongLong] class inexact(number[_NBit1]): # type: ignore def __getnewargs__(self: inexact[_64Bit]) -> tuple[float, ...]: ... _IntType = TypeVar("_IntType", bound=integer[Any]) _FloatType = TypeVar('_FloatType', bound=floating[Any]) class floating(inexact[_NBit1]): def __init__(self, value: _FloatValue = ..., /) -> None: ... def item( self, args: L[0] \| tuple[()] \| tuple[L[0]] = ..., /, ) -> float: ... def tolist(self) -> float: ... def is_integer(self) -> bool: ... def hex(self: float64) -> str: ... @classmethod def fromhex(cls: type[float64], string: str, /) -> float64: ... def as_integer_ratio(self) -> tuple[int, int]: ... def __ceil__(self: float64) -> int: ... def __floor__(self: float64) -> int: ... def __trunc__(self: float64) -> int: ... def __getnewargs__(self: float64) -> tuple[float]: ... def __getformat__(self: float64, typestr: L["double", "float"], /) -> str: ... @overload def __round__(self, ndigits: None = ...) -> int: ... @overload def __round__(self: _ScalarType, ndigits: SupportsIndex) -> _ScalarType: ... __add__: _FloatOp[_NBit1] __radd__: _FloatOp[_NBit1] __sub__: _FloatOp[_NBit1] __rsub__: _FloatOp[_NBit1] __mul__: _FloatOp[_NBit1] __rmul__: _FloatOp[_NBit1] __truediv__: _FloatOp[_NBit1] __rtruediv__: _FloatOp[_NBit1] __floordiv__: _FloatOp[_NBit1] __rfloordiv__: _FloatOp[_NBit1] __pow__: _FloatOp[_NBit1] __rpow__: _FloatOp[_NBit1] __mod__: _FloatMod[_NBit1] __rmod__: _FloatMod[_NBit1] __divmod__: _FloatDivMod[_NBit1] __rdivmod__: _FloatDivMod[_NBit1] float16 = floating[_16Bit] float32 = floating[_32Bit] float64 = floating[_64Bit] half = floating[_NBitHalf] single = floating[_NBitSingle] double = floating[_NBitDouble] float_ = floating[_NBitDouble] longdouble = floating[_NBitLongDouble] longfloat = floating[_NBitLongDouble] # The main reason for `complexfloating` having two typevars is cosmetic. # It is used to clarify why `complex128`s precision is `_64Bit`, the latter # describing the two 64 bit floats representing its real and imaginary component class complexfloating(inexact[_NBit1], Generic[_NBit1, _NBit2]): def __init__(self, value: _ComplexValue = ..., /) -> None: ... def item( self, args: L[0] \| tuple[()] \| tuple[L[0]] = ..., /, ) -> complex: ... def tolist(self) -> complex: ... @property def real(self) -> floating[_NBit1]: ... # type: ignore[override] @property def imag(self) -> floating[_NBit2]: ... # type: ignore[override] def __abs__(self) -> floating[_NBit1]: ... # type: ignore[override] def __getnewargs__(self: complex128) -> tuple[float, float]: ... # NOTE: Deprecated # def __round__(self, ndigits=...): ... __add__: _ComplexOp[_NBit1] __radd__: _ComplexOp[_NBit1] __sub__: _ComplexOp[_NBit1] __rsub__: _ComplexOp[_NBit1] __mul__: _ComplexOp[_NBit1] __rmul__: _ComplexOp[_NBit1] __truediv__: _ComplexOp[_NBit1] __rtruediv__: _ComplexOp[_NBit1] __pow__: _ComplexOp[_NBit1] __rpow__: _ComplexOp[_NBit1] complex64 = complexfloating[_32Bit, _32Bit] complex128 = complexfloating[_64Bit, _64Bit] csingle = complexfloating[_NBitSingle, _NBitSingle] singlecomplex = complexfloating[_NBitSingle, _NBitSingle] cdouble = complexfloating[_NBitDouble, _NBitDouble] complex_ = complexfloating[_NBitDouble, _NBitDouble] cfloat = complexfloating[_NBitDouble, _NBitDouble] clongdouble = complexfloating[_NBitLongDouble, _NBitLongDouble] clongfloat = complexfloating[_NBitLongDouble, _NBitLongDouble] longcomplex = complexfloating[_NBitLongDouble, _NBitLongDouble] class flexible(generic): ... # type: ignore # TODO: `item`/`tolist` returns either `bytes` or `tuple` # depending on whether or not it's used as an opaque bytes sequence # or a structure class void(flexible): @overload def __init__(self, value: _IntLike_co \| bytes, /, dtype : None = ...) -> None: ... @overload def __init__(self, value: Any, /, dtype: _DTypeLikeVoid) -> None: ... @property def real(self: _ArraySelf) -> _ArraySelf: ... @property def imag(self: _ArraySelf) -> _ArraySelf: ... def setfield( self, val: ArrayLike, dtype: DTypeLike, offset: int = ... ) -> None: ... @overload def __getitem__(self, key: str \| SupportsIndex) -> Any: ... @overload def __getitem__(self, key: list[str]) -> void: ... def __setitem__( self, key: str \| list[str] \| SupportsIndex, value: ArrayLike, ) -> None: ... class character(flexible): # type: ignore def __int__(self) -> int: ... def __float__(self) -> float: ... # NOTE: Most `np.bytes_` / `np.str_` methods return their # builtin `bytes` / `str` counterpart class bytes_(character, bytes): @overload def __init__(self, value: object = ..., /) -> None: ... @overload def __init__( self, value: str, /, encoding: str = ..., errors: str = ... ) -> None: ... def item( self, args: L[0] \| tuple[()] \| tuple[L[0]] = ..., /, ) -> bytes: ... def tolist(self) -> bytes: ... string_ = bytes_ class str_(character, str): @overload def __init__(self, value: object = ..., /) -> None: ... @overload def __init__( self, value: bytes, /, encoding: str = ..., errors: str = ... ) -> None: ... def item( self, args: L[0] \| tuple[()] \| tuple[L[0]] = ..., /, ) -> str: ... def tolist(self) -> str: ... unicode_ = str_ # # Constants # Inf: Final[float] Infinity: Final[float] NAN: Final[float] NINF: Final[float] NZERO: Final[float] NaN: Final[float] PINF: Final[float] PZERO: Final[float] e: Final[float] euler_gamma: Final[float] inf: Final[float] infty: Final[float] nan: Final[float] pi: Final[float] ERR_IGNORE: L[0] ERR_WARN: L[1] ERR_RAISE: L[2] ERR_CALL: L[3] ERR_PRINT: L[4] ERR_LOG: L[5] ERR_DEFAULT: L[521] SHIFT_DIVIDEBYZERO: L[0] SHIFT_OVERFLOW: L[3] SHIFT_UNDERFLOW: L[6] SHIFT_INVALID: L[9] FPE_DIVIDEBYZERO: L[1] FPE_OVERFLOW: L[2] FPE_UNDERFLOW: L[4] FPE_INVALID: L[8] FLOATING_POINT_SUPPORT: L[1] UFUNC_BUFSIZE_DEFAULT = BUFSIZE little_endian: Final[bool] True_: Final[bool_] False_: Final[bool_] UFUNC_PYVALS_NAME: L["UFUNC_PYVALS"] newaxis: None # See `numpy._typing._ufunc` for more concrete nin-/nout-specific stubs @final class ufunc: @property def __name__(self) -> str: ... @property def __doc__(self) -> str: ... __call__: Callable[..., Any] @property def nin(self) -> int: ... @property def nout(self) -> int: ... @property def nargs(self) -> int: ... @property def ntypes(self) -> int: ... @property def types(self) -> list[str]: ... # Broad return type because it has to encompass things like # # >>> np.logical_and.identity is True # True # >>> np.add.identity is 0 # True # >>> np.sin.identity is None # True # # and any user-defined ufuncs. @property def identity(self) -> Any: ... # This is None for ufuncs and a string for gufuncs. @property def signature(self) -> None \| str: ... # The next four methods will always exist, but they will just # raise a ValueError ufuncs with that don't accept two input # arguments and return one output argument. Because of that we # can't type them very precisely. reduce: Any accumulate: Any reduceat: Any outer: Any # Similarly at won't be defined for ufuncs that return multiple # outputs, so we can't type it very precisely. at: Any # Parameters: `__name__`, `ntypes` and `identity` absolute: _UFunc_Nin1_Nout1[L['absolute'], L[20], None] add: _UFunc_Nin2_Nout1[L['add'], L[22], L[0]] arccos: _UFunc_Nin1_Nout1[L['arccos'], L[8], None] arccosh: _UFunc_Nin1_Nout1[L['arccosh'], L[8], None] arcsin: _UFunc_Nin1_Nout1[L['arcsin'], L[8], None] arcsinh: _UFunc_Nin1_Nout1[L['arcsinh'], L[8], None] arctan2: _UFunc_Nin2_Nout1[L['arctan2'], L[5], None] arctan: _UFunc_Nin1_Nout1[L['arctan'], L[8], None] arctanh: _UFunc_Nin1_Nout1[L['arctanh'], L[8], None] bitwise_and: _UFunc_Nin2_Nout1[L['bitwise_and'], L[12], L[-1]] bitwise_not: _UFunc_Nin1_Nout1[L['invert'], L[12], None] bitwise_or: _UFunc_Nin2_Nout1[L['bitwise_or'], L[12], L[0]] bitwise_xor: _UFunc_Nin2_Nout1[L['bitwise_xor'], L[12], L[0]] cbrt: _UFunc_Nin1_Nout1[L['cbrt'], L[5], None] ceil: _UFunc_Nin1_Nout1[L['ceil'], L[7], None] conj: _UFunc_Nin1_Nout1[L['conjugate'], L[18], None] conjugate: _UFunc_Nin1_Nout1[L['conjugate'], L[18], None] copysign: _UFunc_Nin2_Nout1[L['copysign'], L[4], None] cos: _UFunc_Nin1_Nout1[L['cos'], L[9], None] cosh: _UFunc_Nin1_Nout1[L['cosh'], L[8], None] deg2rad: _UFunc_Nin1_Nout1[L['deg2rad'], L[5], None] degrees: _UFunc_Nin1_Nout1[L['degrees'], L[5], None] divide: _UFunc_Nin2_Nout1[L['true_divide'], L[11], None] divmod: _UFunc_Nin2_Nout2[L['divmod'], L[15], None] equal: _UFunc_Nin2_Nout1[L['equal'], L[23], None] exp2: _UFunc_Nin1_Nout1[L['exp2'], L[8], None] exp: _UFunc_Nin1_Nout1[L['exp'], L[10], None] expm1: _UFunc_Nin1_Nout1[L['expm1'], L[8], None] fabs: _UFunc_Nin1_Nout1[L['fabs'], L[5], None] float_power: _UFunc_Nin2_Nout1[L['float_power'], L[4], None] floor: _UFunc_Nin1_Nout1[L['floor'], L[7], None] floor_divide: _UFunc_Nin2_Nout1[L['floor_divide'], L[21], None] fmax: _UFunc_Nin2_Nout1[L['fmax'], L[21], None] fmin: _UFunc_Nin2_Nout1[L['fmin'], L[21], None] fmod: _UFunc_Nin2_Nout1[L['fmod'], L[15], None] frexp: _UFunc_Nin1_Nout2[L['frexp'], L[4], None] gcd: _UFunc_Nin2_Nout1[L['gcd'], L[11], L[0]] greater: _UFunc_Nin2_Nout1[L['greater'], L[23], None] greater_equal: _UFunc_Nin2_Nout1[L['greater_equal'], L[23], None] heaviside: _UFunc_Nin2_Nout1[L['heaviside'], L[4], None] hypot: _UFunc_Nin2_Nout1[L['hypot'], L[5], L[0]] invert: _UFunc_Nin1_Nout1[L['invert'], L[12], None] isfinite: _UFunc_Nin1_Nout1[L['isfinite'], L[20], None] isinf: _UFunc_Nin1_Nout1[L['isinf'], L[20], None] isnan: _UFunc_Nin1_Nout1[L['isnan'], L[20], None] isnat: _UFunc_Nin1_Nout1[L['isnat'], L[2], None] lcm: _UFunc_Nin2_Nout1[L['lcm'], L[11], None] ldexp: _UFunc_Nin2_Nout1[L['ldexp'], L[8], None] left_shift: _UFunc_Nin2_Nout1[L['left_shift'], L[11], None] less: _UFunc_Nin2_Nout1[L['less'], L[23], None] less_equal: _UFunc_Nin2_Nout1[L['less_equal'], L[23], None] log10: _UFunc_Nin1_Nout1[L['log10'], L[8], None] log1p: _UFunc_Nin1_Nout1[L['log1p'], L[8], None] log2: _UFunc_Nin1_Nout1[L['log2'], L[8], None] log: _UFunc_Nin1_Nout1[L['log'], L[10], None] logaddexp2: _UFunc_Nin2_Nout1[L['logaddexp2'], L[4], float] logaddexp: _UFunc_Nin2_Nout1[L['logaddexp'], L[4], float] logical_and: _UFunc_Nin2_Nout1[L['logical_and'], L[20], L[True]] logical_not: _UFunc_Nin1_Nout1[L['logical_not'], L[20], None] logical_or: _UFunc_Nin2_Nout1[L['logical_or'], L[20], L[False]] logical_xor: _UFunc_Nin2_Nout1[L['logical_xor'], L[19], L[False]] matmul: _GUFunc_Nin2_Nout1[L['matmul'], L[19], None] maximum: _UFunc_Nin2_Nout1[L['maximum'], L[21], None] minimum: _UFunc_Nin2_Nout1[L['minimum'], L[21], None] mod: _UFunc_Nin2_Nout1[L['remainder'], L[16], None] modf: _UFunc_Nin1_Nout2[L['modf'], L[4], None] multiply: _UFunc_Nin2_Nout1[L['multiply'], L[23], L[1]] negative: _UFunc_Nin1_Nout1[L['negative'], L[19], None] nextafter: _UFunc_Nin2_Nout1[L['nextafter'], L[4], None] not_equal: _UFunc_Nin2_Nout1[L['not_equal'], L[23], None] positive: _UFunc_Nin1_Nout1[L['positive'], L[19], None] power: _UFunc_Nin2_Nout1[L['power'], L[18], None] rad2deg: _UFunc_Nin1_Nout1[L['rad2deg'], L[5], None] radians: _UFunc_Nin1_Nout1[L['radians'], L[5], None] reciprocal: _UFunc_Nin1_Nout1[L['reciprocal'], L[18], None] remainder: _UFunc_Nin2_Nout1[L['remainder'], L[16], None] right_shift: _UFunc_Nin2_Nout1[L['right_shift'], L[11], None] rint: _UFunc_Nin1_Nout1[L['rint'], L[10], None] sign: _UFunc_Nin1_Nout1[L['sign'], L[19], None] signbit: _UFunc_Nin1_Nout1[L['signbit'], L[4], None] sin: _UFunc_Nin1_Nout1[L['sin'], L[9], None] sinh: _UFunc_Nin1_Nout1[L['sinh'], L[8], None] spacing: _UFunc_Nin1_Nout1[L['spacing'], L[4], None] sqrt: _UFunc_Nin1_Nout1[L['sqrt'], L[10], None] square: _UFunc_Nin1_Nout1[L['square'], L[18], None] subtract: _UFunc_Nin2_Nout1[L['subtract'], L[21], None] tan: _UFunc_Nin1_Nout1[L['tan'], L[8], None] tanh: _UFunc_Nin1_Nout1[L['tanh'], L[8], None] true_divide: _UFunc_Nin2_Nout1[L['true_divide'], L[11], None] trunc: _UFunc_Nin1_Nout1[L['trunc'], L[7], None] abs = absolute class _CopyMode(enum.Enum): ALWAYS: L[True] IF_NEEDED: L[False] NEVER: L[2] # Warnings class RankWarning(UserWarning): ... _CallType = TypeVar("_CallType", bound=_ErrFunc \| _SupportsWrite[str]) class errstate(Generic[_CallType], ContextDecorator): call: _CallType kwargs: _ErrDictOptional # Expand `kwargs` into explicit keyword-only arguments def __init__( self, , call: _CallType = ..., all: None \| _ErrKind = ..., divide: None \| _ErrKind = ..., over: None \| _ErrKind = ..., under: None \| _ErrKind = ..., invalid: None \| _ErrKind = ..., ) -> None: ... def __enter__(self) -> None: ... def __exit__( self, exc_type: None \| type[BaseException], exc_value: None \| BaseException, traceback: None \| TracebackType, /, ) -> None: ... @contextmanager def _no_nep50_warning() -> Generator[None, None, None]: ... def _get_promotion_state() -> str: ... def _set_promotion_state(state: str, /) -> None: ... class ndenumerate(Generic[_ScalarType]): iter: flatiter[NDArray[_ScalarType]] @overload def __new__( cls, arr: _FiniteNestedSequence[_SupportsArray[dtype[_ScalarType]]], ) -> ndenumerate[_ScalarType]: ... @overload def __new__(cls, arr: str \| _NestedSequence[str]) -> ndenumerate[str_]: ... @overload def __new__(cls, arr: bytes \| _NestedSequence[bytes]) -> ndenumerate[bytes_]: ... @overload def __new__(cls, arr: bool \| _NestedSequence[bool]) -> ndenumerate[bool_]: ... @overload def __new__(cls, arr: int \| _NestedSequence[int]) -> ndenumerate[int_]: ... @overload def __new__(cls, arr: float \| _NestedSequence[float]) -> ndenumerate[float_]: ... @overload def __new__(cls, arr: complex \| _NestedSequence[complex]) -> ndenumerate[complex_]: ... def __next__(self: ndenumerate[_ScalarType]) -> tuple[_Shape, _ScalarType]: ... def __iter__(self: _T) -> _T: ... class ndindex: @overload def __init__(self, shape: tuple[SupportsIndex, ...], /) -> None: ... @overload def __init__(self, shape: SupportsIndex) -> None: ... def __iter__(self: _T) -> _T: ... def __next__(self) -> _Shape: ... class DataSource: def __init__( self, destpath: None \| str \| os.PathLike[str] = ..., ) -> None: ... def __del__(self) -> None: ... def abspath(self, path: str) -> str: ... def exists(self, path: str) -> bool: ... # Whether the file-object is opened in string or bytes mode (by default) # depends on the file-extension of `path` def open( self, path: str, mode: str = ..., encoding: None \| str = ..., newline: None \| str = ..., ) -> IO[Any]: ... # TODO: The type of each `__next__` and `iters` return-type depends # on the length and dtype of `args`; we can't describe this behavior yet # as we lack variadics (PEP 646). @final class broadcast: def __new__(cls, args: ArrayLike) -> broadcast: ... @property def index(self) -> int: ... @property def iters(self) -> tuple[flatiter[Any], ...]: ... @property def nd(self) -> int: ... @property def ndim(self) -> int: ... @property def numiter(self) -> int: ... @property def shape(self) -> _Shape: ... @property def size(self) -> int: ... def __next__(self) -> tuple[Any, ...]: ... def __iter__(self: _T) -> _T: ... def reset(self) -> None: ... @final class busdaycalendar: def __new__( cls, weekmask: ArrayLike = ..., holidays: ArrayLike \| dt.date \| _NestedSequence[dt.date] = ..., ) -> busdaycalendar: ... @property def weekmask(self) -> NDArray[bool_]: ... @property def holidays(self) -> NDArray[datetime64]: ... class finfo(Generic[_FloatType]): dtype: dtype[_FloatType] bits: int eps: _FloatType epsneg: _FloatType iexp: int machep: int max: _FloatType maxexp: int min: _FloatType minexp: int negep: int nexp: int nmant: int precision: int resolution: _FloatType smallest_subnormal: _FloatType @property def smallest_normal(self) -> _FloatType: ... @property def tiny(self) -> _FloatType: ... @overload def __new__( cls, dtype: inexact[_NBit1] \| _DTypeLike[inexact[_NBit1]] ) -> finfo[floating[_NBit1]]: ... @overload def __new__( cls, dtype: complex \| float \| type[complex] \| type[float] ) -> finfo[float_]: ... @overload def __new__( cls, dtype: str ) -> finfo[floating[Any]]: ... class iinfo(Generic[_IntType]): dtype: dtype[_IntType] kind: str bits: int key: str @property def min(self) -> int: ... @property def max(self) -> int: ... @overload def __new__(cls, dtype: _IntType \| _DTypeLike[_IntType]) -> iinfo[_IntType]: ... @overload def __new__(cls, dtype: int \| type[int]) -> iinfo[int_]: ... @overload def __new__(cls, dtype: str) -> iinfo[Any]: ... class format_parser: dtype: dtype[void] def __init__( self, formats: DTypeLike, names: None \| str \| Sequence[str], titles: None \| str \| Sequence[str], aligned: bool = ..., byteorder: None \| _ByteOrder = ..., ) -> None: ... class recarray(ndarray[_ShapeType, _DType_co]): # NOTE: While not strictly mandatory, we're demanding here that arguments # for the `format_parser`- and `dtype`-based dtype constructors are # mutually exclusive @overload def __new__( subtype, shape: _ShapeLike, dtype: None = ..., buf: None \| _SupportsBuffer = ..., offset: SupportsIndex = ..., strides: None \| _ShapeLike = ..., , formats: DTypeLike, names: None \| str \| Sequence[str] = ..., titles: None \| str \| Sequence[str] = ..., byteorder: None \| _ByteOrder = ..., aligned: bool = ..., order: _OrderKACF = ..., ) -> recarray[Any, dtype[record]]: ... @overload def __new__( subtype, shape: _ShapeLike, dtype: DTypeLike, buf: None \| _SupportsBuffer = ..., offset: SupportsIndex = ..., strides: None \| _ShapeLike = ..., formats: None = ..., names: None = ..., titles: None = ..., byteorder: None = ..., aligned: L[False] = ..., order: _OrderKACF = ..., ) -> recarray[Any, dtype[Any]]: ... def __array_finalize__(self, obj: object) -> None: ... def __getattribute__(self, attr: str) -> Any: ... def __setattr__(self, attr: str, val: ArrayLike) -> None: ... @overload def __getitem__(self, indx: ( SupportsIndex \| _ArrayLikeInt_co \| tuple[SupportsIndex \| _ArrayLikeInt_co, ...] )) -> Any: ... @overload def __getitem__(self: recarray[Any, dtype[void]], indx: ( None \| slice \| ellipsis \| SupportsIndex \| _ArrayLikeInt_co \| tuple[None \| slice \| ellipsis \| _ArrayLikeInt_co \| SupportsIndex, ...] )) -> recarray[Any, _DType_co]: ... @overload def __getitem__(self, indx: ( None \| slice \| ellipsis \| SupportsIndex \| _ArrayLikeInt_co \| tuple[None \| slice \| ellipsis \| _ArrayLikeInt_co \| SupportsIndex, ...] )) -> ndarray[Any, _DType_co]: ... @overload def __getitem__(self, indx: str) -> NDArray[Any]: ... @overload def __getitem__(self, indx: list[str]) -> recarray[_ShapeType, dtype[record]]: ... @overload def field(self, attr: int \| str, val: None = ...) -> Any: ... @overload def field(self, attr: int \| str, val: ArrayLike) -> None: ... class record(void): def __getattribute__(self, attr: str) -> Any: ... def __setattr__(self, attr: str, val: ArrayLike) -> None: ... def pprint(self) -> str: ... @overload def __getitem__(self, key: str \| SupportsIndex) -> Any: ... @overload def __getitem__(self, key: list[str]) -> record: ... _NDIterFlagsKind = L[ "buffered", "c_index", "copy_if_overlap", "common_dtype", "delay_bufalloc", "external_loop", "f_index", "grow_inner", "growinner", "multi_index", "ranged", "refs_ok", "reduce_ok", "zerosize_ok", ] _NDIterOpFlagsKind = L[ "aligned", "allocate", "arraymask", "copy", "config", "nbo", "no_subtype", "no_broadcast", "overlap_assume_elementwise", "readonly", "readwrite", "updateifcopy", "virtual", "writeonly", "writemasked" ] @final class nditer: def __new__( cls, op: ArrayLike \| Sequence[ArrayLike], flags: None \| Sequence[_NDIterFlagsKind] = ..., op_flags: None \| Sequence[Sequence[_NDIterOpFlagsKind]] = ..., op_dtypes: DTypeLike \| Sequence[DTypeLike] = ..., order: _OrderKACF = ..., casting: _CastingKind = ..., op_axes: None \| Sequence[Sequence[SupportsIndex]] = ..., itershape: None \| _ShapeLike = ..., buffersize: SupportsIndex = ..., ) -> nditer: ... def __enter__(self) -> nditer: ... def __exit__( self, exc_type: None \| type[BaseException], exc_value: None \| BaseException, traceback: None \| TracebackType, ) -> None: ... def __iter__(self) -> nditer: ... def __next__(self) -> tuple[NDArray[Any], ...]: ... def __len__(self) -> int: ... def __copy__(self) -> nditer: ... @overload def __getitem__(self, index: SupportsIndex) -> NDArray[Any]: ... @overload def __getitem__(self, index: slice) -> tuple[NDArray[Any], ...]: ... def __setitem__(self, index: slice \| SupportsIndex, value: ArrayLike) -> None: ... def close(self) -> None: ... def copy(self) -> nditer: ... def debug_print(self) -> None: ... def enable_external_loop(self) -> None: ... def iternext(self) -> bool: ... def remove_axis(self, i: SupportsIndex, /) -> None: ... def remove_multi_index(self) -> None: ... def reset(self) -> None: ... @property def dtypes(self) -> tuple[dtype[Any], ...]: ... @property def finished(self) -> bool: ... @property def has_delayed_bufalloc(self) -> bool: ... @property def has_index(self) -> bool: ... @property def has_multi_index(self) -> bool: ... @property def index(self) -> int: ... @property def iterationneedsapi(self) -> bool: ... @property def iterindex(self) -> int: ... @property def iterrange(self) -> tuple[int, ...]: ... @property def itersize(self) -> int: ... @property def itviews(self) -> tuple[NDArray[Any], ...]: ... @property def multi_index(self) -> tuple[int, ...]: ... @property def ndim(self) -> int: ... @property def nop(self) -> int: ... @property def operands(self) -> tuple[NDArray[Any], ...]: ... @property def shape(self) -> tuple[int, ...]: ... @property def value(self) -> tuple[NDArray[Any], ...]: ... _MemMapModeKind = L[ "readonly", "r", "copyonwrite", "c", "readwrite", "r+", "write", "w+", ] class memmap(ndarray[_ShapeType, _DType_co]): __array_priority__: ClassVar[float] filename: str \| None offset: int mode: str @overload def __new__( subtype, filename: str \| bytes \| os.PathLike[str] \| os.PathLike[bytes] \| _MemMapIOProtocol, dtype: type[uint8] = ..., mode: _MemMapModeKind = ..., offset: int = ..., shape: None \| int \| tuple[int, ...] = ..., order: _OrderKACF = ..., ) -> memmap[Any, dtype[uint8]]: ... @overload def __new__( subtype, filename: str \| bytes \| os.PathLike[str] \| os.PathLike[bytes] \| _MemMapIOProtocol, dtype: _DTypeLike[_ScalarType], mode: _MemMapModeKind = ..., offset: int = ..., shape: None \| int \| tuple[int, ...] = ..., order: _OrderKACF = ..., ) -> memmap[Any, dtype[_ScalarType]]: ... @overload def __new__( subtype, filename: str \| bytes \| os.PathLike[str] \| os.PathLike[bytes] \| _MemMapIOProtocol, dtype: DTypeLike, mode: _MemMapModeKind = ..., offset: int = ..., shape: None \| int \| tuple[int, ...] = ..., order: _OrderKACF = ..., ) -> memmap[Any, dtype[Any]]: ... def __array_finalize__(self, obj: object) -> None: ... def __array_wrap__( self, array: memmap[_ShapeType, _DType_co], context: None \| tuple[ufunc, tuple[Any, ...], int] = ..., ) -> Any: ... def flush(self) -> None: ... # TODO: Add a mypy plugin for managing functions whose output type is dependent # on the literal value of some sort of signature (e.g. `einsum` and `vectorize`) class vectorize: pyfunc: Callable[..., Any] cache: bool signature: None \| str otypes: None \| str excluded: set[int \| str] __doc__: None \| str def __init__( self, pyfunc: Callable[..., Any], otypes: None \| str \| Iterable[DTypeLike] = ..., doc: None \| str = ..., excluded: None \| Iterable[int \| str] = ..., cache: bool = ..., signature: None \| str = ..., ) -> None: ... def __call__(self, args: Any, *kwargs: Any) -> Any: ... class poly1d: @property def variable(self) -> str: ... @property def order(self) -> int: ... @property def o(self) -> int: ... @property def roots(self) -> NDArray[Any]: ... @property def r(self) -> NDArray[Any]: ... @property def coeffs(self) -> NDArray[Any]: ... @coeffs.setter def coeffs(self, value: NDArray[Any]) -> None: ... @property def c(self) -> NDArray[Any]: ... @c.setter def c(self, value: NDArray[Any]) -> None: ... @property def coef(self) -> NDArray[Any]: ... @coef.setter def coef(self, value: NDArray[Any]) -> None: ... @property def coefficients(self) -> NDArray[Any]: ... @coefficients.setter def coefficients(self, value: NDArray[Any]) -> None: ... __hash__: ClassVar[None] # type: ignore @overload def __array__(self, t: None = ...) -> NDArray[Any]: ... @overload def __array__(self, t: _DType) -> ndarray[Any, _DType]: ... @overload def __call__(self, val: _ScalarLike_co) -> Any: ... @overload def __call__(self, val: poly1d) -> poly1d: ... @overload def __call__(self, val: ArrayLike) -> NDArray[Any]: ... def __init__( self, c_or_r: ArrayLike, r: bool = ..., variable: None \| str = ..., ) -> None: ... def __len__(self) -> int: ... def __neg__(self) -> poly1d: ... def __pos__(self) -> poly1d: ... def __mul__(self, other: ArrayLike) -> poly1d: ... def __rmul__(self, other: ArrayLike) -> poly1d: ... def __add__(self, other: ArrayLike) -> poly1d: ... def __radd__(self, other: ArrayLike) -> poly1d: ... def __pow__(self, val: _FloatLike_co) -> poly1d: ... # Integral floats are accepted def __sub__(self, other: ArrayLike) -> poly1d: ... def __rsub__(self, other: ArrayLike) -> poly1d: ... def __div__(self, other: ArrayLike) -> poly1d: ... def __truediv__(self, other: ArrayLike) -> poly1d: ... def __rdiv__(self, other: ArrayLike) -> poly1d: ... def __rtruediv__(self, other: ArrayLike) -> poly1d: ... def __getitem__(self, val: int) -> Any: ... def __setitem__(self, key: int, val: Any) -> None: ... def __iter__(self) -> Iterator[Any]: ... def deriv(self, m: SupportsInt \| SupportsIndex = ...) -> poly1d: ... def integ( self, m: SupportsInt \| SupportsIndex = ..., k: None \| _ArrayLikeComplex_co \| _ArrayLikeObject_co = ..., ) -> poly1d: ... class matrix(ndarray[_ShapeType, _DType_co]): __array_priority__: ClassVar[float] def __new__( subtype, data: ArrayLike, dtype: DTypeLike = ..., copy: bool = ..., ) -> matrix[Any, Any]: ... def __array_finalize__(self, obj: object) -> None: ... @overload def __getitem__(self, key: ( SupportsIndex \| _ArrayLikeInt_co \| tuple[SupportsIndex \| _ArrayLikeInt_co, ...] )) -> Any: ... @overload def __getitem__(self, key: ( None \| slice \| ellipsis \| SupportsIndex \| _ArrayLikeInt_co \| tuple[None \| slice \| ellipsis \| _ArrayLikeInt_co \| SupportsIndex, ...] )) -> matrix[Any, _DType_co]: ... @overload def __getitem__(self: NDArray[void], key: str) -> matrix[Any, dtype[Any]]: ... @overload def __getitem__(self: NDArray[void], key: list[str]) -> matrix[_ShapeType, dtype[void]]: ... def __mul__(self, other: ArrayLike) -> matrix[Any, Any]: ... def __rmul__(self, other: ArrayLike) -> matrix[Any, Any]: ... def __imul__(self, other: ArrayLike) -> matrix[_ShapeType, _DType_co]: ... def __pow__(self, other: ArrayLike) -> matrix[Any, Any]: ... def __ipow__(self, other: ArrayLike) -> matrix[_ShapeType, _DType_co]: ... @overload def sum(self, axis: None = ..., dtype: DTypeLike = ..., out: None = ...) -> Any: ... @overload def sum(self, axis: _ShapeLike, dtype: DTypeLike = ..., out: None = ...) -> matrix[Any, Any]: ... @overload def sum(self, axis: None \| _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... @overload def mean(self, axis: None = ..., dtype: DTypeLike = ..., out: None = ...) -> Any: ... @overload def mean(self, axis: _ShapeLike, dtype: DTypeLike = ..., out: None = ...) -> matrix[Any, Any]: ... @overload def mean(self, axis: None \| _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... @overload def std(self, axis: None = ..., dtype: DTypeLike = ..., out: None = ..., ddof: float = ...) -> Any: ... @overload def std(self, axis: _ShapeLike, dtype: DTypeLike = ..., out: None = ..., ddof: float = ...) -> matrix[Any, Any]: ... @overload def std(self, axis: None \| _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., ddof: float = ...) -> _NdArraySubClass: ... @overload def var(self, axis: None = ..., dtype: DTypeLike = ..., out: None = ..., ddof: float = ...) -> Any: ... @overload def var(self, axis: _ShapeLike, dtype: DTypeLike = ..., out: None = ..., ddof: float = ...) -> matrix[Any, Any]: ... @overload def var(self, axis: None \| _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., ddof: float = ...) -> _NdArraySubClass: ... @overload def prod(self, axis: None = ..., dtype: DTypeLike = ..., out: None = ...) -> Any: ... @overload def prod(self, axis: _ShapeLike, dtype: DTypeLike = ..., out: None = ...) -> matrix[Any, Any]: ... @overload def prod(self, axis: None \| _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... @overload def any(self, axis: None = ..., out: None = ...) -> bool_: ... @overload def any(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, dtype[bool_]]: ... @overload def any(self, axis: None \| _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... @overload def all(self, axis: None = ..., out: None = ...) -> bool_: ... @overload def all(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, dtype[bool_]]: ... @overload def all(self, axis: None \| _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... @overload def max(self: NDArray[_ScalarType], axis: None = ..., out: None = ...) -> _ScalarType: ... @overload def max(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, _DType_co]: ... @overload def max(self, axis: None \| _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... @overload def min(self: NDArray[_ScalarType], axis: None = ..., out: None = ...) -> _ScalarType: ... @overload def min(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, _DType_co]: ... @overload def min(self, axis: None \| _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... @overload def argmax(self: NDArray[_ScalarType], axis: None = ..., out: None = ...) -> intp: ... @overload def argmax(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, dtype[intp]]: ... @overload def argmax(self, axis: None \| _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... @overload def argmin(self: NDArray[_ScalarType], axis: None = ..., out: None = ...) -> intp: ... @overload def argmin(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, dtype[intp]]: ... @overload def argmin(self, axis: None \| _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... @overload def ptp(self: NDArray[_ScalarType], axis: None = ..., out: None = ...) -> _ScalarType: ... @overload def ptp(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, _DType_co]: ... @overload def ptp(self, axis: None \| _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... def squeeze(self, axis: None \| _ShapeLike = ...) -> matrix[Any, _DType_co]: ... def tolist(self: matrix[Any, dtype[_SupportsItem[_T]]]) -> list[list[_T]]: ... # type: ignore[typevar] def ravel(self, order: _OrderKACF = ...) -> matrix[Any, _DType_co]: ... def flatten(self, order: _OrderKACF = ...) -> matrix[Any, _DType_co]: ... @property def T(self) -> matrix[Any, _DType_co]: ... @property def I(self) -> matrix[Any, Any]: ... @property def A(self) -> ndarray[_ShapeType, _DType_co]: ... @property def A1(self) -> ndarray[Any, _DType_co]: ... @property def H(self) -> matrix[Any, _DType_co]: ... def getT(self) -> matrix[Any, _DType_co]: ... def getI(self) -> matrix[Any, Any]: ... def getA(self) -> ndarray[_ShapeType, _DType_co]: ... def getA1(self) -> ndarray[Any, _DType_co]: ... def getH(self) -> matrix[Any, _DType_co]: ... _CharType = TypeVar("_CharType", str_, bytes_) _CharDType = TypeVar("_CharDType", dtype[str_], dtype[bytes_]) _CharArray = chararray[Any, dtype[_CharType]] class chararray(ndarray[_ShapeType, _CharDType]): @overload def __new__( subtype, shape: _ShapeLike, itemsize: SupportsIndex \| SupportsInt = ..., unicode: L[False] = ..., buffer: _SupportsBuffer = ..., offset: SupportsIndex = ..., strides: _ShapeLike = ..., order: _OrderKACF = ..., ) -> chararray[Any, dtype[bytes_]]: ... @overload def __new__( subtype, shape: _ShapeLike, itemsize: SupportsIndex \| SupportsInt = ..., unicode: L[True] = ..., buffer: _SupportsBuffer = ..., offset: SupportsIndex = ..., strides: _ShapeLike = ..., order: _OrderKACF = ..., ) -> chararray[Any, dtype[str_]]: ... def __array_finalize__(self, obj: object) -> None: ... def __mul__(self, other: _ArrayLikeInt_co) -> chararray[Any, _CharDType]: ... def __rmul__(self, other: _ArrayLikeInt_co) -> chararray[Any, _CharDType]: ... def __mod__(self, i: Any) -> chararray[Any, _CharDType]: ... @overload def __eq__( self: _CharArray[str_], other: _ArrayLikeStr_co, ) -> NDArray[bool_]: ... @overload def __eq__( self: _CharArray[bytes_], other: _ArrayLikeBytes_co, ) -> NDArray[bool_]: ... @overload def __ne__( self: _CharArray[str_], other: _ArrayLikeStr_co, ) -> NDArray[bool_]: ... @overload def __ne__( self: _CharArray[bytes_], other: _ArrayLikeBytes_co, ) -> NDArray[bool_]: ... @overload def __ge__( self: _CharArray[str_], other: _ArrayLikeStr_co, ) -> NDArray[bool_]: ... @overload def __ge__( self: _CharArray[bytes_], other: _ArrayLikeBytes_co, ) -> NDArray[bool_]: ... @overload def __le__( self: _CharArray[str_], other: _ArrayLikeStr_co, ) -> NDArray[bool_]: ... @overload def __le__( self: _CharArray[bytes_], other: _ArrayLikeBytes_co, ) -> NDArray[bool_]: ... @overload def __gt__( self: _CharArray[str_], other: _ArrayLikeStr_co, ) -> NDArray[bool_]: ... @overload def __gt__( self: _CharArray[bytes_], other: _ArrayLikeBytes_co, ) -> NDArray[bool_]: ... @overload def __lt__( self: _CharArray[str_], other: _ArrayLikeStr_co, ) -> NDArray[bool_]: ... @overload def __lt__( self: _CharArray[bytes_], other: _ArrayLikeBytes_co, ) -> NDArray[bool_]: ... @overload def __add__( self: _CharArray[str_], other: _ArrayLikeStr_co, ) -> _CharArray[str_]: ... @overload def __add__( self: _CharArray[bytes_], other: _ArrayLikeBytes_co, ) -> _CharArray[bytes_]: ... @overload def __radd__( self: _CharArray[str_], other: _ArrayLikeStr_co, ) -> _CharArray[str_]: ... @overload def __radd__( self: _CharArray[bytes_], other: _ArrayLikeBytes_co, ) -> _CharArray[bytes_]: ... @overload def center( self: _CharArray[str_], width: _ArrayLikeInt_co, fillchar: _ArrayLikeStr_co = ..., ) -> _CharArray[str_]: ... @overload def center( self: _CharArray[bytes_], width: _ArrayLikeInt_co, fillchar: _ArrayLikeBytes_co = ..., ) -> _CharArray[bytes_]: ... @overload def count( self: _CharArray[str_], sub: _ArrayLikeStr_co, start: _ArrayLikeInt_co = ..., end: None \| _ArrayLikeInt_co = ..., ) -> NDArray[int_]: ... @overload def count( self: _CharArray[bytes_], sub: _ArrayLikeBytes_co, start: _ArrayLikeInt_co = ..., end: None \| _ArrayLikeInt_co = ..., ) -> NDArray[int_]: ... def decode( self: _CharArray[bytes_], encoding: None \| str = ..., errors: None \| str = ..., ) -> _CharArray[str_]: ... def encode( self: _CharArray[str_], encoding: None \| str = ..., errors: None \| str = ..., ) -> _CharArray[bytes_]: ... @overload def endswith( self: _CharArray[str_], suffix: _ArrayLikeStr_co, start: _ArrayLikeInt_co = ..., end: None \| _ArrayLikeInt_co = ..., ) -> NDArray[bool_]: ... @overload def endswith( self: _CharArray[bytes_], suffix: _ArrayLikeBytes_co, start: _ArrayLikeInt_co = ..., end: None \| _ArrayLikeInt_co = ..., ) -> NDArray[bool_]: ... def expandtabs( self, tabsize: _ArrayLikeInt_co = ..., ) -> chararray[Any, _CharDType]: ... @overload def find( self: _CharArray[str_], sub: _ArrayLikeStr_co, start: _ArrayLikeInt_co = ..., end: None \| _ArrayLikeInt_co = ..., ) -> NDArray[int_]: ... @overload def find( self: _CharArray[bytes_], sub: _ArrayLikeBytes_co, start: _ArrayLikeInt_co = ..., end: None \| _ArrayLikeInt_co = ..., ) -> NDArray[int_]: ... @overload def index( self: _CharArray[str_], sub: _ArrayLikeStr_co, start: _ArrayLikeInt_co = ..., end: None \| _ArrayLikeInt_co = ..., ) -> NDArray[int_]: ... @overload def index( self: _CharArray[bytes_], sub: _ArrayLikeBytes_co, start: _ArrayLikeInt_co = ..., end: None \| _ArrayLikeInt_co = ..., ) -> NDArray[int_]: ... @overload def join( self: _CharArray[str_], seq: _ArrayLikeStr_co, ) -> _CharArray[str_]: ... @overload def join( self: _CharArray[bytes_], seq: _ArrayLikeBytes_co, ) -> _CharArray[bytes_]: ... @overload def ljust( self: _CharArray[str_], width: _ArrayLikeInt_co, fillchar: _ArrayLikeStr_co = ..., ) -> _CharArray[str_]: ... @overload def ljust( self: _CharArray[bytes_], width: _ArrayLikeInt_co, fillchar: _ArrayLikeBytes_co = ..., ) -> _CharArray[bytes_]: ... @overload def lstrip( self: _CharArray[str_], chars: None \| _ArrayLikeStr_co = ..., ) -> _CharArray[str_]: ... @overload def lstrip( self: _CharArray[bytes_], chars: None \| _ArrayLikeBytes_co = ..., ) -> _CharArray[bytes_]: ... @overload def partition( self: _CharArray[str_], sep: _ArrayLikeStr_co, ) -> _CharArray[str_]: ... @overload def partition( self: _CharArray[bytes_], sep: _ArrayLikeBytes_co, ) -> _CharArray[bytes_]: ... @overload def replace( self: _CharArray[str_], old: _ArrayLikeStr_co, new: _ArrayLikeStr_co, count: None \| _ArrayLikeInt_co = ..., ) -> _CharArray[str_]: ... @overload def replace( self: _CharArray[bytes_], old: _ArrayLikeBytes_co, new: _ArrayLikeBytes_co, count: None \| _ArrayLikeInt_co = ..., ) -> _CharArray[bytes_]: ... @overload def rfind( self: _CharArray[str_], sub: _ArrayLikeStr_co, start: _ArrayLikeInt_co = ..., end: None \| _ArrayLikeInt_co = ..., ) -> NDArray[int_]: ... @overload def rfind( self: _CharArray[bytes_], sub: _ArrayLikeBytes_co, start: _ArrayLikeInt_co = ..., end: None \| _ArrayLikeInt_co = ..., ) -> NDArray[int_]: ... @overload def rindex( self: _CharArray[str_], sub: _ArrayLikeStr_co, start: _ArrayLikeInt_co = ..., end: None \| _ArrayLikeInt_co = ..., ) -> NDArray[int_]: ... @overload def rindex( self: _CharArray[bytes_], sub: _ArrayLikeBytes_co, start: _ArrayLikeInt_co = ..., end: None \| _ArrayLikeInt_co = ..., ) -> NDArray[int_]: ... @overload def rjust( self: _CharArray[str_], width: _ArrayLikeInt_co, fillchar: _ArrayLikeStr_co = ..., ) -> _CharArray[str_]: ... @overload def rjust( self: _CharArray[bytes_], width: _ArrayLikeInt_co, fillchar: _ArrayLikeBytes_co = ..., ) -> _CharArray[bytes_]: ... @overload def rpartition( self: _CharArray[str_], sep: _ArrayLikeStr_co, ) -> _CharArray[str_]: ... @overload def rpartition( self: _CharArray[bytes_], sep: _ArrayLikeBytes_co, ) -> _CharArray[bytes_]: ... @overload def rsplit( self: _CharArray[str_], sep: None \| _ArrayLikeStr_co = ..., maxsplit: None \| _ArrayLikeInt_co = ..., ) -> NDArray[object_]: ... @overload def rsplit( self: _CharArray[bytes_], sep: None \| _ArrayLikeBytes_co = ..., maxsplit: None \| _ArrayLikeInt_co = ..., ) -> NDArray[object_]: ... @overload def rstrip( self: _CharArray[str_], chars: None \| _ArrayLikeStr_co = ..., ) -> _CharArray[str_]: ... @overload def rstrip( self: _CharArray[bytes_], chars: None \| _ArrayLikeBytes_co = ..., ) -> _CharArray[bytes_]: ... @overload def split( self: _CharArray[str_], sep: None \| _ArrayLikeStr_co = ..., maxsplit: None \| _ArrayLikeInt_co = ..., ) -> NDArray[object_]: ... @overload def split( self: _CharArray[bytes_], sep: None \| _ArrayLikeBytes_co = ..., maxsplit: None \| _ArrayLikeInt_co = ..., ) -> NDArray[object_]: ... def splitlines(self, keepends: None \| _ArrayLikeBool_co = ...) -> NDArray[object_]: ... @overload def startswith( self: _CharArray[str_], prefix: _ArrayLikeStr_co, start: _ArrayLikeInt_co = ..., end: None \| _ArrayLikeInt_co = ..., ) -> NDArray[bool_]: ... @overload def startswith( self: _CharArray[bytes_], prefix: _ArrayLikeBytes_co, start: _ArrayLikeInt_co = ..., end: None \| _ArrayLikeInt_co = ..., ) -> NDArray[bool_]: ... @overload def strip( self: _CharArray[str_], chars: None \| _ArrayLikeStr_co = ..., ) -> _CharArray[str_]: ... @overload def strip( self: _CharArray[bytes_], chars: None \| _ArrayLikeBytes_co = ..., ) -> _CharArray[bytes_]: ... @overload def translate( self: _CharArray[str_], table: _ArrayLikeStr_co, deletechars: None \| _ArrayLikeStr_co = ..., ) -> _CharArray[str_]: ... @overload def translate( self: _CharArray[bytes_], table: _ArrayLikeBytes_co, deletechars: None \| _ArrayLikeBytes_co = ..., ) -> _CharArray[bytes_]: ... def zfill(self, width: _ArrayLikeInt_co) -> chararray[Any, _CharDType]: ... def capitalize(self) -> chararray[_ShapeType, _CharDType]: ... def title(self) -> chararray[_ShapeType, _CharDType]: ... def swapcase(self) -> chararray[_ShapeType, _CharDType]: ... def lower(self) -> chararray[_ShapeType, _CharDType]: ... def upper(self) -> chararray[_ShapeType, _CharDType]: ... def isalnum(self) -> ndarray[_ShapeType, dtype[bool_]]: ... def isalpha(self) -> ndarray[_ShapeType, dtype[bool_]]: ... def isdigit(self) -> ndarray[_ShapeType, dtype[bool_]]: ... def islower(self) -> ndarray[_ShapeType, dtype[bool_]]: ... def isspace(self) -> ndarray[_ShapeType, dtype[bool_]]: ... def istitle(self) -> ndarray[_ShapeType, dtype[bool_]]: ... def isupper(self) -> ndarray[_ShapeType, dtype[bool_]]: ... def isnumeric(self) -> ndarray[_ShapeType, dtype[bool_]]: ... def isdecimal(self) -> ndarray[_ShapeType, dtype[bool_]]: ... # NOTE: Deprecated # class MachAr: ... class _SupportsDLPack(Protocol[_T_contra]): def __dlpack__(self, , stream: None \| _T_contra = ...) -> _PyCapsule: ... def from_dlpack(obj: _SupportsDLPack[None], /) -> NDArray[Any]: ...	150.11 KB	2026-01-20 12:58
📁 __pycache__	-	2026-03-21 15:45
📄 _distributor_init.py """ Distributor init file Distributors: you can add custom code here to support particular distributions of numpy. For example, this is a good place to put any checks for hardware requirements. The numpy standard source distribution will not put code in this file, so you can safely replace this file with your own version. """	331 B	2026-01-20 12:58
📄 _globals.py """ Module defining global singleton classes. This module raises a RuntimeError if an attempt to reload it is made. In that way the identities of the classes defined here are fixed and will remain so even if numpy itself is reloaded. In particular, a function like the following will still work correctly after numpy is reloaded:: def foo(arg=np._NoValue): if arg is np._NoValue: ... That was not the case when the singleton classes were defined in the numpy ``__init__.py`` file. See gh-7844 for a discussion of the reload problem that motivated this module. """ import enum from ._utils import set_module as _set_module __all__ = ['_NoValue', '_CopyMode'] # Disallow reloading this module so as to preserve the identities of the # classes defined here. if '_is_loaded' in globals(): raise RuntimeError('Reloading numpy._globals is not allowed') _is_loaded = True class _NoValueType: """Special keyword value. The instance of this class may be used as the default value assigned to a keyword if no other obvious default (e.g., `None`) is suitable, Common reasons for using this keyword are: - A new keyword is added to a function, and that function forwards its inputs to another function or method which can be defined outside of NumPy. For example, ``np.std(x)`` calls ``x.std``, so when a ``keepdims`` keyword was added that could only be forwarded if the user explicitly specified ``keepdims``; downstream array libraries may not have added the same keyword, so adding ``x.std(..., keepdims=keepdims)`` unconditionally could have broken previously working code. - A keyword is being deprecated, and a deprecation warning must only be emitted when the keyword is used. """ __instance = None def __new__(cls): # ensure that only one instance exists if not cls.__instance: cls.__instance = super().__new__(cls) return cls.__instance def __repr__(self): return "<no value>" _NoValue = _NoValueType() @_set_module("numpy") class _CopyMode(enum.Enum): """ An enumeration for the copy modes supported by numpy.copy() and numpy.array(). The following three modes are supported, - ALWAYS: This means that a deep copy of the input array will always be taken. - IF_NEEDED: This means that a deep copy of the input array will be taken only if necessary. - NEVER: This means that the deep copy will never be taken. If a copy cannot be avoided then a `ValueError` will be raised. Note that the buffer-protocol could in theory do copies. NumPy currently assumes an object exporting the buffer protocol will never do this. """ ALWAYS = True IF_NEEDED = False NEVER = 2 def __bool__(self): # For backwards compatibility if self == _CopyMode.ALWAYS: return True if self == _CopyMode.IF_NEEDED: return False raise ValueError(f"{self} is neither True nor False.")	3.02 KB	2026-01-20 12:58
📁 _pyinstaller	-	2026-03-21 15:45
📄 _pytesttester.py """ Pytest test running. This module implements the ``test()`` function for NumPy modules. The usual boiler plate for doing that is to put the following in the module ``__init__.py`` file:: from numpy._pytesttester import PytestTester test = PytestTester(__name__) del PytestTester Warnings filtering and other runtime settings should be dealt with in the ``pytest.ini`` file in the numpy repo root. The behavior of the test depends on whether or not that file is found as follows: * ``pytest.ini`` is present (develop mode) All warnings except those explicitly filtered out are raised as error. * ``pytest.ini`` is absent (release mode) DeprecationWarnings and PendingDeprecationWarnings are ignored, other warnings are passed through. In practice, tests run from the numpy repo are run in develop mode. That includes the standard ``python runtests.py`` invocation. This module is imported by every numpy subpackage, so lies at the top level to simplify circular import issues. For the same reason, it contains no numpy imports at module scope, instead importing numpy within function calls. """ import sys import os __all__ = ['PytestTester'] def _show_numpy_info(): import numpy as np print("NumPy version %s" % np.__version__) relaxed_strides = np.ones((10, 1), order="C").flags.f_contiguous print("NumPy relaxed strides checking option:", relaxed_strides) info = np.lib.utils._opt_info() print("NumPy CPU features: ", (info if info else 'nothing enabled')) class PytestTester: """ Pytest test runner. A test function is typically added to a package's __init__.py like so:: from numpy._pytesttester import PytestTester test = PytestTester(__name__).test del PytestTester Calling this test function finds and runs all tests associated with the module and all its sub-modules. Attributes ---------- module_name : str Full path to the package to test. Parameters ---------- module_name : module name The name of the module to test. Notes ----- Unlike the previous ``nose``-based implementation, this class is not publicly exposed as it performs some ``numpy``-specific warning suppression. """ def __init__(self, module_name): self.module_name = module_name def __call__(self, label='fast', verbose=1, extra_argv=None, doctests=False, coverage=False, durations=-1, tests=None): """ Run tests for module using pytest. Parameters ---------- label : {'fast', 'full'}, optional Identifies the tests to run. When set to 'fast', tests decorated with `pytest.mark.slow` are skipped, when 'full', the slow marker is ignored. verbose : int, optional Verbosity value for test outputs, in the range 1-3. Default is 1. extra_argv : list, optional List with any extra arguments to pass to pytests. doctests : bool, optional .. note:: Not supported coverage : bool, optional If True, report coverage of NumPy code. Default is False. Requires installation of (pip) pytest-cov. durations : int, optional If < 0, do nothing, If 0, report time of all tests, if > 0, report the time of the slowest `timer` tests. Default is -1. tests : test or list of tests Tests to be executed with pytest '--pyargs' Returns ------- result : bool Return True on success, false otherwise. Notes ----- Each NumPy module exposes `test` in its namespace to run all tests for it. For example, to run all tests for numpy.lib: >>> np.lib.test() #doctest: +SKIP Examples -------- >>> result = np.lib.test() #doctest: +SKIP ... 1023 passed, 2 skipped, 6 deselected, 1 xfailed in 10.39 seconds >>> result True """ import pytest import warnings module = sys.modules[self.module_name] module_path = os.path.abspath(module.__path__[0]) # setup the pytest arguments pytest_args = ["-l"] # offset verbosity. The "-q" cancels a "-v". pytest_args += ["-q"] with warnings.catch_warnings(): warnings.simplefilter("always") # Filter out distutils cpu warnings (could be localized to # distutils tests). ASV has problems with top level import, # so fetch module for suppression here. from numpy.distutils import cpuinfo with warnings.catch_warnings(record=True): # Ignore the warning from importing the array_api submodule. This # warning is done on import, so it would break pytest collection, # but importing it early here prevents the warning from being # issued when it imported again. import numpy.array_api # Filter out annoying import messages. Want these in both develop and # release mode. pytest_args += [ "-W ignore:Not importing directory", "-W ignore:numpy.dtype size changed", "-W ignore:numpy.ufunc size changed", "-W ignore::UserWarning:cpuinfo", ] # When testing matrices, ignore their PendingDeprecationWarnings pytest_args += [ "-W ignore:the matrix subclass is not", "-W ignore:Importing from numpy.matlib is", ] if doctests: pytest_args += ["--doctest-modules"] if extra_argv: pytest_args += list(extra_argv) if verbose > 1: pytest_args += ["-" + "v"*(verbose - 1)] if coverage: pytest_args += ["--cov=" + module_path] if label == "fast": # not importing at the top level to avoid circular import of module from numpy.testing import IS_PYPY if IS_PYPY: pytest_args += ["-m", "not slow and not slow_pypy"] else: pytest_args += ["-m", "not slow"] elif label != "full": pytest_args += ["-m", label] if durations >= 0: pytest_args += ["--durations=%s" % durations] if tests is None: tests = [self.module_name] pytest_args += ["--pyargs"] + list(tests) # run tests. _show_numpy_info() try: code = pytest.main(pytest_args) except SystemExit as exc: code = exc.code return code == 0	6.51 KB	2026-01-20 12:58
📄 _pytesttester.pyi from collections.abc import Iterable from typing import Literal as L __all__: list[str] class PytestTester: module_name: str def __init__(self, module_name: str) -> None: ... def __call__( self, label: L["fast", "full"] = ..., verbose: int = ..., extra_argv: None \| Iterable[str] = ..., doctests: L[False] = ..., coverage: bool = ..., durations: int = ..., tests: None \| Iterable[str] = ..., ) -> bool: ...	489 B	2026-01-20 12:58
📁 _typing	-	2026-03-21 15:45
📁 _utils	-	2026-03-21 15:45
📄 _version.py # This file was generated by 'versioneer.py' (0.26) from # revision-control system data, or from the parent directory name of an # unpacked source archive. Distribution tarballs contain a pre-generated copy # of this file. import json version_json = ''' { "date": "2023-07-08T12:34:21-0600", "dirty": false, "error": null, "full-revisionid": "609c5399d0c2ca284ccc4b84d606727ed5640469", "version": "1.25.1" } ''' # END VERSION_JSON def get_versions(): return json.loads(version_json)	498 B	2026-01-20 12:58
📁 array_api	-	2026-03-21 15:45
📁 compat	-	2026-03-21 15:45
📄 conftest.py """ Pytest configuration and fixtures for the Numpy test suite. """ import os import tempfile import hypothesis import pytest import numpy from numpy.core._multiarray_tests import get_fpu_mode _old_fpu_mode = None _collect_results = {} # Use a known and persistent tmpdir for hypothesis' caches, which # can be automatically cleared by the OS or user. hypothesis.configuration.set_hypothesis_home_dir( os.path.join(tempfile.gettempdir(), ".hypothesis") ) # We register two custom profiles for Numpy - for details see # https://hypothesis.readthedocs.io/en/latest/settings.html # The first is designed for our own CI runs; the latter also # forces determinism and is designed for use via np.test() hypothesis.settings.register_profile( name="numpy-profile", deadline=None, print_blob=True, ) hypothesis.settings.register_profile( name="np.test() profile", deadline=None, print_blob=True, database=None, derandomize=True, suppress_health_check=list(hypothesis.HealthCheck), ) # Note that the default profile is chosen based on the presence # of pytest.ini, but can be overridden by passing the # --hypothesis-profile=NAME argument to pytest. _pytest_ini = os.path.join(os.path.dirname(__file__), "..", "pytest.ini") hypothesis.settings.load_profile( "numpy-profile" if os.path.isfile(_pytest_ini) else "np.test() profile" ) # The experimentalAPI is used in _umath_tests os.environ["NUMPY_EXPERIMENTAL_DTYPE_API"] = "1" def pytest_configure(config): config.addinivalue_line("markers", "valgrind_error: Tests that are known to error under valgrind.") config.addinivalue_line("markers", "leaks_references: Tests that are known to leak references.") config.addinivalue_line("markers", "slow: Tests that are very slow.") config.addinivalue_line("markers", "slow_pypy: Tests that are very slow on pypy.") def pytest_addoption(parser): parser.addoption("--available-memory", action="store", default=None, help=("Set amount of memory available for running the " "test suite. This can result to tests requiring " "especially large amounts of memory to be skipped. " "Equivalent to setting environment variable " "NPY_AVAILABLE_MEM. Default: determined" "automatically.")) def pytest_sessionstart(session): available_mem = session.config.getoption('available_memory') if available_mem is not None: os.environ['NPY_AVAILABLE_MEM'] = available_mem #FIXME when yield tests are gone. @pytest.hookimpl() def pytest_itemcollected(item): """ Check FPU precision mode was not changed during test collection. The clumsy way we do it here is mainly necessary because numpy still uses yield tests, which can execute code at test collection time. """ global _old_fpu_mode mode = get_fpu_mode() if _old_fpu_mode is None: _old_fpu_mode = mode elif mode != _old_fpu_mode: _collect_results[item] = (_old_fpu_mode, mode) _old_fpu_mode = mode @pytest.fixture(scope="function", autouse=True) def check_fpu_mode(request): """ Check FPU precision mode was not changed during the test. """ old_mode = get_fpu_mode() yield new_mode = get_fpu_mode() if old_mode != new_mode: raise AssertionError("FPU precision mode changed from {0:#x} to {1:#x}" " during the test".format(old_mode, new_mode)) collect_result = _collect_results.get(request.node) if collect_result is not None: old_mode, new_mode = collect_result raise AssertionError("FPU precision mode changed from {0:#x} to {1:#x}" " when collecting the test".format(old_mode, new_mode)) @pytest.fixture(autouse=True) def add_np(doctest_namespace): doctest_namespace['np'] = numpy @pytest.fixture(autouse=True) def env_setup(monkeypatch): monkeypatch.setenv('PYTHONHASHSEED', '0') @pytest.fixture(params=[True, False]) def weak_promotion(request): """ Fixture to ensure "legacy" promotion state or change it to use the new weak promotion (plus warning). `old_promotion` should be used as a parameter in the function. """ state = numpy._get_promotion_state() if request.param: numpy._set_promotion_state("weak_and_warn") else: numpy._set_promotion_state("legacy") yield request.param numpy._set_promotion_state(state)	4.51 KB	2026-01-20 12:58
📁 core	-	2026-03-21 15:45
📄 ctypeslib.py """ ============================ ``ctypes`` Utility Functions ============================ See Also -------- load_library : Load a C library. ndpointer : Array restype/argtype with verification. as_ctypes : Create a ctypes array from an ndarray. as_array : Create an ndarray from a ctypes array. References ---------- .. [1] "SciPy Cookbook: ctypes", https://scipy-cookbook.readthedocs.io/items/Ctypes.html Examples -------- Load the C library: >>> _lib = np.ctypeslib.load_library('libmystuff', '.') #doctest: +SKIP Our result type, an ndarray that must be of type double, be 1-dimensional and is C-contiguous in memory: >>> array_1d_double = np.ctypeslib.ndpointer( ... dtype=np.double, ... ndim=1, flags='CONTIGUOUS') #doctest: +SKIP Our C-function typically takes an array and updates its values in-place. For example:: void foo_func(double* x, int length) { int i; for (i = 0; i < length; i++) { x[i] = ii; } } We wrap it using: >>> _lib.foo_func.restype = None #doctest: +SKIP >>> _lib.foo_func.argtypes = [array_1d_double, c_int] #doctest: +SKIP Then, we're ready to call ``foo_func``: >>> out = np.empty(15, dtype=np.double) >>> _lib.foo_func(out, len(out)) #doctest: +SKIP """ __all__ = ['load_library', 'ndpointer', 'c_intp', 'as_ctypes', 'as_array', 'as_ctypes_type'] import os from numpy import ( integer, ndarray, dtype as _dtype, asarray, frombuffer ) from numpy.core.multiarray import _flagdict, flagsobj try: import ctypes except ImportError: ctypes = None if ctypes is None: def _dummy(args, *kwds): """ Dummy object that raises an ImportError if ctypes is not available. Raises ------ ImportError If ctypes is not available. """ raise ImportError("ctypes is not available.") load_library = _dummy as_ctypes = _dummy as_array = _dummy from numpy import intp as c_intp _ndptr_base = object else: import numpy.core._internal as nic c_intp = nic._getintp_ctype() del nic _ndptr_base = ctypes.c_void_p # Adapted from Albert Strasheim def load_library(libname, loader_path): """ It is possible to load a library using >>> lib = ctypes.cdll[<full_path_name>] # doctest: +SKIP But there are cross-platform considerations, such as library file extensions, plus the fact Windows will just load the first library it finds with that name. NumPy supplies the load_library function as a convenience. .. versionchanged:: 1.20.0 Allow libname and loader_path to take any :term:`python:path-like object`. Parameters ---------- libname : path-like Name of the library, which can have 'lib' as a prefix, but without an extension. loader_path : path-like Where the library can be found. Returns ------- ctypes.cdll[libpath] : library object A ctypes library object Raises ------ OSError If there is no library with the expected extension, or the library is defective and cannot be loaded. """ # Convert path-like objects into strings libname = os.fsdecode(libname) loader_path = os.fsdecode(loader_path) ext = os.path.splitext(libname)[1] if not ext: import sys import sysconfig # Try to load library with platform-specific name, otherwise # default to libname.[so\|dll\|dylib]. Sometimes, these files are # built erroneously on non-linux platforms. base_ext = ".so" if sys.platform.startswith("darwin"): base_ext = ".dylib" elif sys.platform.startswith("win"): base_ext = ".dll" libname_ext = [libname + base_ext] so_ext = sysconfig.get_config_var("EXT_SUFFIX") if not so_ext == base_ext: libname_ext.insert(0, libname + so_ext) else: libname_ext = [libname] loader_path = os.path.abspath(loader_path) if not os.path.isdir(loader_path): libdir = os.path.dirname(loader_path) else: libdir = loader_path for ln in libname_ext: libpath = os.path.join(libdir, ln) if os.path.exists(libpath): try: return ctypes.cdll[libpath] except OSError: ## defective lib file raise ## if no successful return in the libname_ext loop: raise OSError("no file with expected extension") def _num_fromflags(flaglist): num = 0 for val in flaglist: num += _flagdict[val] return num _flagnames = ['C_CONTIGUOUS', 'F_CONTIGUOUS', 'ALIGNED', 'WRITEABLE', 'OWNDATA', 'WRITEBACKIFCOPY'] def _flags_fromnum(num): res = [] for key in _flagnames: value = _flagdict[key] if (num & value): res.append(key) return res class _ndptr(_ndptr_base): @classmethod def from_param(cls, obj): if not isinstance(obj, ndarray): raise TypeError("argument must be an ndarray") if cls._dtype_ is not None \ and obj.dtype != cls._dtype_: raise TypeError("array must have data type %s" % cls._dtype_) if cls._ndim_ is not None \ and obj.ndim != cls._ndim_: raise TypeError("array must have %d dimension(s)" % cls._ndim_) if cls._shape_ is not None \ and obj.shape != cls._shape_: raise TypeError("array must have shape %s" % str(cls._shape_)) if cls._flags_ is not None \ and ((obj.flags.num & cls._flags_) != cls._flags_): raise TypeError("array must have flags %s" % _flags_fromnum(cls._flags_)) return obj.ctypes class _concrete_ndptr(_ndptr): """ Like _ndptr, but with `_shape_` and `_dtype_` specified. Notably, this means the pointer has enough information to reconstruct the array, which is not generally true. """ def _check_retval_(self): """ This method is called when this class is used as the .restype attribute for a shared-library function, to automatically wrap the pointer into an array. """ return self.contents @property def contents(self): """ Get an ndarray viewing the data pointed to by this pointer. This mirrors the `contents` attribute of a normal ctypes pointer """ full_dtype = _dtype((self._dtype_, self._shape_)) full_ctype = ctypes.c_char full_dtype.itemsize buffer = ctypes.cast(self, ctypes.POINTER(full_ctype)).contents return frombuffer(buffer, dtype=full_dtype).squeeze(axis=0) # Factory for an array-checking class with from_param defined for # use with ctypes argtypes mechanism _pointer_type_cache = {} def ndpointer(dtype=None, ndim=None, shape=None, flags=None): """ Array-checking restype/argtypes. An ndpointer instance is used to describe an ndarray in restypes and argtypes specifications. This approach is more flexible than using, for example, ``POINTER(c_double)``, since several restrictions can be specified, which are verified upon calling the ctypes function. These include data type, number of dimensions, shape and flags. If a given array does not satisfy the specified restrictions, a ``TypeError`` is raised. Parameters ---------- dtype : data-type, optional Array data-type. ndim : int, optional Number of array dimensions. shape : tuple of ints, optional Array shape. flags : str or tuple of str Array flags; may be one or more of: - C_CONTIGUOUS / C / CONTIGUOUS - F_CONTIGUOUS / F / FORTRAN - OWNDATA / O - WRITEABLE / W - ALIGNED / A - WRITEBACKIFCOPY / X Returns ------- klass : ndpointer type object A type object, which is an ``_ndtpr`` instance containing dtype, ndim, shape and flags information. Raises ------ TypeError If a given array does not satisfy the specified restrictions. Examples -------- >>> clib.somefunc.argtypes = [np.ctypeslib.ndpointer(dtype=np.float64, ... ndim=1, ... flags='C_CONTIGUOUS')] ... #doctest: +SKIP >>> clib.somefunc(np.array([1, 2, 3], dtype=np.float64)) ... #doctest: +SKIP """ # normalize dtype to an Optional[dtype] if dtype is not None: dtype = _dtype(dtype) # normalize flags to an Optional[int] num = None if flags is not None: if isinstance(flags, str): flags = flags.split(',') elif isinstance(flags, (int, integer)): num = flags flags = _flags_fromnum(num) elif isinstance(flags, flagsobj): num = flags.num flags = _flags_fromnum(num) if num is None: try: flags = [x.strip().upper() for x in flags] except Exception as e: raise TypeError("invalid flags specification") from e num = _num_fromflags(flags) # normalize shape to an Optional[tuple] if shape is not None: try: shape = tuple(shape) except TypeError: # single integer -> 1-tuple shape = (shape,) cache_key = (dtype, ndim, shape, num) try: return _pointer_type_cache[cache_key] except KeyError: pass # produce a name for the new type if dtype is None: name = 'any' elif dtype.names is not None: name = str(id(dtype)) else: name = dtype.str if ndim is not None: name += "_%dd" % ndim if shape is not None: name += "_"+"x".join(str(x) for x in shape) if flags is not None: name += "_"+"_".join(flags) if dtype is not None and shape is not None: base = _concrete_ndptr else: base = _ndptr klass = type("ndpointer_%s"%name, (base,), {"_dtype_": dtype, "_shape_" : shape, "_ndim_" : ndim, "_flags_" : num}) _pointer_type_cache[cache_key] = klass return klass if ctypes is not None: def _ctype_ndarray(element_type, shape): """ Create an ndarray of the given element type and shape """ for dim in shape[::-1]: element_type = dim * element_type # prevent the type name include np.ctypeslib element_type.__module__ = None return element_type def _get_scalar_type_map(): """ Return a dictionary mapping native endian scalar dtype to ctypes types """ ct = ctypes simple_types = [ ct.c_byte, ct.c_short, ct.c_int, ct.c_long, ct.c_longlong, ct.c_ubyte, ct.c_ushort, ct.c_uint, ct.c_ulong, ct.c_ulonglong, ct.c_float, ct.c_double, ct.c_bool, ] return {_dtype(ctype): ctype for ctype in simple_types} _scalar_type_map = _get_scalar_type_map() def _ctype_from_dtype_scalar(dtype): # swapping twice ensure that `=` is promoted to <, >, or \| dtype_with_endian = dtype.newbyteorder('S').newbyteorder('S') dtype_native = dtype.newbyteorder('=') try: ctype = _scalar_type_map[dtype_native] except KeyError as e: raise NotImplementedError( "Converting {!r} to a ctypes type".format(dtype) ) from None if dtype_with_endian.byteorder == '>': ctype = ctype.__ctype_be__ elif dtype_with_endian.byteorder == '<': ctype = ctype.__ctype_le__ return ctype def _ctype_from_dtype_subarray(dtype): element_dtype, shape = dtype.subdtype ctype = _ctype_from_dtype(element_dtype) return _ctype_ndarray(ctype, shape) def _ctype_from_dtype_structured(dtype): # extract offsets of each field field_data = [] for name in dtype.names: field_dtype, offset = dtype.fields[name][:2] field_data.append((offset, name, _ctype_from_dtype(field_dtype))) # ctypes doesn't care about field order field_data = sorted(field_data, key=lambda f: f[0]) if len(field_data) > 1 and all(offset == 0 for offset, name, ctype in field_data): # union, if multiple fields all at address 0 size = 0 _fields_ = [] for offset, name, ctype in field_data: _fields_.append((name, ctype)) size = max(size, ctypes.sizeof(ctype)) # pad to the right size if dtype.itemsize != size: _fields_.append(('', ctypes.c_char * dtype.itemsize)) # we inserted manual padding, so always `_pack_` return type('union', (ctypes.Union,), dict( _fields_=_fields_, _pack_=1, __module__=None, )) else: last_offset = 0 _fields_ = [] for offset, name, ctype in field_data: padding = offset - last_offset if padding < 0: raise NotImplementedError("Overlapping fields") if padding > 0: _fields_.append(('', ctypes.c_char * padding)) _fields_.append((name, ctype)) last_offset = offset + ctypes.sizeof(ctype) padding = dtype.itemsize - last_offset if padding > 0: _fields_.append(('', ctypes.c_char * padding)) # we inserted manual padding, so always `_pack_` return type('struct', (ctypes.Structure,), dict( _fields_=_fields_, _pack_=1, __module__=None, )) def _ctype_from_dtype(dtype): if dtype.fields is not None: return _ctype_from_dtype_structured(dtype) elif dtype.subdtype is not None: return _ctype_from_dtype_subarray(dtype) else: return _ctype_from_dtype_scalar(dtype) def as_ctypes_type(dtype): r""" Convert a dtype into a ctypes type. Parameters ---------- dtype : dtype The dtype to convert Returns ------- ctype A ctype scalar, union, array, or struct Raises ------ NotImplementedError If the conversion is not possible Notes ----- This function does not losslessly round-trip in either direction. ``np.dtype(as_ctypes_type(dt))`` will: - insert padding fields - reorder fields to be sorted by offset - discard field titles ``as_ctypes_type(np.dtype(ctype))`` will: - discard the class names of `ctypes.Structure`\ s and `ctypes.Union`\ s - convert single-element `ctypes.Union`\ s into single-element `ctypes.Structure`\ s - insert padding fields """ return _ctype_from_dtype(_dtype(dtype)) def as_array(obj, shape=None): """ Create a numpy array from a ctypes array or POINTER. The numpy array shares the memory with the ctypes object. The shape parameter must be given if converting from a ctypes POINTER. The shape parameter is ignored if converting from a ctypes array """ if isinstance(obj, ctypes._Pointer): # convert pointers to an array of the desired shape if shape is None: raise TypeError( 'as_array() requires a shape argument when called on a ' 'pointer') p_arr_type = ctypes.POINTER(_ctype_ndarray(obj._type_, shape)) obj = ctypes.cast(obj, p_arr_type).contents return asarray(obj) def as_ctypes(obj): """Create and return a ctypes object from a numpy array. Actually anything that exposes the __array_interface__ is accepted.""" ai = obj.__array_interface__ if ai["strides"]: raise TypeError("strided arrays not supported") if ai["version"] != 3: raise TypeError("only __array_interface__ version 3 supported") addr, readonly = ai["data"] if readonly: raise TypeError("readonly arrays unsupported") # can't use `_dtype((ai["typestr"], ai["shape"]))` here, as it overflows # dtype.itemsize (gh-14214) ctype_scalar = as_ctypes_type(ai["typestr"]) result_type = _ctype_ndarray(ctype_scalar, ai["shape"]) result = result_type.from_address(addr) result.__keep = obj return result	16.84 KB	2026-01-20 12:58
📄 ctypeslib.pyi # NOTE: Numpy's mypy plugin is used for importing the correct # platform-specific `ctypes._SimpleCData[int]` sub-type from ctypes import c_int64 as _c_intp import os import sys import ctypes from collections.abc import Iterable, Sequence from typing import ( Literal as L, Any, Union, TypeVar, Generic, overload, ClassVar, ) from numpy import ( ndarray, dtype, generic, bool_, byte, short, intc, int_, longlong, ubyte, ushort, uintc, uint, ulonglong, single, double, longdouble, void, ) from numpy.core._internal import _ctypes from numpy.core.multiarray import flagsobj from numpy._typing import ( # Arrays NDArray, _ArrayLike, # Shapes _ShapeLike, # DTypes DTypeLike, _DTypeLike, _VoidDTypeLike, _BoolCodes, _UByteCodes, _UShortCodes, _UIntCCodes, _UIntCodes, _ULongLongCodes, _ByteCodes, _ShortCodes, _IntCCodes, _IntCodes, _LongLongCodes, _SingleCodes, _DoubleCodes, _LongDoubleCodes, ) # TODO: Add a proper `_Shape` bound once we've got variadic typevars _DType = TypeVar("_DType", bound=dtype[Any]) _DTypeOptional = TypeVar("_DTypeOptional", bound=None \| dtype[Any]) _SCT = TypeVar("_SCT", bound=generic) _FlagsKind = L[ 'C_CONTIGUOUS', 'CONTIGUOUS', 'C', 'F_CONTIGUOUS', 'FORTRAN', 'F', 'ALIGNED', 'A', 'WRITEABLE', 'W', 'OWNDATA', 'O', 'WRITEBACKIFCOPY', 'X', ] # TODO: Add a shape typevar once we have variadic typevars (PEP 646) class _ndptr(ctypes.c_void_p, Generic[_DTypeOptional]): # In practice these 4 classvars are defined in the dynamic class # returned by `ndpointer` _dtype_: ClassVar[_DTypeOptional] _shape_: ClassVar[None] _ndim_: ClassVar[None \| int] _flags_: ClassVar[None \| list[_FlagsKind]] @overload @classmethod def from_param(cls: type[_ndptr[None]], obj: ndarray[Any, Any]) -> _ctypes[Any]: ... @overload @classmethod def from_param(cls: type[_ndptr[_DType]], obj: ndarray[Any, _DType]) -> _ctypes[Any]: ... class _concrete_ndptr(_ndptr[_DType]): _dtype_: ClassVar[_DType] _shape_: ClassVar[tuple[int, ...]] @property def contents(self) -> ndarray[Any, _DType]: ... def load_library( libname: str \| bytes \| os.PathLike[str] \| os.PathLike[bytes], loader_path: str \| bytes \| os.PathLike[str] \| os.PathLike[bytes], ) -> ctypes.CDLL: ... __all__: list[str] c_intp = _c_intp @overload def ndpointer( dtype: None = ..., ndim: int = ..., shape: None \| _ShapeLike = ..., flags: None \| _FlagsKind \| Iterable[_FlagsKind] \| int \| flagsobj = ..., ) -> type[_ndptr[None]]: ... @overload def ndpointer( dtype: _DTypeLike[_SCT], ndim: int = ..., , shape: _ShapeLike, flags: None \| _FlagsKind \| Iterable[_FlagsKind] \| int \| flagsobj = ..., ) -> type[_concrete_ndptr[dtype[_SCT]]]: ... @overload def ndpointer( dtype: DTypeLike, ndim: int = ..., , shape: _ShapeLike, flags: None \| _FlagsKind \| Iterable[_FlagsKind] \| int \| flagsobj = ..., ) -> type[_concrete_ndptr[dtype[Any]]]: ... @overload def ndpointer( dtype: _DTypeLike[_SCT], ndim: int = ..., shape: None = ..., flags: None \| _FlagsKind \| Iterable[_FlagsKind] \| int \| flagsobj = ..., ) -> type[_ndptr[dtype[_SCT]]]: ... @overload def ndpointer( dtype: DTypeLike, ndim: int = ..., shape: None = ..., flags: None \| _FlagsKind \| Iterable[_FlagsKind] \| int \| flagsobj = ..., ) -> type[_ndptr[dtype[Any]]]: ... @overload def as_ctypes_type(dtype: _BoolCodes \| _DTypeLike[bool_] \| type[ctypes.c_bool]) -> type[ctypes.c_bool]: ... @overload def as_ctypes_type(dtype: _ByteCodes \| _DTypeLike[byte] \| type[ctypes.c_byte]) -> type[ctypes.c_byte]: ... @overload def as_ctypes_type(dtype: _ShortCodes \| _DTypeLike[short] \| type[ctypes.c_short]) -> type[ctypes.c_short]: ... @overload def as_ctypes_type(dtype: _IntCCodes \| _DTypeLike[intc] \| type[ctypes.c_int]) -> type[ctypes.c_int]: ... @overload def as_ctypes_type(dtype: _IntCodes \| _DTypeLike[int_] \| type[int \| ctypes.c_long]) -> type[ctypes.c_long]: ... @overload def as_ctypes_type(dtype: _LongLongCodes \| _DTypeLike[longlong] \| type[ctypes.c_longlong]) -> type[ctypes.c_longlong]: ... @overload def as_ctypes_type(dtype: _UByteCodes \| _DTypeLike[ubyte] \| type[ctypes.c_ubyte]) -> type[ctypes.c_ubyte]: ... @overload def as_ctypes_type(dtype: _UShortCodes \| _DTypeLike[ushort] \| type[ctypes.c_ushort]) -> type[ctypes.c_ushort]: ... @overload def as_ctypes_type(dtype: _UIntCCodes \| _DTypeLike[uintc] \| type[ctypes.c_uint]) -> type[ctypes.c_uint]: ... @overload def as_ctypes_type(dtype: _UIntCodes \| _DTypeLike[uint] \| type[ctypes.c_ulong]) -> type[ctypes.c_ulong]: ... @overload def as_ctypes_type(dtype: _ULongLongCodes \| _DTypeLike[ulonglong] \| type[ctypes.c_ulonglong]) -> type[ctypes.c_ulonglong]: ... @overload def as_ctypes_type(dtype: _SingleCodes \| _DTypeLike[single] \| type[ctypes.c_float]) -> type[ctypes.c_float]: ... @overload def as_ctypes_type(dtype: _DoubleCodes \| _DTypeLike[double] \| type[float \| ctypes.c_double]) -> type[ctypes.c_double]: ... @overload def as_ctypes_type(dtype: _LongDoubleCodes \| _DTypeLike[longdouble] \| type[ctypes.c_longdouble]) -> type[ctypes.c_longdouble]: ... @overload def as_ctypes_type(dtype: _VoidDTypeLike) -> type[Any]: ... # `ctypes.Union` or `ctypes.Structure` @overload def as_ctypes_type(dtype: str) -> type[Any]: ... @overload def as_array(obj: ctypes._PointerLike, shape: Sequence[int]) -> NDArray[Any]: ... @overload def as_array(obj: _ArrayLike[_SCT], shape: None \| _ShapeLike = ...) -> NDArray[_SCT]: ... @overload def as_array(obj: object, shape: None \| _ShapeLike = ...) -> NDArray[Any]: ... @overload def as_ctypes(obj: bool_) -> ctypes.c_bool: ... @overload def as_ctypes(obj: byte) -> ctypes.c_byte: ... @overload def as_ctypes(obj: short) -> ctypes.c_short: ... @overload def as_ctypes(obj: intc) -> ctypes.c_int: ... @overload def as_ctypes(obj: int_) -> ctypes.c_long: ... @overload def as_ctypes(obj: longlong) -> ctypes.c_longlong: ... @overload def as_ctypes(obj: ubyte) -> ctypes.c_ubyte: ... @overload def as_ctypes(obj: ushort) -> ctypes.c_ushort: ... @overload def as_ctypes(obj: uintc) -> ctypes.c_uint: ... @overload def as_ctypes(obj: uint) -> ctypes.c_ulong: ... @overload def as_ctypes(obj: ulonglong) -> ctypes.c_ulonglong: ... @overload def as_ctypes(obj: single) -> ctypes.c_float: ... @overload def as_ctypes(obj: double) -> ctypes.c_double: ... @overload def as_ctypes(obj: longdouble) -> ctypes.c_longdouble: ... @overload def as_ctypes(obj: void) -> Any: ... # `ctypes.Union` or `ctypes.Structure` @overload def as_ctypes(obj: NDArray[bool_]) -> ctypes.Array[ctypes.c_bool]: ... @overload def as_ctypes(obj: NDArray[byte]) -> ctypes.Array[ctypes.c_byte]: ... @overload def as_ctypes(obj: NDArray[short]) -> ctypes.Array[ctypes.c_short]: ... @overload def as_ctypes(obj: NDArray[intc]) -> ctypes.Array[ctypes.c_int]: ... @overload def as_ctypes(obj: NDArray[int_]) -> ctypes.Array[ctypes.c_long]: ... @overload def as_ctypes(obj: NDArray[longlong]) -> ctypes.Array[ctypes.c_longlong]: ... @overload def as_ctypes(obj: NDArray[ubyte]) -> ctypes.Array[ctypes.c_ubyte]: ... @overload def as_ctypes(obj: NDArray[ushort]) -> ctypes.Array[ctypes.c_ushort]: ... @overload def as_ctypes(obj: NDArray[uintc]) -> ctypes.Array[ctypes.c_uint]: ... @overload def as_ctypes(obj: NDArray[uint]) -> ctypes.Array[ctypes.c_ulong]: ... @overload def as_ctypes(obj: NDArray[ulonglong]) -> ctypes.Array[ctypes.c_ulonglong]: ... @overload def as_ctypes(obj: NDArray[single]) -> ctypes.Array[ctypes.c_float]: ... @overload def as_ctypes(obj: NDArray[double]) -> ctypes.Array[ctypes.c_double]: ... @overload def as_ctypes(obj: NDArray[longdouble]) -> ctypes.Array[ctypes.c_longdouble]: ... @overload def as_ctypes(obj: NDArray[void]) -> ctypes.Array[Any]: ... # `ctypes.Union` or `ctypes.Structure`	7.79 KB	2026-01-20 12:58
📁 distutils	-	2026-03-21 15:45
📁 doc	-	2026-03-21 15:45
📄 dtypes.py """ DType classes and utility (:mod:`numpy.dtypes`) =============================================== This module is home to specific dtypes related functionality and their classes. For more general information about dtypes, also see `numpy.dtype` and :ref:`arrays.dtypes`. Similar to the builtin ``types`` module, this submodule defines types (classes) that are not widely used directly. .. versionadded:: NumPy 1.25 The dtypes module is new in NumPy 1.25. Previously DType classes were only accessible indirectly. DType classes ------------- The following are the classes of the corresponding NumPy dtype instances and NumPy scalar types. The classes can be used in ``isinstance`` checks and can also be instantiated or used directly. Direct use of these classes is not typical, since their scalar counterparts (e.g. ``np.float64``) or strings like ``"float64"`` can be used. .. list-table:: :header-rows: 1 * - Group - DType class * - Boolean - ``BoolDType`` * - Bit-sized integers - ``Int8DType``, ``UInt8DType``, ``Int16DType``, ``UInt16DType``, ``Int32DType``, ``UInt32DType``, ``Int64DType``, ``UInt64DType`` * - C-named integers (may be aliases) - ``ByteDType``, ``UByteDType``, ``ShortDType``, ``UShortDType``, ``IntDType``, ``UIntDType``, ``LongDType``, ``ULongDType``, ``LongLongDType``, ``ULongLongDType`` * - Floating point - ``Float16DType``, ``Float32DType``, ``Float64DType``, ``LongDoubleDType`` * - Complex - ``Complex64DType``, ``Complex128DType``, ``CLongDoubleDType`` * - Strings - ``BytesDType``, ``BytesDType`` * - Times - ``DateTime64DType``, ``TimeDelta64DType`` * - Others - ``ObjectDType``, ``VoidDType`` """ __all__ = [] def _add_dtype_helper(DType, alias): # Function to add DTypes a bit more conveniently without channeling them # through `numpy.core._multiarray_umath` namespace or similar. from numpy import dtypes setattr(dtypes, DType.__name__, DType) __all__.append(DType.__name__) if alias: alias = alias.removeprefix("numpy.dtypes.") setattr(dtypes, alias, DType) __all__.append(alias)	2.18 KB	2026-01-20 12:58
📄 dtypes.pyi import numpy as np __all__: list[str] # Boolean: BoolDType = np.dtype[np.bool_] # Sized integers: Int8DType = np.dtype[np.int8] UInt8DType = np.dtype[np.uint8] Int16DType = np.dtype[np.int16] UInt16DType = np.dtype[np.uint16] Int32DType = np.dtype[np.int32] UInt32DType = np.dtype[np.uint32] Int64DType = np.dtype[np.int64] UInt64DType = np.dtype[np.uint64] # Standard C-named version/alias: ByteDType = np.dtype[np.byte] UByteDType = np.dtype[np.ubyte] ShortDType = np.dtype[np.short] UShortDType = np.dtype[np.ushort] IntDType = np.dtype[np.intc] UIntDType = np.dtype[np.uintc] LongDType = np.dtype[np.int_] # Unfortunately, the correct scalar ULongDType = np.dtype[np.uint] # Unfortunately, the correct scalar LongLongDType = np.dtype[np.longlong] ULongLongDType = np.dtype[np.ulonglong] # Floats Float16DType = np.dtype[np.float16] Float32DType = np.dtype[np.float32] Float64DType = np.dtype[np.float64] LongDoubleDType = np.dtype[np.longdouble] # Complex: Complex64DType = np.dtype[np.complex64] Complex128DType = np.dtype[np.complex128] CLongDoubleDType = np.dtype[np.clongdouble] # Others: ObjectDType = np.dtype[np.object_] BytesDType = np.dtype[np.bytes_] StrDType = np.dtype[np.str_] VoidDType = np.dtype[np.void] DateTime64DType = np.dtype[np.datetime64] TimeDelta64DType = np.dtype[np.timedelta64]	1.28 KB	2026-01-20 12:58
📄 exceptions.py """ Exceptions and Warnings (:mod:`numpy.exceptions`) ================================================= General exceptions used by NumPy. Note that some exceptions may be module specific, such as linear algebra errors. .. versionadded:: NumPy 1.25 The exceptions module is new in NumPy 1.25. Older exceptions remain available through the main NumPy namespace for compatibility. .. currentmodule:: numpy.exceptions Warnings -------- .. autosummary:: :toctree: generated/ ComplexWarning Given when converting complex to real. VisibleDeprecationWarning Same as a DeprecationWarning, but more visible. Exceptions ---------- .. autosummary:: :toctree: generated/ AxisError Given when an axis was invalid. DTypePromotionError Given when no common dtype could be found. TooHardError Error specific to `numpy.shares_memory`. """ __all__ = [ "ComplexWarning", "VisibleDeprecationWarning", "ModuleDeprecationWarning", "TooHardError", "AxisError", "DTypePromotionError"] # Disallow reloading this module so as to preserve the identities of the # classes defined here. if '_is_loaded' in globals(): raise RuntimeError('Reloading numpy._globals is not allowed') _is_loaded = True class ComplexWarning(RuntimeWarning): """ The warning raised when casting a complex dtype to a real dtype. As implemented, casting a complex number to a real discards its imaginary part, but this behavior may not be what the user actually wants. """ pass class ModuleDeprecationWarning(DeprecationWarning): """Module deprecation warning. .. warning:: This warning should not be used, since nose testing is not relevant anymore. The nose tester turns ordinary Deprecation warnings into test failures. That makes it hard to deprecate whole modules, because they get imported by default. So this is a special Deprecation warning that the nose tester will let pass without making tests fail. """ class VisibleDeprecationWarning(UserWarning): """Visible deprecation warning. By default, python will not show deprecation warnings, so this class can be used when a very visible warning is helpful, for example because the usage is most likely a user bug. """ # Exception used in shares_memory() class TooHardError(RuntimeError): """max_work was exceeded. This is raised whenever the maximum number of candidate solutions to consider specified by the ``max_work`` parameter is exceeded. Assigning a finite number to max_work may have caused the operation to fail. """ pass class AxisError(ValueError, IndexError): """Axis supplied was invalid. This is raised whenever an ``axis`` parameter is specified that is larger than the number of array dimensions. For compatibility with code written against older numpy versions, which raised a mixture of `ValueError` and `IndexError` for this situation, this exception subclasses both to ensure that ``except ValueError`` and ``except IndexError`` statements continue to catch `AxisError`. .. versionadded:: 1.13 Parameters ---------- axis : int or str The out of bounds axis or a custom exception message. If an axis is provided, then `ndim` should be specified as well. ndim : int, optional The number of array dimensions. msg_prefix : str, optional A prefix for the exception message. Attributes ---------- axis : int, optional The out of bounds axis or ``None`` if a custom exception message was provided. This should be the axis as passed by the user, before any normalization to resolve negative indices. .. versionadded:: 1.22 ndim : int, optional The number of array dimensions or ``None`` if a custom exception message was provided. .. versionadded:: 1.22 Examples -------- >>> array_1d = np.arange(10) >>> np.cumsum(array_1d, axis=1) Traceback (most recent call last): ... numpy.exceptions.AxisError: axis 1 is out of bounds for array of dimension 1 Negative axes are preserved: >>> np.cumsum(array_1d, axis=-2) Traceback (most recent call last): ... numpy.exceptions.AxisError: axis -2 is out of bounds for array of dimension 1 The class constructor generally takes the axis and arrays' dimensionality as arguments: >>> print(np.AxisError(2, 1, msg_prefix='error')) error: axis 2 is out of bounds for array of dimension 1 Alternatively, a custom exception message can be passed: >>> print(np.AxisError('Custom error message')) Custom error message """ __slots__ = ("axis", "ndim", "_msg") def __init__(self, axis, ndim=None, msg_prefix=None): if ndim is msg_prefix is None: # single-argument form: directly set the error message self._msg = axis self.axis = None self.ndim = None else: self._msg = msg_prefix self.axis = axis self.ndim = ndim def __str__(self): axis = self.axis ndim = self.ndim if axis is ndim is None: return self._msg else: msg = f"axis {axis} is out of bounds for array of dimension {ndim}" if self._msg is not None: msg = f"{self._msg}: {msg}" return msg class DTypePromotionError(TypeError): """Multiple DTypes could not be converted to a common one. This exception derives from ``TypeError`` and is raised whenever dtypes cannot be converted to a single common one. This can be because they are of a different category/class or incompatible instances of the same one (see Examples). Notes ----- Many functions will use promotion to find the correct result and implementation. For these functions the error will typically be chained with a more specific error indicating that no implementation was found for the input dtypes. Typically promotion should be considered "invalid" between the dtypes of two arrays when `arr1 == arr2` can safely return all ``False`` because the dtypes are fundamentally different. Examples -------- Datetimes and complex numbers are incompatible classes and cannot be promoted: >>> np.result_type(np.dtype("M8[s]"), np.complex128) DTypePromotionError: The DType <class 'numpy.dtype[datetime64]'> could not be promoted by <class 'numpy.dtype[complex128]'>. This means that no common DType exists for the given inputs. For example they cannot be stored in a single array unless the dtype is `object`. The full list of DTypes is: (<class 'numpy.dtype[datetime64]'>, <class 'numpy.dtype[complex128]'>) For example for structured dtypes, the structure can mismatch and the same ``DTypePromotionError`` is given when two structured dtypes with a mismatch in their number of fields is given: >>> dtype1 = np.dtype([("field1", np.float64), ("field2", np.int64)]) >>> dtype2 = np.dtype([("field1", np.float64)]) >>> np.promote_types(dtype1, dtype2) DTypePromotionError: field names `('field1', 'field2')` and `('field1',)` mismatch. """ pass	7.17 KB	2026-01-20 12:58
📄 exceptions.pyi from typing import overload __all__: list[str] class ComplexWarning(RuntimeWarning): ... class ModuleDeprecationWarning(DeprecationWarning): ... class VisibleDeprecationWarning(UserWarning): ... class TooHardError(RuntimeError): ... class DTypePromotionError(TypeError): ... class AxisError(ValueError, IndexError): axis: None \| int ndim: None \| int @overload def __init__(self, axis: str, ndim: None = ..., msg_prefix: None = ...) -> None: ... @overload def __init__(self, axis: int, ndim: int, msg_prefix: None \| str = ...) -> None: ... def __str__(self) -> str: ...	600 B	2026-01-20 12:58
📁 f2py	-	2026-03-21 15:45
📁 fft	-	2026-03-21 15:45
📁 lib	-	2026-03-21 15:45
📁 linalg	-	2026-03-21 15:45
📁 ma	-	2026-03-21 15:45
📄 matlib.py import warnings # 2018-05-29, PendingDeprecationWarning added to matrix.__new__ # 2020-01-23, numpy 1.19.0 PendingDeprecatonWarning warnings.warn("Importing from numpy.matlib is deprecated since 1.19.0. " "The matrix subclass is not the recommended way to represent " "matrices or deal with linear algebra (see " "https://docs.scipy.org/doc/numpy/user/numpy-for-matlab-users.html). " "Please adjust your code to use regular ndarray. ", PendingDeprecationWarning, stacklevel=2) import numpy as np from numpy.matrixlib.defmatrix import matrix, asmatrix # Matlib.py contains all functions in the numpy namespace with a few # replacements. See doc/source/reference/routines.matlib.rst for details. # Need * as we're copying the numpy namespace. from numpy import * # noqa: F403 __version__ = np.__version__ __all__ = np.__all__[:] # copy numpy namespace __all__ += ['rand', 'randn', 'repmat'] def empty(shape, dtype=None, order='C'): """Return a new matrix of given shape and type, without initializing entries. Parameters ---------- shape : int or tuple of int Shape of the empty matrix. dtype : data-type, optional Desired output data-type. order : {'C', 'F'}, optional Whether to store multi-dimensional data in row-major (C-style) or column-major (Fortran-style) order in memory. See Also -------- empty_like, zeros Notes ----- `empty`, unlike `zeros`, does not set the matrix values to zero, and may therefore be marginally faster. On the other hand, it requires the user to manually set all the values in the array, and should be used with caution. Examples -------- >>> import numpy.matlib >>> np.matlib.empty((2, 2)) # filled with random data matrix([[ 6.76425276e-320, 9.79033856e-307], # random [ 7.39337286e-309, 3.22135945e-309]]) >>> np.matlib.empty((2, 2), dtype=int) matrix([[ 6600475, 0], # random [ 6586976, 22740995]]) """ return ndarray.__new__(matrix, shape, dtype, order=order) def ones(shape, dtype=None, order='C'): """ Matrix of ones. Return a matrix of given shape and type, filled with ones. Parameters ---------- shape : {sequence of ints, int} Shape of the matrix dtype : data-type, optional The desired data-type for the matrix, default is np.float64. order : {'C', 'F'}, optional Whether to store matrix in C- or Fortran-contiguous order, default is 'C'. Returns ------- out : matrix Matrix of ones of given shape, dtype, and order. See Also -------- ones : Array of ones. matlib.zeros : Zero matrix. Notes ----- If `shape` has length one i.e. ``(N,)``, or is a scalar ``N``, `out` becomes a single row matrix of shape ``(1,N)``. Examples -------- >>> np.matlib.ones((2,3)) matrix([[1., 1., 1.], [1., 1., 1.]]) >>> np.matlib.ones(2) matrix([[1., 1.]]) """ a = ndarray.__new__(matrix, shape, dtype, order=order) a.fill(1) return a def zeros(shape, dtype=None, order='C'): """ Return a matrix of given shape and type, filled with zeros. Parameters ---------- shape : int or sequence of ints Shape of the matrix dtype : data-type, optional The desired data-type for the matrix, default is float. order : {'C', 'F'}, optional Whether to store the result in C- or Fortran-contiguous order, default is 'C'. Returns ------- out : matrix Zero matrix of given shape, dtype, and order. See Also -------- numpy.zeros : Equivalent array function. matlib.ones : Return a matrix of ones. Notes ----- If `shape` has length one i.e. ``(N,)``, or is a scalar ``N``, `out` becomes a single row matrix of shape ``(1,N)``. Examples -------- >>> import numpy.matlib >>> np.matlib.zeros((2, 3)) matrix([[0., 0., 0.], [0., 0., 0.]]) >>> np.matlib.zeros(2) matrix([[0., 0.]]) """ a = ndarray.__new__(matrix, shape, dtype, order=order) a.fill(0) return a def identity(n,dtype=None): """ Returns the square identity matrix of given size. Parameters ---------- n : int Size of the returned identity matrix. dtype : data-type, optional Data-type of the output. Defaults to ``float``. Returns ------- out : matrix `n` x `n` matrix with its main diagonal set to one, and all other elements zero. See Also -------- numpy.identity : Equivalent array function. matlib.eye : More general matrix identity function. Examples -------- >>> import numpy.matlib >>> np.matlib.identity(3, dtype=int) matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) """ a = array([1]+n[0], dtype=dtype) b = empty((n, n), dtype=dtype) b.flat = a return b def eye(n,M=None, k=0, dtype=float, order='C'): """ Return a matrix with ones on the diagonal and zeros elsewhere. Parameters ---------- n : int Number of rows in the output. M : int, optional Number of columns in the output, defaults to `n`. k : int, optional Index of the diagonal: 0 refers to the main diagonal, a positive value refers to an upper diagonal, and a negative value to a lower diagonal. dtype : dtype, optional Data-type of the returned matrix. order : {'C', 'F'}, optional Whether the output should be stored in row-major (C-style) or column-major (Fortran-style) order in memory. .. versionadded:: 1.14.0 Returns ------- I : matrix A `n` x `M` matrix where all elements are equal to zero, except for the `k`-th diagonal, whose values are equal to one. See Also -------- numpy.eye : Equivalent array function. identity : Square identity matrix. Examples -------- >>> import numpy.matlib >>> np.matlib.eye(3, k=1, dtype=float) matrix([[0., 1., 0.], [0., 0., 1.], [0., 0., 0.]]) """ return asmatrix(np.eye(n, M=M, k=k, dtype=dtype, order=order)) def rand(args): """ Return a matrix of random values with given shape. Create a matrix of the given shape and propagate it with random samples from a uniform distribution over ``[0, 1)``. Parameters ---------- \\args : Arguments Shape of the output. If given as N integers, each integer specifies the size of one dimension. If given as a tuple, this tuple gives the complete shape. Returns ------- out : ndarray The matrix of random values with shape given by `\\args`. See Also -------- randn, numpy.random.RandomState.rand Examples -------- >>> np.random.seed(123) >>> import numpy.matlib >>> np.matlib.rand(2, 3) matrix([[0.69646919, 0.28613933, 0.22685145], [0.55131477, 0.71946897, 0.42310646]]) >>> np.matlib.rand((2, 3)) matrix([[0.9807642 , 0.68482974, 0.4809319 ], [0.39211752, 0.34317802, 0.72904971]]) If the first argument is a tuple, other arguments are ignored: >>> np.matlib.rand((2, 3), 4) matrix([[0.43857224, 0.0596779 , 0.39804426], [0.73799541, 0.18249173, 0.17545176]]) """ if isinstance(args[0], tuple): args = args[0] return asmatrix(np.random.rand(args)) def randn(args): """ Return a random matrix with data from the "standard normal" distribution. `randn` generates a matrix filled with random floats sampled from a univariate "normal" (Gaussian) distribution of mean 0 and variance 1. Parameters ---------- \\args : Arguments Shape of the output. If given as N integers, each integer specifies the size of one dimension. If given as a tuple, this tuple gives the complete shape. Returns ------- Z : matrix of floats A matrix of floating-point samples drawn from the standard normal distribution. See Also -------- rand, numpy.random.RandomState.randn Notes ----- For random samples from the normal distribution with mean ``mu`` and standard deviation ``sigma``, use:: sigma np.matlib.randn(...) + mu Examples -------- >>> np.random.seed(123) >>> import numpy.matlib >>> np.matlib.randn(1) matrix([[-1.0856306]]) >>> np.matlib.randn(1, 2, 3) matrix([[ 0.99734545, 0.2829785 , -1.50629471], [-0.57860025, 1.65143654, -2.42667924]]) Two-by-four matrix of samples from the normal distribution with mean 3 and standard deviation 2.5: >>> 2.5 * np.matlib.randn((2, 4)) + 3 matrix([[1.92771843, 6.16484065, 0.83314899, 1.30278462], [2.76322758, 6.72847407, 1.40274501, 1.8900451 ]]) """ if isinstance(args[0], tuple): args = args[0] return asmatrix(np.random.randn(args)) def repmat(a, m, n): """ Repeat a 0-D to 2-D array or matrix MxN times. Parameters ---------- a : array_like The array or matrix to be repeated. m, n : int The number of times `a` is repeated along the first and second axes. Returns ------- out : ndarray The result of repeating `a`. Examples -------- >>> import numpy.matlib >>> a0 = np.array(1) >>> np.matlib.repmat(a0, 2, 3) array([[1, 1, 1], [1, 1, 1]]) >>> a1 = np.arange(4) >>> np.matlib.repmat(a1, 2, 2) array([[0, 1, 2, 3, 0, 1, 2, 3], [0, 1, 2, 3, 0, 1, 2, 3]]) >>> a2 = np.asmatrix(np.arange(6).reshape(2, 3)) >>> np.matlib.repmat(a2, 2, 3) matrix([[0, 1, 2, 0, 1, 2, 0, 1, 2], [3, 4, 5, 3, 4, 5, 3, 4, 5], [0, 1, 2, 0, 1, 2, 0, 1, 2], [3, 4, 5, 3, 4, 5, 3, 4, 5]]) """ a = asanyarray(a) ndim = a.ndim if ndim == 0: origrows, origcols = (1, 1) elif ndim == 1: origrows, origcols = (1, a.shape[0]) else: origrows, origcols = a.shape rows = origrows m cols = origcols * n c = a.reshape(1, a.size).repeat(m, 0).reshape(rows, origcols).repeat(n, 0) return c.reshape(rows, cols)	10.22 KB	2026-01-20 12:58
📁 matrixlib	-	2026-03-21 15:45
📁 polynomial	-	2026-03-21 15:45
📄 py.typed	0 B	2026-01-20 12:58
📁 random	-	2026-03-21 15:45
📄 setup.py #!/usr/bin/env python3 def configuration(parent_package='',top_path=None): from numpy.distutils.misc_util import Configuration config = Configuration('numpy', parent_package, top_path) config.add_subpackage('array_api') config.add_subpackage('compat') config.add_subpackage('core') config.add_subpackage('distutils') config.add_subpackage('doc') config.add_subpackage('f2py') config.add_subpackage('fft') config.add_subpackage('lib') config.add_subpackage('linalg') config.add_subpackage('ma') config.add_subpackage('matrixlib') config.add_subpackage('polynomial') config.add_subpackage('random') config.add_subpackage('testing') config.add_subpackage('typing') config.add_subpackage('_typing') config.add_subpackage('_utils') config.add_data_dir('doc') config.add_data_files('py.typed') config.add_data_files('*.pyi') config.add_subpackage('tests') config.add_subpackage('_pyinstaller') config.make_config_py() # installs __config__.py return config if __name__ == '__main__': print('This is the wrong setup.py file to run')	1.11 KB	2026-01-20 12:58
📁 testing	-	2026-03-21 15:45
📁 tests	-	2026-03-21 15:45
📁 typing	-	2026-03-21 15:45
📄 version.py from __future__ import annotations from ._version import get_versions __ALL__ = ['version', '__version__', 'full_version', 'git_revision', 'release'] _built_with_meson = False try: from ._version_meson import get_versions _built_with_meson = True except ImportError: from ._version import get_versions vinfo: dict[str, str] = get_versions() version = vinfo["version"] __version__ = vinfo.get("closest-tag", vinfo["version"]) git_revision = vinfo['full-revisionid'] release = 'dev0' not in version and '+' not in version full_version = version short_version = version.split("+")[0] del get_versions, vinfo	623 B	2026-01-20 12:58

Edit File:

Terminal